Split/Rename/Extract existing Availability infrastructure code.

community/bolt/src/main/java/org/neo4j/bolt/BoltServer.java

@@ -47,10 +47,10 @@
 import org.neo4j.graphdb.factory.GraphDatabaseSettings;
 import org.neo4j.helpers.ListenSocketAddress;
 import org.neo4j.io.fs.FileSystemAbstraction;
-import org.neo4j.kernel.AvailabilityGuard;
 import org.neo4j.kernel.api.net.NetworkConnectionTracker;
 import org.neo4j.kernel.api.security.AuthManager;
 import org.neo4j.kernel.api.security.UserManagerSupplier;
+import org.neo4j.kernel.availability.DatabaseAvailabilityGuard;
 import org.neo4j.kernel.configuration.BoltConnector;
 import org.neo4j.kernel.configuration.Config;
 import org.neo4j.kernel.configuration.ConnectorPortRegister;
@@ -73,7 +73,7 @@ public class BoltServer extends LifecycleAdapter
     private final DatabaseManager databaseManager;
     private final FileSystemAbstraction fs;
     private final JobScheduler jobScheduler;
-    private final AvailabilityGuard availabilityGuard;
+    private final DatabaseAvailabilityGuard databaseAvailabilityGuard;
     private final ConnectorPortRegister connectorPortRegister;
     private final NetworkConnectionTracker connectionTracker;
     private final UsageData usageData;
@@ -87,14 +87,14 @@ public class BoltServer extends LifecycleAdapter
 
     private final LifeSupport life = new LifeSupport();
 
