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 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 as get_stx_client
  27 from cgtsclient.exc import EndpointException
  28 from dcmanagerclient.api.client import client as get_dc_client
  29
  30 from o2common.helper import o2logging
  31 logger = o2logging.get_logger(__name__)
  32
  33
  34 CGTSCLIENT_ENDPOINT_ERROR_MSG = \
  35     'Must provide Keystone credentials or user-defined endpoint and token'
  36
  37
  38 class StxOcloudClient(BaseClient):
  39     def __init__(self, driver=None):
  40         super().__init__()
  41         self.driver = driver if driver else StxClientImp()
  42
  43     def _get(self, id) -> ocloudModel.StxGenericModel:
  44         return self.driver.getInstanceInfo()
  45
  46     def _list(self, **filters):
  47         return [self.driver.getInstanceInfo()]
  48
  49     def _set_stx_client(self):
  50         pass
  51
  52
  53 class StxResourcePoolClient(BaseClient):
  54     def __init__(self):
  55         super().__init__()
  56         self.driver = StxClientImp()
  57
  58     def _get(self, id) -> ocloudModel.StxGenericModel:
  59         return self.driver.getResourcePoolDetail(id)
  60
  61     def _list(self, **filters):
  62         return self.driver.getResourcePoolList(**filters)
  63
  64     def _set_stx_client(self):
  65         pass
  66
  67
  68 class StxDmsClient(BaseClient):
  69     def __init__(self):
  70         super().__init__()
  71         self.driver = StxClientImp()
  72
  73     def _get(self, name) -> ocloudModel.StxGenericModel:
  74         return self.driver.getK8sDetail(name)
  75
  76     def _list(self, **filters):
  77         return self.driver.getK8sList(**filters)
  78
  79     def _set_stx_client(self):
  80         pass
  81
  82
  83 class StxPserverClient(BaseClient):
  84     def __init__(self):
  85         super().__init__()
  86         self.driver = StxClientImp()
  87
  88     def _get(self, id) -> ocloudModel.StxGenericModel:
  89         return self.driver.getPserver(id)
  90
  91     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
  92         filters['resourcepoolid']
  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.warning(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.warning(os_client_args)
 242                 config_client = get_stx_client(**os_client_args)
 243             else:
 244                 raise ValueError('Stx endpoint exception: %s' % msg)
 245         else:
 246             raise ValueError('cgtsclient get subcloud client failed')
 247         return config_client
 248
 249     def setStxClient(self, resource_pool_id):
 250         systems = self.stxclient.isystem.list()
 251         if resource_pool_id == systems[0].uuid:
 252             logger.debug('Stx Client not change: %s' % resource_pool_id)
 253             return
 254
 255         subclouds = self.getSubcloudList()
 256         for subcloud in subclouds:
 257             subcloud_stxclient = self.getSubcloudClient(subcloud.subcloud_id)
 258             systems = subcloud_stxclient.isystem.list()
 259             # logger.debug('subcloud %s id: %s' %
 260             #  (systems[0].name, systems[0].uuid))
 261             # logger.debug('subcloud: %s' % (systems[0].to_dict()))
 262             if resource_pool_id == systems[0].uuid:
 263                 self.stxclient = subcloud_stxclient
 264
 265     def getInstanceInfo(self) -> ocloudModel.StxGenericModel:
 266         systems = self.stxclient.isystem.list()
 267         logger.debug('systems:' + str(systems[0].to_dict()))
 268         # logger.debug('systems[0] uuid: ' + str(systems[0].uuid))
 269         return ocloudModel.StxGenericModel(
 270             ResourceTypeEnum.OCLOUD, systems[0]) if systems else None
 271
 272     def getSubcloudList(self):
 273         subs = self.dcclient.subcloud_manager.list_subclouds()
 274         known_subs = [sub for sub in subs if sub.sync_status != 'unknown']
 275         return known_subs
 276
 277     def getResourcePoolList(self, **filters) -> List[
 278             ocloudModel.StxGenericModel]:
 279         systems = self.stxclient.isystem.list()
 280         logger.debug('system controller distributed_cloud_role:' +
 281                      str(systems[0].distributed_cloud_role))
 282
 283         if systems[0].distributed_cloud_role is None or \
 284                 systems[0].distributed_cloud_role != 'systemcontroller':
 285             return [ocloudModel.StxGenericModel(
 286                 ResourceTypeEnum.RESOURCE_POOL,
 287                 self._respoolconverter(systems[0]))]
 288
 289         pools = []
 290         if config.get_system_controller_as_respool():
 291             pools.append(systems[0])
 292
 293         subclouds = self.getSubcloudList()
 294         logger.debug('subclouds numbers: %s' % len(subclouds))
 295         for subcloud in subclouds:
 296             try:
 297                 subcloud_stxclient = self.getSubcloudClient(
 298                     subcloud.subcloud_id)
 299                 systems = subcloud_stxclient.isystem.list()
 300                 logger.debug('systems:' + str(systems[0].to_dict()))
 301                 pools.append(systems[0])
 302             except Exception as ex:
 303                 logger.warning('Failed get cgstclient of subcloud %s: %s' %
 304                                (subcloud.name, ex))
 305                 continue
 306
 307         return [ocloudModel.StxGenericModel(
 308             ResourceTypeEnum.RESOURCE_POOL,
 309                 self._respoolconverter(
 310                     respool)) for respool in pools if respool]
 311
 312     def getResourcePoolDetail(self, id):
 313         self.setStxClient(id)
 314         systems = self.stxclient.isystem.list()
 315         logger.debug('systems:' + str(systems[0].to_dict()))
 316         return ocloudModel.StxGenericModel(
 317             ResourceTypeEnum.RESOURCE_POOL, systems[0]) if systems else None
 318
 319     def getPserverList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 320         hosts = self.stxclient.ihost.list()
 321         logger.debug('host 1:' + str(hosts[0].to_dict()))
 322         return [ocloudModel.StxGenericModel(
 323             ResourceTypeEnum.PSERVER, self._hostconverter(host))
 324             for host in hosts if host and (host.availability == 'available'
 325                                            or host.availability == 'degraded')]
 326
 327     def getPserver(self, id) -> ocloudModel.StxGenericModel:
 328         host = self.stxclient.ihost.get(id)
 329         logger.debug('host:' + str(host.to_dict()))
 330         return ocloudModel.StxGenericModel(
 331             ResourceTypeEnum.PSERVER, self._hostconverter(host))
 332
 333     def getK8sList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 334         systems = self.stxclient.isystem.list()
 335         logger.debug('system controller distributed_cloud_role:' +
 336                      str(systems[0].distributed_cloud_role))
 337
 338         if systems[0].distributed_cloud_role is None or \
 339                 systems[0].distributed_cloud_role != 'systemcontroller':
 340             k8sclusters = self.stxclient.kube_cluster.list()
 341             setattr(k8sclusters[0], 'cloud_name', systems[0].name)
 342             logger.debug('k8sresources[0]:' + str(k8sclusters[0].to_dict()))
 343             # logger.debug('k8sresources[0] cluster_api_endpoint: ' +
 344             #  str(k8sclusters[0].cluster_api_endpoint))
 345             return [ocloudModel.StxGenericModel(
 346                 ResourceTypeEnum.DMS,
 347                 self._k8sconverter(k8sres), self._k8shasher(k8sres))
 348                 for k8sres in k8sclusters if k8sres]
 349
 350         k8s_list = []
 351         if config.get_system_controller_as_respool():
 352             k8sclusters = self.stxclient.kube_cluster.list()
 353             setattr(k8sclusters[0], 'cloud_name', systems[0].name)
 354             logger.debug('k8sresources[0]:' + str(k8sclusters[0].to_dict()))
 355             # logger.debug('k8sresources[0] cluster_api_endpoint: ' +
 356             #  str(k8sclusters[0].cluster_api_endpoint))
 357             k8s_list.append(k8sclusters[0])
 358
 359         subclouds = self.getSubcloudList()
 360         logger.debug('subclouds numbers: %s' % len(subclouds))
 361         for subcloud in subclouds:
 362             try:
 363                 subcloud_stxclient = self.getSubcloudClient(
 364                     subcloud.subcloud_id)
 365                 systems = subcloud_stxclient.isystem.list()
 366                 k8sclusters = subcloud_stxclient.kube_cluster.list()
 367                 setattr(k8sclusters[0], 'cloud_name', systems[0].name)
 368                 logger.debug('k8sresources[0]:' +
 369                              str(k8sclusters[0].to_dict()))
 370                 # logger.debug('k8sresources[0] cluster_api_endpoint: ' +
 371                 #  str(k8sclusters[0].cluster_api_endpoint))
 372                 k8s_list.append(k8sclusters[0])
 373             except Exception as ex:
 374                 logger.warning('Failed get cgstclient of subcloud %s: %s' %
 375                                (subcloud.name, ex))
 376                 continue
 377
 378         return [ocloudModel.StxGenericModel(ResourceTypeEnum.DMS,
 379                 self._k8sconverter(k8sres), self._k8shasher(k8sres))
 380                 for k8sres in k8s_list if k8sres]
 381
 382     def getK8sDetail(self, name) -> ocloudModel.StxGenericModel:
 383         systems = self.stxclient.isystem.list()
 384         if not name:
 385             k8sclusters = self.stxclient.kube_cluster.list()
 386             # logger.debug("k8sresources[0]:" + str(k8sclusters[0].to_dict()))
 387             setattr(k8sclusters[0], 'cloud_name', systems[0].name)
 388             k8scluster = k8sclusters.pop()
 389         else:
 390             sname = name.split('.')
 391             cloud_name = '.'.join(sname[:-1])
 392             k8s_name = sname[-1]
 393             if cloud_name == systems[0].name:
 394                 k8scluster = self.stxclient.kube_cluster.get(k8s_name)
 395                 setattr(k8scluster, 'cloud_name', cloud_name)
 396             else:
 397                 subclouds = self.getSubcloudList()
 398                 subcloud_id = [
 399                     sub.subcloud_id for sub in subclouds
 400                     if sub.name == cloud_name][0]
 401                 subcloud_stxclient = self.getSubcloudClient(subcloud_id)
 402                 k8scluster = subcloud_stxclient.kube_cluster.get(k8s_name)
 403                 setattr(k8scluster, 'cloud_name', cloud_name)
 404                 # logger.debug('k8sresources[0]:' +
 405                 #  str(k8sclusters[0].to_dict()))
 406                 # logger.debug('k8sresources[0] cluster_api_endpoint: ' +
 407                 #  str(k8sclusters[0].cluster_api_endpoint))
 408
 409         if not k8scluster:
 410             return None
 411         logger.debug('k8sresource:' + str(k8scluster.to_dict()))
 412         return ocloudModel.StxGenericModel(
 413             ResourceTypeEnum.DMS,
 414             self._k8sconverter(k8scluster), self._k8shasher(k8scluster))
 415
 416     def getCpuList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 417         hostid = filters.get('hostid', None)
 418         assert (hostid is not None), 'missing hostid to query icpu list'
 419         cpulist = self.stxclient.icpu.list(hostid)
 420         return [ocloudModel.StxGenericModel(
 421             ResourceTypeEnum.PSERVER_CPU,
 422             self._cpuconverter(cpures)) for cpures in cpulist if cpures]
 423
 424     def getCpu(self, id) -> ocloudModel.StxGenericModel:
 425         cpuinfo = self.stxclient.icpu.get(id)
 426         return ocloudModel.StxGenericModel(
 427             ResourceTypeEnum.PSERVER_CPU, self._cpuconverter(cpuinfo))
 428
 429     def getMemList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 430         hostid = filters.get('hostid', None)
 431         assert (hostid is not None), 'missing hostid to query imem list'
 432         memlist = self.stxclient.imemory.list(hostid)
 433         return [ocloudModel.StxGenericModel(
 434             ResourceTypeEnum.PSERVER_RAM,
 435             self._memconverter(memories)) for memories in memlist if memories]
 436
 437     def getMem(self, id) -> ocloudModel.StxGenericModel:
 438         meminfo = self.stxclient.imemory.get(id)
 439         return ocloudModel.StxGenericModel(
 440             ResourceTypeEnum.PSERVER_RAM, self._memconverter(meminfo))
 441
 442     def getEthernetList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 443         hostid = filters.get('hostid', None)
 444         assert (hostid is not None), 'missing hostid to query port list'
 445         ethlist = self.stxclient.ethernet_port.list(hostid)
 446         return [ocloudModel.StxGenericModel(
 447             ResourceTypeEnum.PSERVER_ETH,
 448             self._ethconverter(eth)) for eth in ethlist if eth]
 449
 450     def getEthernet(self, id) -> ocloudModel.StxGenericModel:
 451         ethinfo = self.stxclient.ethernet_port.get(id)
 452         return ocloudModel.StxGenericModel(
 453             ResourceTypeEnum.PSERVER_ETH, self._ethconverter(ethinfo))
 454
 455     def getIfList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 456         hostid = filters.get('hostid', None)
 457         assert (hostid is not None), 'missing hostid to query iinterface list'
 458         iflist = self.stxclient.iinterface.list(hostid)
 459         return [ocloudModel.StxGenericModel(
 460             ResourceTypeEnum.PSERVER_IF,
 461             self._ifconverter(ifs)) for ifs in iflist if ifs]
 462
 463     def getIf(self, id) -> ocloudModel.StxGenericModel:
 464         ifinfo = self.stxclient.iinterface.get(id)
 465         return ocloudModel.StxGenericModel(
 466             ResourceTypeEnum.PSERVER_IF, self._ifconverter(ifinfo))
 467
 468     def getPortList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 469         ifid = filters.get('interfaceid', None)
 470         assert (ifid is not None), 'missing interface id to query port list'
 471         portlist = self.stxclient.iinterface.list_ports(ifid)
 472         return [ocloudModel.StxGenericModel(
 473             ResourceTypeEnum.PSERVER_IF_PORT,
 474             port) for port in portlist if port]
 475
 476     def getPort(self, id) -> ocloudModel.StxGenericModel:
 477         portinfo = self.stxclient.port.get(id)
 478         return ocloudModel.StxGenericModel(
 479             ResourceTypeEnum.PSERVER_IF_PORT, portinfo)
 480
 481     def getDeviceList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 482         hostid = filters.get('hostid', None)
 483         assert (hostid is not None), 'missing hostid to query pci device list'
 484         pci_dev_list = self.stxclient.pci_device.list(hostid)
 485         return [ocloudModel.StxGenericModel(
 486             ResourceTypeEnum.PSERVER_PCI_DEV,
 487             self._devconverter(pci_dev))
 488             for pci_dev in pci_dev_list if pci_dev]
 489
 490     def getDevice(self, id) -> ocloudModel.StxGenericModel:
 491         pciinfo = self.stxclient.pci_device.get(id)
 492         return ocloudModel.StxGenericModel(
 493             ResourceTypeEnum.PSERVER_PCI_DEV, self._devconverter(pciinfo))
 494
 495     def getAcceleratorList(self, **filters) -> \
 496             List[ocloudModel.StxGenericModel]:
 497         hostid = filters.get('hostid', None)
 498         assert (hostid is not None), 'missing hostid to query accelerator list'
 499         pci_dev_list = self.stxclient.pci_device.list(hostid)
 500         acc_list = []
 501         for pci_dev in pci_dev_list:
 502             if pci_dev.pvendor_id in ['8086']:
 503                 if pci_dev.pdevice_id in ['0d5c', '0d5d']:
 504                     logger.info('Accelerator vendor ID: {}, device ID: {}'.
 505                                 format(pci_dev.pvendor_id, pci_dev.pdevice_id))
 506                     acc_list.append(ocloudModel.StxGenericModel(
 507                         ResourceTypeEnum.PSERVER_ACC,
 508                         self._devconverter(pci_dev)))
 509         return acc_list
 510
 511     def getAccelerator(self, id) -> ocloudModel.StxGenericModel:
 512         pciinfo = self.stxclient.pci_device.get(id)
 513         return ocloudModel.StxGenericModel(
 514             ResourceTypeEnum.PSERVER_ACC, self._devconverter(pciinfo))
 515
 516     def _getIsystems(self):
 517         return self.stxclient.isystem.list()
 518
 519     def _getIsystem(self, id=None):
 520         if id:
 521             return self.stxclient.isystem.get(id)
 522         else:
 523             isystems = self.stxclient.isystem.list()
 524             if len(isystems) != 1 and not id:
 525                 raise Exception('No system uuid was provided and '
 526                                 'more than one system exists in the account.')
 527             return isystems[0]
 528
 529     @ staticmethod
 530     def _respoolconverter(res_pool):
 531         setattr(res_pool, 'name', res_pool.region_name)
 532         return res_pool
 533
 534     @ staticmethod
 535     def _hostconverter(host):
 536         setattr(host, 'name', host.hostname)
 537         return host
 538
 539     @ staticmethod
 540     def _cpuconverter(cpu):
 541         setattr(cpu, 'name', cpu.ihost_uuid.split(
 542             '-', 1)[0] + '-cpu-'+str(cpu.cpu))
 543         return cpu
 544
 545     @ staticmethod
 546     def _memconverter(mem):
 547         setattr(mem, 'name', mem.ihost_uuid.split('-', 1)[0] +
 548                 '-mem-node-'+str(mem.numa_node))
 549         return mem
 550
 551     @ staticmethod
 552     def _ethconverter(eth):
 553         setattr(eth, 'name', eth.host_uuid.split('-', 1)[0] + '-'+eth.name)
 554         setattr(eth, 'updated_at', None)
 555         setattr(eth, 'created_at', None)
 556         return eth
 557
 558     @ staticmethod
 559     def _ifconverter(ifs):
 560         setattr(ifs, 'name', ifs.ihost_uuid.split('-', 1)[0] + '-'+ifs.ifname)
 561         setattr(ifs, 'updated_at', None)
 562         setattr(ifs, 'created_at', None)
 563         return ifs
 564
 565     @ staticmethod
 566     def _devconverter(dev):
 567         setattr(dev, 'name', dev.host_uuid.split('-', 1)[0] + '-'+dev.name)
 568         return dev
 569
 570     @ staticmethod
 571     def _k8sconverter(cluster):
 572         setattr(cluster, 'name', cluster.cloud_name +
 573                 '.' + cluster.cluster_name)
 574         setattr(cluster, 'uuid',
 575                 uuid.uuid3(uuid.NAMESPACE_URL, cluster.name))
 576         setattr(cluster, 'updated_at', None)
 577         setattr(cluster, 'created_at', None)
 578         setattr(cluster, 'events', [])
 579         logger.debug('k8s cluster name/uuid:' +
 580                      cluster.name + '/' + str(cluster.uuid))
 581         return cluster
 582
 583     @ staticmethod
 584     def _k8shasher(cluster):
 585         return str(hash((cluster.cluster_name, cluster.cloud_name,
 586                          cluster.cluster_api_endpoint, cluster.admin_user)))