catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeFilterOperation.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. 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  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20 package org.openecomp.sdc.be.model.jsonjanusgraph.operations;
  21
  22 import com.google.common.collect.ImmutableList;
  23 import com.google.common.collect.ImmutableSet;
  24 import fj.data.Either;
  25 import java.util.ArrayList;
  26 import java.util.List;
  27 import java.util.Optional;
  28 import java.util.Set;
  29 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  30 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  31 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  32 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  33 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  34 import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition;
  35 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  36 import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterCapabilityDataDefinition;
  37 import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterPropertyDataDefinition;
  38 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  39 import org.openecomp.sdc.be.datatypes.enums.NodeFilterConstraintType;
  40 import org.openecomp.sdc.be.model.Component;
  41 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  42 import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
  43 import org.openecomp.sdc.common.jsongraph.util.CommonUtility;
  44 import org.openecomp.sdc.common.log.wrappers.Logger;
  45
  46 @org.springframework.stereotype.Component("node-filter-operations")
  47 public class NodeFilterOperation extends BaseOperation {
  48
  49     private static Logger logger = Logger.getLogger(NodeFilterOperation.class);
  50
  51     public Either<Set<String>, StorageOperationStatus> deleteNodeFilters(final Component component, final Set<String> componentInstanceIds) {
  52         final Either<GraphVertex, JanusGraphOperationStatus> getComponentVertex;
  53         final Either<GraphVertex, JanusGraphOperationStatus> getNodeFilterVertex;
  54         StorageOperationStatus status;
  55         getComponentVertex = janusGraphDao.getVertexById(component.getUniqueId(), JsonParseFlagEnum.NoParse);
  56         if (getComponentVertex.isRight()) {
  57             return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getComponentVertex.right().value()));
  58         }
  59         getNodeFilterVertex = janusGraphDao
  60             .getChildVertex(getComponentVertex.left().value(), EdgeLabelEnum.NODE_FILTER_TEMPLATE, JsonParseFlagEnum.NoParse);
  61         if (getNodeFilterVertex.isLeft()) {
  62             status = deleteToscaDataElements(component.getUniqueId(), EdgeLabelEnum.NODE_FILTER_TEMPLATE, new ArrayList<>(componentInstanceIds));
  63             if (status != StorageOperationStatus.OK) {
  64                 return Either.right(status);
  65             }
  66         }
  67         return Either.left(componentInstanceIds);
  68     }
  69
  70     public Either<String, StorageOperationStatus> deleteNodeFilter(final Component component, final String componentInstanceId) {
  71         final Either<Set<String>, StorageOperationStatus> listStorageOperationStatusEither = deleteNodeFilters(component,
  72             ImmutableSet.of(componentInstanceId));
  73         if (listStorageOperationStatusEither.isRight()) {
  74             return Either.right(listStorageOperationStatusEither.right().value());
  75         }
  76         return Either.left(componentInstanceId);
  77     }
  78
  79     public Either<CINodeFilterDataDefinition, StorageOperationStatus> createNodeFilter(final String componentId, final String componentInstanceId) {
  80         CINodeFilterDataDefinition nodeFilterDataDefinition = new CINodeFilterDataDefinition();
  81         return addOrUpdateNodeFilter(false, componentId, componentInstanceId, nodeFilterDataDefinition);
  82     }
  83
  84     public Either<CINodeFilterDataDefinition, StorageOperationStatus> deleteConstraint(final String serviceId, final String componentInstanceId,
  85                                                                                        final CINodeFilterDataDefinition nodeFilterDataDefinition,
  86                                                                                        final int propertyIndex,
  87                                                                                        final NodeFilterConstraintType nodeFilterConstraintType) {
  88         if (NodeFilterConstraintType.PROPERTIES.equals(nodeFilterConstraintType)) {
  89             final ListDataDefinition<RequirementNodeFilterPropertyDataDefinition> properties = nodeFilterDataDefinition.getProperties();
  90             properties.getListToscaDataDefinition().remove(propertyIndex);
  91             nodeFilterDataDefinition.setProperties(properties);
  92         } else if (NodeFilterConstraintType.CAPABILITIES.equals(nodeFilterConstraintType)) {
  93             final ListDataDefinition<RequirementNodeFilterCapabilityDataDefinition> capabilities = nodeFilterDataDefinition.getCapabilities();
  94             capabilities.getListToscaDataDefinition().remove(propertyIndex);
  95             nodeFilterDataDefinition.setCapabilities(capabilities);
  96         }
  97         return addOrUpdateNodeFilter(true, serviceId, componentInstanceId, nodeFilterDataDefinition);
  98     }
  99
 100     public Either<CINodeFilterDataDefinition, StorageOperationStatus> addNewProperty(final String componentId, final String componentInstanceId,
 101                                                                                      final CINodeFilterDataDefinition nodeFilterDataDefinition,
 102                                                                                      final RequirementNodeFilterPropertyDataDefinition requirementNodeFilterPropertyDataDefinition) {
 103         ListDataDefinition<RequirementNodeFilterPropertyDataDefinition> properties = nodeFilterDataDefinition.getProperties();
 104         if (properties == null) {
 105             properties = new ListDataDefinition<>();
 106             nodeFilterDataDefinition.setProperties(properties);
 107         }
 108         properties.getListToscaDataDefinition().add(requirementNodeFilterPropertyDataDefinition);
 109         nodeFilterDataDefinition.setProperties(properties);
 110         return addOrUpdateNodeFilter(true, componentId, componentInstanceId, nodeFilterDataDefinition);
 111     }
 112
 113     public Either<CINodeFilterDataDefinition, StorageOperationStatus> addNewCapabilities(final String componentId, final String componentInstanceId,
 114                                                                                          final CINodeFilterDataDefinition nodeFilterDataDefinition,
 115                                                                                          final RequirementNodeFilterCapabilityDataDefinition requirementNodeFilterCapabilityDataDefinition) {
 116         ListDataDefinition<RequirementNodeFilterCapabilityDataDefinition> capabilities = nodeFilterDataDefinition.getCapabilities();
 117         if (capabilities == null) {
 118             capabilities = new ListDataDefinition<>();
 119             nodeFilterDataDefinition.setCapabilities(capabilities);
 120         }
 121
 122         final Optional<RequirementNodeFilterCapabilityDataDefinition> existingCap = capabilities
 123                 .getListToscaDataDefinition().stream()
 124                 .filter(def -> def.getName().equals(requirementNodeFilterCapabilityDataDefinition.getName())).findAny();
 125
 126         if (existingCap.isPresent()) {
 127             final ListDataDefinition<RequirementNodeFilterPropertyDataDefinition> newProperties  = requirementNodeFilterCapabilityDataDefinition.getProperties();
 128             final ListDataDefinition<RequirementNodeFilterPropertyDataDefinition> existingProperties = existingCap.get().getProperties();
 129             newProperties.getListToscaDataDefinition().stream().forEach((prop -> existingProperties.add(prop))) ;
 130         } else {
 131             capabilities.getListToscaDataDefinition().add(requirementNodeFilterCapabilityDataDefinition);
 132         }
 133         nodeFilterDataDefinition.setCapabilities(capabilities);
 134         return addOrUpdateNodeFilter(true, componentId, componentInstanceId, nodeFilterDataDefinition);
 135     }
 136
 137     public Either<CINodeFilterDataDefinition, StorageOperationStatus> updateProperties(final String componentId, final String componentInstanceId,
 138                                                                                        final CINodeFilterDataDefinition nodeFilterDataDefinition,
 139                                                                                        final List<RequirementNodeFilterPropertyDataDefinition> requirementNodeFilterPropertyDataDefinition) {
 140         final ListDataDefinition<RequirementNodeFilterPropertyDataDefinition> properties = nodeFilterDataDefinition.getProperties();
 141         properties.getListToscaDataDefinition().clear();
 142         properties.getListToscaDataDefinition().addAll(requirementNodeFilterPropertyDataDefinition);
 143         nodeFilterDataDefinition.setProperties(properties);
 144         return addOrUpdateNodeFilter(true, componentId, componentInstanceId, nodeFilterDataDefinition);
 145     }
 146
 147     public Either<CINodeFilterDataDefinition, StorageOperationStatus> updateCapabilities(final String componentId, final String componentInstanceId,
 148                                                                                          final CINodeFilterDataDefinition nodeFilterDataDefinition,
 149                                                                                          final List<RequirementNodeFilterCapabilityDataDefinition> requirementNodeFilterCapabilityDataDefinitions) {
 150         final ListDataDefinition<RequirementNodeFilterCapabilityDataDefinition> capabilities = nodeFilterDataDefinition.getCapabilities();
 151         capabilities.getListToscaDataDefinition().clear();
 152         capabilities.getListToscaDataDefinition().addAll(requirementNodeFilterCapabilityDataDefinitions);
 153         nodeFilterDataDefinition.setCapabilities(capabilities);
 154         return addOrUpdateNodeFilter(true, componentId, componentInstanceId, nodeFilterDataDefinition);
 155     }
 156
 157     public Either<CINodeFilterDataDefinition, StorageOperationStatus> updateNodeFilter(final String serviceId, final String componentInstanceId,
 158                                                                                        final CINodeFilterDataDefinition ciNodeFilterDataDefinition) {
 159         return addOrUpdateNodeFilter(true, serviceId, componentInstanceId, ciNodeFilterDataDefinition);
 160     }
 161
 162     public Either<CINodeFilterDataDefinition, StorageOperationStatus> addNodeFilterData(
 163             final String componentId,
 164             final String componentInstanceId,
 165             final CINodeFilterDataDefinition nodeFilterDataDefinition) {
 166         return addOrUpdateNodeFilter(false, componentId, componentInstanceId, nodeFilterDataDefinition);
 167     }
 168
 169     private Either<CINodeFilterDataDefinition, StorageOperationStatus> addOrUpdateNodeFilter(final boolean isUpdateAction, final String componentId,
 170                                                                                              final String componentInstanceId,
 171                                                                                              final CINodeFilterDataDefinition ciNodeFilterDataDefinition) {
 172         StorageOperationStatus statusRes;
 173         Either<GraphVertex, JanusGraphOperationStatus> getToscaElementRes;
 174         getToscaElementRes = janusGraphDao.getVertexById(componentId, JsonParseFlagEnum.NoParse);
 175         if (getToscaElementRes.isRight()) {
 176             JanusGraphOperationStatus status = getToscaElementRes.right().value();
 177             CommonUtility
 178                 .addRecordToLog(logger, CommonUtility.LogLevelEnum.DEBUG, "Failed to get tosca element {} upon adding the properties. Status is {}. ",
 179                     componentId, status);
 180             statusRes = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status);
 181             return Either.right(statusRes);
 182         }
 183         GraphVertex serviceVertex = getToscaElementRes.left().value();
 184         ciNodeFilterDataDefinition.setID(componentInstanceId);
 185         statusRes = performUpdateToscaAction(isUpdateAction, serviceVertex, ImmutableList.of(ciNodeFilterDataDefinition));
 186         if (!statusRes.equals(StorageOperationStatus.OK)) {
 187             janusGraphDao.rollback();
 188             logger.error(" Failed to perform tosca update for node filter in service {} , component instance {}. status is {}", componentId,
 189                 componentInstanceId, statusRes);
 190             return Either.right(statusRes);
 191         }
 192         janusGraphDao.commit();
 193         return Either.left(ciNodeFilterDataDefinition);
 194     }
 195
 196     private StorageOperationStatus performUpdateToscaAction(final boolean isUpdate, final GraphVertex graphVertex,
 197                                                             final List<CINodeFilterDataDefinition> toscaDataList) {
 198         if (isUpdate) {
 199             return updateToscaDataOfToscaElement(graphVertex, EdgeLabelEnum.NODE_FILTER_TEMPLATE, VertexTypeEnum.NODE_FILTER_TEMPLATE, toscaDataList,
 200                 JsonPresentationFields.UNIQUE_ID);
 201         } else {
 202             return addToscaDataToToscaElement(graphVertex, EdgeLabelEnum.NODE_FILTER_TEMPLATE, VertexTypeEnum.NODE_FILTER_TEMPLATE, toscaDataList,
 203                 JsonPresentationFields.UNIQUE_ID);
 204         }
 205     }
 206 }