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