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