o2ims/adapter/clients/ocloud_sa_client.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 # client talking to Stx standalone
  16
  17 import uuid
  18 from o2common.service.client.base_client import BaseClient
  19 from typing import List
  20 # Optional,  Set
  21 from o2ims.domain import stx_object as ocloudModel
  22 from o2common.config import config
  23 from o2ims.domain.resource_type import ResourceTypeEnum
  24
  25 # from dcmanagerclient.api import client
  26 from cgtsclient.client import get_client
  27
  28 from o2common.helper import o2logging
  29 logger = o2logging.get_logger(__name__)
  30
  31
  32 class StxSaOcloudClient(BaseClient):
  33     def __init__(self, driver=None):
  34         super().__init__()
  35         self.driver = driver if driver else StxSaClientImp()
  36
  37     def _get(self, id) -> ocloudModel.StxGenericModel:
  38         return self.driver.getInstanceInfo()
  39
  40     def _list(self, **filters):
  41         return [self.driver.getInstanceInfo()]
  42
  43
  44 class StxSaResourcePoolClient(BaseClient):
  45     def __init__(self):
  46         super().__init__()
  47         self.driver = StxSaClientImp()
  48
  49     def _get(self, id) -> ocloudModel.StxGenericModel:
  50         return self.driver.getInstanceInfo()
  51
  52     def _list(self, **filters):
  53         return [self.driver.getInstanceInfo()]
  54
  55
  56 class StxSaDmsClient(BaseClient):
  57     def __init__(self):
  58         super().__init__()
  59         self.driver = StxSaClientImp()
  60
  61     def _get(self, name) -> ocloudModel.StxGenericModel:
  62         return self.driver.getK8sDetail(name)
  63
  64     def _list(self, **filters):
  65         return self.driver.getK8sList(**filters)
  66
  67
  68 class StxPserverClient(BaseClient):
  69     def __init__(self):
  70         super().__init__()
  71         self.driver = StxSaClientImp()
  72
  73     def _get(self, id) -> ocloudModel.StxGenericModel:
  74         return self.driver.getPserver(id)
  75
  76     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
  77         return self.driver.getPserverList(**filters)
  78
  79
  80 class StxCpuClient(BaseClient):
  81     def __init__(self):
  82         super().__init__()
  83         # self._pserver_id = pserver_id
  84         self.driver = StxSaClientImp()
  85
  86     def _get(self, id) -> ocloudModel.StxGenericModel:
  87         return self.driver.getCpu(id)
  88
  89     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
  90         return self.driver.getCpuList(**filters)
  91
  92
  93 class StxMemClient(BaseClient):
  94     def __init__(self):
  95         super().__init__()
  96         self.driver = StxSaClientImp()
  97
  98     def _get(self, id) -> ocloudModel.StxGenericModel:
  99         return self.driver.getMem(id)
 100
 101     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
 102         return self.driver.getMemList(**filters)
 103
 104
 105 class StxEthClient(BaseClient):
 106     def __init__(self):
 107         super().__init__()
 108         self.driver = StxSaClientImp()
 109
 110     def _get(self, id) -> ocloudModel.StxGenericModel:
 111         return self.driver.getEthernet(id)
 112
 113     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
 114         return self.driver.getEthernetList(**filters)
 115
 116
 117 class StxIfClient(BaseClient):
 118     def __init__(self):
 119         super().__init__()
 120         self.driver = StxSaClientImp()
 121
 122     def _get(self, id) -> ocloudModel.StxGenericModel:
 123         return self.driver.getIf(id)
 124
 125     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
 126         return self.driver.getIfList(**filters)
 127
 128
 129 class StxIfPortClient(BaseClient):
 130     def __init__(self):
 131         super().__init__()
 132         self.driver = StxSaClientImp()
 133
 134     def _get(self, id) -> ocloudModel.StxGenericModel:
 135         return self.driver.getPort(id)
 136
 137     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
 138         return self.driver.getPortList(**filters)
 139
 140
 141 # internal driver which implement client call to Stx Standalone instance
 142 class StxSaClientImp(object):
 143     def __init__(self, stx_client=None):
 144         super().__init__()
 145         self.stxclient = stx_client if stx_client else self.getStxClient()
 146
 147     def getStxClient(self):
 148         os_client_args = config.get_stx_access_info()
 149         config_client = get_client(**os_client_args)
 150         return config_client
 151
 152     def getInstanceInfo(self) -> ocloudModel.StxGenericModel:
 153         systems = self.stxclient.isystem.list()
 154         logger.debug('systems:' + str(systems[0].to_dict()))
 155         return ocloudModel.StxGenericModel(
 156             ResourceTypeEnum.OCLOUD, systems[0]) if systems else None
 157
 158     def getPserverList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 159         # resourcepoolid = filters.get("resourcepoolid", None)
 160         hosts = self.stxclient.ihost.list()
 161         logger.debug('host 1:' + str(hosts[0].to_dict()))
 162         return [ocloudModel.StxGenericModel(
 163             ResourceTypeEnum.PSERVER, self._hostconverter(host))
 164             for host in hosts if host and host.availability == 'available']
 165
 166     def getPserver(self, id) -> ocloudModel.StxGenericModel:
 167         host = self.stxclient.ihost.get(id)
 168         logger.debug('host:' + str(host.to_dict()))
 169         return ocloudModel.StxGenericModel(
 170             ResourceTypeEnum.PSERVER, self._hostconverter(host))
 171
 172     def getK8sList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 173         k8sclusters = self.stxclient.kube_cluster.list()
 174         logger.debug('k8sresources[0]:' + str(k8sclusters[0].to_dict()))
 175         return [ocloudModel.StxGenericModel(
 176             ResourceTypeEnum.DMS,
 177             self._k8sconverter(k8sres), self._k8shasher(k8sres))
 178             for k8sres in k8sclusters if k8sres]
 179
 180     def getK8sDetail(self, name) -> ocloudModel.StxGenericModel:
 181         if not name:
 182             k8sclusters = self.stxclient.kube_cluster.list()
 183             # logger.debug("k8sresources[0]:" + str(k8sclusters[0].to_dict()))
 184             k8scluster = k8sclusters.pop()
 185         else:
 186             k8scluster = self.stxclient.kube_cluster.get(name)
 187
 188         if not k8scluster:
 189             return None
 190         logger.debug('k8sresource:' + str(k8scluster.to_dict()))
 191         return ocloudModel.StxGenericModel(
 192             ResourceTypeEnum.DMS,
 193             self._k8sconverter(k8scluster), self._k8shasher(k8scluster))
 194
 195     def getCpuList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 196         hostid = filters.get('hostid', None)
 197         assert (hostid is not None), 'missing hostid to query icpu list'
 198         cpulist = self.stxclient.icpu.list(hostid)
 199         return [ocloudModel.StxGenericModel(
 200             ResourceTypeEnum.PSERVER_CPU,
 201             self._cpuconverter(cpures)) for cpures in cpulist if cpures]
 202
 203     def getCpu(self, id) -> ocloudModel.StxGenericModel:
 204         cpuinfo = self.stxclient.icpu.get(id)
 205         return ocloudModel.StxGenericModel(
 206             ResourceTypeEnum.PSERVER_CPU, self._cpuconverter(cpuinfo))
 207
 208     def getMemList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 209         hostid = filters.get('hostid', None)
 210         assert (hostid is not None), 'missing hostid to query imem list'
 211         memlist = self.stxclient.imemory.list(hostid)
 212         return [ocloudModel.StxGenericModel(
 213             ResourceTypeEnum.PSERVER_RAM,
 214             self._memconverter(memories)) for memories in memlist if memories]
 215
 216     def getMem(self, id) -> ocloudModel.StxGenericModel:
 217         meminfo = self.stxclient.imemory.get(id)
 218         return ocloudModel.StxGenericModel(
 219             ResourceTypeEnum.PSERVER_RAM, self._memconverter(meminfo))
 220
 221     def getEthernetList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 222         hostid = filters.get('hostid', None)
 223         assert (hostid is not None), 'missing hostid to query port list'
 224         ethlist = self.stxclient.ethernet_port.list(hostid)
 225         return [ocloudModel.StxGenericModel(
 226             ResourceTypeEnum.PSERVER_ETH,
 227             self._ethconverter(eth)) for eth in ethlist if eth]
 228
 229     def getEthernet(self, id) -> ocloudModel.StxGenericModel:
 230         ethinfo = self.stxclient.ethernet_port.get(id)
 231         return ocloudModel.StxGenericModel(
 232             ResourceTypeEnum.PSERVER_ETH, self._ethconverter(ethinfo))
 233
 234     def getIfList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 235         hostid = filters.get('hostid', None)
 236         assert (hostid is not None), 'missing hostid to query iinterface list'
 237         iflist = self.stxclient.iinterface.list(hostid)
 238         return [ocloudModel.StxGenericModel(
 239             ResourceTypeEnum.PSERVER_IF,
 240             self._ifconverter(ifs)) for ifs in iflist if ifs]
 241
 242     def getIf(self, id) -> ocloudModel.StxGenericModel:
 243         ifinfo = self.stxclient.iinterface.get(id)
 244         return ocloudModel.StxGenericModel(
 245             ResourceTypeEnum.PSERVER_IF, self._ifconverter(ifinfo))
 246
 247     def getPortList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 248         ifid = filters.get('interfaceid', None)
 249         assert (ifid is not None), 'missing interface id to query port list'
 250         portlist = self.stxclient.iinterface.list_ports(ifid)
 251         return [ocloudModel.StxGenericModel(
 252             ResourceTypeEnum.PSERVER_IF_PORT,
 253             port) for port in portlist if port]
 254
 255     def getPort(self, id) -> ocloudModel.StxGenericModel:
 256         portinfo = self.stxclient.port.get(id)
 257         return ocloudModel.StxGenericModel(
 258             ResourceTypeEnum.PSERVER_IF_PORT, portinfo)
 259
 260     def _getIsystems(self):
 261         return self.stxclient.isystem.list()
 262
 263     def _getIsystem(self, id=None):
 264         if id:
 265             return self.stxclient.isystem.get(id)
 266         else:
 267             isystems = self.stxclient.isystem.list()
 268             if len(isystems) != 1 and not id:
 269                 raise Exception('No system uuid was provided and '
 270                                 'more than one system exists in the account.')
 271             return isystems[0]
 272
 273     @ staticmethod
 274     def _hostconverter(host):
 275         setattr(host, 'name', host.hostname)
 276         return host
 277
 278     @ staticmethod
 279     def _cpuconverter(cpu):
 280         setattr(cpu, 'name', cpu.ihost_uuid.split(
 281             '-', 1)[0] + '-cpu-'+str(cpu.cpu))
 282         return cpu
 283
 284     @ staticmethod
 285     def _memconverter(mem):
 286         setattr(mem, 'name', mem.ihost_uuid.split('-', 1)[0] +
 287                 '-mem-node-'+str(mem.numa_node))
 288         return mem
 289
 290     @ staticmethod
 291     def _ethconverter(eth):
 292         setattr(eth, 'name', eth.host_uuid.split('-', 1)[0] + '-'+eth.name)
 293         setattr(eth, 'updated_at', None)
 294         setattr(eth, 'created_at', None)
 295         return eth
 296
 297     @ staticmethod
 298     def _ifconverter(ifs):
 299         setattr(ifs, 'name', ifs.ihost_uuid.split('-', 1)[0] + '-'+ifs.ifname)
 300         setattr(ifs, 'updated_at', None)
 301         setattr(ifs, 'created_at', None)
 302         return ifs
 303
 304     @ staticmethod
 305     def _k8sconverter(cluster):
 306         setattr(cluster, 'name', cluster.cluster_name)
 307         setattr(cluster, 'uuid',
 308                 uuid.uuid3(uuid.NAMESPACE_URL, cluster.cluster_name))
 309         setattr(cluster, 'updated_at', None)
 310         setattr(cluster, 'created_at', None)
 311         setattr(cluster, 'events', [])
 312         logger.debug('k8s cluster name/uuid:' +
 313                      cluster.name + '/' + str(cluster.uuid))
 314         return cluster
 315
 316     @ staticmethod
 317     def _k8shasher(cluster):
 318         return str(hash((cluster.cluster_name,
 319                          cluster.cluster_api_endpoint, cluster.admin_user)))