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