aai-core/src/main/java/org/openecomp/aai/serialization/db/EdgeRules.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * org.openecomp.aai
   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.aai.serialization.db;
  22
  23 import java.util.Collection;
  24 import java.util.HashMap;
  25 import java.util.Iterator;
  26 import java.util.List;
  27 import java.util.Map;
  28
  29 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
  30 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
  31 import org.apache.tinkerpop.gremlin.structure.Direction;
  32 import org.apache.tinkerpop.gremlin.structure.Edge;
  33 import org.apache.tinkerpop.gremlin.structure.Vertex;
  34
  35 import org.openecomp.aai.db.props.AAIProperties;
  36 import org.openecomp.aai.dbmodel.DbEdgeRules;
  37 import org.openecomp.aai.exceptions.AAIException;
  38 import org.openecomp.aai.serialization.db.exceptions.NoEdgeRuleFoundException;
  39 import com.google.common.collect.ArrayListMultimap;
  40 import com.google.common.collect.Multimap;
  41
  42 public class EdgeRules {
  43
  44         private Multimap<String, String> rules = DbEdgeRules.EdgeRules;
  45         private Multimap<String, String> deleteScope =  DbEdgeRules.DefaultDeleteScope;
  46         private final int EDGE_NAME = 0;
  47         private final int DIRECTION = 1;
  48         private final int MULTIPLICITY_RULE = 2;
  49         private final int IS_PARENT = 3;
  50         private final int USES_RESOURCE = 4;
  51         private final int HAS_DEL_TARGET = 5;
  52         private final int SVC_INFRA = 6;
  53
  54         /**
  55          * Instantiates a new edge rules.
  56          */
  57         private EdgeRules() {
  58
  59         }
  60         private static class Helper {
  61                 private static final EdgeRules INSTANCE = new EdgeRules();
  62
  63         }
  64
  65         /**
  66          * Gets the single instance of EdgeRules.
  67          *
  68          * @return single instance of EdgeRules
  69          */
  70         public static EdgeRules getInstance() {
  71                 return Helper.INSTANCE;
  72
  73         }
  74
  75         /**
  76          * Adds the tree edge.
  77          *
  78          * @param aVertex the out vertex
  79          * @param bVertex the in vertex
  80          * @return the edge
  81          * @throws AAIException the AAI exception
  82          * @throws NoEdgeRuleFoundException
  83          */
  84         public Edge addTreeEdge(GraphTraversalSource traversalSource, Vertex aVertex, Vertex bVertex) throws AAIException {
  85                 return this.addEdge(EdgeType.TREE, traversalSource, aVertex, bVertex);
  86         }
  87
  88         /**
  89          * Adds the edge.
  90          *
  91          * @param aVertex the out vertex
  92          * @param bVertex the in vertex
  93          * @return the edge
  94          * @throws AAIException the AAI exception
  95          * @throws NoEdgeRuleFoundException
  96          */
  97         public Edge addEdge(GraphTraversalSource traversalSource, Vertex aVertex, Vertex bVertex) throws AAIException {
  98                 return this.addEdge(EdgeType.COUSIN, traversalSource, aVertex, bVertex);
  99         }
 100
 101         /**
 102          * Adds the edge.
 103          *
 104          * @param type the type
 105          * @param aVertex the out vertex
 106          * @param bVertex the in vertex
 107          * @return the edge
 108          * @throws AAIException the AAI exception
 109          * @throws NoEdgeRuleFoundException
 110          */
 111         private Edge addEdge(EdgeType type, GraphTraversalSource traversalSource, Vertex aVertex, Vertex bVertex) throws AAIException, NoEdgeRuleFoundException {
 112
 113                 EdgeRule rule = this.getEdgeRule(type, aVertex, bVertex);
 114
 115                 Edge e = null;
 116                 if (this.validateMultiplicity(rule, traversalSource, aVertex, bVertex)) {
 117                         if (rule.getDirection().equals(Direction.OUT)) {
 118                                 e = aVertex.addEdge(rule.getLabel(), bVertex);
 119                         } else if (rule.getDirection().equals(Direction.IN)) {
 120                                 e = bVertex.addEdge(rule.getLabel(), aVertex);
 121                         }
 122
 123                         this.addProperties(e, rule);
 124                 }
 125                 return e;
 126         }
 127
 128         /**
 129          * Adds the properties.
 130          *
 131          * @param edge the edge
 132          * @param rule the rule
 133          */
 134         public void addProperties(Edge edge, EdgeRule rule) {
 135
 136                 // In DbEdgeRules.EdgeRules -- What we have as "edgeRule" is a comma-delimited set of strings.
 137                 // The first item is the edgeLabel.
 138                 // The second in the list is always "direction" which is always OUT for the way we've implemented it.
 139                 // Items starting at "firstTagIndex" and up are all assumed to be booleans that map according to
 140                 // tags as defined in EdgeInfoMap.
 141                 // Note - if they are tagged as 'reverse', that means they get the tag name with "-REV" on it
 142                 Map<String, String> propMap = rule.getEdgeProperties();
 143
 144                 for (String key : propMap.keySet()) {
 145                         String revKeyname = key + "-REV";
 146                         String triple = propMap.get(key);
 147                         if(triple.equals("true")){
 148                                 edge.property(key, true);
 149                                 edge.property(revKeyname,false);
 150                         } else if (triple.equals("false")) {
 151                                 edge.property(key, false);
 152                                 edge.property(revKeyname,false);
 153                         } else if (triple.equals("reverse")) {
 154                                 edge.property(key, false);
 155                                 edge.property(revKeyname,true);
 156                         }
 157                 }
 158         }
 159
 160         /**
 161          * Checks for edge rule.
 162          *
 163          * @param outType the out type
 164          * @param inType the in type
 165          * @return true, if successful
 166          */
 167         public boolean hasEdgeRule(String outType, String inType) {
 168
 169                 Collection<String> collection = rules.get(outType + "|" + inType);
 170
 171                 return !collection.isEmpty();
 172
 173         }
 174
 175         /**
 176          * Checks for edge rule.
 177          *
 178          * @param aVertex the out vertex
 179          * @param bVertex the in vertex
 180          * @return true, if successful
 181          */
 182         public boolean hasEdgeRule(Vertex aVertex, Vertex bVertex) {
 183                 String outType = (String)aVertex.<String>property("aai-node-type").orElse(null);
 184                 String inType = (String)bVertex.<String>property("aai-node-type").orElse(null);
 185
 186                 return this.hasEdgeRule(outType, inType);
 187
 188         }
 189
 190         public Map<String, EdgeRule> getEdgeRules(String outType, String inType) throws AAIException {
 191                 Map<String, EdgeRule> result = new HashMap<>();
 192                 EdgeRule rule = null;
 193                 for (EdgeType type : EdgeType.values()) {
 194                         try {
 195                                 rule = this.getEdgeRule(type, outType, inType);
 196                                 result.put(rule.getLabel(), rule);
 197                         } catch (NoEdgeRuleFoundException e) {
 198                                 continue;
 199                         }
 200                 }
 201
 202                 return result;
 203         }
 204         /**
 205          * Gets the edge rule.
 206          *
 207          * @param outType the out type
 208          * @param inType the in type
 209          * @return the edge rule
 210          * @throws AAIException the AAI exception
 211          */
 212         public EdgeRule getEdgeRule(EdgeType type, String outType, String inType) throws AAIException {
 213                 EdgeRule rule = new EdgeRule();
 214                 Collection<String> collection = null;
 215                 boolean isFlipped = false;
 216                 if (this.hasEdgeRule(outType, inType) || this.hasEdgeRule(inType, outType)) {
 217                 } else {
 218                         String detail = "No EdgeRule found for passed nodeTypes: " + outType + ", " + inType + ".";
 219                         throw new AAIException("AAI_6120", detail);
 220                 }
 221                 String key = outType + "|" + inType;
 222                 collection = rules.get(key);
 223
 224                 String[] info = null;
 225                 Iterator<String> iterator = collection.iterator();
 226                 info = this.findRuleForContext(type, key, iterator);
 227                 if (info == null) { //didn't find anything in that order, look again
 228                         key = inType + "|" + outType;
 229                         collection = rules.get(key);
 230                         iterator = collection.iterator();
 231                         info = this.findRuleForContext(type, key, iterator);
 232                         isFlipped = true;
 233                 }
 234                 if (info == null) {
 235                         throw new NoEdgeRuleFoundException("No EdgeRule found for EdgeType: " + type + " and node types: " + outType + " " + inType);
 236                 }
 237                 rule.setLabel(info[this.EDGE_NAME]);
 238                 rule.setMultiplicityRule(MultiplicityRule.valueOf(info[this.MULTIPLICITY_RULE].toUpperCase()));
 239                 rule.setHasDelTarget(info[this.HAS_DEL_TARGET]);
 240                 rule.setUsesResource(info[this.USES_RESOURCE]);
 241                 rule.setIsParent(info[this.IS_PARENT]);
 242                 rule.setServiceInfrastructure(info[this.SVC_INFRA]);
 243                 Direction direction = Direction.valueOf(info[this.DIRECTION]);
 244                 if (isFlipped && direction.equals(Direction.OUT)) {
 245                         rule.setDirection(Direction.IN);
 246                 } else if (isFlipped && direction.equals(Direction.IN)){
 247                         rule.setDirection(Direction.OUT);
 248                 } else {
 249                         rule.setDirection(direction);
 250                 }
 251
 252                 return rule;
 253         }
 254
 255         private String[] findRuleForContext (EdgeType type, String key, Iterator<String> itr) {
 256                 String[] result = null;
 257                 String s = "";
 258                 String isParent = "";
 259                 String[] info = new String[10];
 260                 while (itr.hasNext()) {
 261                         s = itr.next();
 262                         info = s.split(",");
 263                         isParent = info[this.IS_PARENT];
 264                         //lazily stop iterating if we find a match
 265                         //should there be a mismatch between type and isParent,
 266                         //the caller will receive something.
 267                         //this operates on the assumption that there are at most two rules
 268                         //for a given vertex pair
 269                         if (type.equals(EdgeType.TREE) && (isParent.equals("true") || isParent.equals("reverse"))) {
 270                                 result = info;
 271                                 break;
 272                         } else if (type.equals(EdgeType.COUSIN) && isParent.equals("false")) {
 273                                 result = info;
 274                                 break;
 275                         }
 276                 }
 277
 278
 279                 return result;
 280         }
 281         /**
 282          * Gets the edge rule.
 283          *
 284          * @param aVertex the out vertex
 285          * @param bVertex the in vertex
 286          * @return the edge rule
 287          * @throws AAIException the AAI exception
 288          * @throws NoEdgeRuleFoundException
 289          */
 290         public EdgeRule getEdgeRule(EdgeType type, Vertex aVertex, Vertex bVertex) throws AAIException, NoEdgeRuleFoundException {
 291                 String outType = (String)aVertex.<String>property(AAIProperties.NODE_TYPE).orElse(null);
 292                 String inType = (String)bVertex.<String>property(AAIProperties.NODE_TYPE).orElse(null);
 293
 294                 return this.getEdgeRule(type, outType, inType);
 295
 296
 297         }
 298
 299         /**
 300          * Gets the delete semantic.
 301          *
 302          * @param nodeType the node type
 303          * @return the delete semantic
 304          */
 305         public DeleteSemantic getDeleteSemantic(String nodeType) {
 306                 Collection<String> semanticCollection = deleteScope.get(nodeType);
 307                 String semantic = semanticCollection.iterator().next();
 308
 309                 return DeleteSemantic.valueOf(semantic);
 310
 311         }
 312
 313         /**
 314          * Validate multiplicity.
 315          *
 316          * @param rule the rule
 317          * @param aVertex the out vertex
 318          * @param bVertex the in vertex
 319          * @return true, if successful
 320          * @throws AAIException the AAI exception
 321          */
 322         private boolean validateMultiplicity(EdgeRule rule, GraphTraversalSource traversalSource, Vertex aVertex, Vertex bVertex) throws AAIException {
 323
 324                 if (rule.getDirection().equals(Direction.OUT)) {
 325
 326                 } else if (rule.getDirection().equals(Direction.IN)) {
 327                         Vertex tempV = bVertex;
 328                         bVertex = aVertex;
 329                         aVertex = tempV;
 330                 }
 331
 332                 String aVertexType = aVertex.<String>property(AAIProperties.NODE_TYPE).orElse(null);
 333                 String bVertexType =  bVertex.<String>property(AAIProperties.NODE_TYPE).orElse(null);
 334                 String label = rule.getLabel();
 335                 MultiplicityRule multiplicityRule = rule.getMultiplicityRule();
 336                 List<Edge> outEdges = traversalSource.V(aVertex).outE(label).where(__.inV().has(AAIProperties.NODE_TYPE, bVertexType)).toList();
 337                 List<Edge> inEdges = traversalSource.V(bVertex).inE(label).where(__.outV().has(AAIProperties.NODE_TYPE, aVertexType)).toList();
 338                 String detail = "";
 339                 if (multiplicityRule.equals(MultiplicityRule.ONE2ONE)) {
 340                         if (inEdges.size() >= 1 || outEdges.size() >= 1 ) {
 341                                 detail = "multiplicity rule violated: only one edge can exist with label: " + label + " between " + aVertexType + " and " + bVertexType;
 342                         }
 343                 } else if (multiplicityRule.equals(MultiplicityRule.ONE2MANY)) {
 344                         if (inEdges.size() >= 1) {
 345                                 detail = "multiplicity rule violated: only one edge can exist with label: " + label + " between " + aVertexType + " and " + bVertexType;
 346                         }
 347                 } else if (multiplicityRule.equals(MultiplicityRule.MANY2ONE)) {
 348                         if (outEdges.size() >= 1) {
 349                                 detail = "multiplicity rule violated: only one edge can exist with label: " + label + " between " + aVertexType + " and " + bVertexType;
 350                         }
 351                 } else {
 352
 353                 }
 354
 355                 if (!detail.equals("")) {
 356                         throw new AAIException("AAI_6140", detail);
 357                 }
 358
 359                 return true;
 360
 361         }
 362
 363         public Multimap<String, EdgeRule> getAllRules() throws AAIException {
 364
 365                 Multimap<String, EdgeRule> result = ArrayListMultimap.create();
 366
 367                 for (String key : this.rules.keySet()) {
 368                         String outType = "";
 369                         String inType = "";
 370                         String[] split = key.split("\\|");
 371                         outType = split[0];
 372                         inType = split[1];
 373                         result.putAll(key,this.getEdgeRules(outType, inType).values());
 374                 }
 375
 376                 return result;
 377         }
 378
 379 }