vid-app-common/src/main/java/org/onap/vid/mso/MsoBusinessLogicImpl.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * VID
   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
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  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=========================================================
  20  */
  21 package org.onap.vid.mso;
  22
  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.changeManagement.UIWorkflowsRequest;
  34 import org.onap.vid.changeManagement.WorkflowRequestDetail;
  35 import org.onap.vid.controller.ControllersUtils;
  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.SoftDeleteRequest;
  40 import org.onap.vid.mso.model.*;
  41 import org.onap.vid.mso.rest.OperationalEnvironment.OperationEnvironmentRequestDetails;
  42 import org.onap.vid.mso.rest.*;
  43 import org.springframework.beans.factory.annotation.Autowired;
  44 import org.togglz.core.manager.FeatureManager;
  45
  46 import javax.ws.rs.BadRequestException;
  47 import java.io.IOException;
  48 import java.util.*;
  49 import java.util.regex.Pattern;
  50 import java.util.stream.Collectors;
  51 import java.util.stream.Stream;
  52
  53 import static java.util.stream.Collectors.collectingAndThen;
  54 import static java.util.stream.Collectors.toList;
  55 import static org.apache.commons.lang.StringUtils.upperCase;
  56 import static org.onap.vid.changeManagement.ChangeManagementRequest.MsoChangeManagementRequest;
  57 import static org.onap.vid.controller.MsoController.*;
  58 import static org.onap.vid.mso.MsoProperties.*;
  59 import static org.onap.vid.properties.Features.FLAG_UNASSIGN_SERVICE;
  60 import static org.onap.vid.utils.Logging.debugRequestDetails;
  61
  62 public class MsoBusinessLogicImpl implements MsoBusinessLogic {
  63
  64     static final List<String> DASHBOARD_ALLOWED_TYPES = Stream.of(RequestType.REPLACE_INSTANCE,
  65             RequestType.UPDATE_INSTANCE,
  66             RequestType.APPLY_UPDATED_CONFIG,
  67             RequestType.IN_PLACE_SOFTWARE_UPDATE,
  68             RequestType.SCALE_OUT)
  69             .map(requestType -> requestType.toString().toUpperCase())
  70             .collect(collectingAndThen(toList(), Collections::unmodifiableList));
  71     private static final String RESOURCE_TYPE = "resourceType";
  72     private static final Pattern SOFTWARE_VERSION_PATTERN = Pattern.compile("^[A-Za-z0-9.\\-]+$");
  73     private static final Pattern NUMBER_PATTERN = Pattern.compile("^[0-9]+$");
  74     private static final String ACTIVATE = "/activate";
  75     private static final String DEACTIVATE = "/deactivate";
  76     private static final String ENABLE_PORT = "/enablePort";
  77     private static final String DISABLE_PORT = "/disablePort";
  78     private static final String ACTIVATE_FABRIC_CONFIGURATION = "/activateFabricConfiguration";
  79     private static final String DEACTIVATE_AND_CLOUD_DELETE = "/deactivateAndCloudDelete";
  80     private static final String RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT = "operationalEnvironment";
  81     private static final String SOURCE_OPERATIONAL_ENVIRONMENT = "VID";
  82     private static final ObjectMapper objectMapper = new ObjectMapper();
  83     /**
  84      * The logger.
  85      */
  86     private static final EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(MsoBusinessLogicImpl.class);
  87     /**
  88      * The Mso REST client
  89      * This should be replaced with mso client factory.
  90      */
  91     private final MsoInterface msoClientInterface;
  92     FeatureManager featureManager;
  93
  94     @Autowired
  95     public MsoBusinessLogicImpl(MsoInterface msoClientInterface, FeatureManager featureManager) {
  96         this.msoClientInterface = msoClientInterface;
  97         this.featureManager = featureManager;
  98     }
  99
 100     public static String    validateEndpointPath(String endpointEnvVariable) {
 101         String endpoint = SystemProperties.getProperty(endpointEnvVariable);
 102         if (endpoint == null || endpoint.isEmpty()) {
 103             throw new GenericUncheckedException(endpointEnvVariable + " env variable is not defined");
 104         }
 105         return endpoint;
 106     }
 107
 108     // this function should get params from tosca and send them to instance at mso, then return success response.
 109     @Override
 110     public MsoResponseWrapper createSvcInstance(RequestDetails msoRequest) {
 111         logInvocationInDebug("createSvcInstance");
 112
 113         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_SVC_INSTANCE);
 114
 115         return msoClientInterface.createSvcInstance(msoRequest, endpoint);
 116     }
 117
 118     @Override
 119     public MsoResponseWrapper createE2eSvcInstance(Object msoRequest) {
 120         logInvocationInDebug("createE2eSvcInstance");
 121         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_E2E_SVC_INSTANCE);
 122
 123         return msoClientInterface.createE2eSvcInstance(msoRequest, endpoint);
 124     }
 125
 126     @Override
 127     public MsoResponseWrapper createVnf(RequestDetails requestDetails, String serviceInstanceId) {
 128         logInvocationInDebug("createVnf");
 129
 130         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
 131
 132         String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 133         return msoClientInterface.createVnf(requestDetails, vnfEndpoint);
 134     }
 135
 136     @Override
 137     public MsoResponseWrapper createNwInstance(RequestDetails requestDetails, String serviceInstanceId) {
 138         logInvocationInDebug("createNwInstance");
 139
 140         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_NETWORK_INSTANCE);
 141
 142         String nw_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 143         return msoClientInterface.createNwInstance(requestDetails, nw_endpoint);
 144     }
 145
 146     @Override
 147     public MsoResponseWrapper createVolumeGroupInstance(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
 148         logInvocationInDebug("createVolumeGroupInstance");
 149
 150         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VOLUME_GROUP_INSTANCE);
 151
 152         String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 153         vnfEndpoint = vnfEndpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
 154
 155         return msoClientInterface.createVolumeGroupInstance(requestDetails, vnfEndpoint);
 156     }
 157
 158     @Override
 159     public MsoResponseWrapper createVfModuleInstance(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
 160         logInvocationInDebug("createVfModuleInstance");
 161
 162         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
 163
 164         String partial_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 165         String vf_module_endpoint = partial_endpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
 166
 167         return msoClientInterface.createVfModuleInstance(requestDetails, vf_module_endpoint);
 168     }
 169
 170     @Override
 171     public MsoResponseWrapper scaleOutVfModuleInstance(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
 172         logInvocationInDebug("scaleOutVfModuleInstance");
 173
 174         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_SCALE_OUT);
 175
 176         String partial_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 177         String vf_module_endpoint = partial_endpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
 178         RequestDetailsWrapper wrapper = new RequestDetailsWrapper();
 179         requestDetails.setVnfName(null);
 180         requestDetails.setVnfInstanceId(null);
 181         wrapper.requestDetails = requestDetails;
 182
 183         return msoClientInterface.scaleOutVFModuleInstance(wrapper, vf_module_endpoint);
 184     }
 185
 186     @Override
 187     public MsoResponseWrapper invokeVnfWorkflow(WorkflowRequestDetail request, String userId, UUID serviceInstanceId, UUID vnfInstanceId, UUID workflow_UUID) {
 188         logInvocationInDebug("invokeVnfWorkflow");
 189
 190         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_WORKFLOW_INSTANCE);
 191
 192         String final_endpoint = endpoint
 193                 .replaceFirst(SVC_INSTANCE_ID, serviceInstanceId.toString())
 194                 .replaceFirst(WORKFLOW_ID, workflow_UUID.toString())
 195                 .replaceFirst(VNF_INSTANCE_ID, vnfInstanceId.toString());
 196
 197         Map<String,String> extraHeaders = new HashMap<>();
 198
 199         UUID requestId = UUID.randomUUID();
 200         extraHeaders.put("X-ONAP-RequestID",requestId.toString());
 201         extraHeaders.put("X-ONAP-PartnerName","VID");
 202         extraHeaders.put("X-RequestorID",userId);
 203
 204         return msoClientInterface.invokeWorkflow(request,final_endpoint,extraHeaders);
 205     }
 206
 207     @Override
 208     public MsoResponseWrapper createConfigurationInstance(org.onap.vid.mso.rest.RequestDetailsWrapper requestDetailsWrapper, String serviceInstanceId) {
 209         logInvocationInDebug("createConfigurationInstance");
 210
 211         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATIONS);
 212         endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
 213
 214         return msoClientInterface.createConfigurationInstance(requestDetailsWrapper, endpoint);
 215     }
 216
 217     @Override
 218     public MsoResponseWrapper deleteE2eSvcInstance(Object requestDetails, String serviceInstanceId) {
 219         logInvocationInDebug("deleteE2eSvcInstance");
 220
 221         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_E2E_SVC_INSTANCE) + "/" + serviceInstanceId;
 222
 223         return msoClientInterface.deleteE2eSvcInstance(requestDetails, endpoint);
 224     }
 225
 226     @Override
 227     public MsoResponseWrapper deleteSvcInstance(RequestDetails requestDetails, String serviceInstanceId, String serviceStatus) {
 228         logInvocationInDebug("deleteSvcInstance");
 229         String endpoint;
 230
 231         if (featureManager.isActive(FLAG_UNASSIGN_SERVICE)) {
 232             endpoint = validateEndpointPath(MsoProperties.MSO_DELETE_OR_UNASSIGN_REST_API_SVC_INSTANCE);
 233             if (shouldUnassignService(serviceStatus)) {
 234                 logger.debug(EELFLoggerDelegate.debugLogger, "unassign service");
 235                 String svc_endpoint = endpoint + "/" + serviceInstanceId + "/unassign";
 236                 return msoClientInterface.unassignSvcInstance(requestDetails, svc_endpoint);
 237             }
 238         } else {
 239             endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_SVC_INSTANCE);
 240         }
 241
 242         String svc_endpoint = endpoint + "/" + serviceInstanceId;
 243         return msoClientInterface.deleteSvcInstance(requestDetails, svc_endpoint);
 244     }
 245
 246     private boolean shouldUnassignService(String serviceStatus) {
 247         return ImmutableList.of("created", "pendingdelete", "pending-delete", "assigned").contains(serviceStatus.toLowerCase());
 248     }
 249
 250     @Override
 251     public MsoResponseWrapper deleteVnf(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
 252         logInvocationInDebug("deleteVnf");
 253
 254         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
 255         String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 256         vnfEndpoint = vnfEndpoint + '/' + vnfInstanceId;
 257
 258         return msoClientInterface.deleteVnf(requestDetails, vnfEndpoint);
 259     }
 260
 261     @Override
 262     public MsoResponseWrapper deleteVfModule(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId, String vfModuleId) {
 263         logInvocationInDebug("deleteVfModule");
 264
 265         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
 266         String vf__modules_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId).replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
 267         String delete_vf_endpoint = vf__modules_endpoint + '/' + vfModuleId;
 268
 269         return msoClientInterface.deleteVfModule(requestDetails, delete_vf_endpoint);
 270     }
 271
 272     @Override
 273     public MsoResponseWrapper deleteVolumeGroupInstance(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId, String volumeGroupId) {
 274         logInvocationInDebug("deleteVolumeGroupInstance");
 275
 276         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VOLUME_GROUP_INSTANCE);
 277         String svc_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 278         String vnfEndpoint = svc_endpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
 279         String delete_volume_group_endpoint = vnfEndpoint + "/" + volumeGroupId;
 280
 281         return msoClientInterface.deleteVolumeGroupInstance(requestDetails, delete_volume_group_endpoint);
 282     }
 283
 284     @Override
 285     public MsoResponseWrapper deleteNwInstance(RequestDetails requestDetails, String serviceInstanceId, String networkInstanceId) {
 286         logInvocationInDebug("deleteNwInstance");
 287
 288         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_NETWORK_INSTANCE);
 289         String svc_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 290         String delete_nw_endpoint = svc_endpoint + "/" + networkInstanceId;
 291
 292         return msoClientInterface.deleteNwInstance(requestDetails, delete_nw_endpoint);
 293     }
 294
 295     @Override
 296     public MsoResponseWrapper getOrchestrationRequest(String requestId) {
 297         String methodName = "getOrchestrationRequest";
 298         logInvocationInDebug(methodName);
 299         try {
 300             String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQ);
 301             String path = p + "/" + requestId;
 302
 303             return msoClientInterface.getOrchestrationRequest(path);
 304
 305         } catch (Exception e) {
 306             logException(methodName, e);
 307             throw e;
 308         }
 309     }
 310
 311     @Override
 312     public MsoResponseWrapper getOrchestrationRequests(String filterString) {
 313         String methodName = "getOrchestrationRequest";
 314         logInvocationInDebug(methodName);
 315         try {
 316             String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQS);
 317             String path = p + filterString;
 318
 319             return msoClientInterface.getOrchestrationRequest(path);
 320
 321         } catch (Exception e) {
 322             logException(methodName, e);
 323             throw e;
 324         }
 325     }
 326
 327     @Override
 328     public List<Request> getOrchestrationRequestsForDashboard() {
 329         String methodName = "getOrchestrationRequestsForDashboard";
 330         logInvocationInDebug(methodName);
 331
 332         List<Request> dashboardOrchestrationReqs = new ArrayList<>();
 333         try {
 334             List<RequestWrapper> vnfOrchestrationReqsWrappers = getOrchestrationRequestsByFilter("modelType", "vnf");
 335             dashboardOrchestrationReqs = vnfOrchestrationReqsWrappers.stream()
 336                     .filter(reqWrapper -> Objects.nonNull(reqWrapper.getRequest())
 337                             && DASHBOARD_ALLOWED_TYPES.contains(upperCase(reqWrapper.getRequest().getRequestType())))
 338                     .map(RequestWrapper::getRequest)
 339                     .collect(Collectors.toList());
 340
 341             List<RequestWrapper> scaleOutOrchestrationReqWrappers = getOrchestrationRequestsByFilter("action", "scaleOut");
 342             List<Request> scaleoutRequests = scaleOutOrchestrationReqWrappers.stream()
 343                     .filter(reqWrapper -> Objects.nonNull(reqWrapper.getRequest()))
 344                     .map(RequestWrapper::getRequest)
 345                     .collect(Collectors.toList());
 346
 347             dashboardOrchestrationReqs.addAll(scaleoutRequests);
 348         } catch (Exception e) {
 349             logException(methodName, e);
 350             throw e;
 351         }
 352         return dashboardOrchestrationReqs;
 353     }
 354
 355     private String constructOrchestrationRequestFilter(String filterName, String filterValue) {
 356         return String.format("%sfilter=%s:EQUALS:%s",
 357                 SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQS), filterName, filterValue);
 358     }
 359
 360     private List<RequestWrapper> getOrchestrationRequestsByFilter(String filterName, String filterValue) {
 361         String orchestrationReqPath = constructOrchestrationRequestFilter(filterName, filterValue);
 362         RestObject<String> restObjStr = new RestObject<>();
 363         String str = new String();
 364         restObjStr.set(str);
 365         MsoResponseWrapper msoResponseWrapper = msoClientInterface.getOrchestrationRequest(str, "", orchestrationReqPath, restObjStr, true);
 366         return deserializeOrchestrationRequestsJson(msoResponseWrapper.getEntity());
 367     }
 368
 369     private List<RequestWrapper> deserializeOrchestrationRequestsJson(String orchestrationRequestsJson) {
 370         logInvocationInDebug("deserializeOrchestrationRequestsJson");
 371
 372         ObjectMapper mapper = new ObjectMapper();
 373         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 374         mapper.configure(DeserializationFeature.READ_ENUMS_USING_TO_STRING, true);
 375         RequestList requestList;
 376         try {
 377             requestList = mapper.readValue(orchestrationRequestsJson, RequestList.class);
 378         } catch (IOException e) {
 379             throw new GenericUncheckedException(e);
 380         }
 381         return requestList.getRequestList();
 382     }
 383
 384
 385     @Override
 386     public List<Task> getManualTasksByRequestId(String originalRequestId) {
 387         String methodName = "getManualTasksByRequestId";
 388         logInvocationInDebug(methodName);
 389
 390         try {
 391             String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_MAN_TASKS);
 392             String path = p + "?originalRequestId=" + originalRequestId;
 393
 394             RestObject<String> restObjStr = new RestObject<>();
 395             String str = new String();
 396             restObjStr.set(str);
 397
 398             MsoResponseWrapper msoResponseWrapper = msoClientInterface.getManualTasksByRequestId(str, "", path, restObjStr);
 399             return deserializeManualTasksJson(msoResponseWrapper.getEntity());
 400
 401         } catch (Exception e) {
 402             logException(methodName, e);
 403             throw e;
 404         }
 405     }
 406
 407         private List<Task> deserializeManualTasksJson(String manualTasksJson) {
 408         logInvocationInDebug("deserializeManualTasksJson");
 409
 410         ObjectMapper mapper = new ObjectMapper();
 411         try {
 412             TaskList taskList = mapper.readValue(manualTasksJson, TaskList.class);
 413             return taskList.getTaskList();
 414         } catch (IOException e) {
 415             throw new GenericUncheckedException(e);
 416         }
 417     }
 418
 419
 420     @Override
 421     public MsoResponseWrapper completeManualTask(RequestDetails requestDetails, String taskId) {
 422         String methodName = "completeManualTask";
 423         logInvocationInDebug(methodName);
 424         try {
 425             String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_MAN_TASKS);
 426             String path = p + "/" + taskId + "/complete";
 427
 428             RestObject<String> restObjStr = new RestObject<>();
 429             String str = new String();
 430             restObjStr.set(str);
 431
 432             return msoClientInterface.completeManualTask(requestDetails, str, "", path, restObjStr);
 433
 434         } catch (Exception e) {
 435             logException(methodName, e);
 436             throw e;
 437         }
 438     }
 439
 440     @Override
 441     public MsoResponseWrapper activateServiceInstance(RequestDetails requestDetails, String serviceInstanceId) {
 442         String methodName = "activateServiceInstance";
 443         logInvocationInDebug(methodName);
 444         try {
 445             String serviceEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_SVC_INSTANCE);
 446             String activateServicePath = serviceEndpoint + "/" + serviceInstanceId + ACTIVATE;
 447
 448             RestObject<String> restObjStr = new RestObject<>();
 449             String str = "";
 450             restObjStr.set(str);
 451
 452             msoClientInterface.setServiceInstanceStatus(requestDetails, str, "", activateServicePath, restObjStr);
 453
 454             return MsoUtil.wrapResponse(restObjStr);
 455
 456         } catch (Exception e) {
 457             logException(methodName, e);
 458             throw e;
 459         }
 460     }
 461
 462
 463     @Override
 464     public MsoResponseWrapperInterface updateVnf(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
 465         logInvocationInDebug("updateVnf");
 466
 467         String endpoint;
 468         endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
 469         String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 470         vnfEndpoint = vnfEndpoint + '/' + vnfInstanceId;
 471         return msoClientInterface.updateVnf(requestDetails, vnfEndpoint);
 472     }
 473
 474     @Override
 475     public MsoResponseWrapperInterface replaceVnf(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
 476         logInvocationInDebug("replaceVnf");
 477
 478         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_CHANGE_MANAGEMENT_INSTANCE);
 479         String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 480         vnfEndpoint = vnfEndpoint.replace(VNF_INSTANCE_ID, vnfInstanceId);
 481         vnfEndpoint = vnfEndpoint.replace(REQUEST_TYPE, MsoChangeManagementRequest.REPLACE);
 482         return msoClientInterface.replaceVnf(requestDetails, vnfEndpoint);
 483     }
 484
 485     public RequestDetailsWrapper generateInPlaceMsoRequest(org.onap.vid.changeManagement.RequestDetails requestDetails) {
 486         validateUpdateVnfSoftwarePayload(requestDetails);
 487         RequestDetails inPlaceSoftwareUpdateRequest = new RequestDetails();
 488         inPlaceSoftwareUpdateRequest.setCloudConfiguration(requestDetails.getCloudConfiguration());
 489         inPlaceSoftwareUpdateRequest.setRequestParameters(requestDetails.getRequestParameters());
 490         inPlaceSoftwareUpdateRequest.setRequestInfo(requestDetails.getRequestInfo());
 491         RequestDetailsWrapper requestDetailsWrapper = new RequestDetailsWrapper();
 492         requestDetailsWrapper.requestDetails = inPlaceSoftwareUpdateRequest;
 493         return requestDetailsWrapper;
 494     }
 495
 496     @Override
 497     public RequestDetailsWrapper generateConfigMsoRequest(org.onap.vid.changeManagement.RequestDetails requestDetails) {
 498         validateUpdateVnfConfig(requestDetails);
 499         RequestDetails configUpdateRequest = new RequestDetails();
 500         configUpdateRequest.setRequestParameters(requestDetails.getRequestParameters());
 501         configUpdateRequest.setRequestInfo(requestDetails.getRequestInfo());
 502         RequestDetailsWrapper requestDetailsWrapper = new RequestDetailsWrapper();
 503         requestDetailsWrapper.requestDetails = configUpdateRequest;
 504         return requestDetailsWrapper;
 505     }
 506
 507     @Override
 508     public String getActivateFabricConfigurationPath(String serviceInstanceId) {
 509         String path = validateEndpointPath(MsoProperties.MSO_REST_API_SERVICE_INSTANCE_CREATE);
 510         path += "/" + serviceInstanceId + ACTIVATE_FABRIC_CONFIGURATION;
 511
 512         return path;
 513     }
 514
 515     @Override
 516     public String getDeactivateAndCloudDeletePath(String serviceInstanceId, String vnfInstanceId, String vfModuleInstanceId) {
 517         String path = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
 518         path = path.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 519         path = path.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
 520         path += "/" + vfModuleInstanceId + DEACTIVATE_AND_CLOUD_DELETE;
 521
 522         return path;
 523     }
 524
 525     @Override
 526     public RequestDetails buildRequestDetailsForSoftDelete(SoftDeleteRequest softDeleteRequest) {
 527         RequestDetails requestDetails = new RequestDetails();
 528         RequestInfo requestInfo = new RequestInfo();
 529         requestInfo.setSource("VID");
 530         requestInfo.setRequestorId(softDeleteRequest.getUserId());
 531         requestDetails.setRequestInfo(requestInfo);
 532
 533         CloudConfiguration cloudConfiguration = new CloudConfiguration();
 534         cloudConfiguration.setTenantId(softDeleteRequest.getTenantId());
 535         cloudConfiguration.setLcpCloudRegionId(softDeleteRequest.getLcpCloudRegionId());
 536         requestDetails.setCloudConfiguration(cloudConfiguration);
 537
 538         ModelInfo modelInfo = new ModelInfo();
 539         modelInfo.setModelType("vfModule");
 540         requestDetails.setModelInfo(modelInfo);
 541
 542         RequestParameters requestParameters = new RequestParameters();
 543         requestParameters.setTestApi("GR_API");
 544         requestDetails.setRequestParameters(requestParameters);
 545
 546         return requestDetails;
 547     }
 548
 549     @Override
 550     public MsoResponseWrapper2 deactivateAndCloudDelete(String serviceInstanceId, String vnfInstanceId, String vfModuleInstanceId, RequestDetails requestDetails) {
 551         String path = getDeactivateAndCloudDeletePath(serviceInstanceId, vnfInstanceId, vfModuleInstanceId);
 552         return new MsoResponseWrapper2<>(msoClientInterface.post(path, new RequestDetailsWrapper<>(requestDetails), RequestReferencesContainer.class));
 553     }
 554
 555     @Override
 556     public MsoResponseWrapper2 activateFabricConfiguration(String serviceInstanceId, RequestDetails requestDetails) {
 557         String path = getActivateFabricConfigurationPath(serviceInstanceId);
 558         return new MsoResponseWrapper2<>(msoClientInterface.post(path, new RequestDetailsWrapper<>(requestDetails), RequestReferencesContainer.class));
 559     }
 560
 561
 562     @Override
 563     public MsoResponseWrapperInterface updateVnfSoftware(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
 564         logInvocationInDebug("updateVnfSoftware");
 565         String vnfEndpoint = getChangeManagementEndpoint(serviceInstanceId, vnfInstanceId, MsoChangeManagementRequest.SOFTWARE_UPDATE); //workflow name in mso is different than workflow name in vid UI
 566         RequestDetailsWrapper finalRequestDetails = generateInPlaceMsoRequest(requestDetails);
 567         return msoClientInterface.changeManagementUpdate(finalRequestDetails, vnfEndpoint);
 568     }
 569
 570     @Override
 571     public MsoResponseWrapperInterface updateVnfConfig(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
 572         logInvocationInDebug("updateVnfConfig");
 573         RequestDetailsWrapper finalRequestDetails = generateConfigMsoRequest(requestDetails);
 574         String vnfEndpoint = getChangeManagementEndpoint(serviceInstanceId, vnfInstanceId, MsoChangeManagementRequest.CONFIG_UPDATE);
 575         return msoClientInterface.changeManagementUpdate(finalRequestDetails, vnfEndpoint);
 576     }
 577
 578     private String getChangeManagementEndpoint(String serviceInstanceId, String vnfInstanceId, String vnfRequestType) {
 579         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_CHANGE_MANAGEMENT_INSTANCE);
 580         String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 581         vnfEndpoint = vnfEndpoint.replace(VNF_INSTANCE_ID, vnfInstanceId);
 582         vnfEndpoint = vnfEndpoint.replace(REQUEST_TYPE, vnfRequestType);
 583         return vnfEndpoint;
 584     }
 585
 586     private Map getChangeManagementPayload(RequestDetails requestDetails, String message) {
 587         if (requestDetails.getRequestParameters() == null || requestDetails.getRequestParameters().getAdditionalProperties() == null) {
 588             throw new BadRequestException(message);
 589         }
 590         Object payloadRaw = requestDetails.getRequestParameters().getAdditionalProperties().get("payload");
 591         try {
 592             return objectMapper.readValue((String) payloadRaw, Map.class);
 593         } catch (Exception exception) {
 594             throw new BadRequestException(message);
 595         }
 596     }
 597
 598     private void validateUpdateVnfSoftwarePayload(RequestDetails requestDetails) {
 599         final String noValidPayloadMsg = "No valid payload in " + ChangeManagementRequest.VNF_IN_PLACE_SOFTWARE_UPDATE + " request";
 600
 601         Map payload = getChangeManagementPayload(requestDetails, noValidPayloadMsg);
 602         validateUpdateVnfSoftwarePayloadProperty(payload, noValidPayloadMsg, "existing_software_version", SOFTWARE_VERSION_PATTERN);
 603         validateUpdateVnfSoftwarePayloadProperty(payload, noValidPayloadMsg, "new_software_version", SOFTWARE_VERSION_PATTERN);
 604
 605         //if "operations_timeout" is not integer, trying to read it as String that represent a number
 606         if (!(payload.get("operations_timeout") instanceof Integer)) {
 607             validateUpdateVnfSoftwarePayloadProperty(payload, noValidPayloadMsg, "operations_timeout", NUMBER_PATTERN);
 608         }
 609     }
 610
 611     private void validateUpdateVnfSoftwarePayloadProperty(Map payload, String noValidPayloadMsg, String propertyName, Pattern pattern) {
 612         Object forValidation = payload.get(propertyName);
 613         final String noValidPayloadPropertyMsg = noValidPayloadMsg + ", " + propertyName + " property is not valid";
 614         if (!(forValidation instanceof String)) {
 615             throw new BadRequestException(noValidPayloadPropertyMsg);
 616         }
 617         if (!pattern.matcher((String) forValidation).matches()) {
 618             throw new BadRequestException(noValidPayloadPropertyMsg);
 619         }
 620     }
 621
 622     @Override
 623     public MsoResponseWrapper deleteConfiguration(org.onap.vid.mso.rest.RequestDetailsWrapper requestDetailsWrapper,
 624                                                   String serviceInstanceId,
 625                                                   String configurationId) {
 626
 627         logInvocationInDebug("deleteConfiguration");
 628         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATION_INSTANCE);
 629         endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
 630         endpoint = endpoint.replace(CONFIGURATION_ID, configurationId);
 631
 632         return msoClientInterface.deleteConfiguration(requestDetailsWrapper, endpoint);
 633     }
 634
 635     @Override
 636     public MsoResponseWrapper setConfigurationActiveStatus(
 637             RequestDetails requestDetails,
 638             String serviceInstanceId,
 639             String configurationId,
 640             boolean isActivate) {
 641
 642         logInvocationInDebug("setConfigurationActiveStatus");
 643
 644         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATION_INSTANCE);
 645         endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
 646         endpoint = endpoint.replace(CONFIGURATION_ID, configurationId);
 647
 648         String isActivateState = (isActivate ? ACTIVATE : DEACTIVATE);
 649         endpoint = endpoint + isActivateState;
 650
 651         return msoClientInterface.setConfigurationActiveStatus(requestDetails, endpoint);
 652     }
 653
 654     @Override
 655     public MsoResponseWrapper setServiceInstanceStatus(RequestDetails requestDetails, String serviceInstanceId, boolean isActivate) {
 656         logInvocationInDebug("setServiceInstanceStatus");
 657         String methodName = "setServiceInstanceStatus";
 658         try {
 659             String serviceEndpoint = validateEndpointPath(MsoProperties.MSO_REST_API_SVC_INSTANCE);
 660             String endpoint = serviceEndpoint + "/" + serviceInstanceId;
 661
 662             String isActivateState = (isActivate ? ACTIVATE : DEACTIVATE);
 663             endpoint = endpoint + isActivateState;
 664
 665
 666             RestObject<String> restObjStr = new RestObject<>();
 667             String str = "";
 668             restObjStr.set(str);
 669
 670             msoClientInterface.setServiceInstanceStatus(requestDetails, str, "", endpoint, restObjStr);
 671
 672             return MsoUtil.wrapResponse(restObjStr);
 673
 674         } catch (Exception e) {
 675             logger.error(EELFLoggerDelegate.errorLogger, methodName + e.toString());
 676             logger.debug(EELFLoggerDelegate.debugLogger, methodName + e.toString());
 677             throw e;
 678         }
 679     }
 680
 681     @Override
 682     public MsoResponseWrapper setPortOnConfigurationStatus(
 683             RequestDetails requestDetails,
 684             String serviceInstanceId,
 685             String configurationId,
 686             boolean isEnable) {
 687         logInvocationInDebug("setPortOnConfigurationStatus");
 688
 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);
 692
 693         String isEnablePortStatus = (isEnable ? ENABLE_PORT : DISABLE_PORT);
 694         endpoint = endpoint + isEnablePortStatus;
 695
 696         return msoClientInterface.setPortOnConfigurationStatus(requestDetails, endpoint);
 697     }
 698
 699
 700     @Override
 701     public RequestDetailsWrapper<RequestDetails> createOperationalEnvironmentActivationRequestDetails(OperationalEnvironmentActivateInfo details) {
 702         RequestDetails requestDetails = new RequestDetails();
 703         RequestInfo requestInfo = new RequestInfo();
 704         requestInfo.setAdditionalProperty(RESOURCE_TYPE, RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT);
 705         requestInfo.setSource(SOURCE_OPERATIONAL_ENVIRONMENT);
 706         requestInfo.setRequestorId(details.getUserId());
 707         requestDetails.setRequestInfo(requestInfo);
 708
 709         RelatedInstance relatedInstance = new RelatedInstance();
 710         relatedInstance.setAdditionalProperty(RESOURCE_TYPE, RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT);
 711         relatedInstance.setInstanceId(details.getRelatedInstanceId());
 712         relatedInstance.setInstanceName(details.getRelatedInstanceName());
 713         requestDetails.setAdditionalProperty("relatedInstanceList", Collections.singletonList(ImmutableMap.of("relatedInstance", relatedInstance)));
 714
 715         RequestParameters requestParameters = new RequestParameters();
 716         requestParameters.setUserParams(null);
 717         requestParameters.setAdditionalProperty("operationalEnvironmentType", "VNF");
 718         requestParameters.setAdditionalProperty("workloadContext", details.getWorkloadContext());
 719         requestParameters.setAdditionalProperty("manifest", details.getManifest());
 720         requestDetails.setRequestParameters(requestParameters);
 721
 722         RequestDetailsWrapper<RequestDetails> requestDetailsWrapper = new RequestDetailsWrapper<>(requestDetails);
 723
 724         debugRequestDetails(requestDetailsWrapper, logger);
 725
 726         return requestDetailsWrapper;
 727     }
 728
 729     @Override
 730     public String getOperationalEnvironmentActivationPath(OperationalEnvironmentActivateInfo details) {
 731         String path = validateEndpointPath(MSO_REST_API_OPERATIONAL_ENVIRONMENT_ACTIVATE);
 732         path = path.replace("<operational_environment_id>", details.getOperationalEnvironmentId());
 733         return path;
 734     }
 735
 736     @Override
 737     public RequestDetailsWrapper<RequestDetails> createOperationalEnvironmentDeactivationRequestDetails(OperationalEnvironmentDeactivateInfo details) {
 738         RequestDetails requestDetails = new RequestDetails();
 739
 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);
 745
 746         RequestParameters requestParameters = new RequestParameters();
 747         requestParameters.setUserParams(null);
 748         requestParameters.setAdditionalProperty("operationalEnvironmentType", "VNF");
 749         requestDetails.setRequestParameters(requestParameters);
 750         RequestDetailsWrapper<RequestDetails> requestDetailsWrapper = new RequestDetailsWrapper<>(requestDetails);
 751         debugRequestDetails(requestDetailsWrapper, logger);
 752         return requestDetailsWrapper;
 753     }
 754
 755     @Override
 756     public String getCloudResourcesRequestsStatusPath(String requestId) {
 757         String path = validateEndpointPath(MSO_REST_API_CLOUD_RESOURCES_REQUEST_STATUS);
 758         path = path.replace("<request_id>", requestId);
 759         return path;
 760     }
 761
 762     @Override
 763     public String getOperationalEnvironmentDeactivationPath(OperationalEnvironmentDeactivateInfo details) {
 764         String path = validateEndpointPath(MSO_REST_API_OPERATIONAL_ENVIRONMENT_DEACTIVATE);
 765         path = path.replace("<operational_environment_id>", details.getOperationalEnvironmentId());
 766         return path;
 767     }
 768
 769     @Override
 770     public String getOperationalEnvironmentCreationPath() {
 771         return validateEndpointPath(MSO_REST_API_OPERATIONAL_ENVIRONMENT_CREATE);
 772     }
 773
 774
 775     @Override
 776     public RequestDetailsWrapper<OperationEnvironmentRequestDetails> convertParametersToRequestDetails(OperationalEnvironmentController.OperationalEnvironmentCreateBody input, String userId) {
 777         OperationEnvironmentRequestDetails.RequestInfo requestInfo = new OperationEnvironmentRequestDetails.RequestInfo(
 778                 RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT,
 779                 input.getInstanceName(),
 780                 SOURCE_OPERATIONAL_ENVIRONMENT,
 781                 userId);
 782
 783         OperationEnvironmentRequestDetails.RelatedInstance relatedInstance = new OperationEnvironmentRequestDetails.RelatedInstance(
 784                 RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT,
 785                 input.getEcompInstanceId(),
 786                 input.getEcompInstanceName());
 787
 788         List<OperationEnvironmentRequestDetails.RelatedInstance> relatedInstanceList = Collections.singletonList((relatedInstance));
 789
 790         OperationEnvironmentRequestDetails.RequestParameters requestParameters = new OperationEnvironmentRequestDetails.RequestParameters(
 791                 input.getOperationalEnvironmentType(),
 792                 input.getTenantContext(),
 793                 input.getWorkloadContext());
 794
 795         OperationEnvironmentRequestDetails requestDetails = new OperationEnvironmentRequestDetails(requestInfo, relatedInstanceList, requestParameters);
 796         RequestDetailsWrapper<OperationEnvironmentRequestDetails> requestDetailsWrapper = new RequestDetailsWrapper<>(requestDetails);
 797         debugRequestDetails(requestDetailsWrapper, logger);
 798         return requestDetailsWrapper;
 799     }
 800
 801     @Override
 802     public MsoResponseWrapper removeRelationshipFromServiceInstance(RequestDetails requestDetails, String serviceInstanceId) {
 803         logInvocationInDebug("removeRelationshipFromServiceInstance");
 804
 805         String serviceEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_SVC_INSTANCE);
 806         String removeRelationshipsPath = serviceEndpoint + "/" + serviceInstanceId + "/removeRelationships";
 807
 808         return msoClientInterface.removeRelationshipFromServiceInstance(requestDetails, removeRelationshipsPath);
 809     }
 810
 811     @Override
 812     public MsoResponseWrapper addRelationshipToServiceInstance(RequestDetails requestDetails, String serviceInstanceId) {
 813         logInvocationInDebug("addRelationshipToServiceInstance");
 814
 815         String serviceEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_SVC_INSTANCE);
 816         String addRelationshipsPath = serviceEndpoint + "/" + serviceInstanceId + "/addRelationships";
 817
 818         return msoClientInterface.addRelationshipToServiceInstance(requestDetails, addRelationshipsPath);
 819     }
 820
 821     private void validateUpdateVnfConfig(RequestDetails requestDetails) {
 822         final String noValidPayloadMsg = "No valid payload in " + ChangeManagementRequest.CONFIG_UPDATE + " request";
 823
 824         Map payload = getChangeManagementPayload(requestDetails, noValidPayloadMsg);
 825         validateConfigUpdateVnfPayloadProperty(payload, noValidPayloadMsg, "request-parameters");
 826         validateConfigUpdateVnfPayloadProperty(payload, noValidPayloadMsg, "configuration-parameters");
 827     }
 828
 829     private void validateConfigUpdateVnfPayloadProperty(Map payload, String noValidPayloadMsg, String propertyName) {
 830         final String noValidPayloadPropertyMsg = noValidPayloadMsg + ", " + propertyName + " property is not valid";
 831         if (!payload.containsKey(propertyName)) {
 832             throw new BadRequestException(noValidPayloadPropertyMsg);
 833         }
 834     }
 835
 836     private void logInvocationInDebug(String methodName) {
 837         logger.debug(EELFLoggerDelegate.debugLogger, methodName + "  start");
 838     }
 839
 840     private void logException(String methodName, Exception e) {
 841         logger.error(EELFLoggerDelegate.errorLogger, methodName + e.toString());
 842         logger.debug(EELFLoggerDelegate.debugLogger, methodName + e.toString());
 843     }
 844
 845     enum RequestType {
 846
 847         CREATE_INSTANCE("createInstance"),
 848         DELETE_INSTANCE("deleteInstance"),
 849         REPLACE_INSTANCE("replaceInstance"),
 850         UPDATE_INSTANCE("updateInstance"),
 851         ACTIVATE_INSTANCE("activateInstance"),
 852         DEACTIVATE_INSTANCE("deactivateInstance"),
 853         APPLY_UPDATED_CONFIG("applyUpdatedConfig"),
 854         IN_PLACE_SOFTWARE_UPDATE("inPlaceSoftwareUpdate"),
 855         SCALE_OUT("scaleOut"),
 856         UNKNOWN("unknown"),
 857         NOT_PROVIDED("not provided");
 858         private final String value;
 859         private static final Map<String, RequestType> CONSTANTS = new HashMap<>();
 860
 861         static {
 862             for (RequestType c : values()) {
 863                 CONSTANTS.put(c.value, c);
 864             }
 865         }
 866
 867         RequestType(String value) {
 868             this.value = value;
 869         }
 870
 871         @JsonCreator
 872         public static RequestType fromValue(String value) {
 873             RequestType constant = CONSTANTS.get(value);
 874             if (constant == null) {
 875                 throw new IllegalArgumentException(value);
 876             } else {
 877                 return constant;
 878             }
 879         }
 880
 881         @JsonValue
 882         @Override
 883         public String toString() {
 884             return this.value;
 885         }
 886     }
 887 }