Faster UniquenessConstraintValidationHAIT

enterprise/ha/src/main/java/org/neo4j/kernel/impl/ha/ClusterManager.java

@@ -27,7 +27,9 @@
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
@@ -83,6 +85,7 @@
 import org.neo4j.kernel.impl.logging.NullLogService;
 import org.neo4j.kernel.impl.transaction.log.rotation.StoreFlusher;
 import org.neo4j.kernel.impl.util.Dependencies;
+import org.neo4j.kernel.impl.util.Listener;
 import org.neo4j.kernel.lifecycle.LifeSupport;
 import org.neo4j.kernel.lifecycle.Lifecycle;
 import org.neo4j.kernel.lifecycle.LifecycleAdapter;
@@ -159,6 +162,8 @@ public String apply( int ignored )
     private final Provider clustersProvider;
     private final HighlyAvailableGraphDatabaseFactory dbFactory;
     private final StoreDirInitializer storeDirInitializer;
+    private final Listener<GraphDatabaseService> initialDatasetCreator;
+    private final List<Predicate<ManagedCluster>> availabilityChecks;
     LifeSupport life;
 
     private ClusterManager( Builder builder )
@@ -168,6 +173,8 @@ private ClusterManager( Builder builder )
         this.commonConfig = withDefaults( builder.commonConfig );
         this.dbFactory = builder.factory;
         this.storeDirInitializer = builder.initializer;
+        this.initialDatasetCreator = builder.initialDatasetCreator;
+        this.availabilityChecks = builder.availabilityChecks;
     }
 
     private Map<String,IntFunction<String>> withDefaults( Map<String,IntFunction<String>> commonConfig )
@@ -556,6 +563,17 @@ public void start() throws Throwable
             ManagedCluster managedCluster = new ManagedCluster( cluster );
             clusterMap.put( cluster.getName(), managedCluster );
             life.add( managedCluster );
+
+            for ( Predicate<ManagedCluster> availabilityCheck : availabilityChecks )
+            {
+                managedCluster.await( availabilityCheck );
+            }
+
+            if ( initialDatasetCreator != null )
+            {
+                initialDatasetCreator.receive( managedCluster.getMaster() );
+                managedCluster.sync();
+            }
         }
     }
 
@@ -649,6 +667,20 @@ public interface ClusterBuilder<SELF>
          * {@link Setting} instance as key as well.
          */
         SELF withSharedSetting( Setting<?> setting, String value );
+
+        /**
+         * Initial dataset to be created once the cluster is up and running.
+         *
+         * @param transactor the {@link Listener} receiving a call to create the dataset on the master.
+         */
+        SELF withInitialDataset( Listener<GraphDatabaseService> transactor );
+
+        /**
+         * Checks that must pass before cluster is considered to be up.
+         *
+         * @param checks availability checks that must pass before considering the cluster online.
+         */
+        SELF withAvailabilityChecks( Predicate<ManagedCluster>... checks );
     }
 
     public static class Builder implements ClusterBuilder<Builder>
@@ -658,6 +690,8 @@ public static class Builder implements ClusterBuilder<Builder>
         private final Map<String,IntFunction<String>> commonConfig = new HashMap<>();
         private HighlyAvailableGraphDatabaseFactory factory = new HighlyAvailableGraphDatabaseFactory();
         private StoreDirInitializer initializer;
+        private Listener<GraphDatabaseService> initialDatasetCreator;
+        private List<Predicate<ManagedCluster>> availabilityChecks = Collections.emptyList();
 
         public Builder( File root )
         {
@@ -742,6 +776,21 @@ public Builder withSharedSetting( Setting<?> setting, String value )
             return withInstanceSetting( setting, constant( value ) );
         }
 
