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 @login_required
  94 def create_package_empty(request, descriptor_type=None):
  95     user = osmutils.get_user(request)
  96     pkg_name = request.POST.get('name', '')
  97     try:
  98         client = Client()
  99         if descriptor_type == 'nsd':
 100             result = client.nsd_create_pkg_base(user.get_token(), pkg_name)
 101         elif descriptor_type == 'vnfd':
 102             result = client.vnfd_create_pkg_base(user.get_token(), pkg_name)
 103         else:
 104             log.debug('Update descriptor: Unknown data type')
 105             result = {'error': True, 'data': 'Update descriptor: Unknown data type'}
 106     except Exception as e:
 107         log.exception(e)
 108         result = {'error': True, 'data': str(e)}
 109
 110     if result['error'] == True:
 111         return __response_handler(request, result['data'], url=None,
 112                                   status=result['data']['status'] if 'status' in result['data'] else 500)
 113     else:
 114         result['data']['type'] = descriptor_type
 115         return __response_handler(request, result, url=None, status=200)
 116
 117
 118 @login_required
 119 def clone_descriptor(request, descriptor_type=None, descriptor_id=None):
 120     user = osmutils.get_user(request)
 121     project_id = user.project_id
 122     try:
 123         client = Client()
 124         if descriptor_type == 'nsd':
 125             result = client.nsd_clone(user.get_token(), descriptor_id)
 126         elif descriptor_type == 'vnfd':
 127             result = client.vnfd_clone(user.get_token(), descriptor_id)
 128         else:
 129             log.debug('Update descriptor: Unknown data type')
 130             result = {'error': True, 'data': 'Update descriptor: Unknown data type'}
 131     except Exception as e:
 132         log.exception(e)
 133         result = {'error': True, 'data': str(e)}
 134     if result['error'] == True:
 135         return __response_handler(request, result['data'], url=None,
 136                                   status=result['data']['status'] if 'status' in result['data'] else 500)
 137     else:
 138         return __response_handler(request, {}, url=None, status=200)
 139
 140 @login_required
 141 def addElement(request, descriptor_type=None, descriptor_id=None, element_type=None):
 142     user = osmutils.get_user(request)
 143     project_id = user.project_id
 144     client = Client()
 145     if descriptor_type == 'nsd':
 146         descriptor_result = client.nsd_get(user.get_token(), descriptor_id)
 147         element_id = request.POST.get('id', '')
 148         util = OsmUtil()
 149         descriptor_updated = util.add_base_node('nsd', descriptor_result, element_type, element_id, request.POST.dict())
 150         result = client.nsd_update(user.get_token(), descriptor_id, descriptor_updated)
 151         if result['error'] == True:
 152             return __response_handler(request, result['data'], url=None,
 153                                       status=result['data']['status'] if 'status' in result['data'] else 500)
 154         else:
 155             parser = OsmParser()
 156             # print nsr_object
 157             if descriptor_type == 'nsd':
 158                 result_graph = parser.nsd_to_graph(descriptor_updated)
 159
 160         return __response_handler(request, result_graph, url=None, status=200)
 161
 162     elif descriptor_type == 'vnfd':
 163         descriptor_result = client.vnfd_get(user.get_token(), descriptor_id)
 164         element_id = request.POST.get('id', '')
 165         util = OsmUtil()
 166         descriptor_updated = util.add_base_node('vnfd', descriptor_result, element_type, element_id, request.POST.dict())
 167         result = client.vnfd_update(user.get_token(), descriptor_id, descriptor_updated)
 168         if result['error'] == True:
 169             return __response_handler(request, result['data'], url=None,
 170                                       status=result['data']['status'] if 'status' in result['data'] else 500)
 171         else:
 172             parser = OsmParser()
 173             # print nsr_object
 174             if descriptor_type == 'vnfd':
 175                 result_graph = parser.vnfd_to_graph(descriptor_updated)
 176
 177         return __response_handler(request, result_graph, url=None, status=200)
 178
 179
 180 @login_required
 181 def removeElement(request, descriptor_type=None, descriptor_id=None, element_type=None):
 182     user = osmutils.get_user(request)
 183     project_id = user.project_id
 184     client = Client()
 185     if descriptor_type == 'nsd':
 186         descriptor_result = client.nsd_get(user.get_token(), descriptor_id)
 187         element_id = request.POST.get('id', '')
 188         util = OsmUtil()
 189         descriptor_updated = util.remove_node('nsd', descriptor_result, element_type, element_id, request.POST.dict())
 190         result = client.nsd_update(user.get_token(), descriptor_id, descriptor_updated)
 191         if result['error'] == True:
 192             return __response_handler(request, result['data'], url=None,
 193                                       status=result['data']['status'] if 'status' in result['data'] else 500)
 194         else:
 195             parser = OsmParser()
 196             # print nsr_object
 197             if descriptor_type == 'nsd':
 198                 result_graph = parser.nsd_to_graph(descriptor_updated)
 199
 200         return __response_handler(request, result_graph, url=None, status=200)
 201
 202     elif descriptor_type == 'vnfd':
 203         descriptor_result = client.vnfd_get(user.get_token(), descriptor_id)
 204         element_id = request.POST.get('id', '')
 205         util = OsmUtil()
 206         descriptor_updated = util.remove_node('vnfd', descriptor_result, element_type, element_id, request.POST.dict())
 207         result = client.vnfd_update(user.get_token(), descriptor_id, descriptor_updated)
 208         if result['error'] == True:
 209             return __response_handler(request, result['data'], url=None,
 210                                       status=result['data']['status'] if 'status' in result['data'] else 500)
 211         else:
 212             parser = OsmParser()
 213             # print nsr_object
 214             if descriptor_type == 'vnfd':
 215                 result_graph = parser.vnfd_to_graph(descriptor_updated)
 216
 217             return __response_handler(request, result_graph, url=None, status=200)
 218
 219
 220 @login_required
 221 def updateElement(request, descriptor_type=None, descriptor_id=None, element_type=None):
 222     user = osmutils.get_user(request)
 223     project_id = user.project_id
 224     client = Client()
 225     if descriptor_type == 'nsd':
 226         descriptor_result = client.nsd_get(user.get_token(), descriptor_id)
 227         util = OsmUtil()
 228         payload = request.POST.dict()
 229         if element_type == 'graph_params':
 230             descriptor_updated = util.update_graph_params('nsd', descriptor_result, json.loads(payload['update']))
 231         else:
 232             descriptor_updated = util.update_node('nsd', descriptor_result, element_type, json.loads(payload['old']), json.loads(payload['update']))
 233         result = client.nsd_update(user.get_token(), descriptor_id, descriptor_updated)
 234         if result['error'] == True:
 235             return __response_handler(request, result['data'], url=None,
 236                                       status=result['data']['status'] if 'status' in result['data'] else 500)
 237         else:
 238             parser = OsmParser()
 239             # print nsr_object
 240             if descriptor_type == 'nsd':
 241                 result_graph = parser.nsd_to_graph(descriptor_updated)
 242     if descriptor_type == 'vnfd':
 243         descriptor_result = client.vnfd_get(user.get_token(), descriptor_id)
 244         util = OsmUtil()
 245         payload = request.POST.dict()
 246         if element_type == 'graph_params':
 247             descriptor_updated = util.update_graph_params('vnfd', descriptor_result, json.loads(payload['update']))
 248         else:
 249             descriptor_updated = util.update_node('vnfd', descriptor_result, element_type, json.loads(payload['old']), json.loads(payload['update']))
 250         result = client.vnfd_update(user.get_token(), descriptor_id, descriptor_updated)
 251         if result['error'] == True:
 252             return __response_handler(request, result['data'], url=None,
 253                                       status=result['data']['status'] if 'status' in result['data'] else 500)
 254         else:
 255             parser = OsmParser()
 256             if descriptor_type == 'vnfd':
 257                 result_graph = parser.vnfd_to_graph(descriptor_updated)
 258
 259         return __response_handler(request, result_graph, url=None, status=200)
 260
 261 @login_required
 262 def new_descriptor(request, descriptor_type=None):
 263     user = osmutils.get_user(request)
 264     project_id = user.project_id
 265     page = 'descriptor_new.html'
 266     if request.method == 'GET':
 267         request_id = request.GET.get('id', '')
 268
 269         return __response_handler(request,  {
 270             'project_id': project_id,
 271             'descriptor_type': descriptor_type,
 272             'descriptor_id': request_id,
 273         }, page)
 274     elif request.method == 'POST':
 275         data_type = request.POST.get('type')
 276         if data_type == "file":
 277             file_uploaded = request.FILES['file']
 278
 279             try:
 280                 client = Client()
 281                 if descriptor_type == 'nsd':
 282                     result = client.nsd_onboard(user.get_token(), file_uploaded)
 283                 elif descriptor_type == 'vnfd':
 284                     result = client.vnfd_onboard(user.get_token(), file_uploaded)
 285                 else:
 286                     log.debug('Create descriptor: Unknown data type')
 287                     result = {'error': True, 'data': 'Create descriptor: Unknown data type'}
 288
 289             except Exception as e:
 290                 log.exception(e)
 291                 result = {'error': True, 'data': str(e)}
 292         else:
 293             result = {'error': True, 'data': 'Create descriptor: Unknown data type'}
 294
 295         if result['error']:
 296             return __response_handler(request, result['data'], url=None, status=result['data']['status'] if 'status' in result['data'] else 500)
 297         else:
 298             return __response_handler(request, {}, url=None, status=200)
 299
 300
 301 @login_required
 302 def edit_descriptor(request, descriptor_id=None, descriptor_type=None):
 303     user = osmutils.get_user(request)
 304     project_id = user.project_id
 305     if request.method == 'POST':
 306         new_data = request.POST.get('text'),
 307         data_type = request.POST.get('type')
 308         #print new_data
 309         try:
 310             client = Client()
 311             if descriptor_type == 'nsd':
 312                 if data_type == 'yaml':
 313                     new_data = yaml.load(request.POST.get('text'))
 314                 elif data_type == 'json':
 315                     new_data = json.loads(request.POST.get('text'))
 316                 result = client.nsd_update(user.get_token(), descriptor_id, new_data)
 317             elif descriptor_type == 'vnfd':
 318                 if data_type == 'yaml':
 319                     new_data = yaml.load(request.POST.get('text'))
 320                 elif data_type == 'json':
 321                     new_data = json.loads(request.POST.get('text'))
 322                 result = client.vnfd_update(user.get_token(), descriptor_id, new_data)
 323
 324             else:
 325                 log.debug('Update descriptor: Unknown data type')
 326                 result = {'error': True, 'data': 'Update descriptor: Unknown data type'}
 327         except Exception as e:
 328             log.exception(e)
 329             result = {'error': True, 'data': str(e)}
 330         if result['error'] == True:
 331             return __response_handler(request, result['data'], url=None, status=result['data']['status'] if 'status' in result['data'] else 500)
 332
 333         else:
 334             return __response_handler(request, {}, url=None, status=200)
 335
 336     elif request.method == 'GET':
 337
 338         page = 'descriptor_view.html'
 339         try:
 340             client = Client()
 341             if descriptor_type == 'nsd':
 342                 result = client.nsd_get(user.get_token(), descriptor_id)
 343             elif descriptor_type == 'vnfd':
 344                 result = client.vnfd_get(user.get_token(), descriptor_id)
 345         except Exception as e:
 346             log.exception(e)
 347             result = {'error': True, 'data': str(e)}
 348
 349         if isinstance(result, dict) and 'error' in result and result['error']:
 350             return render(request, 'error.html')
 351
 352         descriptor_string_json = json.dumps(result, indent=2)
 353         descriptor_string_yaml = Util.json2yaml(result)
 354         # print descriptor
 355         return render(request, page, {
 356             'project_id': project_id,
 357             'descriptor_id': descriptor_id,
 358             'descriptor_type': descriptor_type,
 359             'descriptor_strings': {'descriptor_string_yaml': descriptor_string_yaml,
 360                                    'descriptor_string_json': descriptor_string_json}})
 361
 362
 363 @login_required
 364 def get_package_files_list(request, descriptor_id, descriptor_type):
 365     user = osmutils.get_user(request)
 366     try:
 367         client = Client()
 368         if descriptor_type == 'nsd':
 369             artifacts_res = client.nsd_artifacts(user.get_token(), descriptor_id)
 370         elif descriptor_type == 'vnfd':
 371             artifacts_res = client.vnf_packages_artifacts(user.get_token(), descriptor_id)
 372         else:
 373             return False
 374
 375         files_list = yaml.load(artifacts_res['data'] if artifacts_res and artifacts_res['error'] is False else [])
 376         result = {'files': files_list}
 377     except Exception as e:
 378         log.exception(e)
 379         url = 'error.html'
 380         result = {'error_msg': 'Unknown error.'}
 381     return __response_handler(request, result)
 382
 383
 384 @login_required
 385 def download_pkg(request, descriptor_id, descriptor_type):
 386     user = osmutils.get_user(request)
 387     file_name = "osm_export.tar.gz"
 388     tar_pkg = None
 389     try:
 390         client = Client()
 391         if descriptor_type == 'nsd':
 392             tar_pkg = client.get_nsd_pkg(user.get_token(), descriptor_id)
 393         elif descriptor_type == 'vnfd':
 394             tar_pkg = client.get_vnfd_pkg(user.get_token(), descriptor_id)
 395
 396     except Exception as e:
 397         log.exception(e)
 398
 399     response = HttpResponse(content_type="application/tgz")
 400     response["Content-Disposition"] = "attachment; filename="+ file_name
 401     response.write(tar_pkg.getvalue())
 402     return response
 403
 404 @login_required
 405 def open_composer(request):
 406     user = osmutils.get_user(request)
 407     project_id = user.project_id
 408     descriptor_id = request.GET.get('id')
 409     descriptor_type = request.GET.get('type')
 410     result = {}
 411     client = Client()
 412     if descriptor_id:
 413         raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
 414         if 'application/json' not in raw_content_types:
 415             return __response_handler(request, {'type': descriptor_type}, 'composer.html')
 416         try:
 417             if descriptor_type == 'nsd':
 418                 descriptor_result = client.nsd_get(user.get_token(), descriptor_id)
 419             elif descriptor_type == 'vnfd':
 420                 descriptor_result = client.vnfd_get(user.get_token(), descriptor_id)
 421
 422         except Exception as e:
 423             descriptor_result = {'error': True, 'data': str(e)}
 424
 425         if isinstance(descriptor_result, dict) and 'error' in descriptor_result and descriptor_result['error']:
 426             return render(request, 'error.html')
 427
 428         test = OsmParser()
 429         # print nsr_object
 430         if descriptor_type == 'nsd':
 431             result = test.nsd_to_graph(descriptor_result)
 432         elif descriptor_type == 'vnfd':
 433             result = test.vnfd_to_graph(descriptor_result)
 434         return __response_handler(request, result, 'composer.html')
 435
 436     return __response_handler(request, result, 'composer.html')
 437
 438
 439 def get_available_nodes(request):
 440     user = osmutils.get_user(request)
 441     params = request.GET.dict()
 442     client = Client()
 443     result = []
 444     try:
 445         if params['layer'] == 'nsd':
 446             descriptors = client.vnfd_list(user.get_token())
 447     except Exception as e:
 448         log.exception(e)
 449         descriptors = []
 450     if descriptors and descriptors['error'] is False:
 451         for desc in descriptors['data']:
 452             # print desc
 453             result.append({'_id': desc['_id'],'id': desc['id'], 'name': desc['short-name']})
 454
 455     return __response_handler(request, {'descriptors': result})
 456
 457
 458 @login_required
 459 def custom_action(request, descriptor_id=None, descriptor_type=None, action_name=None):
 460     if request.method == 'GET':
 461         return globals()[action_name](request, descriptor_id, descriptor_type)
 462
 463
 464 def __response_handler(request, data_res, url=None, to_redirect=None, *args, **kwargs):
 465     raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
 466     if 'application/json' in raw_content_types or url is None:
 467         return HttpResponse(json.dumps(data_res), content_type="application/json", *args, **kwargs)
 468     elif to_redirect:
 469         return redirect(url, *args, **kwargs)
 470     else:
 471         return render(request, url, data_res)