projecthandler/views.py

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