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