-    public BoltServer( DatabaseManager databaseManager, FileSystemAbstraction fs, JobScheduler jobScheduler, AvailabilityGuard availabilityGuard,
-            ConnectorPortRegister connectorPortRegister, NetworkConnectionTracker connectionTracker, UsageData usageData, Config config,
-            Clock clock, Monitors monitors, LogService logService, DependencyResolver dependencyResolver )
+    public BoltServer( DatabaseManager databaseManager, FileSystemAbstraction fs, JobScheduler jobScheduler,
+            DatabaseAvailabilityGuard databaseAvailabilityGuard, ConnectorPortRegister connectorPortRegister, NetworkConnectionTracker connectionTracker,
+            UsageData usageData, Config config, Clock clock, Monitors monitors, LogService logService, DependencyResolver dependencyResolver )
     {
         this.databaseManager = databaseManager;
         this.fs = fs;
         this.jobScheduler = jobScheduler;
-        this.availabilityGuard = availabilityGuard;
+        this.databaseAvailabilityGuard = databaseAvailabilityGuard;
         this.connectorPortRegister = connectorPortRegister;
         this.connectionTracker = connectionTracker;
         this.usageData = usageData;
@@ -232,6 +232,6 @@ private BoltProtocolFactory createBoltProtocolFactory( BoltConnectionFactory con
 
     private BoltStateMachineFactory createBoltFactory( Authentication authentication, Clock clock )
     {
-        return new BoltStateMachineFactoryImpl( databaseManager, usageData, availabilityGuard, authentication, clock, config, logService );
+        return new BoltStateMachineFactoryImpl( databaseManager, usageData, databaseAvailabilityGuard, authentication, clock, config, logService );
     }
 }

community/bolt/src/main/java/org/neo4j/bolt/runtime/BoltStateMachineFactoryImpl.java

@@ -34,7 +34,7 @@
 import org.neo4j.bolt.v3.runtime.TransactionStateMachineV3SPI;
 import org.neo4j.dbms.database.DatabaseManager;
 import org.neo4j.graphdb.factory.GraphDatabaseSettings;
-import org.neo4j.kernel.AvailabilityGuard;
+import org.neo4j.kernel.availability.DatabaseAvailabilityGuard;
 import org.neo4j.kernel.configuration.Config;
 import org.neo4j.kernel.impl.logging.LogService;
 import org.neo4j.udc.UsageData;
@@ -43,18 +43,18 @@ public class BoltStateMachineFactoryImpl implements BoltStateMachineFactory
 {
     private final DatabaseManager databaseManager;
     private final UsageData usageData;
-    private final AvailabilityGuard availabilityGuard;
+    private final DatabaseAvailabilityGuard databaseAvailabilityGuard;
     private final LogService logging;
     private final Authentication authentication;
     private final Config config;
     private final Clock clock;
 
-    public BoltStateMachineFactoryImpl( DatabaseManager databaseManager, UsageData usageData, AvailabilityGuard availabilityGuard,
+    public BoltStateMachineFactoryImpl( DatabaseManager databaseManager, UsageData usageData, DatabaseAvailabilityGuard databaseAvailabilityGuard,
             Authentication authentication, Clock clock, Config config, LogService logging )
     {
         this.databaseManager = databaseManager;
         this.usageData = usageData;
-        this.availabilityGuard = availabilityGuard;
+        this.databaseAvailabilityGuard = databaseAvailabilityGuard;
         this.logging = logging;
         this.authentication = authentication;
         this.config = config;
@@ -81,7 +81,7 @@ else if ( protocolVersion == BoltProtocolV3.VERSION )
     private BoltStateMachine newStateMachineV1( BoltChannel boltChannel )
     {
         TransactionStateMachineSPI transactionSPI =
-                new TransactionStateMachineV1SPI( databaseManager.getDatabaseFacade( DatabaseManager.DEFAULT_DATABASE_NAME ).get(), availabilityGuard,
+                new TransactionStateMachineV1SPI( databaseManager.getDatabaseFacade( DatabaseManager.DEFAULT_DATABASE_NAME ).get(), databaseAvailabilityGuard,
                         getAwaitDuration(), clock );
         BoltStateMachineSPI boltSPI = new BoltStateMachineV1SPI( boltChannel, usageData, logging, authentication, transactionSPI );
         return new BoltStateMachineV1( boltSPI, boltChannel, clock );
@@ -90,7 +90,7 @@ private BoltStateMachine newStateMachineV1( BoltChannel boltChannel )
     private BoltStateMachine newStateMachineV3( BoltChannel boltChannel )
     {
         TransactionStateMachineSPI transactionSPI =
-                new TransactionStateMachineV3SPI( databaseManager.getDatabaseFacade( DatabaseManager.DEFAULT_DATABASE_NAME ).get(), availabilityGuard,
+                new TransactionStateMachineV3SPI( databaseManager.getDatabaseFacade( DatabaseManager.DEFAULT_DATABASE_NAME ).get(), databaseAvailabilityGuard,
                         getAwaitDuration(), clock );
         BoltStateMachineSPI boltSPI = new BoltStateMachineV1SPI( boltChannel, usageData, logging, authentication, transactionSPI );
         return new BoltStateMachineV3( boltSPI, boltChannel, clock );

community/bolt/src/main/java/org/neo4j/bolt/v1/runtime/TransactionStateMachineV1SPI.java

@@ -34,10 +34,10 @@
 import org.neo4j.internal.kernel.api.exceptions.KernelException;
 import org.neo4j.internal.kernel.api.exceptions.TransactionFailureException;
 import org.neo4j.internal.kernel.api.security.LoginContext;
-import org.neo4j.kernel.AvailabilityGuard;
 import org.neo4j.kernel.GraphDatabaseQueryService;
 import org.neo4j.kernel.api.KernelTransaction;
 import org.neo4j.kernel.api.txtracking.TransactionIdTracker;
+import org.neo4j.kernel.availability.DatabaseAvailabilityGuard;
 import org.neo4j.kernel.impl.core.ThreadToStatementContextBridge;
 import org.neo4j.kernel.impl.coreapi.InternalTransaction;
 import org.neo4j.kernel.impl.coreapi.PropertyContainerLocker;
@@ -68,12 +68,12 @@ public class TransactionStateMachineV1SPI implements TransactionStateMachineSPI
     private final Duration txAwaitDuration;
     private final Clock clock;
 
-    public TransactionStateMachineV1SPI( GraphDatabaseAPI db, AvailabilityGuard availabilityGuard, Duration txAwaitDuration, Clock clock )
+    public TransactionStateMachineV1SPI( GraphDatabaseAPI db, DatabaseAvailabilityGuard databaseAvailabilityGuard, Duration txAwaitDuration, Clock clock )
     {
         this.db = db;
         this.txBridge = db.getDependencyResolver().resolveDependency( ThreadToStatementContextBridge.class );
         this.queryExecutionEngine = db.getDependencyResolver().resolveDependency( QueryExecutionEngine.class );
-        this.transactionIdTracker = newTransactionIdTracker( db, availabilityGuard );
+        this.transactionIdTracker = newTransactionIdTracker( db, databaseAvailabilityGuard );
         this.contextFactory = newTransactionalContextFactory( db );
         this.txAwaitDuration = txAwaitDuration;
         this.clock = clock;
@@ -155,7 +155,7 @@ private InternalTransaction beginTransaction( KernelTransaction.Type type, Login
         return tx;
     }
 
-    private static TransactionIdTracker newTransactionIdTracker( GraphDatabaseAPI db, AvailabilityGuard guard )
+    private static TransactionIdTracker newTransactionIdTracker( GraphDatabaseAPI db, DatabaseAvailabilityGuard guard )
     {
         Supplier<TransactionIdStore> transactionIdStoreSupplier = db.getDependencyResolver().provideDependency( TransactionIdStore.class );
         return new TransactionIdTracker( transactionIdStoreSupplier, guard );

community/bolt/src/main/java/org/neo4j/bolt/v3/runtime/TransactionStateMachineV3SPI.java

@@ -26,17 +26,17 @@
 import org.neo4j.bolt.runtime.BoltResultHandle;
 import org.neo4j.bolt.v1.runtime.TransactionStateMachineV1SPI;
 import org.neo4j.cypher.internal.javacompat.QueryResultProvider;
-import org.neo4j.kernel.AvailabilityGuard;
+import org.neo4j.kernel.availability.DatabaseAvailabilityGuard;
 import org.neo4j.kernel.impl.query.TransactionalContext;
 import org.neo4j.kernel.internal.GraphDatabaseAPI;
 import org.neo4j.values.virtual.MapValue;
 
 public class TransactionStateMachineV3SPI extends TransactionStateMachineV1SPI
 {
 
-    public TransactionStateMachineV3SPI( GraphDatabaseAPI db, AvailabilityGuard availabilityGuard, Duration txAwaitDuration, Clock clock )
+    public TransactionStateMachineV3SPI( GraphDatabaseAPI db, DatabaseAvailabilityGuard databaseAvailabilityGuard, Duration txAwaitDuration, Clock clock )
     {
-        super( db, availabilityGuard, txAwaitDuration, clock );
+        super( db, databaseAvailabilityGuard, txAwaitDuration, clock );
     }
 
     @Override

community/bolt/src/test/java/org/neo4j/bolt/v1/runtime/BoltStateMachineFactoryImplTest.java

@@ -35,8 +35,8 @@
 import org.neo4j.bolt.v3.BoltStateMachineV3;
 import org.neo4j.dbms.database.DatabaseManager;
 import org.neo4j.graphdb.DependencyResolver;
-import org.neo4j.kernel.AvailabilityGuard;
 import org.neo4j.kernel.GraphDatabaseQueryService;
+import org.neo4j.kernel.availability.DatabaseAvailabilityGuard;
 import org.neo4j.kernel.configuration.Config;
 import org.neo4j.kernel.impl.factory.GraphDatabaseFacade;
 import org.neo4j.kernel.impl.logging.NullLogService;
@@ -98,7 +98,8 @@ private static BoltStateMachineFactoryImpl newBoltFactory()
     private static BoltStateMachineFactoryImpl newBoltFactory( DatabaseManager databaseManager )
     {
         return new BoltStateMachineFactoryImpl( databaseManager, new UsageData( new OnDemandJobScheduler() ),
-                new AvailabilityGuard( CLOCK, NullLog.getInstance() ), mock( Authentication.class ), CLOCK, Config.defaults(), NullLogService.getInstance() );
+                new DatabaseAvailabilityGuard( CLOCK, NullLog.getInstance() ), mock( Authentication.class ), CLOCK, Config.defaults(),
+                NullLogService.getInstance() );
     }
 
     private static DatabaseManager newDbMock()

community/bolt/src/test/java/org/neo4j/bolt/v1/runtime/TransactionStateMachineV1SPITest.java

@@ -30,8 +30,8 @@
 
 import org.neo4j.graphdb.DependencyResolver;
 import org.neo4j.internal.kernel.api.exceptions.TransactionFailureException;
-import org.neo4j.kernel.AvailabilityGuard;
 import org.neo4j.kernel.GraphDatabaseQueryService;
+import org.neo4j.kernel.availability.DatabaseAvailabilityGuard;
 import org.neo4j.kernel.impl.core.ThreadToStatementContextBridge;
 import org.neo4j.kernel.impl.query.QueryExecutionEngine;
 import org.neo4j.kernel.impl.transaction.log.TransactionIdStore;
@@ -61,8 +61,8 @@ public void throwsWhenTxAwaitDurationExpires()
         Duration txAwaitDuration = Duration.ofSeconds( 42 );
         FakeClock clock = new FakeClock();
 
-        AvailabilityGuard availabilityGuard = spy( new AvailabilityGuard( clock, NullLog.getInstance() ) );
-        when( availabilityGuard.isAvailable() ).then( invocation ->
+        DatabaseAvailabilityGuard databaseAvailabilityGuard = spy( new DatabaseAvailabilityGuard( clock, NullLog.getInstance() ) );
+        when( databaseAvailabilityGuard.isAvailable() ).then( invocation ->
         {
             // move clock forward on the first availability check
             // this check is executed on every tx id polling iteration
@@ -71,7 +71,7 @@ public void throwsWhenTxAwaitDurationExpires()
             return available;
         } );
 
-        TransactionStateMachineV1SPI txSpi = createTxSpi( txIdStore, txAwaitDuration, availabilityGuard, clock );
+        TransactionStateMachineV1SPI txSpi = createTxSpi( txIdStore, txAwaitDuration, databaseAvailabilityGuard, clock );
 
         Future<Void> result = otherThread.execute( state ->
         {
@@ -117,17 +117,17 @@ private static TransactionIdStore fixedTxIdStore( long lastClosedTransactionId )
     private static TransactionStateMachineV1SPI createTxSpi( Supplier<TransactionIdStore> txIdStore, Duration txAwaitDuration,
             Clock clock )
     {
-        AvailabilityGuard availabilityGuard = new AvailabilityGuard( clock, NullLog.getInstance() );
-        return createTxSpi( txIdStore, txAwaitDuration, availabilityGuard, clock );
+        DatabaseAvailabilityGuard databaseAvailabilityGuard = new DatabaseAvailabilityGuard( clock, NullLog.getInstance() );
+        return createTxSpi( txIdStore, txAwaitDuration, databaseAvailabilityGuard, clock );
     }
 
     private static TransactionStateMachineV1SPI createTxSpi( Supplier<TransactionIdStore> txIdStore, Duration txAwaitDuration,
-            AvailabilityGuard availabilityGuard, Clock clock )
+            DatabaseAvailabilityGuard databaseAvailabilityGuard, Clock clock )
     {
         QueryExecutionEngine queryExecutionEngine = mock( QueryExecutionEngine.class );
 
         DependencyResolver dependencyResolver = mock( DependencyResolver.class );
-        ThreadToStatementContextBridge bridge = new ThreadToStatementContextBridge( availabilityGuard );
+        ThreadToStatementContextBridge bridge = new ThreadToStatementContextBridge( databaseAvailabilityGuard );
         when( dependencyResolver.resolveDependency( ThreadToStatementContextBridge.class ) ).thenReturn( bridge );
         when( dependencyResolver.resolveDependency( QueryExecutionEngine.class ) ).thenReturn( queryExecutionEngine );
         when( dependencyResolver.provideDependency( TransactionIdStore.class ) ).thenReturn( txIdStore );
@@ -139,6 +139,6 @@ private static TransactionStateMachineV1SPI createTxSpi( Supplier<TransactionIdS
         when( queryService.getDependencyResolver() ).thenReturn( dependencyResolver );
         when( dependencyResolver.resolveDependency( GraphDatabaseQueryService.class ) ).thenReturn( queryService );
 
-        return new TransactionStateMachineV1SPI( db, availabilityGuard, txAwaitDuration, clock );
+        return new TransactionStateMachineV1SPI( db, databaseAvailabilityGuard, txAwaitDuration, clock );
     }
 }

community/community-it/bolt-it/src/test/java/org/neo4j/bolt/v3/runtime/integration/SessionExtension.java

@@ -39,9 +39,9 @@
 import org.neo4j.graphdb.config.Setting;
 import org.neo4j.graphdb.factory.GraphDatabaseSettings;
 import org.neo4j.io.IOUtils;
-import org.neo4j.kernel.AvailabilityGuard;
 import org.neo4j.kernel.api.security.AuthManager;
 import org.neo4j.kernel.api.security.UserManagerSupplier;
+import org.neo4j.kernel.availability.DatabaseAvailabilityGuard;
 import org.neo4j.kernel.configuration.Config;
 import org.neo4j.kernel.impl.logging.NullLogService;
 import org.neo4j.kernel.internal.GraphDatabaseAPI;
@@ -83,7 +83,7 @@ public void beforeEach( ExtensionContext extensionContext )
         boltFactory = new BoltStateMachineFactoryImpl(
                 resolver.resolveDependency( DatabaseManager.class ),
                 new UsageData( null ),
-                resolver.resolveDependency( AvailabilityGuard.class ),
+                resolver.resolveDependency( DatabaseAvailabilityGuard.class ),
                 authentication,
                 Clock.systemUTC(),
                 Config.defaults(),

community/community-it/it-test-support/src/main/java/org/neo4j/bolt/v1/runtime/integration/SessionRule.java

@@ -42,9 +42,9 @@
 import org.neo4j.graphdb.DependencyResolver;
 import org.neo4j.graphdb.config.Setting;
 import org.neo4j.graphdb.factory.GraphDatabaseSettings;
-import org.neo4j.kernel.AvailabilityGuard;
 import org.neo4j.kernel.api.security.AuthManager;
 import org.neo4j.kernel.api.security.UserManagerSupplier;
+import org.neo4j.kernel.availability.DatabaseAvailabilityGuard;
 import org.neo4j.kernel.configuration.Config;
 import org.neo4j.kernel.impl.logging.NullLogService;
 import org.neo4j.kernel.impl.transaction.log.TransactionIdStore;
@@ -77,7 +77,7 @@ public void evaluate() throws Throwable
                 boltFactory = new BoltStateMachineFactoryImpl(
                                         databaseManager,
                                         new UsageData( null ),
-                                        resolver.resolveDependency( AvailabilityGuard.class ),
+                                        resolver.resolveDependency( DatabaseAvailabilityGuard.class ),
                                         authentication,
                                         Clock.systemUTC(),
                                         Config.defaults(),

community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/GraphDatabaseServiceTest.java

@@ -29,8 +29,8 @@
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
 
-import org.neo4j.kernel.DatabaseAvailability;
 import org.neo4j.kernel.DeadlockDetectedException;
+import org.neo4j.kernel.availability.DatabaseAvailability;
 import org.neo4j.kernel.impl.MyRelTypes;
 import org.neo4j.test.Barrier;
 import org.neo4j.test.OtherThreadExecutor.WorkerCommand;

community/kernel/src/main/java/org/neo4j/kernel/DatabaseCreationContext.java

@@ -31,6 +31,7 @@
 import org.neo4j.io.pagecache.PageCache;
 import org.neo4j.io.pagecache.tracing.cursor.context.VersionContextSupplier;
 import org.neo4j.kernel.api.explicitindex.AutoIndexing;
+import org.neo4j.kernel.availability.DatabaseAvailabilityGuard;
 import org.neo4j.kernel.configuration.Config;
 import org.neo4j.kernel.extension.KernelExtensionFactory;
 import org.neo4j.kernel.impl.api.CommitProcessFactory;
@@ -123,7 +124,7 @@ public interface DatabaseCreationContext
 
     IOLimiter getIoLimiter();
 
-    AvailabilityGuard getAvailabilityGuard();
+    DatabaseAvailabilityGuard getDatabaseAvailabilityGuard();
 
     SystemNanoClock getClock();