+        @Override
+        public Builder withInitialDataset( Listener<GraphDatabaseService> transactor )
+        {
+            this.initialDatasetCreator = transactor;
+            return this;
+        }
+
+        @Override
+        @SafeVarargs
+        public final Builder withAvailabilityChecks( Predicate<ManagedCluster>... checks )
+        {
+            this.availabilityChecks = Arrays.asList( checks );
+            return this;
+        }
+
         public ClusterManager build()
         {
             return new ClusterManager( this );

enterprise/ha/src/test/java/org/neo4j/ha/TestClusterClientPadding.java

@@ -42,7 +42,7 @@ public class TestClusterClientPadding
     public void setUp() throws Throwable
     {
         cluster = clusterRule.withProvider( clusterWithAdditionalClients( 2, 1 ) )
-                .availabilityChecks( masterAvailable(), masterSeesMembers( 3 ), allSeesAllAsJoined() )
+                .withAvailabilityChecks( masterAvailable(), masterSeesMembers( 3 ), allSeesAllAsJoined() )
                 .startCluster();
     }
 

enterprise/ha/src/test/java/org/neo4j/ha/UniquenessConstraintValidationHAIT.java

@@ -19,50 +19,45 @@
  */
 package org.neo4j.ha;
 
-import org.junit.Before;
+import org.junit.ClassRule;
 import org.junit.Rule;
 import org.junit.Test;
 
-import java.io.File;
 import java.util.concurrent.Future;
 
 import org.neo4j.graphdb.GraphDatabaseService;
+import org.neo4j.graphdb.Label;
 import org.neo4j.graphdb.Transaction;
 import org.neo4j.kernel.ha.HighlyAvailableGraphDatabase;
 import org.neo4j.kernel.impl.ha.ClusterManager;
-import org.neo4j.kernel.lifecycle.LifeRule;
+import org.neo4j.kernel.impl.util.Listener;
 import org.neo4j.test.OtherThreadRule;
-import org.neo4j.test.TargetDirectory;
-import org.neo4j.test.TestGraphDatabaseFactory;
+import org.neo4j.test.ha.ClusterRule;
 
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
+
 import static org.neo4j.graphdb.DynamicLabel.label;
 import static org.neo4j.kernel.impl.api.integrationtest.UniquenessConstraintValidationConcurrencyIT.createNode;
-import static org.neo4j.kernel.impl.ha.ClusterManager.allSeesAllAsAvailable;
 import static org.neo4j.test.OtherThreadRule.isWaiting;
-import static org.neo4j.test.TargetDirectory.testDirForTest;
 
 public class UniquenessConstraintValidationHAIT
 {
-    public final @Rule LifeRule life = new LifeRule();
-    public final @Rule TargetDirectory.TestDirectory targetDir =
-            testDirForTest( UniquenessConstraintValidationHAIT.class );
-    public final @Rule OtherThreadRule<Void> otherThread = new OtherThreadRule<>();
+    private static final Label LABEL = label( "Label1" );
+    private static final String PROPERTY_KEY = "key1";
 
-    @Before
-    public void startLife()
-    {
-        life.start();
-    }
+    @Rule
+    public final OtherThreadRule<Void> otherThread = new OtherThreadRule<>();
+    @ClassRule
+    public static final ClusterRule clusterRule = new ClusterRule( UniquenessConstraintValidationHAIT.class )
+            .withInitialDataset( uniquenessConstraint( LABEL, PROPERTY_KEY ) );
 
     @Test
     public void shouldAllowCreationOfNonConflictingDataOnSeparateHosts() throws Exception
     {
         // given
-        ClusterManager.ManagedCluster cluster = startClusterSeededWith(
-                databaseWithUniquenessConstraint( "Label1", "key1" ) );
+        ClusterManager.ManagedCluster cluster = clusterRule.startCluster();
 
         HighlyAvailableGraphDatabase slave1 = cluster.getAnySlave();
         HighlyAvailableGraphDatabase slave2 = cluster.getAnySlave( /*except:*/slave1 );
@@ -72,9 +67,9 @@ public void shouldAllowCreationOfNonConflictingDataOnSeparateHosts() throws Exce
 
         try ( Transaction tx = slave1.beginTx() )
         {
-            slave1.createNode( label( "Label1" ) ).setProperty( "key1", "value1" );
+            slave1.createNode( LABEL ).setProperty( PROPERTY_KEY, "value1" );
 
-            created = otherThread.execute( createNode( slave2, "Label1", "key1", "value2" ) );
+            created = otherThread.execute( createNode( slave2, LABEL.name(), PROPERTY_KEY, "value2" ) );
             tx.success();
         }
 
@@ -86,8 +81,7 @@ public void shouldAllowCreationOfNonConflictingDataOnSeparateHosts() throws Exce
     public void shouldPreventConcurrentCreationOfConflictingDataOnSeparateHosts() throws Exception
     {
         // given
-        ClusterManager.ManagedCluster cluster = startClusterSeededWith(
-                databaseWithUniquenessConstraint( "Label1", "key1" ) );
+        ClusterManager.ManagedCluster cluster = clusterRule.startCluster();
 
         HighlyAvailableGraphDatabase slave1 = cluster.getAnySlave();
         HighlyAvailableGraphDatabase slave2 = cluster.getAnySlave( /*except:*/slave1 );
@@ -96,9 +90,9 @@ public void shouldPreventConcurrentCreationOfConflictingDataOnSeparateHosts() th
         Future<Boolean> created;
         try ( Transaction tx = slave1.beginTx() )
         {
-            slave1.createNode( label( "Label1" ) ).setProperty( "key1", "value1" );
+            slave1.createNode( LABEL ).setProperty( PROPERTY_KEY, "value3" );
 
-            created = otherThread.execute( createNode( slave2, "Label1", "key1", "value1" ) );
+            created = otherThread.execute( createNode( slave2, LABEL.name(), PROPERTY_KEY, "value3" ) );
 
             assertThat( otherThread, isWaiting() );
 
@@ -114,8 +108,7 @@ public void shouldPreventConcurrentCreationOfConflictingDataOnSeparateHosts() th
     public void shouldPreventConcurrentCreationOfConflictingNonStringPropertyOnMasterAndSlave() throws Exception
     {
         // given
-        ClusterManager.ManagedCluster cluster = startClusterSeededWith(
-                databaseWithUniquenessConstraint( "Label1", "key1" ) );
+        ClusterManager.ManagedCluster cluster = clusterRule.startCluster();
 
         HighlyAvailableGraphDatabase master = cluster.getMaster();
         HighlyAvailableGraphDatabase slave = cluster.getAnySlave();
@@ -124,9 +117,9 @@ public void shouldPreventConcurrentCreationOfConflictingNonStringPropertyOnMaste
         Future<Boolean> created;
         try ( Transaction tx = master.beginTx() )
         {
-            master.createNode( label( "Label1" ) ).setProperty( "key1", 0x0099CC );
+            master.createNode( LABEL ).setProperty( PROPERTY_KEY, 0x0099CC );
 
-            created = otherThread.execute( createNode( slave, "Label1", "key1", 0x0099CC ) );
+            created = otherThread.execute( createNode( slave, LABEL.name(), PROPERTY_KEY, 0x0099CC ) );
 
             assertThat( otherThread, isWaiting() );
 
@@ -141,8 +134,7 @@ public void shouldPreventConcurrentCreationOfConflictingNonStringPropertyOnMaste
     public void shouldAllowOtherHostToCompleteIfFirstHostRollsBackTransaction() throws Exception
     {
         // given
-        ClusterManager.ManagedCluster cluster = startClusterSeededWith(
-                databaseWithUniquenessConstraint( "Label1", "key1" ) );
+        ClusterManager.ManagedCluster cluster = clusterRule.startCluster();
 
         HighlyAvailableGraphDatabase slave1 = cluster.getAnySlave();
         HighlyAvailableGraphDatabase slave2 = cluster.getAnySlave( /*except:*/slave1 );
@@ -152,9 +144,9 @@ public void shouldAllowOtherHostToCompleteIfFirstHostRollsBackTransaction() thro
 
         try ( Transaction tx = slave1.beginTx() )
         {
-            slave1.createNode( label( "Label1" ) ).setProperty( "key1", "value1" );
+            slave1.createNode( LABEL ).setProperty( PROPERTY_KEY, "value4" );
 
-            created = otherThread.execute( createNode( slave2, "Label1", "key1", "value1" ) );
+            created = otherThread.execute( createNode( slave2, LABEL.name(), PROPERTY_KEY, "value4" ) );
 
             assertThat( otherThread, isWaiting() );
 
@@ -166,32 +158,20 @@ public void shouldAllowOtherHostToCompleteIfFirstHostRollsBackTransaction() thro
         assertTrue( "creating data that conflicts only with rolled back data should pass", created.get() );
     }
 
-    private ClusterManager.ManagedCluster startClusterSeededWith( File seedDir )
+    private static Listener<GraphDatabaseService> uniquenessConstraint( final Label label, final String propertyKey )
     {
-        ClusterManager.ManagedCluster cluster = life
-                .add( new ClusterManager.Builder( targetDir.directory() ).withSeedDir( seedDir ).build() )
-                .getDefaultCluster();
-        cluster.await( allSeesAllAsAvailable() );
-        return cluster;
-    }
-
-    private File databaseWithUniquenessConstraint( String label, String propertyKey )
-    {
-        File storeDir = new File( targetDir.directory(), "seed" );
-        GraphDatabaseService graphDb = new TestGraphDatabaseFactory().newEmbeddedDatabase( storeDir.getAbsolutePath() );
-        try
+        return new Listener<GraphDatabaseService>()
         {
-            try ( Transaction tx = graphDb.beginTx() )
+            @Override
+            public void receive( GraphDatabaseService db )
             {
-                graphDb.schema().constraintFor( label( label ) ).assertPropertyIsUnique( propertyKey ).create();
+                try ( Transaction tx = db.beginTx() )
+                {
+                    db.schema().constraintFor( label ).assertPropertyIsUnique( propertyKey ).create();
 
-                tx.success();
+                    tx.success();
+                }
             }
-        }
-        finally
-        {
-            graphDb.shutdown();
-        }
-        return storeDir;
+        };
     }
 }

enterprise/ha/src/test/java/org/neo4j/kernel/ha/HaLoggingIT.java

@@ -49,7 +49,7 @@ public void setup() throws Exception
     {
         cluster = clusterRule
                   .withProvider( clusterWithAdditionalClients( 2, 1 ) )
-                  .availabilityChecks( masterAvailable(), masterSeesMembers( 3 ), allSeesAllAsJoined() )
+                  .withAvailabilityChecks( masterAvailable(), masterSeesMembers( 3 ), allSeesAllAsJoined() )
                   .startCluster();
     }