o2ims/adapter/ocloud_repository.py

   1 # Copyright (C) 2021 Wind River Systems, Inc.
   2 #
   3 #  Licensed under the Apache License, Version 2.0 (the "License");
   4 #  you may not use this file except in compliance with the License.
   5 #  You may obtain a copy of the License at
   6 #
   7 #      http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 #  Unless required by applicable law or agreed to in writing, software
  10 #  distributed under the License is distributed on an "AS IS" BASIS,
  11 #  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 #  See the License for the specific language governing permissions and
  13 #  limitations under the License.
  14
  15 from typing import List, Tuple
  16
  17 from o2ims.domain import ocloud, subscription_obj
  18 from o2ims.domain.ocloud_repo import OcloudRepository, ResourceTypeRepository,\
  19     ResourcePoolRepository, ResourceRepository, DeploymentManagerRepository
  20 from o2ims.domain.subscription_repo import SubscriptionRepository
  21 from o2common.helper import o2logging
  22 logger = o2logging.get_logger(__name__)
  23
  24
  25 class OcloudSqlAlchemyRepository(OcloudRepository):
  26     def __init__(self, session):
  27         super().__init__()
  28         self.session = session
  29
  30     def _add(self, ocloud: ocloud.Ocloud):
  31         self.session.add(ocloud)
  32         # self.session.add_all(ocloud.deploymentManagers)
  33
  34     def _get(self, ocloud_id) -> ocloud.Ocloud:
  35         return self.session.query(ocloud.Ocloud).filter_by(
  36             oCloudId=ocloud_id).first()
  37
  38     def _list(self, *args) -> List[ocloud.Ocloud]:
  39         return self.session.query(ocloud.Ocloud).filter(*args).order_by(
  40             'oCloudId')
  41
  42     def _update(self, ocloud: ocloud.Ocloud):
  43         self.session.add(ocloud)
  44
  45
  46 class ResouceTypeSqlAlchemyRepository(ResourceTypeRepository):
  47     def __init__(self, session):
  48         super().__init__()
  49         self.session = session
  50
  51     def _add(self, resourceType: ocloud.ResourceType):
  52         self.session.add(resourceType)
  53
  54     def _get(self, resource_type_id) -> ocloud.ResourceType:
  55         return self.session.query(ocloud.ResourceType).filter_by(
  56             resourceTypeId=resource_type_id).first()
  57
  58     def _get_by_name(self, resource_type_name) -> ocloud.ResourceType:
  59         return self.session.query(ocloud.ResourceType).filter_by(
  60             name=resource_type_name).first()
  61
  62     def _list(self, *args, **kwargs) -> Tuple[int, List[ocloud.ResourceType]]:
  63         size = kwargs.pop('limit') if 'limit' in kwargs else None
  64         offset = kwargs.pop('start') if 'start' in kwargs else 0
  65
  66         result = self.session.query(ocloud.ResourceType).filter(
  67             *args).order_by('resourceTypeId')
  68         count = result.count()
  69         if size is not None and size != -1:
  70             return (count, result.limit(size).offset(offset))
  71         return (count, result)
  72
  73     def _update(self, resourceType: ocloud.ResourceType):
  74         self.session.add(resourceType)
  75
  76
  77 class ResourcePoolSqlAlchemyRepository(ResourcePoolRepository):
  78     def __init__(self, session):
  79         super().__init__()
  80         self.session = session
  81
  82     def _add(self, resourcePool: ocloud.ResourcePool):
  83         self.session.add(resourcePool)
  84
  85     def _get(self, resource_pool_id) -> ocloud.ResourcePool:
  86         return self.session.query(ocloud.ResourcePool).filter_by(
  87             resourcePoolId=resource_pool_id).first()
  88
  89     def _list(self, *args, **kwargs) -> Tuple[int, List[ocloud.ResourcePool]]:
  90         size = kwargs.pop('limit') if 'limit' in kwargs else None
  91         offset = kwargs.pop('start') if 'start' in kwargs else 0
  92
  93         result = self.session.query(ocloud.ResourcePool).filter(
  94             *args).order_by('resourcePoolId')
  95         count = result.count()
  96         if size is not None and size != -1:
  97             return (count, result.limit(size).offset(offset))
  98         return (count, result)
  99
 100     def _update(self, resourcePool: ocloud.ResourcePool):
 101         self.session.add(resourcePool)
 102
 103
 104 class ResourceSqlAlchemyRepository(ResourceRepository):
 105     def __init__(self, session):
 106         super().__init__()
 107         self.session = session
 108
 109     def _add(self, resource: ocloud.Resource):
 110         self.session.add(resource)
 111
 112     def _get(self, resource_id) -> ocloud.Resource:
 113         # return self.session.query(ocloud.Resource).filter_by(
 114         #     resourceId=resource_id).first()
 115         # topq = uow.session.query(orm.resource).filter(
 116         #     orm.resource.c.resourceId == resourceId).\
 117         #     cte('cte', recursive=True)
 118         # bootomq = uow.session.query(orm.resource).join(
 119         #     topq, orm.resource.c.parentId == topq.c.resourceId)
 120         # res = uow.session.query(topq.union(bootomq))
 121         def recursive(id):
 122             res = self.session.query(ocloud.Resource).filter_by(
 123                 resourceId=id).first()
 124             if res is not None:
 125                 query = self.session.query(ocloud.Resource).filter_by(
 126                     parentId=res.resourceId)
 127                 children = []
 128                 for r in query:
 129                     child = recursive(r.resourceId)
 130                     children.append(child)
 131                 res.set_children(children)
 132             return res
 133         return recursive(resource_id)
 134
 135     def _list(self, resourcepool_id, *args, **kwargs) -> \
 136             Tuple[int, List[ocloud.Resource]]:
 137         if 'sort' in kwargs:
 138             kwargs.pop('sort')
 139         size = kwargs.pop('limit') if 'limit' in kwargs else None
 140         offset = kwargs.pop('start') if 'start' in kwargs else 0
 141
 142         args1 = args + (ocloud.Resource.resourcePoolId == resourcepool_id,)
 143         result = self.session.query(ocloud.Resource).filter(
 144             *args1).order_by('resourceId')
 145         count = result.count()
 146         if size is not None and size != -1:
 147             return (count, result.limit(size).offset(offset))
 148         return (count, result)
 149
 150     def _update(self, resource: ocloud.Resource):
 151         self.session.add(resource)
 152
 153
 154 class DeploymentManagerSqlAlchemyRepository(DeploymentManagerRepository):
 155     def __init__(self, session):
 156         super().__init__()
 157         self.session = session
 158
 159     def _add(self, deployment_manager: ocloud.DeploymentManager):
 160         self.session.add(deployment_manager)
 161
 162     def _get(self, deployment_manager_id) -> ocloud.DeploymentManager:
 163         return self.session.query(ocloud.DeploymentManager).filter_by(
 164             deploymentManagerId=deployment_manager_id).first()
 165
 166     def _list(self, *args, **kwargs) -> Tuple[int,
 167                                               List[ocloud.DeploymentManager]]:
 168         size = kwargs.pop('limit') if 'limit' in kwargs else None
 169         offset = kwargs.pop('start') if 'start' in kwargs else 0
 170
 171         result = self.session.query(ocloud.DeploymentManager).filter(
 172             *args).order_by('deploymentManagerId')
 173         count = result.count()
 174         if size is not None and size != -1:
 175             return (count, result.limit(size).offset(offset))
 176         return (count, result)
 177
 178     def _update(self, deployment_manager: ocloud.DeploymentManager):
 179         self.session.add(deployment_manager)
 180
 181
 182 class SubscriptionSqlAlchemyRepository(SubscriptionRepository):
 183     def __init__(self, session):
 184         super().__init__()
 185         self.session = session
 186
 187     def _add(self, subscription: subscription_obj.Subscription):
 188         self.session.add(subscription)
 189
 190     def _get(self, subscription_id) -> subscription_obj.Subscription:
 191         return self.session.query(subscription_obj.Subscription).filter_by(
 192             subscriptionId=subscription_id).first()
 193
 194     def _list(self, *args, **kwargs) -> \
 195             Tuple[int, List[subscription_obj.Subscription]]:
 196         size = kwargs.pop('limit') if 'limit' in kwargs else None
 197         offset = kwargs.pop('start') if 'start' in kwargs else 0
 198
 199         result = self.session.query(subscription_obj.Subscription).filter(
 200             *args).order_by('subscriptionId')
 201         count = result.count()
 202         if size is not None and size != -1:
 203             return (count, result.limit(size).offset(offset))
 204         return (count, result)
 205
 206     def _update(self, subscription: subscription_obj.Subscription):
 207         self.session.add(subscription)
 208
 209     def _delete(self, subscription_id):
 210         self.session.query(subscription_obj.Subscription).filter_by(
 211             subscriptionId=subscription_id).delete()