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) -> List[ocloud.Ocloud]:
  39         return self.session.query(ocloud.Ocloud)
  40
  41     def _update(self, ocloud: ocloud.Ocloud):
  42         self.session.add(ocloud)
  43
  44
  45 class ResouceTypeSqlAlchemyRepository(ResourceTypeRepository):
  46     def __init__(self, session):
  47         super().__init__()
  48         self.session = session
  49
  50     def _add(self, resourceType: ocloud.ResourceType):
  51         self.session.add(resourceType)
  52
  53     def _get(self, resource_type_id) -> ocloud.ResourceType:
  54         return self.session.query(ocloud.ResourceType).filter_by(
  55             resourceTypeId=resource_type_id).first()
  56
  57     def _get_by_name(self, resource_type_name) -> ocloud.ResourceType:
  58         return self.session.query(ocloud.ResourceType).filter_by(
  59             name=resource_type_name).first()
  60
  61     def _list(self, *args, **kwargs) -> Tuple[int, List[ocloud.ResourceType]]:
  62         size = kwargs.pop('limit') if 'limit' in kwargs else None
  63         offset = kwargs.pop('start') if 'start' in kwargs else 0
  64
  65         result = self.session.query(ocloud.ResourceType).filter(
  66             *args).order_by('resourceTypeId')
  67         count = result.count()
  68         if size is not None and size != -1:
  69             return (count, result.limit(size).offset(offset))
  70         return (count, result)
  71
  72     def _update(self, resourceType: ocloud.ResourceType):
  73         self.session.add(resourceType)
  74
  75
  76 class ResourcePoolSqlAlchemyRepository(ResourcePoolRepository):
  77     def __init__(self, session):
  78         super().__init__()
  79         self.session = session
  80
  81     def _add(self, resourcePool: ocloud.ResourcePool):
  82         self.session.add(resourcePool)
  83
  84     def _get(self, resource_pool_id) -> ocloud.ResourcePool:
  85         return self.session.query(ocloud.ResourcePool).filter_by(
  86             resourcePoolId=resource_pool_id).first()
  87
  88     def _list(self, *args, **kwargs) -> Tuple[int, List[ocloud.ResourcePool]]:
  89         size = kwargs.pop('limit') if 'limit' in kwargs else None
  90         offset = kwargs.pop('start') if 'start' in kwargs else 0
  91
  92         result = self.session.query(ocloud.ResourcePool).filter(
  93             *args).order_by('resourcePoolId')
  94         count = result.count()
  95         if size is not None and size != -1:
  96             return (count, result.limit(size).offset(offset))
  97         return (count, result)
  98
  99     def _update(self, resourcePool: ocloud.ResourcePool):
 100         self.session.add(resourcePool)
 101
 102
 103 class ResourceSqlAlchemyRepository(ResourceRepository):
 104     def __init__(self, session):
 105         super().__init__()
 106         self.session = session
 107
 108     def _add(self, resource: ocloud.Resource):
 109         self.session.add(resource)
 110
 111     def _get(self, resource_id) -> ocloud.Resource:
 112         # return self.session.query(ocloud.Resource).filter_by(
 113         #     resourceId=resource_id).first()
 114         # topq = uow.session.query(orm.resource).filter(
 115         #     orm.resource.c.resourceId == resourceId).\
 116         #     cte('cte', recursive=True)
 117         # bootomq = uow.session.query(orm.resource).join(
 118         #     topq, orm.resource.c.parentId == topq.c.resourceId)
 119         # res = uow.session.query(topq.union(bootomq))
 120         def recursive(id):
 121             res = self.session.query(ocloud.Resource).filter_by(
 122                 resourceId=id).first()
 123             if res is not None:
 124                 query = self.session.query(ocloud.Resource).filter_by(
 125                     parentId=res.resourceId)
 126                 children = []
 127                 for r in query:
 128                     child = recursive(r.resourceId)
 129                     children.append(child)
 130                 res.set_children(children)
 131             return res
 132         return recursive(resource_id)
 133
 134     def _list(self, resourcepool_id, *args, **kwargs) -> \
 135             Tuple[int, List[ocloud.Resource]]:
 136         if 'sort' in kwargs:
 137             kwargs.pop('sort')
 138         size = kwargs.pop('limit') if 'limit' in kwargs else None
 139         offset = kwargs.pop('start') if 'start' in kwargs else 0
 140
 141         args1 = args + (ocloud.Resource.resourcePoolId == resourcepool_id,)
 142         result = self.session.query(ocloud.Resource).filter(
 143             *args1).order_by('resourceId')
 144         count = result.count()
 145         if size is not None and size != -1:
 146             return (count, result.limit(size).offset(offset))
 147         return (count, result)
 148
 149     def _update(self, resource: ocloud.Resource):
 150         self.session.add(resource)
 151
 152
 153 class DeploymentManagerSqlAlchemyRepository(DeploymentManagerRepository):
 154     def __init__(self, session):
 155         super().__init__()
 156         self.session = session
 157
 158     def _add(self, deployment_manager: ocloud.DeploymentManager):
 159         self.session.add(deployment_manager)
 160
 161     def _get(self, deployment_manager_id) -> ocloud.DeploymentManager:
 162         return self.session.query(ocloud.DeploymentManager).filter_by(
 163             deploymentManagerId=deployment_manager_id).first()
 164
 165     def _list(self, *args, **kwargs) -> Tuple[int,
 166                                               List[ocloud.DeploymentManager]]:
 167         size = kwargs.pop('limit') if 'limit' in kwargs else None
 168         offset = kwargs.pop('start') if 'start' in kwargs else 0
 169
 170         result = self.session.query(ocloud.DeploymentManager).filter(
 171             *args).order_by('deploymentManagerId')
 172         count = result.count()
 173         if size is not None and size != -1:
 174             return (count, result.limit(size).offset(offset))
 175         return (count, result)
 176
 177     def _update(self, deployment_manager: ocloud.DeploymentManager):
 178         self.session.add(deployment_manager)
 179
 180
 181 class SubscriptionSqlAlchemyRepository(SubscriptionRepository):
 182     def __init__(self, session):
 183         super().__init__()
 184         self.session = session
 185
 186     def _add(self, subscription: subscription_obj.Subscription):
 187         self.session.add(subscription)
 188
 189     def _get(self, subscription_id) -> subscription_obj.Subscription:
 190         return self.session.query(subscription_obj.Subscription).filter_by(
 191             subscriptionId=subscription_id).first()
 192
 193     def _list(self, *args, **kwargs) -> \
 194             Tuple[int, List[subscription_obj.Subscription]]:
 195         size = kwargs.pop('limit') if 'limit' in kwargs else None
 196         offset = kwargs.pop('start') if 'start' in kwargs else 0
 197
 198         result = self.session.query(subscription_obj.Subscription).filter(
 199             *args).order_by('subscriptionId')
 200         count = result.count()
 201         if size is not None and size != -1:
 202             return (count, result.limit(size).offset(offset))
 203         return (count, result)
 204
 205     def _update(self, subscription: subscription_obj.Subscription):
 206         self.session.add(subscription)
 207
 208     def _delete(self, subscription_id):
 209         self.session.query(subscription_obj.Subscription).filter_by(
 210             subscriptionId=subscription_id).delete()