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