gerrit.onap Code Review - sdc.git/blob

   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
  22 package org.openecomp.sdc.be.components.impl;
  23
  24 import fj.data.Either;
  25 import java.util.Arrays;
  26 import java.util.HashMap;
  27 import java.util.List;
  28 import java.util.Map;
  29 import java.util.Optional;
  30 import org.apache.commons.collections.CollectionUtils;
  31 import org.apache.commons.collections.MapUtils;
  32 import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
  33 import org.openecomp.sdc.be.components.validation.ComponentValidations;
  34 import org.openecomp.sdc.be.dao.api.ActionStatus;
  35 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
  36 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
  37 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  38 import org.openecomp.sdc.be.model.Component;
  39 import org.openecomp.sdc.be.model.ComponentInstance;
  40 import org.openecomp.sdc.be.model.ComponentInstanceInterface;
  41 import org.openecomp.sdc.be.model.ComponentParametersView;
  42 import org.openecomp.sdc.be.model.InterfaceDefinition;
  43 import org.openecomp.sdc.be.model.User;
  44 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations;
  45 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation;
  46 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
  47 import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation;
  48 import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
  49 import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
  50 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  51 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
  52 import org.openecomp.sdc.be.user.Role;
  53 import org.openecomp.sdc.common.datastructure.Wrapper;
  54 import org.openecomp.sdc.exception.ResponseFormat;
  55 import org.slf4j.Logger;
  56 import org.slf4j.LoggerFactory;
  57 import org.springframework.beans.factory.annotation.Autowired;
  58
  59 @org.springframework.stereotype.Component("componentInterfaceOperationBusinessLogic")
  60 public class ComponentInterfaceOperationBusinessLogic extends BaseBusinessLogic {
  61
  62     private final ComponentValidations componentValidations;
  63
  64     private static final Logger LOGGER = LoggerFactory.getLogger(ComponentInterfaceOperationBusinessLogic .class);
  65
  66     @Autowired
  67     public ComponentInterfaceOperationBusinessLogic(final IElementOperation elementDao,
  68                                                     final IGroupOperation groupOperation,
  69                                                     final IGroupInstanceOperation groupInstanceOperation,
  70                                                     final IGroupTypeOperation groupTypeOperation,
  71                                                     final InterfaceOperation interfaceOperation,
  72                                                     final InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
  73                                                     final ArtifactsOperations artifactToscaOperation,
  74                                                     final ComponentValidations componentValidations) {
  75         super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation,
  76             interfaceLifecycleTypeOperation, artifactToscaOperation);
  77         this.componentValidations = componentValidations;
  78     }
  79
  80     public Optional<ComponentInstance> updateComponentInstanceInterfaceOperation(final String componentId,
  81                                                                                  final String componentInstanceId,
  82                                                                                  final InterfaceDefinition interfaceDefinition,
  83                                                                                  final ComponentTypeEnum componentTypeEnum,
  84                                                                                  final Wrapper<ResponseFormat> errorWrapper,
  85                                                                                  final boolean shouldLock)
  86         throws BusinessLogicException {
  87
  88         final Component component = getComponent(componentId);
  89         final Optional<ComponentInstance> componentInstanceOptional = componentValidations
  90             .getComponentInstance(component, componentInstanceId);
  91         ResponseFormat responseFormat;
  92         if (componentInstanceOptional.isEmpty()) {
  93             responseFormat = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND);
  94             LOGGER.debug("Failed to found component instance with id {}, error: {}",
  95                 componentInstanceId, responseFormat);
  96             errorWrapper.setInnerElement(responseFormat);
  97             return Optional.empty();
  98         }
  99
 100         Map<String, List<ComponentInstanceInterface>> componentInstancesInterfaceMap = component
 101             .getComponentInstancesInterfaces();
 102         if (MapUtils.isEmpty(componentInstancesInterfaceMap)) {
 103             componentInstancesInterfaceMap = new HashMap<>();
 104             component.setComponentInstancesInterfaces(componentInstancesInterfaceMap);
 105         }
 106         final List<ComponentInstanceInterface> componentInstanceInterfaceList = componentInstancesInterfaceMap
 107             .get(componentInstanceId);
 108
 109         if (CollectionUtils.isEmpty(componentInstanceInterfaceList)) {
 110             responseFormat = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND);
 111             LOGGER.debug("Failed to found component instance with id {}, error: {}",
 112                 componentInstanceId, responseFormat);
 113             errorWrapper.setInnerElement(responseFormat);
 114             return Optional.empty();
 115         }
 116
 117         final Optional<OperationDataDefinition> optionalOperationDataDefinition = interfaceDefinition
 118             .getOperations().values().stream().findFirst();
 119         if (optionalOperationDataDefinition.isEmpty()) {
 120             responseFormat = componentsUtils.getResponseFormat(ActionStatus.INTERFACE_OPERATION_NOT_FOUND);
 121             LOGGER.debug("Failed to found interface operation on component instance with id {}, error: {}",
 122                 componentInstanceId, responseFormat);
 123             errorWrapper.setInnerElement(responseFormat);
 124             return Optional.empty();
 125         }
 126         final OperationDataDefinition updatedOperationDataDefinition = optionalOperationDataDefinition.get();
 127         final Optional<ComponentInstanceInterface> optionalComponentInstanceInterface = componentInstanceInterfaceList
 128             .stream().filter(ci -> ci.getOperations().values().stream().anyMatch(operationDataDefinition ->
 129                 operationDataDefinition.getUniqueId()
 130                     .equalsIgnoreCase(updatedOperationDataDefinition.getUniqueId()))).findFirst();
 131
 132         if (optionalComponentInstanceInterface.isEmpty()) {
 133             responseFormat = componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT);
 134             LOGGER.debug("Failed to found ComponentInstanceInterface on component instance with id {}, error: {}",
 135                 componentInstanceId, responseFormat);
 136             errorWrapper.setInnerElement(responseFormat);
 137             return Optional.empty();
 138         }
 139
 140         updateOperationDefinitionImplementation(updatedOperationDataDefinition);
 141
 142         optionalComponentInstanceInterface.get().getOperations()
 143             .replace(updatedOperationDataDefinition.getName(), updatedOperationDataDefinition);
 144
 145         boolean wasLocked = false;
 146         try {
 147             if (shouldLock) {
 148                 lockComponent(componentId, component, "Update Interface Operation on Component instance");
 149                 wasLocked = true;
 150             }
 151
 152             final StorageOperationStatus status = toscaOperationFacade
 153                 .updateComponentInstanceInterfaces(component, componentInstanceId);
 154
 155             if (status != StorageOperationStatus.OK) {
 156                 janusGraphDao.rollback();
 157                 responseFormat = componentsUtils
 158                     .getResponseFormat(ActionStatus.GENERAL_ERROR);
 159                 LOGGER.error("Exception occurred when updating Component Instance Interfaces {}", responseFormat);
 160                 errorWrapper.setInnerElement(responseFormat);
 161                 return Optional.empty();
 162             }
 163
 164             final ComponentParametersView componentFilter = new ComponentParametersView();
 165             componentFilter.disableAll();
 166             componentFilter.setIgnoreUsers(false);
 167             componentFilter.setIgnoreComponentInstances(false);
 168             componentFilter.setIgnoreInterfaces(false);
 169             componentFilter.setIgnoreComponentInstancesInterfaces(false);
 170
 171             final Either<Component, StorageOperationStatus> operationStatusEither = toscaOperationFacade
 172                 .updateComponentInstanceMetadataOfTopologyTemplate(component, componentFilter);
 173
 174             if (operationStatusEither.isRight()) {
 175                 janusGraphDao.rollback();
 176                 responseFormat = componentsUtils
 177                     .getResponseFormat(ActionStatus.GENERAL_ERROR);
 178                 LOGGER.error("Exception occurred when updating Component Instance Topology template {}", responseFormat);
 179                 errorWrapper.setInnerElement(responseFormat);
 180                 return Optional.empty();
 181             }
 182             janusGraphDao.commit();
 183
 184         } catch (final Exception e) {
 185             janusGraphDao.rollback();
 186             LOGGER.error("Exception occurred when updating Interface Operation on Component Instance: {}",
 187                 e.getMessage(), e);
 188             responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
 189             errorWrapper.setInnerElement(responseFormat);
 190             throw new BusinessLogicException(responseFormat);
 191
 192         } finally {
 193             if (wasLocked) {
 194                 unlockComponent(component.getUniqueId(), componentTypeEnum);
 195             }
 196         }
 197
 198         return componentInstanceOptional;
 199
 200     }
 201
 202     public User validateUser(final String userId) {
 203         final User user = userValidations.validateUserExists(userId);
 204         userValidations
 205             .validateUserRole(user, Arrays.asList(Role.DESIGNER, Role.ADMIN));
 206         return user;
 207     }
 208
 209     private void unlockComponent(final String componentUniqueId,
 210                                  final ComponentTypeEnum componentType) {
 211         graphLockOperation.unlockComponent(componentUniqueId, componentType.getNodeType());
 212     }
 213
 214     private void updateOperationDefinitionImplementation(final OperationDataDefinition updatedOperationDataDefinition) {
 215         final ArtifactDataDefinition artifactInfo = new ArtifactDataDefinition();
 216         artifactInfo.setArtifactName(
 217             String.format("'%s'", updatedOperationDataDefinition.getImplementation().getArtifactName())
 218         );
 219         updatedOperationDataDefinition.setImplementation(artifactInfo);
 220     }
 221 }