zte/vmanager/driver/interfaces/views.py

   1 # Copyright 2016-2017 ZTE Corporation.
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #         http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 import inspect
  16 import json
  17 import logging
  18 import traceback
  19 import os
  20
  21 from rest_framework.decorators import api_view
  22 from rest_framework.response import Response
  23
  24 from driver.pub.utils import restcall
  25 from driver.pub.utils.restcall import req_by_msb
  26 from driver.pub.config.config import VNF_FTP
  27
  28 logger = logging.getLogger(__name__)
  29
  30
  31 def load_json_file(file_name):
  32     json_file = os.path.join(os.path.dirname(__file__), "data/" + file_name)
  33     f = open(json_file)
  34     json_data = json.JSONDecoder().decode(f.read())
  35     f.close()
  36     return json_data
  37
  38
  39 def fun_name():
  40     return "=================%s==================" % inspect.stack()[1][3]
  41
  42
  43 def ignorcase_get(args, key):
  44     if not key:
  45         return ""
  46     if not args:
  47         return ""
  48     if key in args:
  49         return args[key]
  50     for old_key in args:
  51         if old_key.upper() == key.upper():
  52             return args[old_key]
  53     return ""
  54
  55
  56 def mapping_conv(keyword_map, rest_return):
  57     resp_data = {}
  58     for param in keyword_map:
  59         if keyword_map[param]:
  60             resp_data[keyword_map[param]] = ignorcase_get(rest_return, param)
  61     return resp_data
  62
  63
  64 # Query vnfm_info from nslcm
  65 def get_vnfminfo_from_nslcm(vnfmid):
  66     ret = req_by_msb("api/nslcm/v1/vnfms/%s" % vnfmid, "GET")
  67     return ret
  68
  69
  70 # Query vnfd_info from nslcm
  71 def vnfd_get(vnfpackageid):
  72     ret = req_by_msb("api/nslcm/v1/vnfpackage/%s" % vnfpackageid, "GET")
  73     return ret
  74
  75
  76 # Query vnfpackage_info from nslcm
  77 def vnfpackage_get(csarid):
  78     ret = req_by_msb("api/nslcm/v1/vnfpackage/%s" % csarid, "GET")
  79     return ret
  80
  81
  82 @api_view(http_method_names=['POST'])
  83 def instantiate_vnf(request, *args, **kwargs):
  84     try:
  85         logger.debug("[%s] request.data=%s", fun_name(), request.data)
  86         vnfm_id = ignorcase_get(kwargs, "vnfmid")
  87         ret = get_vnfminfo_from_nslcm(vnfm_id)
  88         if ret[0] != 0:
  89             return Response(data={'error': ret[1]}, status=ret[2])
  90         vnfm_info = json.JSONDecoder().decode(ret[1])
  91         logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info)
  92         vnf_package_id = ignorcase_get(request.data, "vnfPackageId")
  93         ret = vnfd_get(vnf_package_id)
  94         if ret[0] != 0:
  95             return Response(data={'error': ret[1]}, status=ret[2])
  96         vnfd_info = json.JSONDecoder().decode(ret[1])
  97         logger.debug("[%s] vnfd_info=%s", fun_name(), vnfd_info)
  98         csar_id = ignorcase_get(vnfd_info, "csarId")
  99         ret = vnfpackage_get(csar_id)
 100         if ret[0] != 0:
 101             return Response(data={'error': ret[1]}, status=ret[2])
 102         vnf_package_info = json.JSONDecoder().decode(ret[1])
 103         packageInfo = ignorcase_get(vnf_package_info, "packageInfo")
 104         logger.debug("[%s] packageInfo=%s", fun_name(), packageInfo)
 105         data = {}
 106         data["NFVOID"] = 1
 107         data["VNFMID"] = vnfm_id
 108         vnfdModel = json.loads(ignorcase_get(packageInfo, "vnfdModel"))
 109         metadata = ignorcase_get(vnfdModel, "metadata")
 110         vnfd_name = ignorcase_get(metadata, "name")
 111         # TODO  convert sdc vnf package to vnf vender package
 112         inputs = []
 113         if "SPGW" in vnfd_name.upper():
 114             data["VNFD"] = VNF_FTP + "SPGW"
 115             inputs = load_json_file("SPGW" + "_inputs.json")
 116         elif "MME" in vnfd_name.upper():
 117             data["VNFD"] = VNF_FTP + "MME"
 118             inputs = load_json_file("MME" + "_inputs.json")
 119         else:
 120             data["VNFD"] = ignorcase_get(packageInfo, "downloadUri")
 121
 122         data["VNFURL"] = data["VNFD"]
 123
 124         data["extension"] = {}
 125         for name, value in ignorcase_get(ignorcase_get(request.data, "additionalParam"), "inputs").items():
 126             inputs.append({"name": name, "value": value})
 127
 128         data["extension"]["inputs"] = json.dumps(inputs)
 129         additionalParam = ignorcase_get(request.data, "additionalParam")
 130         data["extension"]["extVirtualLinks"] = ignorcase_get(additionalParam, "extVirtualLinks")
 131         data["extension"]["vnfinstancename"] = ignorcase_get(request.data, "vnfInstanceName")
 132         data["extension"]["vnfid"] = data["VNFD"]
 133         data["extension"]["multivim"] = 0
 134         logger.debug("[%s] call_req data=%s", fun_name(), data)
 135
 136         ret = restcall.call_req(
 137             base_url=ignorcase_get(vnfm_info, "url"),
 138             user=ignorcase_get(vnfm_info, "userName"),
 139             passwd=ignorcase_get(vnfm_info, "password"),
 140             auth_type=restcall.rest_no_auth,
 141             resource="v1/vnfs",
 142             method='post',
 143             content=json.JSONEncoder().encode(data))
 144
 145         logger.debug("[%s] call_req ret=%s", fun_name(), ret)
 146         if ret[0] != 0:
 147             return Response(data={'error': ret[1]}, status=ret[2])
 148         resp = json.JSONDecoder().decode(ret[1])
 149         resp_data = {
 150             "vnfInstanceId": ignorcase_get(resp, "VNFInstanceID"),
 151             "jobId": ignorcase_get(resp, "JobId")
 152         }
 153         logger.info("[%s]resp_data=%s", fun_name(), resp_data)
 154     except Exception as e:
 155         logger.error("Error occurred when instantiating VNF")
 156         raise e
 157     return Response(data=resp_data, status=ret[2])
 158
 159
 160 @api_view(http_method_names=['POST'])
 161 def terminate_vnf(request, *args, **kwargs):
 162     try:
 163         logger.debug("[%s] request.data=%s", fun_name(), request.data)
 164         vnfm_id = ignorcase_get(kwargs, "vnfmid")
 165         ret = get_vnfminfo_from_nslcm(vnfm_id)
 166         if ret[0] != 0:
 167             return Response(data={'error': ret[1]}, status=ret[2])
 168         vnfm_info = json.JSONDecoder().decode(ret[1])
 169         logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info)
 170         ret = restcall.call_req(
 171             base_url=ignorcase_get(vnfm_info, "url"),
 172             user=ignorcase_get(vnfm_info, "userName"),
 173             passwd=ignorcase_get(vnfm_info, "password"),
 174             auth_type=restcall.rest_no_auth,
 175             resource="v1/vnfs/%s" % (ignorcase_get(kwargs, "vnfInstanceID")),
 176             method='delete',
 177             content=json.JSONEncoder().encode(request.data))
 178         if ret[0] != 0:
 179             return Response(data={'error': ret[1]}, status=ret[2])
 180         resp = json.JSONDecoder().decode(ret[1])
 181         resp_data = {
 182             "vnfInstanceId": ignorcase_get(resp, "VNFInstanceID"),
 183             "jobId": ignorcase_get(resp, "JobId")
 184         }
 185         logger.debug("[%s]resp_data=%s", fun_name(), resp_data)
 186     except Exception as e:
 187         logger.error("Error occurred when terminating VNF")
 188         raise e
 189     return Response(data=resp_data, status=ret[2])
 190
 191
 192 vnf_detail_url = "v1/vnfs/%s"
 193 vnf_detail_resp_mapping = {
 194     "VNFInstanseStatus": "status"
 195 }
 196
 197
 198 @api_view(http_method_names=['GET'])
 199 def query_vnf(request, *args, **kwargs):
 200     try:
 201         logger.debug("[%s] request.data=%s", fun_name(), request.data)
 202         vnfm_id = ignorcase_get(kwargs, "vnfmid")
 203         ret = get_vnfminfo_from_nslcm(vnfm_id)
 204         if ret[0] != 0:
 205             return Response(data={'error': ret[1]}, status=ret[2])
 206         vnfm_info = json.JSONDecoder().decode(ret[1])
 207         logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info)
 208         data = {}
 209         ret = restcall.call_req(
 210             base_url=ignorcase_get(vnfm_info, "url"),
 211             user=ignorcase_get(vnfm_info, "userName"),
 212             passwd=ignorcase_get(vnfm_info, "password"),
 213             auth_type=restcall.rest_no_auth,
 214             resource=vnf_detail_url % (ignorcase_get(kwargs, "vnfInstanceID")),
 215             method='get',
 216             content=json.JSONEncoder().encode(data))
 217         if ret[0] != 0:
 218             return Response(data={'error': ret[1]}, status=ret[2])
 219         resp = json.JSONDecoder().decode(ret[1])
 220         vnf_status = ignorcase_get(resp, "vnfinstancestatus")
 221         resp_data = {"vnfInfo": {"vnfStatus": vnf_status}}
 222         logger.debug("[%s]resp_data=%s", fun_name(), resp_data)
 223     except Exception as e:
 224         logger.error("Error occurred when querying VNF information.")
 225         raise e
 226     return Response(data=resp_data, status=ret[2])
 227
 228
 229 # Get Operation Status
 230 operation_status_url = '/v1/jobs/{jobId}?NFVOID={nfvoId}&VNFMID={vnfmId}&ResponseID={responseId}'
 231 operation_status_resp_map = {
 232     "JobId": "jobId",
 233     "Status": "status",
 234     "Progress": "progress",
 235     "StatusDescription": "currentStep",
 236     "ErrorCode": "errorCode",
 237     "ResponseId": "responseId",
 238     "ResponseHistoryList": "responseHistoryList",
 239     "ResponseDescriptor": "responseDescriptor"
 240 }
 241
 242
 243 @api_view(http_method_names=['GET'])
 244 def operation_status(request, *args, **kwargs):
 245     data = {}
 246     try:
 247         logger.debug("[%s] request.data=%s", fun_name(), request.data)
 248         vnfm_id = ignorcase_get(kwargs, "vnfmid")
 249         ret = get_vnfminfo_from_nslcm(vnfm_id)
 250         if ret[0] != 0:
 251             return Response(data={'error': ret[1]}, status=ret[2])
 252         vnfm_info = json.JSONDecoder().decode(ret[1])
 253         logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info)
 254         ret = restcall.call_req(
 255             base_url=ignorcase_get(vnfm_info, 'url'),
 256             user=ignorcase_get(vnfm_info, 'userName'),
 257             passwd=ignorcase_get(vnfm_info, 'password'),
 258             auth_type=restcall.rest_no_auth,
 259             resource=operation_status_url.format(jobId=ignorcase_get(kwargs, 'jobid'), nfvoId=1,
 260                                                  vnfmId=ignorcase_get(kwargs, 'vnfmid'),
 261                                                  responseId=ignorcase_get(request.GET, 'responseId')),
 262             method='get',
 263             content=json.JSONEncoder().encode(data))
 264
 265         if ret[0] != 0:
 266             return Response(data={'error': ret[1]}, status=ret[2])
 267         resp_data = json.JSONDecoder().decode(ret[1])
 268         logger.info("[%s]resp_data=%s", fun_name(), resp_data)
 269     except Exception as e:
 270         logger.error("Error occurred when getting operation status information.")
 271         raise e
 272     return Response(data=resp_data, status=ret[2])
 273
 274
 275 # Grant VNF Lifecycle Operation
 276 grant_vnf_url = 'api/nslcm/v1/ns/grantvnf'
 277 grant_vnf_param_map = {
 278     "VNFMID": "",
 279     "NFVOID": "",
 280     "VIMID": "",
 281     "ExVIMIDList": "",
 282     "ExVIMID": "",
 283     "Tenant": "",
 284     "VNFInstanceID": "vnfInstanceId",
 285     "OperationRight": "",
 286     "VMList": "",
 287     "VMFlavor": "",
 288     "VMNumber": ""}
 289
 290
 291 @api_view(http_method_names=['PUT'])
 292 def grantvnf(request, *args, **kwargs):
 293     logger.info("=====grantvnf=====")
 294     try:
 295         resp_data = {}
 296         logger.info("req_data = %s", request.data)
 297         data = mapping_conv(grant_vnf_param_map, request.data)
 298         logger.info("grant_vnf_url = %s", grant_vnf_url)
 299         data["vnfDescriptorId"] = ""
 300         if ignorcase_get(request.data, "operationright") == 0:
 301             data["lifecycleOperation"] = "Instantiate"
 302             data["addresource"] = []
 303             for vm in ignorcase_get(request.data, "vmlist"):
 304                 for i in range(int(ignorcase_get(vm, "vmnumber"))):
 305                     data["addresource"].append(
 306                         {"type": "vdu",
 307                          "resourceDefinitionId": i,
 308                          "vdu": ignorcase_get(vm, "vmflavor"),
 309                          "vimid": ignorcase_get(vm, "vimid"),
 310                          "tenant": ignorcase_get(vm, "tenant")
 311                          })
 312
 313         data["additionalparam"] = {}
 314         data["additionalparam"]["vnfmid"] = ignorcase_get(request.data, "vnfmid")
 315         data["additionalparam"]["vimid"] = ignorcase_get(request.data, "vimid")
 316         data["additionalparam"]["tenant"] = ignorcase_get(request.data, "tenant")
 317
 318         logger.info("data = %s", data)
 319         ret = req_by_msb(grant_vnf_url, "POST", content=json.JSONEncoder().encode(data))
 320         logger.info("ret = %s", ret)
 321         if ret[0] != 0:
 322             return Response(data={'error': ret[1]}, status=ret[2])
 323         resp = json.JSONDecoder().decode(ret[1])
 324
 325         resp_data['vimid'] = ignorcase_get(resp['vim'], 'vimid')
 326         resp_data['tenant'] = ignorcase_get(ignorcase_get(resp['vim'], 'accessinfo'), 'tenant')
 327
 328         logger.info("[%s]resp_data=%s", fun_name(), resp_data)
 329     except Exception as e:
 330         logger.error("Error occurred in Grant VNF.")
 331         raise e
 332     return Response(data=resp_data, status=ret[2])
 333
 334
 335 # Notify LCM Events
 336 notify_url = 'api/nslcm/v1/ns/{vnfmid}/vnfs/{vnfInstanceId}/Notify'
 337 notify_param_map = {
 338     "NFVOID": "",
 339     "VNFMID": "VNFMID",
 340     "VIMID": "vimid",
 341     "VNFInstanceID": "vnfInstanceId",
 342     "TimeStamp": "",
 343     "EventType": "operation",
 344     "VMList": "",
 345     "VMFlavor": "",
 346     "VMNumber": "",
 347     "VMIDlist": "",
 348     "VMUUID": ""
 349 }
 350
 351
 352 @api_view(http_method_names=['POST'])
 353 def notify(request, *args, **kwargs):
 354     try:
 355         logger.info("[%s]req_data = %s", fun_name(), request.data)
 356         data = mapping_conv(notify_param_map, request.data)
 357         logger.info("[%s]data = %s", fun_name(), data)
 358
 359         data["status"] = "result"
 360         data["jobId"] = "notMust"
 361         data["affectedVnfc"] = []
 362         data["affectedVl"] = []
 363         data["affectedVirtualStorage"] = []
 364         data["affectedCp"] = []
 365
 366         extension = ignorcase_get(request.data, "extension")
 367         openo_notification = ignorcase_get(extension, "openo_notification")
 368         if openo_notification:
 369             affectedvnfcs = ignorcase_get(openo_notification, "affectedVnfc")
 370             affectedvls = ignorcase_get(openo_notification, "affectedvirtuallink")
 371             affectedcps = ignorcase_get(openo_notification, "affectedCp")
 372             vnfdmodule = ignorcase_get(openo_notification, "vnfdmodule")
 373         else:
 374             affectedvnfcs = ignorcase_get(ignorcase_get(request.data, "extension"), "affectedvnfc")
 375             affectedvls = ignorcase_get(ignorcase_get(request.data, "extension"), "affectedvl")
 376             affectedcps = ignorcase_get(ignorcase_get(request.data, "extension"), "affectedcp")
 377             vnfdmodule = ignorcase_get(ignorcase_get(request.data, "extension"), "vnfdmodule")
 378
 379         data["vnfdmodule"] = vnfdmodule
 380
 381         for affectedvnfc in affectedvnfcs:
 382             data["affectedVnfc"].append({
 383                 "vnfcInstanceId": ignorcase_get(affectedvnfc, "vnfcInstanceId"),
 384                 "vduId": ignorcase_get(affectedvnfc, "vduId"),
 385                 "changeType": ignorcase_get(affectedvnfc, "changeType"),
 386                 "vimid": ignorcase_get(ignorcase_get(affectedvnfc, "computeResource"), "vimId"),
 387                 "vmId": ignorcase_get(ignorcase_get(affectedvnfc, "computeResource"), "resourceId"),
 388                 "vmName": ignorcase_get(ignorcase_get(affectedvnfc, "computeResource"), "resourceName")
 389             })
 390
 391         for affectedvl in affectedvls:
 392             data["affectedVl"].append({
 393                 "vlInstanceId": ignorcase_get(affectedvl, "virtuallinkinstanceid"),
 394                 "vimid": ignorcase_get(ignorcase_get(affectedvl, "networkresource"), "vimid"),
 395                 "vldid": ignorcase_get(affectedvl, "virtuallinkdescid"),
 396                 "vllid": ignorcase_get(ignorcase_get(affectedvl, "networkresource"), "resourceid"),
 397                 "vlName": ignorcase_get(ignorcase_get(affectedvl, "networkresource"), "resourcename")
 398             })
 399
 400         for affectedcp in affectedcps:
 401             data["affectedCp"].append(affectedcp)
 402
 403         ret = req_by_msb(notify_url.format(vnfmid=ignorcase_get(data, 'VNFMID'),
 404                                            vnfInstanceId=ignorcase_get(data, 'vnfinstanceid')),
 405                          "POST", content=json.JSONEncoder().encode(data))
 406
 407         logger.info("[%s]data = %s", fun_name(), ret)
 408         if ret[0] != 0:
 409             return Response(data={'error': ret[1]}, status=ret[2])
 410     except Exception as e:
 411         logger.error("Error occurred in LCM notification.")
 412         logger.error(traceback.format_exc())
 413         raise e
 414     return Response(data=None, status=ret[2])
 415
 416
 417 nf_scaling_url = '/v1/vnfs/{vnfInstanceID}/scale'
 418
 419
 420 @api_view(http_method_names=['POST'])
 421 def scale(request, *args, **kwargs):
 422     logger.info("====scale_vnf===")
 423     try:
 424         logger.info("request.data = %s", request.data)
 425         logger.info("requested_url = %s", request.get_full_path())
 426         vnfm_id = ignorcase_get(kwargs, "vnfmid")
 427         nf_instance_id = ignorcase_get(kwargs, "vnfInstanceId")
 428         ret = get_vnfminfo_from_nslcm(vnfm_id)
 429         if ret[0] != 0:
 430             return Response(data={'error': ret[1]}, status=ret[2])
 431         vnfm_info = json.JSONDecoder().decode(ret[1])
 432         scale_type = ignorcase_get(request.data, "type")
 433         aspect_id = ignorcase_get(request.data, "aspectId")
 434         number_of_steps = ignorcase_get(request.data, "numberOfSteps")
 435         # extension = ignorcase_get(request.data, "additionalParam")
 436         # vnfd_model = ignorcase_get(extension, "vnfdModel")
 437         data = {
 438             'vnfmid': vnfm_id,
 439             'nfvoid': 1,
 440             'scaletype': '0' if scale_type == 'SCALE_OUT' else '1',
 441             'vmlist': [{'VMNumber': number_of_steps, 'VMFlavor': aspect_id}],
 442             'extension': ''
 443         }
 444         '''
 445         for vdu_id in get_vdus(vnfd_model, aspect_id):
 446             data['vmlist'].append({
 447                 "VMFlavor": vdu_id,
 448                 "VMNumber": number_of_steps
 449             })
 450         '''
 451         logger.info("data = %s", data)
 452         ret = restcall.call_req(
 453             base_url=ignorcase_get(vnfm_info, "url"),
 454             user=ignorcase_get(vnfm_info, "userName"),
 455             passwd=ignorcase_get(vnfm_info, "password"),
 456             auth_type=restcall.rest_no_auth,
 457             resource=nf_scaling_url.format(vnfInstanceID=nf_instance_id),
 458             method='put',  # POST
 459             content=json.JSONEncoder().encode(data))
 460         logger.info("ret=%s", ret)
 461         if ret[0] != 0:
 462             return Response(data={'error': 'scale error'}, status=ret[2])
 463         resp_data = json.JSONDecoder().decode(ret[1])
 464         logger.info("resp_data=%s", resp_data)
 465     except Exception as e:
 466         logger.error("Error occurred when scaling VNF,error:%s", e.message)
 467         logger.error(traceback.format_exc())
 468         return Response(data={'error': 'scale expection'}, status='500')
 469     return Response(data=resp_data, status=ret[2])
 470
 471
 472 nf_healing_url = '/api/v1/nf_m_i/nfs/{vnfInstanceID}/vms/operation'
 473
 474
 475 @api_view(http_method_names=['POST'])
 476 def heal(request, *args, **kwargs):
 477     logger.info("====heal_vnf===")
 478     try:
 479         logger.info("request.data = %s", request.data)
 480         logger.info("requested_url = %s", request.get_full_path())
 481         vnfm_id = ignorcase_get(kwargs, "vnfmid")
 482         nf_instance_id = ignorcase_get(kwargs, "vnfInstanceId")
 483         ret = get_vnfminfo_from_nslcm(vnfm_id)
 484         if ret[0] != 0:
 485             return Response(data={'error': ret[1]}, status=ret[2])
 486         vnfm_info = json.JSONDecoder().decode(ret[1])
 487         data = {}
 488         data['action'] = ignorcase_get(request.data, 'action')
 489         affectedvm = ignorcase_get(request.data, 'affectedvm')
 490         data['affectedvm'] = []
 491         if isinstance(affectedvm, list):
 492             data['affectedvm'] = affectedvm
 493         else:
 494             data['affectedvm'].append(affectedvm)
 495         data['lifecycleoperation'] = 'operate'
 496         data['isgrace'] = 'force'
 497
 498         logger.info("data = %s", data)
 499         ret = restcall.call_req(
 500             base_url=ignorcase_get(vnfm_info, "url"),
 501             user=ignorcase_get(vnfm_info, "userName"),
 502             passwd=ignorcase_get(vnfm_info, "password"),
 503             auth_type=restcall.rest_no_auth,
 504             resource=nf_healing_url.format(vnfInstanceID=nf_instance_id),
 505             method='post',
 506             content=json.JSONEncoder().encode(data))
 507         logger.info("ret=%s", ret)
 508         if ret[0] != 0:
 509             return Response(data={'error': 'heal error'}, status=ret[2])
 510         resp_data = json.JSONDecoder().decode(ret[1])
 511         logger.info("resp_data=%s", resp_data)
 512     except Exception as e:
 513         logger.error("Error occurred when healing VNF,error:%s", e.message)
 514         logger.error(traceback.format_exc())
 515         return Response(data={'error': 'heal expection'}, status='500')
 516     return Response(data=resp_data, status=ret[2])
 517
 518
 519 def get_vdus(nf_model, aspect_id):
 520     associated_group = ''
 521     members = []
 522     vnf_flavours = nf_model['vnf_flavours']
 523     for vnf_flaour in vnf_flavours:
 524         scaling_aspects = vnf_flaour['scaling_aspects']
 525         for aspect in scaling_aspects:
 526             if aspect_id == aspect['id']:
 527                 associated_group = aspect['associated_group']
 528                 break
 529     if not associated_group:
 530         logger.error('Cannot find the corresponding element group')
 531         raise Exception('Cannot find the corresponding element group')
 532     for element_group in nf_model['element_groups']:
 533         if element_group['group_id'] == associated_group:
 534             members = element_group['members']
 535     if not members:
 536         logger.error('Cannot find the corresponding members')
 537         raise Exception('Cannot find the corresponding members')
 538     return members
 539
 540
 541 @api_view(http_method_names=['GET'])
 542 def samples(request, *args, **kwargs):
 543     return Response(data={"status": "ok"})