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.contrib.auth.decorators import login_required
  19 from django.http import HttpResponse, JsonResponse
  20 import yaml
  21 import json
  22 import logging
  23 from lib.osm.osmclient.clientv2 import Client
  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
  34     user = osmutils.get_user(request)
  35     project_id = user.project_id
  36     client = Client()
  37     result = {'type': type, 'project_id': project_id}
  38     if "OSM_ERROR" in request.session:
  39         result['alert_error'] = request.session["OSM_ERROR"]
  40         del request.session["OSM_ERROR"]
  41     raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
  42     if 'application/json' not in raw_content_types:
  43         return __response_handler(request, result, 'instance_list.html')
  44     instance_list = None
  45     if type == 'ns':
  46         instance_list = client.ns_list(user.get_token())
  47     elif type == 'vnf':
  48         instance_list = client.vnf_list(user.get_token())
  49
  50     result['instances'] = instance_list['data'] if instance_list and instance_list['error'] is False else []
  51
  52     return __response_handler(request, result, 'instance_list.html')
  53
  54
  55 @login_required
  56 def create(request):
  57     result = {}
  58     try:
  59
  60         ns_data = {
  61             "nsName": request.POST.get('nsName', 'WithoutName'),
  62             "nsDescription": request.POST.get('nsDescription', ''),
  63             "nsdId": request.POST.get('nsdId', ''),
  64             "vimAccountId": request.POST.get('vimAccountId', ''),
  65         }
  66         if 'ssh_key' in request.POST and request.POST.get('ssh_key') != '':
  67             ns_data["ssh-authorized-key"] = [request.POST.get('ssh_key')]
  68
  69         if 'config' in request.POST:
  70             ns_config = yaml.load(request.POST.get('config'))
  71             if isinstance(ns_config, dict):
  72                 if "vim-network-name" in ns_config:
  73                     ns_config["vld"] = ns_config.pop("vim-network-name")
  74                 if "vld" in ns_config:
  75                     print ns_config
  76                     for vld in ns_config["vld"]:
  77                         if vld.get("vim-network-name"):
  78                             if isinstance(vld["vim-network-name"], dict):
  79                                 vim_network_name_dict = {}
  80                                 for vim_account, vim_net in vld["vim-network-name"].items():
  81                                     vim_network_name_dict[ns_data["vimAccountId"]] = vim_net
  82                                 vld["vim-network-name"] = vim_network_name_dict
  83                     ns_data["vld"] = ns_config["vld"]
  84                 if "vnf" in ns_config:
  85                     for vnf in ns_config["vnf"]:
  86                         if vnf.get("vim_account"):
  87                             vnf["vimAccountId"] = ns_data["vimAccountId"]
  88
  89                     ns_data["vnf"] = ns_config["vnf"]
  90     except Exception as e:
  91         request.session["OSM_ERROR"] = "Error creating the NS; Invalid parameters provided."
  92         return __response_handler(request, {}, 'instances:list', to_redirect=True, type='ns', )
  93
  94     print ns_data
  95     user = osmutils.get_user(request)
  96     client = Client()
  97     result = client.ns_create(user.get_token(), ns_data)
  98     return __response_handler(request, result, 'instances:list', to_redirect=True, type='ns',)
  99
 100
 101 @login_required
 102 def ns_operations(request, instance_id=None, type=None):
 103     user = osmutils.get_user(request)
 104     project_id = user.project_id
 105
 106     result = {'type': 'ns', 'project_id': project_id, 'instance_id': instance_id}
 107     raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
 108     if 'application/json' not in raw_content_types:
 109         return __response_handler(request, result, 'instance_operations_list.html')
 110     client = Client()
 111     op_list = client.ns_op_list(user.get_token(), instance_id)
 112     result['operations'] = op_list['data'] if op_list and op_list['error'] is False else []
 113
 114     return __response_handler(request, result, 'instance_operations_list.html')
 115
 116 @login_required
 117 def ns_operation(request, op_id, instance_id=None, type=None):
 118     user = osmutils.get_user(request)
 119     client = Client()
 120     result = client.ns_op(user.get_token(), op_id)
 121     return __response_handler(request, result['data'])
 122
 123
 124 @login_required
 125 def action(request, instance_id=None, type=None):
 126     user = osmutils.get_user(request)
 127     client = Client()
 128     # result = client.ns_action(instance_id, action_payload)
 129     primitive_param_keys = request.POST.getlist('primitive_params_name')
 130     primitive_param_value = request.POST.getlist('primitive_params_value')
 131     action_payload = {
 132         "vnf_member_index": request.POST.get('vnf_member_index'),
 133         "primitive": request.POST.get('primitive'),
 134         "primitive_params": {k: v for k, v in zip(primitive_param_keys, primitive_param_value) if len(k) > 0}
 135     }
 136
 137     result = client.ns_action(user.get_token(), instance_id, action_payload)
 138     print result
 139     if result['error']:
 140         return __response_handler(request, result['data'], url=None,
 141                                   status=result['data']['status'] if 'status' in result['data'] else 500)
 142
 143     else:
 144         return __response_handler(request, {}, url=None, status=200)
 145
 146
 147 @login_required
 148 def delete(request, instance_id=None, type=None):
 149     force = bool(request.GET.get('force', False))
 150     result = {}
 151     user = osmutils.get_user(request)
 152     client = Client()
 153     result = client.ns_delete(user.get_token(), instance_id, force)
 154     print result
 155     return __response_handler(request, result, 'instances:list', to_redirect=True, type='ns')
 156
 157
 158 def show_topology(request, instance_id=None, type=None):
 159     user = osmutils.get_user(request)
 160     project_id = user.project_id
 161     raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
 162     if 'application/json' in raw_content_types:
 163         result = {'vertices': [
 164             {"info": {"type": "vnf", "property": {"custom_label": ""},
 165                       "group": []}, "id": "ping"},
 166             {"info": {"type": "vnf", "property": {"custom_label": ""},
 167                       "group": []}, "id": "pong"},
 168             {"info": {"type": "vdu", "property": {"custom_label": ""},
 169                       "group": ['pong']}, "id": "pong/ubuntu"},
 170             {"info": {"type": "vdu", "property": {"custom_label": ""},
 171                       "group": ['ping']}, "id": "ping/ubuntu"},
 172             {"info": {"type": "cp", "property": {"custom_label": ""},
 173                       "group": ['ping']}, "id": "ping/cp0"},
 174             {"info": {"type": "cp", "property": {"custom_label": ""},
 175                       "group": ['ping']}, "id": "ping/cp1"},
 176             {"info": {"type": "cp", "property": {"custom_label": ""},
 177                       "group": ['pong']}, "id": "pong/cp0"},
 178             {"info": {"type": "cp", "property": {"custom_label": ""},
 179                       "group": ['pong']}, "id": "pong/cp1"},
 180             {"info": {"type": "ns_vl", "property": {"custom_label": ""},
 181                       "group": []}, "id": "mgmt_vl"},
 182         ],
 183             'edges': [
 184                 # {"source": "ping", "group": [], "target": "ping/cp0", "view": "Data"},
 185                 {"source": "pong/ubuntu", "group": ['pong'], "target": "pong/cp0", "view": "vnf"},
 186                 {"source": "ping/ubuntu", "group": ['ping'], "target": "ping/cp0", "view": "vnf"},
 187                 {"source": "pong/ubuntu", "group": ['pong'], "target": "pong/cp1", "view": "vnf"},
 188                 {"source": "ping/ubuntu", "group": ['ping'], "target": "ping/cp1", "view": "vnf"},
 189                 {"source": "pong", "group": [], "target": "mgmt_vl", "view": "ns"},
 190                 {"source": "ping", "group": [], "target": "mgmt_vl", "view": "ns"},
 191             ], 'graph_parameters': [],
 192             'model': {
 193                 "layer": {
 194
 195                     "ns": {
 196                         "nodes": {
 197                             "vnf": {
 198                                 "addable": {
 199                                     "callback": "addNode"
 200                                 },
 201                                 "removable": {
 202                                     "callback": "removeNode"
 203                                 },
 204                                 "expands": "vnf"
 205                             },
 206                             "ns_vl": {
 207                                 "addable": {
 208                                     "callback": "addNode"
 209                                 },
 210                                 "removable": {
 211                                     "callback": "removeNode"
 212                                 }
 213                             },
 214
 215                         },
 216                         "allowed_edges": {
 217                             "ns_vl": {
 218                                 "destination": {
 219                                     "vnf": {
 220                                         "callback": "addLink",
 221                                         "direct_edge": False,
 222                                         "removable": {
 223                                             "callback": "removeLink"
 224                                         }
 225                                     }
 226                                 }
 227                             },
 228                             "vnf": {
 229                                 "destination": {
 230                                     "ns_vl": {
 231                                         "callback": "addLink",
 232                                         "direct_edge": False,
 233                                         "removable": {
 234                                             "callback": "removeLink"
 235                                         }
 236                                     },
 237
 238                                 }
 239                             }
 240
 241                         }
 242                     },
 243                     "vnf": {
 244                         "nodes": {
 245                             "vdu": {
 246                                 "addable": {
 247                                     "callback": "addNode"
 248                                 },
 249                                 "removable": {
 250                                     "callback": "removeNode"
 251                                 }
 252                             },
 253                             "cp": {
 254                                 "addable": {
 255                                     "callback": "addNode"
 256                                 },
 257                                 "removable": {
 258                                     "callback": "removeNode"
 259                                 }
 260                             },
 261
 262                         },
 263                         "allowed_edges": {
 264                             "vdu": {
 265                                 "destination": {
 266                                     "cp": {
 267                                         "callback": "addLink",
 268                                         "direct_edge": False,
 269                                         "removable": {
 270                                             "callback": "removeLink"
 271                                         }
 272                                     }
 273                                 }
 274                             },
 275                             "cp": {
 276                                 "destination": {
 277                                     "vdu": {
 278                                         "callback": "addLink",
 279                                         "direct_edge": False,
 280                                         "removable": {
 281                                             "callback": "removeLink"
 282                                         }
 283                                     }
 284                                 }
 285                             }
 286                         }
 287                     },
 288                     "name": "OSM",
 289                     "version": 1,
 290                     "nodes": {
 291                         "vnf": {
 292                             "label": "vnf"
 293                         },
 294                         "ns_vl": {
 295                             "label": "vl"
 296                         },
 297                         "cp": {
 298                             "label": "cp"
 299                         },
 300                         "vdu": {
 301                             "label": "vdu"
 302                         }
 303                     },
 304                     "description": "osm"
 305                 }
 306             }}
 307         return __response_handler(request, result)
 308     else:
 309         result = {'type': type, 'project_id': project_id, 'instance_id': instance_id}
 310         return __response_handler(request, result, 'instance_topology_view.html')
 311
 312
 313 @login_required
 314 def show(request, instance_id=None, type=None):
 315     # result = {}
 316     user = osmutils.get_user(request)
 317     project_id = user.project_id
 318     client = Client()
 319     if type == 'ns':
 320         result = client.ns_get(user.get_token(), instance_id)
 321     elif type == 'vnf':
 322         result = client.vnf_get(user.get_token(), instance_id)
 323     print result
 324     return __response_handler(request, result)
 325
 326
 327 @login_required
 328 def export_metric(request, instance_id=None, type=None):
 329     metric_data = request.POST.dict()
 330     user = osmutils.get_user(request)
 331     project_id = user.project_id
 332     client = Client()
 333     keys = ["collection_period",
 334             "vnf_member_index",
 335             "metric_name",
 336             "correlation_id",
 337             "vdu_name",
 338             "collection_unit"]
 339     metric_data = dict(filter(lambda i: i[0] in keys and len(i[1]) > 0, metric_data.items()))
 340
 341     result = client.ns_metric_export(user.get_token(), instance_id, metric_data)
 342
 343     if result['error']:
 344         print result
 345         return __response_handler(request, result['data'], url=None,
 346                                   status=result['data']['status'] if 'status' in result['data'] else 500)
 347     else:
 348         return __response_handler(request, {}, url=None, status=200)
 349
 350
 351 @login_required
 352 def create_alarm(request, instance_id=None, type=None):
 353     metric_data = request.POST.dict()
 354     print metric_data
 355     user = osmutils.get_user(request)
 356     project_id = user.project_id
 357     client = Client()
 358
 359     keys = ["threshold_value",
 360             "vnf_member_index",
 361             "metric_name",
 362             "vdu_name",
 363             "alarm_name",
 364             "correlation_id",
 365             "statistic",
 366             "operation",
 367             "severity"]
 368     metric_data = dict(filter(lambda i: i[0] in keys and len(i[1]) > 0, metric_data.items()))
 369
 370     result = client.ns_alarm_create(user.get_token(), instance_id, metric_data)
 371     if result['error']:
 372         print result
 373         return __response_handler(request, result['data'], url=None,
 374                                   status=result['data']['status'] if 'status' in result['data'] else 500)
 375     else:
 376         return __response_handler(request, {}, url=None, status=200)
 377
 378
 379 def __response_handler(request, data_res, url=None, to_redirect=None, *args, **kwargs):
 380     raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
 381     if 'application/json' in raw_content_types or url is None:
 382         return HttpResponse(json.dumps(data_res), content_type="application/json")
 383     elif to_redirect:
 384         return redirect(url, *args, **kwargs)
 385     else:
 386         return render(request, url, data_res)