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 django.contrib.auth.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
  68 def open_composer(request):
  69     user = osmutils.get_user(request)
  70     project_id = user.project_id
  71     result = {'project_id': project_id,
  72               'vertices': [
  73                   {"info": {"type": "vnf", "property": {"custom_label": ""},
  74                             "group": []}, "id": "vm"},
  75                   {"info": {"type": "vnf", "property": {"custom_label": ""},
  76                             "group": []}, "id": "vlan"},
  77                   {"info": {"type": "vnf", "property": {"custom_label": ""},
  78                             "group": []}, "id": "firewall"},
  79                   {"info": {"type": "vnf", "property": {"custom_label": ""},
  80                             "group": []}, "id": "ping"},
  81
  82                   {"info": {"type": "ns_vl", "property": {"custom_label": ""},
  83                             "group": []}, "id": "vl1"},
  84                   {"info": {"type": "ns_vl", "property": {"custom_label": ""},
  85                             "group": []}, "id": "vl2"},
  86                   {"info": {"type": "ns_vl", "property": {"custom_label": ""},
  87                             "group": []}, "id": "vl3"},
  88               ],
  89               'edges': [
  90                   {"source": "vm", "group": [], "target": "vl3", "view": "ns"},
  91                   {"source": "vlan", "group": [], "target": "vl3", "view": "ns"},
  92                   {"source": "vlan", "group": [], "target": "vl1", "view": "ns"},
  93                   {"source": "firewall", "group": [], "target": "vl1", "view": "ns"},
  94                   {"source": "firewall", "group": [], "target": "vl2", "view": "ns"},
  95                   {"source": "ping", "group": [], "target": "vl2", "view": "ns"},
  96               ],
  97               'model': {
  98                 "layer": {
  99
 100                     "ns": {
 101                         "nodes": {
 102                             "vnf": {
 103                                 "addable": {
 104                                     "callback": "addNode"
 105                                 },
 106                                 "removable": {
 107                                     "callback": "removeNode"
 108                                 },
 109                                 "expands": "vnf"
 110                             },
 111                             "ns_vl": {
 112                                 "addable": {
 113                                     "callback": "addNode"
 114                                 },
 115                                 "removable": {
 116                                     "callback": "removeNode"
 117                                 }
 118                             },
 119
 120                         },
 121                         "allowed_edges": {
 122                             "ns_vl": {
 123                                 "destination": {
 124                                     "vnf": {
 125                                         "callback": "addLink",
 126                                         "direct_edge": False,
 127                                         "removable": {
 128                                             "callback": "removeLink"
 129                                         }
 130                                     }
 131                                 }
 132                             },
 133                             "vnf": {
 134                                 "destination": {
 135                                     "ns_vl": {
 136                                         "callback": "addLink",
 137                                         "direct_edge": False,
 138                                         "removable": {
 139                                             "callback": "removeLink"
 140                                         }
 141                                     },
 142
 143                                 }
 144                             }
 145
 146                         }
 147                     },
 148                     "vnf": {
 149                         "nodes": {
 150                             "vdu": {
 151                                 "addable": {
 152                                     "callback": "addNode"
 153                                 },
 154                                 "removable": {
 155                                     "callback": "removeNode"
 156                                 }
 157                             },
 158                             "cp": {
 159                                 "addable": {
 160                                     "callback": "addNode"
 161                                 },
 162                                 "removable": {
 163                                     "callback": "removeNode"
 164                                 }
 165                             },
 166
 167                         },
 168                         "allowed_edges": {
 169                             "vdu": {
 170                                 "destination": {
 171                                     "cp": {
 172                                         "callback": "addLink",
 173                                         "direct_edge": False,
 174                                         "removable": {
 175                                             "callback": "removeLink"
 176                                         }
 177                                     }
 178                                 }
 179                             },
 180                             "cp": {
 181                                 "destination": {
 182                                     "vdu": {
 183                                         "callback": "addLink",
 184                                         "direct_edge": False,
 185                                         "removable": {
 186                                             "callback": "removeLink"
 187                                         }
 188                                     }
 189                                 }
 190                             }
 191                         }
 192                     },
 193                     "name": "OSM",
 194                     "version": 1,
 195                     "nodes": {
 196                         "vnf": {
 197                             "label": "vnf"
 198                         },
 199                         "ns_vl": {
 200                             "label": "vl"
 201                         },
 202                         "cp": {
 203                             "label": "cp"
 204                         },
 205                         "vdu": {
 206                             "label": "vdu"
 207                         }
 208                     },
 209                     "description": "osm",
 210                     "callback": {
 211                         "addNode": {
 212                             "file": "osm_controller.js",
 213                             "class": "OsmController"
 214                         },
 215                         "removeNode": {
 216                             "file": "osm_controller.js",
 217                             "class": "OsmController"
 218                         },
 219                         "addLink": {
 220                             "file": "osm_controller.js",
 221                             "class": "OsmController"
 222                         },
 223                         "removeLink": {
 224                             "file": "osm_controller.js",
 225                             "class": "OsmController"
 226                         }
 227                     }
 228
 229                 }
 230             }}
 231     return __response_handler(request, result, 'project_graph_base.html')
 232
 233
 234 def get_available_nodes(request):
 235
 236     params = request.GET.dict()
 237     nodes = {
 238         'ns': [{"types": [{"name": "Generic", "id": "vnf"},
 239                           {"name": "ping", "id": "vnf"},
 240                           {"name": "pong", "id": "vnf"},
 241                           {"name": "hackfest1-vm", "id": "vnf"}], "category_name": "Vnf"},
 242                {"types": [{"name": "VL", "id": "ns_vl"}], "category_name": "VirtualLink"}],
 243         'vnf': [{"types": [{"name": "VDU", "id": "vdu"}], "category_name": "Vdu"},
 244                 {"types": [{"name": "CP", "id": "cp"}], "category_name": "CP"}]
 245     }
 246
 247     return __response_handler(request, nodes[params['layer']])
 248
 249
 250 @login_required
 251 def open_project(request):
 252     user = osmutils.get_user(request)
 253     project_id = user.project_id
 254     try:
 255
 256         client = Client()
 257         ##TODO change with adhoc api call
 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': '-',
 266             'created_date': '-',
 267             'info': '-',
 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):
 284     user = osmutils.get_user(request)
 285     project_id = user.project_id
 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 show_descriptors(request, descriptor_type=None):
 305     user = osmutils.get_user(request)
 306     project_id = user.project_id
 307     client = Client()
 308     print request.GET.dict()
 309     try:
 310         if descriptor_type == 'nsd':
 311             descriptors = client.nsd_list(user.get_token())
 312         elif descriptor_type == 'vnfd':
 313             descriptors = client.vnfd_list(user.get_token())
 314     except Exception as e:
 315         log.exception(e)
 316         descriptors = []
 317
 318     url = 'osm/osm_project_descriptors.html'
 319     return __response_handler(request, {
 320         'descriptors': descriptors['data'] if descriptors and descriptors['error'] is False else [],
 321         'project_id': project_id,
 322         'project_type': 'osm',
 323         'descriptor_type': descriptor_type
 324     },url)
 325
 326
 327 @login_required
 328 def delete_descriptor(request, descriptor_type=None, descriptor_id=None):
 329     user = osmutils.get_user(request)
 330     project_id = user.project_id
 331     try:
 332         client = Client()
 333         if descriptor_type == 'nsd':
 334             result = client.nsd_delete(user.get_token(), descriptor_id)
 335         elif descriptor_type == 'vnfd':
 336             result = client.vnfd_delete(user.get_token(), descriptor_id)
 337     except Exception as e:
 338         log.exception(e)
 339         result = {'error': True, 'data': str(e)}
 340
 341     url = 'osm/osm_project_descriptors.html'
 342     descriptors = {}
 343     try:
 344         if descriptor_type == 'nsd':
 345             descriptors = client.nsd_list(user.get_token())
 346         elif descriptor_type == 'vnfd':
 347             descriptors = client.vnfd_list(user.get_token())
 348     except Exception as e:
 349         log.exception(e)
 350
 351     return __response_handler(request, {
 352         'descriptors': descriptors['data'] if descriptors and descriptors['error'] is False else [],
 353         'project_id': project_id,
 354         'project_type': 'osm',
 355         'descriptor_type': descriptor_type,
 356         'alert_message': {
 357             'success': False if result['error'] is True else True,
 358             'message': 'An error occurred while processing your request.' if result and result['error'] is True else "Record deleted successfully"}
 359     }, url)
 360
 361
 362
 363 @login_required
 364 def new_descriptor(request, descriptor_type=None):
 365     user = osmutils.get_user(request)
 366     project_id = user.project_id
 367     page = 'osm/descriptor/descriptor_new.html'
 368     if request.method == 'GET':
 369         request_id = request.GET.get('id', '')
 370
 371         return __response_handler(request,  {
 372             'project_id': project_id,
 373             'descriptor_type': descriptor_type,
 374             'descriptor_id': request_id,
 375         }, page)
 376     elif request.method == 'POST':
 377         data_type = request.POST.get('type')
 378         print "TYPE", data_type
 379         if data_type == "file":
 380             file_uploaded = request.FILES['file']
 381
 382             try:
 383                 client = Client()
 384                 if descriptor_type == 'nsd':
 385                     result = client.nsd_onboard(user.get_token(), file_uploaded)
 386                 elif descriptor_type == 'vnfd':
 387                     result = client.vnfd_onboard(user.get_token(), file_uploaded)
 388                 else:
 389                     log.debug('Create descriptor: Unknown data type')
 390                     result = {'error': True, 'data': 'Create descriptor: Unknown data type'}
 391
 392             except Exception as e:
 393                 log.exception(e)
 394                 result = {'error': True, 'data': str(e)}
 395         else:
 396             result = {'error': True, 'data': 'Create descriptor: Unknown data type'}
 397
 398         if result['error']:
 399             print result
 400             return __response_handler(request, result['data'], url=None, status=result['data']['status'] if 'status' in result['data'] else 500)
 401         else:
 402             return __response_handler(request, {}, url=None, status=200)
 403
 404
 405 @login_required
 406 def edit_descriptor(request, descriptor_id=None, descriptor_type=None):
 407     user = osmutils.get_user(request)
 408     project_id = user.project_id
 409     if request.method == 'POST':
 410         print "edit_descriptor"
 411         new_data = request.POST.get('text'),
 412         data_type = request.POST.get('type')
 413         #print new_data
 414         try:
 415             client = Client()
 416             if descriptor_type == 'nsd':
 417                 if data_type == 'yaml':
 418                     new_data = yaml.load(request.POST.get('text'))
 419                 elif data_type == 'json':
 420                     new_data = json.loads(request.POST.get('text'))
 421                 print new_data
 422                 result = client.nsd_update(user.get_token(), descriptor_id, new_data)
 423             elif descriptor_type == 'vnfd':
 424                 if data_type == 'yaml':
 425                     new_data = yaml.load(request.POST.get('text'))
 426                 elif data_type == 'json':
 427                     new_data = json.loads(request.POST.get('text'))
 428                 print new_data
 429                 result = client.vnfd_update(user.get_token(), descriptor_id, new_data)
 430
 431             else:
 432                 log.debug('Update descriptor: Unknown data type')
 433                 result = {'error': True, 'data': 'Update descriptor: Unknown data type'}
 434         except Exception as e:
 435             log.exception(e)
 436             result = {'error': True, 'data': str(e)}
 437         print result
 438         if result['error'] == True:
 439             return __response_handler(request, result['data'], url=None, status=result['data']['status'] if 'status' in result['data'] else 500)
 440
 441         else:
 442             return __response_handler(request, {}, url=None, status=200)
 443
 444     elif request.method == 'GET':
 445
 446         page = 'osm/descriptor/descriptor_view.html'
 447         try:
 448             client = Client()
 449             if descriptor_type == 'nsd':
 450                 result = client.nsd_get(user.get_token(), descriptor_id)
 451                 print result
 452             elif descriptor_type == 'vnfd':
 453                 result = client.vnfd_get(user.get_token(), descriptor_id)
 454
 455                 print result
 456         except Exception as e:
 457             log.exception(e)
 458             result = {'error': True, 'data': str(e)}
 459
 460         if isinstance(result, dict) and 'error' in result and result['error']:
 461             return render(request, 'error.html')
 462
 463         descriptor_string_json = json.dumps(result, indent=2)
 464         descriptor_string_yaml = Util.json2yaml(result)
 465         # print descriptor
 466         return render(request, page, {
 467             'project_id': project_id,
 468             'descriptor_id': descriptor_id,
 469             'descriptor_type': descriptor_type,
 470             'descriptor_strings': {'descriptor_string_yaml': descriptor_string_yaml,
 471                                    'descriptor_string_json': descriptor_string_json}})
 472
 473
 474 @login_required
 475 def get_package_files_list(request, descriptor_id, descriptor_type):
 476     user = osmutils.get_user(request)
 477     try:
 478         client = Client()
 479         if descriptor_type == 'nsd':
 480             artifacts_res = client.nsd_artifacts(user.get_token(), descriptor_id)
 481         elif descriptor_type == 'vnfd':
 482             artifacts_res = client.vnf_packages_artifacts(user.get_token(), descriptor_id)
 483         else:
 484             return False
 485
 486         files_list = yaml.load(artifacts_res['data'] if artifacts_res and artifacts_res['error'] is False else [])
 487         result = {'files': files_list}
 488     except Exception as e:
 489         log.exception(e)
 490         url = 'error.html'
 491         result = {'error_msg': 'Unknown error.'}
 492     return __response_handler(request, result)
 493
 494 @login_required
 495 def download_pkg(request, descriptor_id, descriptor_type):
 496     user = osmutils.get_user(request)
 497     file_name = "osm_export.tar.gz"
 498     tar_pkg = None
 499     try:
 500         client = Client()
 501         if descriptor_type == 'nsd':
 502             tar_pkg = client.get_nsd_pkg(user.get_token(), descriptor_id)
 503         elif descriptor_type == 'vnfd':
 504             tar_pkg = client.get_vnfd_pkg(user.get_token(), descriptor_id)
 505
 506     except Exception as e:
 507         log.exception(e)
 508
 509     response = HttpResponse(content_type="application/tgz")
 510     response["Content-Disposition"] = "attachment; filename="+ file_name
 511     response.write(tar_pkg.getvalue())
 512     return response
 513
 514
 515 @login_required
 516 def custom_action(request, descriptor_id=None, descriptor_type=None, action_name=None):
 517     if request.method == 'GET':
 518         print "Custom action: " + action_name
 519         return globals()[action_name](request, descriptor_id, descriptor_type)
 520
 521
 522 def __response_handler(request, data_res, url=None, to_redirect=None, *args, **kwargs):
 523     raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
 524     if 'application/json' in raw_content_types or url is None:
 525         return HttpResponse(json.dumps(data_res), content_type="application/json", *args, **kwargs)
 526     elif to_redirect:
 527         return redirect(url, *args, **kwargs)
 528     else:
 529         return render(request, url, data_res)