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         result = self.session.query(ocloud.Resource).filter(
 142             *args).order_by('resourceId')
 143         count = result.count()
 144         if size is not None and size != -1:
 145             return (count, result.limit(size).offset(offset))
 146         return (count, result)
 147
 148     def _update(self, resource: ocloud.Resource):
 149         self.session.add(resource)
 150
 151
 152 class DeploymentManagerSqlAlchemyRepository(DeploymentManagerRepository):
 153     def __init__(self, session):
 154         super().__init__()
 155         self.session = session
 156
 157     def _add(self, deployment_manager: ocloud.DeploymentManager):
 158         self.session.add(deployment_manager)
 159
 160     def _get(self, deployment_manager_id) -> ocloud.DeploymentManager:
 161         return self.session.query(ocloud.DeploymentManager).filter_by(
 162             deploymentManagerId=deployment_manager_id).first()
 163
 164     def _list(self, *args, **kwargs) -> Tuple[int,
 165                                               List[ocloud.DeploymentManager]]:
 166         size = kwargs.pop('limit') if 'limit' in kwargs else None
 167         offset = kwargs.pop('start') if 'start' in kwargs else 0
 168
 169         result = self.session.query(ocloud.DeploymentManager).filter(
 170             *args).order_by('deploymentManagerId')
 171         count = result.count()
 172         if size is not None and size != -1:
 173             return (count, result.limit(size).offset(offset))
 174         return (count, result)
 175
 176     def _update(self, deployment_manager: ocloud.DeploymentManager):
 177         self.session.add(deployment_manager)
 178
 179
 180 class SubscriptionSqlAlchemyRepository(SubscriptionRepository):
 181     def __init__(self, session):
 182         super().__init__()
 183         self.session = session
 184
 185     def _add(self, subscription: subscription_obj.Subscription):
 186         self.session.add(subscription)
 187
 188     def _get(self, subscription_id) -> subscription_obj.Subscription:
 189         return self.session.query(subscription_obj.Subscription).filter_by(
 190             subscriptionId=subscription_id).first()
 191
 192     def _list(self, *args, **kwargs) -> \
 193             Tuple[int, List[subscription_obj.Subscription]]:
 194         size = kwargs.pop('limit') if 'limit' in kwargs else None
 195         offset = kwargs.pop('start') if 'start' in kwargs else 0
 196
 197         result = self.session.query(subscription_obj.Subscription).filter(
 198             *args).order_by('subscriptionId')
 199         count = result.count()
 200         if size is not None and size != -1:
 201             return (count, result.limit(size).offset(offset))
 202         return (count, result)
 203
 204     def _update(self, subscription: subscription_obj.Subscription):
 205         self.session.add(subscription)
 206
 207     def _delete(self, subscription_id):
 208         self.session.query(subscription_obj.Subscription).filter_by(
 209             subscriptionId=subscription_id).delete()