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

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