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         prj = client.project_get(user.get_token(), project_id)
 259         nsd = client.nsd_list(user.get_token())
 260         vnfd = client.vnfd_list(user.get_token())
 261         ns = client.ns_list(user.get_token())
 262         vnf = client.vnf_list(user.get_token())
 263         project_overview = {
 264             'owner': user.username,
 265             'name': project_id,
 266             'updated_date': prj['data']['_admin']['modified'] if prj and prj['error'] is False else '-',
 267             'created_date': prj['data']['_admin']['created'] if prj and prj['error'] is False else '-',
 268
 269             'type': 'osm',
 270             'nsd': len(nsd['data']) if nsd and nsd['error'] is False else 0,
 271             'vnfd': len(vnfd['data']) if vnfd and vnfd['error'] is False else 0,
 272             'ns': len(ns['data']) if ns and ns['error'] is False else 0,
 273             'vnf': len(vnf['data']) if vnf and vnf['error'] is False else 0,
 274         }
 275         return render(request, 'osm/osm_project_details.html',
 276                       {'project_overview': project_overview, 'project_id': project_id})
 277
 278     except Exception as e:
 279         print e
 280         return render(request, 'error.html', {'error_msg': 'Error open project! Please retry.'})
 281
 282
 283 @login_required
 284 def delete_project(request):
 285     user = osmutils.get_user(request)
 286     project_id = user.project_id
 287     client = Client()
 288     result = client.project_delete(user.get_token(), project_id)
 289     if isinstance(result, dict) and 'error' in result and result['error']:
 290         print result
 291         return __response_handler(request, result['data'], url=None,
 292                                   status=result['data']['status'] if 'status' in result['data'] else 500)
 293     else:
 294         return __response_handler(request, {}, url=None, status=200)
 295
 296
 297 @login_required
 298 def switch_project(request, project_id):
 299     user = osmutils.get_user(request)
 300     user.switch_project(project_id)
 301     return redirect('projects:open_project')
 302
 303
 304 @login_required
 305 def show_descriptors(request, descriptor_type=None):
 306     user = osmutils.get_user(request)
 307     project_id = user.project_id
 308     client = Client()
 309     print request.GET.dict()
 310     try:
 311         if descriptor_type == 'nsd':
 312             descriptors = client.nsd_list(user.get_token())
 313         elif descriptor_type == 'vnfd':
 314             descriptors = client.vnfd_list(user.get_token())
 315     except Exception as e:
 316         log.exception(e)
 317         descriptors = []
 318
 319     url = 'osm/osm_project_descriptors.html'
 320     return __response_handler(request, {
 321         'descriptors': descriptors['data'] if descriptors and descriptors['error'] is False else [],
 322         'project_id': project_id,
 323         'project_type': 'osm',
 324         'descriptor_type': descriptor_type
 325     },url)
 326
 327
 328 @login_required
 329 def delete_descriptor(request, descriptor_type=None, descriptor_id=None):
 330     user = osmutils.get_user(request)
 331     project_id = user.project_id
 332     try:
 333         client = Client()
 334         if descriptor_type == 'nsd':
 335             result = client.nsd_delete(user.get_token(), descriptor_id)
 336         elif descriptor_type == 'vnfd':
 337             result = client.vnfd_delete(user.get_token(), descriptor_id)
 338     except Exception as e:
 339         log.exception(e)
 340         result = {'error': True, 'data': str(e)}
 341
 342     url = 'osm/osm_project_descriptors.html'
 343     descriptors = {}
 344     try:
 345         if descriptor_type == 'nsd':
 346             descriptors = client.nsd_list(user.get_token())
 347         elif descriptor_type == 'vnfd':
 348             descriptors = client.vnfd_list(user.get_token())
 349     except Exception as e:
 350         log.exception(e)
 351
 352     return __response_handler(request, {
 353         'descriptors': descriptors['data'] if descriptors and descriptors['error'] is False else [],
 354         'project_id': project_id,
 355         'project_type': 'osm',
 356         'descriptor_type': descriptor_type,
 357         'alert_message': {
 358             'success': False if result['error'] is True else True,
 359             'message': 'An error occurred while processing your request.' if result and result['error'] is True else "Record deleted successfully"}
 360     }, url)
 361
 362
 363
 364 @login_required
 365 def new_descriptor(request, descriptor_type=None):
 366     user = osmutils.get_user(request)
 367     project_id = user.project_id
 368     page = 'osm/descriptor/descriptor_new.html'
 369     if request.method == 'GET':
 370         request_id = request.GET.get('id', '')
 371
 372         return __response_handler(request,  {
 373             'project_id': project_id,
 374             'descriptor_type': descriptor_type,
 375             'descriptor_id': request_id,
 376         }, page)
 377     elif request.method == 'POST':
 378         data_type = request.POST.get('type')
 379         print "TYPE", data_type
 380         if data_type == "file":
 381             file_uploaded = request.FILES['file']
 382
 383             try:
 384                 client = Client()
 385                 if descriptor_type == 'nsd':
 386                     result = client.nsd_onboard(user.get_token(), file_uploaded)
 387                 elif descriptor_type == 'vnfd':
 388                     result = client.vnfd_onboard(user.get_token(), file_uploaded)
 389                 else:
 390                     log.debug('Create descriptor: Unknown data type')
 391                     result = {'error': True, 'data': 'Create descriptor: Unknown data type'}
 392
 393             except Exception as e:
 394                 log.exception(e)
 395                 result = {'error': True, 'data': str(e)}
 396         else:
 397             result = {'error': True, 'data': 'Create descriptor: Unknown data type'}
 398
 399         if result['error']:
 400             print result
 401             return __response_handler(request, result['data'], url=None, status=result['data']['status'] if 'status' in result['data'] else 500)
 402         else:
 403             return __response_handler(request, {}, url=None, status=200)
 404
 405
 406 @login_required
 407 def edit_descriptor(request, descriptor_id=None, descriptor_type=None):
 408     user = osmutils.get_user(request)
 409     project_id = user.project_id
 410     if request.method == 'POST':
 411         print "edit_descriptor"
 412         new_data = request.POST.get('text'),
 413         data_type = request.POST.get('type')
 414         #print new_data
 415         try:
 416             client = Client()
 417             if descriptor_type == 'nsd':
 418                 if data_type == 'yaml':
 419                     new_data = yaml.load(request.POST.get('text'))
 420                 elif data_type == 'json':
 421                     new_data = json.loads(request.POST.get('text'))
 422                 print new_data
 423                 result = client.nsd_update(user.get_token(), descriptor_id, new_data)
 424             elif descriptor_type == 'vnfd':
 425                 if data_type == 'yaml':
 426                     new_data = yaml.load(request.POST.get('text'))
 427                 elif data_type == 'json':
 428                     new_data = json.loads(request.POST.get('text'))
 429                 print new_data
 430                 result = client.vnfd_update(user.get_token(), descriptor_id, new_data)
 431
 432             else:
 433                 log.debug('Update descriptor: Unknown data type')
 434                 result = {'error': True, 'data': 'Update descriptor: Unknown data type'}
 435         except Exception as e:
 436             log.exception(e)
 437             result = {'error': True, 'data': str(e)}
 438         print result
 439         if result['error'] == True:
 440             return __response_handler(request, result['data'], url=None, status=result['data']['status'] if 'status' in result['data'] else 500)
 441
 442         else:
 443             return __response_handler(request, {}, url=None, status=200)
 444
 445     elif request.method == 'GET':
 446
 447         page = 'osm/descriptor/descriptor_view.html'
 448         try:
 449             client = Client()
 450             if descriptor_type == 'nsd':
 451                 result = client.nsd_get(user.get_token(), descriptor_id)
 452                 print result
 453             elif descriptor_type == 'vnfd':
 454                 result = client.vnfd_get(user.get_token(), descriptor_id)
 455
 456                 print result
 457         except Exception as e:
 458             log.exception(e)
 459             result = {'error': True, 'data': str(e)}
 460
 461         if isinstance(result, dict) and 'error' in result and result['error']:
 462             return render(request, 'error.html')
 463
 464         descriptor_string_json = json.dumps(result, indent=2)
 465         descriptor_string_yaml = Util.json2yaml(result)
 466         # print descriptor
 467         return render(request, page, {
 468             'project_id': project_id,
 469             'descriptor_id': descriptor_id,
 470             'descriptor_type': descriptor_type,
 471             'descriptor_strings': {'descriptor_string_yaml': descriptor_string_yaml,
 472                                    'descriptor_string_json': descriptor_string_json}})
 473
 474
 475 @login_required
 476 def get_package_files_list(request, descriptor_id, descriptor_type):
 477     user = osmutils.get_user(request)
 478     try:
 479         client = Client()
 480         if descriptor_type == 'nsd':
 481             artifacts_res = client.nsd_artifacts(user.get_token(), descriptor_id)
 482         elif descriptor_type == 'vnfd':
 483             artifacts_res = client.vnf_packages_artifacts(user.get_token(), descriptor_id)
 484         else:
 485             return False
 486
 487         files_list = yaml.load(artifacts_res['data'] if artifacts_res and artifacts_res['error'] is False else [])
 488         result = {'files': files_list}
 489     except Exception as e:
 490         log.exception(e)
 491         url = 'error.html'
 492         result = {'error_msg': 'Unknown error.'}
 493     return __response_handler(request, result)
 494
 495 @login_required
 496 def download_pkg(request, descriptor_id, descriptor_type):
 497     user = osmutils.get_user(request)
 498     file_name = "osm_export.tar.gz"
 499     tar_pkg = None
 500     try:
 501         client = Client()
 502         if descriptor_type == 'nsd':
 503             tar_pkg = client.get_nsd_pkg(user.get_token(), descriptor_id)
 504         elif descriptor_type == 'vnfd':
 505             tar_pkg = client.get_vnfd_pkg(user.get_token(), descriptor_id)
 506
 507     except Exception as e:
 508         log.exception(e)
 509
 510     response = HttpResponse(content_type="application/tgz")
 511     response["Content-Disposition"] = "attachment; filename="+ file_name
 512     response.write(tar_pkg.getvalue())
 513     return response
 514
 515
 516 @login_required
 517 def custom_action(request, descriptor_id=None, descriptor_type=None, action_name=None):
 518     if request.method == 'GET':
 519         print "Custom action: " + action_name
 520         return globals()[action_name](request, descriptor_id, descriptor_type)
 521
 522
 523 def __response_handler(request, data_res, url=None, to_redirect=None, *args, **kwargs):
 524     raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
 525     if 'application/json' in raw_content_types or url is None:
 526         return HttpResponse(json.dumps(data_res), content_type="application/json", *args, **kwargs)
 527     elif to_redirect:
 528         return redirect(url, *args, **kwargs)
 529     else:
 530         return render(request, url, data_res)