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