aai-core/src/main/java/org/openecomp/aai/db/schema/ManageTitanSchema.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.db.schema;
  22
  23 import java.util.ArrayList;
  24 import java.util.List;
  25 import java.util.Set;
  26
  27 import org.apache.tinkerpop.gremlin.structure.Vertex;
  28
  29 import org.openecomp.aai.introspection.Version;
  30 import com.thinkaurelius.titan.core.PropertyKey;
  31 import com.thinkaurelius.titan.core.TitanGraph;
  32 import com.thinkaurelius.titan.core.schema.SchemaStatus;
  33 import com.thinkaurelius.titan.core.schema.TitanGraphIndex;
  34 import com.thinkaurelius.titan.core.schema.TitanManagement;
  35 import com.thinkaurelius.titan.core.schema.TitanManagement.IndexBuilder;
  36
  37 public class ManageTitanSchema {
  38
  39
  40         private TitanManagement graphMgmt;
  41         private TitanGraph graph;
  42         private List<DBProperty> aaiProperties;
  43         private List<DBIndex> aaiIndexes;
  44         private List<EdgeProperty> aaiEdgeProperties;
  45         private Auditor oxmInfo = null;
  46         private Auditor graphInfo = null;
  47
  48         /**
  49          * Instantiates a new manage titan schema.
  50          *
  51          * @param graph the graph
  52          */
  53         public ManageTitanSchema(final TitanGraph graph) {
  54                 this.graph = graph;
  55                 oxmInfo = AuditorFactory.getOXMAuditor(Version.v8);
  56                 graphInfo = AuditorFactory.getGraphAuditor(graph);
  57         }
  58
  59
  60         /**
  61          * Builds the schema.
  62          */
  63         public void buildSchema() {
  64
  65                 this.graphMgmt = graph.openManagement();
  66                 aaiProperties = new ArrayList<>();
  67                 aaiEdgeProperties = new ArrayList<>();
  68                 aaiIndexes = new ArrayList<>();
  69                 aaiProperties.addAll(oxmInfo.getAuditDoc().getProperties());
  70                 aaiIndexes.addAll(oxmInfo.getAuditDoc().getIndexes());
  71                 aaiEdgeProperties.addAll(oxmInfo.getAuditDoc().getEdgeLabels());
  72                 try {
  73                         createPropertyKeys();
  74                         createIndexes();
  75                         createEdgeLabels();
  76                 } catch (Exception e) {
  77                         e.printStackTrace();
  78                         graphMgmt.rollback();
  79                 }
  80                 graphMgmt.commit();
  81         }
  82
  83         /**
  84          * Creates the property keys.
  85          */
  86         private void createPropertyKeys() {
  87
  88
  89                 for (DBProperty prop : aaiProperties) {
  90
  91                         if (graphMgmt.containsPropertyKey(prop.getName())) {
  92                                 PropertyKey key = graphMgmt.getPropertyKey(prop.getName());
  93                                 boolean isChanged = false;
  94                                 if (!prop.getCardinality().equals(key.cardinality())) {
  95                                         isChanged = true;
  96                                 }
  97                                 if (!prop.getTypeClass().equals(key.dataType())) {
  98                                         isChanged = true;
  99                                 }
 100                                 if (isChanged) {
 101                                         //must modify!
 102                                         this.replaceProperty(prop);
 103                                 }
 104                         } else {
 105                                 //create a new property key
 106                                 System.out.println("Key: " + prop.getName() + " not found - adding");
 107                                 graphMgmt.makePropertyKey(prop.getName()).dataType(prop.getTypeClass()).cardinality(prop.getCardinality()).make();
 108                         }
 109                 }
 110
 111         }
 112
 113         /**
 114          * Creates the indexes.
 115          */
 116         private void createIndexes() {
 117
 118                 for (DBIndex index : aaiIndexes) {
 119                         Set<DBProperty> props = index.getProperties();
 120                         boolean isChanged = false;
 121                         boolean isNew = false;
 122                         List<PropertyKey> keyList = new ArrayList<>();
 123                         for (DBProperty prop : props) {
 124                                 keyList.add(graphMgmt.getPropertyKey(prop.getName()));
 125                         }
 126                         if (graphMgmt.containsGraphIndex(index.getName())) {
 127                                 TitanGraphIndex titanIndex = graphMgmt.getGraphIndex(index.getName());
 128                                 PropertyKey[] dbKeys = titanIndex.getFieldKeys();
 129                                 if (dbKeys.length != keyList.size()) {
 130                                         isChanged = true;
 131                                 } else {
 132                                         int i = 0;
 133                                         for (PropertyKey key : keyList) {
 134                                                 if (!dbKeys[i].equals(key)) {
 135                                                         isChanged = true;
 136                                                         break;
 137                                                 }
 138                                                 i++;
 139                                         }
 140                                 }
 141                         } else {
 142                                 isNew = true;
 143                         }
 144                         if (keyList.size() > 0) {
 145                                 this.createIndex(graphMgmt, index.getName(), keyList, index.isUnique(), isNew, isChanged);
 146                         }
 147                 }
 148         }
 149
 150         // Use EdgeRules to make sure edgeLabels are defined in the db.  NOTE: the multiplicty used here is
 151         // always "MULTI".  This is not the same as our internal "Many2Many", "One2One", "One2Many" or "Many2One"
 152         // We use the same edge-label for edges between many different types of nodes and our internal
 153         // multiplicty definitions depends on which two types of nodes are being connected.
 154         /**
 155          * Creates the edge labels.
 156          */
 157         private void createEdgeLabels() {
 158
 159
 160                 for (EdgeProperty prop : aaiEdgeProperties) {
 161
 162                         if (graphMgmt.containsEdgeLabel(prop.getName())) {
 163                                 // see what changed
 164                         } else {
 165                                 graphMgmt.makeEdgeLabel(prop.getName()).multiplicity(prop.getMultiplicity()).make();
 166                         }
 167
 168                 }
 169
 170
 171         }
 172
 173         /**
 174          * Creates the property.
 175          *
 176          * @param mgmt the mgmt
 177          * @param prop the prop
 178          */
 179         private void createProperty(TitanManagement mgmt, DBProperty prop) {
 180                 if (mgmt.containsPropertyKey(prop.getName())) {
 181                         PropertyKey key = mgmt.getPropertyKey(prop.getName());
 182                         boolean isChanged = false;
 183                         if (!prop.getCardinality().equals(key.cardinality())) {
 184                                 isChanged = true;
 185                         }
 186                         if (!prop.getTypeClass().equals(key.dataType())) {
 187                                 isChanged = true;
 188                         }
 189                         if (isChanged) {
 190                                 //must modify!
 191                                 this.replaceProperty(prop);
 192                         }
 193                 } else {
 194                         //create a new property key
 195                         System.out.println("Key: " + prop.getName() + " not found - adding");
 196                         mgmt.makePropertyKey(prop.getName()).dataType(prop.getTypeClass()).cardinality(prop.getCardinality()).make();
 197                 }
 198         }
 199
 200         /**
 201          * Creates the index.
 202          *
 203          * @param mgmt the mgmt
 204          * @param indexName the index name
 205          * @param keys the keys
 206          * @param isUnique the is unique
 207          * @param isNew the is new
 208          * @param isChanged the is changed
 209          */
 210         private void createIndex(TitanManagement mgmt, String indexName, List<PropertyKey> keys, boolean isUnique, boolean isNew, boolean isChanged) {
 211
 212                 /*if (isChanged) {
 213                         System.out.println("Changing index: " + indexName);
 214                         TitanGraphIndex oldIndex = mgmt.getGraphIndex(indexName);
 215                         mgmt.updateIndex(oldIndex, SchemaAction.DISABLE_INDEX);
 216                         mgmt.commit();
 217                         //cannot remove indexes
 218                         //graphMgmt.updateIndex(oldIndex, SchemaAction.REMOVE_INDEX);
 219                 }*/
 220                 if (isNew || isChanged) {
 221
 222                         if (isNew) {
 223                                 IndexBuilder builder = mgmt.buildIndex(indexName,Vertex.class);
 224                                 for (PropertyKey k : keys) {
 225                                         builder.addKey(k);
 226                                 }
 227                                 if (isUnique) {
 228                                         builder.unique();
 229                                 }
 230                                 builder.buildCompositeIndex();
 231                                 System.out.println("Built index for " + indexName + " with keys: " + keys);
 232
 233                                 //mgmt.commit();
 234                         }
 235
 236                         //mgmt = graph.asAdmin().getManagementSystem();
 237                         //mgmt.updateIndex(mgmt.getGraphIndex(indexName), SchemaAction.REGISTER_INDEX);
 238                         //mgmt.commit();
 239
 240                         try {
 241                                 //waitForCompletion(indexName);
 242                                 //TitanIndexRepair.hbaseRepair(AAIConstants.AAI_CONFIG_FILENAME, indexName, "");
 243                         } catch (Exception e) {
 244                                 // TODO Auto-generated catch block
 245                                 graph.tx().rollback();
 246                                 graph.close();
 247                                 e.printStackTrace();
 248                         }
 249
 250                         //mgmt = graph.asAdmin().getManagementSystem();
 251                         //mgmt.updateIndex(mgmt.getGraphIndex(indexName), SchemaAction.REINDEX);
 252
 253                         //mgmt.updateIndex(mgmt.getGraphIndex(indexName), SchemaAction.ENABLE_INDEX);
 254
 255                         //mgmt.commit();
 256
 257                 }
 258         }
 259
 260         /**
 261          * Wait for completion.
 262          *
 263          * @param name the name
 264          * @throws InterruptedException the interrupted exception
 265          */
 266         private void waitForCompletion(String name) throws InterruptedException {
 267
 268                 boolean registered = false;
 269                 long before = System.currentTimeMillis();
 270                 while (!registered) {
 271                     Thread.sleep(500L);
 272                     TitanManagement mgmt = graph.openManagement();
 273                     TitanGraphIndex idx  = mgmt.getGraphIndex(name);
 274                     registered = true;
 275                     for (PropertyKey k : idx.getFieldKeys()) {
 276                         SchemaStatus s = idx.getIndexStatus(k);
 277                         registered &= s.equals(SchemaStatus.REGISTERED);
 278                     }
 279                     mgmt.rollback();
 280                 }
 281                 System.out.println("Index REGISTERED in " + (System.currentTimeMillis() - before) + " ms");
 282         }
 283
 284         /**
 285          * Replace property.
 286          *
 287          * @param key the key
 288          */
 289         private void replaceProperty(DBProperty key) {
 290
 291
 292
 293
 294         }
 295
 296         /**
 297          * Update index.
 298          *
 299          * @param index the index
 300          */
 301         public void updateIndex(DBIndex index) {
 302
 303                 TitanManagement mgmt = graph.openManagement();
 304                 List<PropertyKey> keys = new ArrayList<>();
 305                 boolean isNew = false;
 306                 boolean isChanged = false;
 307                 for (DBProperty prop : index.getProperties()) {
 308                         createProperty(mgmt, prop);
 309                         keys.add(mgmt.getPropertyKey(prop.getName()));
 310                 }
 311                 if (mgmt.containsGraphIndex(index.getName())) {
 312                         System.out.println("index already exists");
 313                         isNew = false;
 314                         isChanged = true;
 315                 } else {
 316                         isNew = true;
 317                         isChanged = false;
 318                 }
 319                 this.createIndex(mgmt, index.getName(), keys, index.isUnique(), isNew, isChanged);
 320
 321                 mgmt.commit();
 322
 323         }
 324
 325
 326
 327
 328
 329 }