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