projecthandler/views.py

   1 #
   2 #   Copyright 2017 CNIT - Consorzio Nazionale Interuniversitario per le Telecomunicazioni
   3 #
   4 #   Licensed under the Apache License, Version 2.0 (the "License");
   5 #   you may not use this file except in compliance with the License.
   6 #   You may obtain a copy of the License at
   7 #
   8 #       http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 #   Unless required by applicable law or agreed to in writing, software
  11 #   distributed under the License is distributed on an  BASIS,
  12 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 #   See the License for the specific language governing permissions and
  14 #   limitations under the License.
  15 #
  16
  17 import json
  18 import logging
  19
  20 import yaml
  21 from sf_t3d.decorators import login_required
  22 from django.http import HttpResponse, JsonResponse
  23 from django.shortcuts import render, redirect
  24
  25 from authosm.exceptions import OSMAuthException
  26 from lib.util import Util
  27 from lib.osm.osmclient.clientv2 import Client
  28 import authosm.utils as osmutils
  29
  30
  31 logging.basicConfig(level=logging.DEBUG)
  32 log = logging.getLogger('projecthandler/view.py')
  33
  34
  35 @login_required
  36 def home(request):
  37     return render(request, 'home.html', {})
  38
  39
  40 @login_required
  41 def create_new_project(request):
  42     if request.method == 'POST':
  43         user = osmutils.get_user(request)
  44         client = Client()
  45         new_project_dict = request.POST.dict()
  46         keys = ["name"]
  47         project_data = dict(filter(lambda i: i[0] in keys and len(i[1]) > 0, new_project_dict.items()))
  48         result = client.project_create(user.get_token(), project_data)
  49         if isinstance(result, dict) and 'error' in result and result['error']:
  50             print result
  51             return __response_handler(request, result['data'], url=None,
  52                                       status=result['data']['status'] if 'status' in result['data'] else 500)
  53         else:
  54             return __response_handler(request, {}, url=None, status=200)
  55
  56
  57 @login_required
  58 def user_projects(request):
  59     user = osmutils.get_user(request)
  60     client = Client()
  61     result = client.project_list(user.get_token())
  62     return __response_handler(request,{
  63         'projects': result['data'] if result and result['error'] is False else [],
  64     },'projectlist.html')
  65
  66
  67 def open_composer(request):
  68     user = osmutils.get_user(request)
  69     project_id = user.project_id
  70     result = {'project_id': project_id,
  71               'vertices': [
  72                   {"info": {"type": "vnf", "property": {"custom_label": ""},
  73                             "group": []}, "id": "vm"},
  74                   {"info": {"type": "vnf", "property": {"custom_label": ""},
  75                             "group": []}, "id": "vlan"},
  76                   {"info": {"type": "vnf", "property": {"custom_label": ""},
  77                             "group": []}, "id": "firewall"},
  78                   {"info": {"type": "vnf", "property": {"custom_label": ""},
  79                             "group": []}, "id": "ping"},
  80
  81                   {"info": {"type": "ns_vl", "property": {"custom_label": ""},
  82                             "group": []}, "id": "vl1"},
  83                   {"info": {"type": "ns_vl", "property": {"custom_label": ""},
  84                             "group": []}, "id": "vl2"},
  85                   {"info": {"type": "ns_vl", "property": {"custom_label": ""},
  86                             "group": []}, "id": "vl3"},
  87               ],
  88               'edges': [
  89                   {"source": "vm", "group": [], "target": "vl3", "view": "ns"},
  90                   {"source": "vlan", "group": [], "target": "vl3", "view": "ns"},
  91                   {"source": "vlan", "group": [], "target": "vl1", "view": "ns"},
  92                   {"source": "firewall", "group": [], "target": "vl1", "view": "ns"},
  93                   {"source": "firewall", "group": [], "target": "vl2", "view": "ns"},
  94                   {"source": "ping", "group": [], "target": "vl2", "view": "ns"},
  95               ],
  96               'model': {
  97                 "layer": {
  98
  99                     "ns": {
 100                         "nodes": {
 101                             "vnf": {
 102                                 "addable": {
 103                                     "callback": "addNode"
 104                                 },
 105                                 "removable": {
 106                                     "callback": "removeNode"
 107                                 },
 108                                 "expands": "vnf"
 109                             },
 110                             "ns_vl": {
 111                                 "addable": {
 112                                     "callback": "addNode"
 113                                 },
 114                                 "removable": {
 115                                     "callback": "removeNode"
 116                                 }
 117                             },
 118
 119                         },
 120                         "allowed_edges": {
 121                             "ns_vl": {
 122                                 "destination": {
 123                                     "vnf": {
 124                                         "callback": "addLink",
 125                                         "direct_edge": False,
 126                                         "removable": {
 127                                             "callback": "removeLink"
 128                                         }
 129                                     }
 130                                 }
 131                             },
 132                             "vnf": {
 133                                 "destination": {
 134                                     "ns_vl": {
 135                                         "callback": "addLink",
 136                                         "direct_edge": False,
 137                                         "removable": {
 138                                             "callback": "removeLink"
 139                                         }
 140                                     },
 141
 142                                 }
 143                             }
 144
 145                         }
 146                     },
 147                     "vnf": {
 148                         "nodes": {
 149                             "vdu": {
 150                                 "addable": {
 151                                     "callback": "addNode"
 152                                 },
 153                                 "removable": {
 154                                     "callback": "removeNode"
 155                                 }
 156                             },
 157                             "cp": {
 158                                 "addable": {
 159                                     "callback": "addNode"
 160                                 },
 161                                 "removable": {
 162                                     "callback": "removeNode"
 163                                 }
 164                             },
 165
 166                         },
 167                         "allowed_edges": {
 168                             "vdu": {
 169                                 "destination": {
 170                                     "cp": {
 171                                         "callback": "addLink",
 172                                         "direct_edge": False,
 173                                         "removable": {
 174                                             "callback": "removeLink"
 175                                         }
 176                                     }
 177                                 }
 178                             },
 179                             "cp": {
 180                                 "destination": {
 181                                     "vdu": {
 182                                         "callback": "addLink",
 183                                         "direct_edge": False,
 184                                         "removable": {
 185                                             "callback": "removeLink"
 186                                         }
 187                                     }
 188                                 }
 189                             }
 190                         }
 191                     },
 192                     "name": "OSM",
 193                     "version": 1,
 194                     "nodes": {
 195                         "vnf": {
 196                             "label": "vnf"
 197                         },
 198                         "ns_vl": {
 199                             "label": "vl"
 200                         },
 201                         "cp": {
 202                             "label": "cp"
 203                         },
 204                         "vdu": {
 205                             "label": "vdu"
 206                         }
 207                     },
 208                     "description": "osm",
 209                     "callback": {
 210                         "addNode": {
 211                             "file": "osm_controller.js",
 212                             "class": "OsmController"
 213                         },
 214                         "removeNode": {
 215                             "file": "osm_controller.js",
 216                             "class": "OsmController"
 217                         },
 218                         "addLink": {
 219                             "file": "osm_controller.js",
 220                             "class": "OsmController"
 221                         },
 222                         "removeLink": {
 223                             "file": "osm_controller.js",
 224                             "class": "OsmController"
 225                         }
 226                     }
 227
 228                 }
 229             }}
 230     return __response_handler(request, result, 'project_graph_base.html')
 231
 232
 233 def get_available_nodes(request):
 234
 235     params = request.GET.dict()
 236     nodes = {
 237         'ns': [{"types": [{"name": "Generic", "id": "vnf"},
 238                           {"name": "ping", "id": "vnf"},
 239                           {"name": "pong", "id": "vnf"},
 240                           {"name": "hackfest1-vm", "id": "vnf"}], "category_name": "Vnf"},
 241                {"types": [{"name": "VL", "id": "ns_vl"}], "category_name": "VirtualLink"}],
 242         'vnf': [{"types": [{"name": "VDU", "id": "vdu"}], "category_name": "Vdu"},
 243                 {"types": [{"name": "CP", "id": "cp"}], "category_name": "CP"}]
 244     }
 245
 246     return __response_handler(request, nodes[params['layer']])
 247
 248
 249 @login_required
 250 def open_project(request):
 251     user = osmutils.get_user(request)
 252     project_id = user.project_id
 253     try:
 254
 255         client = Client()
 256         ##TODO change with adhoc api call
 257         prj = client.project_get(user.get_token(), project_id)
 258         nsd = client.nsd_list(user.get_token())
 259         vnfd = client.vnfd_list(user.get_token())
 260         ns = client.ns_list(user.get_token())
 261         vnf = client.vnf_list(user.get_token())
 262         project_overview = {
 263             'owner': user.username,
 264             'name': project_id,
 265             'updated_date': prj['data']['_admin']['modified'] if prj and prj['error'] is False else '-',
 266             'created_date': prj['data']['_admin']['created'] if prj and prj['error'] is False else '-',
 267
 268             'type': 'osm',
 269             'nsd': len(nsd['data']) if nsd and nsd['error'] is False else 0,
 270             'vnfd': len(vnfd['data']) if vnfd and vnfd['error'] is False else 0,
 271             'ns': len(ns['data']) if ns and ns['error'] is False else 0,
 272             'vnf': len(vnf['data']) if vnf and vnf['error'] is False else 0,
 273         }
 274         return render(request, 'osm/osm_project_details.html',
 275                       {'project_overview': project_overview, 'project_id': project_id})
 276
 277     except Exception as e:
 278         print e
 279         return render(request, 'error.html', {'error_msg': 'Error open project! Please retry.'})
 280
 281
 282 @login_required
 283 def delete_project(request, project_id):
 284     user = osmutils.get_user(request)
 285
 286     client = Client()
 287     result = client.project_delete(user.get_token(), project_id)
 288     if isinstance(result, dict) and 'error' in result and result['error']:
 289         print result
 290         return __response_handler(request, result['data'], url=None,
 291                                   status=result['data']['status'] if 'status' in result['data'] else 500)
 292     else:
 293         return __response_handler(request, {}, url=None, status=200)
 294
 295
 296 @login_required
 297 def switch_project(request, project_id):
 298     user = osmutils.get_user(request)
 299     user.switch_project(project_id)
 300     return redirect('projects:open_project')
 301
 302
 303 @login_required
 304 def edit_project(request, project_id):
 305     if request.method == 'POST':
 306         user = osmutils.get_user(request)
 307         client = Client()
 308         project_dict = request.POST.dict()
 309         keys = ["name"]
 310         project_data = dict(filter(lambda i: i[0] in keys and len(i[1]) > 0, project_dict.items()))
 311         result = client.project_edit(user.get_token(), project_id, project_data)
 312         if isinstance(result, dict) and 'error' in result and result['error']:
 313             print result
 314             return __response_handler(request, result['data'], url=None,
 315                                       status=result['data']['status'] if 'status' in result['data'] else 500)
 316         else:
 317             return __response_handler(request, {}, url=None, status=200)
 318
 319
 320 @login_required
 321 def show_descriptors(request, descriptor_type=None):
 322     user = osmutils.get_user(request)
 323     project_id = user.project_id
 324     client = Client()
 325     print request.GET.dict()
 326     try:
 327         if descriptor_type == 'nsd':
 328             descriptors = client.nsd_list(user.get_token())
 329         elif descriptor_type == 'vnfd':
 330             descriptors = client.vnfd_list(user.get_token())
 331     except Exception as e:
 332         log.exception(e)
 333         descriptors = []
 334
 335     url = 'osm/osm_project_descriptors.html'
 336     return __response_handler(request, {
 337         'descriptors': descriptors['data'] if descriptors and descriptors['error'] is False else [],
 338         'project_id': project_id,
 339         'project_type': 'osm',
 340         'descriptor_type': descriptor_type
 341     },url)
 342
 343
 344 @login_required
 345 def delete_descriptor(request, descriptor_type=None, descriptor_id=None):
 346     user = osmutils.get_user(request)
 347     project_id = user.project_id
 348     try:
 349         client = Client()
 350         if descriptor_type == 'nsd':
 351             result = client.nsd_delete(user.get_token(), descriptor_id)
 352         elif descriptor_type == 'vnfd':
 353             result = client.vnfd_delete(user.get_token(), descriptor_id)
 354     except Exception as e:
 355         log.exception(e)
 356         result = {'error': True, 'data': str(e)}
 357
 358     url = 'osm/osm_project_descriptors.html'
 359     descriptors = {}
 360     try:
 361         if descriptor_type == 'nsd':
 362             descriptors = client.nsd_list(user.get_token())
 363         elif descriptor_type == 'vnfd':
 364             descriptors = client.vnfd_list(user.get_token())
 365     except Exception as e:
 366         log.exception(e)
 367
 368     return __response_handler(request, {
 369         'descriptors': descriptors['data'] if descriptors and descriptors['error'] is False else [],
 370         'project_id': project_id,
 371         'project_type': 'osm',
 372         'descriptor_type': descriptor_type,
 373         'alert_message': {
 374             'success': False if result['error'] is True else True,
 375             'message': 'An error occurred while processing your request.' if result and result['error'] is True else "Record deleted successfully"}
 376     }, url)
 377
 378
 379 @login_required
 380 def clone_descriptor(request, descriptor_type=None, descriptor_id=None):
 381     user = osmutils.get_user(request)
 382     project_id = user.project_id
 383
 384     try:
 385         client = Client()
 386         if descriptor_type == 'nsd':
 387             result = client.nsd_clone(user.get_token(), descriptor_id)
 388         elif descriptor_type == 'vnfd':
 389             result = client.vnfd_clone(user.get_token(), descriptor_id)
 390         else:
 391             log.debug('Update descriptor: Unknown data type')
 392             result = {'error': True, 'data': 'Update descriptor: Unknown data type'}
 393     except Exception as e:
 394         log.exception(e)
 395         result = {'error': True, 'data': str(e)}
 396     print result
 397     if result['error'] == True:
 398         return __response_handler(request, result['data'], url=None,
 399                                   status=result['data']['status'] if 'status' in result['data'] else 500)
 400
 401     else:
 402         return __response_handler(request, {}, url=None, status=200)
 403
 404
 405
 406 @login_required
 407 def new_descriptor(request, descriptor_type=None):
 408     user = osmutils.get_user(request)
 409     project_id = user.project_id
 410     page = 'osm/descriptor/descriptor_new.html'
 411     if request.method == 'GET':
 412         request_id = request.GET.get('id', '')
 413
 414         return __response_handler(request,  {
 415             'project_id': project_id,
 416             'descriptor_type': descriptor_type,
 417             'descriptor_id': request_id,
 418         }, page)
 419     elif request.method == 'POST':
 420         data_type = request.POST.get('type')
 421         print "TYPE", data_type
 422         if data_type == "file":
 423             file_uploaded = request.FILES['file']
 424
 425             try:
 426                 client = Client()
 427                 if descriptor_type == 'nsd':
 428                     result = client.nsd_onboard(user.get_token(), file_uploaded)
 429                 elif descriptor_type == 'vnfd':
 430                     result = client.vnfd_onboard(user.get_token(), file_uploaded)
 431                 else:
 432                     log.debug('Create descriptor: Unknown data type')
 433                     result = {'error': True, 'data': 'Create descriptor: Unknown data type'}
 434
 435             except Exception as e:
 436                 log.exception(e)
 437                 result = {'error': True, 'data': str(e)}
 438         else:
 439             result = {'error': True, 'data': 'Create descriptor: Unknown data type'}
 440
 441         if result['error']:
 442             print result
 443             return __response_handler(request, result['data'], url=None, status=result['data']['status'] if 'status' in result['data'] else 500)
 444         else:
 445             return __response_handler(request, {}, url=None, status=200)
 446
 447
 448 @login_required
 449 def edit_descriptor(request, descriptor_id=None, descriptor_type=None):
 450     user = osmutils.get_user(request)
 451     project_id = user.project_id
 452     if request.method == 'POST':
 453         print "edit_descriptor"
 454         new_data = request.POST.get('text'),
 455         data_type = request.POST.get('type')
 456         #print new_data
 457         try:
 458             client = Client()
 459             if descriptor_type == 'nsd':
 460                 if data_type == 'yaml':
 461                     new_data = yaml.load(request.POST.get('text'))
 462                 elif data_type == 'json':
 463                     new_data = json.loads(request.POST.get('text'))
 464                 print new_data
 465                 result = client.nsd_update(user.get_token(), descriptor_id, new_data)
 466             elif descriptor_type == 'vnfd':
 467                 if data_type == 'yaml':
 468                     new_data = yaml.load(request.POST.get('text'))
 469                 elif data_type == 'json':
 470                     new_data = json.loads(request.POST.get('text'))
 471                 print new_data
 472                 result = client.vnfd_update(user.get_token(), descriptor_id, new_data)
 473
 474             else:
 475                 log.debug('Update descriptor: Unknown data type')
 476                 result = {'error': True, 'data': 'Update descriptor: Unknown data type'}
 477         except Exception as e:
 478             log.exception(e)
 479             result = {'error': True, 'data': str(e)}
 480         print result
 481         if result['error'] == True:
 482             return __response_handler(request, result['data'], url=None, status=result['data']['status'] if 'status' in result['data'] else 500)
 483
 484         else:
 485             return __response_handler(request, {}, url=None, status=200)
 486
 487     elif request.method == 'GET':
 488
 489         page = 'osm/descriptor/descriptor_view.html'
 490         try:
 491             client = Client()
 492             if descriptor_type == 'nsd':
 493                 result = client.nsd_get(user.get_token(), descriptor_id)
 494                 print result
 495             elif descriptor_type == 'vnfd':
 496                 result = client.vnfd_get(user.get_token(), descriptor_id)
 497
 498                 print result
 499         except Exception as e:
 500             log.exception(e)
 501             result = {'error': True, 'data': str(e)}
 502
 503         if isinstance(result, dict) and 'error' in result and result['error']:
 504             return render(request, 'error.html')
 505
 506         descriptor_string_json = json.dumps(result, indent=2)
 507         descriptor_string_yaml = Util.json2yaml(result)
 508         # print descriptor
 509         return render(request, page, {
 510             'project_id': project_id,
 511             'descriptor_id': descriptor_id,
 512             'descriptor_type': descriptor_type,
 513             'descriptor_strings': {'descriptor_string_yaml': descriptor_string_yaml,
 514                                    'descriptor_string_json': descriptor_string_json}})
 515
 516
 517 @login_required
 518 def get_package_files_list(request, descriptor_id, descriptor_type):
 519     user = osmutils.get_user(request)
 520     try:
 521         client = Client()
 522         if descriptor_type == 'nsd':
 523             artifacts_res = client.nsd_artifacts(user.get_token(), descriptor_id)
 524         elif descriptor_type == 'vnfd':
 525             artifacts_res = client.vnf_packages_artifacts(user.get_token(), descriptor_id)
 526         else:
 527             return False
 528
 529         files_list = yaml.load(artifacts_res['data'] if artifacts_res and artifacts_res['error'] is False else [])
 530         result = {'files': files_list}
 531     except Exception as e:
 532         log.exception(e)
 533         url = 'error.html'
 534         result = {'error_msg': 'Unknown error.'}
 535     return __response_handler(request, result)
 536
 537 @login_required
 538 def download_pkg(request, descriptor_id, descriptor_type):
 539     user = osmutils.get_user(request)
 540     file_name = "osm_export.tar.gz"
 541     tar_pkg = None
 542     try:
 543         client = Client()
 544         if descriptor_type == 'nsd':
 545             tar_pkg = client.get_nsd_pkg(user.get_token(), descriptor_id)
 546         elif descriptor_type == 'vnfd':
 547             tar_pkg = client.get_vnfd_pkg(user.get_token(), descriptor_id)
 548
 549     except Exception as e:
 550         log.exception(e)
 551
 552     response = HttpResponse(content_type="application/tgz")
 553     response["Content-Disposition"] = "attachment; filename="+ file_name
 554     response.write(tar_pkg.getvalue())
 555     return response
 556
 557
 558 @login_required
 559 def custom_action(request, descriptor_id=None, descriptor_type=None, action_name=None):
 560     if request.method == 'GET':
 561         print "Custom action: " + action_name
 562         return globals()[action_name](request, descriptor_id, descriptor_type)
 563
 564
 565 def __response_handler(request, data_res, url=None, to_redirect=None, *args, **kwargs):
 566     raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
 567     if 'application/json' in raw_content_types or url is None:
 568         return HttpResponse(json.dumps(data_res), content_type="application/json", *args, **kwargs)
 569     elif to_redirect:
 570         return redirect(url, *args, **kwargs)
 571     else:
 572         return render(request, url, data_res)