o2ims/adapter/clients/ocloud_client.py

   1 # Copyright (C) 2022 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 import json
  19 from typing import List
  20 # Optional,  Set
  21
  22 from cgtsclient.client import get_client as get_stx_client
  23 from cgtsclient.exc import EndpointException
  24 from dcmanagerclient.api.client import client as get_dc_client
  25
  26 from o2common.config import config
  27 from o2common.service.client.base_client import BaseClient
  28 from o2ims.domain import stx_object as ocloudModel
  29 from o2ims.domain.resource_type import ResourceTypeEnum
  30
  31 from o2common.helper import o2logging
  32 logger = o2logging.get_logger(__name__)
  33
  34
  35 CGTSCLIENT_ENDPOINT_ERROR_MSG = \
  36     'Must provide Keystone credentials or user-defined endpoint and token'
  37
  38
  39 class StxOcloudClient(BaseClient):
  40     def __init__(self, driver=None):
  41         super().__init__()
  42         self.driver = driver if driver else StxClientImp()
  43
  44     def _get(self, id) -> ocloudModel.StxGenericModel:
  45         return self.driver.getInstanceInfo()
  46
  47     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
  48         return [self.driver.getInstanceInfo()]
  49
  50     def _set_stx_client(self):
  51         pass
  52
  53
  54 class StxResourcePoolClient(BaseClient):
  55     def __init__(self):
  56         super().__init__()
  57         self.driver = StxClientImp()
  58
  59     def _get(self, id) -> ocloudModel.StxGenericModel:
  60         return self.driver.getResourcePoolDetail(id)
  61
  62     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
  63         return self.driver.getResourcePoolList(**filters)
  64
  65     def _set_stx_client(self):
  66         pass
  67
  68
  69 class StxDmsClient(BaseClient):
  70     def __init__(self):
  71         super().__init__()
  72         self.driver = StxClientImp()
  73
  74     def _get(self, name) -> ocloudModel.StxGenericModel:
  75         return self.driver.getK8sDetail(name)
  76
  77     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
  78         return self.driver.getK8sList(**filters)
  79
  80     def _set_stx_client(self):
  81         pass
  82
  83
  84 class StxPserverClient(BaseClient):
  85     def __init__(self):
  86         super().__init__()
  87         self.driver = StxClientImp()
  88
  89     def _get(self, id) -> ocloudModel.StxGenericModel:
  90         return self.driver.getPserver(id)
  91
  92     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
  93         return self.driver.getPserverList(**filters)
  94
  95     def _set_stx_client(self):
  96         self.driver.setStxClient(self._pool_id)
  97
  98
  99 class StxCpuClient(BaseClient):
 100     def __init__(self):
 101         super().__init__()
 102         # self._pserver_id = pserver_id
 103         self.driver = StxClientImp()
 104
 105     def _get(self, id) -> ocloudModel.StxGenericModel:
 106         return self.driver.getCpu(id)
 107
 108     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
 109         return self.driver.getCpuList(**filters)
 110
 111     def _set_stx_client(self):
 112         self.driver.setStxClient(self._pool_id)
 113
 114
 115 class StxMemClient(BaseClient):
 116     def __init__(self):
 117         super().__init__()
 118         self.driver = StxClientImp()
 119
 120     def _get(self, id) -> ocloudModel.StxGenericModel:
 121         return self.driver.getMem(id)
 122
 123     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
 124         return self.driver.getMemList(**filters)
 125
 126     def _set_stx_client(self):
 127         self.driver.setStxClient(self._pool_id)
 128
 129
 130 class StxEthClient(BaseClient):
 131     def __init__(self):
 132         super().__init__()
 133         self.driver = StxClientImp()
 134
 135     def _get(self, id) -> ocloudModel.StxGenericModel:
 136         return self.driver.getEthernet(id)
 137
 138     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
 139         return self.driver.getEthernetList(**filters)
 140
 141     def _set_stx_client(self):
 142         self.driver.setStxClient(self._pool_id)
 143
 144
 145 class StxIfClient(BaseClient):
 146     def __init__(self):
 147         super().__init__()
 148         self.driver = StxClientImp()
 149
 150     def _get(self, id) -> ocloudModel.StxGenericModel:
 151         return self.driver.getIf(id)
 152
 153     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
 154         return self.driver.getIfList(**filters)
 155
 156     def _set_stx_client(self):
 157         self.driver.setStxClient(self._pool_id)
 158
 159
 160 class StxIfPortClient(BaseClient):
 161     def __init__(self):
 162         super().__init__()
 163         self.driver = StxClientImp()
 164
 165     def _get(self, id) -> ocloudModel.StxGenericModel:
 166         return self.driver.getPort(id)
 167
 168     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
 169         return self.driver.getPortList(**filters)
 170
 171     def _set_stx_client(self):
 172         self.driver.setStxClient(self._pool_id)
 173
 174
 175 class StxDevClient(BaseClient):
 176     def __init__(self):
 177         super().__init__()
 178         self.driver = StxClientImp()
 179
 180     def _get(self, id) -> ocloudModel.StxGenericModel:
 181         return self.driver.getDevice(id)
 182
 183     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
 184         return self.driver.getDeviceList(**filters)
 185
 186     def _set_stx_client(self):
 187         self.driver.setStxClient(self._pool_id)
 188
 189
 190 class StxAccClient(BaseClient):
 191     def __init__(self):
 192         super().__init__()
 193         self.driver = StxClientImp()
 194
 195     def _get(self, id) -> ocloudModel.StxGenericModel:
 196         return self.driver.getAccelerator(id)
 197
 198     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
 199         return self.driver.getAcceleratorList(**filters)
 200
 201     def _set_stx_client(self):
 202         self.driver.setStxClient(self._pool_id)
 203
 204
 205 # internal driver which implement client call to Stx Standalone and DC instance
 206 class StxClientImp(object):
 207     def __init__(self, stx_client=None, dc_client=None):
 208         super().__init__()
 209         self.stxclient = stx_client if stx_client else self.getStxClient()
 210         self.dcclient = dc_client if dc_client else self.getDcmanagerClient()
 211         # if subcloud_id is not None:
 212         # self.stxclient = self.getSubcloudClient(subcloud_id)
 213
 214     def getStxClient(self):
 215         os_client_args = config.get_stx_access_info()
 216         config_client = get_stx_client(**os_client_args)
 217         return config_client
 218
 219     def getDcmanagerClient(self):
 220         os_client_args = config.get_dc_access_info()
 221         config_client = get_dc_client(**os_client_args)
 222         return config_client
 223
 224     def getSubcloudClient(self, subcloud_id):
 225         subcloud = self.dcclient.subcloud_manager.\
 226             subcloud_additional_details(subcloud_id)
 227         logger.debug('subcloud name: %s, oam_floating_ip: %s' %
 228                      (subcloud[0].name, subcloud[0].oam_floating_ip))
 229         try:
 230             os_client_args = config.get_stx_access_info(
 231                 region_name=subcloud[0].name,
 232                 subcloud_hostname=subcloud[0].oam_floating_ip)
 233             # logger.info(os_client_args)
 234             config_client = get_stx_client(**os_client_args)
 235         except EndpointException as e:
 236             msg = e.format_message()
 237             if CGTSCLIENT_ENDPOINT_ERROR_MSG in msg:
 238                 os_client_args = config.get_stx_access_info(
 239                     region_name=subcloud[0].name, sub_is_https=True,
 240                     subcloud_hostname=subcloud[0].oam_floating_ip)
 241                 # logger.info(os_client_args)
 242                 config_client = get_stx_client(**os_client_args)
 243             else:
 244                 raise ValueError('Stx endpoint exception: %s' % msg)
 245         except Exception:
 246             raise ValueError('cgtsclient get subcloud client failed')
 247
 248         return config_client
 249
 250     def setStxClient(self, resource_pool_id):
 251         systems = self.stxclient.isystem.list()
 252         if resource_pool_id == systems[0].uuid:
 253             logger.debug('Stx Client not change: %s' % resource_pool_id)
 254             return
 255
 256         subclouds = self.getSubcloudList()
 257         for subcloud in subclouds:
 258             subcloud_stxclient = self.getSubcloudClient(subcloud.subcloud_id)
 259             systems = subcloud_stxclient.isystem.list()
 260             # logger.debug('subcloud %s id: %s' %
 261             #  (systems[0].name, systems[0].uuid))
 262             # logger.debug('subcloud: %s' % (systems[0].to_dict()))
 263             if resource_pool_id == systems[0].uuid:
 264                 self.stxclient = subcloud_stxclient
 265
 266     def getInstanceInfo(self) -> ocloudModel.StxGenericModel:
 267         systems = self.stxclient.isystem.list()
 268         logger.debug('systems:' + str(systems[0].to_dict()))
 269         # logger.debug('systems[0] uuid: ' + str(systems[0].uuid))
 270         return ocloudModel.StxGenericModel(
 271             ResourceTypeEnum.OCLOUD, systems[0]) if systems else None
 272
 273     def getSubcloudList(self):
 274         self.dcclient = self.getDcmanagerClient()
 275         subs = self.dcclient.subcloud_manager.list_subclouds()
 276         known_subs = [sub for sub in subs if sub.sync_status != 'unknown']
 277         return known_subs
 278
 279     def getResourcePoolList(self, **filters) -> List[
 280             ocloudModel.StxGenericModel]:
 281         systems = self.stxclient.isystem.list()
 282         logger.debug('system controller distributed_cloud_role:' +
 283                      str(systems[0].distributed_cloud_role))
 284
 285         if systems[0].distributed_cloud_role is None or \
 286                 systems[0].distributed_cloud_role != 'systemcontroller':
 287             return [ocloudModel.StxGenericModel(
 288                 ResourceTypeEnum.RESOURCE_POOL,
 289                 self._respoolconverter(systems[0]))]
 290
 291         pools = []
 292         if config.get_system_controller_as_respool():
 293             pools.append(systems[0])
 294
 295         subclouds = self.getSubcloudList()
 296         logger.debug('subclouds numbers: %s' % len(subclouds))
 297         for subcloud in subclouds:
 298             try:
 299                 subcloud_stxclient = self.getSubcloudClient(
 300                     subcloud.subcloud_id)
 301                 systems = subcloud_stxclient.isystem.list()
 302                 logger.debug('systems:' + str(systems[0].to_dict()))
 303                 pools.append(systems[0])
 304             except Exception as ex:
 305                 logger.warning('Failed get cgstclient of subcloud %s: %s' %
 306                                (subcloud.name, ex))
 307                 continue
 308
 309         return [ocloudModel.StxGenericModel(
 310             ResourceTypeEnum.RESOURCE_POOL,
 311                 self._respoolconverter(
 312                     respool)) for respool in pools if respool]
 313
 314     def getResourcePoolDetail(self, id):
 315         self.setStxClient(id)
 316         systems = self.stxclient.isystem.list()
 317         logger.debug('systems:' + str(systems[0].to_dict()))
 318         return ocloudModel.StxGenericModel(
 319             ResourceTypeEnum.RESOURCE_POOL,
 320             self._respoolconverter(systems[0])) if systems else None
 321
 322     def getPserverList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 323         hosts = self.stxclient.ihost.list()
 324         logger.debug('host 1:' + str(hosts[0].to_dict()))
 325         return [ocloudModel.StxGenericModel(
 326             ResourceTypeEnum.PSERVER, self._hostconverter(host))
 327             for host in hosts if host and (host.availability == 'available'
 328                                            or host.availability == 'online'
 329                                            or host.availability == 'degraded')]
 330
 331     def getPserver(self, id) -> ocloudModel.StxGenericModel:
 332         host = self.stxclient.ihost.get(id)
 333         logger.debug('host:' + str(host.to_dict()))
 334         return ocloudModel.StxGenericModel(
 335             ResourceTypeEnum.PSERVER, self._hostconverter(host))
 336
 337     def _checkLabelExistOnHost(self, label_key, hostid) -> bool:
 338         labels = self.stxclient.label.list(hostid)
 339         return any(label_key == label.label_key for label in labels)
 340
 341     def _checkLabelExistOnCluster(self, label_key) -> bool:
 342         hosts = self.stxclient.ihost.list()
 343
 344         def find_label_on_host():
 345             result = next(
 346                 (
 347                     (host, True)
 348                     for host in hosts
 349                     if self._checkLabelExistOnHost(label_key, host.uuid)
 350                 ),
 351                 (None, False),
 352             )
 353
 354             if result[1]:
 355                 logger.info("host %s has the label %s" %
 356                             (result[0].hostname, label_key))
 357
 358             return result[1]
 359
 360         return find_label_on_host()
 361
 362         # return any(self._checkLabelExistOnHost(label_key, host.uuid) for host
 363         #    in hosts)
 364
 365     def _setK8sCapabilities(self, k8scluster):
 366         capabilities = {}
 367         if self._checkLabelExistOnCluster('OS'):
 368             logger.debug("low latency host inside of the cluster")
 369             capabilities['OS'] = 'low_latency'
 370         setattr(k8scluster, 'capabilities', json.dumps(capabilities))
 371         return k8scluster
 372
 373     def getLabelList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 374         hostid = filters.get('hostid', None)
 375         assert (hostid is not None), 'missing hostid to query label list'
 376         labels = self.stxclient.label.list(hostid)
 377         return [ocloudModel.StxGenericModel(
 378             ResourceTypeEnum.PSERVER_LABEL,
 379             self._labelconverter(label)) for label in labels if label]
 380
 381     def getK8sList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 382         systems = self.stxclient.isystem.list()
 383         logger.debug('system controller distributed_cloud_role:' +
 384                      str(systems[0].distributed_cloud_role))
 385
 386         if systems[0].distributed_cloud_role is None or \
 387                 systems[0].distributed_cloud_role != 'systemcontroller':
 388             k8sclusters = self.stxclient.kube_cluster.list()
 389             setattr(k8sclusters[0], 'cloud_name', systems[0].name)
 390             k8sclusters[0] = self._setK8sCapabilities(k8sclusters[0])
 391             # logger.debug('k8sresources[0]:' + str(k8sclusters[0].to_dict()))
 392             logger.debug('k8sresources[0] cluster_api_endpoint: ' +
 393                          str(k8sclusters[0].cluster_api_endpoint))
 394             return [ocloudModel.StxGenericModel(
 395                 ResourceTypeEnum.DMS,
 396                 self._k8sconverter(k8sres), self._k8shasher(k8sres))
 397                 for k8sres in k8sclusters if k8sres]
 398
 399         k8s_list = []
 400         if config.get_system_controller_as_respool():
 401             k8sclusters = self.stxclient.kube_cluster.list()
 402             setattr(k8sclusters[0], 'cloud_name', systems[0].name)
 403             k8sclusters[0] = self._setK8sCapabilities(k8sclusters[0])
 404             # logger.debug('k8sresources[0]:' + str(k8sclusters[0].to_dict()))
 405             logger.debug('k8sresources[0] cluster_api_endpoint: ' +
 406                          str(k8sclusters[0].cluster_api_endpoint))
 407             k8s_list.append(k8sclusters[0])
 408
 409         subclouds = self.getSubcloudList()
 410         logger.debug('subclouds numbers: %s' % len(subclouds))
 411         for subcloud in subclouds:
 412             try:
 413                 subcloud_stxclient = self.getSubcloudClient(
 414                     subcloud.subcloud_id)
 415                 systems = subcloud_stxclient.isystem.list()
 416                 k8sclusters = subcloud_stxclient.kube_cluster.list()
 417                 setattr(k8sclusters[0], 'cloud_name', systems[0].name)
 418                 k8sclusters[0] = self._setK8sCapabilities(k8sclusters[0])
 419                 logger.debug('k8sresources[0]:' +
 420                              str(k8sclusters[0].to_dict()))
 421                 # logger.debug('k8sresources[0] cluster_api_endpoint: ' +
 422                 #  str(k8sclusters[0].cluster_api_endpoint))
 423                 k8s_list.append(k8sclusters[0])
 424             except Exception as ex:
 425                 logger.warning('Failed get cgstclient of subcloud %s: %s' %
 426                                (subcloud.name, ex))
 427                 continue
 428
 429         return [ocloudModel.StxGenericModel(ResourceTypeEnum.DMS,
 430                 self._k8sconverter(k8sres), self._k8shasher(k8sres))
 431                 for k8sres in k8s_list if k8sres]
 432
 433     def getK8sDetail(self, name) -> ocloudModel.StxGenericModel:
 434         systems = self.stxclient.isystem.list()
 435         if not name:
 436             k8sclusters = self.stxclient.kube_cluster.list()
 437             # logger.debug("k8sresources[0]:" + str(k8sclusters[0].to_dict()))
 438             setattr(k8sclusters[0], 'cloud_name', systems[0].name)
 439             k8sclusters[0] = self._setK8sCapabilities(k8sclusters[0])
 440             k8scluster = k8sclusters.pop()
 441         else:
 442             sname = name.split('.')
 443             cloud_name = '.'.join(sname[:-1])
 444             k8s_name = sname[-1]
 445             if cloud_name == systems[0].name:
 446                 k8scluster = self.stxclient.kube_cluster.get(k8s_name)
 447                 setattr(k8scluster, 'cloud_name', cloud_name)
 448                 k8scluster = self._setK8sCapabilities(k8scluster)
 449             else:
 450                 subclouds = self.getSubcloudList()
 451                 subcloud_id = [
 452                     sub.subcloud_id for sub in subclouds
 453                     if sub.name == cloud_name][0]
 454                 subcloud_stxclient = self.getSubcloudClient(subcloud_id)
 455                 k8scluster = subcloud_stxclient.kube_cluster.get(k8s_name)
 456                 setattr(k8scluster, 'cloud_name', cloud_name)
 457                 k8scluster = self._setK8sCapabilities(k8scluster)
 458                 # logger.debug('k8sresources[0]:' +
 459                 #  str(k8sclusters[0].to_dict()))
 460                 # logger.debug('k8sresources[0] cluster_api_endpoint: ' +
 461                 #  str(k8sclusters[0].cluster_api_endpoint))
 462
 463         if not k8scluster:
 464             return None
 465         logger.debug('k8sresource:' + str(k8scluster.to_dict()))
 466         return ocloudModel.StxGenericModel(
 467             ResourceTypeEnum.DMS,
 468             self._k8sconverter(k8scluster), self._k8shasher(k8scluster))
 469
 470     def getCpuList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 471         hostid = filters.get('hostid', None)
 472         assert (hostid is not None), 'missing hostid to query icpu list'
 473         cpulist = self.stxclient.icpu.list(hostid)
 474         return [ocloudModel.StxGenericModel(
 475             ResourceTypeEnum.PSERVER_CPU,
 476             self._cpuconverter(cpures)) for cpures in cpulist if cpures]
 477
 478     def getCpu(self, id) -> ocloudModel.StxGenericModel:
 479         cpuinfo = self.stxclient.icpu.get(id)
 480         return ocloudModel.StxGenericModel(
 481             ResourceTypeEnum.PSERVER_CPU, self._cpuconverter(cpuinfo))
 482
 483     def getMemList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 484         hostid = filters.get('hostid', None)
 485         assert (hostid is not None), 'missing hostid to query imem list'
 486         memlist = self.stxclient.imemory.list(hostid)
 487         return [ocloudModel.StxGenericModel(
 488             ResourceTypeEnum.PSERVER_RAM,
 489             self._memconverter(memories)) for memories in memlist if memories]
 490
 491     def getMem(self, id) -> ocloudModel.StxGenericModel:
 492         meminfo = self.stxclient.imemory.get(id)
 493         return ocloudModel.StxGenericModel(
 494             ResourceTypeEnum.PSERVER_RAM, self._memconverter(meminfo))
 495
 496     def getEthernetList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 497         hostid = filters.get('hostid', None)
 498         assert (hostid is not None), 'missing hostid to query port list'
 499         ethlist = self.stxclient.ethernet_port.list(hostid)
 500         return [ocloudModel.StxGenericModel(
 501             ResourceTypeEnum.PSERVER_ETH,
 502             self._ethconverter(eth)) for eth in ethlist if eth]
 503
 504     def getEthernet(self, id) -> ocloudModel.StxGenericModel:
 505         ethinfo = self.stxclient.ethernet_port.get(id)
 506         return ocloudModel.StxGenericModel(
 507             ResourceTypeEnum.PSERVER_ETH, self._ethconverter(ethinfo))
 508
 509     def getIfList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 510         hostid = filters.get('hostid', None)
 511         assert (hostid is not None), 'missing hostid to query iinterface list'
 512         iflist = self.stxclient.iinterface.list(hostid)
 513         return [ocloudModel.StxGenericModel(
 514             ResourceTypeEnum.PSERVER_IF,
 515             self._ifconverter(ifs)) for ifs in iflist if ifs]
 516
 517     def getIf(self, id) -> ocloudModel.StxGenericModel:
 518         ifinfo = self.stxclient.iinterface.get(id)
 519         return ocloudModel.StxGenericModel(
 520             ResourceTypeEnum.PSERVER_IF, self._ifconverter(ifinfo))
 521
 522     def getPortList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 523         ifid = filters.get('interfaceid', None)
 524         assert (ifid is not None), 'missing interface id to query port list'
 525         portlist = self.stxclient.iinterface.list_ports(ifid)
 526         return [ocloudModel.StxGenericModel(
 527             ResourceTypeEnum.PSERVER_IF_PORT,
 528             port) for port in portlist if port]
 529
 530     def getPort(self, id) -> ocloudModel.StxGenericModel:
 531         portinfo = self.stxclient.port.get(id)
 532         return ocloudModel.StxGenericModel(
 533             ResourceTypeEnum.PSERVER_IF_PORT, portinfo)
 534
 535     def getDeviceList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 536         hostid = filters.get('hostid', None)
 537         assert (hostid is not None), 'missing hostid to query pci device list'
 538         pci_dev_list = self.stxclient.pci_device.list(hostid)
 539         return [ocloudModel.StxGenericModel(
 540             ResourceTypeEnum.PSERVER_PCI_DEV,
 541             self._devconverter(pci_dev))
 542             for pci_dev in pci_dev_list if pci_dev]
 543
 544     def getDevice(self, id) -> ocloudModel.StxGenericModel:
 545         pciinfo = self.stxclient.pci_device.get(id)
 546         return ocloudModel.StxGenericModel(
 547             ResourceTypeEnum.PSERVER_PCI_DEV, self._devconverter(pciinfo))
 548
 549     def getAcceleratorList(self, **filters) -> \
 550             List[ocloudModel.StxGenericModel]:
 551         hostid = filters.get('hostid', None)
 552         assert (hostid is not None), 'missing hostid to query accelerator list'
 553         pci_dev_list = self.stxclient.pci_device.list(hostid)
 554         acc_list = []
 555         for pci_dev in pci_dev_list:
 556             if pci_dev.pvendor_id in ['8086']:
 557                 if pci_dev.pdevice_id in ['0d5c', '0d5d']:
 558                     logger.info('Accelerator vendor ID: {}, device ID: {}'.
 559                                 format(pci_dev.pvendor_id, pci_dev.pdevice_id))
 560                     acc_list.append(ocloudModel.StxGenericModel(
 561                         ResourceTypeEnum.PSERVER_ACC,
 562                         self._devconverter(pci_dev)))
 563         return acc_list
 564
 565     def getAccelerator(self, id) -> ocloudModel.StxGenericModel:
 566         pciinfo = self.stxclient.pci_device.get(id)
 567         return ocloudModel.StxGenericModel(
 568             ResourceTypeEnum.PSERVER_ACC, self._devconverter(pciinfo))
 569
 570     def _getIsystems(self):
 571         return self.stxclient.isystem.list()
 572
 573     def _getIsystem(self, id=None):
 574         if id:
 575             return self.stxclient.isystem.get(id)
 576         else:
 577             isystems = self.stxclient.isystem.list()
 578             if len(isystems) != 1 and not id:
 579                 raise Exception('No system uuid was provided and '
 580                                 'more than one system exists in the account.')
 581             return isystems[0]
 582
 583     @ staticmethod
 584     def _respoolconverter(res_pool):
 585         setattr(res_pool, 'name', res_pool.region_name)
 586         return res_pool
 587
 588     @ staticmethod
 589     def _hostconverter(host):
 590         selected_keys = [
 591             "hostname", "personality", "id", "mgmt_ip", "mgmt_mac",
 592             "software_load", "capabilities",
 593             "operational", "availability", "administrative",
 594             "boot_device", "rootfs_device", "install_state", "subfunctions",
 595             "clock_synchronization", "max_cpu_mhz_allowed"
 596         ]
 597         content = host.to_dict()
 598         filtered = dict(
 599             filter(lambda item: item[0] in selected_keys, content.items()))
 600         setattr(host, 'filtered', filtered)
 601         setattr(host, 'name', host.hostname)
 602         return host
 603
 604     @ staticmethod
 605     def _labelconverter(label):
 606         selected_keys = [
 607             "uuid", "label_key", "label_value", "host_uuid"
 608         ]
 609         content = label.to_dict()
 610         print(content)
 611         filtered = dict(
 612             filter(lambda item: item[0] in selected_keys, content.items()))
 613         setattr(label, 'filtered', filtered)
 614         setattr(label, 'name', label.uuid.split(
 615             '-', 1)[0] + '-label-' + label.label_key)
 616         setattr(label, 'updated_at', None)
 617         setattr(label, 'created_at', None)
 618         return label
 619
 620     @ staticmethod
 621     def _cpuconverter(cpu):
 622         selected_keys = [
 623             "cpu", "core", "thread", "allocated_function", "numa_node",
 624             "cpu_model", "cpu_family"
 625         ]
 626         content = cpu.to_dict()
 627         filtered = dict(
 628             filter(lambda item: item[0] in selected_keys, content.items()))
 629         setattr(cpu, 'filtered', filtered)
 630         setattr(cpu, 'name', cpu.ihost_uuid.split(
 631             '-', 1)[0] + '-cpu-'+str(cpu.cpu))
 632         return cpu
 633
 634     @ staticmethod
 635     def _memconverter(mem):
 636         selected_keys = [
 637             "memtotal_mib", "memavail_mib", "vm_hugepages_use_1G",
 638             "vm_hugepages_possible_1G", "hugepages_configured",
 639             "vm_hugepages_avail_1G", "vm_hugepages_nr_1G",
 640             "vm_hugepages_nr_4K", "vm_hugepages_nr_2M",
 641             "vm_hugepages_possible_2M", "vm_hugepages_avail_2M",
 642             "platform_reserved_mib", "numa_node"
 643         ]
 644         content = mem.to_dict()
 645         filtered = dict(
 646             filter(lambda item: item[0] in selected_keys, content.items()))
 647         setattr(mem, 'filtered', filtered)
 648         setattr(mem, 'name', mem.ihost_uuid.split('-', 1)[0] +
 649                 '-mem-node-'+str(mem.numa_node))
 650         return mem
 651
 652     @ staticmethod
 653     def _ethconverter(eth):
 654         selected_keys = [
 655             "name", "namedisplay", "dev_id", "pdevice", "capabilities",
 656             "type", "driver", "mac", "numa_node",
 657             "pciaddr", "pclass", "psvendor", "psdevice",
 658             "sriov_totalvfs", "sriov_numvfs", "dpdksupport",
 659             "sriov_vf_driver", "sriov_vf_pdevice_id", "interface_uuid"
 660         ]
 661         content = eth.to_dict()
 662         filtered = dict(
 663             filter(lambda item: item[0] in selected_keys, content.items()))
 664         setattr(eth, 'filtered', filtered)
 665         setattr(eth, 'name', eth.host_uuid.split('-', 1)[0] + '-'+eth.name)
 666         setattr(eth, 'updated_at', None)
 667         setattr(eth, 'created_at', None)
 668         return eth
 669
 670     @ staticmethod
 671     def _ifconverter(ifs):
 672         selected_keys = [
 673             "ifname", "iftype", "imac", "vlan_id", "imtu",
 674             "ifclass", "uses", "max_tx_rate",
 675             "sriov_vf_driver", "sriov_numvfs", "ptp_role"
 676         ]
 677         content = ifs.to_dict()
 678         filtered = dict(
 679             filter(lambda item: item[0] in selected_keys, content.items()))
 680         setattr(ifs, 'filtered', filtered)
 681         setattr(ifs, 'name', ifs.ihost_uuid.split('-', 1)[0] + '-'+ifs.ifname)
 682         setattr(ifs, 'updated_at', None)
 683         setattr(ifs, 'created_at', None)
 684         return ifs
 685
 686     @ staticmethod
 687     def _devconverter(dev):
 688         selected_keys = [
 689             "name", "pdevice", "pciaddr", "pvendor_id", "pvendor",
 690             "pclass_id", "pclass", "psvendor", "psdevice",
 691             "sriov_totalvfs", "sriov_numvfs", "numa_node"
 692         ]
 693         content = dev.to_dict()
 694         filtered = dict(
 695             filter(lambda item: item[0] in selected_keys, content.items()))
 696         setattr(dev, 'filtered', filtered)
 697         setattr(dev, 'name', dev.host_uuid.split('-', 1)[0] + '-'+dev.name)
 698         return dev
 699
 700     @ staticmethod
 701     def _k8sconverter(cluster):
 702         setattr(cluster, 'name', cluster.cloud_name +
 703                 '.' + cluster.cluster_name)
 704         setattr(cluster, 'uuid',
 705                 uuid.uuid3(uuid.NAMESPACE_URL, cluster.cluster_name))
 706         setattr(cluster, 'updated_at', None)
 707         setattr(cluster, 'created_at', None)
 708         setattr(cluster, 'events', [])
 709         logger.debug('k8s cluster name/uuid:' +
 710                      cluster.name + '/' + str(cluster.uuid))
 711         return cluster
 712
 713     @ staticmethod
 714     def _k8shasher(cluster):
 715         return str(hash((cluster.cluster_name, cluster.cloud_name,
 716                          cluster.cluster_api_endpoint, cluster.admin_user,
 717                          cluster.capabilities)))