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