instancehandler/views.py

   1 #
   2 #   Copyright 2018 CNIT - Consorzio Nazionale Interuniversitario per le Telecomunicazioni
   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 from django.shortcuts import render, redirect
  18 from django.http import HttpResponse, JsonResponse
  19 import yaml
  20 import json
  21 import logging
  22 from lib.osm.osmclient.clientv2 import Client
  23 from lib.osm.osm_rdcl_parser import OsmParser
  24 import authosm.utils as osmutils
  25 from sf_t3d.decorators import login_required
  26
  27 logging.basicConfig(level=logging.DEBUG)
  28 log = logging.getLogger('instancehandler/view.py')
  29
  30
  31 @login_required
  32 def list(request, type=None):
  33     user = osmutils.get_user(request)
  34     project_id = user.project_id
  35     client = Client()
  36     result = {'type': type, 'project_id': project_id}
  37     if "OSM_ERROR" in request.session:
  38         result['alert_error'] = request.session["OSM_ERROR"]
  39         del request.session["OSM_ERROR"]
  40     raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
  41     if 'application/json' not in raw_content_types:
  42         return __response_handler(request, result, 'instance_list.html')
  43     instance_list = None
  44     if type == 'ns':
  45         instance_list = client.ns_list(user.get_token())
  46     elif type == 'vnf':
  47         instance_list = client.vnf_list(user.get_token())
  48     elif type == 'pdu':
  49         instance_list = client.pdu_list(user.get_token())
  50     elif type == 'nsi':
  51         instance_list = client.nsi_list(user.get_token())
  52
  53     result['instances'] = instance_list['data'] if instance_list and instance_list['error'] is False else []
  54
  55     return __response_handler(request, result, 'instance_list.html')
  56
  57 @login_required
  58 def create(request, type=None):
  59     result = {}
  60     config_vim_account_id = {}
  61     user = osmutils.get_user(request)
  62     client = Client()
  63
  64     if type == 'ns':
  65         try:
  66
  67             ns_data = {
  68                 "nsName": request.POST.get('nsName', 'WithoutName'),
  69                 "nsDescription": request.POST.get('nsDescription', ''),
  70                 "nsdId": request.POST.get('nsdId', ''),
  71                 "vimAccountId": request.POST.get('vimAccountId', ''),
  72             }
  73             if 'ssh_key' in request.POST and request.POST.get('ssh_key') != '':
  74                 ns_data["ssh_keys"] = [request.POST.get('ssh_key')]
  75
  76             if 'config' in request.POST:
  77                 ns_config = yaml.load(request.POST.get('config'))
  78                 if isinstance(ns_config, dict):
  79                     if "vim-network-name" in ns_config:
  80                         ns_config["vld"] = ns_config.pop("vim-network-name")
  81                     if "vld" in ns_config:
  82                         print ns_config
  83                         for vld in ns_config["vld"]:
  84                             if vld.get("vim-network-name"):
  85                                 if isinstance(vld["vim-network-name"], dict):
  86                                     vim_network_name_dict = {}
  87                                     for vim_account, vim_net in vld["vim-network-name"].items():
  88                                         vim_network_name_dict[ns_data["vimAccountId"]] = vim_net
  89                                     vld["vim-network-name"] = vim_network_name_dict
  90                         ns_data["vld"] = ns_config["vld"]
  91                     if "vnf" in ns_config:
  92                         for vnf in ns_config["vnf"]:
  93                             if vnf.get("vim_account"):
  94                                 vnf["vimAccountId"] = ns_data["vimAccountId"]
  95
  96                         ns_data["vnf"] = ns_config["vnf"]
  97         except Exception as e:
  98             request.session["OSM_ERROR"] = "Error creating the NS; Invalid parameters provided."
  99             return __response_handler(request, {}, 'instances:list', to_redirect=True, type='ns', )
 100         result = client.ns_create(user.get_token(), ns_data)
 101         return __response_handler(request, result, 'instances:list', to_redirect=True, type='ns')
 102
 103     elif type == 'nsi':
 104         try:
 105             nsi_data = {
 106                 "nsiName": request.POST.get('nsiName', 'WithoutName'),
 107                 "nsiDescription": request.POST.get('nsiDescription', ''),
 108                 "nstId": request.POST.get('nstId', ''),
 109                 "vimAccountId": request.POST.get('vimAccountId', ''),
 110             }
 111
 112             if 'ssh_key' in request.POST and request.POST.get('ssh_key') != '':
 113                 nsi_data["ssh_keys"] = [request.POST.get('ssh_key')]
 114         except Exception as e:
 115             request.session["OSM_ERROR"] = "Error creating the NSI; Invalid parameters provided."
 116             return __response_handler(request, {}, 'instances:list', to_redirect=True, type=type)
 117         result = client.nsi_create(user.get_token(), nsi_data)
 118         return __response_handler(request, result, 'instances:list', to_redirect=True, type=type)
 119
 120     elif type == 'pdu':
 121         interface_param_name = request.POST.getlist('interfaces_name')
 122         interface_param_ip = request.POST.getlist('interfaces_ip')
 123         interface_param_mgmt = request.POST.getlist('interfaces_mgmt')
 124         interface_param_netname = request.POST.getlist('interfaces_vimnetname')
 125
 126         pdu_payload = {
 127             "name": request.POST.get('name'),
 128             "type": request.POST.get('pdu_type'),
 129             "vim_accounts": request.POST.getlist('pdu_vim_accounts'),
 130             "description": request.POST.get('description'),
 131             "interfaces": []
 132         }
 133         for i in (0,len(interface_param_name)-1):
 134             pdu_payload['interfaces'].append({
 135                 'name': interface_param_name[i],
 136                 'mgmt': True if interface_param_mgmt[i] == 'true' else False,
 137                 'ip-address': interface_param_ip[i],
 138                 'vim-network-name': interface_param_netname[i]
 139             })
 140         result = client.pdu_create(user.get_token(), pdu_payload)
 141         if result['error']:
 142             return __response_handler(request, result['data'], url=None,
 143                                   status=result['data']['status'] if 'status' in result['data'] else 500)
 144         else:
 145             return __response_handler(request, {}, url=None, status=200)
 146
 147 @login_required
 148 def ns_operations(request, instance_id=None, type=None):
 149     user = osmutils.get_user(request)
 150     project_id = user.project_id
 151
 152     result = {'type': type, 'project_id': project_id, 'instance_id': instance_id}
 153     raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
 154     if 'application/json' not in raw_content_types:
 155         return __response_handler(request, result, 'instance_operations_list.html')
 156     client = Client()
 157     if type == 'ns':
 158         op_list = client.ns_op_list(user.get_token(), instance_id)
 159     elif type == 'nsi':
 160         op_list = client.nsi_op_list(user.get_token(), instance_id)
 161     result['operations'] = op_list['data'] if op_list and op_list['error'] is False else []
 162
 163     return __response_handler(request, result, 'instance_operations_list.html')
 164
 165 @login_required
 166 def ns_operation(request, op_id, instance_id=None, type=None):
 167     user = osmutils.get_user(request)
 168     client = Client()
 169     result = client.ns_op(user.get_token(), op_id)
 170     return __response_handler(request, result['data'])
 171
 172
 173 @login_required
 174 def action(request, instance_id=None, type=None):
 175     user = osmutils.get_user(request)
 176     client = Client()
 177     # result = client.ns_action(instance_id, action_payload)
 178     primitive_param_keys = request.POST.getlist('primitive_params_name')
 179     primitive_param_value = request.POST.getlist('primitive_params_value')
 180     action_payload = {
 181         "vnf_member_index": request.POST.get('vnf_member_index'),
 182         "primitive": request.POST.get('primitive'),
 183         "primitive_params": {k: v for k, v in zip(primitive_param_keys, primitive_param_value) if len(k) > 0}
 184     }
 185
 186     result = client.ns_action(user.get_token(), instance_id, action_payload)
 187     print result
 188     if result['error']:
 189         return __response_handler(request, result['data'], url=None,
 190                                   status=result['data']['status'] if 'status' in result['data'] else 500)
 191     else:
 192         return __response_handler(request, {}, url=None, status=200)
 193
 194
 195 @login_required
 196 def delete(request, instance_id=None, type=None):
 197     force = bool(request.GET.get('force', False))
 198     result = {}
 199     user = osmutils.get_user(request)
 200     client = Client()
 201     if type == 'ns':
 202         result = client.ns_delete(user.get_token(), instance_id, force)
 203     elif type == 'pdu':
 204         result = client.pdu_delete(user.get_token(), instance_id)
 205     elif type == 'nsi':
 206         result = client.nsi_delete(user.get_token(), instance_id, force)
 207
 208     if result['error']:
 209         return __response_handler(request, result['data'], url=None,
 210                                   status=result['data']['status'] if 'status' in result['data'] else 500)
 211     else:
 212         return __response_handler(request, {}, url=None, status=200)
 213
 214 @login_required
 215 def show_topology(request, instance_id=None, type=None):
 216     user = osmutils.get_user(request)
 217     project_id = user.project_id
 218     raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
 219     if 'application/json' in raw_content_types:
 220         client = Client()
 221         nsr_object = {'nsr': {}, 'vnfr': {}, 'vnfd': {}}
 222         if type == 'ns':
 223
 224             nsr_resp = client.ns_get(user.get_token(), instance_id)
 225             nsr_object['nsr'] = nsr_resp['data']
 226             if 'constituent-vnfr-ref' in nsr_object['nsr'] :
 227                 for vnfr_id in nsr_object['nsr']['constituent-vnfr-ref']:
 228                     vnfr_resp = client.vnf_get(user.get_token(), vnfr_id)
 229                     vnfr = vnfr_resp['data']
 230                     nsr_object['vnfr'][vnfr['id']] = vnfr
 231                     if vnfr['vnfd-id'] not in nsr_object['vnfd']:
 232                         vnfd_resp = client.vnfd_get(user.get_token(), vnfr['vnfd-id'])
 233                         nsr_object['vnfd'][vnfr['vnfd-id']] = vnfd_resp['vnfd:vnfd-catalog']['vnfd'][0]
 234
 235         test = OsmParser()
 236
 237         result = test.nsr_to_graph(nsr_object)
 238         return __response_handler(request, result)
 239     else:
 240         result = {'type': type, 'project_id': project_id, 'instance_id': instance_id}
 241         return __response_handler(request, result, 'instance_topology_view.html')
 242
 243
 244 @login_required
 245 def show(request, instance_id=None, type=None):
 246     # result = {}
 247     user = osmutils.get_user(request)
 248     project_id = user.project_id
 249     client = Client()
 250     if type == 'ns':
 251         result = client.ns_get(user.get_token(), instance_id)
 252     elif type == 'vnf':
 253         result = client.vnf_get(user.get_token(), instance_id)
 254     elif type == 'pdu':
 255         result = client.pdu_get(user.get_token(), instance_id)
 256     elif type == 'nsi':
 257         result = client.nsi_get(user.get_token(), instance_id)
 258     print result
 259     return __response_handler(request, result)
 260
 261
 262 @login_required
 263 def export_metric(request, instance_id=None, type=None):
 264     metric_data = request.POST.dict()
 265     user = osmutils.get_user(request)
 266     project_id = user.project_id
 267     client = Client()
 268     keys = ["collection_period",
 269             "vnf_member_index",
 270             "metric_name",
 271             "correlation_id",
 272             "vdu_name",
 273             "collection_unit"]
 274     metric_data = dict(filter(lambda i: i[0] in keys and len(i[1]) > 0, metric_data.items()))
 275
 276     result = client.ns_metric_export(user.get_token(), instance_id, metric_data)
 277
 278     if result['error']:
 279         print result
 280         return __response_handler(request, result['data'], url=None,
 281                                   status=result['data']['status'] if 'status' in result['data'] else 500)
 282     else:
 283         return __response_handler(request, {}, url=None, status=200)
 284
 285
 286 @login_required
 287 def create_alarm(request, instance_id=None, type=None):
 288     metric_data = request.POST.dict()
 289     print metric_data
 290     user = osmutils.get_user(request)
 291     project_id = user.project_id
 292     client = Client()
 293
 294     keys = ["threshold_value",
 295             "vnf_member_index",
 296             "metric_name",
 297             "vdu_name",
 298             "alarm_name",
 299             "correlation_id",
 300             "statistic",
 301             "operation",
 302             "severity"]
 303     metric_data = dict(filter(lambda i: i[0] in keys and len(i[1]) > 0, metric_data.items()))
 304
 305     result = client.ns_alarm_create(user.get_token(), instance_id, metric_data)
 306     if result['error']:
 307         print result
 308         return __response_handler(request, result['data'], url=None,
 309                                   status=result['data']['status'] if 'status' in result['data'] else 500)
 310     else:
 311         return __response_handler(request, {}, url=None, status=200)
 312
 313
 314 def __response_handler(request, data_res, url=None, to_redirect=None, *args, **kwargs):
 315     raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
 316     if not to_redirect and ('application/json' in raw_content_types or url is None):
 317         return HttpResponse(json.dumps(data_res), content_type="application/json", *args, **kwargs)
 318     elif to_redirect:
 319         return redirect(url, *args, **kwargs)
 320     else:
 321         return render(request, url, data_res)