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