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 com.fasterxml.jackson.annotation.JsonCreator;
24 import com.fasterxml.jackson.annotation.JsonValue;
25 import com.fasterxml.jackson.databind.DeserializationFeature;
26 import com.fasterxml.jackson.databind.ObjectMapper;
27 import com.google.common.collect.ImmutableList;
28 import com.google.common.collect.ImmutableMap;
29 import io.joshworks.restclient.http.HttpResponse;
30 import org.apache.commons.collections4.ListUtils;
31 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
32 import org.onap.portalsdk.core.util.SystemProperties;
33 import org.onap.vid.changeManagement.ChangeManagementRequest;
34 import org.onap.vid.changeManagement.RequestDetailsWrapper;
35 import org.onap.vid.changeManagement.WorkflowRequestDetail;
36 import org.onap.vid.controller.OperationalEnvironmentController;
37 import org.onap.vid.exceptions.GenericUncheckedException;
38 import org.onap.vid.model.RequestReferencesContainer;
39 import org.onap.vid.model.SOWorkflowList;
40 import org.onap.vid.model.SoftDeleteRequest;
41 import org.onap.vid.model.probes.ExternalComponentStatus;
42 import org.onap.vid.model.probes.HttpRequestMetadata;
43 import org.onap.vid.model.probes.StatusMetadata;
44 import org.onap.vid.mso.model.CloudConfiguration;
45 import org.onap.vid.mso.model.ModelInfo;
46 import org.onap.vid.mso.model.OperationalEnvironmentActivateInfo;
47 import org.onap.vid.mso.model.OperationalEnvironmentDeactivateInfo;
48 import org.onap.vid.mso.model.RequestInfo;
49 import org.onap.vid.mso.model.RequestParameters;
50 import org.onap.vid.mso.rest.OperationalEnvironment.OperationEnvironmentRequestDetails;
51 import org.onap.vid.mso.rest.RelatedInstance;
52 import org.onap.vid.mso.rest.Request;
53 import org.onap.vid.mso.rest.RequestDetails;
54 import org.onap.vid.mso.rest.RequestList;
55 import org.onap.vid.mso.rest.RequestWrapper;
56 import org.onap.vid.mso.rest.Task;
57 import org.onap.vid.mso.rest.TaskList;
58 import org.springframework.beans.factory.annotation.Autowired;
59 import org.springframework.http.HttpMethod;
60 import org.springframework.http.HttpStatus;
61 import org.togglz.core.manager.FeatureManager;
63 import javax.ws.rs.BadRequestException;
64 import java.io.IOException;
65 import java.util.ArrayList;
66 import java.util.Collections;
67 import java.util.HashMap;
68 import java.util.List;
70 import java.util.Objects;
71 import java.util.UUID;
72 import java.util.regex.Pattern;
73 import java.util.stream.Collectors;
74 import java.util.stream.Stream;
76 import static java.util.stream.Collectors.collectingAndThen;
77 import static java.util.stream.Collectors.toList;
78 import static org.apache.commons.lang.StringUtils.upperCase;
79 import static org.onap.vid.changeManagement.ChangeManagementRequest.MsoChangeManagementRequest;
80 import static org.onap.vid.controller.MsoController.CONFIGURATION_ID;
81 import static org.onap.vid.controller.MsoController.REQUEST_TYPE;
82 import static org.onap.vid.controller.MsoController.SVC_INSTANCE_ID;
83 import static org.onap.vid.controller.MsoController.VNF_INSTANCE_ID;
84 import static org.onap.vid.controller.MsoController.WORKFLOW_ID;
85 import static org.onap.vid.mso.MsoProperties.MSO_REST_API_CLOUD_RESOURCES_REQUEST_STATUS;
86 import static org.onap.vid.mso.MsoProperties.MSO_REST_API_OPERATIONAL_ENVIRONMENT_ACTIVATE;
87 import static org.onap.vid.mso.MsoProperties.MSO_REST_API_OPERATIONAL_ENVIRONMENT_CREATE;
88 import static org.onap.vid.mso.MsoProperties.MSO_REST_API_OPERATIONAL_ENVIRONMENT_DEACTIVATE;
89 import static org.onap.vid.mso.MsoProperties.MSO_REST_API_WORKFLOW_SPECIFICATIONS;
90 import static org.onap.vid.properties.Features.FLAG_UNASSIGN_SERVICE;
91 import static org.onap.vid.utils.Logging.debugRequestDetails;
93 public class MsoBusinessLogicImpl implements MsoBusinessLogic {
95 static final List<String> DASHBOARD_ALLOWED_TYPES = Stream.of(RequestType.REPLACE_INSTANCE,
96 RequestType.UPDATE_INSTANCE,
97 RequestType.APPLY_UPDATED_CONFIG,
98 RequestType.IN_PLACE_SOFTWARE_UPDATE,
99 RequestType.SCALE_OUT)
100 .map(requestType -> requestType.toString().toUpperCase())
101 .collect(collectingAndThen(toList(), Collections::unmodifiableList));
102 private static final String RESOURCE_TYPE = "resourceType";
103 private static final Pattern SOFTWARE_VERSION_PATTERN = Pattern.compile("^[A-Za-z0-9.\\-]+$");
104 private static final Pattern NUMBER_PATTERN = Pattern.compile("^[0-9]+$");
105 private static final String ACTIVATE = "/activate";
106 private static final String DEACTIVATE = "/deactivate";
107 private static final String ENABLE_PORT = "/enablePort";
108 private static final String DISABLE_PORT = "/disablePort";
109 private static final String ACTIVATE_FABRIC_CONFIGURATION = "/activateFabricConfiguration";
110 private static final String DEACTIVATE_AND_CLOUD_DELETE = "/deactivateAndCloudDelete";
111 private static final String RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT = "operationalEnvironment";
112 private static final String SOURCE_OPERATIONAL_ENVIRONMENT = "VID";
113 private static final ObjectMapper objectMapper = new ObjectMapper();
117 private static final EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(MsoBusinessLogicImpl.class);
119 * The Mso REST client
120 * This should be replaced with mso client factory.
122 private final MsoInterface msoClientInterface;
123 FeatureManager featureManager;
126 public MsoBusinessLogicImpl(MsoInterface msoClientInterface, FeatureManager featureManager) {
127 this.msoClientInterface = msoClientInterface;
128 this.featureManager = featureManager;
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_REST_API_SVC_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");
171 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_NETWORK_INSTANCE);
173 String nw_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
174 return msoClientInterface.createNwInstance(requestDetails, nw_endpoint);
178 public MsoResponseWrapper createVolumeGroupInstance(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
179 logInvocationInDebug("createVolumeGroupInstance");
181 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VOLUME_GROUP_INSTANCE);
183 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
184 vnfEndpoint = vnfEndpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
186 return msoClientInterface.createVolumeGroupInstance(requestDetails, vnfEndpoint);
190 public MsoResponseWrapper createVfModuleInstance(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
191 logInvocationInDebug("createVfModuleInstance");
193 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
195 String partial_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
196 String vf_module_endpoint = partial_endpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
198 return msoClientInterface.createVfModuleInstance(requestDetails, vf_module_endpoint);
202 public MsoResponseWrapper scaleOutVfModuleInstance(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
203 logInvocationInDebug("scaleOutVfModuleInstance");
205 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_SCALE_OUT);
207 String partial_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
208 String vf_module_endpoint = partial_endpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
209 RequestDetailsWrapper wrapper = new RequestDetailsWrapper();
210 requestDetails.setVnfName(null);
211 requestDetails.setVnfInstanceId(null);
212 wrapper.requestDetails = requestDetails;
214 return msoClientInterface.scaleOutVFModuleInstance(wrapper, vf_module_endpoint);
218 public MsoResponseWrapper invokeVnfWorkflow(WorkflowRequestDetail request, String userId, UUID serviceInstanceId, UUID vnfInstanceId, UUID workflow_UUID) {
219 logInvocationInDebug("invokeVnfWorkflow");
221 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_WORKFLOW_INSTANCE);
223 String final_endpoint = endpoint
224 .replaceFirst(SVC_INSTANCE_ID, serviceInstanceId.toString())
225 .replaceFirst(WORKFLOW_ID, workflow_UUID.toString())
226 .replaceFirst(VNF_INSTANCE_ID, vnfInstanceId.toString());
228 Map<String,String> extraHeaders = new HashMap<>();
230 UUID requestId = UUID.randomUUID();
231 extraHeaders.put("X-ONAP-RequestID",requestId.toString());
232 extraHeaders.put("X-ONAP-PartnerName","VID");
233 extraHeaders.put("X-RequestorID",userId);
235 return msoClientInterface.invokeWorkflow(request,final_endpoint,extraHeaders);
239 public MsoResponseWrapper createConfigurationInstance(org.onap.vid.mso.rest.RequestDetailsWrapper requestDetailsWrapper, String serviceInstanceId) {
240 logInvocationInDebug("createConfigurationInstance");
242 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATIONS);
243 endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
245 return msoClientInterface.createConfigurationInstance(requestDetailsWrapper, endpoint);
249 public MsoResponseWrapper deleteE2eSvcInstance(Object requestDetails, String serviceInstanceId) {
250 logInvocationInDebug("deleteE2eSvcInstance");
252 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_E2E_SVC_INSTANCE) + "/" + serviceInstanceId;
254 return msoClientInterface.deleteE2eSvcInstance(requestDetails, endpoint);
258 public MsoResponseWrapper deleteSvcInstance(RequestDetails requestDetails, String serviceInstanceId, String serviceStatus) {
259 logInvocationInDebug("deleteSvcInstance");
262 if (featureManager.isActive(FLAG_UNASSIGN_SERVICE)) {
263 endpoint = validateEndpointPath(MsoProperties.MSO_DELETE_OR_UNASSIGN_REST_API_SVC_INSTANCE);
264 if (shouldUnassignService(serviceStatus)) {
265 logger.debug(EELFLoggerDelegate.debugLogger, "unassign service");
266 String svc_endpoint = endpoint + "/" + serviceInstanceId + "/unassign";
267 return msoClientInterface.unassignSvcInstance(requestDetails, svc_endpoint);
270 endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_SVC_INSTANCE);
273 String svc_endpoint = endpoint + "/" + serviceInstanceId;
274 return msoClientInterface.deleteSvcInstance(requestDetails, svc_endpoint);
277 private boolean shouldUnassignService(String serviceStatus) {
278 return ImmutableList.of("created", "pendingdelete", "pending-delete", "assigned").contains(serviceStatus.toLowerCase());
282 public MsoResponseWrapper deleteVnf(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
283 logInvocationInDebug("deleteVnf");
285 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
286 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
287 vnfEndpoint = vnfEndpoint + '/' + vnfInstanceId;
289 return msoClientInterface.deleteVnf(requestDetails, vnfEndpoint);
293 public MsoResponseWrapper deleteVfModule(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId, String vfModuleId) {
294 logInvocationInDebug("deleteVfModule");
296 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
297 String vf__modules_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId).replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
298 String delete_vf_endpoint = vf__modules_endpoint + '/' + vfModuleId;
300 return msoClientInterface.deleteVfModule(requestDetails, delete_vf_endpoint);
304 public MsoResponseWrapper deleteVolumeGroupInstance(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId, String volumeGroupId) {
305 logInvocationInDebug("deleteVolumeGroupInstance");
307 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VOLUME_GROUP_INSTANCE);
308 String svc_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
309 String vnfEndpoint = svc_endpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
310 String delete_volume_group_endpoint = vnfEndpoint + "/" + volumeGroupId;
312 return msoClientInterface.deleteVolumeGroupInstance(requestDetails, delete_volume_group_endpoint);
316 public MsoResponseWrapper deleteNwInstance(RequestDetails requestDetails, String serviceInstanceId, String networkInstanceId) {
317 logInvocationInDebug("deleteNwInstance");
319 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_NETWORK_INSTANCE);
320 String svc_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
321 String delete_nw_endpoint = svc_endpoint + "/" + networkInstanceId;
323 return msoClientInterface.deleteNwInstance(requestDetails, delete_nw_endpoint);
327 public MsoResponseWrapper getOrchestrationRequest(String requestId) {
328 String methodName = "getOrchestrationRequest";
329 logInvocationInDebug(methodName);
331 String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQ);
332 String path = p + "/" + requestId;
334 return msoClientInterface.getOrchestrationRequest(path);
336 } catch (Exception e) {
337 logException(methodName, e);
343 public MsoResponseWrapper getOrchestrationRequests(String filterString) {
344 String methodName = "getOrchestrationRequest";
345 logInvocationInDebug(methodName);
347 String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQS);
348 String path = p + filterString;
350 return msoClientInterface.getOrchestrationRequest(path);
352 } catch (Exception e) {
353 logException(methodName, e);
359 public List<Request> getOrchestrationRequestsForDashboard() {
360 String methodName = "getOrchestrationRequestsForDashboard";
361 logInvocationInDebug(methodName);
363 List<Request> dashboardOrchestrationReqs = new ArrayList<>();
365 List<RequestWrapper> vnfOrchestrationReqsWrappers = getOrchestrationRequestsByFilter("modelType", "vnf");
366 dashboardOrchestrationReqs = vnfOrchestrationReqsWrappers.stream()
367 .filter(reqWrapper -> Objects.nonNull(reqWrapper.getRequest())
368 && DASHBOARD_ALLOWED_TYPES.contains(upperCase(reqWrapper.getRequest().getRequestType())))
369 .map(RequestWrapper::getRequest)
370 .collect(Collectors.toList());
372 List<RequestWrapper> scaleOutOrchestrationReqWrappers = getOrchestrationRequestsByFilter("action", "scaleOut");
373 List<Request> scaleoutRequests = scaleOutOrchestrationReqWrappers.stream()
374 .filter(reqWrapper -> Objects.nonNull(reqWrapper.getRequest()))
375 .map(RequestWrapper::getRequest)
376 .collect(Collectors.toList());
378 dashboardOrchestrationReqs.addAll(scaleoutRequests);
379 } catch (Exception e) {
380 logException(methodName, e);
383 return dashboardOrchestrationReqs;
386 private String constructOrchestrationRequestFilter(String filterName, String filterValue) {
387 return String.format("%sfilter=%s:EQUALS:%s",
388 SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQS), filterName, filterValue);
391 private List<RequestWrapper> getOrchestrationRequestsByFilter(String filterName, String filterValue) {
392 String orchestrationReqPath = constructOrchestrationRequestFilter(filterName, filterValue);
393 RestObject<String> restObjStr = new RestObject<>();
394 String str = new String();
396 MsoResponseWrapper msoResponseWrapper = msoClientInterface.getOrchestrationRequest(str, "", orchestrationReqPath, restObjStr, true);
397 return deserializeOrchestrationRequestsJson(msoResponseWrapper.getEntity());
400 private List<RequestWrapper> deserializeOrchestrationRequestsJson(String orchestrationRequestsJson) {
401 logInvocationInDebug("deserializeOrchestrationRequestsJson");
403 ObjectMapper mapper = new ObjectMapper();
404 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
405 mapper.configure(DeserializationFeature.READ_ENUMS_USING_TO_STRING, true);
406 RequestList requestList;
408 requestList = mapper.readValue(orchestrationRequestsJson, RequestList.class);
409 } catch (IOException e) {
410 throw new GenericUncheckedException(e);
412 return ListUtils.emptyIfNull(requestList.getRequestList());
417 public List<Task> getManualTasksByRequestId(String originalRequestId) {
418 String methodName = "getManualTasksByRequestId";
419 logInvocationInDebug(methodName);
422 String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_MAN_TASKS);
423 String path = p + "?originalRequestId=" + originalRequestId;
425 RestObject<String> restObjStr = new RestObject<>();
426 String str = new String();
429 MsoResponseWrapper msoResponseWrapper = msoClientInterface.getManualTasksByRequestId(str, "", path, restObjStr);
430 return deserializeManualTasksJson(msoResponseWrapper.getEntity());
432 } catch (Exception e) {
433 logException(methodName, e);
438 private List<Task> deserializeManualTasksJson(String manualTasksJson) {
439 logInvocationInDebug("deserializeManualTasksJson");
441 ObjectMapper mapper = new ObjectMapper();
443 TaskList taskList = mapper.readValue(manualTasksJson, TaskList.class);
444 return taskList.getTaskList();
445 } catch (IOException e) {
446 throw new GenericUncheckedException(e);
452 public MsoResponseWrapper completeManualTask(RequestDetails requestDetails, String taskId) {
453 String methodName = "completeManualTask";
454 logInvocationInDebug(methodName);
456 String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_MAN_TASKS);
457 String path = p + "/" + taskId + "/complete";
459 RestObject<String> restObjStr = new RestObject<>();
460 String str = new String();
463 return msoClientInterface.completeManualTask(requestDetails, str, "", path, restObjStr);
465 } catch (Exception e) {
466 logException(methodName, e);
472 public MsoResponseWrapper activateServiceInstance(RequestDetails requestDetails, String serviceInstanceId) {
473 String methodName = "activateServiceInstance";
474 logInvocationInDebug(methodName);
476 String serviceEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_SVC_INSTANCE);
477 String activateServicePath = serviceEndpoint + "/" + serviceInstanceId + ACTIVATE;
479 RestObject<String> restObjStr = new RestObject<>();
483 msoClientInterface.setServiceInstanceStatus(requestDetails, activateServicePath);
485 return MsoUtil.wrapResponse(restObjStr);
487 } catch (Exception e) {
488 logException(methodName, e);
495 public MsoResponseWrapperInterface updateVnf(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
496 logInvocationInDebug("updateVnf");
499 endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
500 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
501 vnfEndpoint = vnfEndpoint + '/' + vnfInstanceId;
502 return msoClientInterface.updateVnf(requestDetails, vnfEndpoint);
506 public MsoResponseWrapperInterface replaceVnf(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
507 logInvocationInDebug("replaceVnf");
509 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_CHANGE_MANAGEMENT_INSTANCE);
510 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
511 vnfEndpoint = vnfEndpoint.replace(VNF_INSTANCE_ID, vnfInstanceId);
512 vnfEndpoint = vnfEndpoint.replace(REQUEST_TYPE, MsoChangeManagementRequest.REPLACE);
513 return msoClientInterface.replaceVnf(requestDetails, vnfEndpoint);
516 public RequestDetailsWrapper generateInPlaceMsoRequest(org.onap.vid.changeManagement.RequestDetails requestDetails) {
517 validateUpdateVnfSoftwarePayload(requestDetails);
518 RequestDetails inPlaceSoftwareUpdateRequest = new RequestDetails();
519 inPlaceSoftwareUpdateRequest.setCloudConfiguration(requestDetails.getCloudConfiguration());
520 inPlaceSoftwareUpdateRequest.setRequestParameters(requestDetails.getRequestParameters());
521 inPlaceSoftwareUpdateRequest.setRequestInfo(requestDetails.getRequestInfo());
522 RequestDetailsWrapper requestDetailsWrapper = new RequestDetailsWrapper();
523 requestDetailsWrapper.requestDetails = inPlaceSoftwareUpdateRequest;
524 return requestDetailsWrapper;
528 public RequestDetailsWrapper generateConfigMsoRequest(org.onap.vid.changeManagement.RequestDetails requestDetails) {
529 validateUpdateVnfConfig(requestDetails);
530 RequestDetails configUpdateRequest = new RequestDetails();
531 configUpdateRequest.setRequestParameters(requestDetails.getRequestParameters());
532 configUpdateRequest.setRequestInfo(requestDetails.getRequestInfo());
533 RequestDetailsWrapper requestDetailsWrapper = new RequestDetailsWrapper();
534 requestDetailsWrapper.requestDetails = configUpdateRequest;
535 return requestDetailsWrapper;
539 public String getActivateFabricConfigurationPath(String serviceInstanceId) {
540 String path = validateEndpointPath(MsoProperties.MSO_REST_API_SERVICE_INSTANCE_CREATE);
541 path += "/" + serviceInstanceId + ACTIVATE_FABRIC_CONFIGURATION;
547 public String getDeactivateAndCloudDeletePath(String serviceInstanceId, String vnfInstanceId, String vfModuleInstanceId) {
548 String path = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
549 path = path.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
550 path = path.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
551 path += "/" + vfModuleInstanceId + DEACTIVATE_AND_CLOUD_DELETE;
557 public RequestDetails buildRequestDetailsForSoftDelete(SoftDeleteRequest softDeleteRequest) {
558 RequestDetails requestDetails = new RequestDetails();
559 RequestInfo requestInfo = new RequestInfo();
560 requestInfo.setSource("VID");
561 requestInfo.setRequestorId(softDeleteRequest.getUserId());
562 requestDetails.setRequestInfo(requestInfo);
564 CloudConfiguration cloudConfiguration = new CloudConfiguration();
565 cloudConfiguration.setTenantId(softDeleteRequest.getTenantId());
566 cloudConfiguration.setLcpCloudRegionId(softDeleteRequest.getLcpCloudRegionId());
567 requestDetails.setCloudConfiguration(cloudConfiguration);
569 ModelInfo modelInfo = new ModelInfo();
570 modelInfo.setModelType("vfModule");
571 requestDetails.setModelInfo(modelInfo);
573 RequestParameters requestParameters = new RequestParameters();
574 requestParameters.setTestApi("GR_API");
575 requestDetails.setRequestParameters(requestParameters);
577 return requestDetails;
581 public MsoResponseWrapper2 deactivateAndCloudDelete(String serviceInstanceId, String vnfInstanceId, String vfModuleInstanceId, RequestDetails requestDetails) {
582 String path = getDeactivateAndCloudDeletePath(serviceInstanceId, vnfInstanceId, vfModuleInstanceId);
583 return new MsoResponseWrapper2<>(msoClientInterface.post(path, new RequestDetailsWrapper<>(requestDetails), RequestReferencesContainer.class));
587 public MsoResponseWrapper2 activateFabricConfiguration(String serviceInstanceId, RequestDetails requestDetails) {
588 String path = getActivateFabricConfigurationPath(serviceInstanceId);
589 return new MsoResponseWrapper2<>(msoClientInterface.post(path, new RequestDetailsWrapper<>(requestDetails), RequestReferencesContainer.class));
593 public SOWorkflowList getWorkflowListByModelId(String modelVersionId) {
594 logInvocationInDebug("getWorkflowListByModelId");
595 String pathTemplate = validateEndpointPath(MSO_REST_API_WORKFLOW_SPECIFICATIONS);
596 String path = pathTemplate.replaceFirst("<model_version_id>", modelVersionId);
598 HttpResponse<SOWorkflowList> workflowListByModelId = msoClientInterface.getWorkflowListByModelId(path);
599 if (!isSuccessful(workflowListByModelId)) {
600 logger.error(EELFLoggerDelegate.errorLogger, workflowListByModelId.getStatusText());
601 throw new WorkflowListException(String.format("Get worklflow list for id: %s failed due to %s", modelVersionId, workflowListByModelId.getStatusText()));
603 return workflowListByModelId.getBody();
608 public MsoResponseWrapperInterface updateVnfSoftware(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
609 logInvocationInDebug("updateVnfSoftware");
610 String vnfEndpoint = getChangeManagementEndpoint(serviceInstanceId, vnfInstanceId, MsoChangeManagementRequest.SOFTWARE_UPDATE); //workflow name in mso is different than workflow name in vid UI
611 RequestDetailsWrapper finalRequestDetails = generateInPlaceMsoRequest(requestDetails);
612 return msoClientInterface.changeManagementUpdate(finalRequestDetails, vnfEndpoint);
616 public MsoResponseWrapperInterface updateVnfConfig(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
617 logInvocationInDebug("updateVnfConfig");
618 RequestDetailsWrapper finalRequestDetails = generateConfigMsoRequest(requestDetails);
619 String vnfEndpoint = getChangeManagementEndpoint(serviceInstanceId, vnfInstanceId, MsoChangeManagementRequest.CONFIG_UPDATE);
620 return msoClientInterface.changeManagementUpdate(finalRequestDetails, vnfEndpoint);
623 private String getChangeManagementEndpoint(String serviceInstanceId, String vnfInstanceId, String vnfRequestType) {
624 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_CHANGE_MANAGEMENT_INSTANCE);
625 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
626 vnfEndpoint = vnfEndpoint.replace(VNF_INSTANCE_ID, vnfInstanceId);
627 vnfEndpoint = vnfEndpoint.replace(REQUEST_TYPE, vnfRequestType);
631 private Map getChangeManagementPayload(RequestDetails requestDetails, String message) {
632 if (requestDetails.getRequestParameters() == null || requestDetails.getRequestParameters().getAdditionalProperties() == null) {
633 throw new BadRequestException(message);
635 Object payloadRaw = requestDetails.getRequestParameters().getAdditionalProperties().get("payload");
637 return objectMapper.readValue((String) payloadRaw, Map.class);
638 } catch (Exception exception) {
639 throw new BadRequestException(message);
643 private void validateUpdateVnfSoftwarePayload(RequestDetails requestDetails) {
644 final String noValidPayloadMsg = "No valid payload in " + ChangeManagementRequest.VNF_IN_PLACE_SOFTWARE_UPDATE + " request";
646 Map payload = getChangeManagementPayload(requestDetails, noValidPayloadMsg);
647 validateUpdateVnfSoftwarePayloadProperty(payload, noValidPayloadMsg, "existing_software_version", SOFTWARE_VERSION_PATTERN);
648 validateUpdateVnfSoftwarePayloadProperty(payload, noValidPayloadMsg, "new_software_version", SOFTWARE_VERSION_PATTERN);
650 //if "operations_timeout" is not integer, trying to read it as String that represent a number
651 if (!(payload.get("operations_timeout") instanceof Integer)) {
652 validateUpdateVnfSoftwarePayloadProperty(payload, noValidPayloadMsg, "operations_timeout", NUMBER_PATTERN);
656 private void validateUpdateVnfSoftwarePayloadProperty(Map payload, String noValidPayloadMsg, String propertyName, Pattern pattern) {
657 Object forValidation = payload.get(propertyName);
658 final String noValidPayloadPropertyMsg = noValidPayloadMsg + ", " + propertyName + " property is not valid";
659 if (!(forValidation instanceof String)) {
660 throw new BadRequestException(noValidPayloadPropertyMsg);
662 if (!pattern.matcher((String) forValidation).matches()) {
663 throw new BadRequestException(noValidPayloadPropertyMsg);
668 public MsoResponseWrapper deleteConfiguration(org.onap.vid.mso.rest.RequestDetailsWrapper requestDetailsWrapper,
669 String serviceInstanceId,
670 String configurationId) {
672 logInvocationInDebug("deleteConfiguration");
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 return msoClientInterface.deleteConfiguration(requestDetailsWrapper, endpoint);
681 public MsoResponseWrapper setConfigurationActiveStatus(
682 RequestDetails requestDetails,
683 String serviceInstanceId,
684 String configurationId,
685 boolean isActivate) {
687 logInvocationInDebug("setConfigurationActiveStatus");
689 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATION_INSTANCE);
690 endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
691 endpoint = endpoint.replace(CONFIGURATION_ID, configurationId);
693 String isActivateState = (isActivate ? ACTIVATE : DEACTIVATE);
694 endpoint = endpoint + isActivateState;
696 return msoClientInterface.setConfigurationActiveStatus(requestDetails, endpoint);
700 public MsoResponseWrapper setServiceInstanceStatus(RequestDetails requestDetails, String serviceInstanceId, boolean isActivate) {
701 logInvocationInDebug("setServiceInstanceStatus");
702 String methodName = "setServiceInstanceStatus";
704 String serviceEndpoint = validateEndpointPath(MsoProperties.MSO_REST_API_SVC_INSTANCE);
705 String endpoint = serviceEndpoint + "/" + serviceInstanceId;
707 String isActivateState = (isActivate ? ACTIVATE : DEACTIVATE);
708 endpoint = endpoint + isActivateState;
710 return msoClientInterface.setServiceInstanceStatus(requestDetails, endpoint);
711 } catch (Exception e) {
712 logger.error(EELFLoggerDelegate.errorLogger, methodName + e.toString());
713 logger.debug(EELFLoggerDelegate.debugLogger, methodName + e.toString());
719 public MsoResponseWrapper setPortOnConfigurationStatus(
720 RequestDetails requestDetails,
721 String serviceInstanceId,
722 String configurationId,
724 logInvocationInDebug("setPortOnConfigurationStatus");
726 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATION_INSTANCE);
727 endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
728 endpoint = endpoint.replace(CONFIGURATION_ID, configurationId);
730 String isEnablePortStatus = (isEnable ? ENABLE_PORT : DISABLE_PORT);
731 endpoint = endpoint + isEnablePortStatus;
733 return msoClientInterface.setPortOnConfigurationStatus(requestDetails, endpoint);
738 public RequestDetailsWrapper<RequestDetails> createOperationalEnvironmentActivationRequestDetails(OperationalEnvironmentActivateInfo details) {
739 RequestDetails requestDetails = new RequestDetails();
740 RequestInfo requestInfo = new RequestInfo();
741 requestInfo.setAdditionalProperty(RESOURCE_TYPE, RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT);
742 requestInfo.setSource(SOURCE_OPERATIONAL_ENVIRONMENT);
743 requestInfo.setRequestorId(details.getUserId());
744 requestDetails.setRequestInfo(requestInfo);
746 RelatedInstance relatedInstance = new RelatedInstance();
747 relatedInstance.setAdditionalProperty(RESOURCE_TYPE, RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT);
748 relatedInstance.setInstanceId(details.getRelatedInstanceId());
749 relatedInstance.setInstanceName(details.getRelatedInstanceName());
750 requestDetails.setAdditionalProperty("relatedInstanceList", Collections.singletonList(ImmutableMap.of("relatedInstance", relatedInstance)));
752 RequestParameters requestParameters = new RequestParameters();
753 requestParameters.setUserParams(null);
754 requestParameters.setAdditionalProperty("operationalEnvironmentType", "VNF");
755 requestParameters.setAdditionalProperty("workloadContext", details.getWorkloadContext());
756 requestParameters.setAdditionalProperty("manifest", details.getManifest());
757 requestDetails.setRequestParameters(requestParameters);
759 RequestDetailsWrapper<RequestDetails> requestDetailsWrapper = new RequestDetailsWrapper<>(requestDetails);
761 debugRequestDetails(requestDetailsWrapper, logger);
763 return requestDetailsWrapper;
767 public String getOperationalEnvironmentActivationPath(OperationalEnvironmentActivateInfo details) {
768 String path = validateEndpointPath(MSO_REST_API_OPERATIONAL_ENVIRONMENT_ACTIVATE);
769 path = path.replace("<operational_environment_id>", details.getOperationalEnvironmentId());
774 public RequestDetailsWrapper<RequestDetails> createOperationalEnvironmentDeactivationRequestDetails(OperationalEnvironmentDeactivateInfo details) {
775 RequestDetails requestDetails = new RequestDetails();
777 RequestInfo requestInfo = new RequestInfo();
778 requestInfo.setAdditionalProperty(RESOURCE_TYPE, RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT);
779 requestInfo.setSource(SOURCE_OPERATIONAL_ENVIRONMENT);
780 requestInfo.setRequestorId(details.getUserId());
781 requestDetails.setRequestInfo(requestInfo);
783 RequestParameters requestParameters = new RequestParameters();
784 requestParameters.setUserParams(null);
785 requestParameters.setAdditionalProperty("operationalEnvironmentType", "VNF");
786 requestDetails.setRequestParameters(requestParameters);
787 RequestDetailsWrapper<RequestDetails> requestDetailsWrapper = new RequestDetailsWrapper<>(requestDetails);
788 debugRequestDetails(requestDetailsWrapper, logger);
789 return requestDetailsWrapper;
793 public String getCloudResourcesRequestsStatusPath(String requestId) {
794 String path = validateEndpointPath(MSO_REST_API_CLOUD_RESOURCES_REQUEST_STATUS);
795 path = path.replace("<request_id>", requestId);
800 public String getOperationalEnvironmentDeactivationPath(OperationalEnvironmentDeactivateInfo details) {
801 String path = validateEndpointPath(MSO_REST_API_OPERATIONAL_ENVIRONMENT_DEACTIVATE);
802 path = path.replace("<operational_environment_id>", details.getOperationalEnvironmentId());
807 public String getOperationalEnvironmentCreationPath() {
808 return validateEndpointPath(MSO_REST_API_OPERATIONAL_ENVIRONMENT_CREATE);
813 public RequestDetailsWrapper<OperationEnvironmentRequestDetails> convertParametersToRequestDetails(OperationalEnvironmentController.OperationalEnvironmentCreateBody input, String userId) {
814 OperationEnvironmentRequestDetails.RequestInfo requestInfo = new OperationEnvironmentRequestDetails.RequestInfo(
815 RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT,
816 input.getInstanceName(),
817 SOURCE_OPERATIONAL_ENVIRONMENT,
820 OperationEnvironmentRequestDetails.RelatedInstance relatedInstance = new OperationEnvironmentRequestDetails.RelatedInstance(
821 RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT,
822 input.getEcompInstanceId(),
823 input.getEcompInstanceName());
825 List<OperationEnvironmentRequestDetails.RelatedInstance> relatedInstanceList = Collections.singletonList((relatedInstance));
827 OperationEnvironmentRequestDetails.RequestParameters requestParameters = new OperationEnvironmentRequestDetails.RequestParameters(
828 input.getOperationalEnvironmentType(),
829 input.getTenantContext(),
830 input.getWorkloadContext());
832 OperationEnvironmentRequestDetails requestDetails = new OperationEnvironmentRequestDetails(requestInfo, relatedInstanceList, requestParameters);
833 RequestDetailsWrapper<OperationEnvironmentRequestDetails> requestDetailsWrapper = new RequestDetailsWrapper<>(requestDetails);
834 debugRequestDetails(requestDetailsWrapper, logger);
835 return requestDetailsWrapper;
839 public MsoResponseWrapper removeRelationshipFromServiceInstance(RequestDetails requestDetails, String serviceInstanceId) {
840 logInvocationInDebug("removeRelationshipFromServiceInstance");
842 String serviceEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_SVC_INSTANCE);
843 String removeRelationshipsPath = serviceEndpoint + "/" + serviceInstanceId + "/removeRelationships";
845 return msoClientInterface.removeRelationshipFromServiceInstance(requestDetails, removeRelationshipsPath);
849 public MsoResponseWrapper addRelationshipToServiceInstance(RequestDetails requestDetails, String serviceInstanceId) {
850 logInvocationInDebug("addRelationshipToServiceInstance");
852 String serviceEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_SVC_INSTANCE);
853 String addRelationshipsPath = serviceEndpoint + "/" + serviceInstanceId + "/addRelationships";
855 return msoClientInterface.addRelationshipToServiceInstance(requestDetails, addRelationshipsPath);
860 public ExternalComponentStatus probeComponent() {
861 String url = SystemProperties.getProperty(
862 MsoProperties.MSO_SERVER_URL) + "/" + SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQS);
863 long startTime = System.currentTimeMillis();
864 ExternalComponentStatus externalComponentStatus;
867 String rawBody = objectMapper.writeValueAsString(getOrchestrationRequestsForDashboard());
868 StatusMetadata statusMetadata=new HttpRequestMetadata(HttpMethod.GET,200,url,rawBody,"VID-SO",System.currentTimeMillis() - startTime);
870 externalComponentStatus = new ExternalComponentStatus(ExternalComponentStatus.Component.MSO, true, statusMetadata);
871 } catch (Exception e) {
872 StatusMetadata statusMetadata = new HttpRequestMetadata(HttpMethod.GET, HttpStatus.INTERNAL_SERVER_ERROR.value(), url, "", e.getMessage(), System.currentTimeMillis() - startTime);
873 externalComponentStatus = new ExternalComponentStatus(ExternalComponentStatus.Component.MSO, false, statusMetadata);
876 return externalComponentStatus;
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) {
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() {