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 from lib.util import Util
  26 from lib.osm.osmclient.clientv2 import Client
  27 from lib.osm.osm_rdcl_parser import OsmParser
  28 from lib.osm.osm_util import OsmUtil
  29 import authosm.utils as osmutils
  30
  31 logging.basicConfig(level=logging.DEBUG)
  32 log = logging.getLogger('descriptorhandler/view.py')
  33
  34
  35 @login_required
  36 def addElement(request, descriptor_type=None, descriptor_id=None, element_type=None):
  37     user = osmutils.get_user(request)
  38     client = Client()
  39     if descriptor_type == 'nsd':
  40         descriptor_result = client.nsd_get(user.get_token(), descriptor_id)
  41         element_id = request.POST.get('id', '')
  42         util = OsmUtil()
  43         descriptor_updated = util.add_base_node('nsd', descriptor_result, element_type, element_id, request.POST.dict())
  44         result = client.nsd_update(user.get_token(), descriptor_id, descriptor_updated)
  45         if result['error'] == True:
  46             return __response_handler(request, result['data'], url=None,
  47                                       status=result['data']['status'] if 'status' in result['data'] else 500)
  48         else:
  49             parser = OsmParser()
  50             # print nsr_object
  51             if descriptor_type == 'nsd':
  52                 result_graph = parser.nsd_to_graph(descriptor_updated)
  53
  54         return __response_handler(request, result_graph, url=None, status=200)
  55
  56     elif descriptor_type == 'vnfd':
  57         descriptor_result = client.vnfd_get(user.get_token(), descriptor_id)
  58         element_id = request.POST.get('id', '')
  59         util = OsmUtil()
  60         descriptor_updated = util.add_base_node('vnfd', descriptor_result, element_type, element_id, request.POST.dict())
  61         result = client.vnfd_update(user.get_token(), descriptor_id, descriptor_updated)
  62         if result['error'] == True:
  63             return __response_handler(request, result['data'], url=None,
  64                                       status=result['data']['status'] if 'status' in result['data'] else 500)
  65         else:
  66             parser = OsmParser()
  67             # print nsr_object
  68             if descriptor_type == 'vnfd':
  69                 result_graph = parser.vnfd_to_graph(descriptor_updated)
  70
  71         return __response_handler(request, result_graph, url=None, status=200)
  72
  73
  74 @login_required
  75 def removeElement(request, descriptor_type=None, descriptor_id=None, element_type=None):
  76     user = osmutils.get_user(request)
  77     client = Client()
  78     if descriptor_type == 'nsd':
  79         descriptor_result = client.nsd_get(user.get_token(), descriptor_id)
  80         element_id = request.POST.get('id', '')
  81         util = OsmUtil()
  82         descriptor_updated = util.remove_node('nsd', descriptor_result, element_type, element_id, request.POST.dict())
  83         result = client.nsd_update(user.get_token(), descriptor_id, descriptor_updated)
  84         if result['error'] == True:
  85             return __response_handler(request, result['data'], url=None,
  86                                       status=result['data']['status'] if 'status' in result['data'] else 500)
  87         else:
  88             parser = OsmParser()
  89             # print nsr_object
  90             if descriptor_type == 'nsd':
  91                 result_graph = parser.nsd_to_graph(descriptor_updated)
  92
  93         return __response_handler(request, result_graph, url=None, status=200)
  94
  95     elif descriptor_type == 'vnfd':
  96         descriptor_result = client.vnfd_get(user.get_token(), descriptor_id)
  97         element_id = request.POST.get('id', '')
  98         util = OsmUtil()
  99         descriptor_updated = util.remove_node('vnfd', descriptor_result, element_type, element_id, request.POST.dict())
 100         result = client.vnfd_update(user.get_token(), descriptor_id, descriptor_updated)
 101         if result['error'] == True:
 102             return __response_handler(request, result['data'], url=None,
 103                                       status=result['data']['status'] if 'status' in result['data'] else 500)
 104         else:
 105             parser = OsmParser()
 106             # print nsr_object
 107             if descriptor_type == 'vnfd':
 108                 result_graph = parser.vnfd_to_graph(descriptor_updated)
 109
 110             return __response_handler(request, result_graph, url=None, status=200)
 111
 112
 113 @login_required
 114 def updateElement(request, descriptor_type=None, descriptor_id=None, element_type=None):
 115     user = osmutils.get_user(request)
 116     client = Client()
 117     payload = request.POST.dict()
 118     util = OsmUtil()
 119
 120     if descriptor_type == 'nsd':
 121         descriptor_result = client.nsd_get(user.get_token(), descriptor_id)
 122     elif descriptor_type == 'vnfd':
 123         descriptor_result = client.vnfd_get(user.get_token(), descriptor_id)
 124
 125     if element_type == 'graph_params':
 126         descriptor_updated = util.update_graph_params(descriptor_type, descriptor_result, json.loads(payload['update']))
 127     else:
 128         descriptor_updated = util.update_node(descriptor_type, descriptor_result, element_type, json.loads(payload['old']), json.loads(payload['update']))
 129
 130     if descriptor_type == 'nsd':
 131         result = client.nsd_update(user.get_token(), descriptor_id, descriptor_updated)
 132     elif descriptor_type == 'vnfd':
 133         result = client.vnfd_update(user.get_token(), descriptor_id, descriptor_updated)
 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         parser = OsmParser()
 139         if descriptor_type == 'vnfd':
 140             result_graph = parser.vnfd_to_graph(descriptor_updated)
 141         elif descriptor_type == 'nsd':
 142             result_graph = parser.nsd_to_graph(descriptor_updated)
 143         return __response_handler(request, result_graph, url=None, status=200)
 144
 145
 146
 147 @login_required
 148 def edit_descriptor(request, descriptor_id=None, descriptor_type=None):
 149     user = osmutils.get_user(request)
 150     project_id = user.project_id
 151     project_name = user.project_name
 152     if request.method == 'POST':
 153         new_data = request.POST.get('text'),
 154         data_type = request.POST.get('type')
 155         #print new_data
 156         try:
 157             client = Client()
 158             if descriptor_type == 'nsd':
 159                 if data_type == 'yaml':
 160                     new_data = yaml.load(request.POST.get('text'))
 161                 elif data_type == 'json':
 162                     new_data = json.loads(request.POST.get('text'))
 163                 result = client.nsd_update(user.get_token(), descriptor_id, new_data)
 164             elif descriptor_type == 'vnfd':
 165                 if data_type == 'yaml':
 166                     new_data = yaml.load(request.POST.get('text'))
 167                 elif data_type == 'json':
 168                     new_data = json.loads(request.POST.get('text'))
 169                 result = client.vnfd_update(user.get_token(), descriptor_id, new_data)
 170
 171             else:
 172                 log.debug('Update descriptor: Unknown data type')
 173                 result = {'error': True, 'data': 'Update descriptor: Unknown data type'}
 174         except Exception as e:
 175             log.exception(e)
 176             result = {'error': True, 'data': str(e)}
 177         if result['error'] == True:
 178             return __response_handler(request, result['data'], url=None, status=result['data']['status'] if 'status' in result['data'] else 500)
 179         else:
 180             return __response_handler(request, {}, url=None, status=200)
 181
 182     elif request.method == 'GET':
 183
 184         page = 'descriptor_view.html'
 185         try:
 186             client = Client()
 187             if descriptor_type == 'nsd':
 188                 result = client.nsd_get(user.get_token(), descriptor_id)
 189             elif descriptor_type == 'vnfd':
 190                 result = client.vnfd_get(user.get_token(), descriptor_id)
 191         except Exception as e:
 192             log.exception(e)
 193             result = {'error': True, 'data': str(e)}
 194
 195         if isinstance(result, dict) and 'error' in result and result['error']:
 196             return render(request, 'error.html')
 197
 198         descriptor_string_json = json.dumps(result, indent=2)
 199         descriptor_string_yaml = Util.json2yaml(result)
 200         # print descriptor
 201         return render(request, page, {
 202             'project_id': project_id,
 203             'project_name': project_name,
 204             'descriptor_id': descriptor_id,
 205             'descriptor_type': descriptor_type,
 206             'descriptor_strings': {'descriptor_string_yaml': descriptor_string_yaml,
 207                                    'descriptor_string_json': descriptor_string_json}})
 208
 209 @login_required
 210 def open_composer(request):
 211     user = osmutils.get_user(request)
 212     descriptor_id = request.GET.get('id')
 213     descriptor_type = request.GET.get('type')
 214     result = {}
 215     client = Client()
 216     if descriptor_id:
 217         raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
 218         if 'application/json' not in raw_content_types:
 219             return __response_handler(request, {'type': descriptor_type}, 'composer.html')
 220         try:
 221             if descriptor_type == 'nsd':
 222                 descriptor_result = client.nsd_get(user.get_token(), descriptor_id)
 223             elif descriptor_type == 'vnfd':
 224                 descriptor_result = client.vnfd_get(user.get_token(), descriptor_id)
 225
 226         except Exception as e:
 227             descriptor_result = {'error': True, 'data': str(e)}
 228
 229         if isinstance(descriptor_result, dict) and 'error' in descriptor_result and descriptor_result['error']:
 230             return render(request, 'error.html')
 231
 232         test = OsmParser()
 233         # print nsr_object
 234         if descriptor_type == 'nsd':
 235             result = test.nsd_to_graph(descriptor_result)
 236         elif descriptor_type == 'vnfd':
 237             result = test.vnfd_to_graph(descriptor_result)
 238         return __response_handler(request, result, 'composer.html')
 239
 240     return __response_handler(request, result, 'composer.html')
 241
 242 def get_available_nodes(request):
 243     user = osmutils.get_user(request)
 244     params = request.GET.dict()
 245     client = Client()
 246     result = []
 247     try:
 248         if params['layer'] == 'nsd':
 249             descriptors = client.vnfd_list(user.get_token())
 250     except Exception as e:
 251         log.exception(e)
 252         descriptors = []
 253     if descriptors and descriptors['error'] is False:
 254         for desc in descriptors['data']:
 255             # print desc
 256             result.append({'_id': desc['_id'],'id': desc['id'], 'name': desc['short-name']})
 257
 258     return __response_handler(request, {'descriptors': result})
 259
 260 @login_required
 261 def custom_action(request, descriptor_id=None, descriptor_type=None, action_name=None):
 262     if request.method == 'GET':
 263         return globals()[action_name](request, descriptor_id, descriptor_type)
 264
 265 def __response_handler(request, data_res, url=None, to_redirect=None, *args, **kwargs):
 266     raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
 267     if 'application/json' in raw_content_types or url is None:
 268         return HttpResponse(json.dumps(data_res), content_type="application/json", *args, **kwargs)
 269     elif to_redirect:
 270         return redirect(url, *args, **kwargs)
 271     else:
 272         return render(request, url, data_res)