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.jetbrains.annotations.NotNull;
32 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
33 import org.onap.portalsdk.core.util.SystemProperties;
34 import org.onap.vid.changeManagement.ChangeManagementRequest;
35 import org.onap.vid.changeManagement.RequestDetailsWrapper;
36 import org.onap.vid.changeManagement.WorkflowRequestDetail;
37 import org.onap.vid.controller.OperationalEnvironmentController;
38 import org.onap.vid.exceptions.GenericUncheckedException;
39 import org.onap.vid.model.RequestReferencesContainer;
40 import org.onap.vid.model.SOWorkflowList;
41 import org.onap.vid.model.SoftDeleteRequest;
42 import org.onap.vid.model.probes.ExternalComponentStatus;
43 import org.onap.vid.model.probes.HttpRequestMetadata;
44 import org.onap.vid.model.probes.StatusMetadata;
45 import org.onap.vid.mso.model.CloudConfiguration;
46 import org.onap.vid.mso.model.ModelInfo;
47 import org.onap.vid.mso.model.OperationalEnvironmentActivateInfo;
48 import org.onap.vid.mso.model.OperationalEnvironmentDeactivateInfo;
49 import org.onap.vid.mso.model.RequestInfo;
50 import org.onap.vid.mso.model.RequestParameters;
51 import org.onap.vid.mso.rest.OperationalEnvironment.OperationEnvironmentRequestDetails;
52 import org.onap.vid.mso.rest.RelatedInstance;
53 import org.onap.vid.mso.rest.Request;
54 import org.onap.vid.mso.rest.RequestDetails;
55 import org.onap.vid.mso.rest.RequestList;
56 import org.onap.vid.mso.rest.RequestWrapper;
57 import org.onap.vid.mso.rest.Task;
58 import org.onap.vid.mso.rest.TaskList;
59 import org.springframework.beans.factory.annotation.Autowired;
60 import org.springframework.http.HttpMethod;
61 import org.springframework.http.HttpStatus;
62 import org.togglz.core.manager.FeatureManager;
64 import javax.ws.rs.BadRequestException;
65 import java.io.IOException;
66 import java.util.ArrayList;
67 import java.util.Collections;
68 import java.util.HashMap;
69 import java.util.List;
71 import java.util.Objects;
72 import java.util.UUID;
73 import java.util.regex.Pattern;
74 import java.util.stream.Collectors;
75 import java.util.stream.Stream;
77 import static java.util.stream.Collectors.collectingAndThen;
78 import static java.util.stream.Collectors.toList;
79 import static org.apache.commons.lang.StringUtils.upperCase;
80 import static org.onap.vid.changeManagement.ChangeManagementRequest.MsoChangeManagementRequest;
81 import static org.onap.vid.controller.MsoController.CONFIGURATION_ID;
82 import static org.onap.vid.controller.MsoController.REQUEST_TYPE;
83 import static org.onap.vid.controller.MsoController.SVC_INSTANCE_ID;
84 import static org.onap.vid.controller.MsoController.VNF_INSTANCE_ID;
85 import static org.onap.vid.controller.MsoController.WORKFLOW_ID;
86 import static org.onap.vid.mso.MsoProperties.MSO_REST_API_CLOUD_RESOURCES_REQUEST_STATUS;
87 import static org.onap.vid.mso.MsoProperties.MSO_REST_API_OPERATIONAL_ENVIRONMENT_ACTIVATE;
88 import static org.onap.vid.mso.MsoProperties.MSO_REST_API_OPERATIONAL_ENVIRONMENT_CREATE;
89 import static org.onap.vid.mso.MsoProperties.MSO_REST_API_OPERATIONAL_ENVIRONMENT_DEACTIVATE;
90 import static org.onap.vid.mso.MsoProperties.MSO_REST_API_WORKFLOW_SPECIFICATIONS;
91 import static org.onap.vid.properties.Features.FLAG_UNASSIGN_SERVICE;
92 import static org.onap.vid.utils.Logging.debugRequestDetails;
94 public class MsoBusinessLogicImpl implements MsoBusinessLogic {
96 static final List<String> DASHBOARD_ALLOWED_TYPES = Stream.of(RequestType.REPLACE_INSTANCE,
97 RequestType.UPDATE_INSTANCE,
98 RequestType.APPLY_UPDATED_CONFIG,
99 RequestType.IN_PLACE_SOFTWARE_UPDATE,
100 RequestType.SCALE_OUT)
101 .map(requestType -> requestType.toString().toUpperCase())
102 .collect(collectingAndThen(toList(), Collections::unmodifiableList));
103 private static final String RESOURCE_TYPE = "resourceType";
104 private static final Pattern SOFTWARE_VERSION_PATTERN = Pattern.compile("^[A-Za-z0-9.\\-]+$");
105 private static final Pattern NUMBER_PATTERN = Pattern.compile("^[0-9]+$");
106 private static final String ACTIVATE = "/activate";
107 private static final String DEACTIVATE = "/deactivate";
108 private static final String ENABLE_PORT = "/enablePort";
109 private static final String DISABLE_PORT = "/disablePort";
110 private static final String ACTIVATE_FABRIC_CONFIGURATION = "/activateFabricConfiguration";
111 private static final String DEACTIVATE_AND_CLOUD_DELETE = "/deactivateAndCloudDelete";
112 private static final String RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT = "operationalEnvironment";
113 private static final String SOURCE_OPERATIONAL_ENVIRONMENT = "VID";
114 private static final ObjectMapper objectMapper = new ObjectMapper();
118 private static final EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(MsoBusinessLogicImpl.class);
120 * The Mso REST client
121 * This should be replaced with mso client factory.
123 private final MsoInterface msoClientInterface;
124 FeatureManager featureManager;
127 public MsoBusinessLogicImpl(MsoInterface msoClientInterface, FeatureManager featureManager) {
128 this.msoClientInterface = msoClientInterface;
129 this.featureManager = featureManager;
132 public static String validateEndpointPath(String endpointEnvVariable) {
133 String endpoint = SystemProperties.getProperty(endpointEnvVariable);
134 if (endpoint == null || endpoint.isEmpty()) {
135 throw new GenericUncheckedException(endpointEnvVariable + " env variable is not defined");
140 // this function should get params from tosca and send them to instance at mso, then return success response.
142 public MsoResponseWrapper createSvcInstance(RequestDetails msoRequest) {
143 logInvocationInDebug("createSvcInstance");
145 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_SVC_INSTANCE);
147 return msoClientInterface.createSvcInstance(msoRequest, endpoint);
151 public MsoResponseWrapper createE2eSvcInstance(Object msoRequest) {
152 logInvocationInDebug("createE2eSvcInstance");
153 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_E2E_SVC_INSTANCE);
155 return msoClientInterface.createE2eSvcInstance(msoRequest, endpoint);
159 public MsoResponseWrapper createVnf(RequestDetails requestDetails, String serviceInstanceId) {
160 logInvocationInDebug("createVnf");
162 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
164 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
165 return msoClientInterface.createVnf(requestDetails, vnfEndpoint);
169 public MsoResponseWrapper createNwInstance(RequestDetails requestDetails, String serviceInstanceId) {
170 logInvocationInDebug("createNwInstance");
172 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_NETWORK_INSTANCE);
174 String nw_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
175 return msoClientInterface.createNwInstance(requestDetails, nw_endpoint);
179 public MsoResponseWrapper createVolumeGroupInstance(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
180 logInvocationInDebug("createVolumeGroupInstance");
182 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VOLUME_GROUP_INSTANCE);
184 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
185 vnfEndpoint = vnfEndpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
187 return msoClientInterface.createVolumeGroupInstance(requestDetails, vnfEndpoint);
191 public MsoResponseWrapper createVfModuleInstance(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
192 logInvocationInDebug("createVfModuleInstance");
194 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
196 String partial_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
197 String vf_module_endpoint = partial_endpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
199 return msoClientInterface.createVfModuleInstance(requestDetails, vf_module_endpoint);
203 public MsoResponseWrapper scaleOutVfModuleInstance(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
204 logInvocationInDebug("scaleOutVfModuleInstance");
206 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_SCALE_OUT);
208 String partial_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
209 String vf_module_endpoint = partial_endpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
210 RequestDetailsWrapper wrapper = new RequestDetailsWrapper();
211 requestDetails.setVnfName(null);
212 requestDetails.setVnfInstanceId(null);
213 wrapper.requestDetails = requestDetails;
215 return msoClientInterface.scaleOutVFModuleInstance(wrapper, vf_module_endpoint);
219 public MsoResponseWrapper invokeVnfWorkflow(WorkflowRequestDetail request, String userId, UUID serviceInstanceId, UUID vnfInstanceId, UUID workflow_UUID) {
220 logInvocationInDebug("invokeVnfWorkflow");
222 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_WORKFLOW_INSTANCE);
224 String final_endpoint = endpoint
225 .replaceFirst(SVC_INSTANCE_ID, serviceInstanceId.toString())
226 .replaceFirst(WORKFLOW_ID, workflow_UUID.toString())
227 .replaceFirst(VNF_INSTANCE_ID, vnfInstanceId.toString());
229 Map<String,String> extraHeaders = new HashMap<>();
231 UUID requestId = UUID.randomUUID();
232 extraHeaders.put("X-ONAP-RequestID",requestId.toString());
233 extraHeaders.put("X-ONAP-PartnerName","VID");
234 extraHeaders.put("X-RequestorID",userId);
236 return msoClientInterface.invokeWorkflow(request,final_endpoint,extraHeaders);
240 public MsoResponseWrapper createConfigurationInstance(org.onap.vid.mso.rest.RequestDetailsWrapper requestDetailsWrapper, String serviceInstanceId) {
241 logInvocationInDebug("createConfigurationInstance");
243 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATIONS);
244 endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
246 return msoClientInterface.createConfigurationInstance(requestDetailsWrapper, endpoint);
250 public MsoResponseWrapper deleteE2eSvcInstance(Object requestDetails, String serviceInstanceId) {
251 logInvocationInDebug("deleteE2eSvcInstance");
253 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_E2E_SVC_INSTANCE) + "/" + serviceInstanceId;
255 return msoClientInterface.deleteE2eSvcInstance(requestDetails, endpoint);
259 public MsoResponseWrapper deleteSvcInstance(RequestDetails requestDetails, String serviceInstanceId, String serviceStatus) {
260 logInvocationInDebug("deleteSvcInstance");
263 if (featureManager.isActive(FLAG_UNASSIGN_SERVICE)) {
264 endpoint = validateEndpointPath(MsoProperties.MSO_DELETE_OR_UNASSIGN_REST_API_SVC_INSTANCE);
265 if (shouldUnassignService(serviceStatus)) {
266 logger.debug(EELFLoggerDelegate.debugLogger, "unassign service");
267 String svc_endpoint = endpoint + "/" + serviceInstanceId + "/unassign";
268 return msoClientInterface.unassignSvcInstance(requestDetails, svc_endpoint);
271 endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_SVC_INSTANCE);
274 String svc_endpoint = endpoint + "/" + serviceInstanceId;
275 return msoClientInterface.deleteSvcInstance(requestDetails, svc_endpoint);
278 private boolean shouldUnassignService(String serviceStatus) {
279 return ImmutableList.of("created", "pendingdelete", "pending-delete", "assigned").contains(serviceStatus.toLowerCase());
283 public MsoResponseWrapper deleteVnf(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
284 logInvocationInDebug("deleteVnf");
286 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
287 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
288 vnfEndpoint = vnfEndpoint + '/' + vnfInstanceId;
290 return msoClientInterface.deleteVnf(requestDetails, vnfEndpoint);
294 public MsoResponseWrapper deleteVfModule(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId, String vfModuleId) {
295 logInvocationInDebug("deleteVfModule");
297 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
298 String vf__modules_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId).replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
299 String delete_vf_endpoint = vf__modules_endpoint + '/' + vfModuleId;
301 return msoClientInterface.deleteVfModule(requestDetails, delete_vf_endpoint);
305 public MsoResponseWrapper deleteVolumeGroupInstance(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId, String volumeGroupId) {
306 logInvocationInDebug("deleteVolumeGroupInstance");
308 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VOLUME_GROUP_INSTANCE);
309 String svc_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
310 String vnfEndpoint = svc_endpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
311 String delete_volume_group_endpoint = vnfEndpoint + "/" + volumeGroupId;
313 return msoClientInterface.deleteVolumeGroupInstance(requestDetails, delete_volume_group_endpoint);
317 public MsoResponseWrapper deleteNwInstance(RequestDetails requestDetails, String serviceInstanceId, String networkInstanceId) {
318 logInvocationInDebug("deleteNwInstance");
320 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_NETWORK_INSTANCE);
321 String svc_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
322 String delete_nw_endpoint = svc_endpoint + "/" + networkInstanceId;
324 return msoClientInterface.deleteNwInstance(requestDetails, delete_nw_endpoint);
328 public MsoResponseWrapper getOrchestrationRequest(String requestId) {
329 String methodName = "getOrchestrationRequest";
330 logInvocationInDebug(methodName);
332 String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQ);
333 String path = p + "/" + requestId;
335 return msoClientInterface.getOrchestrationRequest(path);
337 } catch (Exception e) {
338 logException(methodName, e);
344 public MsoResponseWrapper getOrchestrationRequests(String filterString) {
345 String methodName = "getOrchestrationRequest";
346 logInvocationInDebug(methodName);
348 String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQS);
349 String path = p + filterString;
351 return msoClientInterface.getOrchestrationRequest(path);
353 } catch (Exception e) {
354 logException(methodName, e);
360 public List<Request> getOrchestrationRequestsForDashboard() {
361 String methodName = "getOrchestrationRequestsForDashboard";
362 logInvocationInDebug(methodName);
364 List<Request> dashboardOrchestrationReqs = new ArrayList<>();
366 List<RequestWrapper> vnfOrchestrationReqsWrappers = getOrchestrationRequestsByFilter("modelType", "vnf");
367 dashboardOrchestrationReqs = vnfOrchestrationReqsWrappers.stream()
368 .filter(reqWrapper -> Objects.nonNull(reqWrapper.getRequest())
369 && DASHBOARD_ALLOWED_TYPES.contains(upperCase(reqWrapper.getRequest().getRequestType())))
370 .map(RequestWrapper::getRequest)
371 .collect(Collectors.toList());
373 List<RequestWrapper> scaleOutOrchestrationReqWrappers = getOrchestrationRequestsByFilter("action", "scaleOut");
374 List<Request> scaleoutRequests = scaleOutOrchestrationReqWrappers.stream()
375 .filter(reqWrapper -> Objects.nonNull(reqWrapper.getRequest()))
376 .map(RequestWrapper::getRequest)
377 .collect(Collectors.toList());
379 dashboardOrchestrationReqs.addAll(scaleoutRequests);
380 } catch (Exception e) {
381 logException(methodName, e);
384 return dashboardOrchestrationReqs;
387 private String constructOrchestrationRequestFilter(String filterName, String filterValue) {
388 return String.format("%sfilter=%s:EQUALS:%s",
389 SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQS), filterName, filterValue);
392 private List<RequestWrapper> getOrchestrationRequestsByFilter(String filterName, String filterValue) {
393 String orchestrationReqPath = constructOrchestrationRequestFilter(filterName, filterValue);
394 RestObject<String> restObjStr = new RestObject<>();
395 String str = new String();
397 MsoResponseWrapper msoResponseWrapper = msoClientInterface.getOrchestrationRequest(str, "", orchestrationReqPath, restObjStr, true);
398 return deserializeOrchestrationRequestsJson(msoResponseWrapper.getEntity());
401 private List<RequestWrapper> deserializeOrchestrationRequestsJson(String orchestrationRequestsJson) {
402 logInvocationInDebug("deserializeOrchestrationRequestsJson");
404 ObjectMapper mapper = new ObjectMapper();
405 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
406 mapper.configure(DeserializationFeature.READ_ENUMS_USING_TO_STRING, true);
407 RequestList requestList;
409 requestList = mapper.readValue(orchestrationRequestsJson, RequestList.class);
410 } catch (IOException e) {
411 throw new GenericUncheckedException(e);
413 return ListUtils.emptyIfNull(requestList.getRequestList());
418 public List<Task> getManualTasksByRequestId(String originalRequestId) {
419 String methodName = "getManualTasksByRequestId";
420 logInvocationInDebug(methodName);
423 String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_MAN_TASKS);
424 String path = p + "?originalRequestId=" + originalRequestId;
426 RestObject<String> restObjStr = new RestObject<>();
427 String str = new String();
430 MsoResponseWrapper msoResponseWrapper = msoClientInterface.getManualTasksByRequestId(str, "", path, restObjStr);
431 return deserializeManualTasksJson(msoResponseWrapper.getEntity());
433 } catch (Exception e) {
434 logException(methodName, e);
439 private List<Task> deserializeManualTasksJson(String manualTasksJson) {
440 logInvocationInDebug("deserializeManualTasksJson");
442 ObjectMapper mapper = new ObjectMapper();
444 TaskList taskList = mapper.readValue(manualTasksJson, TaskList.class);
445 return taskList.getTaskList();
446 } catch (IOException e) {
447 throw new GenericUncheckedException(e);
453 public MsoResponseWrapper completeManualTask(RequestDetails requestDetails, String taskId) {
454 String methodName = "completeManualTask";
455 logInvocationInDebug(methodName);
457 String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_MAN_TASKS);
458 String path = p + "/" + taskId + "/complete";
460 RestObject<String> restObjStr = new RestObject<>();
461 String str = new String();
464 return msoClientInterface.completeManualTask(requestDetails, str, "", path, restObjStr);
466 } catch (Exception e) {
467 logException(methodName, e);
473 public MsoResponseWrapper activateServiceInstance(RequestDetails requestDetails, String serviceInstanceId) {
474 String methodName = "activateServiceInstance";
475 logInvocationInDebug(methodName);
477 String serviceEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_SVC_INSTANCE);
478 String activateServicePath = serviceEndpoint + "/" + serviceInstanceId + ACTIVATE;
480 RestObject<String> restObjStr = new RestObject<>();
484 msoClientInterface.setServiceInstanceStatus(requestDetails, str, "", activateServicePath, restObjStr);
486 return MsoUtil.wrapResponse(restObjStr);
488 } catch (Exception e) {
489 logException(methodName, e);
496 public MsoResponseWrapperInterface updateVnf(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
497 logInvocationInDebug("updateVnf");
500 endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
501 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
502 vnfEndpoint = vnfEndpoint + '/' + vnfInstanceId;
503 return msoClientInterface.updateVnf(requestDetails, vnfEndpoint);
507 public MsoResponseWrapperInterface replaceVnf(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
508 logInvocationInDebug("replaceVnf");
510 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_CHANGE_MANAGEMENT_INSTANCE);
511 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
512 vnfEndpoint = vnfEndpoint.replace(VNF_INSTANCE_ID, vnfInstanceId);
513 vnfEndpoint = vnfEndpoint.replace(REQUEST_TYPE, MsoChangeManagementRequest.REPLACE);
514 return msoClientInterface.replaceVnf(requestDetails, vnfEndpoint);
517 public RequestDetailsWrapper generateInPlaceMsoRequest(org.onap.vid.changeManagement.RequestDetails requestDetails) {
518 validateUpdateVnfSoftwarePayload(requestDetails);
519 RequestDetails inPlaceSoftwareUpdateRequest = new RequestDetails();
520 inPlaceSoftwareUpdateRequest.setCloudConfiguration(requestDetails.getCloudConfiguration());
521 inPlaceSoftwareUpdateRequest.setRequestParameters(requestDetails.getRequestParameters());
522 inPlaceSoftwareUpdateRequest.setRequestInfo(requestDetails.getRequestInfo());
523 RequestDetailsWrapper requestDetailsWrapper = new RequestDetailsWrapper();
524 requestDetailsWrapper.requestDetails = inPlaceSoftwareUpdateRequest;
525 return requestDetailsWrapper;
529 public RequestDetailsWrapper generateConfigMsoRequest(org.onap.vid.changeManagement.RequestDetails requestDetails) {
530 validateUpdateVnfConfig(requestDetails);
531 RequestDetails configUpdateRequest = new RequestDetails();
532 configUpdateRequest.setRequestParameters(requestDetails.getRequestParameters());
533 configUpdateRequest.setRequestInfo(requestDetails.getRequestInfo());
534 RequestDetailsWrapper requestDetailsWrapper = new RequestDetailsWrapper();
535 requestDetailsWrapper.requestDetails = configUpdateRequest;
536 return requestDetailsWrapper;
540 public String getActivateFabricConfigurationPath(String serviceInstanceId) {
541 String path = validateEndpointPath(MsoProperties.MSO_REST_API_SERVICE_INSTANCE_CREATE);
542 path += "/" + serviceInstanceId + ACTIVATE_FABRIC_CONFIGURATION;
548 public String getDeactivateAndCloudDeletePath(String serviceInstanceId, String vnfInstanceId, String vfModuleInstanceId) {
549 String path = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
550 path = path.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
551 path = path.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
552 path += "/" + vfModuleInstanceId + DEACTIVATE_AND_CLOUD_DELETE;
558 public RequestDetails buildRequestDetailsForSoftDelete(SoftDeleteRequest softDeleteRequest) {
559 RequestDetails requestDetails = new RequestDetails();
560 RequestInfo requestInfo = new RequestInfo();
561 requestInfo.setSource("VID");
562 requestInfo.setRequestorId(softDeleteRequest.getUserId());
563 requestDetails.setRequestInfo(requestInfo);
565 CloudConfiguration cloudConfiguration = new CloudConfiguration();
566 cloudConfiguration.setTenantId(softDeleteRequest.getTenantId());
567 cloudConfiguration.setLcpCloudRegionId(softDeleteRequest.getLcpCloudRegionId());
568 requestDetails.setCloudConfiguration(cloudConfiguration);
570 ModelInfo modelInfo = new ModelInfo();
571 modelInfo.setModelType("vfModule");
572 requestDetails.setModelInfo(modelInfo);
574 RequestParameters requestParameters = new RequestParameters();
575 requestParameters.setTestApi("GR_API");
576 requestDetails.setRequestParameters(requestParameters);
578 return requestDetails;
582 public MsoResponseWrapper2 deactivateAndCloudDelete(String serviceInstanceId, String vnfInstanceId, String vfModuleInstanceId, RequestDetails requestDetails) {
583 String path = getDeactivateAndCloudDeletePath(serviceInstanceId, vnfInstanceId, vfModuleInstanceId);
584 return new MsoResponseWrapper2<>(msoClientInterface.post(path, new RequestDetailsWrapper<>(requestDetails), RequestReferencesContainer.class));
588 public MsoResponseWrapper2 activateFabricConfiguration(String serviceInstanceId, RequestDetails requestDetails) {
589 String path = getActivateFabricConfigurationPath(serviceInstanceId);
590 return new MsoResponseWrapper2<>(msoClientInterface.post(path, new RequestDetailsWrapper<>(requestDetails), RequestReferencesContainer.class));
594 public SOWorkflowList getWorkflowListByModelId(String modelVersionId) {
595 logInvocationInDebug("getWorkflowListByModelId");
596 String pathTemplate = validateEndpointPath(MSO_REST_API_WORKFLOW_SPECIFICATIONS);
597 String path = pathTemplate.replaceFirst("<model_version_id>", modelVersionId);
599 HttpResponse<SOWorkflowList> workflowListByModelId = msoClientInterface.getWorkflowListByModelId(path);
600 if (!isSuccessful(workflowListByModelId)) {
601 logger.error(EELFLoggerDelegate.errorLogger, workflowListByModelId.getStatusText());
602 throw new WorkflowListException(String.format("Get worklflow list for id: %s failed due to %s", modelVersionId, workflowListByModelId.getStatusText()));
604 return workflowListByModelId.getBody();
609 public MsoResponseWrapperInterface updateVnfSoftware(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
610 logInvocationInDebug("updateVnfSoftware");
611 String vnfEndpoint = getChangeManagementEndpoint(serviceInstanceId, vnfInstanceId, MsoChangeManagementRequest.SOFTWARE_UPDATE); //workflow name in mso is different than workflow name in vid UI
612 RequestDetailsWrapper finalRequestDetails = generateInPlaceMsoRequest(requestDetails);
613 return msoClientInterface.changeManagementUpdate(finalRequestDetails, vnfEndpoint);
617 public MsoResponseWrapperInterface updateVnfConfig(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
618 logInvocationInDebug("updateVnfConfig");
619 RequestDetailsWrapper finalRequestDetails = generateConfigMsoRequest(requestDetails);
620 String vnfEndpoint = getChangeManagementEndpoint(serviceInstanceId, vnfInstanceId, MsoChangeManagementRequest.CONFIG_UPDATE);
621 return msoClientInterface.changeManagementUpdate(finalRequestDetails, vnfEndpoint);
624 private String getChangeManagementEndpoint(String serviceInstanceId, String vnfInstanceId, String vnfRequestType) {
625 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_CHANGE_MANAGEMENT_INSTANCE);
626 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
627 vnfEndpoint = vnfEndpoint.replace(VNF_INSTANCE_ID, vnfInstanceId);
628 vnfEndpoint = vnfEndpoint.replace(REQUEST_TYPE, vnfRequestType);
632 private Map getChangeManagementPayload(RequestDetails requestDetails, String message) {
633 if (requestDetails.getRequestParameters() == null || requestDetails.getRequestParameters().getAdditionalProperties() == null) {
634 throw new BadRequestException(message);
636 Object payloadRaw = requestDetails.getRequestParameters().getAdditionalProperties().get("payload");
638 return objectMapper.readValue((String) payloadRaw, Map.class);
639 } catch (Exception exception) {
640 throw new BadRequestException(message);
644 private void validateUpdateVnfSoftwarePayload(RequestDetails requestDetails) {
645 final String noValidPayloadMsg = "No valid payload in " + ChangeManagementRequest.VNF_IN_PLACE_SOFTWARE_UPDATE + " request";
647 Map payload = getChangeManagementPayload(requestDetails, noValidPayloadMsg);
648 validateUpdateVnfSoftwarePayloadProperty(payload, noValidPayloadMsg, "existing_software_version", SOFTWARE_VERSION_PATTERN);
649 validateUpdateVnfSoftwarePayloadProperty(payload, noValidPayloadMsg, "new_software_version", SOFTWARE_VERSION_PATTERN);
651 //if "operations_timeout" is not integer, trying to read it as String that represent a number
652 if (!(payload.get("operations_timeout") instanceof Integer)) {
653 validateUpdateVnfSoftwarePayloadProperty(payload, noValidPayloadMsg, "operations_timeout", NUMBER_PATTERN);
657 private void validateUpdateVnfSoftwarePayloadProperty(Map payload, String noValidPayloadMsg, String propertyName, Pattern pattern) {
658 Object forValidation = payload.get(propertyName);
659 final String noValidPayloadPropertyMsg = noValidPayloadMsg + ", " + propertyName + " property is not valid";
660 if (!(forValidation instanceof String)) {
661 throw new BadRequestException(noValidPayloadPropertyMsg);
663 if (!pattern.matcher((String) forValidation).matches()) {
664 throw new BadRequestException(noValidPayloadPropertyMsg);
669 public MsoResponseWrapper deleteConfiguration(org.onap.vid.mso.rest.RequestDetailsWrapper requestDetailsWrapper,
670 String serviceInstanceId,
671 String configurationId) {
673 logInvocationInDebug("deleteConfiguration");
674 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATION_INSTANCE);
675 endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
676 endpoint = endpoint.replace(CONFIGURATION_ID, configurationId);
678 return msoClientInterface.deleteConfiguration(requestDetailsWrapper, endpoint);
682 public MsoResponseWrapper setConfigurationActiveStatus(
683 RequestDetails requestDetails,
684 String serviceInstanceId,
685 String configurationId,
686 boolean isActivate) {
688 logInvocationInDebug("setConfigurationActiveStatus");
690 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATION_INSTANCE);
691 endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
692 endpoint = endpoint.replace(CONFIGURATION_ID, configurationId);
694 String isActivateState = (isActivate ? ACTIVATE : DEACTIVATE);
695 endpoint = endpoint + isActivateState;
697 return msoClientInterface.setConfigurationActiveStatus(requestDetails, endpoint);
701 public MsoResponseWrapper setServiceInstanceStatus(RequestDetails requestDetails, String serviceInstanceId, boolean isActivate) {
702 logInvocationInDebug("setServiceInstanceStatus");
703 String methodName = "setServiceInstanceStatus";
705 String serviceEndpoint = validateEndpointPath(MsoProperties.MSO_REST_API_SVC_INSTANCE);
706 String endpoint = serviceEndpoint + "/" + serviceInstanceId;
708 String isActivateState = (isActivate ? ACTIVATE : DEACTIVATE);
709 endpoint = endpoint + isActivateState;
712 RestObject<String> restObjStr = new RestObject<>();
716 msoClientInterface.setServiceInstanceStatus(requestDetails, str, "", endpoint, restObjStr);
718 return MsoUtil.wrapResponse(restObjStr);
720 } catch (Exception e) {
721 logger.error(EELFLoggerDelegate.errorLogger, methodName + e.toString());
722 logger.debug(EELFLoggerDelegate.debugLogger, methodName + e.toString());
728 public MsoResponseWrapper setPortOnConfigurationStatus(
729 RequestDetails requestDetails,
730 String serviceInstanceId,
731 String configurationId,
733 logInvocationInDebug("setPortOnConfigurationStatus");
735 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATION_INSTANCE);
736 endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
737 endpoint = endpoint.replace(CONFIGURATION_ID, configurationId);
739 String isEnablePortStatus = (isEnable ? ENABLE_PORT : DISABLE_PORT);
740 endpoint = endpoint + isEnablePortStatus;
742 return msoClientInterface.setPortOnConfigurationStatus(requestDetails, endpoint);
747 public RequestDetailsWrapper<RequestDetails> createOperationalEnvironmentActivationRequestDetails(OperationalEnvironmentActivateInfo details) {
748 RequestDetails requestDetails = new RequestDetails();
749 RequestInfo requestInfo = new RequestInfo();
750 requestInfo.setAdditionalProperty(RESOURCE_TYPE, RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT);
751 requestInfo.setSource(SOURCE_OPERATIONAL_ENVIRONMENT);
752 requestInfo.setRequestorId(details.getUserId());
753 requestDetails.setRequestInfo(requestInfo);
755 RelatedInstance relatedInstance = new RelatedInstance();
756 relatedInstance.setAdditionalProperty(RESOURCE_TYPE, RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT);
757 relatedInstance.setInstanceId(details.getRelatedInstanceId());
758 relatedInstance.setInstanceName(details.getRelatedInstanceName());
759 requestDetails.setAdditionalProperty("relatedInstanceList", Collections.singletonList(ImmutableMap.of("relatedInstance", relatedInstance)));
761 RequestParameters requestParameters = new RequestParameters();
762 requestParameters.setUserParams(null);
763 requestParameters.setAdditionalProperty("operationalEnvironmentType", "VNF");
764 requestParameters.setAdditionalProperty("workloadContext", details.getWorkloadContext());
765 requestParameters.setAdditionalProperty("manifest", details.getManifest());
766 requestDetails.setRequestParameters(requestParameters);
768 RequestDetailsWrapper<RequestDetails> requestDetailsWrapper = new RequestDetailsWrapper<>(requestDetails);
770 debugRequestDetails(requestDetailsWrapper, logger);
772 return requestDetailsWrapper;
776 public String getOperationalEnvironmentActivationPath(OperationalEnvironmentActivateInfo details) {
777 String path = validateEndpointPath(MSO_REST_API_OPERATIONAL_ENVIRONMENT_ACTIVATE);
778 path = path.replace("<operational_environment_id>", details.getOperationalEnvironmentId());
783 public RequestDetailsWrapper<RequestDetails> createOperationalEnvironmentDeactivationRequestDetails(OperationalEnvironmentDeactivateInfo details) {
784 RequestDetails requestDetails = new RequestDetails();
786 RequestInfo requestInfo = new RequestInfo();
787 requestInfo.setAdditionalProperty(RESOURCE_TYPE, RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT);
788 requestInfo.setSource(SOURCE_OPERATIONAL_ENVIRONMENT);
789 requestInfo.setRequestorId(details.getUserId());
790 requestDetails.setRequestInfo(requestInfo);
792 RequestParameters requestParameters = new RequestParameters();
793 requestParameters.setUserParams(null);
794 requestParameters.setAdditionalProperty("operationalEnvironmentType", "VNF");
795 requestDetails.setRequestParameters(requestParameters);
796 RequestDetailsWrapper<RequestDetails> requestDetailsWrapper = new RequestDetailsWrapper<>(requestDetails);
797 debugRequestDetails(requestDetailsWrapper, logger);
798 return requestDetailsWrapper;
802 public String getCloudResourcesRequestsStatusPath(String requestId) {
803 String path = validateEndpointPath(MSO_REST_API_CLOUD_RESOURCES_REQUEST_STATUS);
804 path = path.replace("<request_id>", requestId);
809 public String getOperationalEnvironmentDeactivationPath(OperationalEnvironmentDeactivateInfo details) {
810 String path = validateEndpointPath(MSO_REST_API_OPERATIONAL_ENVIRONMENT_DEACTIVATE);
811 path = path.replace("<operational_environment_id>", details.getOperationalEnvironmentId());
816 public String getOperationalEnvironmentCreationPath() {
817 return validateEndpointPath(MSO_REST_API_OPERATIONAL_ENVIRONMENT_CREATE);
822 public RequestDetailsWrapper<OperationEnvironmentRequestDetails> convertParametersToRequestDetails(OperationalEnvironmentController.OperationalEnvironmentCreateBody input, String userId) {
823 OperationEnvironmentRequestDetails.RequestInfo requestInfo = new OperationEnvironmentRequestDetails.RequestInfo(
824 RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT,
825 input.getInstanceName(),
826 SOURCE_OPERATIONAL_ENVIRONMENT,
829 OperationEnvironmentRequestDetails.RelatedInstance relatedInstance = new OperationEnvironmentRequestDetails.RelatedInstance(
830 RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT,
831 input.getEcompInstanceId(),
832 input.getEcompInstanceName());
834 List<OperationEnvironmentRequestDetails.RelatedInstance> relatedInstanceList = Collections.singletonList((relatedInstance));
836 OperationEnvironmentRequestDetails.RequestParameters requestParameters = new OperationEnvironmentRequestDetails.RequestParameters(
837 input.getOperationalEnvironmentType(),
838 input.getTenantContext(),
839 input.getWorkloadContext());
841 OperationEnvironmentRequestDetails requestDetails = new OperationEnvironmentRequestDetails(requestInfo, relatedInstanceList, requestParameters);
842 RequestDetailsWrapper<OperationEnvironmentRequestDetails> requestDetailsWrapper = new RequestDetailsWrapper<>(requestDetails);
843 debugRequestDetails(requestDetailsWrapper, logger);
844 return requestDetailsWrapper;
848 public MsoResponseWrapper removeRelationshipFromServiceInstance(RequestDetails requestDetails, String serviceInstanceId) {
849 logInvocationInDebug("removeRelationshipFromServiceInstance");
851 String serviceEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_SVC_INSTANCE);
852 String removeRelationshipsPath = serviceEndpoint + "/" + serviceInstanceId + "/removeRelationships";
854 return msoClientInterface.removeRelationshipFromServiceInstance(requestDetails, removeRelationshipsPath);
858 public MsoResponseWrapper addRelationshipToServiceInstance(RequestDetails requestDetails, String serviceInstanceId) {
859 logInvocationInDebug("addRelationshipToServiceInstance");
861 String serviceEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_SVC_INSTANCE);
862 String addRelationshipsPath = serviceEndpoint + "/" + serviceInstanceId + "/addRelationships";
864 return msoClientInterface.addRelationshipToServiceInstance(requestDetails, addRelationshipsPath);
869 public ExternalComponentStatus probeGetOrchestrationRequests() {
870 String url = SystemProperties.getProperty(
871 MsoProperties.MSO_SERVER_URL) + "/" + SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQS);
872 long startTime = System.currentTimeMillis();
873 ExternalComponentStatus externalComponentStatus;
876 RestObject<List<Request>> restObject = createRequestsList(getOrchestrationRequestsForDashboard());
878 StatusMetadata statusMetadata = new HttpRequestMetadata(new RestObjectWithRequestInfo(HttpMethod.GET, url, restObject),
879 "VID-SO communication works", System.currentTimeMillis() - startTime);
881 externalComponentStatus = new ExternalComponentStatus(ExternalComponentStatus.Component.MSO, true, statusMetadata);
882 } catch (Exception e) {
883 StatusMetadata statusMetadata = new HttpRequestMetadata(HttpMethod.GET, HttpStatus.INTERNAL_SERVER_ERROR.value(), url, "", e.getMessage(), System.currentTimeMillis() - startTime);
884 externalComponentStatus = new ExternalComponentStatus(ExternalComponentStatus.Component.MSO, false, statusMetadata);
887 return externalComponentStatus;
891 private RestObject<List<Request>> createRequestsList(List<Request> orchestrationRequestsForDashboard) {
892 RestObject<List<Request>> restObject = new RestObject<>();
893 restObject.set(orchestrationRequestsForDashboard);
894 restObject.setStatusCode(200);
899 private void validateUpdateVnfConfig(RequestDetails requestDetails) {
900 final String noValidPayloadMsg = "No valid payload in " + ChangeManagementRequest.CONFIG_UPDATE + " request";
902 Map payload = getChangeManagementPayload(requestDetails, noValidPayloadMsg);
903 validateConfigUpdateVnfPayloadProperty(payload, noValidPayloadMsg, "request-parameters");
904 validateConfigUpdateVnfPayloadProperty(payload, noValidPayloadMsg, "configuration-parameters");
907 private void validateConfigUpdateVnfPayloadProperty(Map payload, String noValidPayloadMsg, String propertyName) {
908 final String noValidPayloadPropertyMsg = noValidPayloadMsg + ", " + propertyName + " property is not valid";
909 if (!payload.containsKey(propertyName)) {
910 throw new BadRequestException(noValidPayloadPropertyMsg);
914 private void logInvocationInDebug(String methodName) {
915 logger.debug(EELFLoggerDelegate.debugLogger, methodName + " start");
918 private void logException(String methodName, Exception e) {
919 logger.error(EELFLoggerDelegate.errorLogger, methodName + e.toString());
920 logger.debug(EELFLoggerDelegate.debugLogger, methodName + e.toString());
923 private boolean isSuccessful(HttpResponse<SOWorkflowList> workflowListByModelId) {
924 int status = workflowListByModelId.getStatus();
925 return HttpStatus.OK.value() == status || HttpStatus.ACCEPTED.value() == status;
928 static class WorkflowListException extends RuntimeException{
930 WorkflowListException(String message) {
937 CREATE_INSTANCE("createInstance"),
938 DELETE_INSTANCE("deleteInstance"),
939 REPLACE_INSTANCE("replaceInstance"),
940 UPDATE_INSTANCE("updateInstance"),
941 ACTIVATE_INSTANCE("activateInstance"),
942 DEACTIVATE_INSTANCE("deactivateInstance"),
943 APPLY_UPDATED_CONFIG("applyUpdatedConfig"),
944 IN_PLACE_SOFTWARE_UPDATE("inPlaceSoftwareUpdate"),
945 SCALE_OUT("scaleOut"),
947 NOT_PROVIDED("not provided");
948 private final String value;
949 private static final Map<String, RequestType> CONSTANTS = new HashMap<>();
952 for (RequestType c : values()) {
953 CONSTANTS.put(c.value, c);
957 RequestType(String value) {
962 public static RequestType fromValue(String value) {
963 RequestType constant = CONSTANTS.get(value);
964 if (constant == null) {
965 throw new IllegalArgumentException(value);
973 public String toString() {