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