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     if descriptor_type == 'nsd':
 118         descriptor_result = client.nsd_get(user.get_token(), descriptor_id)
 119         util = OsmUtil()
 120         payload = request.POST.dict()
 121         if element_type == 'graph_params':
 122             descriptor_updated = util.update_graph_params('nsd', descriptor_result, json.loads(payload['update']))
 123         else:
 124             descriptor_updated = util.update_node('nsd', descriptor_result, element_type, json.loads(payload['old']), json.loads(payload['update']))
 125         result = client.nsd_update(user.get_token(), descriptor_id, descriptor_updated)
 126         if result['error'] == True:
 127             return __response_handler(request, result['data'], url=None,
 128                                       status=result['data']['status'] if 'status' in result['data'] else 500)
 129         else:
 130             parser = OsmParser()
 131             # print nsr_object
 132             if descriptor_type == 'nsd':
 133                 result_graph = parser.nsd_to_graph(descriptor_updated)
 134     if descriptor_type == 'vnfd':
 135         descriptor_result = client.vnfd_get(user.get_token(), descriptor_id)
 136         util = OsmUtil()
 137         payload = request.POST.dict()
 138         if element_type == 'graph_params':
 139             descriptor_updated = util.update_graph_params('vnfd', descriptor_result, json.loads(payload['update']))
 140         else:
 141             descriptor_updated = util.update_node('vnfd', descriptor_result, element_type, json.loads(payload['old']), json.loads(payload['update']))
 142         result = client.vnfd_update(user.get_token(), descriptor_id, descriptor_updated)
 143         if result['error'] == True:
 144             return __response_handler(request, result['data'], url=None,
 145                                       status=result['data']['status'] if 'status' in result['data'] else 500)
 146         else:
 147             parser = OsmParser()
 148             if descriptor_type == 'vnfd':
 149                 result_graph = parser.vnfd_to_graph(descriptor_updated)
 150
 151         return __response_handler(request, result_graph, url=None, status=200)
 152
 153
 154 @login_required
 155 def edit_descriptor(request, descriptor_id=None, descriptor_type=None):
 156     user = osmutils.get_user(request)
 157     project_id = user.project_id
 158     if request.method == 'POST':
 159         new_data = request.POST.get('text'),
 160         data_type = request.POST.get('type')
 161         #print new_data
 162         try:
 163             client = Client()
 164             if descriptor_type == 'nsd':
 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.nsd_update(user.get_token(), descriptor_id, new_data)
 170             elif descriptor_type == 'vnfd':
 171                 if data_type == 'yaml':
 172                     new_data = yaml.load(request.POST.get('text'))
 173                 elif data_type == 'json':
 174                     new_data = json.loads(request.POST.get('text'))
 175                 result = client.vnfd_update(user.get_token(), descriptor_id, new_data)
 176
 177             else:
 178                 log.debug('Update descriptor: Unknown data type')
 179                 result = {'error': True, 'data': 'Update descriptor: Unknown data type'}
 180         except Exception as e:
 181             log.exception(e)
 182             result = {'error': True, 'data': str(e)}
 183         if result['error'] == True:
 184             return __response_handler(request, result['data'], url=None, status=result['data']['status'] if 'status' in result['data'] else 500)
 185         else:
 186             return __response_handler(request, {}, url=None, status=200)
 187
 188     elif request.method == 'GET':
 189
 190         page = 'descriptor_view.html'
 191         try:
 192             client = Client()
 193             if descriptor_type == 'nsd':
 194                 result = client.nsd_get(user.get_token(), descriptor_id)
 195             elif descriptor_type == 'vnfd':
 196                 result = client.vnfd_get(user.get_token(), descriptor_id)
 197         except Exception as e:
 198             log.exception(e)
 199             result = {'error': True, 'data': str(e)}
 200
 201         if isinstance(result, dict) and 'error' in result and result['error']:
 202             return render(request, 'error.html')
 203
 204         descriptor_string_json = json.dumps(result, indent=2)
 205         descriptor_string_yaml = Util.json2yaml(result)
 206         # print descriptor
 207         return render(request, page, {
 208             'project_id': project_id,
 209             'descriptor_id': descriptor_id,
 210             'descriptor_type': descriptor_type,
 211             'descriptor_strings': {'descriptor_string_yaml': descriptor_string_yaml,
 212                                    'descriptor_string_json': descriptor_string_json}})
 213
 214 @login_required
 215 def open_composer(request):
 216     user = osmutils.get_user(request)
 217     descriptor_id = request.GET.get('id')
 218     descriptor_type = request.GET.get('type')
 219     result = {}
 220     client = Client()
 221     if descriptor_id:
 222         raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
 223         if 'application/json' not in raw_content_types:
 224             return __response_handler(request, {'type': descriptor_type}, 'composer.html')
 225         try:
 226             if descriptor_type == 'nsd':
 227                 descriptor_result = client.nsd_get(user.get_token(), descriptor_id)
 228             elif descriptor_type == 'vnfd':
 229                 descriptor_result = client.vnfd_get(user.get_token(), descriptor_id)
 230
 231         except Exception as e:
 232             descriptor_result = {'error': True, 'data': str(e)}
 233
 234         if isinstance(descriptor_result, dict) and 'error' in descriptor_result and descriptor_result['error']:
 235             return render(request, 'error.html')
 236
 237         test = OsmParser()
 238         # print nsr_object
 239         if descriptor_type == 'nsd':
 240             result = test.nsd_to_graph(descriptor_result)
 241         elif descriptor_type == 'vnfd':
 242             result = test.vnfd_to_graph(descriptor_result)
 243         return __response_handler(request, result, 'composer.html')
 244
 245     return __response_handler(request, result, 'composer.html')
 246
 247 def get_available_nodes(request):
 248     user = osmutils.get_user(request)
 249     params = request.GET.dict()
 250     client = Client()
 251     result = []
 252     try:
 253         if params['layer'] == 'nsd':
 254             descriptors = client.vnfd_list(user.get_token())
 255     except Exception as e:
 256         log.exception(e)
 257         descriptors = []
 258     if descriptors and descriptors['error'] is False:
 259         for desc in descriptors['data']:
 260             # print desc
 261             result.append({'_id': desc['_id'],'id': desc['id'], 'name': desc['short-name']})
 262
 263     return __response_handler(request, {'descriptors': result})
 264
 265 @login_required
 266 def custom_action(request, descriptor_id=None, descriptor_type=None, action_name=None):
 267     if request.method == 'GET':
 268         return globals()[action_name](request, descriptor_id, descriptor_type)
 269
 270 def __response_handler(request, data_res, url=None, to_redirect=None, *args, **kwargs):
 271     raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
 272     if 'application/json' in raw_content_types or url is None:
 273         return HttpResponse(json.dumps(data_res), content_type="application/json", *args, **kwargs)
 274     elif to_redirect:
 275         return redirect(url, *args, **kwargs)
 276     else:
 277         return render(request, url, data_res)