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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * VID
   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
  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.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;
  42
  43 import javax.ws.rs.BadRequestException;
  44 import java.io.IOException;
  45 import java.util.*;
  46 import java.util.regex.Pattern;
  47 import java.util.stream.Collectors;
  48 import java.util.stream.Stream;
  49
  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;
  58
  59 public class MsoBusinessLogicImpl implements MsoBusinessLogic {
  60
  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();
  80     /**
  81      * The logger.
  82      */
  83     private static final EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(MsoBusinessLogicImpl.class);
  84     /**
  85      * The Mso REST client
  86      * This should be replaced with mso client factory.
  87      */
  88     private final MsoInterface msoClientInterface;
  89     FeatureManager featureManager;
  90
  91     @Autowired
  92     public MsoBusinessLogicImpl(MsoInterface msoClientInterface, FeatureManager featureManager) {
  93         this.msoClientInterface = msoClientInterface;
  94         this.featureManager = featureManager;
  95     }
  96
  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");
 101         }
 102         return endpoint;
 103     }
 104
 105     // this function should get params from tosca and send them to instance at mso, then return success response.
 106     @Override
 107     public MsoResponseWrapper createSvcInstance(RequestDetails msoRequest) {
 108         logInvocationInDebug("createSvcInstance");
 109
 110         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_SVC_INSTANCE);
 111
 112         return msoClientInterface.createSvcInstance(msoRequest, endpoint);
 113     }
 114
 115     @Override
 116     public MsoResponseWrapper createE2eSvcInstance(Object msoRequest) {
 117         logInvocationInDebug("createE2eSvcInstance");
 118         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_E2E_SVC_INSTANCE);
 119
 120         return msoClientInterface.createE2eSvcInstance(msoRequest, endpoint);
 121     }
 122
 123     @Override
 124     public MsoResponseWrapper createVnf(RequestDetails requestDetails, String serviceInstanceId) {
 125         logInvocationInDebug("createVnf");
 126
 127         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
 128
 129         String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 130         return msoClientInterface.createVnf(requestDetails, vnfEndpoint);
 131     }
 132
 133     @Override
 134     public MsoResponseWrapper createNwInstance(RequestDetails requestDetails, String serviceInstanceId) {
 135         logInvocationInDebug("createNwInstance");
 136
 137         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_NETWORK_INSTANCE);
 138
 139         String nw_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 140         return msoClientInterface.createNwInstance(requestDetails, nw_endpoint);
 141     }
 142
 143     @Override
 144     public MsoResponseWrapper createVolumeGroupInstance(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
 145         logInvocationInDebug("createVolumeGroupInstance");
 146
 147         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VOLUME_GROUP_INSTANCE);
 148
 149         String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 150         vnfEndpoint = vnfEndpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
 151
 152         return msoClientInterface.createVolumeGroupInstance(requestDetails, vnfEndpoint);
 153     }
 154
 155     @Override
 156     public MsoResponseWrapper createVfModuleInstance(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
 157         logInvocationInDebug("createVfModuleInstance");
 158
 159         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
 160
 161         String partial_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 162         String vf_module_endpoint = partial_endpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
 163
 164         return msoClientInterface.createVfModuleInstance(requestDetails, vf_module_endpoint);
 165     }
 166
 167     @Override
 168     public MsoResponseWrapper scaleOutVfModuleInstance(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
 169         logInvocationInDebug("scaleOutVfModuleInstance");
 170
 171         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_SCALE_OUT);
 172
 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;
 179
 180         return msoClientInterface.scaleOutVFModuleInstance(wrapper, vf_module_endpoint);
 181     }
 182
 183     @Override
 184     public MsoResponseWrapper createConfigurationInstance(org.onap.vid.mso.rest.RequestDetailsWrapper requestDetailsWrapper, String serviceInstanceId) {
 185         logInvocationInDebug("createConfigurationInstance");
 186
 187         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATIONS);
 188         endpoint = endpoint.replace(SVC_INSTANCE_ID, serviceInstanceId);
 189
 190         return msoClientInterface.createConfigurationInstance(requestDetailsWrapper, endpoint);
 191     }
 192
 193     @Override
 194     public MsoResponseWrapper deleteE2eSvcInstance(Object requestDetails, String serviceInstanceId) {
 195         logInvocationInDebug("deleteE2eSvcInstance");
 196
 197         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_E2E_SVC_INSTANCE) + "/" + serviceInstanceId;
 198
 199         return msoClientInterface.deleteE2eSvcInstance(requestDetails, endpoint);
 200     }
 201
 202     @Override
 203     public MsoResponseWrapper deleteSvcInstance(RequestDetails requestDetails, String serviceInstanceId, String serviceStatus) {
 204         logInvocationInDebug("deleteSvcInstance");
 205         String endpoint;
 206
 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);
 213             }
 214         } else {
 215             endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_SVC_INSTANCE);
 216         }
 217
 218         String svc_endpoint = endpoint + "/" + serviceInstanceId;
 219         return msoClientInterface.deleteSvcInstance(requestDetails, svc_endpoint);
 220     }
 221
 222     private boolean shouldUnassignService(String serviceStatus) {
 223         return ImmutableList.of("created", "pendingdelete", "pending-delete", "assigned").contains(serviceStatus.toLowerCase());
 224     }
 225
 226     @Override
 227     public MsoResponseWrapper deleteVnf(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
 228         logInvocationInDebug("deleteVnf");
 229
 230         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
 231         String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 232         vnfEndpoint = vnfEndpoint + '/' + vnfInstanceId;
 233
 234         return msoClientInterface.deleteVnf(requestDetails, vnfEndpoint);
 235     }
 236
 237     @Override
 238     public MsoResponseWrapper deleteVfModule(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId, String vfModuleId) {
 239         logInvocationInDebug("deleteVfModule");
 240
 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;
 244
 245         return msoClientInterface.deleteVfModule(requestDetails, delete_vf_endpoint);
 246     }
 247
 248     @Override
 249     public MsoResponseWrapper deleteVolumeGroupInstance(RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId, String volumeGroupId) {
 250         logInvocationInDebug("deleteVolumeGroupInstance");
 251
 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;
 256
 257         return msoClientInterface.deleteVolumeGroupInstance(requestDetails, delete_volume_group_endpoint);
 258     }
 259
 260     @Override
 261     public MsoResponseWrapper deleteNwInstance(RequestDetails requestDetails, String serviceInstanceId, String networkInstanceId) {
 262         logInvocationInDebug("deleteNwInstance");
 263
 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;
 267
 268         return msoClientInterface.deleteNwInstance(requestDetails, delete_nw_endpoint);
 269     }
 270
 271     @Override
 272     public MsoResponseWrapper getOrchestrationRequest(String requestId) {
 273         String methodName = "getOrchestrationRequest";
 274         logInvocationInDebug(methodName);
 275         try {
 276             String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQ);
 277             String path = p + "/" + requestId;
 278
 279             return msoClientInterface.getOrchestrationRequest(path);
 280
 281         } catch (Exception e) {
 282             logException(methodName, e);
 283             throw e;
 284         }
 285     }
 286
 287     @Override
 288     public MsoResponseWrapper getOrchestrationRequests(String filterString) {
 289         String methodName = "getOrchestrationRequest";
 290         logInvocationInDebug(methodName);
 291         try {
 292             String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQS);
 293             String path = p + filterString;
 294
 295             return msoClientInterface.getOrchestrationRequest(path);
 296
 297         } catch (Exception e) {
 298             logException(methodName, e);
 299             throw e;
 300         }
 301     }
 302
 303     @Override
 304     public List<Request> getOrchestrationRequestsForDashboard() {
 305         String methodName = "getOrchestrationRequestsForDashboard";
 306         logInvocationInDebug(methodName);
 307
 308         List<Request> dashboardOrchestrationReqs = new ArrayList<>();
 309         try {
 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());
 316
 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());
 322
 323             dashboardOrchestrationReqs.addAll(scaleoutRequests);
 324         } catch (Exception e) {
 325             logException(methodName, e);
 326         }
 327         return dashboardOrchestrationReqs;
 328     }
 329
 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);
 333     }
 334
 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();
 339         restObjStr.set(str);
 340         MsoResponseWrapper msoResponseWrapper = msoClientInterface.getOrchestrationRequest(str, "", orchestrationReqPath, restObjStr, true);
 341         return deserializeOrchestrationRequestsJson(msoResponseWrapper.getEntity());
 342     }
 343
 344     private List<RequestWrapper> deserializeOrchestrationRequestsJson(String orchestrationRequestsJson) {
 345         logInvocationInDebug("deserializeOrchestrationRequestsJson");
 346
 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;
 351         try {
 352             requestList = mapper.readValue(orchestrationRequestsJson, RequestList.class);
 353         } catch (IOException e) {
 354             throw new GenericUncheckedException(e);
 355         }
 356         return requestList.getRequestList();
 357     }
 358
 359
 360     @Override
 361     public List<Task> getManualTasksByRequestId(String originalRequestId) {
 362         String methodName = "getManualTasksByRequestId";
 363         logInvocationInDebug(methodName);
 364
 365         try {
 366             String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_MAN_TASKS);
 367             String path = p + "?originalRequestId=" + originalRequestId;
 368
 369             RestObject<String> restObjStr = new RestObject<>();
 370             String str = new String();
 371             restObjStr.set(str);
 372
 373             MsoResponseWrapper msoResponseWrapper = msoClientInterface.getManualTasksByRequestId(str, "", path, restObjStr);
 374             return deserializeManualTasksJson(msoResponseWrapper.getEntity());
 375
 376         } catch (Exception e) {
 377             logException(methodName, e);
 378             throw e;
 379         }
 380     }
 381
 382     private List<Task> deserializeManualTasksJson(String manualTasksJson) {
 383         logInvocationInDebug("deserializeManualTasksJson");
 384
 385         ObjectMapper mapper = new ObjectMapper();
 386         try {
 387             TaskList taskList = mapper.readValue(manualTasksJson, TaskList.class);
 388             return taskList.getTaskList();
 389         } catch (IOException e) {
 390             throw new GenericUncheckedException(e);
 391         }
 392     }
 393
 394
 395     @Override
 396     public MsoResponseWrapper completeManualTask(RequestDetails requestDetails, String taskId) {
 397         String methodName = "completeManualTask";
 398         logInvocationInDebug(methodName);
 399         try {
 400             String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_MAN_TASKS);
 401             String path = p + "/" + taskId + "/complete";
 402
 403             RestObject<String> restObjStr = new RestObject<>();
 404             String str = new String();
 405             restObjStr.set(str);
 406
 407             msoClientInterface.completeManualTask(requestDetails, str, "", path, restObjStr);
 408
 409             return MsoUtil.wrapResponse(restObjStr);
 410
 411         } catch (Exception e) {
 412             logException(methodName, e);
 413             throw e;
 414         }
 415     }
 416
 417     @Override
 418     public MsoResponseWrapper activateServiceInstance(RequestDetails requestDetails, String serviceInstanceId) {
 419         String methodName = "activateServiceInstance";
 420         logInvocationInDebug(methodName);
 421         try {
 422             String serviceEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_SVC_INSTANCE);
 423             String activateServicePath = serviceEndpoint + "/" + serviceInstanceId + ACTIVATE;
 424
 425             RestObject<String> restObjStr = new RestObject<>();
 426             String str = "";
 427             restObjStr.set(str);
 428
 429             msoClientInterface.setServiceInstanceStatus(requestDetails, str, "", activateServicePath, restObjStr);
 430
 431             return MsoUtil.wrapResponse(restObjStr);
 432
 433         } catch (Exception e) {
 434             logException(methodName, e);
 435             throw e;
 436         }
 437     }
 438
 439
 440     @Override
 441     public MsoResponseWrapperInterface updateVnf(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
 442         logInvocationInDebug("updateVnf");
 443
 444         String endpoint;
 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);
 449     }
 450
 451     @Override
 452     public MsoResponseWrapperInterface replaceVnf(org.onap.vid.changeManagement.RequestDetails requestDetails, String serviceInstanceId, String vnfInstanceId) {
 453         logInvocationInDebug("replaceVnf");
 454
 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);
 460     }
 461
 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;
 471     }
 472
 473     @Override
 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;
 482     }
 483
 484     @Override
 485     public String getActivateFabricConfigurationPath(String serviceInstanceId) {
 486         String path = validateEndpointPath(MsoProperties.MSO_REST_API_SERVICE_INSTANCE_CREATE);
 487         path += "/" + serviceInstanceId + ACTIVATE_FABRIC_CONFIGURATION;
 488
 489         return path;
 490     }
 491
 492     @Override
 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;
 498
 499         return path;
 500     }
 501
 502     @Override
 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);
 509
 510         CloudConfiguration cloudConfiguration = new CloudConfiguration();
 511         cloudConfiguration.setTenantId(softDeleteRequest.getTenantId());
 512         cloudConfiguration.setLcpCloudRegionId(softDeleteRequest.getLcpCloudRegionId());
 513         requestDetails.setCloudConfiguration(cloudConfiguration);
 514
 515         ModelInfo modelInfo = new ModelInfo();
 516         modelInfo.setModelType("vfModule");
 517         requestDetails.setModelInfo(modelInfo);
 518
 519         RequestParameters requestParameters = new RequestParameters();
 520         requestParameters.setTestApi("GR_API");
 521         requestDetails.setRequestParameters(requestParameters);
 522
 523         return requestDetails;
 524     }
 525
 526     @Override
 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));
 530     }
 531
 532     @Override
 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));
 536     }
 537
 538
 539     @Override
 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);
 545     }
 546
 547     @Override
 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);
 553     }
 554
 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);
 560         return vnfEndpoint;
 561     }
 562
 563     private Map getChangeManagementPayload(RequestDetails requestDetails, String message) {
 564         if (requestDetails.getRequestParameters() == null || requestDetails.getRequestParameters().getAdditionalProperties() == null) {
 565             throw new BadRequestException(message);
 566         }
 567         Object payloadRaw = requestDetails.getRequestParameters().getAdditionalProperties().get("payload");
 568         try {
 569             return objectMapper.readValue((String) payloadRaw, Map.class);
 570         } catch (Exception exception) {
 571             throw new BadRequestException(message);
 572         }
 573     }
 574
 575     private void validateUpdateVnfSoftwarePayload(RequestDetails requestDetails) {
 576         final String noValidPayloadMsg = "No valid payload in " + ChangeManagementRequest.VNF_IN_PLACE_SOFTWARE_UPDATE + " request";
 577
 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);
 581
 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);
 585         }
 586     }
 587
 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);
 593         }
 594         if (!pattern.matcher((String) forValidation).matches()) {
 595             throw new BadRequestException(noValidPayloadPropertyMsg);
 596         }
 597     }
 598
 599     @Override
 600     public MsoResponseWrapper deleteConfiguration(org.onap.vid.mso.rest.RequestDetailsWrapper requestDetailsWrapper,
 601                                                   String serviceInstanceId,
 602                                                   String configurationId) {
 603
 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);
 608
 609         return msoClientInterface.deleteConfiguration(requestDetailsWrapper, endpoint);
 610     }
 611
 612     @Override
 613     public MsoResponseWrapper setConfigurationActiveStatus(
 614             RequestDetails requestDetails,
 615             String serviceInstanceId,
 616             String configurationId,
 617             boolean isActivate) {
 618
 619         logInvocationInDebug("setConfigurationActiveStatus");
 620
 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);
 624
 625         String isActivateState = (isActivate ? ACTIVATE : DEACTIVATE);
 626         endpoint = endpoint + isActivateState;
 627
 628         return msoClientInterface.setConfigurationActiveStatus(requestDetails, endpoint);
 629     }
 630
 631     @Override
 632     public MsoResponseWrapper setServiceInstanceStatus(RequestDetails requestDetails, String serviceInstanceId, boolean isActivate) {
 633         logInvocationInDebug("setServiceInstanceStatus");
 634         String methodName = "setServiceInstanceStatus";
 635         try {
 636             String serviceEndpoint = validateEndpointPath(MsoProperties.MSO_REST_API_SVC_INSTANCE);
 637             String endpoint = serviceEndpoint + "/" + serviceInstanceId;
 638
 639             String isActivateState = (isActivate ? ACTIVATE : DEACTIVATE);
 640             endpoint = endpoint + isActivateState;
 641
 642
 643             RestObject<String> restObjStr = new RestObject<>();
 644             String str = "";
 645             restObjStr.set(str);
 646
 647             msoClientInterface.setServiceInstanceStatus(requestDetails, str, "", endpoint, restObjStr);
 648
 649             return MsoUtil.wrapResponse(restObjStr);
 650
 651         } catch (Exception e) {
 652             logger.error(EELFLoggerDelegate.errorLogger, methodName + e.toString());
 653             logger.debug(EELFLoggerDelegate.debugLogger, methodName + e.toString());
 654             throw e;
 655         }
 656     }
 657
 658     @Override
 659     public MsoResponseWrapper setPortOnConfigurationStatus(
 660             RequestDetails requestDetails,
 661             String serviceInstanceId,
 662             String configurationId,
 663             boolean isEnable) {
 664         logInvocationInDebug("setPortOnConfigurationStatus");
 665
 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);
 669
 670         String isEnablePortStatus = (isEnable ? ENABLE_PORT : DISABLE_PORT);
 671         endpoint = endpoint + isEnablePortStatus;
 672
 673         return msoClientInterface.setPortOnConfigurationStatus(requestDetails, endpoint);
 674     }
 675
 676
 677     @Override
 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);
 685
 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)));
 691
 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);
 698
 699         RequestDetailsWrapper<RequestDetails> requestDetailsWrapper = new RequestDetailsWrapper<>(requestDetails);
 700
 701         debugRequestDetails(requestDetailsWrapper, logger);
 702
 703         return requestDetailsWrapper;
 704     }
 705
 706     @Override
 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());
 710         return path;
 711     }
 712
 713     @Override
 714     public RequestDetailsWrapper<RequestDetails> createOperationalEnvironmentDeactivationRequestDetails(OperationalEnvironmentDeactivateInfo details) {
 715         RequestDetails requestDetails = new RequestDetails();
 716
 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);
 722
 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;
 730     }
 731
 732     @Override
 733     public String getCloudResourcesRequestsStatusPath(String requestId) {
 734         String path = validateEndpointPath(MSO_REST_API_CLOUD_RESOURCES_REQUEST_STATUS);
 735         path = path.replace("<request_id>", requestId);
 736         return path;
 737     }
 738
 739     @Override
 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());
 743         return path;
 744     }
 745
 746     @Override
 747     public String getOperationalEnvironmentCreationPath() {
 748         return validateEndpointPath(MSO_REST_API_OPERATIONAL_ENVIRONMENT_CREATE);
 749     }
 750
 751
 752     @Override
 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,
 758                 userId);
 759
 760         OperationEnvironmentRequestDetails.RelatedInstance relatedInstance = new OperationEnvironmentRequestDetails.RelatedInstance(
 761                 RESOURCE_TYPE_OPERATIONAL_ENVIRONMENT,
 762                 input.getEcompInstanceId(),
 763                 input.getEcompInstanceName());
 764
 765         List<OperationEnvironmentRequestDetails.RelatedInstance> relatedInstanceList = Collections.singletonList((relatedInstance));
 766
 767         OperationEnvironmentRequestDetails.RequestParameters requestParameters = new OperationEnvironmentRequestDetails.RequestParameters(
 768                 input.getOperationalEnvironmentType(),
 769                 input.getTenantContext(),
 770                 input.getWorkloadContext());
 771
 772         OperationEnvironmentRequestDetails requestDetails = new OperationEnvironmentRequestDetails(requestInfo, relatedInstanceList, requestParameters);
 773         RequestDetailsWrapper<OperationEnvironmentRequestDetails> requestDetailsWrapper = new RequestDetailsWrapper<>(requestDetails);
 774         debugRequestDetails(requestDetailsWrapper, logger);
 775         return requestDetailsWrapper;
 776     }
 777
 778     @Override
 779     public MsoResponseWrapper removeRelationshipFromServiceInstance(RequestDetails requestDetails, String serviceInstanceId) {
 780         logInvocationInDebug("removeRelationshipFromServiceInstance");
 781
 782         String serviceEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_SVC_INSTANCE);
 783         String removeRelationshipsPath = serviceEndpoint + "/" + serviceInstanceId + "/removeRelationships";
 784
 785         return msoClientInterface.removeRelationshipFromServiceInstance(requestDetails, removeRelationshipsPath);
 786     }
 787
 788     @Override
 789     public MsoResponseWrapper addRelationshipToServiceInstance(RequestDetails requestDetails, String serviceInstanceId) {
 790         logInvocationInDebug("addRelationshipToServiceInstance");
 791
 792         String serviceEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_SVC_INSTANCE);
 793         String addRelationshipsPath = serviceEndpoint + "/" + serviceInstanceId + "/addRelationships";
 794
 795         return msoClientInterface.addRelationshipToServiceInstance(requestDetails, addRelationshipsPath);
 796     }
 797
 798     private void validateUpdateVnfConfig(RequestDetails requestDetails) {
 799         final String noValidPayloadMsg = "No valid payload in " + ChangeManagementRequest.CONFIG_UPDATE + " request";
 800
 801         Map payload = getChangeManagementPayload(requestDetails, noValidPayloadMsg);
 802         validateConfigUpdateVnfPayloadProperty(payload, noValidPayloadMsg, "request-parameters");
 803         validateConfigUpdateVnfPayloadProperty(payload, noValidPayloadMsg, "configuration-parameters");
 804     }
 805
 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);
 810         }
 811     }
 812
 813     private void logInvocationInDebug(String methodName) {
 814         logger.debug(EELFLoggerDelegate.debugLogger, methodName + "  start");
 815     }
 816
 817     private void logException(String methodName, Exception e) {
 818         logger.error(EELFLoggerDelegate.errorLogger, methodName + e.toString());
 819         logger.debug(EELFLoggerDelegate.debugLogger, methodName + e.toString());
 820     }
 821
 822     enum RequestType {
 823
 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"),
 833         UNKNOWN("unknown"),
 834         NOT_PROVIDED("not provided");
 835         private final String value;
 836         private static final Map<String, RequestType> CONSTANTS = new HashMap<>();
 837
 838         static {
 839             for (RequestType c : values()) {
 840                 CONSTANTS.put(c.value, c);
 841             }
 842         }
 843
 844         RequestType(String value) {
 845             this.value = value;
 846         }
 847
 848         @JsonCreator
 849         public static RequestType fromValue(String value) {
 850             RequestType constant = CONSTANTS.get(value);
 851             if (constant == null) {
 852                 throw new IllegalArgumentException(value);
 853             } else {
 854                 return constant;
 855             }
 856         }
 857
 858         @JsonValue
 859         @Override
 860         public String toString() {
 861             return this.value;
 862         }
 863     }
 864 }