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
20 from typing import List
23 from cgtsclient.client import get_client as get_stx_client
24 from cgtsclient.exc import EndpointException
25 from dcmanagerclient.api.client import client as get_dc_client
26 from kubernetes import client as k8sclient, config as k8sconfig
28 from o2common.config import config
29 from o2common.service.client.base_client import BaseClient
30 from o2ims.domain import stx_object as ocloudModel
31 from o2ims.domain.resource_type import ResourceTypeEnum
33 from o2common.helper import o2logging
34 logger = o2logging.get_logger(__name__)
37 CGTSCLIENT_ENDPOINT_ERROR_MSG = \
38 'Must provide Keystone credentials or user-defined endpoint and token'
41 class StxOcloudClient(BaseClient):
42 def __init__(self, driver=None):
44 self.driver = driver if driver else StxClientImp()
46 def _get(self, id) -> ocloudModel.StxGenericModel:
47 return self.driver.getInstanceInfo()
49 def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
50 return [self.driver.getInstanceInfo()]
52 def _set_stx_client(self):
56 class StxResourcePoolClient(BaseClient):
59 self.driver = StxClientImp()
61 def _get(self, id) -> ocloudModel.StxGenericModel:
62 return self.driver.getResourcePoolDetail(id)
64 def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
65 return self.driver.getResourcePoolList(**filters)
67 def _set_stx_client(self):
71 class StxDmsClient(BaseClient):
74 self.driver = StxClientImp()
76 def _get(self, name) -> ocloudModel.StxGenericModel:
77 return self.driver.getK8sDetail(name)
79 def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
80 return self.driver.getK8sList(**filters)
82 def _set_stx_client(self):
86 class StxPserverClient(BaseClient):
89 self.driver = StxClientImp()
91 def _get(self, id) -> ocloudModel.StxGenericModel:
92 return self.driver.getPserver(id)
94 def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
95 return self.driver.getPserverList(**filters)
97 def _set_stx_client(self):
98 self.driver.setStxClient(self._pool_id)
101 class StxCpuClient(BaseClient):
104 # self._pserver_id = pserver_id
105 self.driver = StxClientImp()
107 def _get(self, id) -> ocloudModel.StxGenericModel:
108 return self.driver.getCpu(id)
110 def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
111 return self.driver.getCpuList(**filters)
113 def _set_stx_client(self):
114 self.driver.setStxClient(self._pool_id)
117 class StxMemClient(BaseClient):
120 self.driver = StxClientImp()
122 def _get(self, id) -> ocloudModel.StxGenericModel:
123 return self.driver.getMem(id)
125 def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
126 return self.driver.getMemList(**filters)
128 def _set_stx_client(self):
129 self.driver.setStxClient(self._pool_id)
132 class StxEthClient(BaseClient):
135 self.driver = StxClientImp()
137 def _get(self, id) -> ocloudModel.StxGenericModel:
138 return self.driver.getEthernet(id)
140 def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
141 return self.driver.getEthernetList(**filters)
143 def _set_stx_client(self):
144 self.driver.setStxClient(self._pool_id)
147 class StxIfClient(BaseClient):
150 self.driver = StxClientImp()
152 def _get(self, id) -> ocloudModel.StxGenericModel:
153 return self.driver.getIf(id)
155 def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
156 return self.driver.getIfList(**filters)
158 def _set_stx_client(self):
159 self.driver.setStxClient(self._pool_id)
162 class StxIfPortClient(BaseClient):
165 self.driver = StxClientImp()
167 def _get(self, id) -> ocloudModel.StxGenericModel:
168 return self.driver.getPort(id)
170 def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
171 return self.driver.getPortList(**filters)
173 def _set_stx_client(self):
174 self.driver.setStxClient(self._pool_id)
177 class StxDevClient(BaseClient):
180 self.driver = StxClientImp()
182 def _get(self, id) -> ocloudModel.StxGenericModel:
183 return self.driver.getDevice(id)
185 def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
186 return self.driver.getDeviceList(**filters)
188 def _set_stx_client(self):
189 self.driver.setStxClient(self._pool_id)
192 class StxAccClient(BaseClient):
195 self.driver = StxClientImp()
197 def _get(self, id) -> ocloudModel.StxGenericModel:
198 return self.driver.getAccelerator(id)
200 def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
201 return self.driver.getAcceleratorList(**filters)
203 def _set_stx_client(self):
204 self.driver.setStxClient(self._pool_id)
207 # internal driver which implement client call to Stx Standalone and DC instance
208 class StxClientImp(object):
209 def __init__(self, stx_client=None, dc_client=None):
211 self.stxclient = stx_client if stx_client else self.getStxClient()
212 self.dcclient = dc_client if dc_client else self.getDcmanagerClient()
213 # if subcloud_id is not None:
214 # self.stxclient = self.getSubcloudClient(subcloud_id)
216 def getStxClient(self):
217 os_client_args = config.get_stx_access_info()
218 config_client = get_stx_client(**os_client_args)
221 def getDcmanagerClient(self):
222 os_client_args = config.get_dc_access_info()
223 config_client = get_dc_client(**os_client_args)
226 def getSubcloudClient(self, subcloud_id):
227 subcloud = self.dcclient.subcloud_manager.\
228 subcloud_additional_details(subcloud_id)
229 logger.debug('subcloud name: %s, oam_floating_ip: %s' %
230 (subcloud[0].name, subcloud[0].oam_floating_ip))
231 if subcloud[0].oam_floating_ip == 'unavailable':
232 raise EnvironmentError(f"{subcloud[0].name} was unavailable")
234 os_client_args = config.get_stx_access_info(
235 region_name=subcloud[0].region_name,
236 subcloud_hostname=subcloud[0].oam_floating_ip)
237 # logger.info(os_client_args)
238 config_client = get_stx_client(**os_client_args)
239 except EndpointException as e:
240 msg = e.format_message()
241 if CGTSCLIENT_ENDPOINT_ERROR_MSG in msg:
242 os_client_args = config.get_stx_access_info(
243 region_name=subcloud[0].region_name, sub_is_https=True,
244 subcloud_hostname=subcloud[0].oam_floating_ip)
245 # logger.info(os_client_args)
246 config_client = get_stx_client(**os_client_args)
248 raise ValueError('Stx endpoint exception: %s' % msg)
250 raise ValueError('cgtsclient get subcloud client failed')
254 def getK8sClient(self, k8scluster):
255 def _b64_encode_str(msg: str, encode: str = 'utf-8') -> str:
256 msg_bytes = msg.encode('utf-8')
257 base64_bytes = base64.b64encode(msg_bytes)
258 base64_msg = base64_bytes.decode('utf-8')
261 conf_dict = config.gen_k8s_config_dict(
262 k8scluster.cluster_api_endpoint,
263 _b64_encode_str(k8scluster.cluster_ca_cert),
264 k8scluster.admin_user,
265 _b64_encode_str(k8scluster.admin_client_cert),
266 _b64_encode_str(k8scluster.admin_client_key),
268 k8sconfig.load_kube_config_from_dict(conf_dict)
269 v1 = k8sclient.CoreV1Api()
272 def setStxClient(self, resource_pool_id):
273 systems = self.stxclient.isystem.list()
274 if resource_pool_id == systems[0].uuid:
275 logger.debug('Stx Client not change: %s' % resource_pool_id)
278 subclouds = self.getSubcloudList()
279 for subcloud in subclouds:
280 subcloud_stxclient = self.getSubcloudClient(subcloud.subcloud_id)
281 systems = subcloud_stxclient.isystem.list()
282 # logger.debug('subcloud %s id: %s' %
283 # (systems[0].name, systems[0].uuid))
284 # logger.debug('subcloud: %s' % (systems[0].to_dict()))
285 if resource_pool_id == systems[0].uuid:
286 self.stxclient = subcloud_stxclient
288 def getInstanceInfo(self) -> ocloudModel.StxGenericModel:
289 systems = self.stxclient.isystem.list()
290 logger.debug('systems:' + str(systems[0].to_dict()))
291 # logger.debug('systems[0] uuid: ' + str(systems[0].uuid))
292 return ocloudModel.StxGenericModel(
293 ResourceTypeEnum.OCLOUD, systems[0]) if systems else None
295 def getSubcloudList(self):
296 self.dcclient = self.getDcmanagerClient()
297 subs = self.dcclient.subcloud_manager.list_subclouds()
298 known_subs = [sub for sub in subs if sub.sync_status != 'unknown']
301 def getResourcePoolList(self, **filters) -> List[
302 ocloudModel.StxGenericModel]:
303 systems = self.stxclient.isystem.list()
304 logger.debug('system controller distributed_cloud_role:' +
305 str(systems[0].distributed_cloud_role))
307 if systems[0].distributed_cloud_role is None or \
308 systems[0].distributed_cloud_role != 'systemcontroller':
309 return [ocloudModel.StxGenericModel(
310 ResourceTypeEnum.RESOURCE_POOL,
311 self._respoolconverter(systems[0]))]
314 if config.get_system_controller_as_respool():
315 pools.append(systems[0])
317 subclouds = self.getSubcloudList()
318 logger.debug('subclouds numbers: %s' % len(subclouds))
319 for subcloud in subclouds:
321 subcloud_stxclient = self.getSubcloudClient(
322 subcloud.subcloud_id)
323 systems = subcloud_stxclient.isystem.list()
324 logger.debug('subcloud system:' + str(systems[0].to_dict()))
325 pools.append(systems[0])
326 except Exception as ex:
327 logger.warning('Failed get cgstclient of subcloud %s: %s' %
331 return [ocloudModel.StxGenericModel(
332 ResourceTypeEnum.RESOURCE_POOL,
333 self._respoolconverter(
334 respool)) for respool in pools if respool]
336 def getResourcePoolDetail(self, id):
337 self.setStxClient(id)
338 systems = self.stxclient.isystem.list()
339 logger.debug('systems:' + str(systems[0].to_dict()))
340 return ocloudModel.StxGenericModel(
341 ResourceTypeEnum.RESOURCE_POOL,
342 self._respoolconverter(systems[0])) if systems else None
344 def getPserverList(self, **filters) -> List[ocloudModel.StxGenericModel]:
345 hosts = self.stxclient.ihost.list()
346 logger.debug('host 1:' + str(hosts[0].to_dict()))
347 return [ocloudModel.StxGenericModel(
348 ResourceTypeEnum.PSERVER, self._hostconverter(host))
349 for host in hosts if host and (host.availability == 'available'
350 or host.availability == 'online'
351 or host.availability == 'degraded')]
353 def getPserver(self, id) -> ocloudModel.StxGenericModel:
354 host = self.stxclient.ihost.get(id)
355 logger.debug('host:' + str(host.to_dict()))
356 return ocloudModel.StxGenericModel(
357 ResourceTypeEnum.PSERVER, self._hostconverter(host))
359 def _checkLabelExistOnHost(self, client, label_to_check, host_id,
360 check_value=False) -> bool:
361 labels = client.label.list(host_id)
363 return any(label_to_check['key'] == label.label_key and
364 label_to_check['value'] == label.label_value
367 return any(label_to_check['key'] == label.label_key
370 def _checkLabelExistOnCluster(self, client, label_to_check,
371 check_value=False) -> bool:
372 hosts = client.ihost.list()
374 if self._checkLabelExistOnHost(client, label_to_check,
375 host.uuid, check_value):
378 f"host {host.hostname} has the label "
379 f"{label_to_check['key']} with value "
380 f"{label_to_check['value']}")
383 f"host {host.hostname} has the label "
384 f"{label_to_check['key']}")
388 def _getK8sNodes(self, k8sclient):
389 return k8sclient.list_node()
391 def _getK8sNodeDetail(self, k8sclient, node_name):
392 return k8sclient.read_node(name=node_name)
394 def _getK8sCapabilities(self, k8s_client):
395 k8s_capabilities = {}
396 nodes = self._getK8sNodes(k8s_client)
397 for node in nodes.items:
398 logger.debug(f'k8s node {node.metadata.name} allocatable: '
399 f'{node.status.allocatable}')
400 for allocatable in node.status.allocatable:
401 if allocatable.startswith('intel.com/pci_sriov_net_'):
402 k8s_capabilities[f'{node.metadata.name}_sriov'] = True
403 if allocatable == 'windriver.com/isolcpus':
404 k8s_capabilities[f'{node.metadata.name}_isolcpus'] = True
405 return k8s_capabilities
407 def _setK8sCapabilities(self, k8scluster, client, k8s_client):
409 label_OS_2chk = {'key': 'OS', 'value': 'low_latency'}
410 if self._checkLabelExistOnCluster(client, label_OS_2chk, True):
411 logger.debug("low latency host inside of the k8s cluster")
412 capabilities[label_OS_2chk['key']] = label_OS_2chk['value']
414 # Add Kubernetes capabilities
415 k8s_capabilities = self._getK8sCapabilities(k8s_client)
416 capabilities.update(k8s_capabilities)
418 setattr(k8scluster, 'capabilities', json.dumps(capabilities))
421 def _getK8sCapacity(self, k8s_client):
423 nodes = self._getK8sNodes(k8s_client)
424 for node in nodes.items:
425 logger.debug(f'k8s node {node.metadata.name} capacity: '
426 f'{node.status.capacity}')
427 for key, value in node.status.capacity.items():
428 k8s_capacity[f'{node.metadata.name}_{key}'] = value
431 def _setK8sCapacity(self, k8scluster, client, k8s_client):
434 # Add Kubernetes capacity
435 k8s_capacity = self._getK8sCapacity(k8s_client)
436 capacity.update(k8s_capacity)
438 setattr(k8scluster, 'capacity', json.dumps(capacity))
441 def getLabelList(self, **filters) -> List[ocloudModel.StxGenericModel]:
442 hostid = filters.get('hostid', None)
443 assert (hostid is not None), 'missing hostid to query label list'
444 labels = self.stxclient.label.list(hostid)
445 return [ocloudModel.StxGenericModel(
446 ResourceTypeEnum.PSERVER_LABEL,
447 self._labelconverter(label)) for label in labels if label]
449 def getK8sList(self, **filters) -> List[ocloudModel.StxGenericModel]:
450 def process_cluster(client, cluster):
451 setattr(cluster, 'cloud_name', systems[0].name)
452 setattr(cluster, 'cloud_uuid', systems[0].uuid)
454 k8s_client = self.getK8sClient(cluster)
455 cluster = self._setK8sCapabilities(cluster, client, k8s_client)
456 cluster = self._setK8sCapacity(cluster, client, k8s_client)
458 logger.debug('k8sresources cluster_api_endpoint: ' +
459 str(cluster.cluster_api_endpoint))
460 return ocloudModel.StxGenericModel(ResourceTypeEnum.DMS,
461 self._k8sconverter(cluster),
462 self._k8shasher(cluster))
464 systems = self.stxclient.isystem.list()
465 distributed_cloud_role = systems[0].distributed_cloud_role
467 f'system controller distributed_cloud_role: '
468 f'{distributed_cloud_role}'))
472 if distributed_cloud_role is None or distributed_cloud_role != \
475 [process_cluster(self.stxclient, k8s)
476 for k8s in self.stxclient.kube_cluster.list() if k8s])
479 if config.get_system_controller_as_respool():
481 [process_cluster(self.stxclient, k8s)
482 for k8s in self.stxclient.kube_cluster.list() if k8s])
484 subclouds = self.getSubcloudList()
485 logger.debug(f'subclouds numbers: {len(subclouds)}')
487 for subcloud in subclouds:
489 subcloud_stxclient = self.getSubcloudClient(
490 subcloud.subcloud_id)
491 systems = subcloud_stxclient.isystem.list()
492 k8sclusters = subcloud_stxclient.kube_cluster.list()
493 k8s_list.extend([process_cluster(subcloud_stxclient, k8s)
494 for k8s in k8sclusters if k8s])
495 except Exception as ex:
497 f'Failed to get cgstclient of subcloud '
498 f'{subcloud.name}: {ex}'))
503 def getK8sDetail(self, name) -> ocloudModel.StxGenericModel:
504 def process_k8s_cluster(client, k8s_cluster, cloud_name, cloud_uuid):
505 setattr(k8s_cluster, 'cloud_name', cloud_name)
506 setattr(k8s_cluster, 'cloud_uuid', cloud_uuid)
508 k8s_client = self.getK8sClient(k8s_cluster)
509 cluster = self._setK8sCapabilities(k8s_cluster, client, k8s_client)
510 cluster = self._setK8sCapacity(cluster, client, k8s_client)
513 systems = self.stxclient.isystem.list()
514 system_name = systems[0].name
515 system_uuid = systems[0].uuid
518 k8s_clusters = self.stxclient.kube_cluster.list()
519 k8s_cluster = process_k8s_cluster(
520 self.stxclient, k8s_clusters.pop(), system_name)
522 sname = name.split('.')
523 cloud_name = '.'.join(sname[:-1])
526 if cloud_name == system_name:
527 k8s_cluster = process_k8s_cluster(
529 self.stxclient.kube_cluster.get(k8s_name), cloud_name,
532 subclouds = self.getSubcloudList()
534 sub.subcloud_id for sub in subclouds
535 if sub.name == cloud_name)
536 subcloud_stxclient = self.getSubcloudClient(subcloud_id)
537 systems = subcloud_stxclient.isystem.list()
538 system_uuid = systems[0].uuid
539 k8s_cluster = process_k8s_cluster(
541 subcloud_stxclient.kube_cluster.get(k8s_name), cloud_name,
547 logger.debug(f'k8sresource: {k8s_cluster.to_dict()}')
548 return ocloudModel.StxGenericModel(
549 ResourceTypeEnum.DMS, self._k8sconverter(k8s_cluster),
550 self._k8shasher(k8s_cluster))
552 def getCpuList(self, **filters) -> List[ocloudModel.StxGenericModel]:
553 hostid = filters.get('hostid', None)
554 assert (hostid is not None), 'missing hostid to query icpu list'
555 cpulist = self.stxclient.icpu.list(hostid)
556 return [ocloudModel.StxGenericModel(
557 ResourceTypeEnum.PSERVER_CPU,
558 self._cpuconverter(cpures)) for cpures in cpulist if cpures]
560 def getCpu(self, id) -> ocloudModel.StxGenericModel:
561 cpuinfo = self.stxclient.icpu.get(id)
562 return ocloudModel.StxGenericModel(
563 ResourceTypeEnum.PSERVER_CPU, self._cpuconverter(cpuinfo))
565 def getMemList(self, **filters) -> List[ocloudModel.StxGenericModel]:
566 hostid = filters.get('hostid', None)
567 assert (hostid is not None), 'missing hostid to query imem list'
568 memlist = self.stxclient.imemory.list(hostid)
569 return [ocloudModel.StxGenericModel(
570 ResourceTypeEnum.PSERVER_RAM,
571 self._memconverter(memories)) for memories in memlist if memories]
573 def getMem(self, id) -> ocloudModel.StxGenericModel:
574 meminfo = self.stxclient.imemory.get(id)
575 return ocloudModel.StxGenericModel(
576 ResourceTypeEnum.PSERVER_RAM, self._memconverter(meminfo))
578 def getEthernetList(self, **filters) -> List[ocloudModel.StxGenericModel]:
579 hostid = filters.get('hostid', None)
580 assert (hostid is not None), 'missing hostid to query port list'
581 ethlist = self.stxclient.ethernet_port.list(hostid)
582 return [ocloudModel.StxGenericModel(
583 ResourceTypeEnum.PSERVER_ETH,
584 self._ethconverter(eth)) for eth in ethlist if eth]
586 def getEthernet(self, id) -> ocloudModel.StxGenericModel:
587 ethinfo = self.stxclient.ethernet_port.get(id)
588 return ocloudModel.StxGenericModel(
589 ResourceTypeEnum.PSERVER_ETH, self._ethconverter(ethinfo))
591 def getIfList(self, **filters) -> List[ocloudModel.StxGenericModel]:
592 hostid = filters.get('hostid', None)
593 assert (hostid is not None), 'missing hostid to query iinterface list'
594 iflist = self.stxclient.iinterface.list(hostid)
595 return [ocloudModel.StxGenericModel(
596 ResourceTypeEnum.PSERVER_IF,
597 self._ifconverter(ifs)) for ifs in iflist if ifs]
599 def getIf(self, id) -> ocloudModel.StxGenericModel:
600 ifinfo = self.stxclient.iinterface.get(id)
601 return ocloudModel.StxGenericModel(
602 ResourceTypeEnum.PSERVER_IF, self._ifconverter(ifinfo))
604 def getPortList(self, **filters) -> List[ocloudModel.StxGenericModel]:
605 ifid = filters.get('interfaceid', None)
606 assert (ifid is not None), 'missing interface id to query port list'
607 portlist = self.stxclient.iinterface.list_ports(ifid)
608 return [ocloudModel.StxGenericModel(
609 ResourceTypeEnum.PSERVER_IF_PORT,
610 port) for port in portlist if port]
612 def getPort(self, id) -> ocloudModel.StxGenericModel:
613 portinfo = self.stxclient.port.get(id)
614 return ocloudModel.StxGenericModel(
615 ResourceTypeEnum.PSERVER_IF_PORT, portinfo)
617 def getDeviceList(self, **filters) -> List[ocloudModel.StxGenericModel]:
618 hostid = filters.get('hostid', None)
619 assert (hostid is not None), 'missing hostid to query pci device list'
620 pci_dev_list = self.stxclient.pci_device.list(hostid)
621 return [ocloudModel.StxGenericModel(
622 ResourceTypeEnum.PSERVER_PCI_DEV,
623 self._devconverter(pci_dev))
624 for pci_dev in pci_dev_list if pci_dev]
626 def getDevice(self, id) -> ocloudModel.StxGenericModel:
627 pciinfo = self.stxclient.pci_device.get(id)
628 return ocloudModel.StxGenericModel(
629 ResourceTypeEnum.PSERVER_PCI_DEV, self._devconverter(pciinfo))
631 def getAcceleratorList(self, **filters) -> \
632 List[ocloudModel.StxGenericModel]:
633 hostid = filters.get('hostid', None)
634 assert (hostid is not None), 'missing hostid to query accelerator list'
635 pci_dev_list = self.stxclient.pci_device.list(hostid)
637 for pci_dev in pci_dev_list:
638 if pci_dev.pvendor_id in ['8086']:
639 if pci_dev.pdevice_id in ['0d5c', '0d5d']:
640 logger.info('Accelerator vendor ID: {}, device ID: {}'.
641 format(pci_dev.pvendor_id, pci_dev.pdevice_id))
642 acc_list.append(ocloudModel.StxGenericModel(
643 ResourceTypeEnum.PSERVER_ACC,
644 self._devconverter(pci_dev)))
647 def getAccelerator(self, id) -> ocloudModel.StxGenericModel:
648 pciinfo = self.stxclient.pci_device.get(id)
649 return ocloudModel.StxGenericModel(
650 ResourceTypeEnum.PSERVER_ACC, self._devconverter(pciinfo))
652 def _getIsystems(self):
653 return self.stxclient.isystem.list()
655 def _getIsystem(self, id=None):
657 return self.stxclient.isystem.get(id)
659 isystems = self.stxclient.isystem.list()
660 if len(isystems) != 1 and not id:
661 raise Exception('No system uuid was provided and '
662 'more than one system exists in the account.')
666 def _respoolconverter(res_pool):
667 setattr(res_pool, 'name', res_pool.region_name)
671 def _hostconverter(host):
673 "hostname", "personality", "id", "mgmt_ip", "mgmt_mac",
674 "software_load", "capabilities",
675 "operational", "availability", "administrative",
676 "boot_device", "rootfs_device", "install_state", "subfunctions",
677 "clock_synchronization", "max_cpu_mhz_allowed"
679 content = host.to_dict()
681 filter(lambda item: item[0] in selected_keys, content.items()))
682 setattr(host, 'filtered', filtered)
683 setattr(host, 'name', host.hostname)
687 def _labelconverter(label):
689 "uuid", "label_key", "label_value", "host_uuid"
691 content = label.to_dict()
694 filter(lambda item: item[0] in selected_keys, content.items()))
695 setattr(label, 'filtered', filtered)
696 setattr(label, 'name', label.uuid.split(
697 '-', 1)[0] + '-label-' + label.label_key)
698 setattr(label, 'updated_at', None)
699 setattr(label, 'created_at', None)
703 def _cpuconverter(cpu):
705 "cpu", "core", "thread", "allocated_function", "numa_node",
706 "cpu_model", "cpu_family"
708 content = cpu.to_dict()
710 filter(lambda item: item[0] in selected_keys, content.items()))
711 setattr(cpu, 'filtered', filtered)
712 setattr(cpu, 'name', cpu.ihost_uuid.split(
713 '-', 1)[0] + '-cpu-'+str(cpu.cpu))
717 def _memconverter(mem):
719 "memtotal_mib", "memavail_mib", "vm_hugepages_use_1G",
720 "vm_hugepages_possible_1G", "hugepages_configured",
721 "vm_hugepages_avail_1G", "vm_hugepages_nr_1G",
722 "vm_hugepages_nr_4K", "vm_hugepages_nr_2M",
723 "vm_hugepages_possible_2M", "vm_hugepages_avail_2M",
724 "platform_reserved_mib", "numa_node"
726 content = mem.to_dict()
728 filter(lambda item: item[0] in selected_keys, content.items()))
729 setattr(mem, 'filtered', filtered)
730 setattr(mem, 'name', mem.ihost_uuid.split('-', 1)[0] +
731 '-mem-node-'+str(mem.numa_node))
735 def _ethconverter(eth):
737 "name", "namedisplay", "dev_id", "pdevice", "capabilities",
738 "type", "driver", "mac", "numa_node",
739 "pciaddr", "pclass", "psvendor", "psdevice",
740 "sriov_totalvfs", "sriov_numvfs", "dpdksupport",
741 "sriov_vf_driver", "sriov_vf_pdevice_id", "interface_uuid"
743 content = eth.to_dict()
745 filter(lambda item: item[0] in selected_keys, content.items()))
746 setattr(eth, 'filtered', filtered)
747 setattr(eth, 'name', eth.host_uuid.split('-', 1)[0] + '-'+eth.name)
748 setattr(eth, 'updated_at', None)
749 setattr(eth, 'created_at', None)
753 def _ifconverter(ifs):
755 "ifname", "iftype", "imac", "vlan_id", "imtu",
756 "ifclass", "uses", "max_tx_rate",
757 "sriov_vf_driver", "sriov_numvfs", "ptp_role"
759 content = ifs.to_dict()
761 filter(lambda item: item[0] in selected_keys, content.items()))
762 setattr(ifs, 'filtered', filtered)
763 setattr(ifs, 'name', ifs.ihost_uuid.split('-', 1)[0] + '-'+ifs.ifname)
764 setattr(ifs, 'updated_at', None)
765 setattr(ifs, 'created_at', None)
769 def _devconverter(dev):
771 "name", "pdevice", "pciaddr", "pvendor_id", "pvendor",
772 "pclass_id", "pclass", "psvendor", "psdevice",
773 "sriov_totalvfs", "sriov_numvfs", "numa_node"
775 content = dev.to_dict()
777 filter(lambda item: item[0] in selected_keys, content.items()))
778 setattr(dev, 'filtered', filtered)
779 setattr(dev, 'name', dev.host_uuid.split('-', 1)[0] + '-'+dev.name)
783 def _k8sconverter(cluster):
784 setattr(cluster, 'name', cluster.cloud_name +
785 '.' + cluster.cluster_name)
786 setattr(cluster, 'uuid',
787 uuid.uuid3(uuid.NAMESPACE_URL, cluster.cloud_uuid))
788 setattr(cluster, 'updated_at', None)
789 setattr(cluster, 'created_at', None)
790 setattr(cluster, 'events', [])
791 logger.debug('k8s cluster name/uuid:' +
792 cluster.name + '/' + str(cluster.uuid))
796 def _k8shasher(cluster):
797 return str(hash((cluster.cluster_name, cluster.cloud_name,
798 cluster.cluster_api_endpoint, cluster.admin_user,
799 cluster.capabilities)))