o2ims/views/ocloud_view.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 import filecmp
  16 import os.path
  17 import uuid
  18 import yaml
  19 from datetime import datetime
  20 import shutil
  21
  22 from o2common.service import unit_of_work
  23 from o2common.config import config
  24 from o2common.views.view import gen_filter, check_filter
  25 from o2common.views.pagination_view import Pagination
  26 from o2common.views.route_exception import BadRequestException, \
  27     NotFoundException
  28
  29 from o2ims.domain import ocloud
  30 from o2ims.views.ocloud_dto import SubscriptionDTO
  31 from o2ims.domain.subscription_obj import Subscription
  32
  33 from o2common.helper import o2logging
  34 logger = o2logging.get_logger(__name__)
  35
  36
  37 def oclouds(uow: unit_of_work.AbstractUnitOfWork):
  38     with uow:
  39         li = uow.oclouds.list()
  40     return [r.serialize() for r in li]
  41
  42
  43 def ocloud_one(ocloudid: str, uow: unit_of_work.AbstractUnitOfWork):
  44     with uow:
  45         first = uow.oclouds.get(ocloudid)
  46         return first.serialize() if first is not None else None
  47
  48
  49 def resource_types(uow: unit_of_work.AbstractUnitOfWork, **kwargs):
  50     pagination = Pagination(**kwargs)
  51     query_kwargs = pagination.get_pagination()
  52     args = gen_filter(ocloud.ResourceType,
  53                       kwargs['filter']) if 'filter' in kwargs else []
  54     with uow:
  55         li = uow.resource_types.list_with_count(*args, **query_kwargs)
  56     return pagination.get_result(li)
  57
  58
  59 def resource_type_one(resourceTypeId: str,
  60                       uow: unit_of_work.AbstractUnitOfWork):
  61     with uow:
  62         first = uow.resource_types.get(resourceTypeId)
  63         return first.serialize() if first is not None else None
  64
  65
  66 def resource_pools(uow: unit_of_work.AbstractUnitOfWork, **kwargs):
  67     pagination = Pagination(**kwargs)
  68     query_kwargs = pagination.get_pagination()
  69     args = gen_filter(ocloud.ResourcePool,
  70                       kwargs['filter']) if 'filter' in kwargs else []
  71     with uow:
  72         li = uow.resource_pools.list_with_count(*args, **query_kwargs)
  73     return pagination.get_result(li)
  74
  75
  76 def resource_pool_one(resourcePoolId: str,
  77                       uow: unit_of_work.AbstractUnitOfWork):
  78     with uow:
  79         first = uow.resource_pools.get(resourcePoolId)
  80         return first.serialize() if first else None
  81
  82
  83 def resources(resourcePoolId: str, uow: unit_of_work.AbstractUnitOfWork,
  84               **kwargs):
  85     with uow:
  86         first = uow.resource_pools.get(resourcePoolId)
  87     if first is None:
  88         raise NotFoundException("ResourcePool {} doesn't exist".format(
  89             resourcePoolId))
  90     pagination = Pagination(**kwargs)
  91     # filter key should be the same with database name
  92     query_kwargs = pagination.get_pagination()
  93     if 'resourceTypeName' in kwargs:
  94         resource_type_name = kwargs['resourceTypeName']
  95         with uow:
  96             # res_types = uow.resource_types.list()
  97             # restype_ids = [
  98             #     restype.resourceTypeId for restype in res_types
  99             #     if resourceTypeName == restype.name]
 100             # restype_id = '' if len(restype_ids) == 0 else restype_ids[0]
 101             res_type = uow.resource_types.get_by_name(resource_type_name)
 102             restype_id = '' if res_type is None else res_type.resourceTypeId
 103         query_kwargs['resourceTypeId'] = restype_id
 104     args = gen_filter(
 105         ocloud.Resource, kwargs['filter']) if 'filter' in kwargs else []
 106     args.append(ocloud.Resource.resourcePoolId == resourcePoolId)
 107     # args.append(ocloud.Resource.parentId == None)
 108
 109     if 'parentId' in kwargs:
 110         query_kwargs['parentId'] = kwargs['parentId']
 111     if 'sort' in kwargs:
 112         query_kwargs['sort'] = kwargs['sort']
 113
 114     with uow:
 115         ret = uow.resources.list_with_count(
 116             resourcePoolId, *args, **query_kwargs)
 117
 118     return pagination.get_result(ret)
 119
 120
 121 def resource_one(resourceId: str,
 122                  uow: unit_of_work.AbstractUnitOfWork, resourcePoolId: str):
 123     with uow:
 124         resoucePool = uow.resource_pools.get(resourcePoolId)
 125     if resoucePool is None:
 126         raise NotFoundException("ResourcePool {} doesn't exist".format(
 127             resourcePoolId))
 128
 129     first = uow.resources.get(resourceId)
 130     if first is None:
 131         raise NotFoundException("Resource {} doesn't exist".format(
 132             resourceId))
 133     return first.serialize()
 134
 135
 136 def deployment_managers(uow: unit_of_work.AbstractUnitOfWork, **kwargs):
 137     pagination = Pagination(**kwargs)
 138     query_kwargs = pagination.get_pagination()
 139     args = gen_filter(ocloud.DeploymentManager,
 140                       kwargs['filter']) if 'filter' in kwargs else []
 141     with uow:
 142         li = uow.deployment_managers.list_with_count(*args, **query_kwargs)
 143     return pagination.get_result(li)
 144
 145
 146 def deployment_manager_one(deploymentManagerId: str,
 147                            uow: unit_of_work.AbstractUnitOfWork,
 148                            profile: str =
 149                            ocloud.DeploymentManagerProfileDefault):
 150     profile = profile.lower()
 151     with uow:
 152         first = uow.deployment_managers.get(deploymentManagerId)
 153         if first is None:
 154             return first
 155         result = first.serialize()
 156         if result is None:
 157             return None
 158
 159     profile_data = result.pop("profile", None)
 160     profiles = config.get_dms_support_profiles()
 161     if profile not in profiles:
 162         return ""
 163
 164     extensions = {
 165         'profileName': profile
 166     }
 167     if ocloud.DeploymentManagerProfileDefault == profile \
 168             or ocloud.DeploymentManagerProfileSOL018 == profile:
 169         result['serviceUri'] = \
 170             profile_data['cluster_api_endpoint']
 171         extensions['profileData'] = profile_data
 172     elif ocloud.DeploymentManagerProfileSOL018HelmCLI == profile:
 173         result['serviceUri'] = \
 174             profile_data['cluster_api_endpoint']
 175
 176         helmcli_profile = dict()
 177         helmcli_profile["helmcli_host_with_port"], helmcli_profile[
 178             "helmcli_username"], helmcli_profile["helmcli_password"] = \
 179             config.get_helmcli_access()
 180         helmcli_profile["helmcli_kubeconfig"] = _gen_kube_config(
 181             deploymentManagerId, profile_data)
 182         extensions['profileData'] = helmcli_profile
 183     else:
 184         return ""
 185
 186     result['extensions'] = extensions
 187     return result
 188
 189
 190 def _gen_kube_config(dmId: str, kubeconfig: dict) -> dict:
 191
 192     data = config.gen_k8s_config_dict(
 193         kubeconfig.pop('cluster_api_endpoint', None),
 194         kubeconfig.pop('cluster_ca_cert', None),
 195         kubeconfig.pop('admin_user', None),
 196         kubeconfig.pop('admin_client_cert', None),
 197         kubeconfig.pop('admin_client_key', None),
 198     )
 199
 200     # Generate a random key for tmp kube config file
 201     # letters = string.ascii_uppercase
 202     # random_key = ''.join(random.choice(letters) for i in range(10))
 203     name_key = dmId[:8]
 204
 205     # Get datetime of now as tag of the tmp file
 206     current_time = datetime.now().strftime("%Y%m%d%H%M%S")
 207     tmp_file_name = 'kubeconfig_' + name_key + "_" + current_time
 208     kube_config_name = 'kubeconfig_' + name_key + '.config'
 209
 210     # write down the yaml file of kubectl into tmp folder
 211     with open('/tmp/' + tmp_file_name, 'w') as file:
 212         yaml.dump(data, file)
 213
 214     # generate the kube config file if not exist or update the file if it
 215     # changes
 216     if not os.path.exists('/configs/' + kube_config_name) or not \
 217             filecmp.cmp('/tmp/'+tmp_file_name, '/configs/'+kube_config_name):
 218         shutil.move(os.path.join('/tmp', tmp_file_name),
 219                     os.path.join('/configs', kube_config_name))
 220
 221     return '/configs/'+kube_config_name
 222
 223
 224 def subscriptions(uow: unit_of_work.AbstractUnitOfWork, **kwargs):
 225     pagination = Pagination(**kwargs)
 226     query_kwargs = pagination.get_pagination()
 227     args = gen_filter(Subscription,
 228                       kwargs['filter']) if 'filter' in kwargs else []
 229     with uow:
 230         li = uow.subscriptions.list_with_count(*args, **query_kwargs)
 231     return pagination.get_result(li)
 232
 233
 234 def subscription_one(subscriptionId: str,
 235                      uow: unit_of_work.AbstractUnitOfWork):
 236     with uow:
 237         first = uow.subscriptions.get(subscriptionId)
 238         return first.serialize() if first is not None else None
 239
 240
 241 def subscription_create(subscriptionDto: SubscriptionDTO.subscription_create,
 242                         uow: unit_of_work.AbstractUnitOfWork):
 243     filter = subscriptionDto.get('filter', '')
 244     consumer_subs_id = subscriptionDto.get('consumerSubscriptionId', '')
 245
 246     check_filter(ocloud.Resource, filter)
 247
 248     sub_uuid = str(uuid.uuid4())
 249     subscription = Subscription(
 250         sub_uuid, subscriptionDto['callback'],
 251         consumer_subs_id, filter)
 252     with uow:
 253         args = list()
 254         args.append(getattr(Subscription, 'callback')
 255                     == subscriptionDto['callback'])
 256         args.append(getattr(Subscription, 'filter') == filter)
 257         args.append(getattr(Subscription,
 258                     'consumerSubscriptionId') == consumer_subs_id)
 259         count, _ = uow.subscriptions.list_with_count(*args)
 260         if count > 0:
 261             raise BadRequestException("The value of parameters is duplicated")
 262         uow.subscriptions.add(subscription)
 263         uow.commit()
 264         first = uow.subscriptions.get(sub_uuid)
 265         return first.serialize()
 266
 267
 268 def subscription_delete(subscriptionId: str,
 269                         uow: unit_of_work.AbstractUnitOfWork):
 270     with uow:
 271         first = uow.subscriptions.get(subscriptionId)
 272         if not first:
 273             raise NotFoundException(
 274                 "Subscription {} not found.".format(subscriptionId))
 275         uow.subscriptions.delete(subscriptionId)
 276         uow.commit()
 277     return True