def post(self, request):
logger.debug("Enter CreateNS: %s", request.data)
req_serializer = _CreateNsReqSerializer(data=request.data)
if not req_serializer.is_valid():
raise BadRequestException(req_serializer.errors)
if ignore_case_get(request.data, 'test') == "test":
return Response(data={'nsInstanceId': "test"},
status=status.HTTP_201_CREATED)
csar_id = ignore_case_get(request.data, 'csarId')
ns_name = ignore_case_get(request.data, 'nsName')
description = ignore_case_get(request.data, 'description')
context = ignore_case_get(request.data, 'context')
ns_inst_id = CreateNSService(csar_id, ns_name, description,
context).do_biz()
logger.debug("CreateNSView::post::ret={'nsInstanceId':%s}", ns_inst_id)
ret = {
'nsInstanceId': ns_inst_id,
'nsInstanceName': 'nsInstanceName',
'nsInstanceDescription': 'nsInstanceDescription',
'nsdId': 123,
'nsdInfoId': 456,
'nsState': 'NOT_INSTANTIATED',
'_links': {
'self': {
'href': 'href'
}
}
}
resp_serializer = _CreateNsRespSerializer(data=ret)
if not resp_serializer.is_valid():
raise NSLCMException(resp_serializer.errors)
return Response(data=ret, status=status.HTTP_201_CREATED)
def post(self, request, vnfinstid):
logger.debug("NfScaleView--post::> %s" % request.data)
try:
req_serializer = ScaleVnfReqSerializer(data=request.data)
if not req_serializer.is_valid():
raise BadRequestException(req_serializer.errors)
NFManualScaleService(vnfinstid, request.data).start()
return Response(data={}, status=status.HTTP_202_ACCEPTED)
except Exception as e:
logger.error(e.args[0])
return Response(data={'error': '%s' % e.args[0]}, status=status.HTTP_409_CONFLICT)
def post(self, request, ns_instance_id):
logger.debug("Enter NSInstView::post::ns_instance_id=%s",
ns_instance_id)
logger.debug("request.data=%s", request.data)
req_serializer = _InstantNsReqSerializer(data=request.data)
if not req_serializer.is_valid():
logger.debug("request.data is not valid,error: %s" %
req_serializer.errors)
raise BadRequestException(req_serializer.errors)
ack = InstantNSService(ns_instance_id, request.data).do_biz()
logger.debug("Leave NSInstView::post::ack=%s", ack)
return Response(data=ack['data'], status=ack['status'])
def post(self, request, job_id):
try:
logger.debug("Enter JobView:post, job_id=%s, request=%s", job_id,
request.data)
req_serializer = JobUpdReqSerializer(data=request.data)
if not req_serializer.is_valid():
raise BadRequestException(req_serializer.errors)
jobs = JobUtil.query_job_status(job_id)
if not jobs:
raise BadRequestException("Job(%s) does not exist." % job_id)
if jobs[-1].errcode != JOB_ERROR_CODE.ERROR:
job_up_req = JobUpdReq(**request.data)
desc = job_up_req.desc
no_err_list = ('true', 'active', '0')
err_code = JOB_ERROR_CODE.NO_ERROR if job_up_req.errcode in no_err_list else JOB_ERROR_CODE.ERROR
logger.debug("errcode=%s", err_code)
JobUtil.add_job_status(job_id,
job_up_req.progress,
desc,
error_code=err_code)
job_update_resp = JobUpdResp('ok')
resp_serializer = JobUpdRespSerializer(job_update_resp)
logger.debug("Leave JobView::post, response=%s", job_update_resp)
return Response(data=resp_serializer.data,
status=status.HTTP_202_ACCEPTED)
except BadRequestException as e:
job_update_resp = JobUpdResp('error', e.args[0])
resp_serializer = JobUpdRespSerializer(job_update_resp)
return Response(data=resp_serializer.data,
status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
job_update_resp = JobUpdResp('error', e.args[0])
resp_serializer = JobUpdRespSerializer(job_update_resp)
return Response(data=resp_serializer.data,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
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)
def post(self, request):
logger.debug(
"Enter NSInstancesView::POST ns_instances: Header:%s, Body: %s" %
(request.META, request.data))
globalCustomerId = request.META.get("HTTP_GLOBALCUSTOMERID", None)
if not globalCustomerId:
raise BadRequestException("Not found globalCustomerId in header")
serviceType = request.META.get("HTTP_SERVICETYPE", None)
if not serviceType:
serviceType = "NetworkService"
req_serializer = CreateNsRequestSerializer(data=request.data)
if not req_serializer.is_valid():
raise BadRequestException(req_serializer.errors)
if ignore_case_get(request.data, 'test') == "test":
return Response(data={'nsInstanceId': "test"},
status=status.HTTP_201_CREATED)
csar_id = ignore_case_get(request.data, 'nsdId')
ns_name = ignore_case_get(request.data, 'nsName')
description = ignore_case_get(request.data, 'nsDescription')
context = {
"globalCustomerId": globalCustomerId,
"serviceType": serviceType
}
ns_inst_id = CreateNSService(csar_id, ns_name, description,
context).do_biz()
logger.debug("CreateNSView::post::ret={'nsInstanceId':%s}", ns_inst_id)
ns_filter = {"ns_inst_id": ns_inst_id}
nsInstance = GetNSInfoService(ns_filter).get_ns_info(is_sol=True)[0]
logger.debug("nsInstance: %s" % nsInstance)
resp_serializer = NsInstanceSerializer(data=nsInstance)
if not resp_serializer.is_valid():
raise NSLCMException(resp_serializer.errors)
response = Response(data=nsInstance, status=status.HTTP_201_CREATED)
response["Location"] = NS_INSTANCE_BASE_URI % nsInstance['id']
return response
def post(self, request):
job_id = "VNFSDK_" + str(uuid.uuid4())
logger.debug("NfVerifyView--post::%s> %s", job_id, request.data)
try:
req_serializer = VerifyVnfReqSerializer(data=request.data)
if not req_serializer.is_valid():
raise BadRequestException(req_serializer.errors)
VerifyVnfs(request.data, job_id).start()
rsp = {"jobId": job_id}
resp_serializer = VerifyVnfRespSerializer(data=rsp)
if not resp_serializer.is_valid():
raise Exception(resp_serializer.errors)
return Response(data=rsp, status=status.HTTP_202_ACCEPTED)
except Exception as e:
logger.error(e.args[0])
return Response(data={'error': '%s' % e.args[0]}, status=status.HTTP_409_CONFLICT)
def post(self, request, ns_instance_id):
job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.UPDATE,
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():
logger.debug("request.data is not valid,error: %s" %
req_serializer.errors)
raise BadRequestException(req_serializer.errors)
ns_update_service = NSUpdateService(ns_instance_id, request.data,
job_id)
ns_update_service.start()
response = Response(data={}, status=status.HTTP_202_ACCEPTED)
logger.debug("Location: %s" % ns_update_service.occ_id)
response["Location"] = NS_OCC_BASE_URI % ns_update_service.occ_id
logger.debug("Leave UpdateNSView")
return response
def post(self, request, ns_instance_id):
logger.debug(
"Enter HealNSView::post nsInstanceId:%s, request.data:%s" %
(ns_instance_id, request.data))
req_serializer = HealNsReqSerializer(data=request.data)
if not req_serializer.is_valid():
logger.error("request.data is not valid,error: %s" %
req_serializer.errors)
raise BadRequestException(req_serializer.errors)
job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.HEAL,
ns_instance_id)
ns_heal_service = NSHealService(ns_instance_id, request.data, job_id)
ns_heal_service.start()
response = Response(data={}, status=status.HTTP_202_ACCEPTED)
logger.debug("Location: %s" % ns_heal_service.occ_id)
response["Location"] = NS_OCC_BASE_URI % ns_heal_service.occ_id
logger.debug("Leave NSHealView")
return response
def post(self, request, ns_instance_id):
logger.debug("Enter ScaleNSView::post %s, %s", request.data,
ns_instance_id)
req_serializer = ScaleNsRequestSerializer(data=request.data)
if not req_serializer.is_valid():
raise BadRequestException(req_serializer.errors)
job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.MANUAL_SCALE,
ns_instance_id)
nsManualScaleService = NSManualScaleService(ns_instance_id,
request.data, job_id)
nsManualScaleService.start()
response = Response(data={}, status=status.HTTP_202_ACCEPTED)
logger.debug("Location: %s" % nsManualScaleService.occ_id)
response["Location"] = NS_OCC_BASE_URI % nsManualScaleService.occ_id
logger.debug("Leave ScaleNSView")
return response
def post(self, request):
try:
logger.info("Create Service Function Chain start")
logger.info("service_function_chain_request: %s" % json.dumps(request.data))
logger.info("service_function_chain_context : %s" % json.dumps(request.data['context']))
logger.info("service_function_chain_context : %s" % request.data['context'])
logger.info("service_function_chain_instanceid : %s" % ignorcase_get(request.data, 'nsInstanceId'))
logger.info("service_function_chain_sdncontrollerid : %s" % ignorcase_get(request.data, 'sdnControllerId'))
logger.info("service_function_chain_fpindex : %s" % ignorcase_get(request.data, 'fpindex'))
req_serializer = CreateSfcReqSerializer(data=request.data)
if not req_serializer.is_valid():
raise BadRequestException(req_serializer.errors)
except Exception as e:
logger.error("Exception occurs: %s", e.args[0])
logger.error(traceback.format_exc())
ns_model_data = json.loads(request.data['context'])
data = {
'nsinstid': ignorcase_get(request.data, 'nsInstanceId'),
"ns_model_data": ns_model_data,
'fpindex': get_fp_id(ignorcase_get(request.data, 'fpindex'), ns_model_data),
'fpinstid': str(uuid.uuid4()),
'sdncontrollerid': ignorcase_get(request.data, 'sdnControllerId')
}
logger.info("Save FPInstModel start: ")
SfcInstance(data).do_biz()
logger.info("Save FPInstModel end: ")
worker = CreateSfcWorker(data)
job_id = worker.init_data()
worker.start()
logger.info("Service Function Chain Thread Sleep start : %s" % time.ctime())
time.sleep(2)
logger.info("Service Function Chain Thread Sleep end: %s" % time.ctime())
logger.info("Create Service Function Chain end")
resp_serializer = CreateSfcRespSerializer(data={"jobId": job_id, "sfcInstId": data["fpinstid"]})
if not resp_serializer.is_valid():
logger.error(resp_serializer.errors)
return Response(data={"jobId": job_id, "sfcInstId": data["fpinstid"]}, status=status.HTTP_200_OK)
def post(self, request, ns_instance_id):
logger.debug("Enter NSInstPostDealView::post %s, %s", request.data,
ns_instance_id)
ns_post_status = ignore_case_get(request.data, 'status')
ns_status = NS_INST_STATUS.ACTIVE if ns_post_status == 'true' else NS_INST_STATUS.FAILED
ns_opr_status = 'success' if ns_post_status == 'true' else 'failed'
try:
req_serializer = _InstNsPostDealReqSerializer(data=request.data)
if not req_serializer.is_valid():
raise BadRequestException(req_serializer.errors)
NSInstModel.objects.filter(id=ns_instance_id).update(
status=ns_status)
ServiceBaseInfoModel.objects.filter(
service_id=ns_instance_id).update(active_status=ns_status,
status=ns_opr_status)
nsd_info = NSInstModel.objects.filter(id=ns_instance_id)
nsd_id = nsd_info[0].nsd_id
nsd_model = json.loads(nsd_info[0].nsd_model)
if "policies" in nsd_model and nsd_model["policies"]:
policy = nsd_model["policies"][0]
if "properties" in policy and policy["properties"]:
file_url = ignore_case_get(policy["properties"][0],
"drl_file_url")
else:
file_url = ""
self.send_policy_request(ns_instance_id, nsd_id, file_url)
except:
logger.error(traceback.format_exc())
return Response(data={
'error':
'Failed to update status of NS(%s)' % ns_instance_id
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
logger.debug("*****NS INST %s, %s******", ns_status, ns_opr_status)
return Response(data={
'success':
'Update status of NS(%s) to %s' % (ns_instance_id, ns_status)
},
status=status.HTTP_202_ACCEPTED)
def post(self, request):
try:
req_serializer = CreateSfcInstReqSerializer(data=request.data)
if not req_serializer.is_valid():
raise BadRequestException(req_serializer.errors)
data = {
'nsinstid': request.data['nsInstanceId'],
"ns_model_data": json.loads(request.data['context']),
'fpindex': request.data['fpindex'],
'fpinstid': str(uuid.uuid4()),
'sdncontrollerid': request.data["sdnControllerId"]}
rsp = SfcInstance(data).do_biz()
resp_serializer = CreateSfcInstRespSerializer(data=rsp)
if not resp_serializer.is_valid():
raise NSLCMException(resp_serializer.errors)
return Response(data=rsp, status=status.HTTP_200_OK)
except Exception as e:
logger.error(traceback.format_exc())
return Response(data={'error': e.args[0]}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def post(self, request, ns_instance_id):
job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.TERMINATE,
ns_instance_id)
logger.debug("Enter TerminateNSView::post %s", request.data)
req_serializer = TerminateNsReqSerializer(data=request.data)
if not req_serializer.is_valid():
logger.debug("request.data is not valid,error: %s" %
req_serializer.errors)
raise BadRequestException(req_serializer.errors)
termination_time = ignore_case_get(request.data, 'terminationTime')
logger.debug("terminationTime is %s" % termination_time)
# todo terminationTime
terminate_ns_service = TerminateNsService(ns_instance_id, job_id,
request.data)
terminate_ns_service.start()
logger.debug("Location: %s" % terminate_ns_service.occ_id)
response = Response(data={'jobId': job_id},
status=status.HTTP_202_ACCEPTED)
response["Location"] = NS_OCC_BASE_URI % terminate_ns_service.occ_id
logger.debug("Leave TerminateNSView")
return response
def post(self, request):
logger.debug("SubscribeNotification--post::> %s" % request.data)
lccn_subscription_request_serializer = LccnSubscriptionRequestSerializer(
data=request.data)
if not lccn_subscription_request_serializer.is_valid():
raise BadRequestException(
lccn_subscription_request_serializer.errors)
subscription = CreateSubscription(
lccn_subscription_request_serializer.data).do_biz()
lccn_notifications_filter = {
"notificationTypes":
ast.literal_eval(subscription.notification_types),
"operationTypes":
ast.literal_eval(subscription.operation_types),
"operationStates":
ast.literal_eval(subscription.operation_states),
"nsInstanceSubscriptionFilter":
json.loads(subscription.ns_instance_filter),
"nsComponentTypes":
ast.literal_eval(subscription.ns_component_types),
"lcmOpNameImpactingNsComponent":
ast.literal_eval(subscription.lcm_opname_impacting_nscomponent),
"lcmOpOccStatusImpactingNsComponent":
ast.literal_eval(
subscription.lcm_opoccstatus_impacting_nscomponent)
}
subscription_data = {
"id": subscription.subscription_id,
"callbackUri": subscription.callback_uri,
"_links": json.loads(subscription.links),
"filter": lccn_notifications_filter
}
sub_resp_serializer = LccnSubscriptionSerializer(
data=subscription_data)
if not sub_resp_serializer.is_valid():
raise NSLCMException(sub_resp_serializer.errors)
return Response(data=subscription_data, status=status.HTTP_201_CREATED)
def post(self, request, ns_instance_id):
logger.debug("Enter NSManualScaleView::post %s, %s", request.data,
ns_instance_id)
req_serializer = _ManualScaleNsReqSerializer(data=request.data)
if not req_serializer.is_valid():
raise BadRequestException(req_serializer.errors)
req = request.data
scale_data = {}
scale_data['scaleType'] = req['scaleType']
scaleNsData = req['scaleNsData'][0]
scale_data['scaleNsData'] = {
"scaleNsByStepsData": scaleNsData['scaleNsByStepsData'][0]
}
job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.MANUAL_SCALE,
ns_instance_id)
NSManualScaleService(ns_instance_id, scale_data, job_id).start()
resp_serializer = _NsOperateJobSerializer(data={'jobId': job_id})
if not resp_serializer.is_valid():
raise NSLCMException(resp_serializer.errors)
return Response(data={'jobId': job_id},
status=status.HTTP_202_ACCEPTED)