2 # Copyright 2018 CNIT - Consorzio Nazionale Interuniversitario per le Telecomunicazioni
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
8 # http://www.apache.org/licenses/LICENSE-2.0
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.
17 from django
.shortcuts
import render
, redirect
18 from django
.http
import HttpResponse
, JsonResponse
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
27 logging
.basicConfig(level
=logging
.DEBUG
)
28 log
= logging
.getLogger('instancehandler/view.py')
32 def list(request
, type=None):
33 user
= osmutils
.get_user(request
)
34 project_id
= user
.project_id
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')
45 instance_list
= client
.ns_list(user
.get_token())
47 instance_list
= client
.vnf_list(user
.get_token())
49 instance_list
= client
.pdu_list(user
.get_token())
51 instance_list
= client
.nsi_list(user
.get_token())
53 result
['instances'] = instance_list
['data'] if instance_list
and instance_list
['error'] is False else []
55 return __response_handler(request
, result
, 'instance_list.html')
58 def create(request
, type=None):
60 config_vim_account_id
= {}
61 config_wim_account_id
= {}
62 user
= osmutils
.get_user(request
)
65 def get_vim_account_id(vim_account
):
66 if config_vim_account_id
.get(vim_account
):
67 return config_vim_account_id
[vim_account
]
68 result_client
= client
.vim_list(user
.get_token())
69 vim_list
= result_client
['data'] if result_client
and result_client
['error'] is False else []
70 if vim_list
is None or len(vim_list
) == 0:
71 raise ValueError("cannot find vim account '{}'".format(vim_account
))
73 if vim_account
== vim
['name']:
74 config_vim_account_id
[vim_account
] = vim
['uuid']
77 def get_wim_account_id(wim_account
):
79 if config_wim_account_id
.get(wim_account
):
80 return config_wim_account_id
[wim_account
]
81 result_client
= client
.wim_list(user
.get_token())
82 wim_list
= result_client
['data'] if result_client
and result_client
['error'] is False else []
83 if wim_list
is None or len(wim_list
) == 0:
84 raise ValueError("cannot find wim account '{}'".format(wim_account
))
86 if wim_account
== wim
['name']:
87 config_wim_account_id
[wim_account
] = wim
['uuid']
95 "nsName": request
.POST
.get('nsName', 'WithoutName'),
96 "nsDescription": request
.POST
.get('nsDescription', ''),
97 "nsdId": request
.POST
.get('nsdId', ''),
98 "vimAccountId": request
.POST
.get('vimAccountId', ''),
100 ns_data
["ssh_keys"] = []
101 if 'ssh_key' in request
.POST
and request
.POST
.get('ssh_key') != '':
102 ns_data
["ssh_keys"].append(request
.POST
.get('ssh_key'))
103 ssh_key_files
= request
.FILES
.getlist('ssh_key_files')
104 for ssh_key_file
in ssh_key_files
:
106 for line
in ssh_key_file
:
107 ssh_key
= ssh_key
+ line
.decode()
108 ns_data
["ssh_keys"].append(ssh_key
)
111 config_file
= request
.FILES
.get('config_file')
113 if config_file
is not None:
115 for line
in config_file
:
116 config
= config
+ line
.decode()
117 ns_config
= yaml
.load(config
)
118 elif 'config' in request
.POST
and request
.POST
.get('config') != '':
119 ns_config
= yaml
.load(request
.POST
.get('config'))
124 if ns_config
is not None:
125 if isinstance(ns_config
, dict):
126 if "vim-network-name" in ns_config
:
127 ns_config
["vld"] = ns_config
.pop("vim-network-name")
128 if "vld" in ns_config
:
129 for vld
in ns_config
["vld"]:
130 if vld
.get("vim-network-name"):
131 if isinstance(vld
["vim-network-name"], dict):
132 vim_network_name_dict
= {}
133 for vim_account
, vim_net
in list(vld
["vim-network-name"].items()):
134 vim_network_name_dict
[get_vim_account_id(vim_account
)] = vim_net
135 vld
["vim-network-name"] = vim_network_name_dict
136 if "wim_account" in vld
and vld
["wim_account"] is not None:
137 vld
["wimAccountId"] = get_wim_account_id(vld
.pop("wim_account"))
138 ns_data
["vld"] = ns_config
["vld"]
139 if "vnf" in ns_config
:
140 for vnf
in ns_config
["vnf"]:
141 if vnf
.get("vim_account"):
142 vnf
["vimAccountId"] = get_vim_account_id(vnf
.pop("vim_account"))
143 ns_data
["vnf"] = ns_config
["vnf"]
145 if "additionalParamsForNs" in ns_config
:
146 ns_data
["additionalParamsForNs"] = ns_config
.pop("additionalParamsForNs")
147 if not isinstance(ns_data
["additionalParamsForNs"], dict):
148 raise ValueError("Error 'additionalParamsForNs' must be a dictionary")
149 if "additionalParamsForVnf" in ns_config
:
150 ns_data
["additionalParamsForVnf"] = ns_config
.pop("additionalParamsForVnf")
151 if not isinstance(ns_data
["additionalParamsForVnf"], list):
152 raise ValueError("Error 'additionalParamsForVnf' must be a list")
153 for additional_param_vnf
in ns_data
["additionalParamsForVnf"]:
154 if not isinstance(additional_param_vnf
, dict):
155 raise ValueError("Error 'additionalParamsForVnf' items must be dictionaries")
156 if not additional_param_vnf
.get("member-vnf-index"):
157 raise ValueError("Error 'additionalParamsForVnf' items must contain "
158 "'member-vnf-index'")
159 if not additional_param_vnf
.get("additionalParams"):
160 raise ValueError("Error 'additionalParamsForVnf' items must contain "
161 "'additionalParams'")
162 if "wim_account" in ns_config
:
163 wim_account
= ns_config
.pop("wim_account")
164 if wim_account
is not None:
165 ns_data
['wimAccountId'] = get_wim_account_id(wim_account
)
167 except Exception as e
:
168 return __response_handler(request
, {'status': 400, 'code': 'BAD_REQUEST', 'detail': e
.message
} , url
=None, status
=400)
169 result
= client
.ns_create(user
.get_token(), ns_data
)
172 return __response_handler(request
, result
['data'], url
=None,
173 status
=result
['data']['status'] if 'status' in result
['data'] else 500)
175 return __response_handler(request
, {}, url
=None, status
=200)
180 "nsiName": request
.POST
.get('nsiName', 'WithoutName'),
181 "nsiDescription": request
.POST
.get('nsiDescription', ''),
182 "nstId": request
.POST
.get('nstId', ''),
183 "vimAccountId": request
.POST
.get('vimAccountId', ''),
186 nsi_data
["ssh_keys"] = []
187 if 'ssh_key' in request
.POST
and request
.POST
.get('ssh_key') != '':
188 nsi_data
["ssh_keys"].append(request
.POST
.get('ssh_key'))
189 ssh_key_files
= request
.FILES
.getlist('ssh_key_files')
190 for ssh_key_file
in ssh_key_files
:
192 for line
in ssh_key_file
:
193 ssh_key
= ssh_key
+ line
.decode()
194 nsi_data
["ssh_keys"].append(ssh_key
)
195 nsi_data
["ssh_keys"] = ','.join(nsi_data
["ssh_keys"])
197 config_file
= request
.FILES
.get('config_file')
199 if config_file
is not None:
201 for line
in config_file
:
202 config
= config
+ line
.decode()
203 nsi_config
= yaml
.load(config
)
204 elif 'config' in request
.POST
and request
.POST
.get('config') != '':
205 nsi_config
= yaml
.load(request
.POST
.get('config'))
209 if nsi_config
is not None:
210 if "netslice-vld" in nsi_config
:
211 for vld
in nsi_config
["netslice-vld"]:
212 if vld
.get("vim-network-name"):
213 if isinstance(vld
["vim-network-name"], dict):
214 vim_network_name_dict
= {}
215 for vim_account
, vim_net
in list(vld
["vim-network-name"].items()):
216 vim_network_name_dict
[get_vim_account_id(vim_account
)] = vim_net
217 vld
["vim-network-name"] = vim_network_name_dict
218 nsi_data
["netslice-vld"] = nsi_config
["netslice-vld"]
219 if "netslice-subnet" in nsi_config
:
220 for nssubnet
in nsi_config
["netslice-subnet"]:
221 if "vld" in nssubnet
:
222 for vld
in nssubnet
["vld"]:
223 if vld
.get("vim-network-name"):
224 if isinstance(vld
["vim-network-name"], dict):
225 vim_network_name_dict
= {}
226 for vim_account
, vim_net
in list(vld
["vim-network-name"].items()):
227 vim_network_name_dict
[get_vim_account_id(vim_account
)] = vim_net
228 vld
["vim-network-name"] = vim_network_name_dict
229 if "vnf" in nssubnet
:
230 for vnf
in nsi_config
["vnf"]:
231 if vnf
.get("vim_account"):
232 vnf
["vimAccountId"] = get_vim_account_id(vnf
.pop("vim_account"))
233 nsi_data
["netslice-subnet"] = nsi_config
["netslice-subnet"]
234 if "additionalParamsForNsi" in nsi_config
:
235 nsi_data
["additionalParamsForNsi"] = nsi_config
.pop("additionalParamsForNsi")
236 if not isinstance(nsi_data
["additionalParamsForNsi"], dict):
237 raise ValueError("Error at 'additionalParamsForNsi' must be a dictionary")
238 if "additionalParamsForSubnet" in nsi_config
:
239 nsi_data
["additionalParamsForSubnet"] = nsi_config
.pop("additionalParamsForSubnet")
240 if not isinstance(nsi_data
["additionalParamsForSubnet"], list):
241 raise ValueError("Error 'additionalParamsForSubnet' must be a list")
242 for additional_param_subnet
in nsi_data
["additionalParamsForSubnet"]:
243 if not isinstance(additional_param_subnet
, dict):
244 raise ValueError("Error 'additionalParamsForSubnet' items must be dictionaries")
245 if not additional_param_subnet
.get("id"):
246 raise ValueError("Error 'additionalParamsForSubnet' items must contain subnet 'id'")
247 if not additional_param_subnet
.get("additionalParamsForNs") and\
248 not additional_param_subnet
.get("additionalParamsForVnf"):
249 raise ValueError("Error 'additionalParamsForSubnet' items must contain "
250 "'additionalParamsForNs' and/or 'additionalParamsForVnf'")
251 except Exception as e
:
252 return __response_handler(request
, {'status': 400, 'code': 'BAD_REQUEST', 'detail': e
.message
} , url
=None, status
=400)
254 result
= client
.nsi_create(user
.get_token(), nsi_data
)
256 return __response_handler(request
, result
['data'], url
=None,
257 status
=result
['data']['status'] if 'status' in result
['data'] else 500)
259 return __response_handler(request
, {}, url
=None, status
=200)
262 interface_param_name
= request
.POST
.getlist('interfaces_name')
263 interface_param_ip
= request
.POST
.getlist('interfaces_ip')
264 interface_param_mgmt
= request
.POST
.getlist('interfaces_mgmt')
265 interface_param_netname
= request
.POST
.getlist('interfaces_vimnetname')
268 "name": request
.POST
.get('name'),
269 "type": request
.POST
.get('pdu_type'),
270 "vim_accounts": request
.POST
.getlist('pdu_vim_accounts'),
271 "description": request
.POST
.get('description'),
274 for i
in (0,len(interface_param_name
)-1):
275 pdu_payload
['interfaces'].append({
276 'name': interface_param_name
[i
],
277 'mgmt': True if interface_param_mgmt
[i
] == 'true' else False,
278 'ip-address': interface_param_ip
[i
],
279 'vim-network-name': interface_param_netname
[i
]
281 result
= client
.pdu_create(user
.get_token(), pdu_payload
)
283 return __response_handler(request
, result
['data'], url
=None,
284 status
=result
['data']['status'] if 'status' in result
['data'] else 500)
286 return __response_handler(request
, {}, url
=None, status
=200)
289 def ns_operations(request
, instance_id
=None, type=None):
290 user
= osmutils
.get_user(request
)
291 project_id
= user
.project_id
293 result
= {'type': type, 'project_id': project_id
, 'instance_id': instance_id
}
294 raw_content_types
= request
.META
.get('HTTP_ACCEPT', '*/*').split(',')
295 if 'application/json' not in raw_content_types
:
296 return __response_handler(request
, result
, 'instance_operations_list.html')
299 op_list
= client
.ns_op_list(user
.get_token(), instance_id
)
301 op_list
= client
.nsi_op_list(user
.get_token(), instance_id
)
302 result
['operations'] = op_list
['data'] if op_list
and op_list
['error'] is False else []
304 return __response_handler(request
, result
, 'instance_operations_list.html')
307 def ns_operation(request
, op_id
, instance_id
=None, type=None):
308 user
= osmutils
.get_user(request
)
310 result
= client
.ns_op(user
.get_token(), op_id
)
311 return __response_handler(request
, result
['data'])
315 def action(request
, instance_id
=None, type=None):
316 user
= osmutils
.get_user(request
)
318 # result = client.ns_action(instance_id, action_payload)
319 primitive_param_keys
= request
.POST
.getlist('primitive_params_name')
320 primitive_param_value
= request
.POST
.getlist('primitive_params_value')
322 "vnf_member_index": request
.POST
.get('vnf_member_index'),
323 "primitive": request
.POST
.get('primitive'),
324 "primitive_params": {k
: v
for k
, v
in zip(primitive_param_keys
, primitive_param_value
) if len(k
) > 0}
327 result
= client
.ns_action(user
.get_token(), instance_id
, action_payload
)
329 return __response_handler(request
, result
['data'], url
=None,
330 status
=result
['data']['status'] if 'status' in result
['data'] else 500)
332 return __response_handler(request
, {}, url
=None, status
=200)
336 def delete(request
, instance_id
=None, type=None):
337 force
= bool(request
.GET
.get('force', False))
339 user
= osmutils
.get_user(request
)
342 result
= client
.ns_delete(user
.get_token(), instance_id
, force
)
344 result
= client
.pdu_delete(user
.get_token(), instance_id
)
346 result
= client
.nsi_delete(user
.get_token(), instance_id
, force
)
349 return __response_handler(request
, result
['data'], url
=None,
350 status
=result
['data']['status'] if 'status' in result
['data'] else 500)
352 return __response_handler(request
, {}, url
=None, status
=200)
355 def show_topology(request
, instance_id
=None, type=None):
356 user
= osmutils
.get_user(request
)
357 project_id
= user
.project_id
358 raw_content_types
= request
.META
.get('HTTP_ACCEPT', '*/*').split(',')
359 if 'application/json' in raw_content_types
:
361 nsr_object
= {'nsr': {}, 'vnfr': {}, 'vnfd': {}}
364 nsr_resp
= client
.ns_get(user
.get_token(), instance_id
)
365 nsr_object
['nsr'] = nsr_resp
['data']
366 if 'constituent-vnfr-ref' in nsr_object
['nsr'] :
367 for vnfr_id
in nsr_object
['nsr']['constituent-vnfr-ref']:
368 vnfr_resp
= client
.vnf_get(user
.get_token(), vnfr_id
)
369 vnfr
= vnfr_resp
['data']
370 nsr_object
['vnfr'][vnfr
['id']] = vnfr
371 if vnfr
['vnfd-id'] not in nsr_object
['vnfd']:
372 vnfd_resp
= client
.vnfd_get(user
.get_token(), vnfr
['vnfd-id'])
373 nsr_object
['vnfd'][vnfr
['vnfd-id']] = vnfd_resp
['vnfd:vnfd-catalog']['vnfd'][0]
377 result
= test
.nsr_to_graph(nsr_object
)
378 return __response_handler(request
, result
)
380 result
= {'type': type, 'project_id': project_id
, 'instance_id': instance_id
}
381 return __response_handler(request
, result
, 'instance_topology_view.html')
385 def show(request
, instance_id
=None, type=None):
387 user
= osmutils
.get_user(request
)
388 project_id
= user
.project_id
391 result
= client
.ns_get(user
.get_token(), instance_id
)
393 result
= client
.vnf_get(user
.get_token(), instance_id
)
395 result
= client
.pdu_get(user
.get_token(), instance_id
)
397 result
= client
.nsi_get(user
.get_token(), instance_id
)
399 return __response_handler(request
, result
)
403 def export_metric(request
, instance_id
=None, type=None):
404 metric_data
= request
.POST
.dict()
405 user
= osmutils
.get_user(request
)
406 project_id
= user
.project_id
408 keys
= ["collection_period",
414 metric_data
= dict(filter(lambda i
: i
[0] in keys
and len(i
[1]) > 0, metric_data
.items()))
416 result
= client
.ns_metric_export(user
.get_token(), instance_id
, metric_data
)
419 return __response_handler(request
, result
['data'], url
=None,
420 status
=result
['data']['status'] if 'status' in result
['data'] else 500)
422 return __response_handler(request
, {}, url
=None, status
=200)
426 def create_alarm(request
, instance_id
=None, type=None):
427 metric_data
= request
.POST
.dict()
428 user
= osmutils
.get_user(request
)
429 project_id
= user
.project_id
432 keys
= ["threshold_value",
441 metric_data
= dict(filter(lambda i
: i
[0] in keys
and len(i
[1]) > 0, metric_data
.items()))
443 result
= client
.ns_alarm_create(user
.get_token(), instance_id
, metric_data
)
445 return __response_handler(request
, result
['data'], url
=None,
446 status
=result
['data']['status'] if 'status' in result
['data'] else 500)
448 return __response_handler(request
, {}, url
=None, status
=200)
451 def __response_handler(request
, data_res
, url
=None, to_redirect
=None, *args
, **kwargs
):
452 raw_content_types
= request
.META
.get('HTTP_ACCEPT', '*/*').split(',')
453 if not to_redirect
and ('application/json' in raw_content_types
or url
is None):
454 return HttpResponse(json
.dumps(data_res
), content_type
="application/json", *args
, **kwargs
)
456 return redirect(url
, *args
, **kwargs
)
458 return render(request
, url
, data_res
)