lib/osm/osmclient/clientv2.py

   1 import requests
   2 import logging
   3 import json
   4 import tarfile
   5 import yaml
   6 import pyaml
   7 import StringIO
   8 from lib.util import Util
   9 import hashlib
  10 import os
  11
  12 logging.basicConfig(level=logging.DEBUG)
  13 log = logging.getLogger('helper.py')
  14
  15
  16 class Client(object):
  17     def __init__(self):
  18         self._token_endpoint = 'admin/v1/tokens'
  19         self._user_endpoint = 'admin/v1/users'
  20         self._host = os.getenv('OSM_SERVER', "localhost")
  21         self._so_port = 9999
  22         self._base_path = "https://{0}:{1}/osm".format(self._host, self._so_port)
  23
  24     def auth(self, args):
  25         result = {'error': True, 'data': ''}
  26         token_url = "{0}/{1}".format(self._base_path, self._token_endpoint)
  27         headers = {"Content-Type": "application/yaml", "accept": "application/json"}
  28         try:
  29             r = requests.post(token_url, json=args, verify=False, headers=headers)
  30         except Exception as e:
  31             log.exception(e)
  32             result['data'] = str(e)
  33             return result
  34         if r.status_code == requests.codes.ok:
  35             result['error'] = False
  36
  37         result['data'] = Util.json_loads_byteified(r.text)
  38
  39         return result
  40
  41     def switch_project(self, args):
  42         result = {'error': True, 'data': ''}
  43         token_url = "{0}/{1}".format(self._base_path, self._token_endpoint)
  44         headers = {"Content-Type": "application/yaml", "accept": "application/json"}
  45         try:
  46             r = requests.post(token_url, json=args, verify=False, headers=headers)
  47         except Exception as e:
  48             log.exception(e)
  49             result['data'] = str(e)
  50             return result
  51         if r.status_code == requests.codes.ok:
  52             result['error'] = False
  53
  54         result['data'] = Util.json_loads_byteified(r.text)
  55
  56         return result
  57
  58     def user_list(self, token):
  59         result = {'error': True, 'data': ''}
  60         headers = {"Content-Type": "application/json", "accept": "application/json",
  61                    'Authorization': 'Bearer {}'.format(token['id'])}
  62
  63         _url = "{0}/admin/v1/users".format(self._base_path)
  64         try:
  65             r = requests.get(_url, params=None, verify=False, stream=True, headers=headers)
  66         except Exception as e:
  67             log.exception(e)
  68             result['data'] = str(e)
  69             return result
  70         if r.status_code == requests.codes.ok:
  71             result['error'] = False
  72         result['data'] = Util.json_loads_byteified(r.text)
  73
  74         return result
  75
  76     def user_create(self, token, user_data):
  77         result = {'error': True, 'data': ''}
  78         headers = {"Content-Type": "application/json", "accept": "application/json",
  79                    'Authorization': 'Bearer {}'.format(token['id'])}
  80
  81         _url = "{0}/admin/v1/users".format(self._base_path)
  82
  83         try:
  84             r = requests.post(_url, json=user_data, verify=False, headers=headers)
  85         except Exception as e:
  86             log.exception(e)
  87             result['data'] = str(e)
  88             return result
  89         print r.status_code
  90         if r.status_code == requests.codes.created:
  91             result['error'] = False
  92         result['data'] = Util.json_loads_byteified(r.text)
  93         return result
  94
  95     def user_delete(self, token, id):
  96         result = {'error': True, 'data': ''}
  97         headers = {"Content-Type": "application/yaml", "accept": "application/json",
  98                    'Authorization': 'Bearer {}'.format(token['id'])}
  99
 100         _url = "{0}/admin/v1/users/{1}".format(self._base_path, id)
 101         try:
 102             r = requests.delete(_url, params=None, verify=False, headers=headers)
 103         except Exception as e:
 104             log.exception(e)
 105             result['data'] = str(e)
 106             return result
 107         if r.status_code == requests.codes.no_content:
 108             result['error'] = False
 109         else:
 110             result['data'] = Util.json_loads_byteified(r.text)
 111         return result
 112
 113     def get_user_info(self, token, id):
 114         result = {'error': True, 'data': ''}
 115         headers = {"Content-Type": "application/yaml", "accept": "application/json",
 116                    'Authorization': 'Bearer {}'.format(token['id'])}
 117         _url = "{0}/admin/v1/users/{1}".format(self._base_path, id)
 118         try:
 119             r = requests.get(_url, params=None, verify=False, stream=True, headers=headers)
 120         except Exception as e:
 121             log.exception(e)
 122             result['data'] = str(e)
 123             return result
 124         if r.status_code == requests.codes.ok:
 125             result['error'] = False
 126         result['data'] = Util.json_loads_byteified(r.text)
 127         return result
 128
 129     def project_list(self, token):
 130         result = {'error': True, 'data': ''}
 131         headers = {"Content-Type": "application/yaml", "accept": "application/json",
 132                    'Authorization': 'Bearer {}'.format(token['id'])}
 133
 134         _url = "{0}/admin/v1/projects".format(self._base_path)
 135         try:
 136             r = requests.get(_url, params=None, verify=False, stream=True, headers=headers)
 137         except Exception as e:
 138             log.exception(e)
 139             result['data'] = str(e)
 140             return result
 141         if r.status_code == requests.codes.ok:
 142             result['error'] = False
 143         result['data'] = Util.json_loads_byteified(r.text)
 144
 145         return result
 146
 147     def project_get(self, token, id):
 148         result = {'error': True, 'data': ''}
 149         headers = {"Content-Type": "application/yaml", "accept": "application/json",
 150                    'Authorization': 'Bearer {}'.format(token['id'])}
 151         _url = "{0}/admin/v1/projects/{1}".format(self._base_path, id)
 152         try:
 153             r = requests.get(_url, params=None, verify=False, stream=True, headers=headers)
 154         except Exception as e:
 155             log.exception(e)
 156             result['data'] = str(e)
 157             return result
 158         if r.status_code == requests.codes.ok:
 159             result['error'] = False
 160         result['data'] = Util.json_loads_byteified(r.text)
 161         return result
 162
 163     def project_create(self, token, project_data):
 164
 165         result = {'error': True, 'data': ''}
 166         headers = {"Content-Type": "application/json", "accept": "application/json",
 167                    'Authorization': 'Bearer {}'.format(token['id'])}
 168
 169         _url = "{0}/admin/v1/projects".format(self._base_path)
 170
 171         try:
 172             r = requests.post(_url, json=project_data, verify=False, headers=headers)
 173         except Exception as e:
 174             log.exception(e)
 175             result['data'] = str(e)
 176             return result
 177         print r.status_code
 178         if r.status_code == requests.codes.created:
 179             result['error'] = False
 180         result['data'] = Util.json_loads_byteified(r.text)
 181         return result
 182
 183     def project_edit(self, token, id, project_data):
 184
 185         result = {'error': True, 'data': ''}
 186         headers = {"Content-Type": "application/json", "accept": "application/json",
 187                    'Authorization': 'Bearer {}'.format(token['id'])}
 188
 189         _url = "{0}/admin/v1/projects/{1}".format(self._base_path, id)
 190
 191         try:
 192             r = requests.put(_url, json=project_data, verify=False, headers=headers)
 193         except Exception as e:
 194             log.exception(e)
 195             result['data'] = str(e)
 196             return result
 197         print r.status_code
 198         if r.status_code == requests.codes.no_content:
 199             result['error'] = False
 200         result['data'] = Util.json_loads_byteified(r.text)
 201         return result
 202
 203     def project_delete(self, token, id):
 204         result = {'error': True, 'data': ''}
 205         headers = {"Content-Type": "application/yaml", "accept": "application/json",
 206                    'Authorization': 'Bearer {}'.format(token['id'])}
 207
 208         _url = "{0}/admin/v1/projects/{1}".format(self._base_path, id)
 209         try:
 210             r = requests.delete(_url, params=None, verify=False, headers=headers)
 211         except Exception as e:
 212             log.exception(e)
 213             result['data'] = str(e)
 214             return result
 215         if r.status_code == requests.codes.no_content:
 216             result['error'] = False
 217         else:
 218             result['data'] = Util.json_loads_byteified(r.text)
 219         return result
 220
 221     def nsd_list(self, token):
 222         result = {'error': True, 'data': ''}
 223         headers = {"Content-Type": "application/yaml", "accept": "application/json",
 224                    'Authorization': 'Bearer {}'.format(token['id'])}
 225
 226         _url = "{0}/nsd/v1/ns_descriptors_content".format(self._base_path)
 227         try:
 228             r = requests.get(_url, params=None, verify=False, stream=True, headers=headers)
 229         except Exception as e:
 230             log.exception(e)
 231             result['data'] = str(e)
 232             return result
 233         if r.status_code == requests.codes.ok:
 234             result['error'] = False
 235         result['data'] = Util.json_loads_byteified(r.text)
 236
 237         return result
 238
 239     def vnfd_list(self, token):
 240         result = {'error': True, 'data': ''}
 241         headers = {"Content-Type": "application/yaml", "accept": "application/json",
 242                    'Authorization': 'Bearer {}'.format(token['id'])}
 243
 244         _url = "{0}/vnfpkgm/v1/vnf_packages_content".format(self._base_path)
 245         try:
 246             r = requests.get(_url, params=None, verify=False, stream=True, headers=headers)
 247         except Exception as e:
 248             log.exception(e)
 249             result['data'] = str(e)
 250             return result
 251         if r.status_code == requests.codes.ok:
 252             result['error'] = False
 253         result['data'] = Util.json_loads_byteified(r.text)
 254
 255         return result
 256
 257     def ns_list(self, token):
 258         result = {'error': True, 'data': ''}
 259         headers = {"Content-Type": "application/yaml", "accept": "application/json",
 260                    'Authorization': 'Bearer {}'.format(token['id'])}
 261         _url = "{0}/nslcm/v1/ns_instances_content".format(self._base_path)
 262         try:
 263             r = requests.get(_url, params=None, verify=False, stream=True, headers=headers)
 264         except Exception as e:
 265             log.exception(e)
 266             result['data'] = str(e)
 267             return result
 268         if r.status_code == requests.codes.ok:
 269             result['error'] = False
 270         result['data'] = Util.json_loads_byteified(r.text)
 271
 272         return result
 273
 274     def vnf_list(self, token):
 275         result = {'error': True, 'data': ''}
 276         headers = {"Content-Type": "application/yaml", "accept": "application/json",
 277                    'Authorization': 'Bearer {}'.format(token['id'])}
 278         _url = "{0}/nslcm/v1/vnfrs".format(self._base_path)
 279         try:
 280             r = requests.get(_url, params=None, verify=False, stream=True, headers=headers)
 281         except Exception as e:
 282             log.exception(e)
 283             result['data'] = str(e)
 284             return result
 285         if r.status_code == requests.codes.ok:
 286             result['error'] = False
 287         result['data'] = Util.json_loads_byteified(r.text)
 288
 289         return result
 290
 291     def nsd_delete(self, token, id):
 292         result = {'error': True, 'data': ''}
 293         headers = {"Content-Type": "application/yaml", "accept": "application/json",
 294                    'Authorization': 'Bearer {}'.format(token['id'])}
 295
 296         _url = "{0}/nsd/v1/ns_descriptors_content/{1}".format(self._base_path, id)
 297         try:
 298             r = requests.delete(_url, params=None, verify=False,headers=headers)
 299         except Exception as e:
 300             log.exception(e)
 301             result['data'] = str(e)
 302             return result
 303         if r.status_code == requests.codes.ok:
 304             result['error'] = False
 305         result['data'] = Util.json_loads_byteified(r.text)
 306         return result
 307
 308     def vnfd_delete(self, token, id):
 309         result = {'error': True, 'data': ''}
 310         headers = {"Content-Type": "application/yaml", "accept": "application/json",
 311                    'Authorization': 'Bearer {}'.format(token['id'])}
 312
 313         _url = "{0}/vnfpkgm/v1/vnf_packages_content/{1}".format(self._base_path, id)
 314         try:
 315             r = requests.delete(_url, params=None, verify=False, headers=headers)
 316         except Exception as e:
 317             log.exception(e)
 318             result['data'] = str(e)
 319             return result
 320         if r.status_code == requests.codes.ok:
 321             result['error'] = False
 322         result['data'] = Util.json_loads_byteified(r.text)
 323         return result
 324
 325     def nsd_onboard(self, token, package):
 326         result = {'error': True, 'data': ''}
 327         headers = {"Content-Type": "application/gzip", "accept": "application/json",
 328                    'Authorization': 'Bearer {}'.format(token['id'])}
 329         with open('/tmp/'+package.name, 'wb+') as destination:
 330             for chunk in package.chunks():
 331                 destination.write(chunk)
 332         headers['Content-File-MD5'] = self.md5(open('/tmp/'+package.name, 'rb'))
 333         _url = "{0}/nsd/v1/ns_descriptors_content/".format(self._base_path)
 334         try:
 335             r = requests.post(_url, data=open('/tmp/'+package.name, 'rb'), verify=False, headers=headers)
 336         except Exception as e:
 337             log.exception(e)
 338             result['data'] = str(e)
 339             return result
 340         if r.status_code == requests.codes.created:
 341             result['error'] = False
 342         result['data'] = Util.json_loads_byteified(r.text)
 343         return result
 344
 345     def vnfd_onboard(self, token, package):
 346         result = {'error': True, 'data': ''}
 347         headers = {"Content-Type": "application/gzip", "accept": "application/json",
 348                    'Authorization': 'Bearer {}'.format(token['id'])}
 349         with open('/tmp/'+package.name, 'wb+') as destination:
 350             for chunk in package.chunks():
 351                 destination.write(chunk)
 352         headers['Content-File-MD5'] = self.md5(open('/tmp/'+package.name, 'rb'))
 353         _url = "{0}/vnfpkgm/v1/vnf_packages_content".format(self._base_path)
 354         try:
 355             r = requests.post(_url, data=open('/tmp/'+package.name, 'rb'), verify=False, headers=headers)
 356         except Exception as e:
 357             log.exception(e)
 358             result['data'] = str(e)
 359             return result
 360         if r.status_code == requests.codes.created:
 361             result['error'] = False
 362         result['data'] = Util.json_loads_byteified(r.text)
 363         return result
 364
 365     def nsd_update(self, token, id, data):
 366         result = {'error': True, 'data': ''}
 367         headers = {"Content-Type": "application/gzip", "accept": "application/json",
 368                    'Authorization': 'Bearer {}'.format(token['id'])}
 369
 370         # get the package onboarded
 371         tar_pkg = self.get_nsd_pkg(token, id)
 372         tarf = tarfile.open(fileobj=tar_pkg)
 373
 374         tarf = self._descriptor_update(tarf, data)
 375         headers['Content-File-MD5'] = self.md5(open('/tmp/' + tarf.getnames()[0] + ".tar.gz", 'rb'))
 376
 377         _url = "{0}/nsd/v1/ns_descriptors/{1}/nsd_content".format(self._base_path, id)
 378
 379         try:
 380             r = requests.put(_url, data=open('/tmp/' + tarf.getnames()[0] + ".tar.gz", 'rb'), verify=False,
 381                              headers=headers)
 382         except Exception as e:
 383             log.exception(e)
 384             result['data'] = str(e)
 385             return result
 386         if r.status_code == requests.codes.no_content:
 387             result['error'] = False
 388
 389         return result
 390
 391     def vnfd_update(self, token, id, data):
 392         result = {'error': True, 'data': ''}
 393         headers = {"Content-Type": "application/gzip", "accept": "application/json",
 394                    'Authorization': 'Bearer {}'.format(token['id'])}
 395
 396         # get the package onboarded
 397         tar_pkg = self.get_vnfd_pkg(token, id)
 398         tarf = tarfile.open(fileobj=tar_pkg)
 399
 400         tarf = self._descriptor_update(tarf, data)
 401         headers['Content-File-MD5'] = self.md5(open('/tmp/' + tarf.getnames()[0] + ".tar.gz", 'rb'))
 402
 403         _url = "{0}/vnfpkgm/v1/vnf_packages/{1}/package_content".format(self._base_path, id)
 404
 405         try:
 406             r = requests.put(_url, data=open('/tmp/' + tarf.getnames()[0] + ".tar.gz", 'rb'), verify=False,
 407                              headers=headers)
 408         except Exception as e:
 409             log.exception(e)
 410             result['data'] = str(e)
 411             return result
 412         if r.status_code == requests.codes.no_content:
 413             result['error'] = False
 414
 415         return result
 416
 417     def get_nsd_pkg(self, token, id):
 418         result = {'error': True, 'data': ''}
 419         headers = { "accept": "application/zip",
 420                    'Authorization': 'Bearer {}'.format(token['id'])}
 421
 422         _url = "{0}/nsd/v1/ns_descriptors/{1}/nsd_content".format(self._base_path, id)
 423         try:
 424             r = requests.get(_url, params=None, verify=False, stream=True, headers=headers)
 425         except Exception as e:
 426             log.exception(e)
 427             result['data'] = str(e)
 428             return result
 429         if r.status_code == requests.codes.ok:
 430             result['error'] = False
 431             tarf = StringIO.StringIO(r.content)
 432             return tarf
 433         return result
 434
 435     def get_vnfd_pkg(self, token, id):
 436         result = {'error': True, 'data': ''}
 437         headers = {"accept": "application/zip",
 438                    'Authorization': 'Bearer {}'.format(token['id'])}
 439         _url = "{0}/vnfpkgm/v1/vnf_packages/{1}/package_content".format(self._base_path, id)
 440         try:
 441             r = requests.get(_url, params=None, verify=False, stream=True, headers=headers)
 442             print r.status_code
 443         except Exception as e:
 444             log.exception(e)
 445             result['data'] = str(e)
 446             return result
 447         if r.status_code == requests.codes.ok:
 448             result['error'] = False
 449             tarf = StringIO.StringIO(r.content)
 450             return tarf
 451         return result
 452
 453     def _descriptor_update(self, tarf, data):
 454         print tarf.getnames()
 455         # extract the package on a tmp directory
 456         tarf.extractall('/tmp')
 457
 458         for name in tarf.getnames():
 459             if name.endswith(".yaml") or name.endswith(".yml"):
 460                 with open('/tmp/' + name, 'w') as outfile:
 461                     yaml.safe_dump(data, outfile, default_flow_style=False)
 462                 break
 463
 464         tarf_temp = tarfile.open('/tmp/' + tarf.getnames()[0] + ".tar.gz", "w:gz")
 465         # tarf_temp = tarfile.open("pippo.tar.gz", "w:gz")
 466         print tarf_temp.getnames()
 467         # tarf_temp.add('/tmp/'+tarf.getnames()[0])
 468         for tarinfo in tarf:
 469             # if tarinfo.name.startswith(tarf.getnames()[0]):
 470             #    new_name = tarinfo.name[len(tarf.getnames()[0]):]
 471             tarf_temp.add('/tmp/' + tarinfo.name, tarinfo.name, recursive=False)
 472         print tarf_temp.getnames()
 473         tarf_temp.close()
 474         return tarf
 475
 476     def nsd_get(self, token, id):
 477         result = {'error': True, 'data': ''}
 478         headers = {'Content-Type': 'application/yaml',
 479                    'Authorization': 'Bearer {}'.format(token['id'])}
 480         _url = "{0}/nsd/v1/ns_descriptors/{1}/nsd".format(self._base_path, id)
 481         try:
 482             r = requests.get(_url, params=None, verify=False, stream=True, headers=headers)
 483         except Exception as e:
 484             log.exception(e)
 485             result['data'] = str(e)
 486             return result
 487         if r.status_code == requests.codes.ok:
 488             result['error'] = False
 489             return yaml.load(r.text)
 490         else:
 491             try:
 492                 result['data'] = r.json()
 493             except Exception as e:
 494                 result['data'] = {}
 495         return result
 496
 497     def vnfd_get(self, token, id):
 498         result = {'error': True, 'data': ''}
 499         headers = {'Content-Type': 'application/yaml',
 500                    'Authorization': 'Bearer {}'.format(token['id'])}
 501         _url = "{0}/vnfpkgm/v1/vnf_packages/{1}/vnfd".format(self._base_path, id)
 502         try:
 503             r = requests.get(_url, params=None, verify=False, stream=True, headers=headers)
 504         except Exception as e:
 505             log.exception(e)
 506             result['data'] = str(e)
 507             return result
 508         if r.status_code == requests.codes.ok:
 509             result['error'] = False
 510             return yaml.load(r.text)
 511         else:
 512             try:
 513                 result['data'] = r.json()
 514             except Exception as e:
 515                 result['data'] = {}
 516         return result
 517
 518     def nsd_artifacts(self, token, id):
 519         result = {'error': True, 'data': ''}
 520         headers = {'Content-Type': 'application/yaml', 'accept': 'text/plain',
 521                    'Authorization': 'Bearer {}'.format(token['id'])}
 522         _url = "{0}/nsd/v1/ns_descriptors/{1}/artifacts".format(self._base_path, id)
 523         try:
 524             r = requests.get(_url, params=None, verify=False, stream=True, headers=headers)
 525         except Exception as e:
 526             log.exception(e)
 527             result['data'] = str(e)
 528             return result
 529         if r.status_code == requests.codes.ok:
 530             result['error'] = False
 531             result['data'] = r.text
 532         else:
 533             try:
 534                 result['data'] = r.json()
 535             except Exception as e:
 536                 result['data'] = {}
 537
 538         return result
 539
 540     def vnf_packages_artifacts(self, token, id):
 541         result = {'error': True, 'data': ''}
 542         headers = {'Content-Type': 'application/yaml', 'accept': 'text/plain',
 543                    'Authorization': 'Bearer {}'.format(token['id'])}
 544         _url = "{0}/vnfpkgm/v1/vnf_packages/{1}/artifacts".format(self._base_path, id)
 545         try:
 546             r = requests.get(_url, params=None, verify=False, stream=True, headers=headers)
 547         except Exception as e:
 548             log.exception(e)
 549             result['data'] = str(e)
 550             return result
 551         if r.status_code == requests.codes.ok:
 552             result['error'] = False
 553             result['data'] = r.text
 554         else:
 555             try:
 556                 result['data'] = r.json()
 557             except Exception as e:
 558                 result['data'] = {}
 559
 560         return result
 561
 562     def ns_create(self, token, ns_data):
 563         result = {'error': True, 'data': ''}
 564         headers = {"Content-Type": "application/yaml", "accept": "application/json",
 565                    'Authorization': 'Bearer {}'.format(token['id'])}
 566
 567         _url = "{0}/nslcm/v1/ns_instances_content".format(self._base_path)
 568
 569         try:
 570             r = requests.post(_url, json=ns_data, verify=False, headers=headers)
 571         except Exception as e:
 572             log.exception(e)
 573             result['data'] = str(e)
 574             return result
 575         if r.status_code == requests.codes.ok:
 576             result['error'] = False
 577         result['data'] = Util.json_loads_byteified(r.text)
 578         return result
 579
 580     def ns_op_list(self, token, id):
 581         result = {'error': True, 'data': ''}
 582         headers = {"Content-Type": "application/json", "accept": "application/json",
 583                    'Authorization': 'Bearer {}'.format(token['id'])}
 584         _url = "{0}/nslcm/v1/ns_lcm_op_occs/?nsInstanceId={1}".format(self._base_path, id)
 585
 586         try:
 587             r = requests.get(_url, params=None, verify=False, stream=True, headers=headers)
 588         except Exception as e:
 589             log.exception(e)
 590             result['data'] = str(e)
 591             return result
 592         if r.status_code == requests.codes.ok:
 593             result['error'] = False
 594         result['data'] = Util.json_loads_byteified(r.text)
 595
 596         return result
 597
 598     def ns_op(self, token, id):
 599         result = {'error': True, 'data': ''}
 600         headers = {"Content-Type": "application/json", "accept": "application/json",
 601                    'Authorization': 'Bearer {}'.format(token['id'])}
 602         _url = "{0}/nslcm/v1/ns_lcm_op_occs/{1}".format(self._base_path, id)
 603
 604         try:
 605             r = requests.get(_url, params=None, verify=False, stream=True, headers=headers)
 606         except Exception as e:
 607             log.exception(e)
 608             result['data'] = str(e)
 609             return result
 610         if r.status_code == requests.codes.ok:
 611             result['error'] = False
 612         result['data'] = Util.json_loads_byteified(r.text)
 613
 614         return result
 615
 616     def ns_action(self, token, id, action_payload):
 617         result = {'error': True, 'data': ''}
 618         headers = {"Content-Type": "application/json", "accept": "application/json",
 619                    'Authorization': 'Bearer {}'.format(token['id'])}
 620
 621         _url = "{0}/nslcm/v1/ns_instances/{1}/action".format(self._base_path, id)
 622
 623         try:
 624             r = requests.post(_url, json=action_payload, verify=False, headers=headers)
 625         except Exception as e:
 626             log.exception(e)
 627             result['data'] = str(e)
 628             return result
 629         print r.status_code
 630         if r.status_code == requests.codes.created:
 631             result['error'] = False
 632         result['data'] = Util.json_loads_byteified(r.text)
 633         return result
 634
 635     def ns_delete(self, token, id, force=None):
 636         result = {'error': True, 'data': ''}
 637         headers = {"Content-Type": "application/yaml", "accept": "application/json",
 638                    'Authorization': 'Bearer {}'.format(token['id'])}
 639         query_path = ''
 640         if force:
 641             query_path = '?FORCE=true'
 642         _url = "{0}/nslcm/v1/ns_instances_content/{1}{2}".format(self._base_path, id, query_path)
 643         try:
 644             r = requests.delete(_url, params=None, verify=False, headers=headers)
 645         except Exception as e:
 646             log.exception(e)
 647             result['data'] = str(e)
 648             return result
 649         if r.status_code == requests.codes.ok:
 650             result['error'] = False
 651         result['data'] = Util.json_loads_byteified(r.text)
 652         return result
 653
 654     def ns_get(self, token, id):
 655         result = {'error': True, 'data': ''}
 656         headers = {"Content-Type": "application/json", "accept": "application/json",
 657                    'Authorization': 'Bearer {}'.format(token['id'])}
 658         _url = "{0}/nslcm/v1/ns_instances_content/{1}".format(self._base_path, id)
 659
 660         try:
 661             r = requests.get(_url, params=None, verify=False, stream=True, headers=headers)
 662         except Exception as e:
 663             log.exception(e)
 664             result['data'] = str(e)
 665             return result
 666         if r.status_code == requests.codes.ok:
 667             result['error'] = False
 668         result['data'] = Util.json_loads_byteified(r.text)
 669         return result
 670
 671     def vnf_get(self, token, id):
 672         result = {'error': True, 'data': ''}
 673         headers = {"Content-Type": "application/json", "accept": "application/json",
 674                    'Authorization': 'Bearer {}'.format(token['id'])}
 675         _url = "{0}/nslcm/v1/vnfrs/{1}".format(self._base_path, id)
 676
 677         try:
 678             r = requests.get(_url, params=None, verify=False, stream=True, headers=headers)
 679         except Exception as e:
 680             log.exception(e)
 681             result['data'] = str(e)
 682             return result
 683         if r.status_code == requests.codes.ok:
 684             result['error'] = False
 685         result['data'] = Util.json_loads_byteified(r.text)
 686         return result
 687
 688     def ns_alarm_create(self, token, id, alarm_payload):
 689         result = {'error': True, 'data': ''}
 690         headers = {"Content-Type": "application/json",
 691                    'Authorization': 'Bearer {}'.format(token['id'])}
 692         _url = "{0}/test/message/alarm_request".format(self._base_path)
 693         try:
 694             r = requests.post(_url, json=alarm_payload, verify=False, headers=headers)
 695         except Exception as e:
 696             log.exception(e)
 697             result['data'] = str(e)
 698             return result
 699         print r.status_code
 700         if r.status_code == requests.codes.ok:
 701             result['error'] = False
 702         #result['data'] = Util.json_loads_byteified(r.text)
 703         result['data'] = r.text
 704         return result
 705
 706     def ns_metric_export(self, token, id, metric_payload):
 707         result = {'error': True, 'data': ''}
 708         headers = {"Content-Type": "application/json",
 709                    'Authorization': 'Bearer {}'.format(token['id'])}
 710         _url = "{0}/test/message/metric_request".format(self._base_path)
 711         try:
 712             r = requests.post(_url, json=metric_payload, verify=False, headers=headers)
 713         except Exception as e:
 714             log.exception(e)
 715             result['data'] = str(e)
 716             return result
 717         print r.status_code
 718         if r.status_code == requests.codes.ok:
 719             result['error'] = False
 720         #result['data'] = Util.json_loads_byteified(r.text)
 721         result['data'] = r.text
 722         return result
 723
 724     def vim_list(self, token):
 725         result = {'error': True, 'data': ''}
 726         headers = {"Content-Type": "application/yaml", "accept": "application/json",
 727                    'Authorization': 'Bearer {}'.format(token['id'])}
 728         _url = "{0}/admin/v1/vims".format(self._base_path)
 729         try:
 730             r = requests.get(_url, params=None, verify=False, stream=True, headers=headers)
 731         except Exception as e:
 732             log.exception(e)
 733             result['data'] = str(e)
 734             return result
 735         if r.status_code == requests.codes.ok:
 736             result['error'] = False
 737         result['data'] = Util.json_loads_byteified(r.text)
 738
 739         return result
 740
 741     def vim_delete(self, token, id):
 742         result = {'error': True, 'data': ''}
 743         headers = { "accept": "application/json",
 744                    'Authorization': 'Bearer {}'.format(token['id'])}
 745         _url = "{0}/admin/v1/vims/{1}".format(self._base_path, id)
 746         try:
 747             r = requests.delete(_url, params=None, verify=False, headers=headers)
 748         except Exception as e:
 749             log.exception(e)
 750             result['data'] = str(e)
 751             return result
 752         print r.status_code
 753         if r.status_code == requests.codes.accepted:
 754             result['error'] = False
 755         else:
 756             result['data'] = r.text
 757         return result
 758
 759     def vim_get(self, token, id):
 760
 761         result = {'error': True, 'data': ''}
 762         headers = {"Content-Type": "application/json", "accept": "application/json",
 763                    'Authorization': 'Bearer {}'.format(token['id'])}
 764         _url = "{0}/admin/v1/vims/{1}".format(self._base_path, id)
 765
 766         try:
 767             r = requests.get(_url, params=None, verify=False, stream=True, headers=headers)
 768         except Exception as e:
 769             log.exception(e)
 770             result['data'] = str(e)
 771             return result
 772         if r.status_code == requests.codes.ok:
 773             result['error'] = False
 774         result['data'] = Util.json_loads_byteified(r.text)
 775         return result
 776
 777     def vim_create(self, token, vim_data):
 778
 779         result = {'error': True, 'data': ''}
 780         headers = {"Content-Type": "application/json", "accept": "application/json",
 781                    'Authorization': 'Bearer {}'.format(token['id'])}
 782
 783         _url = "{0}/admin/v1/vims".format(self._base_path)
 784
 785         try:
 786             r = requests.post(_url, json=vim_data, verify=False, headers=headers)
 787         except Exception as e:
 788             log.exception(e)
 789             result['data'] = str(e)
 790             return result
 791         print r.status_code
 792         if r.status_code == requests.codes.created:
 793             result['error'] = False
 794         result['data'] = Util.json_loads_byteified(r.text)
 795         return result
 796
 797     def sdn_list(self, token):
 798         result = {'error': True, 'data': ''}
 799         headers = {"accept": "application/json",
 800                    'Authorization': 'Bearer {}'.format(token['id'])}
 801         _url = "{0}/admin/v1/sdns".format(self._base_path)
 802         try:
 803             r = requests.get(_url, params=None, verify=False, stream=True, headers=headers)
 804         except Exception as e:
 805             log.exception(e)
 806             result['data'] = str(e)
 807             return result
 808         if r.status_code == requests.codes.ok:
 809             result['error'] = False
 810         result['data'] = Util.json_loads_byteified(r.text)
 811         return result
 812
 813     def sdn_delete(self, token, id):
 814         result = {'error': True, 'data': ''}
 815         headers = {"accept": "application/json",
 816                    'Authorization': 'Bearer {}'.format(token['id'])}
 817         _url = "{0}/admin/v1/sdns/{1}".format(self._base_path, id)
 818         try:
 819             r = requests.delete(_url, params=None, verify=False, headers=headers)
 820         except Exception as e:
 821             log.exception(e)
 822             result['data'] = str(e)
 823             return result
 824         print r.status_code
 825         if r.status_code == requests.codes.accepted:
 826             result['error'] = False
 827         else:
 828             result['data'] = r.text
 829         return result
 830
 831     def sdn_get(self, token, id):
 832         result = {'error': True, 'data': ''}
 833         headers = {"accept": "application/json",
 834                    'Authorization': 'Bearer {}'.format(token['id'])}
 835         _url = "{0}/admin/v1/sdns/{1}".format(self._base_path, id)
 836
 837         try:
 838             r = requests.get(_url, params=None, verify=False, stream=True, headers=headers)
 839         except Exception as e:
 840             log.exception(e)
 841             result['data'] = str(e)
 842             return result
 843         if r.status_code == requests.codes.ok:
 844             result['error'] = False
 845         result['data'] = Util.json_loads_byteified(r.text)
 846         return result
 847
 848
 849     def sdn_create(self, token, sdn_data):
 850         result = {'error': True, 'data': ''}
 851         headers = {"Content-Type": "application/json", "accept": "application/json",
 852                    'Authorization': 'Bearer {}'.format(token['id'])}
 853
 854         _url = "{0}/admin/v1/sdns".format(self._base_path)
 855
 856         try:
 857             r = requests.post(_url, json=sdn_data, verify=False, headers=headers)
 858         except Exception as e:
 859             log.exception(e)
 860             result['data'] = str(e)
 861             return result
 862         print r.status_code
 863         if r.status_code == requests.codes.created:
 864             result['error'] = False
 865         result['data'] = Util.json_loads_byteified(r.text)
 866         return result
 867
 868
 869     @staticmethod
 870     def md5(f):
 871         hash_md5 = hashlib.md5()
 872         for chunk in iter(lambda: f.read(1024), b""):
 873             hash_md5.update(chunk)
 874         return hash_md5.hexdigest()