1 # Copyright (C) 2022 Wind River Systems, Inc.
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
7 # http://www.apache.org/licenses/LICENSE-2.0
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.
15 # client talking to Stx standalone
19 from typing import List
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
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
31 from o2common.helper import o2logging
32 logger = o2logging.get_logger(__name__)
35 CGTSCLIENT_ENDPOINT_ERROR_MSG = \
36 'Must provide Keystone credentials or user-defined endpoint and token'
39 class StxOcloudClient(BaseClient):
40 def __init__(self, driver=None):
42 self.driver = driver if driver else StxClientImp()
44 def _get(self, id) -> ocloudModel.StxGenericModel:
45 return self.driver.getInstanceInfo()
47 def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
48 return [self.driver.getInstanceInfo()]
50 def _set_stx_client(self):
54 class StxResourcePoolClient(BaseClient):
57 self.driver = StxClientImp()
59 def _get(self, id) -> ocloudModel.StxGenericModel:
60 return self.driver.getResourcePoolDetail(id)
62 def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
63 return self.driver.getResourcePoolList(**filters)
65 def _set_stx_client(self):
69 class StxDmsClient(BaseClient):
72 self.driver = StxClientImp()
74 def _get(self, name) -> ocloudModel.StxGenericModel:
75 return self.driver.getK8sDetail(name)
77 def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
78 return self.driver.getK8sList(**filters)
80 def _set_stx_client(self):
84 class StxPserverClient(BaseClient):
87 self.driver = StxClientImp()
89 def _get(self, id) -> ocloudModel.StxGenericModel:
90 return self.driver.getPserver(id)
92 def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
93 return self.driver.getPserverList(**filters)
95 def _set_stx_client(self):
96 self.driver.setStxClient(self._pool_id)
99 class StxCpuClient(BaseClient):
102 # self._pserver_id = pserver_id
103 self.driver = StxClientImp()
105 def _get(self, id) -> ocloudModel.StxGenericModel:
106 return self.driver.getCpu(id)
108 def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
109 return self.driver.getCpuList(**filters)
111 def _set_stx_client(self):
112 self.driver.setStxClient(self._pool_id)
115 class StxMemClient(BaseClient):
118 self.driver = StxClientImp()
120 def _get(self, id) -> ocloudModel.StxGenericModel:
121 return self.driver.getMem(id)
123 def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
124 return self.driver.getMemList(**filters)
126 def _set_stx_client(self):
127 self.driver.setStxClient(self._pool_id)
130 class StxEthClient(BaseClient):
133 self.driver = StxClientImp()
135 def _get(self, id) -> ocloudModel.StxGenericModel:
136 return self.driver.getEthernet(id)
138 def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
139 return self.driver.getEthernetList(**filters)
141 def _set_stx_client(self):
142 self.driver.setStxClient(self._pool_id)
145 class StxIfClient(BaseClient):
148 self.driver = StxClientImp()
150 def _get(self, id) -> ocloudModel.StxGenericModel:
151 return self.driver.getIf(id)
153 def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
154 return self.driver.getIfList(**filters)
156 def _set_stx_client(self):
157 self.driver.setStxClient(self._pool_id)
160 class StxIfPortClient(BaseClient):
163 self.driver = StxClientImp()
165 def _get(self, id) -> ocloudModel.StxGenericModel:
166 return self.driver.getPort(id)
168 def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
169 return self.driver.getPortList(**filters)
171 def _set_stx_client(self):
172 self.driver.setStxClient(self._pool_id)
175 class StxDevClient(BaseClient):
178 self.driver = StxClientImp()
180 def _get(self, id) -> ocloudModel.StxGenericModel:
181 return self.driver.getDevice(id)
183 def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
184 return self.driver.getDeviceList(**filters)
186 def _set_stx_client(self):
187 self.driver.setStxClient(self._pool_id)
190 class StxAccClient(BaseClient):
193 self.driver = StxClientImp()
195 def _get(self, id) -> ocloudModel.StxGenericModel:
196 return self.driver.getAccelerator(id)
198 def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
199 return self.driver.getAcceleratorList(**filters)
201 def _set_stx_client(self):
202 self.driver.setStxClient(self._pool_id)
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):
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)
214 def getStxClient(self):
215 os_client_args = config.get_stx_access_info()
216 config_client = get_stx_client(**os_client_args)
219 def getDcmanagerClient(self):
220 os_client_args = config.get_dc_access_info()
221 config_client = get_dc_client(**os_client_args)
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))
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)
244 raise ValueError('Stx endpoint exception: %s' % msg)
246 raise ValueError('cgtsclient get subcloud client failed')
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)
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
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
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']
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))
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]))]
292 if config.get_system_controller_as_respool():
293 pools.append(systems[0])
295 subclouds = self.getSubcloudList()
296 logger.debug('subclouds numbers: %s' % len(subclouds))
297 for subcloud in subclouds:
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' %
309 return [ocloudModel.StxGenericModel(
310 ResourceTypeEnum.RESOURCE_POOL,
311 self._respoolconverter(
312 respool)) for respool in pools if respool]
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
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')]
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))
337 def _checkLabelExistOnHost(self, client, label_to_check, host_id,
338 check_value=False) -> bool:
339 labels = client.label.list(host_id)
341 return any(label_to_check['key'] == label.label_key and
342 label_to_check['value'] == label.label_value
345 return any(label_to_check['key'] == label.label_key
348 def _checkLabelExistOnCluster(self, client, label_to_check,
349 check_value=False) -> bool:
350 hosts = client.ihost.list()
352 if self._checkLabelExistOnHost(client, label_to_check,
353 host.uuid, check_value):
356 f"host {host.hostname} has the label "
357 f"{label_to_check['key']} with value "
358 f"{label_to_check['value']}")
361 f"host {host.hostname} has the label "
362 f"{label_to_check['key']}")
366 def _setK8sCapabilities(self, client, k8scluster):
368 label_OS_2chk = {'key': 'OS', 'value': 'low_latency'}
369 if self._checkLabelExistOnCluster(client, label_OS_2chk, True):
370 logger.debug("low latency host inside of the k8s cluster")
371 capabilities[label_OS_2chk['key']] = label_OS_2chk['value']
372 setattr(k8scluster, 'capabilities', json.dumps(capabilities))
375 def getLabelList(self, **filters) -> List[ocloudModel.StxGenericModel]:
376 hostid = filters.get('hostid', None)
377 assert (hostid is not None), 'missing hostid to query label list'
378 labels = self.stxclient.label.list(hostid)
379 return [ocloudModel.StxGenericModel(
380 ResourceTypeEnum.PSERVER_LABEL,
381 self._labelconverter(label)) for label in labels if label]
383 def getK8sList(self, **filters) -> List[ocloudModel.StxGenericModel]:
384 def process_cluster(client, cluster):
385 setattr(cluster, 'cloud_name', systems[0].name)
386 setattr(cluster, 'cloud_uuid', systems[0].uuid)
387 cluster = self._setK8sCapabilities(client, cluster)
388 logger.debug('k8sresources cluster_api_endpoint: ' +
389 str(cluster.cluster_api_endpoint))
390 return ocloudModel.StxGenericModel(ResourceTypeEnum.DMS,
391 self._k8sconverter(cluster),
392 self._k8shasher(cluster))
394 systems = self.stxclient.isystem.list()
395 distributed_cloud_role = systems[0].distributed_cloud_role
397 f'system controller distributed_cloud_role: '
398 f'{distributed_cloud_role}'))
402 if distributed_cloud_role is None or distributed_cloud_role != \
405 [process_cluster(self.stxclient, k8s)
406 for k8s in self.stxclient.kube_cluster.list() if k8s])
409 if config.get_system_controller_as_respool():
411 [process_cluster(self.stxclient, k8s)
412 for k8s in self.stxclient.kube_cluster.list() if k8s])
414 subclouds = self.getSubcloudList()
415 logger.debug(f'subclouds numbers: {len(subclouds)}')
417 for subcloud in subclouds:
419 subcloud_stxclient = self.getSubcloudClient(
420 subcloud.subcloud_id)
421 systems = subcloud_stxclient.isystem.list()
422 k8sclusters = subcloud_stxclient.kube_cluster.list()
423 k8s_list.extend([process_cluster(subcloud_stxclient, k8s)
424 for k8s in k8sclusters if k8s])
425 except Exception as ex:
427 f'Failed to get cgstclient of subcloud '
428 f'{subcloud.name}: {ex}'))
433 def getK8sDetail(self, name) -> ocloudModel.StxGenericModel:
434 def process_k8s_cluster(client, k8s_cluster, cloud_name, cloud_uuid):
435 setattr(k8s_cluster, 'cloud_name', cloud_name)
436 setattr(k8s_cluster, 'cloud_uuid', cloud_uuid)
437 k8s_cluster = self._setK8sCapabilities(client, k8s_cluster)
440 systems = self.stxclient.isystem.list()
441 system_name = systems[0].name
442 system_uuid = systems[0].uuid
445 k8s_clusters = self.stxclient.kube_cluster.list()
446 k8s_cluster = process_k8s_cluster(
447 self.stxclient, k8s_clusters.pop(), system_name)
449 sname = name.split('.')
450 cloud_name = '.'.join(sname[:-1])
453 if cloud_name == system_name:
454 k8s_cluster = process_k8s_cluster(
456 self.stxclient.kube_cluster.get(k8s_name), cloud_name,
459 subclouds = self.getSubcloudList()
461 sub.subcloud_id for sub in subclouds
462 if sub.name == cloud_name)
463 subcloud_stxclient = self.getSubcloudClient(subcloud_id)
464 systems = subcloud_stxclient.isystem.list()
465 system_uuid = systems[0].uuid
466 k8s_cluster = process_k8s_cluster(
468 subcloud_stxclient.kube_cluster.get(k8s_name), cloud_name,
474 logger.debug(f'k8sresource: {k8s_cluster.to_dict()}')
475 return ocloudModel.StxGenericModel(
476 ResourceTypeEnum.DMS, self._k8sconverter(k8s_cluster),
477 self._k8shasher(k8s_cluster))
479 def getCpuList(self, **filters) -> List[ocloudModel.StxGenericModel]:
480 hostid = filters.get('hostid', None)
481 assert (hostid is not None), 'missing hostid to query icpu list'
482 cpulist = self.stxclient.icpu.list(hostid)
483 return [ocloudModel.StxGenericModel(
484 ResourceTypeEnum.PSERVER_CPU,
485 self._cpuconverter(cpures)) for cpures in cpulist if cpures]
487 def getCpu(self, id) -> ocloudModel.StxGenericModel:
488 cpuinfo = self.stxclient.icpu.get(id)
489 return ocloudModel.StxGenericModel(
490 ResourceTypeEnum.PSERVER_CPU, self._cpuconverter(cpuinfo))
492 def getMemList(self, **filters) -> List[ocloudModel.StxGenericModel]:
493 hostid = filters.get('hostid', None)
494 assert (hostid is not None), 'missing hostid to query imem list'
495 memlist = self.stxclient.imemory.list(hostid)
496 return [ocloudModel.StxGenericModel(
497 ResourceTypeEnum.PSERVER_RAM,
498 self._memconverter(memories)) for memories in memlist if memories]
500 def getMem(self, id) -> ocloudModel.StxGenericModel:
501 meminfo = self.stxclient.imemory.get(id)
502 return ocloudModel.StxGenericModel(
503 ResourceTypeEnum.PSERVER_RAM, self._memconverter(meminfo))
505 def getEthernetList(self, **filters) -> List[ocloudModel.StxGenericModel]:
506 hostid = filters.get('hostid', None)
507 assert (hostid is not None), 'missing hostid to query port list'
508 ethlist = self.stxclient.ethernet_port.list(hostid)
509 return [ocloudModel.StxGenericModel(
510 ResourceTypeEnum.PSERVER_ETH,
511 self._ethconverter(eth)) for eth in ethlist if eth]
513 def getEthernet(self, id) -> ocloudModel.StxGenericModel:
514 ethinfo = self.stxclient.ethernet_port.get(id)
515 return ocloudModel.StxGenericModel(
516 ResourceTypeEnum.PSERVER_ETH, self._ethconverter(ethinfo))
518 def getIfList(self, **filters) -> List[ocloudModel.StxGenericModel]:
519 hostid = filters.get('hostid', None)
520 assert (hostid is not None), 'missing hostid to query iinterface list'
521 iflist = self.stxclient.iinterface.list(hostid)
522 return [ocloudModel.StxGenericModel(
523 ResourceTypeEnum.PSERVER_IF,
524 self._ifconverter(ifs)) for ifs in iflist if ifs]
526 def getIf(self, id) -> ocloudModel.StxGenericModel:
527 ifinfo = self.stxclient.iinterface.get(id)
528 return ocloudModel.StxGenericModel(
529 ResourceTypeEnum.PSERVER_IF, self._ifconverter(ifinfo))
531 def getPortList(self, **filters) -> List[ocloudModel.StxGenericModel]:
532 ifid = filters.get('interfaceid', None)
533 assert (ifid is not None), 'missing interface id to query port list'
534 portlist = self.stxclient.iinterface.list_ports(ifid)
535 return [ocloudModel.StxGenericModel(
536 ResourceTypeEnum.PSERVER_IF_PORT,
537 port) for port in portlist if port]
539 def getPort(self, id) -> ocloudModel.StxGenericModel:
540 portinfo = self.stxclient.port.get(id)
541 return ocloudModel.StxGenericModel(
542 ResourceTypeEnum.PSERVER_IF_PORT, portinfo)
544 def getDeviceList(self, **filters) -> List[ocloudModel.StxGenericModel]:
545 hostid = filters.get('hostid', None)
546 assert (hostid is not None), 'missing hostid to query pci device list'
547 pci_dev_list = self.stxclient.pci_device.list(hostid)
548 return [ocloudModel.StxGenericModel(
549 ResourceTypeEnum.PSERVER_PCI_DEV,
550 self._devconverter(pci_dev))
551 for pci_dev in pci_dev_list if pci_dev]
553 def getDevice(self, id) -> ocloudModel.StxGenericModel:
554 pciinfo = self.stxclient.pci_device.get(id)
555 return ocloudModel.StxGenericModel(
556 ResourceTypeEnum.PSERVER_PCI_DEV, self._devconverter(pciinfo))
558 def getAcceleratorList(self, **filters) -> \
559 List[ocloudModel.StxGenericModel]:
560 hostid = filters.get('hostid', None)
561 assert (hostid is not None), 'missing hostid to query accelerator list'
562 pci_dev_list = self.stxclient.pci_device.list(hostid)
564 for pci_dev in pci_dev_list:
565 if pci_dev.pvendor_id in ['8086']:
566 if pci_dev.pdevice_id in ['0d5c', '0d5d']:
567 logger.info('Accelerator vendor ID: {}, device ID: {}'.
568 format(pci_dev.pvendor_id, pci_dev.pdevice_id))
569 acc_list.append(ocloudModel.StxGenericModel(
570 ResourceTypeEnum.PSERVER_ACC,
571 self._devconverter(pci_dev)))
574 def getAccelerator(self, id) -> ocloudModel.StxGenericModel:
575 pciinfo = self.stxclient.pci_device.get(id)
576 return ocloudModel.StxGenericModel(
577 ResourceTypeEnum.PSERVER_ACC, self._devconverter(pciinfo))
579 def _getIsystems(self):
580 return self.stxclient.isystem.list()
582 def _getIsystem(self, id=None):
584 return self.stxclient.isystem.get(id)
586 isystems = self.stxclient.isystem.list()
587 if len(isystems) != 1 and not id:
588 raise Exception('No system uuid was provided and '
589 'more than one system exists in the account.')
593 def _respoolconverter(res_pool):
594 setattr(res_pool, 'name', res_pool.region_name)
598 def _hostconverter(host):
600 "hostname", "personality", "id", "mgmt_ip", "mgmt_mac",
601 "software_load", "capabilities",
602 "operational", "availability", "administrative",
603 "boot_device", "rootfs_device", "install_state", "subfunctions",
604 "clock_synchronization", "max_cpu_mhz_allowed"
606 content = host.to_dict()
608 filter(lambda item: item[0] in selected_keys, content.items()))
609 setattr(host, 'filtered', filtered)
610 setattr(host, 'name', host.hostname)
614 def _labelconverter(label):
616 "uuid", "label_key", "label_value", "host_uuid"
618 content = label.to_dict()
621 filter(lambda item: item[0] in selected_keys, content.items()))
622 setattr(label, 'filtered', filtered)
623 setattr(label, 'name', label.uuid.split(
624 '-', 1)[0] + '-label-' + label.label_key)
625 setattr(label, 'updated_at', None)
626 setattr(label, 'created_at', None)
630 def _cpuconverter(cpu):
632 "cpu", "core", "thread", "allocated_function", "numa_node",
633 "cpu_model", "cpu_family"
635 content = cpu.to_dict()
637 filter(lambda item: item[0] in selected_keys, content.items()))
638 setattr(cpu, 'filtered', filtered)
639 setattr(cpu, 'name', cpu.ihost_uuid.split(
640 '-', 1)[0] + '-cpu-'+str(cpu.cpu))
644 def _memconverter(mem):
646 "memtotal_mib", "memavail_mib", "vm_hugepages_use_1G",
647 "vm_hugepages_possible_1G", "hugepages_configured",
648 "vm_hugepages_avail_1G", "vm_hugepages_nr_1G",
649 "vm_hugepages_nr_4K", "vm_hugepages_nr_2M",
650 "vm_hugepages_possible_2M", "vm_hugepages_avail_2M",
651 "platform_reserved_mib", "numa_node"
653 content = mem.to_dict()
655 filter(lambda item: item[0] in selected_keys, content.items()))
656 setattr(mem, 'filtered', filtered)
657 setattr(mem, 'name', mem.ihost_uuid.split('-', 1)[0] +
658 '-mem-node-'+str(mem.numa_node))
662 def _ethconverter(eth):
664 "name", "namedisplay", "dev_id", "pdevice", "capabilities",
665 "type", "driver", "mac", "numa_node",
666 "pciaddr", "pclass", "psvendor", "psdevice",
667 "sriov_totalvfs", "sriov_numvfs", "dpdksupport",
668 "sriov_vf_driver", "sriov_vf_pdevice_id", "interface_uuid"
670 content = eth.to_dict()
672 filter(lambda item: item[0] in selected_keys, content.items()))
673 setattr(eth, 'filtered', filtered)
674 setattr(eth, 'name', eth.host_uuid.split('-', 1)[0] + '-'+eth.name)
675 setattr(eth, 'updated_at', None)
676 setattr(eth, 'created_at', None)
680 def _ifconverter(ifs):
682 "ifname", "iftype", "imac", "vlan_id", "imtu",
683 "ifclass", "uses", "max_tx_rate",
684 "sriov_vf_driver", "sriov_numvfs", "ptp_role"
686 content = ifs.to_dict()
688 filter(lambda item: item[0] in selected_keys, content.items()))
689 setattr(ifs, 'filtered', filtered)
690 setattr(ifs, 'name', ifs.ihost_uuid.split('-', 1)[0] + '-'+ifs.ifname)
691 setattr(ifs, 'updated_at', None)
692 setattr(ifs, 'created_at', None)
696 def _devconverter(dev):
698 "name", "pdevice", "pciaddr", "pvendor_id", "pvendor",
699 "pclass_id", "pclass", "psvendor", "psdevice",
700 "sriov_totalvfs", "sriov_numvfs", "numa_node"
702 content = dev.to_dict()
704 filter(lambda item: item[0] in selected_keys, content.items()))
705 setattr(dev, 'filtered', filtered)
706 setattr(dev, 'name', dev.host_uuid.split('-', 1)[0] + '-'+dev.name)
710 def _k8sconverter(cluster):
711 setattr(cluster, 'name', cluster.cloud_name +
712 '.' + cluster.cluster_name)
713 setattr(cluster, 'uuid',
714 uuid.uuid3(uuid.NAMESPACE_URL, cluster.cloud_uuid))
715 setattr(cluster, 'updated_at', None)
716 setattr(cluster, 'created_at', None)
717 setattr(cluster, 'events', [])
718 logger.debug('k8s cluster name/uuid:' +
719 cluster.name + '/' + str(cluster.uuid))
723 def _k8shasher(cluster):
724 return str(hash((cluster.cluster_name, cluster.cloud_name,
725 cluster.cluster_api_endpoint, cluster.admin_user,
726 cluster.capabilities)))