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 typing import List
  19 # Optional,  Set
  20
  21 from cgtsclient.client import get_client as get_stx_client
  22 from cgtsclient.exc import EndpointException
  23 from dcmanagerclient.api.client import client as get_dc_client
  24
  25 from o2common.config import config
  26 from o2common.service.client.base_client import BaseClient
  27 from o2ims.domain import stx_object as ocloudModel
  28 from o2ims.domain.resource_type import ResourceTypeEnum
  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         return self.driver.getPserverList(**filters)
  93
  94     def _set_stx_client(self):
  95         self.driver.setStxClient(self._pool_id)
  96
  97
  98 class StxCpuClient(BaseClient):
  99     def __init__(self):
 100         super().__init__()
 101         # self._pserver_id = pserver_id
 102         self.driver = StxClientImp()
 103
 104     def _get(self, id) -> ocloudModel.StxGenericModel:
 105         return self.driver.getCpu(id)
 106
 107     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
 108         return self.driver.getCpuList(**filters)
 109
 110     def _set_stx_client(self):
 111         self.driver.setStxClient(self._pool_id)
 112
 113
 114 class StxMemClient(BaseClient):
 115     def __init__(self):
 116         super().__init__()
 117         self.driver = StxClientImp()
 118
 119     def _get(self, id) -> ocloudModel.StxGenericModel:
 120         return self.driver.getMem(id)
 121
 122     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
 123         return self.driver.getMemList(**filters)
 124
 125     def _set_stx_client(self):
 126         self.driver.setStxClient(self._pool_id)
 127
 128
 129 class StxEthClient(BaseClient):
 130     def __init__(self):
 131         super().__init__()
 132         self.driver = StxClientImp()
 133
 134     def _get(self, id) -> ocloudModel.StxGenericModel:
 135         return self.driver.getEthernet(id)
 136
 137     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
 138         return self.driver.getEthernetList(**filters)
 139
 140     def _set_stx_client(self):
 141         self.driver.setStxClient(self._pool_id)
 142
 143
 144 class StxIfClient(BaseClient):
 145     def __init__(self):
 146         super().__init__()
 147         self.driver = StxClientImp()
 148
 149     def _get(self, id) -> ocloudModel.StxGenericModel:
 150         return self.driver.getIf(id)
 151
 152     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
 153         return self.driver.getIfList(**filters)
 154
 155     def _set_stx_client(self):
 156         self.driver.setStxClient(self._pool_id)
 157
 158
 159 class StxIfPortClient(BaseClient):
 160     def __init__(self):
 161         super().__init__()
 162         self.driver = StxClientImp()
 163
 164     def _get(self, id) -> ocloudModel.StxGenericModel:
 165         return self.driver.getPort(id)
 166
 167     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
 168         return self.driver.getPortList(**filters)
 169
 170     def _set_stx_client(self):
 171         self.driver.setStxClient(self._pool_id)
 172
 173
 174 class StxDevClient(BaseClient):
 175     def __init__(self):
 176         super().__init__()
 177         self.driver = StxClientImp()
 178
 179     def _get(self, id) -> ocloudModel.StxGenericModel:
 180         return self.driver.getDevice(id)
 181
 182     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
 183         return self.driver.getDeviceList(**filters)
 184
 185     def _set_stx_client(self):
 186         self.driver.setStxClient(self._pool_id)
 187
 188
 189 class StxAccClient(BaseClient):
 190     def __init__(self):
 191         super().__init__()
 192         self.driver = StxClientImp()
 193
 194     def _get(self, id) -> ocloudModel.StxGenericModel:
 195         return self.driver.getAccelerator(id)
 196
 197     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
 198         return self.driver.getAcceleratorList(**filters)
 199
 200     def _set_stx_client(self):
 201         self.driver.setStxClient(self._pool_id)
 202
 203
 204 # internal driver which implement client call to Stx Standalone and DC instance
 205 class StxClientImp(object):
 206     def __init__(self, stx_client=None, dc_client=None):
 207         super().__init__()
 208         self.stxclient = stx_client if stx_client else self.getStxClient()
 209         self.dcclient = dc_client if dc_client else self.getDcmanagerClient()
 210         # if subcloud_id is not None:
 211         # self.stxclient = self.getSubcloudClient(subcloud_id)
 212
 213     def getStxClient(self):
 214         os_client_args = config.get_stx_access_info()
 215         config_client = get_stx_client(**os_client_args)
 216         return config_client
 217
 218     def getDcmanagerClient(self):
 219         os_client_args = config.get_dc_access_info()
 220         config_client = get_dc_client(**os_client_args)
 221         return config_client
 222
 223     def getSubcloudClient(self, subcloud_id):
 224         subcloud = self.dcclient.subcloud_manager.\
 225             subcloud_additional_details(subcloud_id)
 226         logger.debug('subcloud name: %s, oam_floating_ip: %s' %
 227                      (subcloud[0].name, subcloud[0].oam_floating_ip))
 228         try:
 229             os_client_args = config.get_stx_access_info(
 230                 region_name=subcloud[0].name,
 231                 subcloud_hostname=subcloud[0].oam_floating_ip)
 232             # logger.info(os_client_args)
 233             config_client = get_stx_client(**os_client_args)
 234         except EndpointException as e:
 235             msg = e.format_message()
 236             if CGTSCLIENT_ENDPOINT_ERROR_MSG in msg:
 237                 os_client_args = config.get_stx_access_info(
 238                     region_name=subcloud[0].name, sub_is_https=True,
 239                     subcloud_hostname=subcloud[0].oam_floating_ip)
 240                 # logger.info(os_client_args)
 241                 config_client = get_stx_client(**os_client_args)
 242             else:
 243                 raise ValueError('Stx endpoint exception: %s' % msg)
 244         except Exception:
 245             raise ValueError('cgtsclient get subcloud client failed')
 246
 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,
 318             self._respoolconverter(systems[0])) if systems else None
 319
 320     def getPserverList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 321         hosts = self.stxclient.ihost.list()
 322         logger.debug('host 1:' + str(hosts[0].to_dict()))
 323         return [ocloudModel.StxGenericModel(
 324             ResourceTypeEnum.PSERVER, self._hostconverter(host))
 325             for host in hosts if host and (host.availability == 'available'
 326                                            or host.availability == 'online'
 327                                            or host.availability == 'degraded')]
 328
 329     def getPserver(self, id) -> ocloudModel.StxGenericModel:
 330         host = self.stxclient.ihost.get(id)
 331         logger.debug('host:' + str(host.to_dict()))
 332         return ocloudModel.StxGenericModel(
 333             ResourceTypeEnum.PSERVER, self._hostconverter(host))
 334
 335     def getK8sList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 336         systems = self.stxclient.isystem.list()
 337         logger.debug('system controller distributed_cloud_role:' +
 338                      str(systems[0].distributed_cloud_role))
 339
 340         if systems[0].distributed_cloud_role is None or \
 341                 systems[0].distributed_cloud_role != 'systemcontroller':
 342             k8sclusters = self.stxclient.kube_cluster.list()
 343             setattr(k8sclusters[0], 'cloud_name', systems[0].name)
 344             logger.debug('k8sresources[0]:' + str(k8sclusters[0].to_dict()))
 345             # logger.debug('k8sresources[0] cluster_api_endpoint: ' +
 346             #  str(k8sclusters[0].cluster_api_endpoint))
 347             return [ocloudModel.StxGenericModel(
 348                 ResourceTypeEnum.DMS,
 349                 self._k8sconverter(k8sres), self._k8shasher(k8sres))
 350                 for k8sres in k8sclusters if k8sres]
 351
 352         k8s_list = []
 353         if config.get_system_controller_as_respool():
 354             k8sclusters = self.stxclient.kube_cluster.list()
 355             setattr(k8sclusters[0], 'cloud_name', systems[0].name)
 356             logger.debug('k8sresources[0]:' + str(k8sclusters[0].to_dict()))
 357             # logger.debug('k8sresources[0] cluster_api_endpoint: ' +
 358             #  str(k8sclusters[0].cluster_api_endpoint))
 359             k8s_list.append(k8sclusters[0])
 360
 361         subclouds = self.getSubcloudList()
 362         logger.debug('subclouds numbers: %s' % len(subclouds))
 363         for subcloud in subclouds:
 364             try:
 365                 subcloud_stxclient = self.getSubcloudClient(
 366                     subcloud.subcloud_id)
 367                 systems = subcloud_stxclient.isystem.list()
 368                 k8sclusters = subcloud_stxclient.kube_cluster.list()
 369                 setattr(k8sclusters[0], 'cloud_name', systems[0].name)
 370                 logger.debug('k8sresources[0]:' +
 371                              str(k8sclusters[0].to_dict()))
 372                 # logger.debug('k8sresources[0] cluster_api_endpoint: ' +
 373                 #  str(k8sclusters[0].cluster_api_endpoint))
 374                 k8s_list.append(k8sclusters[0])
 375             except Exception as ex:
 376                 logger.warning('Failed get cgstclient of subcloud %s: %s' %
 377                                (subcloud.name, ex))
 378                 continue
 379
 380         return [ocloudModel.StxGenericModel(ResourceTypeEnum.DMS,
 381                 self._k8sconverter(k8sres), self._k8shasher(k8sres))
 382                 for k8sres in k8s_list if k8sres]
 383
 384     def getK8sDetail(self, name) -> ocloudModel.StxGenericModel:
 385         systems = self.stxclient.isystem.list()
 386         if not name:
 387             k8sclusters = self.stxclient.kube_cluster.list()
 388             # logger.debug("k8sresources[0]:" + str(k8sclusters[0].to_dict()))
 389             setattr(k8sclusters[0], 'cloud_name', systems[0].name)
 390             k8scluster = k8sclusters.pop()
 391         else:
 392             sname = name.split('.')
 393             cloud_name = '.'.join(sname[:-1])
 394             k8s_name = sname[-1]
 395             if cloud_name == systems[0].name:
 396                 k8scluster = self.stxclient.kube_cluster.get(k8s_name)
 397                 setattr(k8scluster, 'cloud_name', cloud_name)
 398             else:
 399                 subclouds = self.getSubcloudList()
 400                 subcloud_id = [
 401                     sub.subcloud_id for sub in subclouds
 402                     if sub.name == cloud_name][0]
 403                 subcloud_stxclient = self.getSubcloudClient(subcloud_id)
 404                 k8scluster = subcloud_stxclient.kube_cluster.get(k8s_name)
 405                 setattr(k8scluster, 'cloud_name', cloud_name)
 406                 # logger.debug('k8sresources[0]:' +
 407                 #  str(k8sclusters[0].to_dict()))
 408                 # logger.debug('k8sresources[0] cluster_api_endpoint: ' +
 409                 #  str(k8sclusters[0].cluster_api_endpoint))
 410
 411         if not k8scluster:
 412             return None
 413         logger.debug('k8sresource:' + str(k8scluster.to_dict()))
 414         return ocloudModel.StxGenericModel(
 415             ResourceTypeEnum.DMS,
 416             self._k8sconverter(k8scluster), self._k8shasher(k8scluster))
 417
 418     def getCpuList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 419         hostid = filters.get('hostid', None)
 420         assert (hostid is not None), 'missing hostid to query icpu list'
 421         cpulist = self.stxclient.icpu.list(hostid)
 422         return [ocloudModel.StxGenericModel(
 423             ResourceTypeEnum.PSERVER_CPU,
 424             self._cpuconverter(cpures)) for cpures in cpulist if cpures]
 425
 426     def getCpu(self, id) -> ocloudModel.StxGenericModel:
 427         cpuinfo = self.stxclient.icpu.get(id)
 428         return ocloudModel.StxGenericModel(
 429             ResourceTypeEnum.PSERVER_CPU, self._cpuconverter(cpuinfo))
 430
 431     def getMemList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 432         hostid = filters.get('hostid', None)
 433         assert (hostid is not None), 'missing hostid to query imem list'
 434         memlist = self.stxclient.imemory.list(hostid)
 435         return [ocloudModel.StxGenericModel(
 436             ResourceTypeEnum.PSERVER_RAM,
 437             self._memconverter(memories)) for memories in memlist if memories]
 438
 439     def getMem(self, id) -> ocloudModel.StxGenericModel:
 440         meminfo = self.stxclient.imemory.get(id)
 441         return ocloudModel.StxGenericModel(
 442             ResourceTypeEnum.PSERVER_RAM, self._memconverter(meminfo))
 443
 444     def getEthernetList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 445         hostid = filters.get('hostid', None)
 446         assert (hostid is not None), 'missing hostid to query port list'
 447         ethlist = self.stxclient.ethernet_port.list(hostid)
 448         return [ocloudModel.StxGenericModel(
 449             ResourceTypeEnum.PSERVER_ETH,
 450             self._ethconverter(eth)) for eth in ethlist if eth]
 451
 452     def getEthernet(self, id) -> ocloudModel.StxGenericModel:
 453         ethinfo = self.stxclient.ethernet_port.get(id)
 454         return ocloudModel.StxGenericModel(
 455             ResourceTypeEnum.PSERVER_ETH, self._ethconverter(ethinfo))
 456
 457     def getIfList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 458         hostid = filters.get('hostid', None)
 459         assert (hostid is not None), 'missing hostid to query iinterface list'
 460         iflist = self.stxclient.iinterface.list(hostid)
 461         return [ocloudModel.StxGenericModel(
 462             ResourceTypeEnum.PSERVER_IF,
 463             self._ifconverter(ifs)) for ifs in iflist if ifs]
 464
 465     def getIf(self, id) -> ocloudModel.StxGenericModel:
 466         ifinfo = self.stxclient.iinterface.get(id)
 467         return ocloudModel.StxGenericModel(
 468             ResourceTypeEnum.PSERVER_IF, self._ifconverter(ifinfo))
 469
 470     def getPortList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 471         ifid = filters.get('interfaceid', None)
 472         assert (ifid is not None), 'missing interface id to query port list'
 473         portlist = self.stxclient.iinterface.list_ports(ifid)
 474         return [ocloudModel.StxGenericModel(
 475             ResourceTypeEnum.PSERVER_IF_PORT,
 476             port) for port in portlist if port]
 477
 478     def getPort(self, id) -> ocloudModel.StxGenericModel:
 479         portinfo = self.stxclient.port.get(id)
 480         return ocloudModel.StxGenericModel(
 481             ResourceTypeEnum.PSERVER_IF_PORT, portinfo)
 482
 483     def getDeviceList(self, **filters) -> List[ocloudModel.StxGenericModel]:
 484         hostid = filters.get('hostid', None)
 485         assert (hostid is not None), 'missing hostid to query pci device list'
 486         pci_dev_list = self.stxclient.pci_device.list(hostid)
 487         return [ocloudModel.StxGenericModel(
 488             ResourceTypeEnum.PSERVER_PCI_DEV,
 489             self._devconverter(pci_dev))
 490             for pci_dev in pci_dev_list if pci_dev]
 491
 492     def getDevice(self, id) -> ocloudModel.StxGenericModel:
 493         pciinfo = self.stxclient.pci_device.get(id)
 494         return ocloudModel.StxGenericModel(
 495             ResourceTypeEnum.PSERVER_PCI_DEV, self._devconverter(pciinfo))
 496
 497     def getAcceleratorList(self, **filters) -> \
 498             List[ocloudModel.StxGenericModel]:
 499         hostid = filters.get('hostid', None)
 500         assert (hostid is not None), 'missing hostid to query accelerator list'
 501         pci_dev_list = self.stxclient.pci_device.list(hostid)
 502         acc_list = []
 503         for pci_dev in pci_dev_list:
 504             if pci_dev.pvendor_id in ['8086']:
 505                 if pci_dev.pdevice_id in ['0d5c', '0d5d']:
 506                     logger.info('Accelerator vendor ID: {}, device ID: {}'.
 507                                 format(pci_dev.pvendor_id, pci_dev.pdevice_id))
 508                     acc_list.append(ocloudModel.StxGenericModel(
 509                         ResourceTypeEnum.PSERVER_ACC,
 510                         self._devconverter(pci_dev)))
 511         return acc_list
 512
 513     def getAccelerator(self, id) -> ocloudModel.StxGenericModel:
 514         pciinfo = self.stxclient.pci_device.get(id)
 515         return ocloudModel.StxGenericModel(
 516             ResourceTypeEnum.PSERVER_ACC, self._devconverter(pciinfo))
 517
 518     def _getIsystems(self):
 519         return self.stxclient.isystem.list()
 520
 521     def _getIsystem(self, id=None):
 522         if id:
 523             return self.stxclient.isystem.get(id)
 524         else:
 525             isystems = self.stxclient.isystem.list()
 526             if len(isystems) != 1 and not id:
 527                 raise Exception('No system uuid was provided and '
 528                                 'more than one system exists in the account.')
 529             return isystems[0]
 530
 531     @ staticmethod
 532     def _respoolconverter(res_pool):
 533         setattr(res_pool, 'name', res_pool.region_name)
 534         return res_pool
 535
 536     @ staticmethod
 537     def _hostconverter(host):
 538         setattr(host, 'name', host.hostname)
 539         return host
 540
 541     @ staticmethod
 542     def _cpuconverter(cpu):
 543         setattr(cpu, 'name', cpu.ihost_uuid.split(
 544             '-', 1)[0] + '-cpu-'+str(cpu.cpu))
 545         return cpu
 546
 547     @ staticmethod
 548     def _memconverter(mem):
 549         setattr(mem, 'name', mem.ihost_uuid.split('-', 1)[0] +
 550                 '-mem-node-'+str(mem.numa_node))
 551         return mem
 552
 553     @ staticmethod
 554     def _ethconverter(eth):
 555         setattr(eth, 'name', eth.host_uuid.split('-', 1)[0] + '-'+eth.name)
 556         setattr(eth, 'updated_at', None)
 557         setattr(eth, 'created_at', None)
 558         return eth
 559
 560     @ staticmethod
 561     def _ifconverter(ifs):
 562         setattr(ifs, 'name', ifs.ihost_uuid.split('-', 1)[0] + '-'+ifs.ifname)
 563         setattr(ifs, 'updated_at', None)
 564         setattr(ifs, 'created_at', None)
 565         return ifs
 566
 567     @ staticmethod
 568     def _devconverter(dev):
 569         setattr(dev, 'name', dev.host_uuid.split('-', 1)[0] + '-'+dev.name)
 570         return dev
 571
 572     @ staticmethod
 573     def _k8sconverter(cluster):
 574         setattr(cluster, 'name', cluster.cloud_name +
 575                 '.' + cluster.cluster_name)
 576         setattr(cluster, 'uuid',
 577                 uuid.uuid3(uuid.NAMESPACE_URL, cluster.name))
 578         setattr(cluster, 'updated_at', None)
 579         setattr(cluster, 'created_at', None)
 580         setattr(cluster, 'events', [])
 581         logger.debug('k8s cluster name/uuid:' +
 582                      cluster.name + '/' + str(cluster.uuid))
 583         return cluster
 584
 585     @ staticmethod
 586     def _k8shasher(cluster):
 587         return str(hash((cluster.cluster_name, cluster.cloud_name,
 588                          cluster.cluster_api_endpoint, cluster.admin_user)))