2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * Modifications Copyright (C) 2018 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 org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
30 import org.onap.portalsdk.core.util.SystemProperties;
31 import org.onap.vid.changeManagement.ChangeManagementRequest;
32 import org.onap.vid.changeManagement.RequestDetailsWrapper;
33 import org.onap.vid.controller.OperationalEnvironmentController;
34 import org.onap.vid.exceptions.GenericUncheckedException;
35 import org.onap.vid.model.RequestReferencesContainer;
36 import org.onap.vid.model.SoftDeleteRequest;
37 import org.onap.vid.mso.model.*;
38 import org.onap.vid.mso.rest.OperationalEnvironment.OperationEnvironmentRequestDetails;
39 import org.onap.vid.mso.rest.*;
40 import org.springframework.beans.factory.annotation.Autowired;
41 import org.togglz.core.manager.FeatureManager;
43 import javax.ws.rs.BadRequestException;
44 import java.io.IOException;
46 import java.util.regex.Pattern;
47 import java.util.stream.Collectors;
48 import java.util.stream.Stream;
50 import static java.util.stream.Collectors.collectingAndThen;
51 import static java.util.stream.Collectors.toList;
52 import static org.apache.commons.lang.StringUtils.upperCase;
53 import static org.onap.vid.changeManagement.ChangeManagementRequest.MsoChangeManagementRequest;
54 import static org.onap.vid.controller.MsoController.*;
55 import static org.onap.vid.mso.MsoProperties.*;
56 import static org.onap.vid.properties.Features.FLAG_UNASSIGN_SERVICE;
57 import static org.onap.vid.utils.Logging.debugRequestDetails;
59 public class MsoBusinessLogicImpl implements MsoBusinessLogic {
61 static final List<String> DASHBOARD_ALLOWED_TYPES = Stream.of(RequestType.REPLACE_INSTANCE,
62 RequestType.UPDATE_INSTANCE,
63 RequestType.APPLY_UPDATED_CONFIG,
64 RequestType.IN_PLACE_SOFTWARE_UPDATE,
65 RequestType.SCALE_OUT)
66 .map(requestType -> requestType.toString().toUpperCase())
67 .collect(collectingAndThen(toList(), Collections::unmodifiableList));
68 private static final String RESOURCE_TYPE = "resourceType";
69 private static final Pattern SOFTWARE_VERSION_PATTERN = Pattern.compile("^[A-Za-z0-9.\\-]+$");
70 private static final Pattern NUMBER_PATTERN = Pattern.compile("^[0-9]+$");
71 private static final String ACTIVATE = "/activate";
72 private static final String DEACTIVATE = "/deactivate";
73 private static final String ENABLE_PORT = "/enablePort";
74 private static final String DISABLE_PORT = "/disablePort";
75 private static final String ACTIVATE_FABRIC_CONFIGURATION = "/activateFabricConfiguration";
76 private static final String DEACTIVATE_AND_CLOUD_DELETE = "/deactivateAndCloudDelete";
77 private static final String RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT = "operationalEnvironment";
78 private static final String SOURCE_OPERATIONAL_ENVIRONMENT = "VID";
79 private static final ObjectMapper objectMapper = new ObjectMapper();
83 private static final EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(MsoBusinessLogicImpl.class);
86 * This should be replaced with mso client factory.
88 private final MsoInterface msoClientInterface;
89 FeatureManager featureManager;
92 public MsoBusinessLogicImpl(MsoInterface msoClientInterface, FeatureManager featureManager) {
93 this.msoClientInterface = msoClientInterface;
94 this.featureManager = featureManager;
97 public static String validateEndpointPath(String endpointEnvVariable) {
98 String endpoint = SystemProperties.getProperty(endpointEnvVariable);
99 if (endpoint == null || endpoint.isEmpty()) {
100 throw new GenericUncheckedException(endpointEnvVariable + " env variable is not defined");
105 // this function should get params from tosca and send them to instance at mso, then return success response.
107 public MsoResponseWrapper createSvcInstance(RequestDetails msoRequest) {
108 logInvocationInDebug("createSvcInstance");
110 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_SVC_INSTANCE);
112 return msoClientInterface.createSvcInstance(msoRequest, endpoint);
116 public MsoResponseWrapper createE2eSvcInstance(Object msoRequest) {
117 logInvocationInDebug("createE2eSvcInstance");
118 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_E2E_SVC_INSTANCE);
120 return msoClientInterface.createE2eSvcInstance(msoRequest, endpoint);
124 public MsoResponseWrapper createVnf(RequestDetails requestDetails, String serviceInstanceId) {
125 logInvocationInDebug("createVnf");
127 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
129 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
130 return msoClientInterface.createVnf(requestDetails, vnfEndpoint);
134 public MsoResponseWrapper createNwInstance(RequestDetails requestDetails, String serviceInstanceId) {
135 logInvocationInDebug("createNwInstance");
137 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_NETWORK_INSTANCE);
139 String nw_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
140 return msoClientInterface.createNwInstance(requestDetails, nw_endpoint);
144 public MsoResponseWrapper createVolumeGroupInstance(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
145 logInvocationInDebug("createVolumeGroupInstance");
147 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VOLUME_GROUP_INSTANCE);
149 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
150 vnfEndpoint = vnfEndpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
152 return msoClientInterface.createVolumeGroupInstance(requestDetails, vnfEndpoint);
156 public MsoResponseWrapper createVfModuleInstance(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
157 logInvocationInDebug("createVfModuleInstance");
159 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
161 String partial_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
162 String vf_module_endpoint = partial_endpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
164 return msoClientInterface.createVfModuleInstance(requestDetails, vf_module_endpoint);
168 public MsoResponseWrapper scaleOutVfModuleInstance(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
169 logInvocationInDebug("scaleOutVfModuleInstance");
171 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_SCALE_OUT);
173 String partial_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
174 String vf_module_endpoint = partial_endpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
175 RequestDetailsWrapper wrapper = new RequestDetailsWrapper();
176 requestDetails.setVnfName(null);
177 requestDetails.setVnfInstanceId(null);
178 wrapper.requestDetails = requestDetails;
180 return msoClientInterface.scaleOutVFModuleInstance(wrapper, vf_module_endpoint);
184 public MsoResponseWrapper createConfigurationInstance(org.onap.vid.mso.rest.RequestDetailsWrapper requestDetailsWrapper, String serviceInstanceId) {
185 logInvocationInDebug("createConfigurationInstance");
187 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATIONS);
188 endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
190 return msoClientInterface.createConfigurationInstance(requestDetailsWrapper, endpoint);
194 public MsoResponseWrapper deleteE2eSvcInstance(Object requestDetails, String serviceInstanceId) {
195 logInvocationInDebug("deleteE2eSvcInstance");
197 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_E2E_SVC_INSTANCE) + "/" + serviceInstanceId;
199 return msoClientInterface.deleteE2eSvcInstance(requestDetails, endpoint);
203 public MsoResponseWrapper deleteSvcInstance(RequestDetails requestDetails, String serviceInstanceId, String serviceStatus) {
204 logInvocationInDebug("deleteSvcInstance");
207 if (featureManager.isActive(FLAG_UNASSIGN_SERVICE)) {
208 endpoint = validateEndpointPath(MsoProperties.MSO_DELETE_OR_UNASSIGN_REST_API_SVC_INSTANCE);
209 if (shouldUnassignService(serviceStatus)) {
210 logger.debug(EELFLoggerDelegate.debugLogger, "unassign service");
211 String svc_endpoint = endpoint + "/" + serviceInstanceId + "/unassign";
212 return msoClientInterface.unassignSvcInstance(requestDetails, svc_endpoint);
215 endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_SVC_INSTANCE);
218 String svc_endpoint = endpoint + "/" + serviceInstanceId;
219 return msoClientInterface.deleteSvcInstance(requestDetails, svc_endpoint);
222 private boolean shouldUnassignService(String serviceStatus) {
223 return ImmutableList.of("created", "pendingdelete", "pending-delete", "assigned").contains(serviceStatus.toLowerCase());
227 public MsoResponseWrapper deleteVnf(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
228 logInvocationInDebug("deleteVnf");
230 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
231 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
232 vnfEndpoint = vnfEndpoint + '/' + vnfInstanceId;
234 return msoClientInterface.deleteVnf(requestDetails, vnfEndpoint);
238 public MsoResponseWrapper deleteVfModule(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId, String vfModuleId) {
239 logInvocationInDebug("deleteVfModule");
241 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
242 String vf__modules_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId).replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
243 String delete_vf_endpoint = vf__modules_endpoint + '/' + vfModuleId;
245 return msoClientInterface.deleteVfModule(requestDetails, delete_vf_endpoint);
249 public MsoResponseWrapper deleteVolumeGroupInstance(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId, String volumeGroupId) {
250 logInvocationInDebug("deleteVolumeGroupInstance");
252 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VOLUME_GROUP_INSTANCE);
253 String svc_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
254 String vnfEndpoint = svc_endpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
255 String delete_volume_group_endpoint = vnfEndpoint + "/" + volumeGroupId;
257 return msoClientInterface.deleteVolumeGroupInstance(requestDetails, delete_volume_group_endpoint);
261 public MsoResponseWrapper deleteNwInstance(RequestDetails requestDetails, String serviceInstanceId, String networkInstanceId) {
262 logInvocationInDebug("deleteNwInstance");
264 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_NETWORK_INSTANCE);
265 String svc_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
266 String delete_nw_endpoint = svc_endpoint + "/" + networkInstanceId;
268 return msoClientInterface.deleteNwInstance(requestDetails, delete_nw_endpoint);
272 public MsoResponseWrapper getOrchestrationRequest(String requestId) {
273 String methodName = "getOrchestrationRequest";
274 logInvocationInDebug(methodName);
276 String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQ);
277 String path = p + "/" + requestId;
279 return msoClientInterface.getOrchestrationRequest(path);
281 } catch (Exception e) {
282 logException(methodName, e);
288 public MsoResponseWrapper getOrchestrationRequests(String filterString) {
289 String methodName = "getOrchestrationRequest";
290 logInvocationInDebug(methodName);
292 String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQS);
293 String path = p + filterString;
295 return msoClientInterface.getOrchestrationRequest(path);
297 } catch (Exception e) {
298 logException(methodName, e);
304 public List<Request> getOrchestrationRequestsForDashboard() {
305 String methodName = "getOrchestrationRequestsForDashboard";
306 logInvocationInDebug(methodName);
308 List<Request> dashboardOrchestrationReqs = new ArrayList<>();
310 List<RequestWrapper> vnfOrchestrationReqsWrappers = getOrchestrationRequestsByFilter("modelType", "vnf");
311 dashboardOrchestrationReqs = vnfOrchestrationReqsWrappers.stream()
312 .filter(reqWrapper -> Objects.nonNull(reqWrapper.getRequest())
313 && DASHBOARD_ALLOWED_TYPES.contains(upperCase(reqWrapper.getRequest().getRequestType())))
314 .map(RequestWrapper::getRequest)
315 .collect(Collectors.toList());
317 List<RequestWrapper> scaleOutOrchestrationReqWrappers = getOrchestrationRequestsByFilter("action", "scaleOut");
318 List<Request> scaleoutRequests = scaleOutOrchestrationReqWrappers.stream()
319 .filter(reqWrapper -> Objects.nonNull(reqWrapper.getRequest()))
320 .map(RequestWrapper::getRequest)
321 .collect(Collectors.toList());
323 dashboardOrchestrationReqs.addAll(scaleoutRequests);
324 } catch (Exception e) {
325 logException(methodName, e);
327 return dashboardOrchestrationReqs;
330 private String constructOrchestrationRequestFilter(String filterName, String filterValue) {
331 return String.format("%sfilter=%s:EQUALS:%s",
332 SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQS), filterName, filterValue);
335 private List<RequestWrapper> getOrchestrationRequestsByFilter(String filterName, String filterValue) {
336 String orchestrationReqPath = constructOrchestrationRequestFilter(filterName, filterValue);
337 RestObject<String> restObjStr = new RestObject<>();
338 String str = new String();
340 MsoResponseWrapper msoResponseWrapper = msoClientInterface.getOrchestrationRequest(str, "", orchestrationReqPath, restObjStr, true);
341 return deserializeOrchestrationRequestsJson(msoResponseWrapper.getEntity());
344 private List<RequestWrapper> deserializeOrchestrationRequestsJson(String orchestrationRequestsJson) {
345 logInvocationInDebug("deserializeOrchestrationRequestsJson");
347 ObjectMapper mapper = new ObjectMapper();
348 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
349 mapper.configure(DeserializationFeature.READ_ENUMS_USING_TO_STRING, true);
350 RequestList requestList;
352 requestList = mapper.readValue(orchestrationRequestsJson, RequestList.class);
353 } catch (IOException e) {
354 throw new GenericUncheckedException(e);
356 return requestList.getRequestList();
361 public List<Task> getManualTasksByRequestId(String originalRequestId) {
362 String methodName = "getManualTasksByRequestId";
363 logInvocationInDebug(methodName);
366 String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_MAN_TASKS);
367 String path = p + "?originalRequestId=" + originalRequestId;
369 RestObject<String> restObjStr = new RestObject<>();
370 String str = new String();
373 MsoResponseWrapper msoResponseWrapper = msoClientInterface.getManualTasksByRequestId(str, "", path, restObjStr);
374 return deserializeManualTasksJson(msoResponseWrapper.getEntity());
376 } catch (Exception e) {
377 logException(methodName, e);
382 private List<Task> deserializeManualTasksJson(String manualTasksJson) {
383 logInvocationInDebug("deserializeManualTasksJson");
385 ObjectMapper mapper = new ObjectMapper();
387 TaskList taskList = mapper.readValue(manualTasksJson, TaskList.class);
388 return taskList.getTaskList();
389 } catch (IOException e) {
390 throw new GenericUncheckedException(e);
396 public MsoResponseWrapper completeManualTask(RequestDetails requestDetails, String taskId) {
397 String methodName = "completeManualTask";
398 logInvocationInDebug(methodName);
400 String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_MAN_TASKS);
401 String path = p + "/" + taskId + "/complete";
403 RestObject<String> restObjStr = new RestObject<>();
404 String str = new String();
407 msoClientInterface.completeManualTask(requestDetails, str, "", path, restObjStr);
409 return MsoUtil.wrapResponse(restObjStr);
411 } catch (Exception e) {
412 logException(methodName, e);
418 public MsoResponseWrapper activateServiceInstance(RequestDetails requestDetails, String serviceInstanceId) {
419 String methodName = "activateServiceInstance";
420 logInvocationInDebug(methodName);
422 String serviceEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_SVC_INSTANCE);
423 String activateServicePath = serviceEndpoint + "/" + serviceInstanceId + ACTIVATE;
425 RestObject<String> restObjStr = new RestObject<>();
429 msoClientInterface.setServiceInstanceStatus(requestDetails, str, "", activateServicePath, restObjStr);
431 return MsoUtil.wrapResponse(restObjStr);
433 } catch (Exception e) {
434 logException(methodName, e);
441 public MsoResponseWrapperInterface updateVnf(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
442 logInvocationInDebug("updateVnf");
445 endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
446 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
447 vnfEndpoint = vnfEndpoint + '/' + vnfInstanceId;
448 return msoClientInterface.updateVnf(requestDetails, vnfEndpoint);
452 public MsoResponseWrapperInterface replaceVnf(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
453 logInvocationInDebug("replaceVnf");
455 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_CHANGE_MANAGEMENT_INSTANCE);
456 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
457 vnfEndpoint = vnfEndpoint.replace(VNF_INSTANCE_ID, vnfInstanceId);
458 vnfEndpoint = vnfEndpoint.replace(REQUEST_TYPE, MsoChangeManagementRequest.REPLACE);
459 return msoClientInterface.replaceVnf(requestDetails, vnfEndpoint);
462 public RequestDetailsWrapper generateInPlaceMsoRequest(org.onap.vid.changeManagement.RequestDetails requestDetails) {
463 validateUpdateVnfSoftwarePayload(requestDetails);
464 RequestDetails inPlaceSoftwareUpdateRequest = new RequestDetails();
465 inPlaceSoftwareUpdateRequest.setCloudConfiguration(requestDetails.getCloudConfiguration());
466 inPlaceSoftwareUpdateRequest.setRequestParameters(requestDetails.getRequestParameters());
467 inPlaceSoftwareUpdateRequest.setRequestInfo(requestDetails.getRequestInfo());
468 RequestDetailsWrapper requestDetailsWrapper = new RequestDetailsWrapper();
469 requestDetailsWrapper.requestDetails = inPlaceSoftwareUpdateRequest;
470 return requestDetailsWrapper;
474 public RequestDetailsWrapper generateConfigMsoRequest(org.onap.vid.changeManagement.RequestDetails requestDetails) {
475 validateUpdateVnfConfig(requestDetails);
476 RequestDetails configUpdateRequest = new RequestDetails();
477 configUpdateRequest.setRequestParameters(requestDetails.getRequestParameters());
478 configUpdateRequest.setRequestInfo(requestDetails.getRequestInfo());
479 RequestDetailsWrapper requestDetailsWrapper = new RequestDetailsWrapper();
480 requestDetailsWrapper.requestDetails = configUpdateRequest;
481 return requestDetailsWrapper;
485 public String getActivateFabricConfigurationPath(String serviceInstanceId) {
486 String path = validateEndpointPath(MsoProperties.MSO_REST_API_SERVICE_INSTANCE_CREATE);
487 path += "/" + serviceInstanceId + ACTIVATE_FABRIC_CONFIGURATION;
493 public String getDeactivateAndCloudDeletePath(String serviceInstanceId, String vnfInstanceId, String vfModuleInstanceId) {
494 String path = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
495 path = path.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
496 path = path.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
497 path += "/" + vfModuleInstanceId + DEACTIVATE_AND_CLOUD_DELETE;
503 public RequestDetails buildRequestDetailsForSoftDelete(SoftDeleteRequest softDeleteRequest) {
504 RequestDetails requestDetails = new RequestDetails();
505 RequestInfo requestInfo = new RequestInfo();
506 requestInfo.setSource("VID");
507 requestInfo.setRequestorId(softDeleteRequest.getUserId());
508 requestDetails.setRequestInfo(requestInfo);
510 CloudConfiguration cloudConfiguration = new CloudConfiguration();
511 cloudConfiguration.setTenantId(softDeleteRequest.getTenantId());
512 cloudConfiguration.setLcpCloudRegionId(softDeleteRequest.getLcpCloudRegionId());
513 requestDetails.setCloudConfiguration(cloudConfiguration);
515 ModelInfo modelInfo = new ModelInfo();
516 modelInfo.setModelType("vfModule");
517 requestDetails.setModelInfo(modelInfo);
519 RequestParameters requestParameters = new RequestParameters();
520 requestParameters.setTestApi("GR_API");
521 requestDetails.setRequestParameters(requestParameters);
523 return requestDetails;
527 public MsoResponseWrapper2 deactivateAndCloudDelete(String serviceInstanceId, String vnfInstanceId, String vfModuleInstanceId, RequestDetails requestDetails) {
528 String path = getDeactivateAndCloudDeletePath(serviceInstanceId, vnfInstanceId, vfModuleInstanceId);
529 return new MsoResponseWrapper2<>(msoClientInterface.post(path, new RequestDetailsWrapper<>(requestDetails), RequestReferencesContainer.class));
533 public MsoResponseWrapper2 activateFabricConfiguration(String serviceInstanceId, RequestDetails requestDetails) {
534 String path = getActivateFabricConfigurationPath(serviceInstanceId);
535 return new MsoResponseWrapper2<>(msoClientInterface.post(path, new RequestDetailsWrapper<>(requestDetails), RequestReferencesContainer.class));
540 public MsoResponseWrapperInterface updateVnfSoftware(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
541 logInvocationInDebug("updateVnfSoftware");
542 String vnfEndpoint = getChangeManagementEndpoint(serviceInstanceId, vnfInstanceId, MsoChangeManagementRequest.SOFTWARE_UPDATE); //workflow name in mso is different than workflow name in vid UI
543 RequestDetailsWrapper finalRequestDetails = generateInPlaceMsoRequest(requestDetails);
544 return msoClientInterface.changeManagementUpdate(finalRequestDetails, vnfEndpoint);
548 public MsoResponseWrapperInterface updateVnfConfig(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
549 logInvocationInDebug("updateVnfConfig");
550 RequestDetailsWrapper finalRequestDetails = generateConfigMsoRequest(requestDetails);
551 String vnfEndpoint = getChangeManagementEndpoint(serviceInstanceId, vnfInstanceId, MsoChangeManagementRequest.CONFIG_UPDATE);
552 return msoClientInterface.changeManagementUpdate(finalRequestDetails, vnfEndpoint);
555 private String getChangeManagementEndpoint(String serviceInstanceId, String vnfInstanceId, String vnfRequestType) {
556 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_CHANGE_MANAGEMENT_INSTANCE);
557 String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
558 vnfEndpoint = vnfEndpoint.replace(VNF_INSTANCE_ID, vnfInstanceId);
559 vnfEndpoint = vnfEndpoint.replace(REQUEST_TYPE, vnfRequestType);
563 private Map getChangeManagementPayload(RequestDetails requestDetails, String message) {
564 if (requestDetails.getRequestParameters() == null || requestDetails.getRequestParameters().getAdditionalProperties() == null) {
565 throw new BadRequestException(message);
567 Object payloadRaw = requestDetails.getRequestParameters().getAdditionalProperties().get("payload");
569 return objectMapper.readValue((String) payloadRaw, Map.class);
570 } catch (Exception exception) {
571 throw new BadRequestException(message);
575 private void validateUpdateVnfSoftwarePayload(RequestDetails requestDetails) {
576 final String noValidPayloadMsg = "No valid payload in " + ChangeManagementRequest.VNF_IN_PLACE_SOFTWARE_UPDATE + " request";
578 Map payload = getChangeManagementPayload(requestDetails, noValidPayloadMsg);
579 validateUpdateVnfSoftwarePayloadProperty(payload, noValidPayloadMsg, "existing_software_version", SOFTWARE_VERSION_PATTERN);
580 validateUpdateVnfSoftwarePayloadProperty(payload, noValidPayloadMsg, "new_software_version", SOFTWARE_VERSION_PATTERN);
582 //if "operations_timeout" is not integer, trying to read it as String that represent a number
583 if (!(payload.get("operations_timeout") instanceof Integer)) {
584 validateUpdateVnfSoftwarePayloadProperty(payload, noValidPayloadMsg, "operations_timeout", NUMBER_PATTERN);
588 private void validateUpdateVnfSoftwarePayloadProperty(Map payload, String noValidPayloadMsg, String propertyName, Pattern pattern) {
589 Object forValidation = payload.get(propertyName);
590 final String noValidPayloadPropertyMsg = noValidPayloadMsg + ", " + propertyName + " property is not valid";
591 if (!(forValidation instanceof String)) {
592 throw new BadRequestException(noValidPayloadPropertyMsg);
594 if (!pattern.matcher((String) forValidation).matches()) {
595 throw new BadRequestException(noValidPayloadPropertyMsg);
600 public MsoResponseWrapper deleteConfiguration(org.onap.vid.mso.rest.RequestDetailsWrapper requestDetailsWrapper,
601 String serviceInstanceId,
602 String configurationId) {
604 logInvocationInDebug("deleteConfiguration");
605 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATION_INSTANCE);
606 endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
607 endpoint = endpoint.replace(CONFIGURATION_ID, configurationId);
609 return msoClientInterface.deleteConfiguration(requestDetailsWrapper, endpoint);
613 public MsoResponseWrapper setConfigurationActiveStatus(
614 RequestDetails requestDetails,
615 String serviceInstanceId,
616 String configurationId,
617 boolean isActivate) {
619 logInvocationInDebug("setConfigurationActiveStatus");
621 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATION_INSTANCE);
622 endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
623 endpoint = endpoint.replace(CONFIGURATION_ID, configurationId);
625 String isActivateState = (isActivate ? ACTIVATE : DEACTIVATE);
626 endpoint = endpoint + isActivateState;
628 return msoClientInterface.setConfigurationActiveStatus(requestDetails, endpoint);
632 public MsoResponseWrapper setServiceInstanceStatus(RequestDetails requestDetails, String serviceInstanceId, boolean isActivate) {
633 logInvocationInDebug("setServiceInstanceStatus");
634 String methodName = "setServiceInstanceStatus";
636 String serviceEndpoint = validateEndpointPath(MsoProperties.MSO_REST_API_SVC_INSTANCE);
637 String endpoint = serviceEndpoint + "/" + serviceInstanceId;
639 String isActivateState = (isActivate ? ACTIVATE : DEACTIVATE);
640 endpoint = endpoint + isActivateState;
643 RestObject<String> restObjStr = new RestObject<>();
647 msoClientInterface.setServiceInstanceStatus(requestDetails, str, "", endpoint, restObjStr);
649 return MsoUtil.wrapResponse(restObjStr);
651 } catch (Exception e) {
652 logger.error(EELFLoggerDelegate.errorLogger, methodName + e.toString());
653 logger.debug(EELFLoggerDelegate.debugLogger, methodName + e.toString());
659 public MsoResponseWrapper setPortOnConfigurationStatus(
660 RequestDetails requestDetails,
661 String serviceInstanceId,
662 String configurationId,
664 logInvocationInDebug("setPortOnConfigurationStatus");
666 String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATION_INSTANCE);
667 endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
668 endpoint = endpoint.replace(CONFIGURATION_ID, configurationId);
670 String isEnablePortStatus = (isEnable ? ENABLE_PORT : DISABLE_PORT);
671 endpoint = endpoint + isEnablePortStatus;
673 return msoClientInterface.setPortOnConfigurationStatus(requestDetails, endpoint);
678 public RequestDetailsWrapper<RequestDetails> createOperationalEnvironmentActivationRequestDetails(OperationalEnvironmentActivateInfo details) {
679 RequestDetails requestDetails = new RequestDetails();
680 RequestInfo requestInfo = new RequestInfo();
681 requestInfo.setAdditionalProperty(RESOURCE_TYPE, RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT);
682 requestInfo.setSource(SOURCE_OPERATIONAL_ENVIRONMENT);
683 requestInfo.setRequestorId(details.getUserId());
684 requestDetails.setRequestInfo(requestInfo);
686 RelatedInstance relatedInstance = new RelatedInstance();
687 relatedInstance.setAdditionalProperty(RESOURCE_TYPE, RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT);
688 relatedInstance.setInstanceId(details.getRelatedInstanceId());
689 relatedInstance.setInstanceName(details.getRelatedInstanceName());
690 requestDetails.setAdditionalProperty("relatedInstanceList", Collections.singletonList(ImmutableMap.of("relatedInstance", relatedInstance)));
692 RequestParameters requestParameters = new RequestParameters();
693 requestParameters.setUserParams(null);
694 requestParameters.setAdditionalProperty("operationalEnvironmentType", "VNF");
695 requestParameters.setAdditionalProperty("workloadContext", details.getWorkloadContext());
696 requestParameters.setAdditionalProperty("manifest", details.getManifest());
697 requestDetails.setRequestParameters(requestParameters);
699 RequestDetailsWrapper<RequestDetails> requestDetailsWrapper = new RequestDetailsWrapper<>(requestDetails);
701 debugRequestDetails(requestDetailsWrapper, logger);
703 return requestDetailsWrapper;
707 public String getOperationalEnvironmentActivationPath(OperationalEnvironmentActivateInfo details) {
708 String path = validateEndpointPath(MSO_REST_API_OPERATIONAL_ENVIRONMENT_ACTIVATE);
709 path = path.replace("<operational_environment_id>", details.getOperationalEnvironmentId());
714 public RequestDetailsWrapper<RequestDetails> createOperationalEnvironmentDeactivationRequestDetails(OperationalEnvironmentDeactivateInfo details) {
715 RequestDetails requestDetails = new RequestDetails();
717 RequestInfo requestInfo = new RequestInfo();
718 requestInfo.setAdditionalProperty(RESOURCE_TYPE, RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT);
719 requestInfo.setSource(SOURCE_OPERATIONAL_ENVIRONMENT);
720 requestInfo.setRequestorId(details.getUserId());
721 requestDetails.setRequestInfo(requestInfo);
723 RequestParameters requestParameters = new RequestParameters();
724 requestParameters.setUserParams(null);
725 requestParameters.setAdditionalProperty("operationalEnvironmentType", "VNF");
726 requestDetails.setRequestParameters(requestParameters);
727 RequestDetailsWrapper<RequestDetails> requestDetailsWrapper = new RequestDetailsWrapper<>(requestDetails);
728 debugRequestDetails(requestDetailsWrapper, logger);
729 return requestDetailsWrapper;
733 public String getCloudResourcesRequestsStatusPath(String requestId) {
734 String path = validateEndpointPath(MSO_REST_API_CLOUD_RESOURCES_REQUEST_STATUS);
735 path = path.replace("<request_id>", requestId);
740 public String getOperationalEnvironmentDeactivationPath(OperationalEnvironmentDeactivateInfo details) {
741 String path = validateEndpointPath(MSO_REST_API_OPERATIONAL_ENVIRONMENT_DEACTIVATE);
742 path = path.replace("<operational_environment_id>", details.getOperationalEnvironmentId());
747 public String getOperationalEnvironmentCreationPath() {
748 return validateEndpointPath(MSO_REST_API_OPERATIONAL_ENVIRONMENT_CREATE);
753 public RequestDetailsWrapper<OperationEnvironmentRequestDetails> convertParametersToRequestDetails(OperationalEnvironmentController.OperationalEnvironmentCreateBody input, String userId) {
754 OperationEnvironmentRequestDetails.RequestInfo requestInfo = new OperationEnvironmentRequestDetails.RequestInfo(
755 RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT,
756 input.getInstanceName(),
757 SOURCE_OPERATIONAL_ENVIRONMENT,
760 OperationEnvironmentRequestDetails.RelatedInstance relatedInstance = new OperationEnvironmentRequestDetails.RelatedInstance(
761 RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT,
762 input.getEcompInstanceId(),
763 input.getEcompInstanceName());
765 List<OperationEnvironmentRequestDetails.RelatedInstance> relatedInstanceList = Collections.singletonList((relatedInstance));
767 OperationEnvironmentRequestDetails.RequestParameters requestParameters = new OperationEnvironmentRequestDetails.RequestParameters(
768 input.getOperationalEnvironmentType(),
769 input.getTenantContext(),
770 input.getWorkloadContext());
772 OperationEnvironmentRequestDetails requestDetails = new OperationEnvironmentRequestDetails(requestInfo, relatedInstanceList, requestParameters);
773 RequestDetailsWrapper<OperationEnvironmentRequestDetails> requestDetailsWrapper = new RequestDetailsWrapper<>(requestDetails);
774 debugRequestDetails(requestDetailsWrapper, logger);
775 return requestDetailsWrapper;
779 public MsoResponseWrapper removeRelationshipFromServiceInstance(RequestDetails requestDetails, String serviceInstanceId) {
780 logInvocationInDebug("removeRelationshipFromServiceInstance");
782 String serviceEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_SVC_INSTANCE);
783 String removeRelationshipsPath = serviceEndpoint + "/" + serviceInstanceId + "/removeRelationships";
785 return msoClientInterface.removeRelationshipFromServiceInstance(requestDetails, removeRelationshipsPath);
789 public MsoResponseWrapper addRelationshipToServiceInstance(RequestDetails requestDetails, String serviceInstanceId) {
790 logInvocationInDebug("addRelationshipToServiceInstance");
792 String serviceEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_SVC_INSTANCE);
793 String addRelationshipsPath = serviceEndpoint + "/" + serviceInstanceId + "/addRelationships";
795 return msoClientInterface.addRelationshipToServiceInstance(requestDetails, addRelationshipsPath);
798 private void validateUpdateVnfConfig(RequestDetails requestDetails) {
799 final String noValidPayloadMsg = "No valid payload in " + ChangeManagementRequest.CONFIG_UPDATE + " request";
801 Map payload = getChangeManagementPayload(requestDetails, noValidPayloadMsg);
802 validateConfigUpdateVnfPayloadProperty(payload, noValidPayloadMsg, "request-parameters");
803 validateConfigUpdateVnfPayloadProperty(payload, noValidPayloadMsg, "configuration-parameters");
806 private void validateConfigUpdateVnfPayloadProperty(Map payload, String noValidPayloadMsg, String propertyName) {
807 final String noValidPayloadPropertyMsg = noValidPayloadMsg + ", " + propertyName + " property is not valid";
808 if (!payload.containsKey(propertyName)) {
809 throw new BadRequestException(noValidPayloadPropertyMsg);
813 private void logInvocationInDebug(String methodName) {
814 logger.debug(EELFLoggerDelegate.debugLogger, methodName + " start");
817 private void logException(String methodName, Exception e) {
818 logger.error(EELFLoggerDelegate.errorLogger, methodName + e.toString());
819 logger.debug(EELFLoggerDelegate.debugLogger, methodName + e.toString());
824 CREATE_INSTANCE("createInstance"),
825 DELETE_INSTANCE("deleteInstance"),
826 REPLACE_INSTANCE("replaceInstance"),
827 UPDATE_INSTANCE("updateInstance"),
828 ACTIVATE_INSTANCE("activateInstance"),
829 DEACTIVATE_INSTANCE("deactivateInstance"),
830 APPLY_UPDATED_CONFIG("applyUpdatedConfig"),
831 IN_PLACE_SOFTWARE_UPDATE("inPlaceSoftwareUpdate"),
832 SCALE_OUT("scaleOut"),
834 NOT_PROVIDED("not provided");
835 private final String value;
836 private static final Map<String, RequestType> CONSTANTS = new HashMap<>();
839 for (RequestType c : values()) {
840 CONSTANTS.put(c.value, c);
844 RequestType(String value) {
849 public static RequestType fromValue(String value) {
850 RequestType constant = CONSTANTS.get(value);
851 if (constant == null) {
852 throw new IllegalArgumentException(value);
860 public String toString() {