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.mso.MsoProperties.MSO_REST_API_CLOUD_RESOURCES_REQUEST_STATUS;
34 import static org.onap.vid.mso.MsoProperties.MSO_REST_API_OPERATIONAL_ENVIRONMENT_ACTIVATE;
35 import static org.onap.vid.mso.MsoProperties.MSO_REST_API_OPERATIONAL_ENVIRONMENT_CREATE;
36 import static org.onap.vid.mso.MsoProperties.MSO_REST_API_OPERATIONAL_ENVIRONMENT_DEACTIVATE;
37 import static org.onap.vid.mso.MsoProperties.MSO_REST_API_WORKFLOW_SPECIFICATIONS;
38 import static org.onap.vid.utils.KotlinUtilsKt.JACKSON_OBJECT_MAPPER;
39 import static org.onap.vid.utils.Logging.debugRequestDetails;
41 import com.fasterxml.jackson.annotation.JsonCreator;
42 import com.fasterxml.jackson.annotation.JsonValue;
43 import com.fasterxml.jackson.databind.DeserializationFeature;
44 import com.fasterxml.jackson.databind.ObjectMapper;
45 import com.google.common.collect.ImmutableList;
46 import com.google.common.collect.ImmutableMap;
47 import io.joshworks.restclient.http.HttpResponse;
48 import java.io.IOException;
49 import java.util.ArrayList;
50 import java.util.Collections;
51 import java.util.HashMap;
52 import java.util.List;
54 import java.util.Objects;
55 import java.util.UUID;
56 import java.util.regex.Pattern;
57 import java.util.stream.Collectors;
58 import java.util.stream.Stream;
59 import javax.ws.rs.BadRequestException;
60 import org.apache.commons.collections4.ListUtils;
61 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
62 import org.onap.portalsdk.core.util.SystemProperties;
63 import org.onap.vid.changeManagement.ChangeManagementRequest;
64 import org.onap.vid.changeManagement.RequestDetailsWrapper;
65 import org.onap.vid.changeManagement.WorkflowRequestDetail;
66 import org.onap.vid.controller.OperationalEnvironmentController;
67 import org.onap.vid.exceptions.GenericUncheckedException;
68 import org.onap.vid.model.SOWorkflowList;
69 import org.onap.vid.model.SoftDeleteRequest;
70 import org.onap.vid.model.probes.ExternalComponentStatus;
71 import org.onap.vid.model.probes.HttpRequestMetadata;
72 import org.onap.vid.model.probes.StatusMetadata;
73 import org.onap.vid.mso.model.CloudConfiguration;
74 import org.onap.vid.mso.model.ModelInfo;
75 import org.onap.vid.mso.model.OperationalEnvironmentActivateInfo;
76 import org.onap.vid.mso.model.OperationalEnvironmentDeactivateInfo;
77 import org.onap.vid.mso.model.RequestInfo;
78 import org.onap.vid.mso.model.RequestParameters;
79 import org.onap.vid.mso.rest.OperationalEnvironment.OperationEnvironmentRequestDetails;
80 import org.onap.vid.mso.rest.RelatedInstance;
81 import org.onap.vid.mso.rest.Request;
82 import org.onap.vid.mso.rest.RequestDetails;
83 import org.onap.vid.mso.rest.RequestList;
84 import org.onap.vid.mso.rest.RequestWrapper;
85 import org.onap.vid.mso.rest.Task;
86 import org.onap.vid.mso.rest.TaskList;
87 import org.springframework.beans.factory.annotation.Autowired;
88 import org.springframework.http.HttpMethod;
89 import org.springframework.http.HttpStatus;
91 public class MsoBusinessLogicImpl implements MsoBusinessLogic {
93 static final List<String> DASHBOARD_ALLOWED_TYPES = Stream.of(RequestType.REPLACE_INSTANCE,
94 RequestType.UPDATE_INSTANCE,
95 RequestType.APPLY_UPDATED_CONFIG,
96 RequestType.IN_PLACE_SOFTWARE_UPDATE,
97 RequestType.SCALE_OUT)
98 .map(requestType -> requestType.toString().toUpperCase())
99 .collect(collectingAndThen(toList(), Collections::unmodifiableList));
100 private static final String RESOURCE_TYPE = "resourceType";
101 private static final Pattern SOFTWARE_VERSION_PATTERN = Pattern.compile("^[A-Za-z0-9.\\-]+$");
102 private static final Pattern NUMBER_PATTERN = Pattern.compile("^[0-9]+$");
103 private static final String ACTIVATE = "/activate";
104 private static final String DEACTIVATE = "/deactivate";
105 private static final String ENABLE_PORT = "/enablePort";
106 private static final String DISABLE_PORT = "/disablePort";
107 private static final String ACTIVATE_FABRIC_CONFIGURATION = "/activateFabricConfiguration";
108 private static final String DEACTIVATE_AND_CLOUD_DELETE = "/deactivateAndCloudDelete";
109 private static final String RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT = "operationalEnvironment";
110 private static final String SOURCE_OPERATIONAL_ENVIRONMENT = "VID";
111 private static final ObjectMapper objectMapper = new ObjectMapper();
115 private static final EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(MsoBusinessLogicImpl.class);
117 * The Mso REST client
118 * This should be replaced with mso client factory.
120 private final MsoInterface msoClientInterface;
123 public MsoBusinessLogicImpl(MsoInterface msoClientInterface) {
124 this.msoClientInterface = msoClientInterface;
127 public static String validateEndpointPath(String endpointEnvVariable) {
128 String endpoint = SystemProperties.getProperty(endpointEnvVariable);
129 if (endpoint == null || endpoint.isEmpty()) {
130 throw new GenericUncheckedException(endpointEnvVariable + " env variable is not defined");
135 // this function should get params from tosca and send them to instance at mso, then return success response.
137 public MsoResponseWrapper createSvcInstance(RequestDetails msoRequest) {
138 logInvocationInDebug("createSvcInstance");
140 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_SVC_INSTANCE);
142 return msoClientInterface.createSvcInstance(msoRequest, endpoint);
146 public MsoResponseWrapper createE2eSvcInstance(Object msoRequest) {
147 logInvocationInDebug("createE2eSvcInstance");
148 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_E2E_SVC_INSTANCE);
150 return msoClientInterface.createE2eSvcInstance(msoRequest, endpoint);
154 public MsoResponseWrapper createVnf(RequestDetails requestDetails, String serviceInstanceId) {
155 logInvocationInDebug("createVnf");
157 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
159 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
160 return msoClientInterface.createVnf(requestDetails, vnfEndpoint);
164 public MsoResponseWrapper createNwInstance(RequestDetails requestDetails, String serviceInstanceId) {
165 logInvocationInDebug("createNwInstance");
168 endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_NETWORK_INSTANCE);
170 String nwEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
171 return msoClientInterface.createNwInstance(requestDetails, nwEndpoint);
175 public MsoResponseWrapper createVolumeGroupInstance(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
176 logInvocationInDebug("createVolumeGroupInstance");
179 endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VOLUME_GROUP_INSTANCE);
181 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
182 vnfEndpoint = vnfEndpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
184 return msoClientInterface.createVolumeGroupInstance(requestDetails, vnfEndpoint);
188 public MsoResponseWrapper createVfModuleInstance(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
189 logInvocationInDebug("createVfModuleInstance");
191 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
193 String partialEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
194 String vfModuleEndpoint = partialEndpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
196 return msoClientInterface.createVfModuleInstance(requestDetails, vfModuleEndpoint);
200 public MsoResponseWrapper scaleOutVfModuleInstance(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
201 logInvocationInDebug("scaleOutVfModuleInstance");
203 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_SCALE_OUT);
205 String partial_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
206 String vf_module_endpoint = partial_endpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
207 RequestDetailsWrapper wrapper = new RequestDetailsWrapper();
208 requestDetails.setVnfName(null);
209 requestDetails.setVnfInstanceId(null);
210 wrapper.requestDetails = requestDetails;
212 return msoClientInterface.scaleOutVFModuleInstance(wrapper, vf_module_endpoint);
216 public MsoResponseWrapper invokeVnfWorkflow(WorkflowRequestDetail request, String userId, UUID serviceInstanceId, UUID vnfInstanceId, UUID workflow_UUID) {
217 logInvocationInDebug("invokeVnfWorkflow");
219 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_WORKFLOW_INSTANCE);
221 String final_endpoint = endpoint
222 .replaceFirst(SVC_INSTANCE_ID, serviceInstanceId.toString())
223 .replaceFirst(WORKFLOW_ID, workflow_UUID.toString())
224 .replaceFirst(VNF_INSTANCE_ID, vnfInstanceId.toString());
226 Map<String,String> extraHeaders = new HashMap<>();
228 UUID requestId = UUID.randomUUID();
229 extraHeaders.put("X-ONAP-RequestID",requestId.toString());
230 extraHeaders.put("X-ONAP-PartnerName","VID");
231 extraHeaders.put("X-RequestorID",userId);
233 return msoClientInterface.invokeWorkflow(request,final_endpoint,extraHeaders);
237 public MsoResponseWrapper createConfigurationInstance(org.onap.vid.mso.rest.RequestDetailsWrapper requestDetailsWrapper, String serviceInstanceId) {
238 logInvocationInDebug("createConfigurationInstance");
240 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATIONS);
241 endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
243 return msoClientInterface.createConfigurationInstance(requestDetailsWrapper, endpoint);
247 public MsoResponseWrapper deleteE2eSvcInstance(Object requestDetails, String serviceInstanceId) {
248 logInvocationInDebug("deleteE2eSvcInstance");
250 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_E2E_SVC_INSTANCE) + "/" + serviceInstanceId;
252 return msoClientInterface.deleteE2eSvcInstance(requestDetails, endpoint);
256 public MsoResponseWrapper deleteSvcInstance(RequestDetails requestDetails, String serviceInstanceId, String serviceStatus) {
257 logInvocationInDebug("deleteSvcInstance");
260 endpoint = validateEndpointPath(MsoProperties.MSO_DELETE_OR_UNASSIGN_REST_API_SVC_INSTANCE);
261 if (shouldUnassignService(serviceStatus)){
262 logger.debug(EELFLoggerDelegate.debugLogger, "unassign service");
263 String svcEndpoint = endpoint + "/" + serviceInstanceId + "/unassign";
264 return msoClientInterface.unassignSvcInstance(requestDetails, svcEndpoint);
267 String svcEndpoint = endpoint + "/" + serviceInstanceId;
268 return msoClientInterface.deleteSvcInstance(requestDetails, svcEndpoint);
271 private boolean shouldUnassignService(String serviceStatus) {
272 return ImmutableList.of("created", "pendingdelete", "pending-delete", "assigned").contains(serviceStatus.toLowerCase());
276 public MsoResponseWrapper deleteVnf(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
277 logInvocationInDebug("deleteVnf");
279 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
280 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
281 vnfEndpoint = vnfEndpoint + '/' + vnfInstanceId;
283 return msoClientInterface.deleteVnf(requestDetails, vnfEndpoint);
287 public MsoResponseWrapper deleteVfModule(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId, String vfModuleId) {
288 logInvocationInDebug("deleteVfModule");
290 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
291 String vfModulesEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId).replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
292 String deleteVfEndpoint = vfModulesEndpoint + '/' + vfModuleId;
294 return msoClientInterface.deleteVfModule(requestDetails, deleteVfEndpoint);
298 public MsoResponseWrapper deleteVolumeGroupInstance(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId, String volumeGroupId) {
299 logInvocationInDebug("deleteVolumeGroupInstance");
301 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VOLUME_GROUP_INSTANCE);
302 String svcEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
303 String vnfEndpoint = svcEndpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
304 String deleteVolumeGroupEndpoint = vnfEndpoint + "/" + volumeGroupId;
306 return msoClientInterface.deleteVolumeGroupInstance(requestDetails, deleteVolumeGroupEndpoint);
310 public MsoResponseWrapper deleteNwInstance(RequestDetails requestDetails, String serviceInstanceId, String networkInstanceId) {
311 logInvocationInDebug("deleteNwInstance");
313 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_NETWORK_INSTANCE);
314 String svcEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
315 String deleteNwEndpoint = svcEndpoint + "/" + networkInstanceId;
317 return msoClientInterface.deleteNwInstance(requestDetails, deleteNwEndpoint);
321 public MsoResponseWrapper getOrchestrationRequest(String requestId) {
322 String methodName = "getOrchestrationRequest";
323 logInvocationInDebug(methodName);
325 String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQ);
326 String path = p + "/" + requestId;
328 return msoClientInterface.getOrchestrationRequest(path);
330 } catch (Exception e) {
331 logException(methodName, e);
337 public MsoResponseWrapper getOrchestrationRequests(String filterString) {
338 String methodName = "getOrchestrationRequest";
339 logInvocationInDebug(methodName);
341 String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQS);
342 String path = p + filterString;
344 return msoClientInterface.getOrchestrationRequest(path);
346 } catch (Exception e) {
347 logException(methodName, e);
353 public List<Request> getOrchestrationRequestsForDashboard() {
354 String methodName = "getOrchestrationRequestsForDashboard";
355 logInvocationInDebug(methodName);
357 List<Request> dashboardOrchestrationReqs = new ArrayList<>();
359 List<RequestWrapper> vnfOrchestrationReqsWrappers = getOrchestrationRequestsByFilter("modelType", "vnf");
360 dashboardOrchestrationReqs = vnfOrchestrationReqsWrappers.stream()
361 .filter(reqWrapper -> Objects.nonNull(reqWrapper.getRequest())
362 && DASHBOARD_ALLOWED_TYPES.contains(upperCase(reqWrapper.getRequest().getRequestType())))
363 .map(RequestWrapper::getRequest)
364 .collect(Collectors.toList());
366 List<RequestWrapper> scaleOutOrchestrationReqWrappers = getOrchestrationRequestsByFilter("action", "scaleOut");
367 List<Request> scaleoutRequests = scaleOutOrchestrationReqWrappers.stream()
368 .filter(reqWrapper -> Objects.nonNull(reqWrapper.getRequest()))
369 .map(RequestWrapper::getRequest)
370 .collect(Collectors.toList());
372 dashboardOrchestrationReqs.addAll(scaleoutRequests);
373 } catch (Exception e) {
374 logException(methodName, e);
377 return dashboardOrchestrationReqs;
380 private String constructOrchestrationRequestFilter(String filterName, String filterValue) {
381 return String.format("%sfilter=%s:EQUALS:%s",
382 SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQS), filterName, filterValue);
385 private List<RequestWrapper> getOrchestrationRequestsByFilter(String filterName, String filterValue) {
386 String orchestrationReqPath = constructOrchestrationRequestFilter(filterName, filterValue);
387 RestObject<String> restObjStr = new RestObject<>();
388 String str = new String();
390 MsoResponseWrapper msoResponseWrapper = msoClientInterface.getOrchestrationRequest(str, "", orchestrationReqPath, restObjStr, true);
391 return deserializeOrchestrationRequestsJson(msoResponseWrapper.getEntity());
394 private List<RequestWrapper> deserializeOrchestrationRequestsJson(String orchestrationRequestsJson) {
395 logInvocationInDebug("deserializeOrchestrationRequestsJson");
397 ObjectMapper mapper = jacksonObjectMapper();
398 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
399 mapper.configure(DeserializationFeature.READ_ENUMS_USING_TO_STRING, true);
400 RequestList requestList;
402 requestList = mapper.readValue(orchestrationRequestsJson, RequestList.class);
403 } catch (IOException e) {
404 throw new GenericUncheckedException(e);
406 return ListUtils.emptyIfNull(requestList.getRequestList());
411 public List<Task> getManualTasksByRequestId(String originalRequestId) {
412 String methodName = "getManualTasksByRequestId";
413 logInvocationInDebug(methodName);
416 String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_MAN_TASKS);
417 String path = p + "?originalRequestId=" + originalRequestId;
419 RestObject<String> restObjStr = new RestObject<>();
423 MsoResponseWrapper msoResponseWrapper = msoClientInterface.getManualTasksByRequestId(str, "", path, restObjStr);
424 return deserializeManualTasksJson(msoResponseWrapper.getEntity());
426 } catch (Exception e) {
427 logException(methodName, e);
432 private List<Task> deserializeManualTasksJson(String manualTasksJson) {
433 logInvocationInDebug("deserializeManualTasksJson");
436 TaskList taskList = JACKSON_OBJECT_MAPPER.readValue(manualTasksJson, TaskList.class);
437 return taskList.getTaskList();
438 } catch (IOException e) {
439 throw new GenericUncheckedException(e);
445 public MsoResponseWrapper completeManualTask(RequestDetails requestDetails, String taskId) {
446 String methodName = "completeManualTask";
447 logInvocationInDebug(methodName);
449 String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_MAN_TASKS);
450 String path = p + "/" + taskId + "/complete";
452 RestObject<String> restObjStr = new RestObject<>();
456 return msoClientInterface.completeManualTask(requestDetails, str, "", path, restObjStr);
458 } catch (Exception e) {
459 logException(methodName, e);
465 public MsoResponseWrapper activateServiceInstance(RequestDetails requestDetails, String serviceInstanceId) {
466 String methodName = "activateServiceInstance";
467 logInvocationInDebug(methodName);
469 String serviceEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_SVC_INSTANCE);
470 String activateServicePath = serviceEndpoint + "/" + serviceInstanceId + ACTIVATE;
472 RestObject<String> restObjStr = new RestObject<>();
476 msoClientInterface.setServiceInstanceStatus(requestDetails, activateServicePath);
478 return MsoUtil.wrapResponse(restObjStr);
480 } catch (Exception e) {
481 logException(methodName, e);
488 public MsoResponseWrapperInterface updateVnf(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
489 logInvocationInDebug("updateVnf");
492 endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
493 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
494 vnfEndpoint = vnfEndpoint + '/' + vnfInstanceId;
495 return msoClientInterface.updateVnf(requestDetails, vnfEndpoint);
499 public MsoResponseWrapperInterface replaceVnf(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
500 logInvocationInDebug("replaceVnf");
502 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_CHANGE_MANAGEMENT_INSTANCE);
503 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
504 vnfEndpoint = vnfEndpoint.replace(VNF_INSTANCE_ID, vnfInstanceId);
505 vnfEndpoint = vnfEndpoint.replace(REQUEST_TYPE, MsoChangeManagementRequest.REPLACE);
506 return msoClientInterface.replaceVnf(requestDetails, vnfEndpoint);
509 public RequestDetailsWrapper generateInPlaceMsoRequest(org.onap.vid.changeManagement.RequestDetails requestDetails) {
510 validateUpdateVnfSoftwarePayload(requestDetails);
511 RequestDetails inPlaceSoftwareUpdateRequest = new RequestDetails();
512 inPlaceSoftwareUpdateRequest.setCloudConfiguration(requestDetails.getCloudConfiguration());
513 inPlaceSoftwareUpdateRequest.setRequestParameters(requestDetails.getRequestParameters());
514 inPlaceSoftwareUpdateRequest.setRequestInfo(requestDetails.getRequestInfo());
515 RequestDetailsWrapper requestDetailsWrapper = new RequestDetailsWrapper();
516 requestDetailsWrapper.requestDetails = inPlaceSoftwareUpdateRequest;
517 return requestDetailsWrapper;
521 public RequestDetailsWrapper generateConfigMsoRequest(org.onap.vid.changeManagement.RequestDetails requestDetails) {
522 validateUpdateVnfConfig(requestDetails);
523 RequestDetails configUpdateRequest = new RequestDetails();
524 configUpdateRequest.setRequestParameters(requestDetails.getRequestParameters());
525 configUpdateRequest.setRequestInfo(requestDetails.getRequestInfo());
526 RequestDetailsWrapper requestDetailsWrapper = new RequestDetailsWrapper();
527 requestDetailsWrapper.requestDetails = configUpdateRequest;
528 return requestDetailsWrapper;
532 public String getActivateFabricConfigurationPath(String serviceInstanceId) {
533 String path = validateEndpointPath(MsoProperties.MSO_REST_API_SERVICE_INSTANCE_CREATE);
534 path += "/" + serviceInstanceId + ACTIVATE_FABRIC_CONFIGURATION;
540 public String getDeactivateAndCloudDeletePath(String serviceInstanceId, String vnfInstanceId, String vfModuleInstanceId) {
541 String path = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
542 path = path.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
543 path = path.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
544 path += "/" + vfModuleInstanceId + DEACTIVATE_AND_CLOUD_DELETE;
550 public RequestDetails buildRequestDetailsForSoftDelete(SoftDeleteRequest softDeleteRequest) {
551 RequestDetails requestDetails = new RequestDetails();
552 RequestInfo requestInfo = new RequestInfo();
553 requestInfo.setSource("VID");
554 requestInfo.setRequestorId(softDeleteRequest.getUserId());
555 requestDetails.setRequestInfo(requestInfo);
557 CloudConfiguration cloudConfiguration = new CloudConfiguration(softDeleteRequest.getLcpCloudRegionId(), softDeleteRequest.getTenantId(), null);
558 requestDetails.setCloudConfiguration(cloudConfiguration);
560 ModelInfo modelInfo = new ModelInfo();
561 modelInfo.setModelType("vfModule");
562 requestDetails.setModelInfo(modelInfo);
564 RequestParameters requestParameters = new RequestParameters();
565 requestParameters.setTestApi("GR_API");
566 requestDetails.setRequestParameters(requestParameters);
568 return requestDetails;
572 public SOWorkflowList getWorkflowListByModelId(String modelVersionId) {
573 logInvocationInDebug("getWorkflowListByModelId");
574 String pathTemplate = validateEndpointPath(MSO_REST_API_WORKFLOW_SPECIFICATIONS);
575 String path = pathTemplate.replaceFirst("<model_version_id>", modelVersionId);
577 HttpResponse<SOWorkflowList> workflowListByModelId = msoClientInterface.getWorkflowListByModelId(path);
578 if (!isSuccessful(workflowListByModelId)) {
579 logger.error(EELFLoggerDelegate.errorLogger, workflowListByModelId.getStatusText());
580 throw new WorkflowListException(String.format("Get worklflow list for id: %s failed due to %s", modelVersionId, workflowListByModelId.getStatusText()));
582 return workflowListByModelId.getBody();
587 public MsoResponseWrapperInterface updateVnfSoftware(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
588 logInvocationInDebug("updateVnfSoftware");
589 String vnfEndpoint = getChangeManagementEndpoint(serviceInstanceId, vnfInstanceId, MsoChangeManagementRequest.SOFTWARE_UPDATE); //workflow name in mso is different than workflow name in vid UI
590 RequestDetailsWrapper finalRequestDetails = generateInPlaceMsoRequest(requestDetails);
591 return msoClientInterface.changeManagementUpdate(finalRequestDetails, vnfEndpoint);
595 public MsoResponseWrapperInterface updateVnfConfig(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
596 logInvocationInDebug("updateVnfConfig");
597 RequestDetailsWrapper finalRequestDetails = generateConfigMsoRequest(requestDetails);
598 String vnfEndpoint = getChangeManagementEndpoint(serviceInstanceId, vnfInstanceId, MsoChangeManagementRequest.CONFIG_UPDATE);
599 return msoClientInterface.changeManagementUpdate(finalRequestDetails, vnfEndpoint);
602 private String getChangeManagementEndpoint(String serviceInstanceId, String vnfInstanceId, String vnfRequestType) {
603 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_CHANGE_MANAGEMENT_INSTANCE);
604 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
605 vnfEndpoint = vnfEndpoint.replace(VNF_INSTANCE_ID, vnfInstanceId);
606 vnfEndpoint = vnfEndpoint.replace(REQUEST_TYPE, vnfRequestType);
610 private Map getChangeManagementPayload(RequestDetails requestDetails, String message) {
611 if (requestDetails.getRequestParameters() == null || requestDetails.getRequestParameters().getAdditionalProperties() == null) {
612 throw new BadRequestException(message);
614 Object payloadRaw = requestDetails.getRequestParameters().getAdditionalProperties().get("payload");
616 return JACKSON_OBJECT_MAPPER.readValue((String) payloadRaw, Map.class);
617 } catch (Exception exception) {
618 throw new BadRequestException(message);
622 private void validateUpdateVnfSoftwarePayload(RequestDetails requestDetails) {
623 final String noValidPayloadMsg = "No valid payload in " + ChangeManagementRequest.VNF_IN_PLACE_SOFTWARE_UPDATE + " request";
625 Map payload = getChangeManagementPayload(requestDetails, noValidPayloadMsg);
626 validateUpdateVnfSoftwarePayloadProperty(payload, noValidPayloadMsg, "existing_software_version", SOFTWARE_VERSION_PATTERN);
627 validateUpdateVnfSoftwarePayloadProperty(payload, noValidPayloadMsg, "new_software_version", SOFTWARE_VERSION_PATTERN);
629 //if "operations_timeout" is not integer, trying to read it as String that represent a number
630 if (!(payload.get("operations_timeout") instanceof Integer)) {
631 validateUpdateVnfSoftwarePayloadProperty(payload, noValidPayloadMsg, "operations_timeout", NUMBER_PATTERN);
635 private void validateUpdateVnfSoftwarePayloadProperty(Map payload, String noValidPayloadMsg, String propertyName, Pattern pattern) {
636 Object forValidation = payload.get(propertyName);
637 final String noValidPayloadPropertyMsg = noValidPayloadMsg + ", " + propertyName + " property is not valid";
638 if (!(forValidation instanceof String)) {
639 throw new BadRequestException(noValidPayloadPropertyMsg);
641 if (!pattern.matcher((String) forValidation).matches()) {
642 throw new BadRequestException(noValidPayloadPropertyMsg);
647 public MsoResponseWrapper deleteConfiguration(org.onap.vid.mso.rest.RequestDetailsWrapper requestDetailsWrapper,
648 String serviceInstanceId,
649 String configurationId) {
651 logInvocationInDebug("deleteConfiguration");
652 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATION_INSTANCE);
653 endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
654 endpoint = endpoint.replace(CONFIGURATION_ID, configurationId);
656 return msoClientInterface.deleteConfiguration(requestDetailsWrapper, endpoint);
660 public MsoResponseWrapper setConfigurationActiveStatus(
661 RequestDetails requestDetails,
662 String serviceInstanceId,
663 String configurationId,
664 boolean isActivate) {
666 logInvocationInDebug("setConfigurationActiveStatus");
668 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATION_INSTANCE);
669 endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
670 endpoint = endpoint.replace(CONFIGURATION_ID, configurationId);
672 String isActivateState = (isActivate ? ACTIVATE : DEACTIVATE);
673 endpoint = endpoint + isActivateState;
675 return msoClientInterface.setConfigurationActiveStatus(requestDetails, endpoint);
679 public MsoResponseWrapper setServiceInstanceStatus(RequestDetails requestDetails, String serviceInstanceId, boolean isActivate) {
680 logInvocationInDebug("setServiceInstanceStatus");
681 String methodName = "setServiceInstanceStatus";
683 String serviceEndpoint = validateEndpointPath(MsoProperties.MSO_REST_API_SVC_INSTANCE);
684 String endpoint = serviceEndpoint + "/" + serviceInstanceId;
686 String isActivateState = (isActivate ? ACTIVATE : DEACTIVATE);
687 endpoint = endpoint + isActivateState;
689 return msoClientInterface.setServiceInstanceStatus(requestDetails, endpoint);
690 } catch (Exception e) {
691 logger.error(EELFLoggerDelegate.errorLogger, methodName + e.toString());
692 logger.debug(EELFLoggerDelegate.debugLogger, methodName + e.toString());
698 public MsoResponseWrapper setPortOnConfigurationStatus(
699 RequestDetails requestDetails,
700 String serviceInstanceId,
701 String configurationId,
703 logInvocationInDebug("setPortOnConfigurationStatus");
705 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATION_INSTANCE);
706 endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
707 endpoint = endpoint.replace(CONFIGURATION_ID, configurationId);
709 String isEnablePortStatus = (isEnable ? ENABLE_PORT : DISABLE_PORT);
710 endpoint = endpoint + isEnablePortStatus;
712 return msoClientInterface.setPortOnConfigurationStatus(requestDetails, endpoint);
717 public RequestDetailsWrapper<RequestDetails> createOperationalEnvironmentActivationRequestDetails(OperationalEnvironmentActivateInfo details) {
718 RequestDetails requestDetails = new RequestDetails();
719 RequestInfo requestInfo = new RequestInfo();
720 requestInfo.setAdditionalProperty(RESOURCE_TYPE, RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT);
721 requestInfo.setSource(SOURCE_OPERATIONAL_ENVIRONMENT);
722 requestInfo.setRequestorId(details.getUserId());
723 requestDetails.setRequestInfo(requestInfo);
725 RelatedInstance relatedInstance = new RelatedInstance();
726 relatedInstance.setAdditionalProperty(RESOURCE_TYPE, RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT);
727 relatedInstance.setInstanceId(details.getRelatedInstanceId());
728 relatedInstance.setInstanceName(details.getRelatedInstanceName());
729 requestDetails.setAdditionalProperty("relatedInstanceList", Collections.singletonList(ImmutableMap.of("relatedInstance", relatedInstance)));
731 RequestParameters requestParameters = new RequestParameters();
732 requestParameters.setUserParams(null);
733 requestParameters.setAdditionalProperty("operationalEnvironmentType", "VNF");
734 requestParameters.setAdditionalProperty("workloadContext", details.getWorkloadContext());
735 requestParameters.setAdditionalProperty("manifest", details.getManifest());
736 requestDetails.setRequestParameters(requestParameters);
738 RequestDetailsWrapper<RequestDetails> requestDetailsWrapper = new RequestDetailsWrapper<>(requestDetails);
740 debugRequestDetails(requestDetailsWrapper, logger);
742 return requestDetailsWrapper;
746 public String getOperationalEnvironmentActivationPath(OperationalEnvironmentActivateInfo details) {
747 String path = validateEndpointPath(MSO_REST_API_OPERATIONAL_ENVIRONMENT_ACTIVATE);
748 path = path.replace("<operational_environment_id>", details.getOperationalEnvironmentId());
753 public RequestDetailsWrapper<RequestDetails> createOperationalEnvironmentDeactivationRequestDetails(OperationalEnvironmentDeactivateInfo details) {
754 RequestDetails requestDetails = new RequestDetails();
756 RequestInfo requestInfo = new RequestInfo();
757 requestInfo.setAdditionalProperty(RESOURCE_TYPE, RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT);
758 requestInfo.setSource(SOURCE_OPERATIONAL_ENVIRONMENT);
759 requestInfo.setRequestorId(details.getUserId());
760 requestDetails.setRequestInfo(requestInfo);
762 RequestParameters requestParameters = new RequestParameters();
763 requestParameters.setUserParams(null);
764 requestParameters.setAdditionalProperty("operationalEnvironmentType", "VNF");
765 requestDetails.setRequestParameters(requestParameters);
766 RequestDetailsWrapper<RequestDetails> requestDetailsWrapper = new RequestDetailsWrapper<>(requestDetails);
767 debugRequestDetails(requestDetailsWrapper, logger);
768 return requestDetailsWrapper;
772 public String getCloudResourcesRequestsStatusPath(String requestId) {
773 String path = validateEndpointPath(MSO_REST_API_CLOUD_RESOURCES_REQUEST_STATUS);
774 path = path.replace("<request_id>", requestId);
779 public String getOperationalEnvironmentDeactivationPath(OperationalEnvironmentDeactivateInfo details) {
780 String path = validateEndpointPath(MSO_REST_API_OPERATIONAL_ENVIRONMENT_DEACTIVATE);
781 path = path.replace("<operational_environment_id>", details.getOperationalEnvironmentId());
786 public String getOperationalEnvironmentCreationPath() {
787 return validateEndpointPath(MSO_REST_API_OPERATIONAL_ENVIRONMENT_CREATE);
792 public RequestDetailsWrapper<OperationEnvironmentRequestDetails> convertParametersToRequestDetails(OperationalEnvironmentController.OperationalEnvironmentCreateBody input, String userId) {
793 OperationEnvironmentRequestDetails.RequestInfo requestInfo = new OperationEnvironmentRequestDetails.RequestInfo(
794 RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT,
795 input.getInstanceName(),
796 SOURCE_OPERATIONAL_ENVIRONMENT,
799 OperationEnvironmentRequestDetails.RelatedInstance relatedInstance = new OperationEnvironmentRequestDetails.RelatedInstance(
800 RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT,
801 input.getEcompInstanceId(),
802 input.getEcompInstanceName());
804 List<OperationEnvironmentRequestDetails.RelatedInstance> relatedInstanceList = Collections.singletonList((relatedInstance));
806 OperationEnvironmentRequestDetails.RequestParameters requestParameters = new OperationEnvironmentRequestDetails.RequestParameters(
807 input.getOperationalEnvironmentType(),
808 input.getTenantContext(),
809 input.getWorkloadContext());
811 OperationEnvironmentRequestDetails requestDetails = new OperationEnvironmentRequestDetails(requestInfo, relatedInstanceList, requestParameters);
812 RequestDetailsWrapper<OperationEnvironmentRequestDetails> requestDetailsWrapper = new RequestDetailsWrapper<>(requestDetails);
813 debugRequestDetails(requestDetailsWrapper, logger);
814 return requestDetailsWrapper;
818 public MsoResponseWrapper removeRelationshipFromServiceInstance(RequestDetails requestDetails, String serviceInstanceId) {
819 logInvocationInDebug("removeRelationshipFromServiceInstance");
821 String serviceEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_SVC_INSTANCE);
822 String removeRelationshipsPath = serviceEndpoint + "/" + serviceInstanceId + "/removeRelationships";
824 return msoClientInterface.removeRelationshipFromServiceInstance(requestDetails, removeRelationshipsPath);
828 public MsoResponseWrapper addRelationshipToServiceInstance(RequestDetails requestDetails, String serviceInstanceId) {
829 logInvocationInDebug("addRelationshipToServiceInstance");
831 String serviceEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_SVC_INSTANCE);
832 String addRelationshipsPath = serviceEndpoint + "/" + serviceInstanceId + "/addRelationships";
834 return msoClientInterface.addRelationshipToServiceInstance(requestDetails, addRelationshipsPath);
839 public ExternalComponentStatus probeComponent() {
840 String url = SystemProperties.getProperty(
841 MsoProperties.MSO_SERVER_URL) + "/" + SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQS);
842 long startTime = System.currentTimeMillis();
843 ExternalComponentStatus externalComponentStatus;
846 String rawBody = objectMapper.writeValueAsString(getOrchestrationRequestsForDashboard());
847 StatusMetadata statusMetadata=new HttpRequestMetadata(HttpMethod.GET,200,url,rawBody,"VID-SO",System.currentTimeMillis() - startTime);
849 externalComponentStatus = new ExternalComponentStatus(ExternalComponentStatus.Component.MSO, true, statusMetadata);
850 } catch (Exception e) {
851 StatusMetadata statusMetadata = new HttpRequestMetadata(HttpMethod.GET, HttpStatus.INTERNAL_SERVER_ERROR.value(), url, "", e.getMessage(), System.currentTimeMillis() - startTime);
852 externalComponentStatus = new ExternalComponentStatus(ExternalComponentStatus.Component.MSO, false, statusMetadata);
855 return externalComponentStatus;
858 private void validateUpdateVnfConfig(RequestDetails requestDetails) {
859 final String noValidPayloadMsg = "No valid payload in " + ChangeManagementRequest.CONFIG_UPDATE + " request";
861 Map payload = getChangeManagementPayload(requestDetails, noValidPayloadMsg);
862 validateConfigUpdateVnfPayloadProperty(payload, noValidPayloadMsg, "request-parameters");
863 validateConfigUpdateVnfPayloadProperty(payload, noValidPayloadMsg, "configuration-parameters");
866 private void validateConfigUpdateVnfPayloadProperty(Map payload, String noValidPayloadMsg, String propertyName) {
867 final String noValidPayloadPropertyMsg = noValidPayloadMsg + ", " + propertyName + " property is not valid";
868 if (!payload.containsKey(propertyName)) {
869 throw new BadRequestException(noValidPayloadPropertyMsg);
873 private void logInvocationInDebug(String methodName) {
874 logger.debug(EELFLoggerDelegate.debugLogger, methodName + " start");
877 private void logException(String methodName, Exception e) {
878 logger.error(EELFLoggerDelegate.errorLogger, methodName + e.toString());
879 logger.debug(EELFLoggerDelegate.debugLogger, methodName + e.toString());
882 private boolean isSuccessful(HttpResponse<SOWorkflowList> workflowListByModelId) {
883 int status = workflowListByModelId.getStatus();
884 return HttpStatus.OK.value() == status || HttpStatus.ACCEPTED.value() == status;
887 static class WorkflowListException extends RuntimeException{
889 WorkflowListException(String message) {
894 public enum RequestType {
896 CREATE_INSTANCE("createInstance"),
897 DELETE_INSTANCE("deleteInstance"),
898 REPLACE_INSTANCE("replaceInstance"),
899 UPDATE_INSTANCE("updateInstance"),
900 ACTIVATE_INSTANCE("activateInstance"),
901 DEACTIVATE_INSTANCE("deactivateInstance"),
902 APPLY_UPDATED_CONFIG("applyUpdatedConfig"),
903 IN_PLACE_SOFTWARE_UPDATE("inPlaceSoftwareUpdate"),
904 SCALE_OUT("scaleOut"),
906 NOT_PROVIDED("not provided");
907 private final String value;
908 private static final Map<String, RequestType> CONSTANTS = new HashMap<>();
911 for (RequestType c : values()) {
912 CONSTANTS.put(c.value, c);
916 RequestType(String value) {
921 public static RequestType fromValue(String value) {
922 RequestType constant = CONSTANTS.get(value);
923 if (constant == null) {
924 throw new IllegalArgumentException(value);
932 public String toString() {