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