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
  21 package org.openecomp.sdc.be.model.jsonjanusgraph.operations;
  22
  23 import com.google.common.collect.ImmutableList;
  24 import com.google.common.collect.ImmutableSet;
  25 import fj.data.Either;
  26 import java.util.ArrayList;
  27 import java.util.List;
  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,
  52                                                                          final Set<String> componentInstanceIds) {
  53         final Either<GraphVertex, JanusGraphOperationStatus> getComponentVertex;
  54         final Either<GraphVertex, JanusGraphOperationStatus> getNodeFilterVertex;
  55         StorageOperationStatus status;
  56
  57         getComponentVertex = janusGraphDao.getVertexById(component.getUniqueId(), JsonParseFlagEnum.NoParse);
  58         if (getComponentVertex.isRight()) {
  59             return Either.right(
  60                     DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getComponentVertex.right().value()));
  61         }
  62         getNodeFilterVertex = janusGraphDao.getChildVertex(getComponentVertex.left().value(),
  63             EdgeLabelEnum.NODE_FILTER_TEMPLATE, JsonParseFlagEnum.NoParse);
  64         if (getNodeFilterVertex.isLeft()) {
  65             status = deleteToscaDataElements(component.getUniqueId(), EdgeLabelEnum.NODE_FILTER_TEMPLATE,
  66                     new ArrayList<>(componentInstanceIds));
  67             if (status != StorageOperationStatus.OK) {
  68                 return Either.right(status);
  69             }
  70         }
  71
  72         return Either.left(componentInstanceIds);
  73     }
  74
  75
  76     public Either<String, StorageOperationStatus> deleteNodeFilter(final Component component,
  77                                                                    final String componentInstanceId) {
  78         final Either<Set<String>, StorageOperationStatus> listStorageOperationStatusEither =
  79                 deleteNodeFilters(component, ImmutableSet.of(componentInstanceId));
  80         if (listStorageOperationStatusEither.isRight()) {
  81             return Either.right(listStorageOperationStatusEither.right().value());
  82         }
  83         return Either.left(componentInstanceId);
  84     }
  85
  86
  87     public Either<CINodeFilterDataDefinition, StorageOperationStatus> createNodeFilter(final String componentId,
  88                                                                                        final String componentInstanceId) {
  89         CINodeFilterDataDefinition nodeFilterDataDefinition = new CINodeFilterDataDefinition();
  90         return addOrUpdateNodeFilter(false, componentId, componentInstanceId, nodeFilterDataDefinition);
  91     }
  92
  93     public Either<CINodeFilterDataDefinition, StorageOperationStatus> deleteConstraint(final String serviceId,
  94                                                                                        final String componentInstanceId,
  95                                                                                        final CINodeFilterDataDefinition nodeFilterDataDefinition,
  96                                                                                        final int propertyIndex,
  97                                                                                        final NodeFilterConstraintType nodeFilterConstraintType) {
  98
  99         if (NodeFilterConstraintType.PROPERTIES.equals(nodeFilterConstraintType)) {
 100             final ListDataDefinition<RequirementNodeFilterPropertyDataDefinition> properties =
 101                 nodeFilterDataDefinition.getProperties();
 102             properties.getListToscaDataDefinition().remove(propertyIndex);
 103             nodeFilterDataDefinition.setProperties(properties);
 104         } else if (NodeFilterConstraintType.CAPABILITIES.equals(nodeFilterConstraintType)) {
 105             final ListDataDefinition<RequirementNodeFilterCapabilityDataDefinition> capabilities =
 106                 nodeFilterDataDefinition.getCapabilities();
 107             capabilities.getListToscaDataDefinition().remove(propertyIndex);
 108             nodeFilterDataDefinition.setCapabilities(capabilities);
 109         }
 110         return addOrUpdateNodeFilter(true, serviceId, componentInstanceId, nodeFilterDataDefinition);
 111     }
 112
 113     public Either<CINodeFilterDataDefinition, StorageOperationStatus> addNewProperty(
 114         final String componentId, final String componentInstanceId,
 115         final CINodeFilterDataDefinition nodeFilterDataDefinition,
 116         final RequirementNodeFilterPropertyDataDefinition requirementNodeFilterPropertyDataDefinition) {
 117
 118         ListDataDefinition<RequirementNodeFilterPropertyDataDefinition> properties =
 119             nodeFilterDataDefinition.getProperties();
 120         if (properties == null) {
 121             properties = new ListDataDefinition<>();
 122             nodeFilterDataDefinition.setProperties(properties);
 123         }
 124         properties.getListToscaDataDefinition().add(requirementNodeFilterPropertyDataDefinition);
 125         nodeFilterDataDefinition.setProperties(properties);
 126         return addOrUpdateNodeFilter(true, componentId, componentInstanceId, nodeFilterDataDefinition);
 127     }
 128
 129     public Either<CINodeFilterDataDefinition, StorageOperationStatus> addNewCapabilities(
 130         final String componentId, final String componentInstanceId,
 131         final CINodeFilterDataDefinition nodeFilterDataDefinition,
 132         final RequirementNodeFilterCapabilityDataDefinition requirementNodeFilterCapabilityDataDefinition) {
 133
 134         ListDataDefinition<RequirementNodeFilterCapabilityDataDefinition> capabilities =
 135             nodeFilterDataDefinition.getCapabilities();
 136         if(capabilities == null) {
 137             capabilities = new ListDataDefinition<>();
 138             nodeFilterDataDefinition.setCapabilities(capabilities);
 139         }
 140         capabilities.getListToscaDataDefinition().add(requirementNodeFilterCapabilityDataDefinition);
 141         nodeFilterDataDefinition.setCapabilities(capabilities);
 142         return addOrUpdateNodeFilter(true, componentId, componentInstanceId, nodeFilterDataDefinition);
 143     }
 144
 145     public Either<CINodeFilterDataDefinition, StorageOperationStatus> updateProperties(
 146         final String serviceId, final String componentInstanceId,
 147         final CINodeFilterDataDefinition nodeFilterDataDefinition,
 148         final List<RequirementNodeFilterPropertyDataDefinition> requirementNodeFilterPropertyDataDefinition) {
 149
 150         ListDataDefinition<RequirementNodeFilterPropertyDataDefinition> properties =
 151                 nodeFilterDataDefinition.getProperties();
 152         properties.getListToscaDataDefinition().clear();
 153         properties.getListToscaDataDefinition().addAll(requirementNodeFilterPropertyDataDefinition);
 154         nodeFilterDataDefinition.setProperties(properties);
 155         return addOrUpdateNodeFilter(true, serviceId, componentInstanceId, nodeFilterDataDefinition);
 156     }
 157
 158     public Either<CINodeFilterDataDefinition, StorageOperationStatus> updateNodeFilter(final String serviceId,
 159                                                                                        final String componentInstanceId,
 160                                                                                        final CINodeFilterDataDefinition ciNodeFilterDataDefinition) {
 161         return addOrUpdateNodeFilter(true, serviceId, componentInstanceId, ciNodeFilterDataDefinition);
 162     }
 163
 164     private Either<CINodeFilterDataDefinition, StorageOperationStatus> addOrUpdateNodeFilter(
 165         final boolean isUpdateAction, final String componentId, final String componentInstanceId,
 166         final CINodeFilterDataDefinition ciNodeFilterDataDefinition) {
 167
 168         StorageOperationStatus statusRes;
 169         Either<GraphVertex, JanusGraphOperationStatus> getToscaElementRes;
 170
 171         getToscaElementRes = janusGraphDao.getVertexById(componentId, JsonParseFlagEnum.NoParse);
 172         if (getToscaElementRes.isRight()) {
 173             JanusGraphOperationStatus status = getToscaElementRes.right().value();
 174             CommonUtility.addRecordToLog(logger, CommonUtility.LogLevelEnum.DEBUG,
 175                     "Failed to get tosca element {} upon adding the properties. Status is {}. ", componentId, status);
 176             statusRes = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status);
 177             return Either.right(statusRes);
 178         }
 179         GraphVertex serviceVertex = getToscaElementRes.left().value();
 180         ciNodeFilterDataDefinition.setID(componentInstanceId);
 181         statusRes = performUpdateToscaAction(isUpdateAction, serviceVertex, ImmutableList.of(ciNodeFilterDataDefinition));
 182         if (!statusRes.equals(StorageOperationStatus.OK)) {
 183             janusGraphDao.rollback();
 184             logger.error(
 185                     " Failed to perform tosca update for node filter in service {} , component instance {}. status is {}",
 186                     componentId, componentInstanceId, statusRes);
 187             return Either.right(statusRes);
 188         }
 189         janusGraphDao.commit();
 190         return Either.left(ciNodeFilterDataDefinition);
 191     }
 192
 193     private StorageOperationStatus performUpdateToscaAction(final boolean isUpdate,
 194                                                             final GraphVertex graphVertex,
 195                                                             final List<CINodeFilterDataDefinition> toscaDataList) {
 196         if (isUpdate) {
 197             return updateToscaDataOfToscaElement(graphVertex, EdgeLabelEnum.NODE_FILTER_TEMPLATE,
 198                 VertexTypeEnum.NODE_FILTER_TEMPLATE, toscaDataList, JsonPresentationFields.UNIQUE_ID);
 199         } else {
 200             return addToscaDataToToscaElement(graphVertex, EdgeLabelEnum.NODE_FILTER_TEMPLATE,
 201                 VertexTypeEnum.NODE_FILTER_TEMPLATE, toscaDataList, JsonPresentationFields.UNIQUE_ID);
 202         }
 203     }
 204
 205 }
 206
 207
 208