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

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