catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ComponentInterfaceOperationBusinessLogic.java

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  *  Copyright (C) 2021 Nordix Foundation. All rights reserved.
   6  *  ================================================================================
   7  *  Licensed under the Apache License, Version 2.0 (the "License");
   8  *  you may not use this file except in compliance with the License.
   9  *  You may obtain a copy of the License at
  10  *
  11  *        http://www.apache.org/licenses/LICENSE-2.0
  12  *  Unless required by applicable law or agreed to in writing, software
  13  *  distributed under the License is distributed on an "AS IS" BASIS,
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.zone-instance.component.ts
  15  *  See the License for the specific language governing permissions and
  16  *  limitations under the License.
  17  *
  18  *  SPDX-License-Identifier: Apache-2.0
  19  *  ============LICENSE_END=========================================================
  20  */
  21 package org.openecomp.sdc.be.components.impl;
  22
  23 import fj.data.Either;
  24 import java.util.Arrays;
  25 import java.util.HashMap;
  26 import java.util.List;
  27 import java.util.Map;
  28 import java.util.Optional;
  29 import org.apache.commons.collections.CollectionUtils;
  30 import org.apache.commons.collections.MapUtils;
  31 import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
  32 import org.openecomp.sdc.be.components.validation.ComponentValidations;
  33 import org.openecomp.sdc.be.dao.api.ActionStatus;
  34 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
  35 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
  36 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  37 import org.openecomp.sdc.be.model.Component;
  38 import org.openecomp.sdc.be.model.ComponentInstance;
  39 import org.openecomp.sdc.be.model.ComponentInstanceInterface;
  40 import org.openecomp.sdc.be.model.ComponentParametersView;
  41 import org.openecomp.sdc.be.model.InterfaceDefinition;
  42 import org.openecomp.sdc.be.model.User;
  43 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations;
  44 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation;
  45 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
  46 import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation;
  47 import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
  48 import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
  49 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  50 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
  51 import org.openecomp.sdc.be.user.Role;
  52 import org.openecomp.sdc.common.datastructure.Wrapper;
  53 import org.openecomp.sdc.exception.ResponseFormat;
  54 import org.slf4j.Logger;
  55 import org.slf4j.LoggerFactory;
  56 import org.springframework.beans.factory.annotation.Autowired;
  57
  58 @org.springframework.stereotype.Component("componentInterfaceOperationBusinessLogic")
  59 public class ComponentInterfaceOperationBusinessLogic extends BaseBusinessLogic {
  60
  61     private static final Logger LOGGER = LoggerFactory.getLogger(ComponentInterfaceOperationBusinessLogic.class);
  62     private final ComponentValidations componentValidations;
  63
  64     @Autowired
  65     public ComponentInterfaceOperationBusinessLogic(final IElementOperation elementDao, final IGroupOperation groupOperation,
  66                                                     final IGroupInstanceOperation groupInstanceOperation,
  67                                                     final IGroupTypeOperation groupTypeOperation, final InterfaceOperation interfaceOperation,
  68                                                     final InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
  69                                                     final ArtifactsOperations artifactToscaOperation,
  70                                                     final ComponentValidations componentValidations) {
  71         super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation, interfaceLifecycleTypeOperation,
  72             artifactToscaOperation);
  73         this.componentValidations = componentValidations;
  74     }
  75
  76     public Optional<ComponentInstance> updateComponentInstanceInterfaceOperation(final String componentId, final String componentInstanceId,
  77                                                                                  final InterfaceDefinition interfaceDefinition,
  78                                                                                  final ComponentTypeEnum componentTypeEnum,
  79                                                                                  final Wrapper<ResponseFormat> errorWrapper, final boolean shouldLock)
  80         throws BusinessLogicException {
  81         final Component component = getComponent(componentId);
  82         final Optional<ComponentInstance> componentInstanceOptional = componentValidations.getComponentInstance(component, componentInstanceId);
  83         ResponseFormat responseFormat;
  84         if (componentInstanceOptional.isEmpty()) {
  85             responseFormat = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND);
  86             LOGGER.debug("Failed to found component instance with id {}, error: {}", componentInstanceId, responseFormat);
  87             errorWrapper.setInnerElement(responseFormat);
  88             return Optional.empty();
  89         }
  90         Map<String, List<ComponentInstanceInterface>> componentInstancesInterfaceMap = component.getComponentInstancesInterfaces();
  91         if (MapUtils.isEmpty(componentInstancesInterfaceMap)) {
  92             componentInstancesInterfaceMap = new HashMap<>();
  93             component.setComponentInstancesInterfaces(componentInstancesInterfaceMap);
  94         }
  95         final List<ComponentInstanceInterface> componentInstanceInterfaceList = componentInstancesInterfaceMap.get(componentInstanceId);
  96         if (CollectionUtils.isEmpty(componentInstanceInterfaceList)) {
  97             responseFormat = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND);
  98             LOGGER.debug("Failed to found component instance with id {}, error: {}", componentInstanceId, responseFormat);
  99             errorWrapper.setInnerElement(responseFormat);
 100             return Optional.empty();
 101         }
 102         final Optional<OperationDataDefinition> optionalOperationDataDefinition = interfaceDefinition.getOperations().values().stream().findFirst();
 103         if (optionalOperationDataDefinition.isEmpty()) {
 104             responseFormat = componentsUtils.getResponseFormat(ActionStatus.INTERFACE_OPERATION_NOT_FOUND);
 105             LOGGER.debug("Failed to found interface operation on component instance with id {}, error: {}", componentInstanceId, responseFormat);
 106             errorWrapper.setInnerElement(responseFormat);
 107             return Optional.empty();
 108         }
 109         final OperationDataDefinition updatedOperationDataDefinition = optionalOperationDataDefinition.get();
 110         final Optional<ComponentInstanceInterface> optionalComponentInstanceInterface = componentInstanceInterfaceList.stream().filter(
 111             ci -> ci.getOperations().values().stream().anyMatch(
 112                 operationDataDefinition -> operationDataDefinition.getUniqueId().equalsIgnoreCase(updatedOperationDataDefinition.getUniqueId())))
 113             .findFirst();
 114         if (optionalComponentInstanceInterface.isEmpty()) {
 115             responseFormat = componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT);
 116             LOGGER
 117                 .debug("Failed to found ComponentInstanceInterface on component instance with id {}, error: {}", componentInstanceId, responseFormat);
 118             errorWrapper.setInnerElement(responseFormat);
 119             return Optional.empty();
 120         }
 121         updateOperationDefinitionImplementation(updatedOperationDataDefinition);
 122         optionalComponentInstanceInterface.get().getOperations().replace(updatedOperationDataDefinition.getName(), updatedOperationDataDefinition);
 123         boolean wasLocked = false;
 124         try {
 125             if (shouldLock) {
 126                 lockComponent(componentId, component, "Update Interface Operation on Component instance");
 127                 wasLocked = true;
 128             }
 129             final StorageOperationStatus status = toscaOperationFacade.updateComponentInstanceInterfaces(component, componentInstanceId);
 130             if (status != StorageOperationStatus.OK) {
 131                 janusGraphDao.rollback();
 132                 responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
 133                 LOGGER.error("Exception occurred when updating Component Instance Interfaces {}", responseFormat);
 134                 errorWrapper.setInnerElement(responseFormat);
 135                 return Optional.empty();
 136             }
 137             final ComponentParametersView componentFilter = new ComponentParametersView();
 138             componentFilter.disableAll();
 139             componentFilter.setIgnoreUsers(false);
 140             componentFilter.setIgnoreComponentInstances(false);
 141             componentFilter.setIgnoreInterfaces(false);
 142             componentFilter.setIgnoreComponentInstancesInterfaces(false);
 143             final Either<Component, StorageOperationStatus> operationStatusEither = toscaOperationFacade
 144                 .updateComponentInstanceMetadataOfTopologyTemplate(component, componentFilter);
 145             if (operationStatusEither.isRight()) {
 146                 janusGraphDao.rollback();
 147                 responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
 148                 LOGGER.error("Exception occurred when updating Component Instance Topology template {}", responseFormat);
 149                 errorWrapper.setInnerElement(responseFormat);
 150                 return Optional.empty();
 151             }
 152             janusGraphDao.commit();
 153         } catch (final Exception e) {
 154             janusGraphDao.rollback();
 155             LOGGER.error("Exception occurred when updating Interface Operation on Component Instance: {}", e.getMessage(), e);
 156             responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
 157             errorWrapper.setInnerElement(responseFormat);
 158             throw new BusinessLogicException(responseFormat);
 159         } finally {
 160             if (wasLocked) {
 161                 unlockComponent(component.getUniqueId(), componentTypeEnum);
 162             }
 163         }
 164         return componentInstanceOptional;
 165     }
 166
 167     public User validateUser(final String userId) {
 168         final User user = userValidations.validateUserExists(userId);
 169         userValidations.validateUserRole(user, Arrays.asList(Role.DESIGNER, Role.ADMIN));
 170         return user;
 171     }
 172
 173     private void unlockComponent(final String componentUniqueId, final ComponentTypeEnum componentType) {
 174         graphLockOperation.unlockComponent(componentUniqueId, componentType.getNodeType());
 175     }
 176
 177     private void updateOperationDefinitionImplementation(final OperationDataDefinition updatedOperationDataDefinition) {
 178         final ArtifactDataDefinition artifactInfo = new ArtifactDataDefinition();
 179         artifactInfo.setArtifactName(String.format("'%s'", updatedOperationDataDefinition.getImplementation().getArtifactName()));
 180         updatedOperationDataDefinition.setImplementation(artifactInfo);
 181     }
 182 }