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.Set;
  28 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  29 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  30 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  31 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  32 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  33 import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition;
  34 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  35 import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterCapabilityDataDefinition;
  36 import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterPropertyDataDefinition;
  37 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  38 import org.openecomp.sdc.be.datatypes.enums.NodeFilterConstraintType;
  39 import org.openecomp.sdc.be.model.Component;
  40 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  41 import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
  42 import org.openecomp.sdc.common.jsongraph.util.CommonUtility;
  43 import org.openecomp.sdc.common.log.wrappers.Logger;
  44
  45 @org.springframework.stereotype.Component("node-filter-operations")
  46 public class NodeFilterOperation extends BaseOperation {
  47
  48     private static Logger logger = Logger.getLogger(NodeFilterOperation.class);
  49
  50     public Either<Set<String>, StorageOperationStatus> deleteNodeFilters(final Component component, final Set<String> componentInstanceIds) {
  51         final Either<GraphVertex, JanusGraphOperationStatus> getComponentVertex;
  52         final Either<GraphVertex, JanusGraphOperationStatus> getNodeFilterVertex;
  53         StorageOperationStatus status;
  54         getComponentVertex = janusGraphDao.getVertexById(component.getUniqueId(), JsonParseFlagEnum.NoParse);
  55         if (getComponentVertex.isRight()) {
  56             return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getComponentVertex.right().value()));
  57         }
  58         getNodeFilterVertex = janusGraphDao
  59             .getChildVertex(getComponentVertex.left().value(), EdgeLabelEnum.NODE_FILTER_TEMPLATE, JsonParseFlagEnum.NoParse);
  60         if (getNodeFilterVertex.isLeft()) {
  61             status = deleteToscaDataElements(component.getUniqueId(), EdgeLabelEnum.NODE_FILTER_TEMPLATE, new ArrayList<>(componentInstanceIds));
  62             if (status != StorageOperationStatus.OK) {
  63                 return Either.right(status);
  64             }
  65         }
  66         return Either.left(componentInstanceIds);
  67     }
  68
  69     public Either<String, StorageOperationStatus> deleteNodeFilter(final Component component, final String componentInstanceId) {
  70         final Either<Set<String>, StorageOperationStatus> listStorageOperationStatusEither = deleteNodeFilters(component,
  71             ImmutableSet.of(componentInstanceId));
  72         if (listStorageOperationStatusEither.isRight()) {
  73             return Either.right(listStorageOperationStatusEither.right().value());
  74         }
  75         return Either.left(componentInstanceId);
  76     }
  77
  78     public Either<CINodeFilterDataDefinition, StorageOperationStatus> createNodeFilter(final String componentId, final String componentInstanceId) {
  79         CINodeFilterDataDefinition nodeFilterDataDefinition = new CINodeFilterDataDefinition();
  80         return addOrUpdateNodeFilter(false, componentId, componentInstanceId, nodeFilterDataDefinition);
  81     }
  82
  83     public Either<CINodeFilterDataDefinition, StorageOperationStatus> deleteConstraint(final String serviceId, final String componentInstanceId,
  84                                                                                        final CINodeFilterDataDefinition nodeFilterDataDefinition,
  85                                                                                        final int propertyIndex,
  86                                                                                        final NodeFilterConstraintType nodeFilterConstraintType) {
  87         if (NodeFilterConstraintType.PROPERTIES.equals(nodeFilterConstraintType)) {
  88             final ListDataDefinition<RequirementNodeFilterPropertyDataDefinition> properties = nodeFilterDataDefinition.getProperties();
  89             properties.getListToscaDataDefinition().remove(propertyIndex);
  90             nodeFilterDataDefinition.setProperties(properties);
  91         } else if (NodeFilterConstraintType.CAPABILITIES.equals(nodeFilterConstraintType)) {
  92             final ListDataDefinition<RequirementNodeFilterCapabilityDataDefinition> capabilities = nodeFilterDataDefinition.getCapabilities();
  93             capabilities.getListToscaDataDefinition().remove(propertyIndex);
  94             nodeFilterDataDefinition.setCapabilities(capabilities);
  95         }
  96         return addOrUpdateNodeFilter(true, serviceId, componentInstanceId, nodeFilterDataDefinition);
  97     }
  98
  99     public Either<CINodeFilterDataDefinition, StorageOperationStatus> addNewProperty(final String componentId, final String componentInstanceId,
 100                                                                                      final CINodeFilterDataDefinition nodeFilterDataDefinition,
 101                                                                                      final RequirementNodeFilterPropertyDataDefinition requirementNodeFilterPropertyDataDefinition) {
 102         ListDataDefinition<RequirementNodeFilterPropertyDataDefinition> properties = nodeFilterDataDefinition.getProperties();
 103         if (properties == null) {
 104             properties = new ListDataDefinition<>();
 105             nodeFilterDataDefinition.setProperties(properties);
 106         }
 107         properties.getListToscaDataDefinition().add(requirementNodeFilterPropertyDataDefinition);
 108         nodeFilterDataDefinition.setProperties(properties);
 109         return addOrUpdateNodeFilter(true, componentId, componentInstanceId, nodeFilterDataDefinition);
 110     }
 111
 112     public Either<CINodeFilterDataDefinition, StorageOperationStatus> addNewCapabilities(final String componentId, final String componentInstanceId,
 113                                                                                          final CINodeFilterDataDefinition nodeFilterDataDefinition,
 114                                                                                          final RequirementNodeFilterCapabilityDataDefinition requirementNodeFilterCapabilityDataDefinition) {
 115         ListDataDefinition<RequirementNodeFilterCapabilityDataDefinition> capabilities = nodeFilterDataDefinition.getCapabilities();
 116         if (capabilities == null) {
 117             capabilities = new ListDataDefinition<>();
 118             nodeFilterDataDefinition.setCapabilities(capabilities);
 119         }
 120         capabilities.getListToscaDataDefinition().add(requirementNodeFilterCapabilityDataDefinition);
 121         nodeFilterDataDefinition.setCapabilities(capabilities);
 122         return addOrUpdateNodeFilter(true, componentId, componentInstanceId, nodeFilterDataDefinition);
 123     }
 124
 125     public Either<CINodeFilterDataDefinition, StorageOperationStatus> updateProperties(final String componentId, final String componentInstanceId,
 126                                                                                        final CINodeFilterDataDefinition nodeFilterDataDefinition,
 127                                                                                        final List<RequirementNodeFilterPropertyDataDefinition> requirementNodeFilterPropertyDataDefinition) {
 128         final ListDataDefinition<RequirementNodeFilterPropertyDataDefinition> properties = nodeFilterDataDefinition.getProperties();
 129         properties.getListToscaDataDefinition().clear();
 130         properties.getListToscaDataDefinition().addAll(requirementNodeFilterPropertyDataDefinition);
 131         nodeFilterDataDefinition.setProperties(properties);
 132         return addOrUpdateNodeFilter(true, componentId, componentInstanceId, nodeFilterDataDefinition);
 133     }
 134
 135     public Either<CINodeFilterDataDefinition, StorageOperationStatus> updateCapabilities(final String componentId, final String componentInstanceId,
 136                                                                                          final CINodeFilterDataDefinition nodeFilterDataDefinition,
 137                                                                                          final List<RequirementNodeFilterCapabilityDataDefinition> requirementNodeFilterCapabilityDataDefinitions) {
 138         final ListDataDefinition<RequirementNodeFilterCapabilityDataDefinition> capabilities = nodeFilterDataDefinition.getCapabilities();
 139         capabilities.getListToscaDataDefinition().clear();
 140         capabilities.getListToscaDataDefinition().addAll(requirementNodeFilterCapabilityDataDefinitions);
 141         nodeFilterDataDefinition.setCapabilities(capabilities);
 142         return addOrUpdateNodeFilter(true, componentId, componentInstanceId, nodeFilterDataDefinition);
 143     }
 144
 145     public Either<CINodeFilterDataDefinition, StorageOperationStatus> updateNodeFilter(final String serviceId, final String componentInstanceId,
 146                                                                                        final CINodeFilterDataDefinition ciNodeFilterDataDefinition) {
 147         return addOrUpdateNodeFilter(true, serviceId, componentInstanceId, ciNodeFilterDataDefinition);
 148     }
 149
 150     public Either<CINodeFilterDataDefinition, StorageOperationStatus> addNodeFilterData(
 151             final String componentId,
 152             final String componentInstanceId,
 153             final CINodeFilterDataDefinition nodeFilterDataDefinition) {
 154         return addOrUpdateNodeFilter(false, componentId, componentInstanceId, nodeFilterDataDefinition);
 155     }
 156
 157     private Either<CINodeFilterDataDefinition, StorageOperationStatus> addOrUpdateNodeFilter(final boolean isUpdateAction, final String componentId,
 158                                                                                              final String componentInstanceId,
 159                                                                                              final CINodeFilterDataDefinition ciNodeFilterDataDefinition) {
 160         StorageOperationStatus statusRes;
 161         Either<GraphVertex, JanusGraphOperationStatus> getToscaElementRes;
 162         getToscaElementRes = janusGraphDao.getVertexById(componentId, JsonParseFlagEnum.NoParse);
 163         if (getToscaElementRes.isRight()) {
 164             JanusGraphOperationStatus status = getToscaElementRes.right().value();
 165             CommonUtility
 166                 .addRecordToLog(logger, CommonUtility.LogLevelEnum.DEBUG, "Failed to get tosca element {} upon adding the properties. Status is {}. ",
 167                     componentId, status);
 168             statusRes = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status);
 169             return Either.right(statusRes);
 170         }
 171         GraphVertex serviceVertex = getToscaElementRes.left().value();
 172         ciNodeFilterDataDefinition.setID(componentInstanceId);
 173         statusRes = performUpdateToscaAction(isUpdateAction, serviceVertex, ImmutableList.of(ciNodeFilterDataDefinition));
 174         if (!statusRes.equals(StorageOperationStatus.OK)) {
 175             janusGraphDao.rollback();
 176             logger.error(" Failed to perform tosca update for node filter in service {} , component instance {}. status is {}", componentId,
 177                 componentInstanceId, statusRes);
 178             return Either.right(statusRes);
 179         }
 180         janusGraphDao.commit();
 181         return Either.left(ciNodeFilterDataDefinition);
 182     }
 183
 184     private StorageOperationStatus performUpdateToscaAction(final boolean isUpdate, final GraphVertex graphVertex,
 185                                                             final List<CINodeFilterDataDefinition> toscaDataList) {
 186         if (isUpdate) {
 187             return updateToscaDataOfToscaElement(graphVertex, EdgeLabelEnum.NODE_FILTER_TEMPLATE, VertexTypeEnum.NODE_FILTER_TEMPLATE, toscaDataList,
 188                 JsonPresentationFields.UNIQUE_ID);
 189         } else {
 190             return addToscaDataToToscaElement(graphVertex, EdgeLabelEnum.NODE_FILTER_TEMPLATE, VertexTypeEnum.NODE_FILTER_TEMPLATE, toscaDataList,
 191                 JsonPresentationFields.UNIQUE_ID);
 192         }
 193     }
 194 }