def delete_pending_csar(self):
JobUtil.create_job(
inst_type='nf',
jobaction='delete_pending',
inst_id=self.csar_id,
job_id=self.job_id)
JobUtil.add_job_status(self.job_id, 5, "Start to delete pending CSAR(%s)." % self.csar_id)
if not NfPackageModel.objects.filter(nfpackageid=self.csar_id):
JobUtil.add_job_status(self.job_id, 100, "Delete pending CSAR(%s) successfully." % self.csar_id)
return
csar_info = query_csar_from_catalog(self.csar_id)
process_state = ignore_case_get(csar_info, "processState")
if process_state == P_STATUS_DELETING:
JobUtil.add_job_status(self.job_id, 100, "CSAR(%s) is deleting now." % self.csar_id)
return
deletion_pending = ignore_case_get(csar_info, "deletionPending")
if deletion_pending.lower() == "false":
JobUtil.add_job_status(self.job_id, 100, "CSAR(%s) need not to be deleted." % self.csar_id)
return
if NfInstModel.objects.filter(package_id=self.csar_id):
JobUtil.add_job_status(self.job_id, 100, "CSAR(%s) is in using, cannot be deleted." % self.csar_id)
return
NfPackage().delete_csar(self.csar_id, self.job_id)
def test_create_job(self):
job_id = "5"
JobModel.objects.filter().delete()
JobUtil.create_job(inst_type="1",
jobaction="2",
inst_id="3",
user="******",
job_id=5,
res_name="6")
self.assertEqual(1, len(JobModel.objects.filter(jobid=job_id)))
JobModel.objects.filter().delete()
def test_ns_update_asynchronous_tasks_when_ns_does_not_exist(self):
ns_instance_id = 'test_ns_update_002'
job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.UPDATE, ns_instance_id)
ns_heal_service = NSUpdateService(ns_instance_id, UPDATE_NS_DICT, job_id)
ns_heal_service.run()
self.assertEqual(JobModel.objects.filter(jobid=job_id).first().progress, JOB_PROGRESS.ERROR)
self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
def test_instantiate_vnf_when_unexpected_exception(self, mock_call,
mock_call_req):
NfInstModel.objects.create(nfinstid='1111',
nf_name='vFW_01',
package_id='222',
version='',
vendor='',
netype='',
vnfd_model='',
status='NOT_INSTANTIATED',
nf_desc='vFW in Nanjing TIC Edge',
vnfdid='111',
create_time=now_time())
r1_get_vnfpackage_by_vnfdid = [
0, json.JSONEncoder().encode(vnfpackage_info), '200'
]
r2_apply_grant_result = [
0, json.JSONEncoder().encode(self.grant_result), '200'
]
mock_call_req.side_effect = [
r1_get_vnfpackage_by_vnfdid, r2_apply_grant_result
]
mock_call.side_effect = [
c1_data_get_tenant_id, c2_data_create_volume, c3_data_get_volume
]
self.nf_inst_id = '1111'
self.job_id = JobUtil.create_job('NF', 'CREATE', self.nf_inst_id)
JobUtil.add_job_status(self.job_id, 0, 'INST_VNF_READY')
data = inst_req_data
InstantiateVnf(data, nf_inst_id=self.nf_inst_id,
job_id=self.job_id).run()
self.assert_job_result(self.job_id, 255, 'unexpected exception')
def test_instantiate_operating_conflict(self, mock_call_req):
NfInstModel.objects.create(nfinstid='1111',
nf_name='vFW_01',
package_id='222',
version='',
vendor='',
netype='',
vnfd_model='',
status='NOT_INSTANTIATED',
nf_desc='vFW in Nanjing TIC Edge',
vnfdid='111',
create_time=now_time())
r1_get_vnfpackage_by_vnfdid = [
0, json.JSONEncoder().encode(vnfpackage_info), '200'
]
mock_call_req.side_effect = [r1_get_vnfpackage_by_vnfdid]
self.nf_inst_id = '1111'
self.job_id = JobUtil.create_job('NF', 'CREATE', self.nf_inst_id)
JobUtil.add_job_status(self.job_id, 0, 'INST_VNF_READY')
VNFLcmOpOccModel.objects.create(
vnf_instance_id=self.nf_inst_id,
id=self.job_id,
operation=const.OPERATION_TYPE.INSTANTIATE,
operation_state=const.OPERATION_STATE_TYPE.PROCESSING)
response = self.client.post(
'/api/vnflcm/v1/vnf_instances/1111/instantiate',
data=inst_req_data,
format='json')
self.assertEqual(status.HTTP_409_CONFLICT, response.status_code)
def post(self, request, vnfinstid):
logger.debug("NfTerminate--post::> %s, %s", vnfinstid, request.data)
req_serializer = TerminateVnfReqSerializer(data=request.data)
if not req_serializer.is_valid():
logger.error(req_serializer.errors)
vnf_inst_id = vnfinstid
terminationType = ignore_case_get(request.data, 'terminationType')
gracefulTerminationTimeout = ignore_case_get(request.data, 'gracefulTerminationTimeout')
job_id = JobUtil.create_job(JOB_TYPE.VNF, JOB_ACTION.TERMINATE, vnf_inst_id)
data = {'terminationType': terminationType, 'gracefulTerminationTimeout': gracefulTerminationTimeout}
logger.debug("data=%s", data)
try:
TerminateVnfs(data, vnf_inst_id, job_id).start()
except Exception as e:
logger.error(e.args[0])
return Response(data={'error': '%s' % e.args[0]}, status=status.HTTP_409_CONFLICT)
rsp = {'jobId': job_id}
resp_serializer = TerminateVnfRespSerializer(data=rsp)
if not resp_serializer.is_valid():
logger.error(resp_serializer.errors)
return Response(data=rsp, status=status.HTTP_202_ACCEPTED)
def setUp(self):
self.ns_inst_id = '1'
self.nf_inst_id = '1'
self.nf_uuid = '1-1-1'
self.job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.HEAL,
self.ns_inst_id)
self.client = APIClient()
NSInstModel.objects.filter().delete()
NfInstModel.objects.filter().delete()
NSInstModel(id=self.ns_inst_id, name='ns_name', status='null').save()
NfInstModel.objects.create(nfinstid=self.nf_inst_id,
nf_name='name_1',
vnf_id='1',
vnfm_inst_id='1',
ns_inst_id=self.ns_inst_id,
max_cpu='14',
max_ram='12296',
max_hd='101',
max_shd='20',
max_net=10,
status='null',
mnfinstid=self.nf_uuid,
package_id='pkg1',
vnfd_model=VNFD_MODEL_DICT)
VNFCInstModel(nfinstid=self.nf_inst_id,
vmid='vmid_01',
vduid='vduid_01').save()
VmInstModel(vmid='vmid_01', vmname='vmname_01').save()
def post(self, request):
logger.debug("NfGrant--post::> %s" % request.data)
try:
req_serializer = GrantVnfReqSerializer(data=request.data)
if not req_serializer.is_valid():
raise Exception(req_serializer.errors)
vnf_inst_id = ignore_case_get(request.data, 'vnfInstanceId')
job_id = JobUtil.create_job(JOB_TYPE.VNF, JOB_ACTION.GRANT, vnf_inst_id)
rsp = GrantVnfs(request.data, job_id).send_grant_vnf_to_resMgr()
"""
rsp = {
"vim": {
"vimid": ignore_case_get(ignore_case_get(request.data, 'additionalparam'), 'vimid'),
"accessinfo": {
"tenant": "admin"
}
}
}
"""
# resp_serializer = GrantVnfRespSerializer(data=rsp)
# if not resp_serializer.is_valid():
# raise Exception(resp_serializer.errors)
return Response(data=rsp, status=status.HTTP_201_CREATED)
except Exception as e:
logger.error(e.args[0])
logger.error(traceback.format_exc())
return Response(data={'error': '%s' % e.args[0]}, status=status.HTTP_409_CONFLICT)
def setUp(self):
self.url = "/api/nslcm/v1/ns_instances/%s/heal"
self.ns_inst_id = str(uuid.uuid4())
self.nf_inst_id = '1'
self.nf_uuid = '1-1-1'
self.job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.HEAL, self.ns_inst_id)
self.client = Client()
model = json.dumps(VNFD_MODEL_DICT)
NSInstModel.objects.filter().delete()
NfInstModel.objects.filter().delete()
NSInstModel(id=self.ns_inst_id, name="ns_name", status='null').save()
NfInstModel.objects.create(
nfinstid=self.nf_inst_id,
nf_name='name_1',
vnf_id='1',
vnfm_inst_id='1',
ns_inst_id=self.ns_inst_id,
max_cpu='14',
max_ram='12296',
max_hd='101',
max_shd="20",
max_net=10,
status='null',
mnfinstid=self.nf_uuid,
package_id='pkg1',
vnfd_model=model)
def test_instantiate_vnf_when_already_instantiated(self):
NfInstModel.objects.create(nfinstid='1111',
nf_name='vFW_01',
package_id='222',
version='',
vendor='',
netype='',
vnfd_model='',
status='INSTANTIATED',
nf_desc='vFW in Nanjing TIC Edge',
vnfdid='111',
create_time=now_time())
self.nf_inst_id = '1111'
self.job_id = JobUtil.create_job('NF', 'CREATE', self.nf_inst_id)
JobUtil.add_job_status(self.job_id, 0, 'INST_VNF_READY')
jobs = JobStatusModel.objects.filter(jobid=self.job_id,
progress=0,
descp='INST_VNF_READY')
self.assertEqual(1, len(jobs))
data = inst_req_data
InstantiateVnf(data, nf_inst_id=self.nf_inst_id,
job_id=self.job_id).run()
self.assert_job_result(
self.job_id, 255,
'VNF instantiationState is not NOT_INSTANTIATED.')
def test_instantiate_vnf_when_get_packageinfo_by_csarid_failed(
self, mock_call_req):
NfInstModel.objects.create(nfinstid='1111',
nf_name='vFW_01',
package_id='222',
version='',
vendor='',
netype='',
vnfd_model='',
status='NOT_INSTANTIATED',
nf_desc='vFW in Nanjing TIC Edge',
vnfdid='111',
create_time=now_time())
r1_get_vnfpackage_by_vnfdid = [
1, json.JSONEncoder().encode(vnfpackage_info), '200'
]
mock_call_req.side_effect = [r1_get_vnfpackage_by_vnfdid]
self.nf_inst_id = '1111'
self.job_id = JobUtil.create_job('NF', 'CREATE', self.nf_inst_id)
JobUtil.add_job_status(self.job_id, 0, 'INST_VNF_READY')
data = inst_req_data
InstantiateVnf(data, nf_inst_id=self.nf_inst_id,
job_id=self.job_id).run()
self.assert_job_result(self.job_id, 255,
'Failed to query vnf CSAR(111) from catalog.')
def test_terminate_vnf(self, mock_call_req):
job_id = JobUtil.create_job("VNF", JOB_TYPE.TERMINATE_VNF, self.nf_inst_id)
mock_vals = {
"/openoapi/nslcm/v1/ns/vls/1":
[0, json.JSONEncoder().encode({"jobId": self.job_id}), '200'],
"/openoapi/nslcm/v1/ns/sfcs/1":
[0, json.JSONEncoder().encode({"jobId": self.job_id}), '200'],
"/openoapi/nslcm/v1/ns/vnfs/1":
[0, json.JSONEncoder().encode({}), '200'],
"/openoapi/ztevmanagerdriver/v1/jobs/" + self.job_id + "&responseId=0":
[0, json.JSONEncoder().encode({"jobid": self.job_id,
"responsedescriptor": {"progress": "100",
"status": JOB_MODEL_STATUS.FINISHED,
"responseid": "3",
"statusdescription": "creating",
"errorcode": "0",
"responsehistorylist": [
{"progress": "0",
"status": JOB_MODEL_STATUS.PROCESSING,
"responseid": "2",
"statusdescription": "creating",
"errorcode": "0"}]}}), '200']}
def side_effect(*args):
return mock_vals[args[4]]
mock_call_req.side_effect = side_effect
TerminateNsService(self.nf_inst_id, "forceful", "600", job_id).start()
nsinst = NSInstModel.objects.get(id=self.ns_inst_id)
if nsinst:
self.assertTrue(1, 0)
else:
self.assertTrue(1, 1)
def on_boarding(self):
JobUtil.create_job(
inst_type='nf',
jobaction='on_boarding',
inst_id=self.csar_id,
job_id=self.job_id)
JobUtil.add_job_status(self.job_id, 5, "Start CSAR(%s) onBoarding." % self.csar_id)
self.on_boarding_pre_deal()
self.nf_package_save()
self.need_rollback_when_failed = True
nf_images = self.download_nf_images()
self.upload_nf_images(nf_images)
set_csar_state(self.csar_id, "onBoardState", STATUS_ONBOARDED)
set_csar_state(self.csar_id, "processState", P_STATUS_NORMAL)
set_csar_state(self.csar_id, "operationalState", P_STATUS_ENABLED)
JobUtil.add_job_status(self.job_id, 100, "CSAR(%s) onBoarding successfully." % self.csar_id)
def test_ns_terminate_asynchronous_tasks_when_no_new_progress(
self, mock_request, mock_sleep):
ns_instance_id = 'test_ns_terminate_when_no_new_progress'
NSInstModel(id=ns_instance_id).save()
NfInstModel(ns_inst_id=ns_instance_id).save()
mock_request.side_effect = [
({
'status': '200'
}, '{"jobId": "zzz"}'.encode('utf-8')),
({
'status': '200'
}, '{}'.encode('utf-8')),
({
'status': '200'
}, '{"responseDescriptor": {"progress": 100, "responseId": 1, '
'"statusDescription": ""}}'.encode('utf-8'))
]
mock_sleep.return_value = None
job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.TERMINATE,
ns_instance_id)
TerminateNsService(ns_instance_id, job_id, TERMINATE_NS_DICT).run()
self.assertEqual(
JobModel.objects.filter(jobid=job_id).first().progress,
JOB_PROGRESS.FINISHED)
def delete_csar(self):
JobUtil.create_job(
inst_type='nf',
jobaction='delete',
inst_id=self.csar_id,
job_id=self.job_id)
JobUtil.add_job_status(self.job_id, 5, "Start to delete CSAR(%s)." % self.csar_id)
if query_csar_from_catalog(self.csar_id, "processState") == P_STATUS_DELETING:
JobUtil.add_job_status(self.job_id, 100, "CSAR(%s) is deleting now." % self.csar_id)
return
if NfInstModel.objects.filter(package_id=self.csar_id):
ret = set_csar_state(self.csar_id, "deletionPending", True)
JobUtil.add_job_status(self.job_id, 100, ret[1])
return
NfPackage().delete_csar(self.csar_id, self.job_id)
def test_ns_terminate_asynchronous_tasks_with_none(self):
ns_instance_id = 'test_ns_terminate_002'
job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.TERMINATE,
ns_instance_id)
TerminateNsService(ns_instance_id, job_id, TERMINATE_NS_DICT).run()
self.assertEqual(
JobModel.objects.filter(jobid=job_id).first().progress,
JOB_PROGRESS.FINISHED)
def run(self):
try:
self.verify_config = self.load_config()
JobUtil.create_job("VNF", JOB_TYPE.CREATE_VNF, self.job_id, 'vnfsdk', self.job_id)
self.do_on_boarding()
self.do_inst_vnf()
self.do_func_test()
self.verify_ok = True
except NSLCMException as e:
self.update_job(JOB_ERROR, e.message)
except:
logger.error(traceback.format_exc())
self.update_job(JOB_ERROR, 'Unknown error in vnf verify.')
finally:
logger.warn("Ignore terminate vnf operation")
if self.verify_ok:
self.update_job(100, "Ignore terminate vnf operation.")
def __init__(self, vnf_instance_id, data):
super(NFManualScaleService, self).__init__()
self.vnf_instance_id = vnf_instance_id
self.data = data
self.job_id = JobUtil.create_job(JOB_TYPE.VNF, JOB_ACTION.MANUAL_SCALE,
vnf_instance_id)
self.nf_scale_params = []
self.m_nf_inst_id = ''
self.vnfm_inst_id = ''
def insert_new_ns(self):
ns_inst_id = str(uuid.uuid4())
job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.MANUAL_SCALE,
self.ns_inst_id)
package_id = "23"
NSInstModel(id=ns_inst_id,
name="abc",
nspackage_id=package_id,
nsd_id=package_id).save()
return ns_inst_id, job_id
def __init__(self, vnf_instance_id, data):
super(NFHealService, self).__init__()
self.vnf_instance_id = vnf_instance_id
self.data = data
self.job_id = JobUtil.create_job(JOB_TYPE.VNF, JOB_ACTION.HEAL, vnf_instance_id)
self.nf_model = {}
self.nf_additional_params = {}
self.nf_heal_params = {}
self.m_nf_inst_id = ''
self.vnfm_inst_id = ''
def prepare_create_params():
nf_inst_id = str(uuid.uuid4())
NfInstModel(nfinstid=nf_inst_id,
status=VNF_STATUS.INSTANTIATING,
create_time=now_time(),
lastuptime=now_time()).save()
job_id = JobUtil.create_job(INST_TYPE_NAME.VNF, JOB_TYPE.CREATE_VNF,
nf_inst_id)
JobUtil.add_job_status(job_id, 0, 'create vnf record in database.', 0)
return nf_inst_id, job_id
def __init__(self, vnf_instance_id, data):
super(NFManualScaleService, self).__init__()
self.vnf_instance_id = vnf_instance_id
self.data = data
self.job_id = JobUtil.create_job("NF", JOB_TYPE.MANUAL_SCALE_VNF,
vnf_instance_id)
self.scale_vnf_data = ''
self.nf_model = {}
self.nf_scale_params = []
self.m_nf_inst_id = ''
self.vnfm_inst_id = ''
def prepare_create_params():
nf_inst_id = str(uuid.uuid4())
NfInstModel(nfinstid=nf_inst_id,
status=VNF_STATUS.INSTANTIATING,
create_time=now_time(),
lastuptime=now_time()).save()
job_id = JobUtil.create_job(JOB_TYPE.VNF, JOB_ACTION.CREATE, nf_inst_id)
JobUtil.add_job_status(job_id, JOB_PROGRESS.STARTED,
'create vnf record in database.',
JOB_ERROR_CODE.NO_ERROR)
return nf_inst_id, job_id
def test_terminate_ns_service(self, mock_call_req):
job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.TERMINATE,
self.ns_inst_id)
mock_vals = {
"/api/nslcm/v1/ns/ns_vls/1":
[0, json.JSONEncoder().encode({"jobId": self.job_id}), '200'],
"/api/nslcm/v1/ns/ns_sfcs/1":
[0, json.JSONEncoder().encode({"jobId": self.job_id}), '200'],
"/api/nslcm/v1/ns/ns_vnfs/1":
[0, json.JSONEncoder().encode({}), '200'],
"/api/ztevnfmdriver/v1/jobs/" + self.job_id + "&responseId=0": [
0,
json.JSONEncoder().encode({
"jobid": self.job_id,
"responsedescriptor": {
"progress":
"100",
"status":
JOB_MODEL_STATUS.FINISHED,
"responseid":
"3",
"statusdescription":
"creating",
"errorcode":
"0",
"responsehistorylist": [{
"progress": "0",
"status": JOB_MODEL_STATUS.PROCESSING,
"responseid": "2",
"statusdescription": "creating",
"errorcode": "0"
}]
}
}), '200'
],
"/api/catalog/v1/ns_descriptors/None":
[0, json.JSONEncoder().encode({}), '202'],
}
def side_effect(*args):
return mock_vals[args[4]]
mock_call_req.side_effect = side_effect
req_data = {
"terminationType": "FORCEFUL",
"gracefulTerminationTimeout": "600"
}
TerminateNsService(self.ns_inst_id, job_id, req_data).run()
nsinst = NSInstModel.objects.get(id=self.ns_inst_id)
if nsinst:
self.assertTrue(1, 0)
else:
self.assertTrue(1, 1)
def setUp(self):
self.url = "/api/nslcm/v1/ns_instances/%s/scale"
self.ns_inst_id = str(uuid.uuid4())
self.job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.MANUAL_SCALE,
self.ns_inst_id)
self.package_id = "7"
self.client = APIClient()
NSInstModel(id=self.ns_inst_id,
name="abc",
nspackage_id=self.package_id,
nsd_id="111").save()
def test_heal_vnf_success_reboot(self, mock_call, mock_call_req):
vim_cache = {}
res_cache = {}
NfInstModel.objects.create(nfinstid='1111',
nf_name='2222',
vnfminstid='1',
package_id='todo',
version='',
vendor='',
netype='',
vnfd_model=json.dumps(vnfd_model_dict),
status='INSTANTIATED',
nf_desc='',
vnfdid='',
vnfSoftwareVersion='',
vnfConfigurableProperties='todo',
localizationLanguage='EN_US',
create_time=now_time(),
resInfo=json.dumps(res_cache),
vimInfo=json.dumps(vim_cache))
VmInstModel.objects.create(vmid="1",
vimid="vimid_1",
resourceid="1",
insttype=0,
instid="1111",
vmname="vduinstname",
is_predefined=1,
tenant="tenantname_1",
operationalstate=1)
t1_apply_grant_result = [0, json.JSONEncoder().encode(self.grant_result), '200']
t2_lcm_notify_result = [0, json.JSONEncoder().encode(''), '200']
t3_action_get_vm = [0, json.JSONEncoder().encode(self.getvmResult), '202']
t4_action_vm_start_reboot = [0, json.JSONEncoder().encode(''), '202']
mock_call_req.side_effect = [t1_apply_grant_result, t2_lcm_notify_result, t3_action_get_vm, t4_action_vm_start_reboot]
mock_call.side_effect = [self.getvmResult, None]
req_data = {
"cause": "Error",
"additionalParams": {
"action": "vmReset",
"affectedvm": {
"vmid": "1",
"vduid": "vdu1Id",
"vmname": "vduinstname"
}
}
}
self.nf_inst_id = '1111'
self.job_id = JobUtil.create_job('NF', 'HEAL', self.nf_inst_id)
JobUtil.add_job_status(self.job_id, 0, "HEAL_VNF_READY")
HealVnf(req_data, nf_inst_id=self.nf_inst_id, job_id=self.job_id).run()
self.assert_job_result(self.job_id, 100, "Heal Vnf success.")
def test_instantiate_vnf_when_inst_id_not_exist(self):
self.nf_inst_id = str(uuid.uuid4())
self.job_id = JobUtil.create_job('NF', 'CREATE', self.nf_inst_id)
JobUtil.add_job_status(self.job_id, 0, "INST_VNF_READY")
jobs = JobStatusModel.objects.filter(
jobid=self.job_id,
progress=0,
descp="INST_VNF_READY")
self.assertEqual(1, len(jobs))
data = inst_req_data
InstVnf(data, nf_inst_id=self.nf_inst_id, job_id=self.job_id).run()
self.assert_job_result(self.job_id, 255, "VNF nf_inst_id is not exist.")
def setUp(self):
self.nsd_id = str(uuid.uuid4())
self.ns_package_id = str(uuid.uuid4())
self.ns_inst_id = str(uuid.uuid4())
self.job_id = JobUtil.create_job("NS", JOB_TYPE.MANUAL_SCALE_VNF,
self.ns_inst_id)
NSDModel(id=self.ns_package_id, nsd_id=self.nsd_id, name='name').save()
self.client = Client()
self.context = '{"vnfs": ["a", "b"], "sfcs": ["c"], "vls": ["d", "e", "f"]}'
NSInstModel(id=self.ns_inst_id,
name="abc",
nspackage_id="7",
nsd_id="111").save()
def post(self, request_paras, vnfinstid):
logger.debug("VnfTerminateView--post::> %s, %s", vnfinstid, request_paras.data)
vnf_inst_id = vnfinstid
terminationType = ignore_case_get(request_paras.data, 'terminationType')
gracefulTerminationTimeout = ignore_case_get(request_paras.data, 'gracefulTerminationTimeout')
job_id = JobUtil.create_job("VNF", JOB_TYPE.TERMINATE_VNF, vnf_inst_id)
data = {'terminationType': terminationType, 'gracefulTerminationTimeout': gracefulTerminationTimeout}
logger.debug("data=%s", data)
try:
TerminateVnfs(data, vnf_inst_id, job_id).start()
except Exception as e:
return Response(data={'error': '%s' % e.message}, status=status.HTTP_409_CONFLICT)
rsp = {'jobId': job_id}
return Response(data=rsp, status=status.HTTP_201_CREATED)
def post(self, request, ns_instance_id):
logger.debug("Enter UpdateNSView::post %s, %s", request.data, ns_instance_id)
req_serializer = UpdateNsReqSerializer(data=request.data)
if not req_serializer.is_valid():
raise BadRequestException(req_serializer.errors)
job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.UPDATE, ns_instance_id)
NSUpdateService(ns_instance_id, request.data, job_id).start()
resp_serializer = _NsOperateJobSerializer(data={'jobId': job_id})
if not resp_serializer.is_valid():
raise NSLCMException(resp_serializer.errors)
logger.debug("Leave UpdateNSView::post ret=%s", {'jobId': job_id})
return Response(data={'jobId': job_id}, status=status.HTTP_202_ACCEPTED)
