descriptorhandler/views.py

   1 #
   2 #   Copyright 2018 EveryUP Srl
   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
  23 from django.shortcuts import render, redirect
  24
  25
  26 from lib.util import Util
  27 from lib.osm.osmclient.clientv2 import Client
  28 from lib.osm.osm_rdcl_parser import OsmParser
  29 from lib.osm.osm_util import OsmUtil
  30 import authosm.utils as osmutils
  31
  32 logging.basicConfig(level=logging.DEBUG)
  33 log = logging.getLogger('descriptorhandler/view.py')
  34
  35
  36 @login_required
  37 def show_descriptors(request, descriptor_type=None):
  38     user = osmutils.get_user(request)
  39     project_id = user.project_id
  40     client = Client()
  41     try:
  42         if descriptor_type == 'nsd':
  43             descriptors = client.nsd_list(user.get_token())
  44         elif descriptor_type == 'vnfd':
  45             descriptors = client.vnfd_list(user.get_token())
  46     except Exception as e:
  47         log.exception(e)
  48         descriptors = []
  49
  50     url = 'osm/osm_project_descriptors.html'
  51     return __response_handler(request, {
  52         'descriptors': descriptors['data'] if descriptors and descriptors['error'] is False else [],
  53         'project_id': project_id,
  54         'project_type': 'osm',
  55         'descriptor_type': descriptor_type
  56     }, url)
  57
  58
  59 @login_required
  60 def delete_descriptor(request, descriptor_type=None, descriptor_id=None):
  61     user = osmutils.get_user(request)
  62     project_id = user.project_id
  63     try:
  64         client = Client()
  65         if descriptor_type == 'nsd':
  66             result = client.nsd_delete(user.get_token(), descriptor_id)
  67         elif descriptor_type == 'vnfd':
  68             result = client.vnfd_delete(user.get_token(), descriptor_id)
  69     except Exception as e:
  70         log.exception(e)
  71         result = {'error': True, 'data': str(e)}
  72
  73     url = 'osm/osm_project_descriptors.html'
  74     descriptors = {}
  75     try:
  76         if descriptor_type == 'nsd':
  77             descriptors = client.nsd_list(user.get_token())
  78         elif descriptor_type == 'vnfd':
  79             descriptors = client.vnfd_list(user.get_token())
  80     except Exception as e:
  81         log.exception(e)
  82
  83     return __response_handler(request, {
  84         'descriptors': descriptors['data'] if descriptors and descriptors['error'] is False else [],
  85         'project_id': project_id,
  86         'project_type': 'osm',
  87         'descriptor_type': descriptor_type,
  88         'alert_message': {
  89             'success': False if result['error'] is True else True,
  90             'message': 'An error occurred while processing your request.' if result and result['error'] is True else "Record deleted successfully"}
  91     }, url)
  92
  93
  94 @login_required
  95 def clone_descriptor(request, descriptor_type=None, descriptor_id=None):
  96     user = osmutils.get_user(request)
  97     project_id = user.project_id
  98
  99     try:
 100         client = Client()
 101         if descriptor_type == 'nsd':
 102             result = client.nsd_clone(user.get_token(), descriptor_id)
 103         elif descriptor_type == 'vnfd':
 104             result = client.vnfd_clone(user.get_token(), descriptor_id)
 105         else:
 106             log.debug('Update descriptor: Unknown data type')
 107             result = {'error': True, 'data': 'Update descriptor: Unknown data type'}
 108     except Exception as e:
 109         log.exception(e)
 110         result = {'error': True, 'data': str(e)}
 111     if result['error'] == True:
 112         return __response_handler(request, result['data'], url=None,
 113                                   status=result['data']['status'] if 'status' in result['data'] else 500)
 114
 115     else:
 116         return __response_handler(request, {}, url=None, status=200)
 117
 118 @login_required
 119 def addElement(request, descriptor_type=None, descriptor_id=None, element_type=None):
 120     user = osmutils.get_user(request)
 121     project_id = user.project_id
 122     client = Client()
 123     if descriptor_type == 'nsd':
 124         descriptor_result = client.nsd_get(user.get_token(), descriptor_id)
 125         element_id = request.POST.get('id', '')
 126         util = OsmUtil()
 127         descriptor_updated = util.add_base_node('nsd', descriptor_result, element_type, element_id, request.POST.dict())
 128         result = client.nsd_update(user.get_token(), descriptor_id, descriptor_updated)
 129         if result['error'] == True:
 130             return __response_handler(request, result['data'], url=None,
 131                                       status=result['data']['status'] if 'status' in result['data'] else 500)
 132         else:
 133             parser = OsmParser()
 134             # print nsr_object
 135             if descriptor_type == 'nsd':
 136                 result_graph = parser.nsd_to_graph(descriptor_updated)
 137
 138         return __response_handler(request, result_graph, url=None, status=200)
 139
 140     elif descriptor_type == 'vnfd':
 141         descriptor_result = client.vnfd_get(user.get_token(), descriptor_id)
 142         element_id = request.POST.get('id', '')
 143         util = OsmUtil()
 144         descriptor_updated = util.add_base_node('vnfd', descriptor_result, element_type, element_id, request.POST.dict())
 145         result = client.vnfd_update(user.get_token(), descriptor_id, descriptor_updated)
 146         if result['error'] == True:
 147             return __response_handler(request, result['data'], url=None,
 148                                       status=result['data']['status'] if 'status' in result['data'] else 500)
 149         else:
 150             parser = OsmParser()
 151             # print nsr_object
 152             if descriptor_type == 'vnfd':
 153                 result_graph = parser.vnfd_to_graph(descriptor_updated)
 154
 155         return __response_handler(request, result_graph, url=None, status=200)
 156
 157
 158 @login_required
 159 def removeElement(request, descriptor_type=None, descriptor_id=None, element_type=None):
 160     user = osmutils.get_user(request)
 161     project_id = user.project_id
 162     client = Client()
 163     if descriptor_type == 'nsd':
 164         descriptor_result = client.nsd_get(user.get_token(), descriptor_id)
 165         element_id = request.POST.get('id', '')
 166         util = OsmUtil()
 167         descriptor_updated = util.remove_node('nsd', descriptor_result, element_type, element_id, request.POST.dict())
 168         result = client.nsd_update(user.get_token(), descriptor_id, descriptor_updated)
 169         if result['error'] == True:
 170             return __response_handler(request, result['data'], url=None,
 171                                       status=result['data']['status'] if 'status' in result['data'] else 500)
 172         else:
 173             parser = OsmParser()
 174             # print nsr_object
 175             if descriptor_type == 'nsd':
 176                 result_graph = parser.nsd_to_graph(descriptor_updated)
 177
 178         return __response_handler(request, result_graph, url=None, status=200)
 179
 180     elif descriptor_type == 'vnfd':
 181         descriptor_result = client.vnfd_get(user.get_token(), descriptor_id)
 182         element_id = request.POST.get('id', '')
 183         util = OsmUtil()
 184         descriptor_updated = util.remove_node('vnfd', descriptor_result, element_type, element_id, request.POST.dict())
 185         result = client.vnfd_update(user.get_token(), descriptor_id, descriptor_updated)
 186         if result['error'] == True:
 187             return __response_handler(request, result['data'], url=None,
 188                                       status=result['data']['status'] if 'status' in result['data'] else 500)
 189         else:
 190             parser = OsmParser()
 191             # print nsr_object
 192             if descriptor_type == 'vnfd':
 193                 result_graph = parser.vnfd_to_graph(descriptor_updated)
 194
 195             return __response_handler(request, result_graph, url=None, status=200)
 196
 197 @login_required
 198 def updateElement(request, descriptor_type=None, descriptor_id=None, element_type=None):
 199     user = osmutils.get_user(request)
 200     project_id = user.project_id
 201     client = Client()
 202     if descriptor_type == 'nsd':
 203         descriptor_result = client.nsd_get(user.get_token(), descriptor_id)
 204         util = OsmUtil()
 205         payload = request.POST.dict()
 206         if element_type == 'graph_params':
 207             descriptor_updated = util.update_graph_params('nsd', descriptor_result, json.loads(payload['update']))
 208         else:
 209             descriptor_updated = util.update_node('nsd', descriptor_result, element_type, json.loads(payload['old']), json.loads(payload['update']))
 210         result = client.nsd_update(user.get_token(), descriptor_id, descriptor_updated)
 211         if result['error'] == True:
 212             return __response_handler(request, result['data'], url=None,
 213                                       status=result['data']['status'] if 'status' in result['data'] else 500)
 214         else:
 215             parser = OsmParser()
 216             # print nsr_object
 217             if descriptor_type == 'nsd':
 218                 result_graph = parser.nsd_to_graph(descriptor_updated)
 219     if descriptor_type == 'vnfd':
 220         descriptor_result = client.vnfd_get(user.get_token(), descriptor_id)
 221         util = OsmUtil()
 222         payload = request.POST.dict()
 223         if element_type == 'graph_params':
 224             descriptor_updated = util.update_graph_params('vnfd', descriptor_result, json.loads(payload['update']))
 225         else:
 226             descriptor_updated = util.update_node('vnfd', descriptor_result, element_type, json.loads(payload['old']), json.loads(payload['update']))
 227         result = client.vnfd_update(user.get_token(), descriptor_id, descriptor_updated)
 228         if result['error'] == True:
 229             return __response_handler(request, result['data'], url=None,
 230                                       status=result['data']['status'] if 'status' in result['data'] else 500)
 231         else:
 232             parser = OsmParser()
 233             if descriptor_type == 'vnfd':
 234                 result_graph = parser.vnfd_to_graph(descriptor_updated)
 235
 236         return __response_handler(request, result_graph, url=None, status=200)
 237
 238 @login_required
 239 def new_descriptor(request, descriptor_type=None):
 240     user = osmutils.get_user(request)
 241     project_id = user.project_id
 242     page = 'descriptor_new.html'
 243     if request.method == 'GET':
 244         request_id = request.GET.get('id', '')
 245
 246         return __response_handler(request,  {
 247             'project_id': project_id,
 248             'descriptor_type': descriptor_type,
 249             'descriptor_id': request_id,
 250         }, page)
 251     elif request.method == 'POST':
 252         data_type = request.POST.get('type')
 253         if data_type == "file":
 254             file_uploaded = request.FILES['file']
 255
 256             try:
 257                 client = Client()
 258                 if descriptor_type == 'nsd':
 259                     result = client.nsd_onboard(user.get_token(), file_uploaded)
 260                 elif descriptor_type == 'vnfd':
 261                     result = client.vnfd_onboard(user.get_token(), file_uploaded)
 262                 else:
 263                     log.debug('Create descriptor: Unknown data type')
 264                     result = {'error': True, 'data': 'Create descriptor: Unknown data type'}
 265
 266             except Exception as e:
 267                 log.exception(e)
 268                 result = {'error': True, 'data': str(e)}
 269         else:
 270             result = {'error': True, 'data': 'Create descriptor: Unknown data type'}
 271
 272         if result['error']:
 273             return __response_handler(request, result['data'], url=None, status=result['data']['status'] if 'status' in result['data'] else 500)
 274         else:
 275             return __response_handler(request, {}, url=None, status=200)
 276
 277
 278 @login_required
 279 def edit_descriptor(request, descriptor_id=None, descriptor_type=None):
 280     user = osmutils.get_user(request)
 281     project_id = user.project_id
 282     if request.method == 'POST':
 283         new_data = request.POST.get('text'),
 284         data_type = request.POST.get('type')
 285         #print new_data
 286         try:
 287             client = Client()
 288             if descriptor_type == 'nsd':
 289                 if data_type == 'yaml':
 290                     new_data = yaml.load(request.POST.get('text'))
 291                 elif data_type == 'json':
 292                     new_data = json.loads(request.POST.get('text'))
 293                 result = client.nsd_update(user.get_token(), descriptor_id, new_data)
 294             elif descriptor_type == 'vnfd':
 295                 if data_type == 'yaml':
 296                     new_data = yaml.load(request.POST.get('text'))
 297                 elif data_type == 'json':
 298                     new_data = json.loads(request.POST.get('text'))
 299                 result = client.vnfd_update(user.get_token(), descriptor_id, new_data)
 300
 301             else:
 302                 log.debug('Update descriptor: Unknown data type')
 303                 result = {'error': True, 'data': 'Update descriptor: Unknown data type'}
 304         except Exception as e:
 305             log.exception(e)
 306             result = {'error': True, 'data': str(e)}
 307         if result['error'] == True:
 308             return __response_handler(request, result['data'], url=None, status=result['data']['status'] if 'status' in result['data'] else 500)
 309
 310         else:
 311             return __response_handler(request, {}, url=None, status=200)
 312
 313     elif request.method == 'GET':
 314
 315         page = 'descriptor_view.html'
 316         try:
 317             client = Client()
 318             if descriptor_type == 'nsd':
 319                 result = client.nsd_get(user.get_token(), descriptor_id)
 320             elif descriptor_type == 'vnfd':
 321                 result = client.vnfd_get(user.get_token(), descriptor_id)
 322
 323         except Exception as e:
 324             log.exception(e)
 325             result = {'error': True, 'data': str(e)}
 326
 327         if isinstance(result, dict) and 'error' in result and result['error']:
 328             return render(request, 'error.html')
 329
 330         descriptor_string_json = json.dumps(result, indent=2)
 331         descriptor_string_yaml = Util.json2yaml(result)
 332         # print descriptor
 333         return render(request, page, {
 334             'project_id': project_id,
 335             'descriptor_id': descriptor_id,
 336             'descriptor_type': descriptor_type,
 337             'descriptor_strings': {'descriptor_string_yaml': descriptor_string_yaml,
 338                                    'descriptor_string_json': descriptor_string_json}})
 339
 340
 341 @login_required
 342 def get_package_files_list(request, descriptor_id, descriptor_type):
 343     user = osmutils.get_user(request)
 344     try:
 345         client = Client()
 346         if descriptor_type == 'nsd':
 347             artifacts_res = client.nsd_artifacts(user.get_token(), descriptor_id)
 348         elif descriptor_type == 'vnfd':
 349             artifacts_res = client.vnf_packages_artifacts(user.get_token(), descriptor_id)
 350         else:
 351             return False
 352
 353         files_list = yaml.load(artifacts_res['data'] if artifacts_res and artifacts_res['error'] is False else [])
 354         result = {'files': files_list}
 355     except Exception as e:
 356         log.exception(e)
 357         url = 'error.html'
 358         result = {'error_msg': 'Unknown error.'}
 359     return __response_handler(request, result)
 360
 361
 362 @login_required
 363 def download_pkg(request, descriptor_id, descriptor_type):
 364     user = osmutils.get_user(request)
 365     file_name = "osm_export.tar.gz"
 366     tar_pkg = None
 367     try:
 368         client = Client()
 369         if descriptor_type == 'nsd':
 370             tar_pkg = client.get_nsd_pkg(user.get_token(), descriptor_id)
 371         elif descriptor_type == 'vnfd':
 372             tar_pkg = client.get_vnfd_pkg(user.get_token(), descriptor_id)
 373
 374     except Exception as e:
 375         log.exception(e)
 376
 377     response = HttpResponse(content_type="application/tgz")
 378     response["Content-Disposition"] = "attachment; filename="+ file_name
 379     response.write(tar_pkg.getvalue())
 380     return response
 381
 382 @login_required
 383 def open_composer(request):
 384     user = osmutils.get_user(request)
 385     project_id = user.project_id
 386     descriptor_id = request.GET.get('id')
 387     descriptor_type = request.GET.get('type')
 388     result = {}
 389     client = Client()
 390     if descriptor_id:
 391         raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
 392         if 'application/json' not in raw_content_types:
 393             return __response_handler(request, {'type': descriptor_type}, 'composer.html')
 394         try:
 395             if descriptor_type == 'nsd':
 396                 descriptor_result = client.nsd_get(user.get_token(), descriptor_id)
 397             elif descriptor_type == 'vnfd':
 398                 descriptor_result = client.vnfd_get(user.get_token(), descriptor_id)
 399
 400         except Exception as e:
 401             descriptor_result = {'error': True, 'data': str(e)}
 402
 403         if isinstance(descriptor_result, dict) and 'error' in descriptor_result and descriptor_result['error']:
 404             return render(request, 'error.html')
 405
 406         test = OsmParser()
 407         # print nsr_object
 408         if descriptor_type == 'nsd':
 409             result = test.nsd_to_graph(descriptor_result)
 410         elif descriptor_type == 'vnfd':
 411             result = test.vnfd_to_graph(descriptor_result)
 412         return __response_handler(request, result, 'composer.html')
 413
 414     return __response_handler(request, result, 'composer.html')
 415
 416
 417 def get_available_nodes(request):
 418     user = osmutils.get_user(request)
 419     params = request.GET.dict()
 420     client = Client()
 421     result = []
 422     try:
 423         if params['layer'] == 'nsd':
 424             descriptors = client.vnfd_list(user.get_token())
 425     except Exception as e:
 426         log.exception(e)
 427         descriptors = []
 428     if descriptors and descriptors['error'] is False:
 429         for desc in descriptors['data']:
 430             # print desc
 431             result.append({'_id': desc['_id'],'id': desc['id'], 'name': desc['short-name']})
 432
 433     return __response_handler(request, {'descriptors': result})
 434
 435
 436 @login_required
 437 def custom_action(request, descriptor_id=None, descriptor_type=None, action_name=None):
 438     if request.method == 'GET':
 439         return globals()[action_name](request, descriptor_id, descriptor_type)
 440
 441
 442 def __response_handler(request, data_res, url=None, to_redirect=None, *args, **kwargs):
 443     raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
 444     if 'application/json' in raw_content_types or url is None:
 445         return HttpResponse(json.dumps(data_res), content_type="application/json", *args, **kwargs)
 446     elif to_redirect:
 447         return redirect(url, *args, **kwargs)
 448     else:
 449         return render(request, url, data_res)