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