aai-core/src/main/java/org/openecomp/aai/dbgraphgen/DbSearchWithTags.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.dbgraphgen;
  22
  23 import java.util.HashMap;
  24 import java.util.Iterator;
  25 import java.util.LinkedHashSet;
  26 import java.util.List;
  27 import java.util.Map;
  28 import java.util.Set;
  29
  30 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
  31 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
  32 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
  33 import org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree;
  34 import org.apache.tinkerpop.gremlin.structure.Element;
  35 import org.apache.tinkerpop.gremlin.structure.Vertex;
  36
  37 import org.openecomp.aai.db.props.AAIProperties;
  38 import org.openecomp.aai.exceptions.AAIException;
  39 import org.openecomp.aai.introspection.Loader;
  40 import org.openecomp.aai.serialization.db.DBSerializer;
  41 import org.openecomp.aai.serialization.engines.TransactionalGraphEngine;
  42 import org.openecomp.aai.util.AAIConfig;
  43 import com.att.eelf.configuration.EELFLogger;
  44 import com.att.eelf.configuration.EELFManager;
  45
  46
  47
  48 /**
  49  * Database-level Search-Utility class that uses edge-tags to help it navigate the graph.
  50  */
  51 public class DbSearchWithTags{
  52
  53         private EELFLogger LOGGER = EELFManager.getInstance().getLogger(DbSearchWithTags.class);
  54
  55         private TransactionalGraphEngine engine;
  56
  57         protected DbSearchWithTags() {
  58
  59         }
  60         public DbSearchWithTags(Loader loader, TransactionalGraphEngine engine, DBSerializer serializer) {
  61                 this.engine = engine;
  62         }
  63
  64         /**
  65          * Run edge tag query.
  66          *
  67          * @param transId the trans id
  68          * @param fromAppId the from app id
  69          * @param edgeTag the edge tag
  70          * @param searchRootType - root collection point when doing the search
  71          * @param displayRootType - if they want more data than would be included using the searchRootType, this
  72          *                            lets them specify it.
  73          * @param searchDirectionStr the search direction str
  74          * @param initialFilterHash the initial filter hash
  75          * @param secondaryFilterHash the secondary filter hash
  76          * @param pruneLevel   either "none", "searchLevel" or "displayLevel".
  77          * @param retNodeType    could be either "all" for the full map, or a single nodeType
  78          * @param trimList     list of nodes to "stop" at when collecting data
  79          * @return List<resultSet>
  80          * @throws AAIException the AAI exception
  81          */
  82           public Tree<Vertex> runEdgeTagQuery( String transId, String fromAppId,
  83                         String edgeTag,
  84                         String searchRootType,
  85                         Map<String,Object> initialFilterHash,
  86                         Map<String,Object> secondaryFilterHash)
  87                             throws AAIException{
  88
  89                 final String tag = edgeTag;
  90                 final String reverseTag = edgeTag + "-REV";
  91                 //max levels is not used at this time, but may be used again
  92                 int maxLevels = 50; // default value
  93                 String maxString = AAIConfig.get("aai.edgeTag.proc.max.levels");
  94                 if( maxString != null &&  !maxString.equals("") ){
  95                         try {
  96                                 int maxVal = Integer.parseInt(maxString);
  97                                 maxLevels = maxVal;
  98                         }
  99                         catch ( Exception nfe ){
 100                                 // Don't worry, we will leave "maxLevels" set to the default value it was initialized with
 101                         }
 102                 }
 103
 104                 // First, we need to use the intialFilter plus the edgeTag to identify a set of search-root-nodes
 105                 HashMap <String, Vertex> searchRootHash = identifyTopNodeSet( transId, fromAppId,
 106                                 edgeTag, searchRootType, initialFilterHash, maxLevels );
 107
 108
 109                 Set<String> keySet = searchRootHash.keySet();
 110                 Iterator<String> itr = keySet.iterator();
 111                 String[] arrayOfVertices = new String[keySet.size()];
 112                 int i = 0;
 113                 while (itr.hasNext()) {
 114                         arrayOfVertices[i] = itr.next();
 115                         i++;
 116                 }
 117                 //start from all vertices provided
 118                 //repeat checking the out edge for the tag and the in edge for reverse tag
 119                 //emit all vertices not already seen and start again
 120                 //return a tree structure of the vertices and edges touched by this traversal
 121                 Tree<Element> resultTree = this.engine.asAdmin().getReadOnlyTraversalSource().V(arrayOfVertices)
 122                                 .emit().repeat(__.union(__.outE().has(tag, true), __.inE().has(reverseTag, true)).otherV()).tree().next();
 123
 124                 //the resulting tree includes the edges because of our query, we'll need to remove them
 125                 Tree<Vertex> sanitizedTree = removeUnwantedItems(resultTree);
 126
 127                 //if we have secondary filters then check each tree returned for matches
 128                 if (!secondaryFilterHash.isEmpty()) {
 129                         filterOutResultTrees(sanitizedTree, secondaryFilterHash);
 130                 }
 131                 return sanitizedTree;
 132
 133           }// End of runEdgeTagQuery()
 134
 135         /**
 136          * Identify top node set.
 137          *
 138          * @param transId the trans id
 139          * @param fromAppId the from app id
 140          * @param edgeTag the edge tag
 141          * @param topNodeType the top node type
 142          * @param initialFilterHash the initial filter hash
 143          * @param maxLevels the max levels
 144          * @return List<titanVertex>
 145          * @throws AAIException the AAI exception
 146          */
 147           public HashMap<String, Vertex> identifyTopNodeSet( String transId, String fromAppId,
 148                           String edgeTag, String topNodeType, Map<String,Object> initialFilterHash, int maxLevels )
 149                                           throws AAIException {
 150
 151                   final String tag = edgeTag;
 152                   final String reverseTag = edgeTag + "-REV";
 153                   HashMap <String, Vertex> topVertHash = new HashMap <>();
 154
 155                   // Given the filter, we want to select all the nodes of the type the filter tells us that have the
 156                   //    property they gave us.
 157                   // Then looping through those start points, we will look "up" and then "down" to find the set of target/top nodes.
 158
 159                   if( initialFilterHash == null || initialFilterHash.isEmpty() ){
 160                           throw new AAIException("AAI_6118", " initialFilterHash is required for identifyInitialNodeSet() call. \n");
 161                   }
 162
 163                   // NOTE: we're expecting the filter to have a format like this: "nodeType.parameterName:parameterValue"
 164                   Iterator <?> it = initialFilterHash.entrySet().iterator();
 165                   // -- DEBUG -- for now we only deal with ONE initial filter parameter
 166                   //     it would be easy enough to deal with multiple parameters if they all
 167                   //     applied to the same nodeType.
 168                   String propNodeTypeDotName = "";
 169                   String initNodeType = "";
 170                   String initPropName = "";
 171
 172                   String extraChecks = "";
 173
 174                   String propVal = "";
 175                   if( it.hasNext() ){
 176                           Map.Entry<?,?> propEntry = (Map.Entry<?,?>) it.next();
 177                           propNodeTypeDotName = (propEntry.getKey()).toString();
 178                           propVal = (propEntry.getValue()).toString();
 179                   }
 180
 181                   GraphTraversalSource source = this.engine.asAdmin().getReadOnlyTraversalSource();
 182                   GraphTraversal<Vertex, Vertex> g;
 183
 184                   int periodLoc = propNodeTypeDotName.indexOf(".");
 185                   if( periodLoc <= 0 ){
 186                           throw new AAIException("AAI_6120", "Bad filter param key passed in: [" + propNodeTypeDotName + "].  Expected format = [nodeName.paramName]\n");
 187                   }
 188                   else {
 189                           initNodeType = propNodeTypeDotName.substring(0,periodLoc);
 190                           initPropName = propNodeTypeDotName.substring(periodLoc + 1);
 191
 192                           //there used to be logic here that would do something special for generic-vnf.vnf-name and vserver.vserver-name
 193                           //it would attempt a search as they sent it, if nothing came back, try as all upper, try as all lower, then fail
 194                           //here it checks whether something comes back or not, if not change the case and try again
 195                           if( (initNodeType.equals("generic-vnf") && initPropName.equals("vnf-name"))
 196                                           || (initNodeType.equals("vserver") && initPropName.equals("vserver-name")) ){
 197                                   if (!this.checkKludgeCase(initNodeType, initPropName, propVal)) {
 198                                           if (this.checkKludgeCase(initNodeType, initPropName, propVal.toUpperCase())) {
 199                                                   propVal = propVal.toUpperCase();
 200                                           } else {
 201                                                   if (this.checkKludgeCase(initNodeType, initPropName, propVal)) {
 202                                                           propVal = propVal.toLowerCase();
 203                                                   }
 204                                           }
 205                                   }
 206                           }
 207                           g = source.V().has(AAIProperties.NODE_TYPE, initNodeType).has(initPropName, propVal);
 208
 209                           //search all around bounded by our edge tag for start nodes that match our topNodeType
 210                           if (!topNodeType.equals(initNodeType)) {
 211
 212                                 g.union(__.<Vertex>start().until(__.has(AAIProperties.NODE_TYPE, topNodeType))
 213                                                  .repeat(__.union(__.inE().has(reverseTag, true), __.outE().has(tag, true)).otherV()),
 214                                                  __.<Vertex>start().until(__.has(AAIProperties.NODE_TYPE, topNodeType))
 215                                                  .repeat(__.union(__.inE().has(tag, true), __.outE().has(reverseTag, true)).otherV())).dedup();
 216                           }
 217
 218                           List<Vertex> results = g.toList();
 219
 220                           results.forEach(v -> {
 221                                   topVertHash.put(v.id().toString(), v);
 222                           });
 223                   }
 224                   if( topVertHash.isEmpty() ){
 225                                 // No Vertex was found  - throw a not-found exception
 226                                 throw new AAIException("AAI_6114", "No Node of type " + topNodeType + " found for properties: " + initialFilterHash.toString() + extraChecks);
 227                   }
 228                   else {
 229                           return topVertHash;
 230                   }
 231
 232           }// End identifyInitialNodeSet()
 233
 234           /**
 235            * This is a carryover from the previous version.
 236            * We may be able to remove this.
 237            *
 238            * @param nodeType
 239            * @param propName
 240            * @param propValue
 241            * @return
 242            */
 243           private boolean checkKludgeCase(String nodeType, String propName, String propValue) {
 244                   return this.engine.getQueryBuilder().getVerticesByIndexedProperty(AAIProperties.NODE_TYPE, nodeType).getVerticesByProperty(propName, propValue).hasNext();
 245           }
 246
 247         /**
 248          * This method starts from the top of the tree object and checks each nested tree.
 249          * If that tree does not contain a node (or nodes) that match the filterHash, remove it
 250          *
 251          * @param tree
 252          * @param filterHash
 253          * @throws AAIException
 254          */
 255         private void filterOutResultTrees(Tree<Vertex> tree, Map<String,Object> filterHash) throws AAIException {
 256                 Set<Vertex> topLevelKeys = new LinkedHashSet<>(tree.keySet());
 257                 for (Vertex topLevel : topLevelKeys) {
 258                         if (!this.checkVertexWithFilters(topLevel, filterHash)) {
 259                                 if (!filterOutResultTreesHelper(tree.get(topLevel), filterHash)) {
 260                                         //if we never found anything to satisfy our filter, remove the entire result tree
 261                                         tree.remove(topLevel);
 262                                 }
 263                         }
 264                 }
 265         }
 266
 267         /**
 268          * Checks all vertices of a tree with the provided filterHash
 269          *
 270          * @param tree
 271          * @param filterHash
 272          * @return
 273          * @throws AAIException
 274          */
 275         private boolean filterOutResultTreesHelper(Tree<Vertex> tree, Map<String,Object> filterHash) throws AAIException {
 276
 277                 Set<Vertex> keys = tree.keySet();
 278
 279                 for (Vertex v : keys) {
 280                         if (checkVertexWithFilters(v, filterHash)) {
 281                                 return true;
 282                         } else {
 283                                 if (filterOutResultTreesHelper(tree.get(v), filterHash)) {
 284                                         return true;
 285                                 }
 286                         }
 287                 }
 288
 289                 return false;
 290         }
 291         /**
 292          * Checks whether a vertex matches the filterHash provided
 293          *
 294          * @param v
 295          * @param filterHash
 296          * @return
 297          * @throws AAIException
 298          */
 299         private boolean checkVertexWithFilters(Vertex v, Map<String,Object> filterHash) throws AAIException {
 300                 Iterator <?> it = filterHash.entrySet().iterator();
 301
 302                 while( it.hasNext() ){
 303                           Map.Entry<?,?> filtEntry = (Map.Entry<?,?>) it.next();
 304                           String propNodeTypeDotName = (filtEntry.getKey()).toString();
 305                           String value = (filtEntry.getValue()).toString();
 306
 307                           int periodLoc = propNodeTypeDotName.indexOf(".");
 308                           if( periodLoc <= 0 ){
 309                                   throw new AAIException("AAI_6120", "Bad filter param key passed in: [" + propNodeTypeDotName + "].  Expected format = [nodeName.paramName]\n");
 310                           }
 311                           else {
 312                                   String nodeType = propNodeTypeDotName.substring(0,periodLoc);
 313                                   String propertyName = propNodeTypeDotName.substring(periodLoc + 1);
 314                                   String nt = v.<String>property("aai-node-type").orElse(null);
 315                                   if( nt.equals( nodeType ) ){
 316                                           if( propertyName.equals("vertex-id") ){
 317                                                   // vertex-id can't be gotten the same way as other properties
 318                                                   String thisVtxId = v.id().toString();
 319                                                   if( thisVtxId.equals(value) ){
 320                                                           return true;
 321                                                   }
 322                                           }
 323                                           else {
 324                                                   Object thisValObj = v.property(propertyName).orElse(null);
 325                                                   if( thisValObj != null ){
 326                                                           String thisVal = thisValObj.toString();
 327                                                           if( thisVal.equals(value) ){
 328                                                                   return true;
 329                                                           }
 330                                                   }
 331                                           }
 332                                   }
 333                           }
 334                   }
 335
 336                  return false;
 337         }
 338
 339         /**
 340          * Removes every other tree from the originalTree provided.
 341          * It is designed to specifically handle removing unwanted edges from the originalTree
 342          * @param originalTree
 343          * @return
 344          */
 345         private Tree<Vertex> removeUnwantedItems(Tree<Element> originalTree) {
 346
 347                 Tree<Vertex> newTree = new Tree<>();
 348                 Set<Element> keys = originalTree.keySet();
 349                 for (Element element : keys) {
 350                         newTree.put((Vertex)element, removeUnwantedItemsHelper(originalTree.get(element).getTreesAtDepth(2)));
 351                 }
 352
 353                 return newTree;
 354
 355
 356         }
 357
 358         private Tree<Vertex> removeUnwantedItemsHelper(List<Tree<Element>> originalTrees) {
 359                 Tree<Vertex> newTree = new Tree<>();
 360                 for (Tree<Element> tree : originalTrees) {
 361                         newTree.addTree(removeUnwantedItems(tree));
 362                 }
 363
 364                 return newTree;
 365         }
 366 }