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

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