aai-core/src/main/java/org/openecomp/aai/util/UniquePropertyCheck.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.util;
  22 import java.util.HashMap;
  23 import java.util.Iterator;
  24 import java.util.Map;
  25 import java.util.Properties;
  26 import java.util.UUID;
  27
  28 import org.apache.tinkerpop.gremlin.structure.Direction;
  29 import org.apache.tinkerpop.gremlin.structure.Edge;
  30 import org.apache.tinkerpop.gremlin.structure.VertexProperty;
  31 import org.slf4j.MDC;
  32
  33 import org.openecomp.aai.exceptions.AAIException;
  34 import com.att.eelf.configuration.Configuration;
  35 import com.att.eelf.configuration.EELFLogger;
  36 import com.att.eelf.configuration.EELFManager;
  37 import com.thinkaurelius.titan.core.TitanEdge;
  38 import com.thinkaurelius.titan.core.TitanFactory;
  39 import com.thinkaurelius.titan.core.TitanGraph;
  40 import com.thinkaurelius.titan.core.TitanTransaction;
  41 import com.thinkaurelius.titan.core.TitanVertex;
  42
  43
  44
  45 public class UniquePropertyCheck {
  46
  47
  48         private static  final  String    FROMAPPID = "AAI-UTILS";
  49         private static  final  String    TRANSID   = UUID.randomUUID().toString();
  50         private static  final  String    COMPONENT = "UniquePropertyCheck";
  51
  52         /**
  53          * The main method.
  54          *
  55          * @param args the arguments
  56          */
  57         public static void main(String[] args) {
  58
  59
  60                 Properties props = System.getProperties();
  61                 props.setProperty(Configuration.PROPERTY_LOGGING_FILE_NAME, "uniquePropertyCheck-logback.xml");
  62                 props.setProperty(Configuration.PROPERTY_LOGGING_FILE_PATH, AAIConstants.AAI_HOME_ETC_APP_PROPERTIES);
  63                 EELFLogger logger = EELFManager.getInstance().getLogger(UniquePropertyCheck.class.getSimpleName());
  64                 MDC.put("logFilenameAppender", UniquePropertyCheck.class.getSimpleName());
  65
  66                 if( args == null || args.length != 1 ){
  67                                 String msg = "usage:  UniquePropertyCheck propertyName \n";
  68                                 System.out.println(msg);
  69                                 logAndPrint(logger, msg );
  70                                 System.exit(1);
  71                 }
  72                 String propertyName = args[0];
  73                 TitanTransaction graph = null;
  74
  75                 try {
  76                 AAIConfig.init();
  77                 System.out.println("    ---- NOTE --- about to open graph (takes a little while)--------\n");
  78                 TitanGraph tGraph = TitanFactory.open(AAIConstants.REALTIME_DB_CONFIG);
  79
  80                 if( tGraph == null ) {
  81                         logAndPrint(logger, " Error:  Could not get TitanGraph ");
  82                         System.exit(1);
  83                 }
  84
  85                 graph = tGraph.newTransaction();
  86                 if( graph == null ){
  87                         logAndPrint(logger, "could not get graph object in UniquePropertyCheck() \n");
  88                         System.exit(0);
  89                 }
  90         }
  91             catch (AAIException e1) {
  92                         String msg =  "Threw Exception: [" + e1.toString() + "]";
  93                         logAndPrint(logger, msg);
  94                         System.exit(0);
  95         }
  96         catch (Exception e2) {
  97                         String msg =  "Threw Exception: [" + e2.toString() + "]";
  98                         logAndPrint(logger, msg);
  99                         System.exit(0);
 100         }
 101
 102                 runTheCheckForUniqueness( TRANSID, FROMAPPID, graph, propertyName, logger );
 103                 System.exit(0);
 104
 105         }// End main()
 106
 107
 108         /**
 109          * Run the check for uniqueness.
 110          *
 111          * @param transId the trans id
 112          * @param fromAppId the from app id
 113          * @param graph the graph
 114          * @param propertyName the property name
 115          * @param logger the logger
 116          * @return the boolean
 117          */
 118         public static Boolean runTheCheckForUniqueness( String transId, String fromAppId, TitanTransaction graph,
 119                         String propertyName, EELFLogger logger ){
 120
 121                 // Note - property can be found in more than one nodetype
 122                 //    our uniqueness constraints are always across the entire db - so this
 123                 //   tool looks across all nodeTypes that the property is found in.
 124                 Boolean foundDupesFlag = false;
 125
 126                 HashMap <String,String> valuesAndVidHash = new HashMap <String, String> ();
 127                 HashMap <String,String> dupeHash = new HashMap <String, String> ();
 128
 129                 int propCount = 0;
 130                 int dupeCount = 0;
 131                 Iterable <?> vertItr = graph.query().has(propertyName).vertices();
 132                 Iterator <?> vertItor = vertItr.iterator();
 133         while( vertItor.hasNext() ){
 134                 propCount++;
 135                 TitanVertex v = (TitanVertex)vertItor.next();
 136                 String thisVid = v.id().toString();
 137                 Object val = (v.<Object>property(propertyName)).orElse(null);
 138                 if( valuesAndVidHash.containsKey(val) ){
 139                         // We've seen this one before- track it in our  dupe hash
 140                         dupeCount++;
 141                         if( dupeHash.containsKey(val) ){
 142                                 // This is not the first one being added to the dupe hash for this value
 143                                 String updatedDupeList = dupeHash.get(val) + "|" + thisVid;
 144                                 dupeHash.put(val.toString(), updatedDupeList);
 145                         }
 146                         else {
 147                                 // This is the first time we see this value repeating
 148                                 String firstTwoVids =  valuesAndVidHash.get(val) + "|" + thisVid;
 149                                 dupeHash.put(val.toString(), firstTwoVids);
 150                         }
 151                 }
 152                 else {
 153                         valuesAndVidHash.put(val.toString(), thisVid);
 154                 }
 155         }
 156
 157
 158         String info = "\n Found this property [" + propertyName + "] " + propCount + " times in our db.";
 159         logAndPrint(logger, info);
 160         info = " Found " + dupeCount + " cases of duplicate values for this property.\n\n";
 161         logAndPrint(logger, info);
 162
 163         try {
 164                 if( ! dupeHash.isEmpty() ){
 165                         Iterator <?> dupeItr = dupeHash.entrySet().iterator();
 166                         while( dupeItr.hasNext() ){
 167                                 Map.Entry pair = (Map.Entry) dupeItr.next();
 168                                 String dupeValue = pair.getKey().toString();;
 169                                                         String vidsStr = pair.getValue().toString();
 170                                 String[] vidArr = vidsStr.split("\\|");
 171                                 logAndPrint(logger, "\n\n -------------- Found " + vidArr.length
 172                                                 + " nodes with " + propertyName + " of this value: [" + dupeValue + "].  Node details: ");
 173
 174                                 for( int i = 0; i < vidArr.length; i++ ){
 175                                         String vidString = vidArr[i];
 176                                         Long idLong = Long.valueOf(vidString);
 177                                         TitanVertex tvx = (TitanVertex)graph.getVertex(idLong);
 178                                         showPropertiesAndEdges( TRANSID, FROMAPPID, tvx, logger );
 179                                 }
 180                         }
 181                 }
 182         }
 183         catch( Exception e2 ){
 184                         logAndPrint(logger, "Threw Exception: [" + e2.toString() + "]");
 185         }
 186         finally {
 187                 if( graph != null ){
 188                         graph.rollback();
 189                 }
 190         }
 191
 192         return foundDupesFlag;
 193
 194         }// end of runTheCheckForUniqueness()
 195
 196
 197         /**
 198          * Show properties and edges.
 199          *
 200          * @param transId the trans id
 201          * @param fromAppId the from app id
 202          * @param tVert the t vert
 203          * @param logger the logger
 204          */
 205         private static void showPropertiesAndEdges( String transId, String fromAppId, TitanVertex tVert,
 206                         EELFLogger logger ){
 207
 208                 if( tVert == null ){
 209                         logAndPrint(logger, "Null node passed to showPropertiesAndEdges.");
 210                 }
 211                 else {
 212                         String nodeType = "";
 213                         Object ob = tVert.<String>property("aai-node-type").orElse(null);
 214                         if( ob == null ){
 215                                 nodeType = "null";
 216                         }
 217                         else{
 218                                 nodeType = ob.toString();
 219                         }
 220
 221                         logAndPrint(logger, " AAINodeType/VtxID for this Node = [" + nodeType + "/" + tVert.id() + "]");
 222                         logAndPrint(logger, " Property Detail: ");
 223                         Iterator<VertexProperty<Object>> pI = tVert.properties();
 224                         while( pI.hasNext() ){
 225                                 VertexProperty<Object> tp = pI.next();
 226                                 Object val = tp.value();
 227                                 logAndPrint(logger, "Prop: [" + tp.key() + "], val = [" + val + "] ");
 228                         }
 229
 230                         Iterator <Edge> eI = tVert.edges(Direction.BOTH);
 231                         if( ! eI.hasNext() ){
 232                                 logAndPrint(logger, "No edges were found for this vertex. ");
 233                         }
 234                         while( eI.hasNext() ){
 235                                 TitanEdge ed = (TitanEdge) eI.next();
 236                                 String lab = ed.label();
 237                                 TitanVertex vtx = (TitanVertex) ed.otherVertex(tVert);
 238                                 if( vtx == null ){
 239                                         logAndPrint(logger, " >>> COULD NOT FIND VERTEX on the other side of this edge edgeId = " + ed.id() + " <<< ");
 240                                 }
 241                                 else {
 242                                         String nType = vtx.<String>property("aai-node-type").orElse(null);
 243                                         String vid = vtx.id().toString();
 244                                         logAndPrint(logger, "Found an edge (" + lab + ") from this vertex to a [" + nType + "] node with VtxId = " + vid);
 245                                 }
 246                         }
 247                 }
 248         } // End of showPropertiesAndEdges()
 249
 250
 251         /**
 252          * Log and print.
 253          *
 254          * @param logger the logger
 255          * @param msg the msg
 256          */
 257         protected static void logAndPrint(EELFLogger logger, String msg) {
 258                 System.out.println(msg);
 259                 logger.info(msg);
 260         }
 261
 262 }
 263
 264