Replaced all tabs with spaces in java and pom.xml
[so.git] / adapters / mso-vfc-adapter / src / main / java / org / onap / so / adapters / vfc / rest / VfcManager.java
1 /*-
2  * ============LICENSE_START=======================================================
3  * ONAP - SO
4  * ================================================================================
5  * Copyright (C) 2017 Huawei Technologies Co., Ltd. All rights reserved.
6  * ================================================================================
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  * 
11  *      http://www.apache.org/licenses/LICENSE-2.0
12  * 
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  * ============LICENSE_END=========================================================
19  */
20
21 package org.onap.so.adapters.vfc.rest;
22
23 import java.util.HashMap;
24 import java.util.Map;
25 import org.onap.so.adapters.vfc.constant.CommonConstant;
26 import org.onap.so.adapters.vfc.constant.CommonConstant.Step;
27 import org.onap.so.adapters.vfc.constant.DriverExceptionID;
28 import org.onap.so.adapters.vfc.constant.HttpCode;
29 import org.onap.so.adapters.vfc.exceptions.ApplicationException;
30 import org.onap.so.adapters.vfc.model.CustomerModel;
31 import org.onap.so.adapters.vfc.model.NSResourceInputParameter;
32 import org.onap.so.adapters.vfc.model.NsCreateReq;
33 import org.onap.so.adapters.vfc.model.NsInstantiateReq;
34 import org.onap.so.adapters.vfc.model.NsOperationKey;
35 import org.onap.so.adapters.vfc.model.NsParameters;
36 import org.onap.so.adapters.vfc.model.NsProgressStatus;
37 import org.onap.so.adapters.vfc.model.NsScaleParameters;
38 import org.onap.so.adapters.vfc.model.ResponseDescriptor;
39 import org.onap.so.adapters.vfc.model.RestfulResponse;
40 import org.onap.so.adapters.vfc.model.VFCScaleData;
41 import org.onap.so.adapters.vfc.util.JsonUtil;
42 import org.onap.so.adapters.vfc.util.RestfulUtil;
43 import org.onap.so.adapters.vfc.util.ValidateUtil;
44 import org.onap.so.db.request.beans.ResourceOperationStatus;
45 import org.onap.so.db.request.data.repository.ResourceOperationStatusRepository;
46 import org.onap.so.requestsdb.RequestsDbConstant;
47 import org.slf4j.Logger;
48 import org.slf4j.LoggerFactory;
49 import org.springframework.beans.factory.annotation.Autowired;
50 import org.springframework.context.annotation.Primary;
51 import org.springframework.data.domain.Example;
52 import org.springframework.stereotype.Component;
53
54 /**
55  * VF-C Manager <br>
56  * <p>
57  * </p>
58  * 
59  * @author
60  * @version ONAP Amsterdam Release 2017-08-28
61  */
62 @Component
63 @Primary
64 public class VfcManager {
65
66     private static final Logger LOGGER = LoggerFactory.getLogger(VfcManager.class);
67
68     /**
69      * nfvo url map
70      */
71     private Map<String, String> nfvoUrlMap;
72
73     @Autowired
74     private ResourceOperationStatusRepository resourceOperationStatusRepository;
75
76     @Autowired
77     private RestfulUtil restfulUtil;
78
79
80     public VfcManager() {
81         nfvoUrlMap = new HashMap<>();
82         nfvoUrlMap.put(Step.CREATE, CommonConstant.NFVO_CREATE_URL);
83         nfvoUrlMap.put(Step.INSTANTIATE, CommonConstant.NFVO_INSTANTIATE_URL);
84         nfvoUrlMap.put(Step.TERMINATE, CommonConstant.NFVO_TERMINATE_URL);
85         nfvoUrlMap.put(Step.DELETE, CommonConstant.NFVO_DELETE_URL);
86         nfvoUrlMap.put(Step.QUERY, CommonConstant.NFVO_QUERY_URL);
87         nfvoUrlMap.put(Step.SCALE, CommonConstant.NFVO_SCALE_URL);
88     }
89
90     /**
91      * create network service <br>
92      * 
93      * @param segInput input parameters for current node from http request
94      * @return
95      * @since ONAP Amsterdam Release
96      */
97     public RestfulResponse createNs(NSResourceInputParameter segInput) throws ApplicationException {
98
99         // Step1: get service template by node type
100         String csarId = segInput.getNsServiceModelUUID();
101         // nsdId for NFVO is "id" in the response, while for SDNO is "servcice template id"
102         LOGGER.info("serviceTemplateId is {}, id is {}", csarId, csarId);
103
104         LOGGER.info("create ns -> begin");
105         // Step2: Prepare url and method type
106         String url = getUrl(null, CommonConstant.Step.CREATE);
107         String methodType = CommonConstant.MethodType.POST;
108
109         // Step3: Prepare restful parameters and options
110         NsCreateReq oRequest = new NsCreateReq();
111         oRequest.setCsarId(csarId);
112         oRequest.setNsName(segInput.getNsServiceName());
113         oRequest.setDescription(segInput.getNsServiceDescription());
114         CustomerModel context = new CustomerModel();
115         context.setGlobalCustomerId(segInput.getNsOperationKey().getGlobalSubscriberId());
116         context.setServiceType(segInput.getNsOperationKey().getServiceType());
117         oRequest.setContext(context);
118         String createReq = JsonUtil.marshal(oRequest);
119
120         // Step4: Call NFVO or SDNO lcm to create ns
121         RestfulResponse createRsp = restfulUtil.send(url, methodType, createReq);
122         ValidateUtil.assertObjectNotNull(createRsp);
123         LOGGER.info("create ns response status is : {}", createRsp.getStatus());
124         LOGGER.info("create ns response content is : {}", createRsp.getResponseContent());
125
126         // Step 5: save resource operation information
127         ResourceOperationStatus status = new ResourceOperationStatus(segInput.getNsOperationKey().getServiceId(),
128                 segInput.getNsOperationKey().getOperationId(), segInput.getNsOperationKey().getNodeTemplateUUID());
129         status.setStatus(RequestsDbConstant.Status.PROCESSING);
130         status = resourceOperationStatusRepository.save(status);
131         if (!HttpCode.isSucess(createRsp.getStatus())) {
132             LOGGER.error("update segment operation status : fail to create ns");
133             status.setProgress("40");
134             status.setStatusDescription("NS is created");
135             status.setStatus(RequestsDbConstant.Status.ERROR);
136             status.setErrorCode(String.valueOf(createRsp.getStatus()));
137             resourceOperationStatusRepository.save(status);
138             throw new ApplicationException(HttpCode.INTERNAL_SERVER_ERROR, DriverExceptionID.FAIL_TO_CREATE_NS);
139         }
140         @SuppressWarnings("unchecked")
141         Map<String, String> rsp = JsonUtil.unMarshal(createRsp.getResponseContent(), Map.class);
142         String nsInstanceId = rsp.get(CommonConstant.NS_INSTANCE_ID);
143         if (ValidateUtil.isStrEmpty(nsInstanceId)) {
144             LOGGER.error("Invalid instanceId from create operation");
145             throw new ApplicationException(HttpCode.INTERNAL_SERVER_ERROR,
146                     DriverExceptionID.INVALID_RESPONSEE_FROM_CREATE_OPERATION);
147         }
148         LOGGER.info("create ns -> end");
149         LOGGER.info("save segment and operaton info -> begin");
150         // Step 6: add relation between service and NS
151         AaiUtil.addRelation(segInput.getNsOperationKey().getGlobalSubscriberId(),
152                 segInput.getNsOperationKey().getServiceType(), segInput.getNsOperationKey().getServiceId(),
153                 nsInstanceId);
154         LOGGER.info("save segment and operation info -> end");
155         return createRsp;
156     }
157
158     /**
159      * delete network service <br>
160      * 
161      * @param nsOperationKey The operation key of the NS resource
162      * @param nsInstanceId The NS instance id
163      * @return
164      * @since ONAP Amsterdam Release
165      */
166     public RestfulResponse deleteNs(NsOperationKey nsOperationKey, String nsInstanceId) throws ApplicationException {
167         LOGGER.info("delete ns -> begin");
168         // Step1: prepare url and methodType
169         String url = getUrl(nsInstanceId, CommonConstant.Step.DELETE);
170         String methodType = CommonConstant.MethodType.DELETE;
171
172         // Step2: prepare restful parameters and options
173         RestfulResponse deleteRsp = restfulUtil.send(url, methodType, "");
174         ValidateUtil.assertObjectNotNull(deleteRsp);
175         LOGGER.info("delete ns response status is : {}", deleteRsp.getStatus());
176         LOGGER.info("delete ns response content is : {}", deleteRsp.getResponseContent());
177         LOGGER.info("delete ns -> end");
178
179         ResourceOperationStatus status = new ResourceOperationStatus(nsOperationKey.getServiceId(),
180                 nsOperationKey.getOperationId(), nsOperationKey.getNodeTemplateUUID());
181         if (!HttpCode.isSucess(deleteRsp.getStatus())) {
182             LOGGER.error("fail to delete ns");
183
184             status.setStatus(RequestsDbConstant.Status.ERROR);
185             status.setErrorCode(String.valueOf(deleteRsp.getStatus()));
186             status.setStatusDescription(CommonConstant.StatusDesc.TERMINATE_NS_FAILED);
187             resourceOperationStatusRepository.save(status);
188             throw new ApplicationException(HttpCode.INTERNAL_SERVER_ERROR, DriverExceptionID.FAIL_TO_DELETE_NS);
189         }
190
191         // Step3: remove relation info between service and ns
192         AaiUtil.removeRelation(nsOperationKey.getGlobalSubscriberId(), nsOperationKey.getServiceType(),
193                 nsOperationKey.getServiceId(), nsInstanceId);
194         LOGGER.info("delete segment information -> end");
195
196         // Step4: update service segment operation status
197         status.setStatus(RequestsDbConstant.Status.FINISHED);
198         status.setErrorCode(String.valueOf(deleteRsp.getStatus()));
199         status.setProgress("100");
200         status.setStatusDescription("VFC resource deletion finished");
201         resourceOperationStatusRepository.save(status);
202         LOGGER.info("update segment operaton status for delete -> end");
203
204         return deleteRsp;
205
206     }
207
208     /**
209      * instantiate network service <br>
210      * 
211      * @param nsInstanceId The NS instance id
212      * @param segInput input parameters for current node from http request
213      * @return
214      * @since ONAP Amsterdam Release
215      */
216     public RestfulResponse instantiateNs(String nsInstanceId, NSResourceInputParameter segInput)
217             throws ApplicationException {
218         // Call the NFVO or SDNO service to instantiate service
219         LOGGER.info("instantiate ns -> begin");
220
221         // Step1: Prepare restful parameters and options
222         NsInstantiateReq oRequest = new NsInstantiateReq();
223         oRequest.setNsInstanceId(nsInstanceId);
224         NsParameters nsParameters = segInput.getNsParameters();
225         oRequest.setLocationConstraints(nsParameters.getLocationConstraints());
226         oRequest.setAdditionalParamForNs(nsParameters.getAdditionalParamForNs());
227         String instReq = JsonUtil.marshal(oRequest);
228         // Step2: prepare url and
229         String url = getUrl(nsInstanceId, CommonConstant.Step.INSTANTIATE);
230         String methodType = CommonConstant.MethodType.POST;
231
232         RestfulResponse instRsp = restfulUtil.send(url, methodType, instReq);
233         ResourceOperationStatus status = new ResourceOperationStatus(segInput.getNsOperationKey().getServiceId(),
234                 segInput.getNsOperationKey().getOperationId(), segInput.getNsOperationKey().getNodeTemplateUUID());
235         ValidateUtil.assertObjectNotNull(instRsp);
236         if (!HttpCode.isSucess(instRsp.getStatus())) {
237             LOGGER.error("update segment operation status : fail to instantiate ns");
238             status.setStatus(RequestsDbConstant.Status.ERROR);
239             status.setErrorCode(String.valueOf(instRsp.getStatus()));
240             status.setStatusDescription(CommonConstant.StatusDesc.INSTANTIATE_NS_FAILED);
241             resourceOperationStatusRepository.save(status);
242             throw new ApplicationException(HttpCode.INTERNAL_SERVER_ERROR, DriverExceptionID.FAIL_TO_INSTANTIATE_NS);
243         }
244         LOGGER.info("instantiate ns response status is : {}", instRsp.getStatus());
245         LOGGER.info("instantiate ns response content is : {}", instRsp.getResponseContent());
246         ValidateUtil.assertObjectNotNull(instRsp.getResponseContent());
247         @SuppressWarnings("unchecked")
248         Map<String, String> rsp = JsonUtil.unMarshal(instRsp.getResponseContent(), Map.class);
249         String jobId = rsp.get(CommonConstant.JOB_ID);
250         if (ValidateUtil.isStrEmpty(jobId)) {
251             LOGGER.error("Invalid jobId from instantiate operation");
252             status.setStatus(RequestsDbConstant.Status.ERROR);
253             status.setErrorCode(String.valueOf(instRsp.getStatus()));
254             status.setStatusDescription(CommonConstant.StatusDesc.INSTANTIATE_NS_FAILED);
255             resourceOperationStatusRepository.save(status);
256             throw new ApplicationException(HttpCode.INTERNAL_SERVER_ERROR,
257                     DriverExceptionID.INVALID_RESPONSE_FROM_INSTANTIATE_OPERATION);
258         }
259         LOGGER.info("instantiate ns -> end");
260         // Step 3: update segment operation job id
261         LOGGER.info("update resource operation status job id -> begin");
262         status.setJobId(jobId);
263         status.setProgress("100");
264         status.setStatusDescription("NS initiation completed.");
265         resourceOperationStatusRepository.save(status);
266         LOGGER.info("update segment operation job id -> end");
267
268         return instRsp;
269     }
270
271     /**
272      * terminate network service <br>
273      * 
274      * @param nsOperationKey The operation key for NS resource
275      * @param nsInstanceId The NS instance id
276      * @return
277      * @since ONAP Amsterdam Release
278      */
279     public RestfulResponse terminateNs(NsOperationKey nsOperationKey, String nsInstanceId) throws ApplicationException {
280         // Step1: save segment operation info for delete process
281         LOGGER.info("save segment operation for delete process");
282         ResourceOperationStatus status = new ResourceOperationStatus(nsOperationKey.getServiceId(),
283                 nsOperationKey.getOperationId(), nsOperationKey.getNodeTemplateUUID());
284         status.setStatus(RequestsDbConstant.Status.PROCESSING);
285         resourceOperationStatusRepository.save(status);
286
287         LOGGER.info("terminate ns -> begin");
288         // Step2: prepare url and method type
289         String url = getUrl(nsInstanceId, CommonConstant.Step.TERMINATE);
290         String methodType = CommonConstant.MethodType.POST;
291
292         // Step3: prepare restful parameters and options
293         Map<String, String> reqBody = new HashMap<>();
294         reqBody.put("nsInstanceId", nsInstanceId);
295         reqBody.put("terminationType", "graceful");
296         reqBody.put("gracefulTerminationTimeout", "60");
297
298         // Step4: Call the NFVO or SDNO service to terminate service
299         RestfulResponse terminateRsp = restfulUtil.send(url, methodType, JsonUtil.marshal(reqBody));
300         ValidateUtil.assertObjectNotNull(terminateRsp);
301         LOGGER.info("terminate ns response status is : {}", terminateRsp.getStatus());
302         LOGGER.info("terminate ns response content is : {}", terminateRsp.getResponseContent());
303         // Step 3: update segment operation
304         if (!HttpCode.isSucess(terminateRsp.getStatus())) {
305             LOGGER.error("fail to instantiate ns");
306             status.setStatus(RequestsDbConstant.Status.ERROR);
307             status.setErrorCode(String.valueOf(terminateRsp.getStatus()));
308             status.setStatusDescription(CommonConstant.StatusDesc.TERMINATE_NS_FAILED);
309             resourceOperationStatusRepository.save(status);
310
311             throw new ApplicationException(HttpCode.INTERNAL_SERVER_ERROR, DriverExceptionID.FAIL_TO_TERMINATE_NS);
312         }
313         @SuppressWarnings("unchecked")
314         Map<String, String> rsp = JsonUtil.unMarshal(terminateRsp.getResponseContent(), Map.class);
315         String jobId = rsp.get(CommonConstant.JOB_ID);
316         if (ValidateUtil.isStrEmpty(jobId)) {
317             LOGGER.error("Invalid jobId from terminate operation");
318             status.setStatus(RequestsDbConstant.Status.ERROR);
319             status.setErrorCode(String.valueOf(terminateRsp.getStatus()));
320             status.setStatusDescription(CommonConstant.StatusDesc.TERMINATE_NS_FAILED);
321             resourceOperationStatusRepository.save(status);
322             throw new ApplicationException(HttpCode.INTERNAL_SERVER_ERROR,
323                     DriverExceptionID.INVALID_RESPONSE_FROM_TERMINATE_OPERATION);
324         }
325         LOGGER.info("terminate ns -> end");
326
327         LOGGER.info("update segment job id -> begin");
328         status.setProgress("60");
329         status.setStatusDescription("NS is termination completed");
330         status.setJobId(jobId);
331         resourceOperationStatusRepository.save(status);
332         LOGGER.info("update segment job id -> end");
333
334         return terminateRsp;
335     }
336
337     /**
338      * get ns progress by job Id <br>
339      * 
340      * @param nsOperationKey The OperationKey for NS resource
341      * @param jobId the job id
342      * @return
343      * @since ONAP Amsterdam Release
344      */
345     public RestfulResponse getNsProgress(NsOperationKey nsOperationKey, String jobId) throws ApplicationException {
346
347         ValidateUtil.assertObjectNotNull(jobId);
348         // Step 1: query the current resource operation status
349         ResourceOperationStatus status = new ResourceOperationStatus(nsOperationKey.getServiceId(),
350                 nsOperationKey.getOperationId(), nsOperationKey.getNodeTemplateUUID());
351         status = resourceOperationStatusRepository.findOne(Example.of(status))
352                 .orElseThrow(() -> new ApplicationException(404, "Cannot Find Operation Status"));
353         // Step 2: start query
354         LOGGER.info("query ns status -> begin");
355         String url = getUrl(jobId, CommonConstant.Step.QUERY);
356         String methodType = CommonConstant.MethodType.GET;
357         // prepare restful parameters and options
358         RestfulResponse rsp = restfulUtil.send(url, methodType, "");
359         ValidateUtil.assertObjectNotNull(rsp);
360         LOGGER.info("query ns progress response status is : {}", rsp.getStatus());
361         LOGGER.info("query ns progress response content is : {}", rsp.getResponseContent());
362         // Step 3:check the response staus
363         if (!HttpCode.isSucess(rsp.getStatus())) {
364             LOGGER.info("fail to query job status");
365             status.setErrorCode(String.valueOf(rsp.getStatus()));
366             status.setStatus(RequestsDbConstant.Status.ERROR);
367             status.setStatusDescription(CommonConstant.StatusDesc.QUERY_JOB_STATUS_FAILED);
368             resourceOperationStatusRepository.save(status);
369             throw new ApplicationException(HttpCode.INTERNAL_SERVER_ERROR, DriverExceptionID.FAIL_TO_QUERY_JOB_STATUS);
370         }
371         // Step 4: Process Network Service Instantiate Response
372         NsProgressStatus nsProgress = JsonUtil.unMarshal(rsp.getResponseContent(), NsProgressStatus.class);
373         ResponseDescriptor rspDesc = nsProgress.getResponseDescriptor();
374         // Step 5: update segment operation progress
375
376         status.setProgress(rspDesc.getProgress());
377         status.setStatusDescription(rspDesc.getStatusDescription());
378         resourceOperationStatusRepository.save(status);
379
380         // Step 6: update segment operation status
381         if (RequestsDbConstant.Progress.ONE_HUNDRED.equals(rspDesc.getProgress())
382                 && RequestsDbConstant.Status.FINISHED.equals(rspDesc.getStatus())) {
383             LOGGER.info("job result is succeeded, operType is {}", status.getOperType());
384             status.setErrorCode(String.valueOf(rsp.getStatus()));
385             status.setStatusDescription(CommonConstant.StatusDesc.QUERY_JOB_STATUS_FAILED);
386
387             if (RequestsDbConstant.OperationType.CREATE.equalsIgnoreCase(status.getOperType())
388                     || "createInstance".equalsIgnoreCase(status.getOperType())) {
389                 status.setStatus(RequestsDbConstant.Status.FINISHED);
390             }
391             resourceOperationStatusRepository.save(status);
392         } else if (RequestsDbConstant.Status.ERROR.equals(rspDesc.getStatus())) {
393             LOGGER.error("job result is failed, operType is {}", status.getOperType());
394             status.setErrorCode(String.valueOf(rsp.getStatus()));
395             status.setStatusDescription(CommonConstant.StatusDesc.QUERY_JOB_STATUS_FAILED);
396             status.setStatus(RequestsDbConstant.Status.ERROR);
397             resourceOperationStatusRepository.save(status);
398             throw new ApplicationException(HttpCode.INTERNAL_SERVER_ERROR, DriverExceptionID.JOB_STATUS_ERROR);
399         } else {
400             LOGGER.error("unexcepted response status");
401         }
402         LOGGER.info("query ns status -> end");
403
404         return rsp;
405     }
406
407     /**
408      * Scale NS instance <br>
409      * 
410      * @param nsInstanceId The NS instance id
411      * @param segInput input parameters for current node from http request
412      * @return
413      * @since ONAP Amsterdam Release
414      */
415     public RestfulResponse scaleNs(String nsInstanceId, NSResourceInputParameter segInput) throws ApplicationException {
416         // Call the NFVO to scale service
417         LOGGER.info("scale ns -> begin");
418
419         // Step1: Prepare restful parameters and options
420         VFCScaleData oRequest = new VFCScaleData();
421         oRequest.setNsInstanceId(nsInstanceId);
422         NsScaleParameters nsScaleParameters = segInput.getNsScaleParameters();
423         oRequest.setScaleType(nsScaleParameters.getScaleType());
424         oRequest.setScaleNsData(nsScaleParameters.getScaleNsByStepsData());
425         String scaleReq = JsonUtil.marshal(oRequest);
426
427         // Step2: prepare url and method type
428         String url = getUrl(nsInstanceId, CommonConstant.Step.SCALE);
429         String methodType = CommonConstant.MethodType.POST;
430         LOGGER.info("scale ns request is {}", scaleReq);
431         // Step3: Call NFVO lcm to scale ns
432         RestfulResponse scaleRsp = restfulUtil.send(url, methodType, scaleReq);
433
434         ResourceOperationStatus status = new ResourceOperationStatus(segInput.getNsOperationKey().getServiceId(),
435                 segInput.getNsOperationKey().getOperationId(), segInput.getNsOperationKey().getNodeTemplateUUID());
436         ResourceOperationStatus nsOperInfo = resourceOperationStatusRepository.findOne(Example.of(status))
437                 .orElseThrow(() -> new ApplicationException(404, "Cannot Find Operation Status"));
438         ValidateUtil.assertObjectNotNull(scaleRsp);
439         if (!HttpCode.isSucess(scaleRsp.getStatus())) {
440             LOGGER.error("update segment operation status : fail to scale ns");
441             nsOperInfo.setStatus(RequestsDbConstant.Status.ERROR);
442             nsOperInfo.setErrorCode(String.valueOf(scaleRsp.getStatus()));
443             nsOperInfo.setStatusDescription(CommonConstant.StatusDesc.SCALE_NS_FAILED);
444             resourceOperationStatusRepository.save(nsOperInfo);
445             throw new ApplicationException(HttpCode.INTERNAL_SERVER_ERROR, DriverExceptionID.FAIL_TO_SCALE_NS);
446         }
447         LOGGER.info("scale ns response status is {}", scaleRsp.getStatus());
448         LOGGER.info("scale ns response content is {}", scaleRsp.getResponseContent());
449
450         ValidateUtil.assertObjectNotNull(scaleRsp.getResponseContent());
451         @SuppressWarnings("unchecked")
452         Map<String, String> rsp = JsonUtil.unMarshal(scaleRsp.getResponseContent(), Map.class);
453         String jobId = rsp.get(CommonConstant.JOB_ID);
454         if (ValidateUtil.isStrEmpty(jobId)) {
455             LOGGER.error("Invalid jobId from scale operation");
456             nsOperInfo.setStatus(RequestsDbConstant.Status.ERROR);
457             nsOperInfo.setErrorCode(String.valueOf(scaleRsp.getStatus()));
458             nsOperInfo.setStatusDescription(CommonConstant.StatusDesc.SCALE_NS_FAILED);
459             resourceOperationStatusRepository.save(nsOperInfo);
460             throw new ApplicationException(HttpCode.INTERNAL_SERVER_ERROR,
461                     DriverExceptionID.INVALID_RESPONSE_FROM_SCALE_OPERATION);
462         }
463
464         LOGGER.info("update resource operation status job id -> begin");
465         // Step 4: update segment operation job id
466         nsOperInfo.setJobId(jobId);
467         resourceOperationStatusRepository.save(nsOperInfo);
468         LOGGER.info("update segment operation job id -> end");
469         LOGGER.info("scale ns -> end");
470
471         return scaleRsp;
472     }
473
474     /**
475      * get url for the operation <br>
476      * 
477      * @param variable variable should be put in the url
478      * @param step step of the operation (terminate,query,delete)
479      * @return
480      * @since ONAP Amsterdam Release
481      */
482     private String getUrl(String variable, String step) {
483
484         String url;
485         String originalUrl;
486         originalUrl = nfvoUrlMap.get(step);
487         url = String.format(originalUrl, variable);
488         return url;
489
490     }
491
492 }