fix 1183: Delete native charms before destroying juju model
[osm/LCM.git] / osm_lcm / ROclient.py
1 #!/usr/bin/env python3
2 # -*- coding: utf-8 -*-
3
4 ##
5 # Copyright 2015 Telefónica Investigación y Desarrollo, S.A.U.
6 #
7 # Licensed under the Apache License, Version 2.0 (the "License"); you may
8 # not use this file except in compliance with the License. You may obtain
9 # a copy of the License at
10 #
11 # http://www.apache.org/licenses/LICENSE-2.0
12 #
13 # Unless required by applicable law or agreed to in writing, software
14 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
15 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
16 # License for the specific language governing permissions and limitations
17 # under the License.
18 #
19 ##
20
21 """
22 asyncio RO python client to interact with RO-server
23 """
24
25 import asyncio
26 import aiohttp
27 import json
28 import yaml
29 import logging
30 from urllib.parse import quote
31 from uuid import UUID
32 from copy import deepcopy
33
34 __author__ = "Alfonso Tierno"
35 __date__ = "$09-Jan-2018 09:09:48$"
36 __version__ = "0.1.2"
37 version_date = "2018-05-16"
38 requests = None
39
40
41 class ROClientException(Exception):
42 def __init__(self, message, http_code=400):
43 """Common Exception for all RO client exceptions"""
44 self.http_code = http_code
45 Exception.__init__(self, message)
46
47
48 def remove_envelop(item, indata=None):
49 """
50 Obtain the useful data removing the envelop. It goes through the vnfd or nsd catalog and returns the
51 vnfd or nsd content
52 :param item: can be 'tenant', 'vim', 'vnfd', 'nsd', 'ns'
53 :param indata: Content to be inspected
54 :return: the useful part of indata (a reference, not a new dictionay)
55 """
56 clean_indata = indata
57 if not indata:
58 return {}
59 if item == "vnfd":
60 if clean_indata.get('vnfd:vnfd-catalog'):
61 clean_indata = clean_indata['vnfd:vnfd-catalog']
62 elif clean_indata.get('vnfd-catalog'):
63 clean_indata = clean_indata['vnfd-catalog']
64 if clean_indata.get('vnfd'):
65 if not isinstance(clean_indata['vnfd'], list) or len(clean_indata['vnfd']) != 1:
66 raise ROClientException("'vnfd' must be a list only one element")
67 clean_indata = clean_indata['vnfd'][0]
68 elif item == "nsd":
69 if clean_indata.get('nsd:nsd-catalog'):
70 clean_indata = clean_indata['nsd:nsd-catalog']
71 elif clean_indata.get('nsd-catalog'):
72 clean_indata = clean_indata['nsd-catalog']
73 if clean_indata.get('nsd'):
74 if not isinstance(clean_indata['nsd'], list) or len(clean_indata['nsd']) != 1:
75 raise ROClientException("'nsd' must be a list only one element")
76 clean_indata = clean_indata['nsd'][0]
77 elif item == "sdn":
78 if len(indata) == 1 and "sdn_controller" in indata:
79 clean_indata = indata["sdn_controller"]
80 elif item == "tenant":
81 if len(indata) == 1 and "tenant" in indata:
82 clean_indata = indata["tenant"]
83 elif item in ("vim", "vim_account", "datacenters"):
84 if len(indata) == 1 and "datacenter" in indata:
85 clean_indata = indata["datacenter"]
86 elif item == "wim":
87 if len(indata) == 1 and "wim" in indata:
88 clean_indata = indata["wim"]
89 elif item == "wim_account":
90 if len(indata) == 1 and "wim_account" in indata:
91 clean_indata = indata["wim_account"]
92 elif item == "ns" or item == "instances":
93 if len(indata) == 1 and "instance" in indata:
94 clean_indata = indata["instance"]
95 else:
96 assert False, "remove_envelop with unknown item {}".format(item)
97
98 return clean_indata
99
100
101 class ROClient:
102 headers_req = {'Accept': 'application/yaml', 'content-type': 'application/yaml'}
103 client_to_RO = {'tenant': 'tenants', 'vim': 'datacenters', 'vim_account': 'datacenters', 'sdn': 'sdn_controllers',
104 'vnfd': 'vnfs', 'nsd': 'scenarios', 'wim': 'wims', 'wim_account': 'wims',
105 'ns': 'instances'}
106 mandatory_for_create = {
107 'tenant': ("name", ),
108 'vnfd': ("name", "id"),
109 'nsd': ("name", "id"),
110 'ns': ("name", "scenario", "datacenter"),
111 'vim': ("name", "vim_url"),
112 'wim': ("name", "wim_url"),
113 'vim_account': (),
114 'wim_account': (),
115 'sdn': ("name", 'type'),
116 }
117 timeout_large = 120
118 timeout_short = 30
119
120 def __init__(self, loop, uri, **kwargs):
121 self.loop = loop
122 self.uri = uri
123
124 self.username = kwargs.get("username")
125 self.password = kwargs.get("password")
126 self.tenant_id_name = kwargs.get("tenant")
127 self.tenant = None
128 self.datacenter_id_name = kwargs.get("datacenter")
129 self.datacenter = None
130 logger_name = kwargs.get('logger_name', 'lcm.ro')
131 self.logger = logging.getLogger(logger_name)
132 if kwargs.get("loglevel"):
133 self.logger.setLevel(kwargs["loglevel"])
134 global requests
135 requests = kwargs.get("TODO remove")
136
137 def __getitem__(self, index):
138 if index == 'tenant':
139 return self.tenant_id_name
140 elif index == 'datacenter':
141 return self.datacenter_id_name
142 elif index == 'username':
143 return self.username
144 elif index == 'password':
145 return self.password
146 elif index == 'uri':
147 return self.uri
148 else:
149 raise KeyError("Invalid key '{}'".format(index))
150
151 def __setitem__(self, index, value):
152 if index == 'tenant':
153 self.tenant_id_name = value
154 elif index == 'datacenter' or index == 'vim':
155 self.datacenter_id_name = value
156 elif index == 'username':
157 self.username = value
158 elif index == 'password':
159 self.password = value
160 elif index == 'uri':
161 self.uri = value
162 else:
163 raise KeyError("Invalid key '{}'".format(index))
164 self.tenant = None # force to reload tenant with different credentials
165 self.datacenter = None # force to reload datacenter with different credentials
166
167 def _parse(self, descriptor, descriptor_format, response=False):
168 if descriptor_format and descriptor_format != "json" and descriptor_format != "yaml":
169 raise ROClientException("'descriptor_format' must be a 'json' or 'yaml' text")
170 if descriptor_format != "json":
171 try:
172 return yaml.load(descriptor)
173 except yaml.YAMLError as exc:
174 error_pos = ""
175 if hasattr(exc, 'problem_mark'):
176 mark = exc.problem_mark
177 error_pos = " at line:{} column:{}s".format(mark.line + 1, mark.column + 1)
178 error_text = "yaml format error" + error_pos
179 elif descriptor_format != "yaml":
180 try:
181 return json.loads(descriptor)
182 except Exception as e:
183 if response:
184 error_text = "json format error" + str(e)
185
186 if response:
187 raise ROClientException(error_text)
188 raise ROClientException(error_text)
189
190 def _parse_yaml(self, descriptor, response=False):
191 try:
192 return yaml.load(descriptor, Loader=yaml.Loader)
193 except yaml.YAMLError as exc:
194 error_pos = ""
195 if hasattr(exc, 'problem_mark'):
196 mark = exc.problem_mark
197 error_pos = " at line:{} column:{}s".format(mark.line + 1, mark.column + 1)
198 error_text = "yaml format error" + error_pos
199 if response:
200 raise ROClientException(error_text)
201 raise ROClientException(error_text)
202
203 @staticmethod
204 def check_if_uuid(uuid_text):
205 """
206 Check if text correspond to an uuid foramt
207 :param uuid_text:
208 :return: True if it is an uuid False if not
209 """
210 try:
211 UUID(uuid_text)
212 return True
213 except Exception:
214 return False
215
216 @staticmethod
217 def _create_envelop(item, indata=None):
218 """
219 Returns a new dict that incledes indata with the expected envelop
220 :param item: can be 'tenant', 'vim', 'vnfd', 'nsd', 'ns'
221 :param indata: Content to be enveloped
222 :return: a new dic with {<envelop>: {indata} } where envelop can be e.g. tenant, datacenter, ...
223 """
224 if item == "vnfd":
225 return {'vnfd-catalog': {'vnfd': [indata]}}
226 elif item == "nsd":
227 return {'nsd-catalog': {'nsd': [indata]}}
228 elif item == "tenant":
229 return {'tenant': indata}
230 elif item in ("vim", "vim_account", "datacenter"):
231 return {'datacenter': indata}
232 elif item == "wim":
233 return {'wim': indata}
234 elif item == "wim_account":
235 return {'wim_account': indata}
236 elif item == "ns" or item == "instances":
237 return {'instance': indata}
238 elif item == "sdn":
239 return {'sdn_controller': indata}
240 else:
241 assert False, "_create_envelop with unknown item {}".format(item)
242
243 @staticmethod
244 def update_descriptor(desc, kwargs):
245 desc = deepcopy(desc) # do not modify original descriptor
246 try:
247 for k, v in kwargs.items():
248 update_content = desc
249 kitem_old = None
250 klist = k.split(".")
251 for kitem in klist:
252 if kitem_old is not None:
253 update_content = update_content[kitem_old]
254 if isinstance(update_content, dict):
255 kitem_old = kitem
256 elif isinstance(update_content, list):
257 kitem_old = int(kitem)
258 else:
259 raise ROClientException(
260 "Invalid query string '{}'. Descriptor is not a list nor dict at '{}'".format(k, kitem))
261 if v == "__DELETE__":
262 del update_content[kitem_old]
263 else:
264 update_content[kitem_old] = v
265 return desc
266 except KeyError:
267 raise ROClientException(
268 "Invalid query string '{}'. Descriptor does not contain '{}'".format(k, kitem_old))
269 except ValueError:
270 raise ROClientException("Invalid query string '{}'. Expected integer index list instead of '{}'".format(
271 k, kitem))
272 except IndexError:
273 raise ROClientException(
274 "Invalid query string '{}'. Index '{}' out of range".format(k, kitem_old))
275
276 @staticmethod
277 def check_ns_status(ns_descriptor):
278 """
279 Inspect RO instance descriptor and indicates the status
280 :param ns_descriptor: instance descriptor obtained with self.show("ns", )
281 :return: status, message: status can be BUILD,ACTIVE,ERROR, message is a text message
282 """
283 error_list = []
284 total = {"VMs": 0, "networks": 0, "SDN_networks": 0}
285 done = {"VMs": 0, "networks": 0, "SDN_networks": 0}
286
287 def _get_ref(desc):
288 # return an identification for the network or vm. Try vim_id if exist, if not descriptor id for net
289 if desc.get("vim_net_id"):
290 return "'vim-id={}'".format(desc["vim_net_id"])
291 elif desc.get("ns_net_osm_id"):
292 return "'nsd-vld-id={}'".format(desc["ns_net_osm_id"])
293 elif desc.get("vnf_net_osm_id"):
294 return "'vnfd-vld-id={}'".format(desc["vnf_net_osm_id"])
295 # for VM
296 elif desc.get("vim_vm_id"):
297 return "'vim-id={}'".format(desc["vim_vm_id"])
298 elif desc.get("vdu_osm_id"):
299 return "'vnfd-vdu-id={}'".format(desc["vdu_osm_id"])
300 else:
301 return ""
302
303 def _get_sdn_ref(sce_net_id):
304 # look for the network associated to the SDN network and obtain the identification
305 net = next((x for x in ns_descriptor["nets"] if x.get("sce_net_id") == sce_net_id), None)
306 if not sce_net_id or not net:
307 return ""
308 return _get_ref(net)
309
310 try:
311 total["networks"] = len(ns_descriptor["nets"])
312 for net in ns_descriptor["nets"]:
313 if net["status"] in ("ERROR", "VIM_ERROR"):
314 error_list.append("VIM network ({}) on error: {}".format(_get_ref(net), net["error_msg"]))
315 elif net["status"] == "ACTIVE":
316 done["networks"] += 1
317
318 total["SDN_networks"] = len(ns_descriptor["sdn_nets"])
319 for sdn_net in ns_descriptor["sdn_nets"]:
320 if sdn_net["status"] in ("ERROR", "VIM_ERROR", "WIM_ERROR"):
321 error_list.append("SDN network ({}) on error: {}".format(_get_sdn_ref(sdn_net.get("sce_net_id")),
322 sdn_net["error_msg"]))
323 elif sdn_net["status"] == "ACTIVE":
324 done["SDN_networks"] += 1
325
326 for vnf in ns_descriptor["vnfs"]:
327 for vm in vnf["vms"]:
328 total["VMs"] += 1
329 if vm["status"] in ("ERROR", "VIM_ERROR"):
330 error_list.append("VIM VM ({}) on error: {}".format(_get_ref(vm), vm["error_msg"]))
331 elif vm["status"] == "ACTIVE":
332 done["VMs"] += 1
333 if error_list:
334 return "ERROR", "; ".join(error_list)
335 if all(total[x] == done[x] for x in total): # DONE == TOTAL for all items
336 return "ACTIVE", str({x: total[x] for x in total if total[x]}) # print only those which value is not 0
337 else:
338 return "BUILD", str({x: "{}/{}".format(done[x], total[x]) for x in total if total[x]})
339 # print done/total for each item if total is not 0
340 except Exception as e:
341 raise ROClientException("Unexpected RO ns descriptor. Wrong version? {}".format(e)) from e
342
343 @staticmethod
344 def check_action_status(action_descriptor):
345 """
346 Inspect RO instance descriptor and indicates the status
347 :param action_descriptor: action instance descriptor obtained with self.show("ns", "action")
348 :return: status, message: status can be BUILD,ACTIVE,ERROR, message is a text message
349 """
350 net_total = 0
351 vm_total = 0
352 net_done = 0
353 vm_done = 0
354 other_total = 0
355 other_done = 0
356
357 for vim_action_set in action_descriptor["actions"]:
358 for vim_action in vim_action_set["vim_wim_actions"]:
359 if vim_action["item"] == "instance_vms":
360 vm_total += 1
361 elif vim_action["item"] == "instance_nets":
362 net_total += 1
363 else:
364 other_total += 1
365 if vim_action["status"] == "FAILED":
366 return "ERROR", vim_action["error_msg"]
367 elif vim_action["status"] in ("DONE", "SUPERSEDED", "FINISHED"):
368 if vim_action["item"] == "instance_vms":
369 vm_done += 1
370 elif vim_action["item"] == "instance_nets":
371 net_done += 1
372 else:
373 other_done += 1
374
375 if net_total == net_done and vm_total == vm_done and other_total == other_done:
376 return "ACTIVE", "VMs {}, networks: {}, other: {} ".format(vm_total, net_total, other_total)
377 else:
378 return "BUILD", "VMs: {}/{}, networks: {}/{}, other: {}/{}".format(vm_done, vm_total, net_done, net_total,
379 other_done, other_total)
380
381 @staticmethod
382 def get_ns_vnf_info(ns_descriptor):
383 """
384 Get a dict with the VIM_id, ip_addresses, mac_addresses of every vnf and vdu
385 :param ns_descriptor: instance descriptor obtained with self.show("ns", )
386 :return: dict with:
387 <member_vnf_index>:
388 ip_address: XXXX,
389 vdur:
390 <vdu_osm_id>:
391 ip_address: XXX
392 vim_id: XXXX
393 interfaces:
394 <name>:
395 ip_address: XXX
396 mac_address: XXX
397 """
398 ns_info = {}
399 for vnf in ns_descriptor["vnfs"]:
400 if not vnf.get("ip_address") and vnf.get("vms"):
401 raise ROClientException("ns member_vnf_index '{}' has no IP address".format(
402 vnf["member_vnf_index"]), http_code=409)
403 vnfr_info = {
404 "ip_address": vnf.get("ip_address"),
405 "vdur": {}
406 }
407 for vm in vnf["vms"]:
408 vdur = {
409 "vim_id": vm.get("vim_vm_id"),
410 "ip_address": vm.get("ip_address"),
411 "interfaces": {}
412 }
413 for iface in vm["interfaces"]:
414 if iface.get("type") == "mgmt" and not iface.get("ip_address"):
415 raise ROClientException("ns member_vnf_index '{}' vm '{}' management interface '{}' has no IP "
416 "address".format(vnf["member_vnf_index"], vm["vdu_osm_id"],
417 iface["external_name"]), http_code=409)
418 vdur["interfaces"][iface["internal_name"]] = {"ip_address": iface.get("ip_address"),
419 "mac_address": iface.get("mac_address"),
420 "vim_id": iface.get("vim_interface_id"),
421 }
422 vnfr_info["vdur"][vm["vdu_osm_id"]] = vdur
423 ns_info[str(vnf["member_vnf_index"])] = vnfr_info
424 return ns_info
425
426 async def _get_item_uuid(self, session, item, item_id_name, all_tenants=False):
427 if all_tenants:
428 tenant_text = "/any"
429 elif all_tenants is None:
430 tenant_text = ""
431 else:
432 if not self.tenant:
433 await self._get_tenant(session)
434 tenant_text = "/" + self.tenant
435
436 item_id = 0
437 url = "{}{}/{}".format(self.uri, tenant_text, item)
438 if self.check_if_uuid(item_id_name):
439 item_id = item_id_name
440 url += "/" + item_id_name
441 elif item_id_name and item_id_name.startswith("'") and item_id_name.endswith("'"):
442 item_id_name = item_id_name[1:-1]
443 self.logger.debug("RO GET %s", url)
444 # timeout = aiohttp.ClientTimeout(total=self.timeout_short)
445 async with session.get(url, headers=self.headers_req) as response:
446 response_text = await response.read()
447 self.logger.debug("GET {} [{}] {}".format(url, response.status, response_text[:100]))
448 if response.status == 404: # NOT_FOUND
449 raise ROClientException("No {} found with id '{}'".format(item[:-1], item_id_name),
450 http_code=404)
451 if response.status >= 300:
452 raise ROClientException(response_text, http_code=response.status)
453 content = self._parse_yaml(response_text, response=True)
454
455 if item_id:
456 return item_id
457 desc = content[item]
458 assert isinstance(desc, list), "_get_item_uuid get a non dict with a list inside {}".format(type(desc))
459 uuid = None
460 for i in desc:
461 if item_id_name and i["name"] != item_id_name:
462 continue
463 if uuid: # found more than one
464 raise ROClientException(
465 "Found more than one {} with name '{}'. uuid must be used".format(item, item_id_name),
466 http_code=404)
467 uuid = i["uuid"]
468 if not uuid:
469 raise ROClientException("No {} found with name '{}'".format(item[:-1], item_id_name), http_code=404)
470 return uuid
471
472 async def _get_item(self, session, item, item_id_name, extra_item=None, extra_item_id=None, all_tenants=False):
473 if all_tenants:
474 tenant_text = "/any"
475 elif all_tenants is None:
476 tenant_text = ""
477 else:
478 if not self.tenant:
479 await self._get_tenant(session)
480 tenant_text = "/" + self.tenant
481
482 if self.check_if_uuid(item_id_name):
483 uuid = item_id_name
484 else:
485 # check that exist
486 uuid = await self._get_item_uuid(session, item, item_id_name, all_tenants)
487
488 url = "{}{}/{}/{}".format(self.uri, tenant_text, item, uuid)
489 if extra_item:
490 url += "/" + extra_item
491 if extra_item_id:
492 url += "/" + extra_item_id
493 self.logger.debug("GET %s", url)
494 # timeout = aiohttp.ClientTimeout(total=self.timeout_short)
495 async with session.get(url, headers=self.headers_req) as response:
496 response_text = await response.read()
497 self.logger.debug("GET {} [{}] {}".format(url, response.status, response_text[:100]))
498 if response.status >= 300:
499 raise ROClientException(response_text, http_code=response.status)
500
501 return self._parse_yaml(response_text, response=True)
502
503 async def _get_tenant(self, session):
504 if not self.tenant:
505 self.tenant = await self._get_item_uuid(session, "tenants", self.tenant_id_name, None)
506 return self.tenant
507
508 async def _get_datacenter(self, session):
509 if not self.tenant:
510 await self._get_tenant(session)
511 if not self.datacenter:
512 self.datacenter = await self._get_item_uuid(session, "datacenters", self.datacenter_id_name, True)
513 return self.datacenter
514
515 async def _create_item(self, session, item, descriptor, item_id_name=None, action=None, all_tenants=False):
516 if all_tenants:
517 tenant_text = "/any"
518 elif all_tenants is None:
519 tenant_text = ""
520 else:
521 if not self.tenant:
522 await self._get_tenant(session)
523 tenant_text = "/" + self.tenant
524 payload_req = yaml.safe_dump(descriptor)
525 # print payload_req
526
527 api_version_text = ""
528 if item == "vnfs":
529 # assumes version v3 only
530 api_version_text = "/v3"
531 item = "vnfd"
532 elif item == "scenarios":
533 # assumes version v3 only
534 api_version_text = "/v3"
535 item = "nsd"
536
537 if not item_id_name:
538 uuid = ""
539 elif self.check_if_uuid(item_id_name):
540 uuid = "/{}".format(item_id_name)
541 else:
542 # check that exist
543 uuid = await self._get_item_uuid(session, item, item_id_name, all_tenants)
544 uuid = "/{}".format(uuid)
545 if not action:
546 action = ""
547 else:
548 action = "/{}".format(action)
549
550 url = "{}{apiver}{tenant}/{item}{id}{action}".format(self.uri, apiver=api_version_text,
551 tenant=tenant_text, item=item, id=uuid, action=action)
552 self.logger.debug("RO POST %s %s", url, payload_req)
553 # timeout = aiohttp.ClientTimeout(total=self.timeout_large)
554 async with session.post(url, headers=self.headers_req, data=payload_req) as response:
555 response_text = await response.read()
556 self.logger.debug("POST {} [{}] {}".format(url, response.status, response_text[:100]))
557 if response.status >= 300:
558 raise ROClientException(response_text, http_code=response.status)
559
560 return self._parse_yaml(response_text, response=True)
561
562 async def _del_item(self, session, item, item_id_name, all_tenants=False):
563 if all_tenants:
564 tenant_text = "/any"
565 elif all_tenants is None:
566 tenant_text = ""
567 else:
568 if not self.tenant:
569 await self._get_tenant(session)
570 tenant_text = "/" + self.tenant
571 if not self.check_if_uuid(item_id_name):
572 # check that exist
573 _all_tenants = all_tenants
574 if item in ("datacenters", 'wims'):
575 _all_tenants = True
576 uuid = await self._get_item_uuid(session, item, item_id_name, all_tenants=_all_tenants)
577 else:
578 uuid = item_id_name
579
580 url = "{}{}/{}/{}".format(self.uri, tenant_text, item, uuid)
581 self.logger.debug("DELETE %s", url)
582 # timeout = aiohttp.ClientTimeout(total=self.timeout_short)
583 async with session.delete(url, headers=self.headers_req) as response:
584 response_text = await response.read()
585 self.logger.debug("DELETE {} [{}] {}".format(url, response.status, response_text[:100]))
586 if response.status >= 300:
587 raise ROClientException(response_text, http_code=response.status)
588
589 return self._parse_yaml(response_text, response=True)
590
591 async def _list_item(self, session, item, all_tenants=False, filter_dict=None):
592 if all_tenants:
593 tenant_text = "/any"
594 elif all_tenants is None:
595 tenant_text = ""
596 else:
597 if not self.tenant:
598 await self._get_tenant(session)
599 tenant_text = "/" + self.tenant
600
601 url = "{}{}/{}".format(self.uri, tenant_text, item)
602 separator = "?"
603 if filter_dict:
604 for k in filter_dict:
605 url += separator + quote(str(k)) + "=" + quote(str(filter_dict[k]))
606 separator = "&"
607 self.logger.debug("RO GET %s", url)
608 # timeout = aiohttp.ClientTimeout(total=self.timeout_short)
609 async with session.get(url, headers=self.headers_req) as response:
610 response_text = await response.read()
611 self.logger.debug("GET {} [{}] {}".format(url, response.status, response_text[:100]))
612 if response.status >= 300:
613 raise ROClientException(response_text, http_code=response.status)
614
615 return self._parse_yaml(response_text, response=True)
616
617 async def _edit_item(self, session, item, item_id, descriptor, all_tenants=False):
618 if all_tenants:
619 tenant_text = "/any"
620 elif all_tenants is None:
621 tenant_text = ""
622 else:
623 if not self.tenant:
624 await self._get_tenant(session)
625 tenant_text = "/" + self.tenant
626
627 payload_req = yaml.safe_dump(descriptor)
628
629 # print payload_req
630 url = "{}{}/{}/{}".format(self.uri, tenant_text, item, item_id)
631 self.logger.debug("RO PUT %s %s", url, payload_req)
632 # timeout = aiohttp.ClientTimeout(total=self.timeout_large)
633 async with session.put(url, headers=self.headers_req, data=payload_req) as response:
634 response_text = await response.read()
635 self.logger.debug("PUT {} [{}] {}".format(url, response.status, response_text[:100]))
636 if response.status >= 300:
637 raise ROClientException(response_text, http_code=response.status)
638
639 return self._parse_yaml(response_text, response=True)
640
641 async def get_version(self):
642 """
643 Obtain RO server version.
644 :return: a list with integers ["major", "minor", "release"]. Raises ROClientException on Error,
645 """
646 try:
647 response_text = ""
648 async with aiohttp.ClientSession(loop=self.loop) as session:
649 url = "{}/version".format(self.uri)
650 self.logger.debug("RO GET %s", url)
651 # timeout = aiohttp.ClientTimeout(total=self.timeout_short)
652 async with session.get(url, headers=self.headers_req) as response:
653 response_text = await response.read()
654 self.logger.debug("GET {} [{}] {}".format(url, response.status, response_text[:100]))
655 if response.status >= 300:
656 raise ROClientException(response_text, http_code=response.status)
657
658 for word in str(response_text).split(" "):
659 if "." in word:
660 version_text, _, _ = word.partition("-")
661 return version_text
662 raise ROClientException("Got invalid version text: '{}'".format(response_text), http_code=500)
663 except (aiohttp.ClientOSError, aiohttp.ClientError) as e:
664 raise ROClientException(e, http_code=504)
665 except asyncio.TimeoutError:
666 raise ROClientException("Timeout", http_code=504)
667 except Exception as e:
668 raise ROClientException("Got invalid version text: '{}'; causing exception {}".format(response_text, e),
669 http_code=500)
670
671 async def get_list(self, item, all_tenants=False, filter_by=None):
672 """
673 Obtain a list of items filtering by the specigy filter_by.
674 :param item: can be 'tenant', 'vim', 'vnfd', 'nsd', 'ns'
675 :param all_tenants: True if not filtering by tenant. Only allowed for admin
676 :param filter_by: dictionary with filtering
677 :return: a list of dict. It can be empty. Raises ROClientException on Error,
678 """
679 try:
680 if item not in self.client_to_RO:
681 raise ROClientException("Invalid item {}".format(item))
682 if item == 'tenant':
683 all_tenants = None
684 async with aiohttp.ClientSession(loop=self.loop) as session:
685 content = await self._list_item(session, self.client_to_RO[item], all_tenants=all_tenants,
686 filter_dict=filter_by)
687 if isinstance(content, dict):
688 if len(content) == 1:
689 for _, v in content.items():
690 return v
691 return content.values()[0]
692 else:
693 raise ROClientException("Output not a list neither dict with len equal 1", http_code=500)
694 return content
695 except (aiohttp.ClientOSError, aiohttp.ClientError) as e:
696 raise ROClientException(e, http_code=504)
697 except asyncio.TimeoutError:
698 raise ROClientException("Timeout", http_code=504)
699
700 async def show(self, item, item_id_name=None, extra_item=None, extra_item_id=None, all_tenants=False):
701 """
702 Obtain the information of an item from its id or name
703 :param item: can be 'tenant', 'vim', 'vnfd', 'nsd', 'ns'
704 :param item_id_name: RO id or name of the item. Raise and exception if more than one found
705 :param extra_item: if supplied, it is used to add to the URL.
706 Can be 'action' if item='ns'; 'networks' or'images' if item='vim'
707 :param extra_item_id: if supplied, it is used get details of a concrete extra_item.
708 :param all_tenants: True if not filtering by tenant. Only allowed for admin
709 :return: dictionary with the information or raises ROClientException on Error, NotFound, found several
710 """
711 try:
712 if item not in self.client_to_RO:
713 raise ROClientException("Invalid item {}".format(item))
714 if item == 'tenant':
715 all_tenants = None
716 elif item == 'vim':
717 all_tenants = True
718 elif item == 'vim_account':
719 all_tenants = False
720
721 async with aiohttp.ClientSession(loop=self.loop) as session:
722 content = await self._get_item(session, self.client_to_RO[item], item_id_name, extra_item=extra_item,
723 extra_item_id=extra_item_id, all_tenants=all_tenants)
724 return remove_envelop(item, content)
725 except (aiohttp.ClientOSError, aiohttp.ClientError) as e:
726 raise ROClientException(e, http_code=504)
727 except asyncio.TimeoutError:
728 raise ROClientException("Timeout", http_code=504)
729
730 async def delete(self, item, item_id_name=None, all_tenants=False):
731 """
732 Delete the information of an item from its id or name
733 :param item: can be 'tenant', 'vim', 'vnfd', 'nsd', 'ns'
734 :param item_id_name: RO id or name of the item. Raise and exception if more than one found
735 :param all_tenants: True if not filtering by tenant. Only allowed for admin
736 :return: dictionary with the information or raises ROClientException on Error, NotFound, found several
737 """
738 try:
739 if item not in self.client_to_RO:
740 raise ROClientException("Invalid item {}".format(item))
741 if item in ('tenant', 'vim', 'wim'):
742 all_tenants = None
743
744 async with aiohttp.ClientSession(loop=self.loop) as session:
745 result = await self._del_item(session, self.client_to_RO[item], item_id_name, all_tenants=all_tenants)
746 # in case of ns delete, get the action_id embeded in text
747 if item == "ns" and result.get("result"):
748 _, _, action_id = result["result"].partition("action_id=")
749 action_id, _, _ = action_id.partition(" ")
750 if action_id:
751 result["action_id"] = action_id
752 return result
753 except (aiohttp.ClientOSError, aiohttp.ClientError) as e:
754 raise ROClientException(e, http_code=504)
755 except asyncio.TimeoutError:
756 raise ROClientException("Timeout", http_code=504)
757
758 async def edit(self, item, item_id_name, descriptor=None, descriptor_format=None, **kwargs):
759 """ Edit an item
760 :param item: can be 'tenant', 'vim', 'vnfd', 'nsd', 'ns', 'vim'
761 :param item_id_name: RO id or name of the item. Raise and exception if more than one found
762 :param descriptor: can be a dict, or a yaml/json text. Autodetect unless descriptor_format is provided
763 :param descriptor_format: Can be 'json' or 'yaml'
764 :param kwargs: Overrides descriptor with values as name, description, vim_url, vim_url_admin, vim_type
765 keys can be a dot separated list to specify elements inside dict
766 :return: dictionary with the information or raises ROClientException on Error
767 """
768 try:
769 if isinstance(descriptor, str):
770 descriptor = self._parse(descriptor, descriptor_format)
771 elif descriptor:
772 pass
773 else:
774 descriptor = {}
775
776 if item not in self.client_to_RO:
777 raise ROClientException("Invalid item {}".format(item))
778 desc = remove_envelop(item, descriptor)
779
780 # Override descriptor with kwargs
781 if kwargs:
782 desc = self.update_descriptor(desc, kwargs)
783 all_tenants = False
784 if item in ('tenant', 'vim'):
785 all_tenants = None
786
787 create_desc = self._create_envelop(item, desc)
788
789 async with aiohttp.ClientSession(loop=self.loop) as session:
790 _all_tenants = all_tenants
791 if item == 'vim':
792 _all_tenants = True
793 item_id = await self._get_item_uuid(session, self.client_to_RO[item], item_id_name,
794 all_tenants=_all_tenants)
795 if item == 'vim':
796 _all_tenants = None
797 # await self._get_tenant(session)
798 outdata = await self._edit_item(session, self.client_to_RO[item], item_id, create_desc,
799 all_tenants=_all_tenants)
800 return remove_envelop(item, outdata)
801 except (aiohttp.ClientOSError, aiohttp.ClientError) as e:
802 raise ROClientException(e, http_code=504)
803 except asyncio.TimeoutError:
804 raise ROClientException("Timeout", http_code=504)
805
806 async def create(self, item, descriptor=None, descriptor_format=None, **kwargs):
807 """
808 Creates an item from its descriptor
809 :param item: can be 'tenant', 'vnfd', 'nsd', 'ns', 'vim', 'vim_account', 'sdn'
810 :param descriptor: can be a dict, or a yaml/json text. Autodetect unless descriptor_format is provided
811 :param descriptor_format: Can be 'json' or 'yaml'
812 :param kwargs: Overrides descriptor with values as name, description, vim_url, vim_url_admin, vim_type
813 keys can be a dot separated list to specify elements inside dict
814 :return: dictionary with the information or raises ROClientException on Error
815 """
816 try:
817 if isinstance(descriptor, str):
818 descriptor = self._parse(descriptor, descriptor_format)
819 elif descriptor:
820 pass
821 else:
822 descriptor = {}
823
824 if item not in self.client_to_RO:
825 raise ROClientException("Invalid item {}".format(item))
826 desc = remove_envelop(item, descriptor)
827
828 # Override descriptor with kwargs
829 if kwargs:
830 desc = self.update_descriptor(desc, kwargs)
831
832 for mandatory in self.mandatory_for_create[item]:
833 if mandatory not in desc:
834 raise ROClientException("'{}' is mandatory parameter for {}".format(mandatory, item))
835
836 all_tenants = False
837 if item in ('tenant', 'vim', 'wim'):
838 all_tenants = None
839
840 create_desc = self._create_envelop(item, desc)
841
842 async with aiohttp.ClientSession(loop=self.loop) as session:
843 outdata = await self._create_item(session, self.client_to_RO[item], create_desc,
844 all_tenants=all_tenants)
845 return remove_envelop(item, outdata)
846 except (aiohttp.ClientOSError, aiohttp.ClientError) as e:
847 raise ROClientException(e, http_code=504)
848 except asyncio.TimeoutError:
849 raise ROClientException("Timeout", http_code=504)
850
851 async def create_action(self, item, item_id_name, descriptor=None, descriptor_format=None, **kwargs):
852 """
853 Performs an action over an item
854 :param item: can be 'tenant', 'vnfd', 'nsd', 'ns', 'vim', 'vim_account', 'sdn'
855 :param item_id_name: RO id or name of the item. Raise and exception if more than one found
856 :param descriptor: can be a dict, or a yaml/json text. Autodetect unless descriptor_format is provided
857 :param descriptor_format: Can be 'json' or 'yaml'
858 :param kwargs: Overrides descriptor with values as name, description, vim_url, vim_url_admin, vim_type
859 keys can be a dot separated list to specify elements inside dict
860 :return: dictionary with the information or raises ROClientException on Error
861 """
862 try:
863 if isinstance(descriptor, str):
864 descriptor = self._parse(descriptor, descriptor_format)
865 elif descriptor:
866 pass
867 else:
868 descriptor = {}
869
870 if item not in self.client_to_RO:
871 raise ROClientException("Invalid item {}".format(item))
872 desc = remove_envelop(item, descriptor)
873
874 # Override descriptor with kwargs
875 if kwargs:
876 desc = self.update_descriptor(desc, kwargs)
877
878 all_tenants = False
879 if item in ('tenant', 'vim'):
880 all_tenants = None
881
882 action = None
883 if item == "vims":
884 action = "sdn_mapping"
885 elif item in ("vim_account", "ns"):
886 action = "action"
887
888 # create_desc = self._create_envelop(item, desc)
889 create_desc = desc
890
891 async with aiohttp.ClientSession(loop=self.loop) as session:
892 _all_tenants = all_tenants
893 if item == 'vim':
894 _all_tenants = True
895 # item_id = await self._get_item_uuid(session, self.client_to_RO[item], item_id_name,
896 # all_tenants=_all_tenants)
897 outdata = await self._create_item(session, self.client_to_RO[item], create_desc,
898 item_id_name=item_id_name, # item_id_name=item_id
899 action=action, all_tenants=_all_tenants)
900 return remove_envelop(item, outdata)
901 except (aiohttp.ClientOSError, aiohttp.ClientError) as e:
902 raise ROClientException(e, http_code=504)
903 except asyncio.TimeoutError:
904 raise ROClientException("Timeout", http_code=504)
905
906 async def attach(self, item, item_id_name=None, descriptor=None, descriptor_format=None, **kwargs):
907 """
908 Attach a datacenter or wim to a tenant, creating a vim_account, wim_account
909 :param item: can be vim_account or wim_account
910 :param item_id_name: id or name of the datacenter, wim
911 :param descriptor:
912 :param descriptor_format:
913 :param kwargs:
914 :return:
915 """
916 try:
917 if isinstance(descriptor, str):
918 descriptor = self._parse(descriptor, descriptor_format)
919 elif descriptor:
920 pass
921 else:
922 descriptor = {}
923
924 desc = remove_envelop(item, descriptor)
925
926 # # check that exist
927 # uuid = self._get_item_uuid(session, "datacenters", uuid_name, all_tenants=True)
928 # tenant_text = "/" + self._get_tenant()
929 if kwargs:
930 desc = self.update_descriptor(desc, kwargs)
931
932 if item == "vim_account":
933 if not desc.get("vim_tenant_name") and not desc.get("vim_tenant_id"):
934 raise ROClientException("Wrong descriptor. At least vim_tenant_name or vim_tenant_id must be "
935 "provided")
936 elif item != "wim_account":
937 raise ROClientException("Attach with unknown item {}. Must be 'vim_account' or 'wim_account'".
938 format(item))
939 create_desc = self._create_envelop(item, desc)
940 payload_req = yaml.safe_dump(create_desc)
941 async with aiohttp.ClientSession(loop=self.loop) as session:
942 # check that exist
943 item_id = await self._get_item_uuid(session, self.client_to_RO[item], item_id_name, all_tenants=True)
944 await self._get_tenant(session)
945
946 url = "{}/{tenant}/{item}/{item_id}".format(self.uri, tenant=self.tenant,
947 item=self.client_to_RO[item], item_id=item_id)
948 self.logger.debug("RO POST %s %s", url, payload_req)
949 # timeout = aiohttp.ClientTimeout(total=self.timeout_large)
950 async with session.post(url, headers=self.headers_req, data=payload_req) as response:
951 response_text = await response.read()
952 self.logger.debug("POST {} [{}] {}".format(url, response.status, response_text[:100]))
953 if response.status >= 300:
954 raise ROClientException(response_text, http_code=response.status)
955
956 response_desc = self._parse_yaml(response_text, response=True)
957 desc = remove_envelop(item, response_desc)
958 return desc
959 except (aiohttp.ClientOSError, aiohttp.ClientError) as e:
960 raise ROClientException(e, http_code=504)
961 except asyncio.TimeoutError:
962 raise ROClientException("Timeout", http_code=504)
963
964 async def detach(self, item, item_id_name=None):
965 # TODO replace the code with delete_item(vim_account,...)
966 try:
967 async with aiohttp.ClientSession(loop=self.loop) as session:
968 # check that exist
969 item_id = await self._get_item_uuid(session, self.client_to_RO[item], item_id_name, all_tenants=False)
970 tenant = await self._get_tenant(session)
971
972 url = "{}/{tenant}/{item}/{datacenter}".format(self.uri, tenant=tenant,
973 item=self.client_to_RO[item], datacenter=item_id)
974 self.logger.debug("RO DELETE %s", url)
975
976 # timeout = aiohttp.ClientTimeout(total=self.timeout_large)
977 async with session.delete(url, headers=self.headers_req) as response:
978 response_text = await response.read()
979 self.logger.debug("DELETE {} [{}] {}".format(url, response.status, response_text[:100]))
980 if response.status >= 300:
981 raise ROClientException(response_text, http_code=response.status)
982
983 response_desc = self._parse_yaml(response_text, response=True)
984 desc = remove_envelop(item, response_desc)
985 return desc
986 except (aiohttp.ClientOSError, aiohttp.ClientError) as e:
987 raise ROClientException(e, http_code=504)
988 except asyncio.TimeoutError:
989 raise ROClientException("Timeout", http_code=504)
990
991 # TODO convert to asyncio
992 # DATACENTERS
993
994 def edit_datacenter(self, uuid=None, name=None, descriptor=None, descriptor_format=None, all_tenants=False,
995 **kwargs):
996 """Edit the parameters of a datacenter
997 Params: must supply a descriptor or/and a parameter to change
998 uuid or/and name. If only name is supplied, there must be only one or an exception is raised
999 descriptor: with format {'datacenter':{params to change info}}
1000 must be a dictionary or a json/yaml text.
1001 parameters to change can be supplyied by the descriptor or as parameters:
1002 new_name: the datacenter name
1003 vim_url: the datacenter URL
1004 vim_url_admin: the datacenter URL for administrative issues
1005 vim_type: the datacenter type, can be openstack or openvim.
1006 public: boolean, available to other tenants
1007 description: datacenter description
1008 Return: Raises an exception on error, not found or found several
1009 Obtain a dictionary with format {'datacenter':{new_datacenter_info}}
1010 """
1011
1012 if isinstance(descriptor, str):
1013 descriptor = self.parse(descriptor, descriptor_format)
1014 elif descriptor:
1015 pass
1016 elif kwargs:
1017 descriptor = {"datacenter": {}}
1018 else:
1019 raise ROClientException("Missing descriptor")
1020
1021 if 'datacenter' not in descriptor or len(descriptor) != 1:
1022 raise ROClientException("Descriptor must contain only one 'datacenter' field")
1023 for param in kwargs:
1024 if param == 'new_name':
1025 descriptor['datacenter']['name'] = kwargs[param]
1026 else:
1027 descriptor['datacenter'][param] = kwargs[param]
1028 return self._edit_item("datacenters", descriptor, uuid, name, all_tenants=None)
1029
1030 def edit_scenario(self, uuid=None, name=None, descriptor=None, descriptor_format=None, all_tenants=False, **kwargs):
1031 """Edit the parameters of a scenario
1032 Params: must supply a descriptor or/and a parameters to change
1033 uuid or/and name. If only name is supplied, there must be only one or an exception is raised
1034 descriptor: with format {'scenario':{params to change info}}
1035 must be a dictionary or a json/yaml text.
1036 parameters to change can be supplyied by the descriptor or as parameters:
1037 new_name: the scenario name
1038 public: boolean, available to other tenants
1039 description: scenario description
1040 tenant_id. Propietary tenant
1041 Return: Raises an exception on error, not found or found several
1042 Obtain a dictionary with format {'scenario':{new_scenario_info}}
1043 """
1044
1045 if isinstance(descriptor, str):
1046 descriptor = self.parse(descriptor, descriptor_format)
1047 elif descriptor:
1048 pass
1049 elif kwargs:
1050 descriptor = {"scenario": {}}
1051 else:
1052 raise ROClientException("Missing descriptor")
1053
1054 if 'scenario' not in descriptor or len(descriptor) > 2:
1055 raise ROClientException("Descriptor must contain only one 'scenario' field")
1056 for param in kwargs:
1057 if param == 'new_name':
1058 descriptor['scenario']['name'] = kwargs[param]
1059 else:
1060 descriptor['scenario'][param] = kwargs[param]
1061 return self._edit_item("scenarios", descriptor, uuid, name, all_tenants=None)
1062
1063 # VIM ACTIONS
1064 def vim_action(self, action, item, uuid=None, all_tenants=False, **kwargs):
1065 """Perform an action over a vim
1066 Params:
1067 action: can be 'list', 'get'/'show', 'delete' or 'create'
1068 item: can be 'tenants' or 'networks'
1069 uuid: uuid of the tenant/net to show or to delete. Ignore otherwise
1070 other parameters:
1071 datacenter_name, datacenter_id: datacenters to act on, if missing uses classes store datacenter
1072 descriptor, descriptor_format: descriptor needed on creation, can be a dict or a yaml/json str
1073 must be a dictionary or a json/yaml text.
1074 name: for created tenant/net Overwrite descriptor name if any
1075 description: tenant descriptor. Overwrite descriptor description if any
1076
1077 Return: Raises an exception on error
1078 Obtain a dictionary with format {'tenant':{new_tenant_info}}
1079 """
1080 session = None # TODO remove when changed to asyncio
1081 if item not in ("tenants", "networks", "images"):
1082 raise ROClientException("Unknown value for item '{}', must be 'tenants', 'nets' or "
1083 "images".format(str(item)))
1084
1085 image_actions = ['list', 'get', 'show', 'delete']
1086 if item == "images" and action not in image_actions:
1087 raise ROClientException("Only available actions for item '{}' are {}\n"
1088 "Requested action was '{}'".format(item, ', '.join(image_actions), action))
1089 if all_tenants:
1090 tenant_text = "/any"
1091 else:
1092 tenant_text = "/" + self._get_tenant()
1093
1094 if "datacenter_id" in kwargs or "datacenter_name" in kwargs:
1095 datacenter = self._get_item_uuid(session, "datacenters", kwargs.get("datacenter"), all_tenants=all_tenants)
1096 else:
1097 datacenter = self.get_datacenter(session)
1098
1099 if action == "list":
1100 url = "{}{}/vim/{}/{}".format(self.uri, tenant_text, datacenter, item)
1101 self.logger.debug("GET %s", url)
1102 mano_response = requests.get(url, headers=self.headers_req)
1103 self.logger.debug("RO response: %s", mano_response.text)
1104 content = self._parse_yaml(mano_response.text, response=True)
1105 if mano_response.status_code == 200:
1106 return content
1107 else:
1108 raise ROClientException(str(content), http_code=mano_response.status)
1109 elif action == "get" or action == "show":
1110 url = "{}{}/vim/{}/{}/{}".format(self.uri, tenant_text, datacenter, item, uuid)
1111 self.logger.debug("GET %s", url)
1112 mano_response = requests.get(url, headers=self.headers_req)
1113 self.logger.debug("RO response: %s", mano_response.text)
1114 content = self._parse_yaml(mano_response.text, response=True)
1115 if mano_response.status_code == 200:
1116 return content
1117 else:
1118 raise ROClientException(str(content), http_code=mano_response.status)
1119 elif action == "delete":
1120 url = "{}{}/vim/{}/{}/{}".format(self.uri, tenant_text, datacenter, item, uuid)
1121 self.logger.debug("DELETE %s", url)
1122 mano_response = requests.delete(url, headers=self.headers_req)
1123 self.logger.debug("RO response: %s", mano_response.text)
1124 content = self._parse_yaml(mano_response.text, response=True)
1125 if mano_response.status_code == 200:
1126 return content
1127 else:
1128 raise ROClientException(str(content), http_code=mano_response.status)
1129 elif action == "create":
1130 if "descriptor" in kwargs:
1131 if isinstance(kwargs["descriptor"], str):
1132 descriptor = self._parse(kwargs["descriptor"], kwargs.get("descriptor_format"))
1133 else:
1134 descriptor = kwargs["descriptor"]
1135 elif "name" in kwargs:
1136 descriptor = {item[:-1]: {"name": kwargs["name"]}}
1137 else:
1138 raise ROClientException("Missing descriptor")
1139
1140 if item[:-1] not in descriptor or len(descriptor) != 1:
1141 raise ROClientException("Descriptor must contain only one 'tenant' field")
1142 if "name" in kwargs:
1143 descriptor[item[:-1]]['name'] = kwargs["name"]
1144 if "description" in kwargs:
1145 descriptor[item[:-1]]['description'] = kwargs["description"]
1146 payload_req = yaml.safe_dump(descriptor)
1147 # print payload_req
1148 url = "{}{}/vim/{}/{}".format(self.uri, tenant_text, datacenter, item)
1149 self.logger.debug("RO POST %s %s", url, payload_req)
1150 mano_response = requests.post(url, headers=self.headers_req, data=payload_req)
1151 self.logger.debug("RO response: %s", mano_response.text)
1152 content = self._parse_yaml(mano_response.text, response=True)
1153 if mano_response.status_code == 200:
1154 return content
1155 else:
1156 raise ROClientException(str(content), http_code=mano_response.status)
1157 else:
1158 raise ROClientException("Unknown value for action '{}".format(str(action)))
1159
1160
1161 if __name__ == '__main__':
1162 RO_URL = "http://localhost:9090/openmano"
1163 TEST_TENANT = "myTenant"
1164 TEST_VIM1 = "myvim"
1165 TEST_URL1 = "https://localhost:5000/v1"
1166 TEST_TYPE1 = "openstack"
1167 TEST_CONFIG1 = {"use_floating_ip": True}
1168 TEST_VIM2 = "myvim2"
1169 TEST_URL2 = "https://localhost:5000/v2"
1170 TEST_TYPE2 = "openvim"
1171 TEST_CONFIG2 = {"config2": "config2", "config3": True}
1172
1173 streamformat = "%(asctime)s %(name)s %(levelname)s: %(message)s"
1174 logging.basicConfig(format=streamformat)
1175 logger = logging.getLogger("ROClient")
1176
1177 tenant_id = None
1178 vim_id = False
1179 loop = asyncio.get_event_loop()
1180 myClient = ROClient(uri=RO_URL, loop=loop, loglevel="DEBUG")
1181 try:
1182 # test tenant
1183 content = loop.run_until_complete(myClient.get_list("tenant"))
1184 print("tenants", content)
1185 content = loop.run_until_complete(myClient.create("tenant", name=TEST_TENANT))
1186 tenant_id = True
1187 content = loop.run_until_complete(myClient.show("tenant", TEST_TENANT))
1188 print("tenant", TEST_TENANT, content)
1189 content = loop.run_until_complete(myClient.edit("tenant", TEST_TENANT, description="another description"))
1190 content = loop.run_until_complete(myClient.show("tenant", TEST_TENANT))
1191 print("tenant edited", TEST_TENANT, content)
1192 myClient["tenant"] = TEST_TENANT
1193
1194 # test VIM
1195 content = loop.run_until_complete(myClient.create("vim", name=TEST_VIM1, type=TEST_TYPE1, vim_url=TEST_URL1,
1196 config=TEST_CONFIG1))
1197 vim_id = True
1198 content = loop.run_until_complete(myClient.get_list("vim"))
1199 print("vim", content)
1200 content = loop.run_until_complete(myClient.show("vim", TEST_VIM1))
1201 print("vim", TEST_VIM1, content)
1202 content = loop.run_until_complete(myClient.edit("vim", TEST_VIM1, description="another description",
1203 name=TEST_VIM2, type=TEST_TYPE2, vim_url=TEST_URL2,
1204 config=TEST_CONFIG2))
1205 content = loop.run_until_complete(myClient.show("vim", TEST_VIM2))
1206 print("vim edited", TEST_VIM2, content)
1207
1208 # test VIM_ACCOUNT
1209 content = loop.run_until_complete(myClient.attach_datacenter(TEST_VIM2, vim_username='user',
1210 vim_password='pass', vim_tenant_name='vimtenant1',
1211 config=TEST_CONFIG1))
1212 vim_id = True
1213 content = loop.run_until_complete(myClient.get_list("vim_account"))
1214 print("vim_account", content)
1215 content = loop.run_until_complete(myClient.show("vim_account", TEST_VIM2))
1216 print("vim_account", TEST_VIM2, content)
1217 content = loop.run_until_complete(myClient.edit("vim_account", TEST_VIM2, vim_username='user2',
1218 vim_password='pass2', vim_tenant_name="vimtenant2",
1219 config=TEST_CONFIG2))
1220 content = loop.run_until_complete(myClient.show("vim_account", TEST_VIM2))
1221 print("vim_account edited", TEST_VIM2, content)
1222
1223 myClient["vim"] = TEST_VIM2
1224
1225 except Exception as e:
1226 logger.error("Error {}".format(e), exc_info=True)
1227
1228 for item in (("vim_account", TEST_VIM1), ("vim", TEST_VIM1),
1229 ("vim_account", TEST_VIM2), ("vim", TEST_VIM2),
1230 ("tenant", TEST_TENANT)):
1231 try:
1232 content = loop.run_until_complete(myClient.delete(item[0], item[1]))
1233 print("{} {} deleted; {}".format(item[0], item[1], content))
1234 except Exception as e:
1235 if e.http_code == 404:
1236 print("{} {} not present or already deleted".format(item[0], item[1]))
1237 else:
1238 logger.error("Error {}".format(e), exc_info=True)
1239
1240 loop.close()