2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 - 2019 AT&T Intellectual Property. All rights reserved.
6 * Modifications Copyright (C) 2018 - 2019 Nokia. All rights reserved.
7 * ================================================================================
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 * ============LICENSE_END=========================================================
21 package org.onap.vid.mso;
23 import static com.fasterxml.jackson.module.kotlin.ExtensionsKt.jacksonObjectMapper;
24 import static java.util.stream.Collectors.collectingAndThen;
25 import static java.util.stream.Collectors.toList;
26 import static org.apache.commons.lang.StringUtils.upperCase;
27 import static org.onap.vid.changeManagement.ChangeManagementRequest.MsoChangeManagementRequest;
28 import static org.onap.vid.controller.MsoController.CONFIGURATION_ID;
29 import static org.onap.vid.controller.MsoController.REQUEST_TYPE;
30 import static org.onap.vid.controller.MsoController.SVC_INSTANCE_ID;
31 import static org.onap.vid.controller.MsoController.VNF_INSTANCE_ID;
32 import static org.onap.vid.controller.MsoController.WORKFLOW_ID;
33 import static org.onap.vid.logging.Headers.PARTNER_NAME;
34 import static org.onap.vid.mso.MsoProperties.MSO_REST_API_CLOUD_RESOURCES_REQUEST_STATUS;
35 import static org.onap.vid.mso.MsoProperties.MSO_REST_API_OPERATIONAL_ENVIRONMENT_ACTIVATE;
36 import static org.onap.vid.mso.MsoProperties.MSO_REST_API_OPERATIONAL_ENVIRONMENT_CREATE;
37 import static org.onap.vid.mso.MsoProperties.MSO_REST_API_OPERATIONAL_ENVIRONMENT_DEACTIVATE;
38 import static org.onap.vid.mso.MsoProperties.MSO_REST_API_WORKFLOW_SPECIFICATIONS;
39 import static org.onap.vid.utils.KotlinUtilsKt.JACKSON_OBJECT_MAPPER;
40 import static org.onap.vid.utils.Logging.debugRequestDetails;
42 import com.fasterxml.jackson.annotation.JsonCreator;
43 import com.fasterxml.jackson.annotation.JsonValue;
44 import com.fasterxml.jackson.databind.DeserializationFeature;
45 import com.fasterxml.jackson.databind.ObjectMapper;
46 import com.google.common.collect.ImmutableList;
47 import com.google.common.collect.ImmutableMap;
48 import io.joshworks.restclient.http.HttpResponse;
49 import java.io.IOException;
50 import java.util.ArrayList;
51 import java.util.Collections;
52 import java.util.HashMap;
53 import java.util.List;
55 import java.util.Objects;
56 import java.util.UUID;
57 import java.util.regex.Pattern;
58 import java.util.stream.Collectors;
59 import java.util.stream.Stream;
60 import javax.ws.rs.BadRequestException;
61 import org.apache.commons.collections4.ListUtils;
62 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
63 import org.onap.portalsdk.core.util.SystemProperties;
64 import org.onap.vid.aai.ExceptionWithRequestInfo;
65 import org.onap.vid.aai.HttpResponseWithRequestInfo;
66 import org.onap.vid.changeManagement.ChangeManagementRequest;
67 import org.onap.vid.changeManagement.RequestDetailsWrapper;
68 import org.onap.vid.changeManagement.WorkflowRequestDetail;
69 import org.onap.vid.controller.OperationalEnvironmentController;
70 import org.onap.vid.exceptions.GenericUncheckedException;
71 import org.onap.vid.model.SOWorkflowList;
72 import org.onap.vid.model.SoftDeleteRequest;
73 import org.onap.vid.model.probes.ErrorMetadata;
74 import org.onap.vid.model.probes.ExternalComponentStatus;
75 import org.onap.vid.model.probes.HttpRequestMetadata;
76 import org.onap.vid.model.probes.StatusMetadata;
77 import org.onap.vid.mso.model.CloudConfiguration;
78 import org.onap.vid.mso.model.ModelInfo;
79 import org.onap.vid.mso.model.OperationalEnvironmentActivateInfo;
80 import org.onap.vid.mso.model.OperationalEnvironmentDeactivateInfo;
81 import org.onap.vid.mso.model.RequestInfo;
82 import org.onap.vid.mso.model.RequestParameters;
83 import org.onap.vid.mso.rest.OperationalEnvironment.OperationEnvironmentRequestDetails;
84 import org.onap.vid.mso.rest.RelatedInstance;
85 import org.onap.vid.mso.rest.Request;
86 import org.onap.vid.mso.rest.RequestDetails;
87 import org.onap.vid.mso.rest.RequestList;
88 import org.onap.vid.mso.rest.RequestWrapper;
89 import org.onap.vid.mso.rest.Task;
90 import org.onap.vid.mso.rest.TaskList;
91 import org.onap.vid.utils.Logging;
92 import org.springframework.beans.factory.annotation.Autowired;
93 import org.springframework.http.HttpStatus;
95 public class MsoBusinessLogicImpl implements MsoBusinessLogic {
97 static final List<String> DASHBOARD_ALLOWED_TYPES = Stream.of(RequestType.REPLACE_INSTANCE,
98 RequestType.UPDATE_INSTANCE,
99 RequestType.APPLY_UPDATED_CONFIG,
100 RequestType.IN_PLACE_SOFTWARE_UPDATE,
101 RequestType.SCALE_OUT)
102 .map(requestType -> requestType.toString().toUpperCase())
103 .collect(collectingAndThen(toList(), Collections::unmodifiableList));
104 private static final String RESOURCE_TYPE = "resourceType";
105 private static final Pattern SOFTWARE_VERSION_PATTERN = Pattern.compile("^[A-Za-z0-9.\\-]+$");
106 private static final Pattern NUMBER_PATTERN = Pattern.compile("^[0-9]+$");
107 private static final String ACTIVATE = "/activate";
108 private static final String DEACTIVATE = "/deactivate";
109 private static final String ENABLE_PORT = "/enablePort";
110 private static final String DISABLE_PORT = "/disablePort";
111 private static final String ACTIVATE_FABRIC_CONFIGURATION = "/activateFabricConfiguration";
112 private static final String DEACTIVATE_AND_CLOUD_DELETE = "/deactivateAndCloudDelete";
113 private static final String RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT = "operationalEnvironment";
114 private static final String SOURCE_OPERATIONAL_ENVIRONMENT = "VID";
115 private static final ObjectMapper objectMapper = new ObjectMapper();
119 private static final EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(MsoBusinessLogicImpl.class);
121 * The Mso REST client
122 * This should be replaced with mso client factory.
124 private final MsoInterface msoClientInterface;
127 public MsoBusinessLogicImpl(MsoInterface msoClientInterface) {
128 this.msoClientInterface = msoClientInterface;
131 public static String validateEndpointPath(String endpointEnvVariable) {
132 String endpoint = SystemProperties.getProperty(endpointEnvVariable);
133 if (endpoint == null || endpoint.isEmpty()) {
134 throw new GenericUncheckedException(endpointEnvVariable + " env variable is not defined");
139 // this function should get params from tosca and send them to instance at mso, then return success response.
141 public MsoResponseWrapper createSvcInstance(RequestDetails msoRequest) {
142 logInvocationInDebug("createSvcInstance");
144 String endpoint = validateEndpointPath(MsoProperties.MSO_RESTAPI_SERVICE_INSTANCE);
146 return msoClientInterface.createSvcInstance(msoRequest, endpoint);
150 public MsoResponseWrapper createE2eSvcInstance(Object msoRequest) {
151 logInvocationInDebug("createE2eSvcInstance");
152 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_E2E_SVC_INSTANCE);
154 return msoClientInterface.createE2eSvcInstance(msoRequest, endpoint);
158 public MsoResponseWrapper createVnf(RequestDetails requestDetails, String serviceInstanceId) {
159 logInvocationInDebug("createVnf");
161 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
163 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
164 return msoClientInterface.createVnf(requestDetails, vnfEndpoint);
168 public MsoResponseWrapper createNwInstance(RequestDetails requestDetails, String serviceInstanceId) {
169 logInvocationInDebug("createNwInstance");
172 endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_NETWORK_INSTANCE);
174 String nwEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
175 return msoClientInterface.createNwInstance(requestDetails, nwEndpoint);
179 public MsoResponseWrapper createVolumeGroupInstance(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
180 logInvocationInDebug("createVolumeGroupInstance");
183 endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VOLUME_GROUP_INSTANCE);
185 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
186 vnfEndpoint = vnfEndpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
188 return msoClientInterface.createVolumeGroupInstance(requestDetails, vnfEndpoint);
192 public MsoResponseWrapper createVfModuleInstance(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
193 logInvocationInDebug("createVfModuleInstance");
195 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
197 String partialEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
198 String vfModuleEndpoint = partialEndpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
200 return msoClientInterface.createVfModuleInstance(requestDetails, vfModuleEndpoint);
204 public MsoResponseWrapper scaleOutVfModuleInstance(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
205 logInvocationInDebug("scaleOutVfModuleInstance");
207 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_SCALE_OUT);
209 String partial_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
210 String vf_module_endpoint = partial_endpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
211 RequestDetailsWrapper wrapper = new RequestDetailsWrapper();
212 requestDetails.setVnfName(null);
213 requestDetails.setVnfInstanceId(null);
214 wrapper.requestDetails = requestDetails;
216 return msoClientInterface.scaleOutVFModuleInstance(wrapper, vf_module_endpoint);
220 public MsoResponseWrapper invokeVnfWorkflow(WorkflowRequestDetail request, String userId, UUID serviceInstanceId, UUID vnfInstanceId, UUID workflow_UUID) {
221 logInvocationInDebug("invokeVnfWorkflow");
223 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_WORKFLOW_INSTANCE);
225 String final_endpoint = endpoint
226 .replaceFirst(SVC_INSTANCE_ID, serviceInstanceId.toString())
227 .replaceFirst(WORKFLOW_ID, workflow_UUID.toString())
228 .replaceFirst(VNF_INSTANCE_ID, vnfInstanceId.toString());
230 Map<String,String> extraHeaders = new HashMap<>();
232 UUID requestId = UUID.randomUUID();
233 extraHeaders.put("X-ONAP-RequestID",requestId.toString());
234 extraHeaders.put(PARTNER_NAME.getHeaderName(), PARTNER_NAME.getHeaderValue());
235 extraHeaders.put("X-RequestorID",userId);
237 return msoClientInterface.invokeWorkflow(request,final_endpoint,extraHeaders);
241 public MsoResponseWrapper createConfigurationInstance(org.onap.vid.mso.rest.RequestDetailsWrapper requestDetailsWrapper, String serviceInstanceId) {
242 logInvocationInDebug("createConfigurationInstance");
244 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATIONS);
245 endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
247 return msoClientInterface.createConfigurationInstance(requestDetailsWrapper, endpoint);
251 public MsoResponseWrapper deleteE2eSvcInstance(Object requestDetails, String serviceInstanceId) {
252 logInvocationInDebug("deleteE2eSvcInstance");
254 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_E2E_SVC_INSTANCE) + "/" + serviceInstanceId;
256 return msoClientInterface.deleteE2eSvcInstance(requestDetails, endpoint);
260 public MsoResponseWrapper deleteSvcInstance(RequestDetails requestDetails, String serviceInstanceId, String serviceStatus) {
261 logInvocationInDebug("deleteSvcInstance");
264 endpoint = validateEndpointPath(MsoProperties.MSO_RESTAPI_SERVICE_INSTANCE);
265 if (shouldUnassignService(serviceStatus)){
266 logger.debug(EELFLoggerDelegate.debugLogger, "unassign service");
267 String svcEndpoint = endpoint + "/" + serviceInstanceId + "/unassign";
268 return msoClientInterface.unassignSvcInstance(requestDetails, svcEndpoint);
271 String svcEndpoint = endpoint + "/" + serviceInstanceId;
272 return msoClientInterface.deleteSvcInstance(requestDetails, svcEndpoint);
275 private boolean shouldUnassignService(String serviceStatus) {
276 return ImmutableList.of("created", "pendingdelete", "pending-delete", "assigned").contains(serviceStatus.toLowerCase());
280 public MsoResponseWrapper deleteVnf(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
281 logInvocationInDebug("deleteVnf");
283 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
284 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
285 vnfEndpoint = vnfEndpoint + '/' + vnfInstanceId;
287 return msoClientInterface.deleteVnf(requestDetails, vnfEndpoint);
291 public MsoResponseWrapper deleteVfModule(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId, String vfModuleId) {
292 logInvocationInDebug("deleteVfModule");
294 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
295 String vfModulesEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId).replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
296 String deleteVfEndpoint = vfModulesEndpoint + '/' + vfModuleId;
298 return msoClientInterface.deleteVfModule(requestDetails, deleteVfEndpoint);
302 public MsoResponseWrapper deleteVolumeGroupInstance(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId, String volumeGroupId) {
303 logInvocationInDebug("deleteVolumeGroupInstance");
305 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VOLUME_GROUP_INSTANCE);
306 String svcEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
307 String vnfEndpoint = svcEndpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
308 String deleteVolumeGroupEndpoint = vnfEndpoint + "/" + volumeGroupId;
310 return msoClientInterface.deleteVolumeGroupInstance(requestDetails, deleteVolumeGroupEndpoint);
314 public MsoResponseWrapper deleteNwInstance(RequestDetails requestDetails, String serviceInstanceId, String networkInstanceId) {
315 logInvocationInDebug("deleteNwInstance");
317 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_NETWORK_INSTANCE);
318 String svcEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
319 String deleteNwEndpoint = svcEndpoint + "/" + networkInstanceId;
321 return msoClientInterface.deleteNwInstance(requestDetails, deleteNwEndpoint);
325 public MsoResponseWrapper getOrchestrationRequest(String requestId) {
326 String methodName = "getOrchestrationRequest";
327 logInvocationInDebug(methodName);
329 String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQ);
330 String path = p + "/" + requestId;
332 return msoClientInterface.getOrchestrationRequest(path);
334 } catch (Exception e) {
335 logException(methodName, e);
341 public MsoResponseWrapper getOrchestrationRequests(String filterString) {
342 String methodName = "getOrchestrationRequest";
343 logInvocationInDebug(methodName);
345 String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQS);
346 String path = p + filterString;
348 return msoClientInterface.getOrchestrationRequest(path);
350 } catch (Exception e) {
351 logException(methodName, e);
357 public List<Request> getOrchestrationRequestsForDashboard() {
358 String methodName = "getOrchestrationRequestsForDashboard";
359 logInvocationInDebug(methodName);
361 List<Request> dashboardOrchestrationReqs = new ArrayList<>();
363 List<RequestWrapper> vnfOrchestrationReqsWrappers = getOrchestrationRequestsByFilter("modelType", "vnf");
364 dashboardOrchestrationReqs = vnfOrchestrationReqsWrappers.stream()
365 .filter(reqWrapper -> Objects.nonNull(reqWrapper.getRequest())
366 && DASHBOARD_ALLOWED_TYPES.contains(upperCase(reqWrapper.getRequest().getRequestType())))
367 .map(RequestWrapper::getRequest)
368 .collect(Collectors.toList());
370 List<RequestWrapper> scaleOutOrchestrationReqWrappers = getOrchestrationRequestsByFilter("action", "scaleOut");
371 List<Request> scaleoutRequests = scaleOutOrchestrationReqWrappers.stream()
372 .filter(reqWrapper -> Objects.nonNull(reqWrapper.getRequest()))
373 .map(RequestWrapper::getRequest)
374 .collect(Collectors.toList());
376 dashboardOrchestrationReqs.addAll(scaleoutRequests);
377 } catch (Exception e) {
378 logException(methodName, e);
381 return dashboardOrchestrationReqs;
384 private String constructOrchestrationRequestFilter(String filterName, String filterValue) {
385 return String.format("%sfilter=%s:EQUALS:%s",
386 SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQS), filterName, filterValue);
389 private List<RequestWrapper> getOrchestrationRequestsByFilter(String filterName, String filterValue) {
390 HttpResponseWithRequestInfo<String> msoResponseWrapper = getRawOrchestrationRequestsByFilter(filterName, filterValue);
391 return deserializeOrchestrationRequestsJson(msoResponseWrapper.getResponse().getBody());
394 private HttpResponseWithRequestInfo<String> getRawOrchestrationRequestsByFilter(String filterName, String filterValue) {
395 String orchestrationReqPath = constructOrchestrationRequestFilter(filterName, filterValue);
396 return msoClientInterface.getOrchestrationRequest(orchestrationReqPath, true);
399 private List<RequestWrapper> deserializeOrchestrationRequestsJson(String orchestrationRequestsJson) {
400 logInvocationInDebug("deserializeOrchestrationRequestsJson");
402 ObjectMapper mapper = jacksonObjectMapper();
403 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
404 mapper.configure(DeserializationFeature.READ_ENUMS_USING_TO_STRING, true);
405 RequestList requestList;
407 requestList = mapper.readValue(orchestrationRequestsJson, RequestList.class);
408 } catch (IOException e) {
409 throw new GenericUncheckedException(e);
411 return ListUtils.emptyIfNull(requestList.getRequestList());
416 public List<Task> getManualTasksByRequestId(String originalRequestId) {
417 String methodName = "getManualTasksByRequestId";
418 logInvocationInDebug(methodName);
421 String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_MAN_TASKS);
422 String path = p + "?originalRequestId=" + originalRequestId;
424 RestObject<String> restObjStr = new RestObject<>();
428 MsoResponseWrapper msoResponseWrapper = msoClientInterface.getManualTasksByRequestId(str, "", path, restObjStr);
429 return deserializeManualTasksJson(msoResponseWrapper.getEntity());
431 } catch (Exception e) {
432 logException(methodName, e);
437 private List<Task> deserializeManualTasksJson(String manualTasksJson) {
438 logInvocationInDebug("deserializeManualTasksJson");
441 TaskList taskList = JACKSON_OBJECT_MAPPER.readValue(manualTasksJson, TaskList.class);
442 return taskList.getTaskList();
443 } catch (IOException e) {
444 throw new GenericUncheckedException(e);
450 public MsoResponseWrapper completeManualTask(RequestDetails requestDetails, String taskId) {
451 String methodName = "completeManualTask";
452 logInvocationInDebug(methodName);
454 String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_MAN_TASKS);
455 String path = p + "/" + taskId + "/complete";
457 RestObject<String> restObjStr = new RestObject<>();
461 return msoClientInterface.completeManualTask(requestDetails, str, "", path, restObjStr);
463 } catch (Exception e) {
464 logException(methodName, e);
470 public MsoResponseWrapper activateServiceInstance(RequestDetails requestDetails, String serviceInstanceId) {
471 String methodName = "activateServiceInstance";
472 logInvocationInDebug(methodName);
474 String serviceEndpoint = SystemProperties.getProperty(MsoProperties.MSO_RESTAPI_SERVICE_INSTANCE);
475 String activateServicePath = serviceEndpoint + "/" + serviceInstanceId + ACTIVATE;
477 RestObject<String> restObjStr = new RestObject<>();
481 msoClientInterface.setServiceInstanceStatus(requestDetails, activateServicePath);
483 return MsoUtil.wrapResponse(restObjStr);
485 } catch (Exception e) {
486 logException(methodName, e);
493 public MsoResponseWrapperInterface updateVnf(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
494 logInvocationInDebug("updateVnf");
497 endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
498 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
499 vnfEndpoint = vnfEndpoint + '/' + vnfInstanceId;
500 return msoClientInterface.updateVnf(requestDetails, vnfEndpoint);
504 public MsoResponseWrapperInterface replaceVnf(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
505 logInvocationInDebug("replaceVnf");
507 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_CHANGE_MANAGEMENT_INSTANCE);
508 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
509 vnfEndpoint = vnfEndpoint.replace(VNF_INSTANCE_ID, vnfInstanceId);
510 vnfEndpoint = vnfEndpoint.replace(REQUEST_TYPE, MsoChangeManagementRequest.REPLACE);
511 return msoClientInterface.replaceVnf(requestDetails, vnfEndpoint);
514 public RequestDetailsWrapper generateInPlaceMsoRequest(org.onap.vid.changeManagement.RequestDetails requestDetails) {
515 validateUpdateVnfSoftwarePayload(requestDetails);
516 RequestDetails inPlaceSoftwareUpdateRequest = new RequestDetails();
517 inPlaceSoftwareUpdateRequest.setCloudConfiguration(requestDetails.getCloudConfiguration());
518 inPlaceSoftwareUpdateRequest.setRequestParameters(requestDetails.getRequestParameters());
519 inPlaceSoftwareUpdateRequest.setRequestInfo(requestDetails.getRequestInfo());
520 RequestDetailsWrapper requestDetailsWrapper = new RequestDetailsWrapper();
521 requestDetailsWrapper.requestDetails = inPlaceSoftwareUpdateRequest;
522 return requestDetailsWrapper;
526 public RequestDetailsWrapper generateConfigMsoRequest(org.onap.vid.changeManagement.RequestDetails requestDetails) {
527 validateUpdateVnfConfig(requestDetails);
528 RequestDetails configUpdateRequest = new RequestDetails();
529 configUpdateRequest.setRequestParameters(requestDetails.getRequestParameters());
530 configUpdateRequest.setRequestInfo(requestDetails.getRequestInfo());
531 RequestDetailsWrapper requestDetailsWrapper = new RequestDetailsWrapper();
532 requestDetailsWrapper.requestDetails = configUpdateRequest;
533 return requestDetailsWrapper;
537 public String getActivateFabricConfigurationPath(String serviceInstanceId) {
538 String path = validateEndpointPath(MsoProperties.MSO_RESTAPI_SERVICE_INSTANCE);
539 path += "/" + serviceInstanceId + ACTIVATE_FABRIC_CONFIGURATION;
545 public String getDeactivateAndCloudDeletePath(String serviceInstanceId, String vnfInstanceId, String vfModuleInstanceId) {
546 String path = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
547 path = path.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
548 path = path.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
549 path += "/" + vfModuleInstanceId + DEACTIVATE_AND_CLOUD_DELETE;
555 public RequestDetails buildRequestDetailsForSoftDelete(SoftDeleteRequest softDeleteRequest) {
556 RequestDetails requestDetails = new RequestDetails();
557 RequestInfo requestInfo = new RequestInfo();
558 requestInfo.setSource("VID");
559 requestInfo.setRequestorId(softDeleteRequest.getUserId());
560 requestDetails.setRequestInfo(requestInfo);
562 CloudConfiguration cloudConfiguration = new CloudConfiguration(softDeleteRequest.getLcpCloudRegionId(), softDeleteRequest.getTenantId(), null);
563 requestDetails.setCloudConfiguration(cloudConfiguration);
565 ModelInfo modelInfo = new ModelInfo();
566 modelInfo.setModelType("vfModule");
567 requestDetails.setModelInfo(modelInfo);
569 RequestParameters requestParameters = new RequestParameters();
570 requestParameters.setTestApi("GR_API");
571 requestDetails.setRequestParameters(requestParameters);
573 return requestDetails;
577 public SOWorkflowList getWorkflowListByModelId(String modelVersionId) {
578 logInvocationInDebug("getWorkflowListByModelId");
579 String pathTemplate = validateEndpointPath(MSO_REST_API_WORKFLOW_SPECIFICATIONS);
580 String path = pathTemplate.replaceFirst("<model_version_id>", modelVersionId);
582 HttpResponse<SOWorkflowList> workflowListByModelId = msoClientInterface.getWorkflowListByModelId(path);
583 if (!isSuccessful(workflowListByModelId)) {
584 logger.error(EELFLoggerDelegate.errorLogger, workflowListByModelId.getStatusText());
585 throw new WorkflowListException(String.format("Get worklflow list for id: %s failed due to %s", modelVersionId, workflowListByModelId.getStatusText()));
587 return workflowListByModelId.getBody();
592 public MsoResponseWrapperInterface updateVnfSoftware(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
593 logInvocationInDebug("updateVnfSoftware");
594 String vnfEndpoint = getChangeManagementEndpoint(serviceInstanceId, vnfInstanceId, MsoChangeManagementRequest.SOFTWARE_UPDATE); //workflow name in mso is different than workflow name in vid UI
595 RequestDetailsWrapper finalRequestDetails = generateInPlaceMsoRequest(requestDetails);
596 return msoClientInterface.changeManagementUpdate(finalRequestDetails, vnfEndpoint);
600 public MsoResponseWrapperInterface updateVnfConfig(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
601 logInvocationInDebug("updateVnfConfig");
602 RequestDetailsWrapper finalRequestDetails = generateConfigMsoRequest(requestDetails);
603 String vnfEndpoint = getChangeManagementEndpoint(serviceInstanceId, vnfInstanceId, MsoChangeManagementRequest.CONFIG_UPDATE);
604 return msoClientInterface.changeManagementUpdate(finalRequestDetails, vnfEndpoint);
607 private String getChangeManagementEndpoint(String serviceInstanceId, String vnfInstanceId, String vnfRequestType) {
608 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_CHANGE_MANAGEMENT_INSTANCE);
609 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
610 vnfEndpoint = vnfEndpoint.replace(VNF_INSTANCE_ID, vnfInstanceId);
611 vnfEndpoint = vnfEndpoint.replace(REQUEST_TYPE, vnfRequestType);
615 private Map getChangeManagementPayload(RequestDetails requestDetails, String message) {
616 if (requestDetails.getRequestParameters() == null || requestDetails.getRequestParameters().getAdditionalProperties() == null) {
617 throw new BadRequestException(message);
619 Object payloadRaw = requestDetails.getRequestParameters().getAdditionalProperties().get("payload");
621 return JACKSON_OBJECT_MAPPER.readValue((String) payloadRaw, Map.class);
622 } catch (Exception exception) {
623 throw new BadRequestException(message);
627 private void validateUpdateVnfSoftwarePayload(RequestDetails requestDetails) {
628 final String noValidPayloadMsg = "No valid payload in " + ChangeManagementRequest.VNF_IN_PLACE_SOFTWARE_UPDATE + " request";
630 Map payload = getChangeManagementPayload(requestDetails, noValidPayloadMsg);
631 validateUpdateVnfSoftwarePayloadProperty(payload, noValidPayloadMsg, "existing_software_version", SOFTWARE_VERSION_PATTERN);
632 validateUpdateVnfSoftwarePayloadProperty(payload, noValidPayloadMsg, "new_software_version", SOFTWARE_VERSION_PATTERN);
634 //if "operations_timeout" is not integer, trying to read it as String that represent a number
635 if (!(payload.get("operations_timeout") instanceof Integer)) {
636 validateUpdateVnfSoftwarePayloadProperty(payload, noValidPayloadMsg, "operations_timeout", NUMBER_PATTERN);
640 private void validateUpdateVnfSoftwarePayloadProperty(Map payload, String noValidPayloadMsg, String propertyName, Pattern pattern) {
641 Object forValidation = payload.get(propertyName);
642 final String noValidPayloadPropertyMsg = noValidPayloadMsg + ", " + propertyName + " property is not valid";
643 if (!(forValidation instanceof String)) {
644 throw new BadRequestException(noValidPayloadPropertyMsg);
646 if (!pattern.matcher((String) forValidation).matches()) {
647 throw new BadRequestException(noValidPayloadPropertyMsg);
652 public MsoResponseWrapper deleteConfiguration(org.onap.vid.mso.rest.RequestDetailsWrapper requestDetailsWrapper,
653 String serviceInstanceId,
654 String configurationId) {
656 logInvocationInDebug("deleteConfiguration");
657 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATION_INSTANCE);
658 endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
659 endpoint = endpoint.replace(CONFIGURATION_ID, configurationId);
661 return msoClientInterface.deleteConfiguration(requestDetailsWrapper, endpoint);
665 public MsoResponseWrapper setConfigurationActiveStatus(
666 RequestDetails requestDetails,
667 String serviceInstanceId,
668 String configurationId,
669 boolean isActivate) {
671 logInvocationInDebug("setConfigurationActiveStatus");
673 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATION_INSTANCE);
674 endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
675 endpoint = endpoint.replace(CONFIGURATION_ID, configurationId);
677 String isActivateState = (isActivate ? ACTIVATE : DEACTIVATE);
678 endpoint = endpoint + isActivateState;
680 return msoClientInterface.setConfigurationActiveStatus(requestDetails, endpoint);
684 public MsoResponseWrapper setServiceInstanceStatus(RequestDetails requestDetails, String serviceInstanceId, boolean isActivate) {
685 logInvocationInDebug("setServiceInstanceStatus");
686 String methodName = "setServiceInstanceStatus";
688 String serviceEndpoint = validateEndpointPath(MsoProperties.MSO_RESTAPI_SERVICE_INSTANCE);
689 String endpoint = serviceEndpoint + "/" + serviceInstanceId;
691 String isActivateState = (isActivate ? ACTIVATE : DEACTIVATE);
692 endpoint = endpoint + isActivateState;
694 return msoClientInterface.setServiceInstanceStatus(requestDetails, endpoint);
695 } catch (Exception e) {
696 logger.error(EELFLoggerDelegate.errorLogger, methodName + e.toString());
697 logger.debug(EELFLoggerDelegate.debugLogger, methodName + e.toString());
703 public MsoResponseWrapper setPortOnConfigurationStatus(
704 RequestDetails requestDetails,
705 String serviceInstanceId,
706 String configurationId,
708 logInvocationInDebug("setPortOnConfigurationStatus");
710 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATION_INSTANCE);
711 endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
712 endpoint = endpoint.replace(CONFIGURATION_ID, configurationId);
714 String isEnablePortStatus = (isEnable ? ENABLE_PORT : DISABLE_PORT);
715 endpoint = endpoint + isEnablePortStatus;
717 return msoClientInterface.setPortOnConfigurationStatus(requestDetails, endpoint);
722 public RequestDetailsWrapper<RequestDetails> createOperationalEnvironmentActivationRequestDetails(OperationalEnvironmentActivateInfo details) {
723 RequestDetails requestDetails = new RequestDetails();
724 RequestInfo requestInfo = new RequestInfo();
725 requestInfo.setAdditionalProperty(RESOURCE_TYPE, RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT);
726 requestInfo.setSource(SOURCE_OPERATIONAL_ENVIRONMENT);
727 requestInfo.setRequestorId(details.getUserId());
728 requestDetails.setRequestInfo(requestInfo);
730 RelatedInstance relatedInstance = new RelatedInstance();
731 relatedInstance.setAdditionalProperty(RESOURCE_TYPE, RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT);
732 relatedInstance.setInstanceId(details.getRelatedInstanceId());
733 relatedInstance.setInstanceName(details.getRelatedInstanceName());
734 requestDetails.setAdditionalProperty("relatedInstanceList", Collections.singletonList(ImmutableMap.of("relatedInstance", relatedInstance)));
736 RequestParameters requestParameters = new RequestParameters();
737 requestParameters.setUserParams(null);
738 requestParameters.setAdditionalProperty("operationalEnvironmentType", "VNF");
739 requestParameters.setAdditionalProperty("workloadContext", details.getWorkloadContext());
740 requestParameters.setAdditionalProperty("manifest", details.getManifest());
741 requestDetails.setRequestParameters(requestParameters);
743 RequestDetailsWrapper<RequestDetails> requestDetailsWrapper = new RequestDetailsWrapper<>(requestDetails);
745 debugRequestDetails(requestDetailsWrapper, logger);
747 return requestDetailsWrapper;
751 public String getOperationalEnvironmentActivationPath(OperationalEnvironmentActivateInfo details) {
752 String path = validateEndpointPath(MSO_REST_API_OPERATIONAL_ENVIRONMENT_ACTIVATE);
753 path = path.replace("<operational_environment_id>", details.getOperationalEnvironmentId());
758 public RequestDetailsWrapper<RequestDetails> createOperationalEnvironmentDeactivationRequestDetails(OperationalEnvironmentDeactivateInfo details) {
759 RequestDetails requestDetails = new RequestDetails();
761 RequestInfo requestInfo = new RequestInfo();
762 requestInfo.setAdditionalProperty(RESOURCE_TYPE, RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT);
763 requestInfo.setSource(SOURCE_OPERATIONAL_ENVIRONMENT);
764 requestInfo.setRequestorId(details.getUserId());
765 requestDetails.setRequestInfo(requestInfo);
767 RequestParameters requestParameters = new RequestParameters();
768 requestParameters.setUserParams(null);
769 requestParameters.setAdditionalProperty("operationalEnvironmentType", "VNF");
770 requestDetails.setRequestParameters(requestParameters);
771 RequestDetailsWrapper<RequestDetails> requestDetailsWrapper = new RequestDetailsWrapper<>(requestDetails);
772 debugRequestDetails(requestDetailsWrapper, logger);
773 return requestDetailsWrapper;
777 public String getCloudResourcesRequestsStatusPath(String requestId) {
778 String path = validateEndpointPath(MSO_REST_API_CLOUD_RESOURCES_REQUEST_STATUS);
779 path = path.replace("<request_id>", requestId);
784 public String getOperationalEnvironmentDeactivationPath(OperationalEnvironmentDeactivateInfo details) {
785 String path = validateEndpointPath(MSO_REST_API_OPERATIONAL_ENVIRONMENT_DEACTIVATE);
786 path = path.replace("<operational_environment_id>", details.getOperationalEnvironmentId());
791 public String getOperationalEnvironmentCreationPath() {
792 return validateEndpointPath(MSO_REST_API_OPERATIONAL_ENVIRONMENT_CREATE);
797 public RequestDetailsWrapper<OperationEnvironmentRequestDetails> convertParametersToRequestDetails(OperationalEnvironmentController.OperationalEnvironmentCreateBody input, String userId) {
798 OperationEnvironmentRequestDetails.RequestInfo requestInfo = new OperationEnvironmentRequestDetails.RequestInfo(
799 RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT,
800 input.getInstanceName(),
801 SOURCE_OPERATIONAL_ENVIRONMENT,
804 OperationEnvironmentRequestDetails.RelatedInstance relatedInstance = new OperationEnvironmentRequestDetails.RelatedInstance(
805 RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT,
806 input.getEcompInstanceId(),
807 input.getEcompInstanceName());
809 List<OperationEnvironmentRequestDetails.RelatedInstance> relatedInstanceList = Collections.singletonList((relatedInstance));
811 OperationEnvironmentRequestDetails.RequestParameters requestParameters = new OperationEnvironmentRequestDetails.RequestParameters(
812 input.getOperationalEnvironmentType(),
813 input.getTenantContext(),
814 input.getWorkloadContext());
816 OperationEnvironmentRequestDetails requestDetails = new OperationEnvironmentRequestDetails(requestInfo, relatedInstanceList, requestParameters);
817 RequestDetailsWrapper<OperationEnvironmentRequestDetails> requestDetailsWrapper = new RequestDetailsWrapper<>(requestDetails);
818 debugRequestDetails(requestDetailsWrapper, logger);
819 return requestDetailsWrapper;
823 public MsoResponseWrapper removeRelationshipFromServiceInstance(RequestDetails requestDetails, String serviceInstanceId) {
824 logInvocationInDebug("removeRelationshipFromServiceInstance");
826 String serviceEndpoint = SystemProperties.getProperty(MsoProperties.MSO_RESTAPI_SERVICE_INSTANCE);
827 String removeRelationshipsPath = serviceEndpoint + "/" + serviceInstanceId + "/removeRelationships";
829 return msoClientInterface.removeRelationshipFromServiceInstance(requestDetails, removeRelationshipsPath);
833 public MsoResponseWrapper addRelationshipToServiceInstance(RequestDetails requestDetails, String serviceInstanceId) {
834 logInvocationInDebug("addRelationshipToServiceInstance");
836 String serviceEndpoint = SystemProperties.getProperty(MsoProperties.MSO_RESTAPI_SERVICE_INSTANCE);
837 String addRelationshipsPath = serviceEndpoint + "/" + serviceInstanceId + "/addRelationships";
839 return msoClientInterface.addRelationshipToServiceInstance(requestDetails, addRelationshipsPath);
844 public ExternalComponentStatus probeComponent() {
845 final long startTime = System.currentTimeMillis();
846 HttpResponseWithRequestInfo<String> responseWithRequestInfo = null;
848 responseWithRequestInfo = getRawOrchestrationRequestsByFilter("requestExecutionDate", "01-01-2100" );
849 int httpCode = responseWithRequestInfo.getResponse().getStatus();
850 boolean isAvailable = httpCode == 200 || httpCode == 202;
852 //make sure response can be parsed to RequestList.class
853 JACKSON_OBJECT_MAPPER.readValue(responseWithRequestInfo.getResponse().getBody(), RequestList.class);
856 HttpRequestMetadata metadata = new HttpRequestMetadata(responseWithRequestInfo,
857 isAvailable ? "OK" : "MSO returned no orchestration requests",
858 System.currentTimeMillis() - startTime, true);
859 return new ExternalComponentStatus(ExternalComponentStatus.Component.MSO, isAvailable, metadata);
861 } catch (ExceptionWithRequestInfo e) {
862 long duration = System.currentTimeMillis() - startTime;
863 return new ExternalComponentStatus(ExternalComponentStatus.Component.MSO, false,
864 new HttpRequestMetadata(e, duration));
865 } catch (Exception e) {
866 StatusMetadata metadata;
867 long duration = System.currentTimeMillis() - startTime;
869 if (responseWithRequestInfo == null) {
870 metadata = new ErrorMetadata(Logging.exceptionToDescription(e), duration);
872 metadata = new HttpRequestMetadata(responseWithRequestInfo, Logging.exceptionToDescription(e), duration, true);
875 return new ExternalComponentStatus(ExternalComponentStatus.Component.MSO, false, metadata);
879 private void validateUpdateVnfConfig(RequestDetails requestDetails) {
880 final String noValidPayloadMsg = "No valid payload in " + ChangeManagementRequest.CONFIG_UPDATE + " request";
882 Map payload = getChangeManagementPayload(requestDetails, noValidPayloadMsg);
883 validateConfigUpdateVnfPayloadProperty(payload, noValidPayloadMsg, "request-parameters");
884 validateConfigUpdateVnfPayloadProperty(payload, noValidPayloadMsg, "configuration-parameters");
887 private void validateConfigUpdateVnfPayloadProperty(Map payload, String noValidPayloadMsg, String propertyName) {
888 final String noValidPayloadPropertyMsg = noValidPayloadMsg + ", " + propertyName + " property is not valid";
889 if (!payload.containsKey(propertyName)) {
890 throw new BadRequestException(noValidPayloadPropertyMsg);
894 private void logInvocationInDebug(String methodName) {
895 logger.debug(EELFLoggerDelegate.debugLogger, methodName + " start");
898 private void logException(String methodName, Exception e) {
899 logger.error(EELFLoggerDelegate.errorLogger, methodName + e.toString());
900 logger.debug(EELFLoggerDelegate.debugLogger, methodName + e.toString());
903 private boolean isSuccessful(HttpResponse<SOWorkflowList> workflowListByModelId) {
904 int status = workflowListByModelId.getStatus();
905 return HttpStatus.OK.value() == status || HttpStatus.ACCEPTED.value() == status;
908 static class WorkflowListException extends RuntimeException{
910 WorkflowListException(String message) {
915 public enum RequestType {
917 CREATE_INSTANCE("createInstance"),
918 DELETE_INSTANCE("deleteInstance"),
919 REPLACE_INSTANCE("replaceInstance"),
920 UPDATE_INSTANCE("updateInstance"),
921 ACTIVATE_INSTANCE("activateInstance"),
922 DEACTIVATE_INSTANCE("deactivateInstance"),
923 APPLY_UPDATED_CONFIG("applyUpdatedConfig"),
924 IN_PLACE_SOFTWARE_UPDATE("inPlaceSoftwareUpdate"),
925 SCALE_OUT("scaleOut"),
927 NOT_PROVIDED("not provided");
928 private final String value;
929 private static final Map<String, RequestType> CONSTANTS = new HashMap<>();
932 for (RequestType c : values()) {
933 CONSTANTS.put(c.value, c);
937 RequestType(String value) {
942 public static RequestType fromValue(String value) {
943 RequestType constant = CONSTANTS.get(value);
944 if (constant == null) {
945 throw new IllegalArgumentException(value);
953 public String toString() {