Fix INF-364 alarmEventRecord does not comply with spec
[pti/o2.git] / o2ims / adapter / clients / ocloud_sa_client.py
1 # Copyright (C) 2021 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
27
28 from o2common.helper import o2logging
29 logger = o2logging.get_logger(__name__)
30
31
32 class StxSaOcloudClient(BaseClient):
33     def __init__(self, driver=None):
34         super().__init__()
35         self.driver = driver if driver else StxSaClientImp()
36
37     def _get(self, id) -> ocloudModel.StxGenericModel:
38         return self.driver.getInstanceInfo()
39
40     def _list(self, **filters):
41         return [self.driver.getInstanceInfo()]
42
43
44 class StxSaResourcePoolClient(BaseClient):
45     def __init__(self):
46         super().__init__()
47         self.driver = StxSaClientImp()
48
49     def _get(self, id) -> ocloudModel.StxGenericModel:
50         return self.driver.getInstanceInfo()
51
52     def _list(self, **filters):
53         return [self.driver.getInstanceInfo()]
54
55
56 class StxSaDmsClient(BaseClient):
57     def __init__(self):
58         super().__init__()
59         self.driver = StxSaClientImp()
60
61     def _get(self, name) -> ocloudModel.StxGenericModel:
62         return self.driver.getK8sDetail(name)
63
64     def _list(self, **filters):
65         return self.driver.getK8sList(**filters)
66
67
68 class StxPserverClient(BaseClient):
69     def __init__(self):
70         super().__init__()
71         self.driver = StxSaClientImp()
72
73     def _get(self, id) -> ocloudModel.StxGenericModel:
74         return self.driver.getPserver(id)
75
76     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
77         return self.driver.getPserverList(**filters)
78
79
80 class StxCpuClient(BaseClient):
81     def __init__(self):
82         super().__init__()
83         # self._pserver_id = pserver_id
84         self.driver = StxSaClientImp()
85
86     def _get(self, id) -> ocloudModel.StxGenericModel:
87         return self.driver.getCpu(id)
88
89     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
90         return self.driver.getCpuList(**filters)
91
92
93 class StxMemClient(BaseClient):
94     def __init__(self):
95         super().__init__()
96         self.driver = StxSaClientImp()
97
98     def _get(self, id) -> ocloudModel.StxGenericModel:
99         return self.driver.getMem(id)
100
101     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
102         return self.driver.getMemList(**filters)
103
104
105 class StxEthClient(BaseClient):
106     def __init__(self):
107         super().__init__()
108         self.driver = StxSaClientImp()
109
110     def _get(self, id) -> ocloudModel.StxGenericModel:
111         return self.driver.getEthernet(id)
112
113     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
114         return self.driver.getEthernetList(**filters)
115
116
117 class StxIfClient(BaseClient):
118     def __init__(self):
119         super().__init__()
120         self.driver = StxSaClientImp()
121
122     def _get(self, id) -> ocloudModel.StxGenericModel:
123         return self.driver.getIf(id)
124
125     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
126         return self.driver.getIfList(**filters)
127
128
129 class StxIfPortClient(BaseClient):
130     def __init__(self):
131         super().__init__()
132         self.driver = StxSaClientImp()
133
134     def _get(self, id) -> ocloudModel.StxGenericModel:
135         return self.driver.getPort(id)
136
137     def _list(self, **filters) -> List[ocloudModel.StxGenericModel]:
138         return self.driver.getPortList(**filters)
139
140
141 # internal driver which implement client call to Stx Standalone instance
142 class StxSaClientImp(object):
143     def __init__(self, stx_client=None):
144         super().__init__()
145         self.stxclient = stx_client if stx_client else self.getStxClient()
146
147     def getStxClient(self):
148         os_client_args = config.get_stx_access_info()
149         config_client = get_client(**os_client_args)
150         return config_client
151
152     def getInstanceInfo(self) -> ocloudModel.StxGenericModel:
153         systems = self.stxclient.isystem.list()
154         logger.debug('systems:' + str(systems[0].to_dict()))
155         return ocloudModel.StxGenericModel(
156             ResourceTypeEnum.OCLOUD, systems[0]) if systems else None
157
158     def getPserverList(self, **filters) -> List[ocloudModel.StxGenericModel]:
159         # resourcepoolid = filters.get("resourcepoolid", None)
160         hosts = self.stxclient.ihost.list()
161         logger.debug('host 1:' + str(hosts[0].to_dict()))
162         return [ocloudModel.StxGenericModel(
163             ResourceTypeEnum.PSERVER, self._hostconverter(host))
164             for host in hosts if host and host.availability == 'available']
165
166     def getPserver(self, id) -> ocloudModel.StxGenericModel:
167         host = self.stxclient.ihost.get(id)
168         logger.debug('host:' + str(host.to_dict()))
169         return ocloudModel.StxGenericModel(
170             ResourceTypeEnum.PSERVER, self._hostconverter(host))
171
172     def getK8sList(self, **filters) -> List[ocloudModel.StxGenericModel]:
173         k8sclusters = self.stxclient.kube_cluster.list()
174         logger.debug('k8sresources[0]:' + str(k8sclusters[0].to_dict()))
175         return [ocloudModel.StxGenericModel(
176             ResourceTypeEnum.DMS,
177             self._k8sconverter(k8sres), self._k8shasher(k8sres))
178             for k8sres in k8sclusters if k8sres]
179
180     def getK8sDetail(self, name) -> ocloudModel.StxGenericModel:
181         if not name:
182             k8sclusters = self.stxclient.kube_cluster.list()
183             # logger.debug("k8sresources[0]:" + str(k8sclusters[0].to_dict()))
184             k8scluster = k8sclusters.pop()
185         else:
186             k8scluster = self.stxclient.kube_cluster.get(name)
187
188         if not k8scluster:
189             return None
190         logger.debug('k8sresource:' + str(k8scluster.to_dict()))
191         return ocloudModel.StxGenericModel(
192             ResourceTypeEnum.DMS,
193             self._k8sconverter(k8scluster), self._k8shasher(k8scluster))
194
195     def getCpuList(self, **filters) -> List[ocloudModel.StxGenericModel]:
196         hostid = filters.get('hostid', None)
197         assert (hostid is not None), 'missing hostid to query icpu list'
198         cpulist = self.stxclient.icpu.list(hostid)
199         return [ocloudModel.StxGenericModel(
200             ResourceTypeEnum.PSERVER_CPU,
201             self._cpuconverter(cpures)) for cpures in cpulist if cpures]
202
203     def getCpu(self, id) -> ocloudModel.StxGenericModel:
204         cpuinfo = self.stxclient.icpu.get(id)
205         return ocloudModel.StxGenericModel(
206             ResourceTypeEnum.PSERVER_CPU, self._cpuconverter(cpuinfo))
207
208     def getMemList(self, **filters) -> List[ocloudModel.StxGenericModel]:
209         hostid = filters.get('hostid', None)
210         assert (hostid is not None), 'missing hostid to query imem list'
211         memlist = self.stxclient.imemory.list(hostid)
212         return [ocloudModel.StxGenericModel(
213             ResourceTypeEnum.PSERVER_RAM,
214             self._memconverter(memories)) for memories in memlist if memories]
215
216     def getMem(self, id) -> ocloudModel.StxGenericModel:
217         meminfo = self.stxclient.imemory.get(id)
218         return ocloudModel.StxGenericModel(
219             ResourceTypeEnum.PSERVER_RAM, self._memconverter(meminfo))
220
221     def getEthernetList(self, **filters) -> List[ocloudModel.StxGenericModel]:
222         hostid = filters.get('hostid', None)
223         assert (hostid is not None), 'missing hostid to query port list'
224         ethlist = self.stxclient.ethernet_port.list(hostid)
225         return [ocloudModel.StxGenericModel(
226             ResourceTypeEnum.PSERVER_ETH,
227             self._ethconverter(eth)) for eth in ethlist if eth]
228
229     def getEthernet(self, id) -> ocloudModel.StxGenericModel:
230         ethinfo = self.stxclient.ethernet_port.get(id)
231         return ocloudModel.StxGenericModel(
232             ResourceTypeEnum.PSERVER_ETH, self._ethconverter(ethinfo))
233
234     def getIfList(self, **filters) -> List[ocloudModel.StxGenericModel]:
235         hostid = filters.get('hostid', None)
236         assert (hostid is not None), 'missing hostid to query iinterface list'
237         iflist = self.stxclient.iinterface.list(hostid)
238         return [ocloudModel.StxGenericModel(
239             ResourceTypeEnum.PSERVER_IF,
240             self._ifconverter(ifs)) for ifs in iflist if ifs]
241
242     def getIf(self, id) -> ocloudModel.StxGenericModel:
243         ifinfo = self.stxclient.iinterface.get(id)
244         return ocloudModel.StxGenericModel(
245             ResourceTypeEnum.PSERVER_IF, self._ifconverter(ifinfo))
246
247     def getPortList(self, **filters) -> List[ocloudModel.StxGenericModel]:
248         ifid = filters.get('interfaceid', None)
249         assert (ifid is not None), 'missing interface id to query port list'
250         portlist = self.stxclient.iinterface.list_ports(ifid)
251         return [ocloudModel.StxGenericModel(
252             ResourceTypeEnum.PSERVER_IF_PORT,
253             port) for port in portlist if port]
254
255     def getPort(self, id) -> ocloudModel.StxGenericModel:
256         portinfo = self.stxclient.port.get(id)
257         return ocloudModel.StxGenericModel(
258             ResourceTypeEnum.PSERVER_IF_PORT, portinfo)
259
260     def _getIsystems(self):
261         return self.stxclient.isystem.list()
262
263     def _getIsystem(self, id=None):
264         if id:
265             return self.stxclient.isystem.get(id)
266         else:
267             isystems = self.stxclient.isystem.list()
268             if len(isystems) != 1 and not id:
269                 raise Exception('No system uuid was provided and '
270                                 'more than one system exists in the account.')
271             return isystems[0]
272
273     @ staticmethod
274     def _hostconverter(host):
275         setattr(host, 'name', host.hostname)
276         return host
277
278     @ staticmethod
279     def _cpuconverter(cpu):
280         setattr(cpu, 'name', cpu.ihost_uuid.split(
281             '-', 1)[0] + '-cpu-'+str(cpu.cpu))
282         return cpu
283
284     @ staticmethod
285     def _memconverter(mem):
286         setattr(mem, 'name', mem.ihost_uuid.split('-', 1)[0] +
287                 '-mem-node-'+str(mem.numa_node))
288         return mem
289
290     @ staticmethod
291     def _ethconverter(eth):
292         setattr(eth, 'name', eth.host_uuid.split('-', 1)[0] + '-'+eth.name)
293         setattr(eth, 'updated_at', None)
294         setattr(eth, 'created_at', None)
295         return eth
296
297     @ staticmethod
298     def _ifconverter(ifs):
299         setattr(ifs, 'name', ifs.ihost_uuid.split('-', 1)[0] + '-'+ifs.ifname)
300         setattr(ifs, 'updated_at', None)
301         setattr(ifs, 'created_at', None)
302         return ifs
303
304     @ staticmethod
305     def _k8sconverter(cluster):
306         setattr(cluster, 'name', cluster.cluster_name)
307         setattr(cluster, 'uuid',
308                 uuid.uuid3(uuid.NAMESPACE_URL, cluster.cluster_name))
309         setattr(cluster, 'updated_at', None)
310         setattr(cluster, 'created_at', None)
311         setattr(cluster, 'events', [])
312         logger.debug('k8s cluster name/uuid:' +
313                      cluster.name + '/' + str(cluster.uuid))
314         return cluster
315
316     @ staticmethod
317     def _k8shasher(cluster):
318         return str(hash((cluster.cluster_name,
319                          cluster.cluster_api_endpoint, cluster.admin_user)))