From cef4ad4d39aa42ce1c6735ff06215a2216cbb5ec Mon Sep 17 00:00:00 2001 From: MishaDemianenko Date: Tue, 21 Aug 2018 13:00:58 +0200 Subject: [PATCH] Introduce composite guard for editions with multiple databases. Move global guard to edition module. --- .../runtime/TransactionStateMachineV1SPI.java | 3 +- .../TransactionStateMachineV1SPITest.java | 7 ++-- .../neo4j/locking/QueryExecutionLocksIT.java | 4 +- .../org/neo4j/kernel/NeoStoreDataSource.java | 3 +- .../neo4j/kernel/api/KernelTransaction.java | 4 +- .../api/txtracking/TransactionIdTracker.java | 6 +-- .../availability/AvailabilityGuard.java | 41 +++++++++++++++++++ .../availability/DatabaseAvailability.java | 4 +- .../DatabaseAvailabilityGuard.java | 11 ++++- .../kernel/availability/StartupWaiter.java | 6 +-- .../availability/UnavailableException.java | 2 +- .../api/KernelTransactionImplementation.java | 8 ++-- .../kernel/impl/api/KernelTransactions.java | 6 +-- .../kernel/DatabaseAvailabilityGuardTest.java | 3 +- .../txtracking/TransactionIdTrackerTest.java | 3 +- .../builtinprocs/StubKernelTransaction.java | 4 +- .../impl/api/KernelTransactionTestBase.java | 3 +- .../impl/api/KernelTransactionsTest.java | 7 ++-- .../facade/GraphDatabaseFacadeFactory.java | 2 +- .../graphdb/factory/module/EditionModule.java | 20 +++++++++ .../ModularDatabaseCreationContext.java | 2 +- .../factory/module/PlatformModule.java | 10 ----- .../causalclustering/ReplicationModule.java | 5 ++- .../catchup/storecopy/LocalDatabase.java | 5 ++- .../core/EnterpriseCoreEditionModule.java | 7 ++-- .../core/replication/RaftReplicator.java | 10 ++--- .../EnterpriseReadReplicaEditionModule.java | 2 +- .../catchup/storecopy/LocalDatabaseTest.java | 11 ++--- .../scenarios/ReadReplicaReplicationIT.java | 3 +- .../org/neo4j/kernel/ha/PullerFactory.java | 10 ++--- .../neo4j/kernel/ha/SlaveUpdatePuller.java | 10 ++--- .../HighAvailabilityMemberStateMachine.java | 6 +-- .../modeswitch/LockManagerSwitcher.java | 10 ++--- .../factory/HighlyAvailableEditionModule.java | 16 ++++---- .../kernel/ha/lock/SlaveLockManager.java | 10 ++--- .../kernel/ha/lock/SlaveLocksClient.java | 10 ++--- ...ighAvailabilityMemberStateMachineTest.java | 23 ++++++----- .../builtinprocs/StubKernelTransaction.java | 4 +- 38 files changed, 187 insertions(+), 114 deletions(-) create mode 100644 community/kernel/src/main/java/org/neo4j/kernel/availability/AvailabilityGuard.java diff --git a/community/bolt/src/main/java/org/neo4j/bolt/v1/runtime/TransactionStateMachineV1SPI.java b/community/bolt/src/main/java/org/neo4j/bolt/v1/runtime/TransactionStateMachineV1SPI.java index 08589fe17b8f6..d7d49a9adf5f0 100644 --- a/community/bolt/src/main/java/org/neo4j/bolt/v1/runtime/TransactionStateMachineV1SPI.java +++ b/community/bolt/src/main/java/org/neo4j/bolt/v1/runtime/TransactionStateMachineV1SPI.java @@ -37,6 +37,7 @@ import org.neo4j.kernel.GraphDatabaseQueryService; import org.neo4j.kernel.api.KernelTransaction; import org.neo4j.kernel.api.txtracking.TransactionIdTracker; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; import org.neo4j.kernel.impl.core.ThreadToStatementContextBridge; import org.neo4j.kernel.impl.coreapi.InternalTransaction; @@ -158,7 +159,7 @@ private InternalTransaction beginTransaction( KernelTransaction.Type type, Login private static TransactionIdTracker newTransactionIdTracker( GraphDatabaseAPI db ) { Supplier transactionIdStoreSupplier = db.getDependencyResolver().provideDependency( TransactionIdStore.class ); - DatabaseAvailabilityGuard guard = resolveDependency( db, DatabaseAvailabilityGuard.class ); + AvailabilityGuard guard = resolveDependency( db, DatabaseAvailabilityGuard.class ); return new TransactionIdTracker( transactionIdStoreSupplier, guard ); } diff --git a/community/bolt/src/test/java/org/neo4j/bolt/v1/runtime/TransactionStateMachineV1SPITest.java b/community/bolt/src/test/java/org/neo4j/bolt/v1/runtime/TransactionStateMachineV1SPITest.java index ea2b20d5b9511..383579b074c06 100644 --- a/community/bolt/src/test/java/org/neo4j/bolt/v1/runtime/TransactionStateMachineV1SPITest.java +++ b/community/bolt/src/test/java/org/neo4j/bolt/v1/runtime/TransactionStateMachineV1SPITest.java @@ -31,6 +31,7 @@ import org.neo4j.graphdb.DependencyResolver; import org.neo4j.internal.kernel.api.exceptions.TransactionFailureException; import org.neo4j.kernel.GraphDatabaseQueryService; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; import org.neo4j.kernel.impl.core.ThreadToStatementContextBridge; import org.neo4j.kernel.impl.query.QueryExecutionEngine; @@ -62,7 +63,7 @@ public void throwsWhenTxAwaitDurationExpires() Duration txAwaitDuration = Duration.ofSeconds( 42 ); FakeClock clock = new FakeClock(); - DatabaseAvailabilityGuard databaseAvailabilityGuard = spy( new DatabaseAvailabilityGuard( DEFAULT_DATABASE_NAME, clock, NullLog.getInstance() ) ); + AvailabilityGuard databaseAvailabilityGuard = spy( new DatabaseAvailabilityGuard( DEFAULT_DATABASE_NAME, clock, NullLog.getInstance() ) ); when( databaseAvailabilityGuard.isAvailable() ).then( invocation -> { // move clock forward on the first availability check @@ -118,12 +119,12 @@ private static TransactionIdStore fixedTxIdStore( long lastClosedTransactionId ) private static TransactionStateMachineV1SPI createTxSpi( Supplier txIdStore, Duration txAwaitDuration, Clock clock ) { - DatabaseAvailabilityGuard databaseAvailabilityGuard = new DatabaseAvailabilityGuard( DEFAULT_DATABASE_NAME, clock, NullLog.getInstance() ); + AvailabilityGuard databaseAvailabilityGuard = new DatabaseAvailabilityGuard( DEFAULT_DATABASE_NAME, clock, NullLog.getInstance() ); return createTxSpi( txIdStore, txAwaitDuration, databaseAvailabilityGuard, clock ); } private static TransactionStateMachineV1SPI createTxSpi( Supplier txIdStore, Duration txAwaitDuration, - DatabaseAvailabilityGuard databaseAvailabilityGuard, Clock clock ) + AvailabilityGuard databaseAvailabilityGuard, Clock clock ) { QueryExecutionEngine queryExecutionEngine = mock( QueryExecutionEngine.class ); diff --git a/community/community-it/kernel-it/src/test/java/org/neo4j/locking/QueryExecutionLocksIT.java b/community/community-it/kernel-it/src/test/java/org/neo4j/locking/QueryExecutionLocksIT.java index 2443e44107f13..23759e9e16bbd 100644 --- a/community/community-it/kernel-it/src/test/java/org/neo4j/locking/QueryExecutionLocksIT.java +++ b/community/community-it/kernel-it/src/test/java/org/neo4j/locking/QueryExecutionLocksIT.java @@ -65,7 +65,7 @@ import org.neo4j.kernel.api.exceptions.Status; import org.neo4j.kernel.api.query.ExecutingQuery; import org.neo4j.kernel.api.txstate.TxStateHolder; -import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.impl.api.ClockContext; import org.neo4j.kernel.impl.core.ThreadToStatementContextBridge; import org.neo4j.kernel.impl.coreapi.InternalTransaction; @@ -797,7 +797,7 @@ public void setMetaData( Map metaData ) } @Override - public DatabaseAvailabilityGuard getAvailabilityGuard() + public AvailabilityGuard getAvailabilityGuard() { return internal.getAvailabilityGuard(); } diff --git a/community/kernel/src/main/java/org/neo4j/kernel/NeoStoreDataSource.java b/community/kernel/src/main/java/org/neo4j/kernel/NeoStoreDataSource.java index 6fe919554dff4..46645478a3ae0 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/NeoStoreDataSource.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/NeoStoreDataSource.java @@ -45,6 +45,7 @@ import org.neo4j.kernel.api.explicitindex.AutoIndexing; import org.neo4j.kernel.api.index.NodePropertyAccessor; import org.neo4j.kernel.api.labelscan.LabelScanStore; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.availability.DatabaseAvailability; import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; import org.neo4j.kernel.configuration.Config; @@ -569,7 +570,7 @@ private void buildRecovery( private NeoStoreKernelModule buildKernel( LogFiles logFiles, TransactionAppender appender, IndexingService indexingService, DatabaseSchemaState databaseSchemaState, LabelScanStore labelScanStore, StorageEngine storageEngine, IndexConfigStore indexConfigStore, TransactionIdStore transactionIdStore, - DatabaseAvailabilityGuard databaseAvailabilityGuard, SystemNanoClock clock, NodePropertyAccessor nodePropertyAccessor ) + AvailabilityGuard databaseAvailabilityGuard, SystemNanoClock clock, NodePropertyAccessor nodePropertyAccessor ) { AtomicReference cpuClockRef = setupCpuClockAtomicReference(); AtomicReference heapAllocationRef = setupHeapAllocationAtomicReference(); diff --git a/community/kernel/src/main/java/org/neo4j/kernel/api/KernelTransaction.java b/community/kernel/src/main/java/org/neo4j/kernel/api/KernelTransaction.java index ec043ead34f22..22161cc6d0ef7 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/api/KernelTransaction.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/api/KernelTransaction.java @@ -32,7 +32,7 @@ import org.neo4j.internal.kernel.api.security.AuthSubject; import org.neo4j.internal.kernel.api.security.LoginContext; import org.neo4j.internal.kernel.api.security.SecurityContext; -import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.impl.api.ClockContext; import org.neo4j.storageengine.api.schema.IndexDescriptor; @@ -181,7 +181,7 @@ interface CloseListener /** * @return database availability guard of database this transaction was started against. */ - DatabaseAvailabilityGuard getAvailabilityGuard(); + AvailabilityGuard getAvailabilityGuard(); @FunctionalInterface interface Revertable extends AutoCloseable diff --git a/community/kernel/src/main/java/org/neo4j/kernel/api/txtracking/TransactionIdTracker.java b/community/kernel/src/main/java/org/neo4j/kernel/api/txtracking/TransactionIdTracker.java index 0c20bee57e533..01b56207d24b6 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/api/txtracking/TransactionIdTracker.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/api/txtracking/TransactionIdTracker.java @@ -25,7 +25,7 @@ import org.neo4j.internal.kernel.api.exceptions.TransactionFailureException; import org.neo4j.kernel.api.exceptions.Status; -import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.impl.transaction.log.TransactionIdStore; import static org.neo4j.kernel.impl.transaction.log.TransactionIdStore.BASE_TX_ID; @@ -37,9 +37,9 @@ public class TransactionIdTracker { private final Supplier transactionIdStoreSupplier; - private final DatabaseAvailabilityGuard databaseAvailabilityGuard; + private final AvailabilityGuard databaseAvailabilityGuard; - public TransactionIdTracker( Supplier transactionIdStoreSupplier, DatabaseAvailabilityGuard databaseAvailabilityGuard ) + public TransactionIdTracker( Supplier transactionIdStoreSupplier, AvailabilityGuard databaseAvailabilityGuard ) { this.databaseAvailabilityGuard = databaseAvailabilityGuard; this.transactionIdStoreSupplier = transactionIdStoreSupplier; diff --git a/community/kernel/src/main/java/org/neo4j/kernel/availability/AvailabilityGuard.java b/community/kernel/src/main/java/org/neo4j/kernel/availability/AvailabilityGuard.java new file mode 100644 index 0000000000000..6a11ade3d6ff0 --- /dev/null +++ b/community/kernel/src/main/java/org/neo4j/kernel/availability/AvailabilityGuard.java @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2002-2018 "Neo4j," + * Neo4j Sweden AB [http://neo4j.com] + * + * This file is part of Neo4j. + * + * Neo4j is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package org.neo4j.kernel.availability; + +public interface AvailabilityGuard +{ + void require( AvailabilityRequirement requirement ); + + void fulfill( AvailabilityRequirement requirement ); + + boolean isAvailable(); + + boolean isShutdown(); + + boolean isAvailable( long millis ); + + void checkAvailable() throws UnavailableException; + + void await( long millis ) throws UnavailableException; + + void addListener( AvailabilityListener listener ); + + void removeListener( AvailabilityListener listener ); +} diff --git a/community/kernel/src/main/java/org/neo4j/kernel/availability/DatabaseAvailability.java b/community/kernel/src/main/java/org/neo4j/kernel/availability/DatabaseAvailability.java index b10953a557517..929e65e2a916b 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/availability/DatabaseAvailability.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/availability/DatabaseAvailability.java @@ -35,13 +35,13 @@ public class DatabaseAvailability extends LifecycleAdapter { private static final AvailabilityRequirement AVAILABILITY_REQUIREMENT = new DescriptiveAvailabilityRequirement( "Database available" ); - private final DatabaseAvailabilityGuard databaseAvailabilityGuard; + private final AvailabilityGuard databaseAvailabilityGuard; private final TransactionCounters transactionCounters; private final Clock clock; private final long awaitActiveTransactionDeadlineMillis; private volatile boolean started; - public DatabaseAvailability( DatabaseAvailabilityGuard databaseAvailabilityGuard, TransactionCounters transactionCounters, Clock clock, + public DatabaseAvailability( AvailabilityGuard databaseAvailabilityGuard, TransactionCounters transactionCounters, Clock clock, long awaitActiveTransactionDeadlineMillis ) { this.databaseAvailabilityGuard = databaseAvailabilityGuard; diff --git a/community/kernel/src/main/java/org/neo4j/kernel/availability/DatabaseAvailabilityGuard.java b/community/kernel/src/main/java/org/neo4j/kernel/availability/DatabaseAvailabilityGuard.java index 4ca1f96eca06d..4d8b13c1c9ed9 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/availability/DatabaseAvailabilityGuard.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/availability/DatabaseAvailabilityGuard.java @@ -37,7 +37,7 @@ * Consumers determine if it is ok to call the database using {@link #isAvailable()}, * or await availability using {@link #isAvailable(long)}. */ -public class DatabaseAvailabilityGuard +public class DatabaseAvailabilityGuard implements AvailabilityGuard { private static final String DATABASE_AVAILABLE_MSG = "Fulfilling of requirement makes database %s available: %s."; private static final String DATABASE_UNAVAILABLE_MSG = "Requirement makes database %s unavailable: %s."; @@ -63,6 +63,7 @@ public DatabaseAvailabilityGuard( String databaseName, Clock clock, Log log ) * * @param requirement the requirement object */ + @Override public void require( AvailabilityRequirement requirement ) { if ( !blockingRequirements.add( requirement ) ) @@ -85,6 +86,7 @@ public void require( AvailabilityRequirement requirement ) * * @param requirement the requirement object */ + @Override public void fulfill( AvailabilityRequirement requirement ) { if ( !blockingRequirements.remove( requirement ) ) @@ -126,6 +128,7 @@ public void shutdown() * * @return true if there are no requirements waiting to be fulfilled and the guard has not been shutdown */ + @Override public boolean isAvailable() { return availability() == Availability.AVAILABLE; @@ -134,6 +137,7 @@ public boolean isAvailable() /** * Check if the database has been shut down. */ + @Override public boolean isShutdown() { return availability() == Availability.SHUTDOWN; @@ -145,6 +149,7 @@ public boolean isShutdown() * @param millis to wait for availability * @return true if there are no requirements waiting to be fulfilled and the guard has not been shutdown */ + @Override public boolean isAvailable( long millis ) { return availability( millis ) == Availability.AVAILABLE; @@ -156,6 +161,7 @@ public boolean isAvailable( long millis ) * * @throws UnavailableException if not available. */ + @Override public void checkAvailable() throws UnavailableException { await( 0 ); @@ -167,6 +173,7 @@ public void checkAvailable() throws UnavailableException * @param millis to wait for availability * @throws UnavailableException thrown when the timeout has been exceeded or the guard has been shutdown */ + @Override public void await( long millis ) throws UnavailableException { Availability availability = availability( millis ); @@ -231,6 +238,7 @@ private Availability availability( long millis ) * * @param listener the listener to receive callbacks when availability changes */ + @Override public void addListener( AvailabilityListener listener ) { listeners.add( listener ); @@ -241,6 +249,7 @@ public void addListener( AvailabilityListener listener ) * * @param listener the listener to remove */ + @Override public void removeListener( AvailabilityListener listener ) { listeners.remove( listener ); diff --git a/community/kernel/src/main/java/org/neo4j/kernel/availability/StartupWaiter.java b/community/kernel/src/main/java/org/neo4j/kernel/availability/StartupWaiter.java index 3100093baa567..707d401af6dfc 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/availability/StartupWaiter.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/availability/StartupWaiter.java @@ -29,12 +29,12 @@ */ public class StartupWaiter extends LifecycleAdapter { - private final DatabaseAvailabilityGuard databaseAvailabilityGuard; + private final AvailabilityGuard databaseAvailabilityGuard; private final long timeout; - public StartupWaiter( DatabaseAvailabilityGuard databaseAvailabilityGuard, long timeout ) + public StartupWaiter( AvailabilityGuard availabilityGuard, long timeout ) { - this.databaseAvailabilityGuard = databaseAvailabilityGuard; + this.databaseAvailabilityGuard = availabilityGuard; this.timeout = timeout; } diff --git a/community/kernel/src/main/java/org/neo4j/kernel/availability/UnavailableException.java b/community/kernel/src/main/java/org/neo4j/kernel/availability/UnavailableException.java index 71311607d593b..72f34c715e66e 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/availability/UnavailableException.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/availability/UnavailableException.java @@ -23,7 +23,7 @@ public class UnavailableException extends Exception implements Status.HasStatus { - UnavailableException( String message ) + public UnavailableException( String message ) { super( message ); } diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactionImplementation.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactionImplementation.java index 6f9379b6eb538..2254b518e6950 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactionImplementation.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactionImplementation.java @@ -68,7 +68,7 @@ import org.neo4j.kernel.api.txstate.ExplicitIndexTransactionState; import org.neo4j.kernel.api.txstate.TransactionState; import org.neo4j.kernel.api.txstate.TxStateHolder; -import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.impl.api.index.IndexingProvidersService; import org.neo4j.kernel.impl.api.state.ConstraintIndexCreator; import org.neo4j.kernel.impl.api.state.TxState; @@ -143,7 +143,7 @@ public class KernelTransactionImplementation implements KernelTransaction, TxSta private final TransactionMonitor transactionMonitor; private final PageCursorTracerSupplier cursorTracerSupplier; private final VersionContextSupplier versionContextSupplier; - private final DatabaseAvailabilityGuard databaseAvailabilityGuard; + private final AvailabilityGuard databaseAvailabilityGuard; private final StorageReader storageReader; private final ClockContext clocks; private final AccessCapability accessCapability; @@ -196,7 +196,7 @@ public KernelTransactionImplementation( StatementOperationParts statementOperati AccessCapability accessCapability, AutoIndexing autoIndexing, ExplicitIndexStore explicitIndexStore, VersionContextSupplier versionContextSupplier, CollectionsFactorySupplier collectionsFactorySupplier, ConstraintSemantics constraintSemantics, SchemaState schemaState, IndexingProvidersService indexProviders, TokenHolders tokenHolders, Dependencies dataSourceDependencies, - DatabaseAvailabilityGuard databaseAvailabilityGuard ) + AvailabilityGuard databaseAvailabilityGuard ) { this.schemaWriteGuard = schemaWriteGuard; this.hooks = hooks; @@ -395,7 +395,7 @@ public void setMetaData( Map data ) } @Override - public DatabaseAvailabilityGuard getAvailabilityGuard() + public AvailabilityGuard getAvailabilityGuard() { return databaseAvailabilityGuard; } diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactions.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactions.java index ac66823cb3b96..5a1db81cb3cbe 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactions.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactions.java @@ -39,7 +39,7 @@ import org.neo4j.kernel.api.exceptions.Status; import org.neo4j.kernel.api.explicitindex.AutoIndexing; import org.neo4j.kernel.api.txstate.ExplicitIndexTransactionState; -import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.impl.api.index.IndexingProvidersService; import org.neo4j.kernel.impl.api.state.ConstraintIndexCreator; import org.neo4j.kernel.impl.api.state.ExplicitIndexTransactionStateImpl; @@ -86,7 +86,7 @@ public class KernelTransactions extends LifecycleAdapter implements Supplier cpuClockRef, AtomicReference heapAllocationRef, AccessCapability accessCapability, AutoIndexing autoIndexing, ExplicitIndexStore explicitIndexStore, VersionContextSupplier versionContextSupplier, diff --git a/community/kernel/src/test/java/org/neo4j/kernel/DatabaseAvailabilityGuardTest.java b/community/kernel/src/test/java/org/neo4j/kernel/DatabaseAvailabilityGuardTest.java index c18b86b29b011..65c25effedeb4 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/DatabaseAvailabilityGuardTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/DatabaseAvailabilityGuardTest.java @@ -25,6 +25,7 @@ import java.time.Clock; import java.util.concurrent.atomic.AtomicBoolean; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.availability.AvailabilityListener; import org.neo4j.kernel.availability.AvailabilityRequirement; import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; @@ -63,7 +64,7 @@ public void logOnAvailabilityChange() { // Given Log log = mock( Log.class ); - DatabaseAvailabilityGuard databaseAvailabilityGuard = getDatabaseAvailabilityGuard( clock, log ); + AvailabilityGuard databaseAvailabilityGuard = getDatabaseAvailabilityGuard( clock, log ); // When starting out verifyZeroInteractions( log ); diff --git a/community/kernel/src/test/java/org/neo4j/kernel/api/txtracking/TransactionIdTrackerTest.java b/community/kernel/src/test/java/org/neo4j/kernel/api/txtracking/TransactionIdTrackerTest.java index 5ecd137dee07f..f2e6fe578bbd4 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/api/txtracking/TransactionIdTrackerTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/api/txtracking/TransactionIdTrackerTest.java @@ -27,6 +27,7 @@ import org.neo4j.internal.kernel.api.exceptions.TransactionFailureException; import org.neo4j.kernel.api.exceptions.Status; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; import org.neo4j.kernel.impl.transaction.log.TransactionIdStore; @@ -47,7 +48,7 @@ public class TransactionIdTrackerTest private static final Duration DEFAULT_DURATION = ofSeconds( 10 ); private final TransactionIdStore transactionIdStore = mock( TransactionIdStore.class ); - private final DatabaseAvailabilityGuard databaseAvailabilityGuard = mock( DatabaseAvailabilityGuard.class ); + private final AvailabilityGuard databaseAvailabilityGuard = mock( DatabaseAvailabilityGuard.class ); private TransactionIdTracker transactionIdTracker; diff --git a/community/kernel/src/test/java/org/neo4j/kernel/builtinprocs/StubKernelTransaction.java b/community/kernel/src/test/java/org/neo4j/kernel/builtinprocs/StubKernelTransaction.java index 8d8b2a187f162..c7d6dc1104ae2 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/builtinprocs/StubKernelTransaction.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/builtinprocs/StubKernelTransaction.java @@ -44,7 +44,7 @@ import org.neo4j.kernel.api.KernelTransaction; import org.neo4j.kernel.api.Statement; import org.neo4j.kernel.api.exceptions.Status; -import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.impl.api.ClockContext; import org.neo4j.storageengine.api.schema.IndexDescriptor; @@ -284,7 +284,7 @@ public void setMetaData( Map metaData ) } @Override - public DatabaseAvailabilityGuard getAvailabilityGuard() + public AvailabilityGuard getAvailabilityGuard() { throw new UnsupportedOperationException( "not implemented" ); } diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionTestBase.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionTestBase.java index 89b6b0fb4b181..d5804294af6a7 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionTestBase.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionTestBase.java @@ -39,6 +39,7 @@ import org.neo4j.io.pagecache.tracing.cursor.context.EmptyVersionContextSupplier; import org.neo4j.kernel.api.explicitindex.AutoIndexing; import org.neo4j.kernel.api.txstate.ExplicitIndexTransactionState; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; import org.neo4j.kernel.configuration.Config; import org.neo4j.kernel.impl.api.index.IndexingService; @@ -101,7 +102,7 @@ public class KernelTransactionTestBase protected final TransactionHeaderInformation headerInformation = mock( TransactionHeaderInformation.class ); protected final TransactionHeaderInformationFactory headerInformationFactory = mock( TransactionHeaderInformationFactory.class ); protected final SchemaWriteGuard schemaWriteGuard = mock( SchemaWriteGuard.class ); - protected final DatabaseAvailabilityGuard availabilityGuard = mock( DatabaseAvailabilityGuard.class ); + protected final AvailabilityGuard availabilityGuard = mock( DatabaseAvailabilityGuard.class ); protected final FakeClock clock = Clocks.fakeClock(); protected final Pool txPool = mock( Pool.class ); protected final StatementOperationParts statementOperations = mock( StatementOperationParts.class ); diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionsTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionsTest.java index 0fa0459386f41..a5a3f0fc2e665 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionsTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionsTest.java @@ -44,6 +44,7 @@ import org.neo4j.kernel.api.exceptions.Status; import org.neo4j.kernel.api.explicitindex.AutoIndexing; import org.neo4j.kernel.api.security.AnonymousContext; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; import org.neo4j.kernel.impl.api.index.IndexingProvidersService; import org.neo4j.kernel.impl.api.state.ConstraintIndexCreator; @@ -605,7 +606,7 @@ private static KernelTransactions newKernelTransactions( Locks locks, StorageEng private static KernelTransactions createTransactions( StorageEngine storageEngine, TransactionCommitProcess commitProcess, TransactionIdStore transactionIdStore, Tracers tracers, StatementLocksFactory statementLocksFactory, StatementOperationParts statementOperations, - SystemNanoClock clock, DatabaseAvailabilityGuard databaseAvailabilityGuard ) + SystemNanoClock clock, AvailabilityGuard databaseAvailabilityGuard ) { return new KernelTransactions( statementLocksFactory, null, statementOperations, null, DEFAULT, commitProcess, null, null, new TransactionHooks(), @@ -621,7 +622,7 @@ null, DEFAULT, commitProcess, null, null, new TransactionHooks(), private static TestKernelTransactions createTestTransactions( StorageEngine storageEngine, TransactionCommitProcess commitProcess, TransactionIdStore transactionIdStore, Tracers tracers, StatementLocksFactory statementLocksFactory, StatementOperationParts statementOperations, - SystemNanoClock clock, DatabaseAvailabilityGuard databaseAvailabilityGuard ) + SystemNanoClock clock, AvailabilityGuard databaseAvailabilityGuard ) { return new TestKernelTransactions( statementLocksFactory, null, statementOperations, null, DEFAULT, commitProcess, null, null, new TransactionHooks(), mock( TransactionMonitor.class ), databaseAvailabilityGuard, tracers, storageEngine, new Procedures(), transactionIdStore, clock, @@ -672,7 +673,7 @@ private static class TestKernelTransactions extends KernelTransactions SchemaWriteGuard schemaWriteGuard, TransactionHeaderInformationFactory txHeaderFactory, TransactionCommitProcess transactionCommitProcess, IndexConfigStore indexConfigStore, ExplicitIndexProvider explicitIndexProviderLookup, TransactionHooks hooks, - TransactionMonitor transactionMonitor, DatabaseAvailabilityGuard databaseAvailabilityGuard, Tracers tracers, + TransactionMonitor transactionMonitor, AvailabilityGuard databaseAvailabilityGuard, Tracers tracers, StorageEngine storageEngine, Procedures procedures, TransactionIdStore transactionIdStore, SystemNanoClock clock, AccessCapability accessCapability, AutoIndexing autoIndexing, VersionContextSupplier versionContextSupplier, TokenHolders tokenHolders, Dependencies dataSourceDependencies ) diff --git a/community/neo4j/src/main/java/org/neo4j/graphdb/facade/GraphDatabaseFacadeFactory.java b/community/neo4j/src/main/java/org/neo4j/graphdb/facade/GraphDatabaseFacadeFactory.java index 19e795a198a0d..6646f3f775963 100644 --- a/community/neo4j/src/main/java/org/neo4j/graphdb/facade/GraphDatabaseFacadeFactory.java +++ b/community/neo4j/src/main/java/org/neo4j/graphdb/facade/GraphDatabaseFacadeFactory.java @@ -177,7 +177,7 @@ public GraphDatabaseFacade initFacade( File storeDir, Config config, final Depen platform.life.add( new VmPauseMonitorComponent( config, platform.logging.getInternalLog( VmPauseMonitorComponent.class ), platform.jobScheduler ) ); platform.dependencies.satisfyDependency( edition.globalTransactionCounter() ); platform.life.add( new PublishPageCacheTracerMetricsAfterStart( platform.tracers.pageCursorTracerSupplier ) ); - platform.life.add( new StartupWaiter( platform.databaseAvailabilityGuard, edition.transactionStartTimeout ) ); + platform.life.add( new StartupWaiter( edition.getGlobalAvailabilityGuard( platform.clock, platform.logging ), edition.transactionStartTimeout ) ); platform.dependencies.satisfyDependency( edition.schemaWriteGuard ); platform.life.setLast( platform.eventHandlers ); diff --git a/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/EditionModule.java b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/EditionModule.java index 4f162504863dc..bceedb5c50f5a 100644 --- a/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/EditionModule.java +++ b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/EditionModule.java @@ -20,6 +20,7 @@ package org.neo4j.graphdb.factory.module; import java.io.File; +import java.time.Clock; import java.util.function.Function; import java.util.function.Predicate; import java.util.function.Supplier; @@ -37,6 +38,8 @@ import org.neo4j.kernel.api.security.AuthManager; import org.neo4j.kernel.api.security.SecurityModule; import org.neo4j.kernel.api.security.UserManagerSupplier; +import org.neo4j.kernel.availability.AvailabilityGuard; +import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; import org.neo4j.kernel.configuration.Config; import org.neo4j.kernel.impl.api.CommitProcessFactory; import org.neo4j.kernel.impl.api.SchemaWriteGuard; @@ -122,6 +125,8 @@ public abstract class EditionModule private final DatabaseTransactionStats databaseStatistics = new DatabaseTransactionStats(); + protected AvailabilityGuard globalAvailabilityGuard; + protected FileSystemWatcherService createFileSystemWatcherService( FileSystemAbstraction fileSystem, File databaseDirectory, LogService logging, JobScheduler jobScheduler, Config config, Predicate fileNameFilter ) { @@ -288,4 +293,19 @@ public TransactionCounters globalTransactionCounter() { return databaseStatistics; } + + public AvailabilityGuard getGlobalAvailabilityGuard( Clock clock, LogService logService ) + { + if ( globalAvailabilityGuard == null ) + { + globalAvailabilityGuard = + new DatabaseAvailabilityGuard( DatabaseManager.DEFAULT_DATABASE_NAME, clock, logService.getInternalLog( DatabaseAvailabilityGuard.class ) ); + } + return globalAvailabilityGuard; + } + + public DatabaseAvailabilityGuard createDatabaseAvailabilityGuard( String databaseName, Clock clock, LogService logService ) + { + return (DatabaseAvailabilityGuard) getGlobalAvailabilityGuard( clock, logService ); + } } diff --git a/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/ModularDatabaseCreationContext.java b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/ModularDatabaseCreationContext.java index 6fb5a2d74dfe0..0017d3c4a8868 100644 --- a/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/ModularDatabaseCreationContext.java +++ b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/ModularDatabaseCreationContext.java @@ -152,7 +152,7 @@ public class ModularDatabaseCreationContext implements DatabaseCreationContext this.procedures = procedures; this.ioLimiter = editionModule.ioLimiter; this.clock = platformModule.clock; - this.databaseAvailabilityGuard = new DatabaseAvailabilityGuard( databaseName, clock, logService.getInternalLog( DatabaseAvailabilityGuard.class ) ); + this.databaseAvailabilityGuard = editionModule.createDatabaseAvailabilityGuard( databaseName, clock, logService ); this.databaseAvailability = new DatabaseAvailability( databaseAvailabilityGuard, transactionStats, platformModule.clock, getAwaitActiveTransactionDeadlineMillis() ); this.coreAPIAvailabilityGuard = new CoreAPIAvailabilityGuard( databaseAvailabilityGuard, editionModule.transactionStartTimeout ); diff --git a/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/PlatformModule.java b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/PlatformModule.java index d58b00134fe98..c2a6d57762069 100644 --- a/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/PlatformModule.java +++ b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/PlatformModule.java @@ -22,7 +22,6 @@ import java.io.File; import java.io.IOException; -import org.neo4j.dbms.database.DatabaseManager; import org.neo4j.graphdb.facade.GraphDatabaseFacadeFactory; import org.neo4j.graphdb.factory.GraphDatabaseSettings; import org.neo4j.graphdb.security.URLAccessRule; @@ -36,7 +35,6 @@ import org.neo4j.io.pagecache.PageCache; import org.neo4j.io.pagecache.tracing.cursor.context.EmptyVersionContextSupplier; import org.neo4j.io.pagecache.tracing.cursor.context.VersionContextSupplier; -import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; import org.neo4j.kernel.configuration.Config; import org.neo4j.kernel.configuration.ConnectorPortRegister; import org.neo4j.kernel.extension.GlobalKernelExtensions; @@ -126,8 +124,6 @@ public class PlatformModule public final JobScheduler jobScheduler; - public final DatabaseAvailabilityGuard databaseAvailabilityGuard; - public final ThreadToStatementContextBridge threadToTransactionBridge; public final SystemNanoClock clock; @@ -211,7 +207,6 @@ public PlatformModule( File providedStoreDir, Config config, DatabaseInfo databa dependencies.satisfyDependency( dataSourceManager ); - databaseAvailabilityGuard = createAvailabilityGuard(); threadToTransactionBridge = dependencies.satisfyDependency( new ThreadToStatementContextBridge() ); kernelExtensionFactories = externalDependencies.kernelExtensions(); @@ -237,11 +232,6 @@ protected VersionContextSupplier createCursorContextSupplier( Config config ) : EmptyVersionContextSupplier.EMPTY; } - protected DatabaseAvailabilityGuard createAvailabilityGuard() - { - return new DatabaseAvailabilityGuard( DatabaseManager.DEFAULT_DATABASE_NAME, clock, logging.getInternalLog( DatabaseAvailabilityGuard.class ) ); - } - protected StoreLocker createStoreLocker() { return new GlobalStoreLocker( fileSystem, storeLayout ); diff --git a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/ReplicationModule.java b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/ReplicationModule.java index 0a6aa67dd025f..40723b9b9564b 100644 --- a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/ReplicationModule.java +++ b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/ReplicationModule.java @@ -42,6 +42,7 @@ import org.neo4j.causalclustering.messaging.Outbound; import org.neo4j.graphdb.factory.module.PlatformModule; import org.neo4j.io.fs.FileSystemAbstraction; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.configuration.Config; import org.neo4j.kernel.lifecycle.LifeSupport; import org.neo4j.logging.LogProvider; @@ -56,7 +57,7 @@ public class ReplicationModule public ReplicationModule( MemberId myself, PlatformModule platformModule, Config config, ConsensusModule consensusModule, Outbound outbound, - File clusterStateDirectory, FileSystemAbstraction fileSystem, LogProvider logProvider ) + File clusterStateDirectory, FileSystemAbstraction fileSystem, LogProvider logProvider, AvailabilityGuard globalAvailabilityGuard ) { LifeSupport life = platformModule.life; @@ -88,7 +89,7 @@ public ReplicationModule( MemberId myself, PlatformModule platformModule, Config progressRetryStrategy, leaderRetryStrategy, availabilityTimeoutMillis, - platformModule.databaseAvailabilityGuard, logProvider, replicationLimit, platformModule.monitors ); + globalAvailabilityGuard, logProvider, replicationLimit, platformModule.monitors ); } public RaftReplicator getReplicator() diff --git a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/catchup/storecopy/LocalDatabase.java b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/catchup/storecopy/LocalDatabase.java index 74f6c5c6dcaf2..608a84ffdfa99 100644 --- a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/catchup/storecopy/LocalDatabase.java +++ b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/catchup/storecopy/LocalDatabase.java @@ -30,6 +30,7 @@ import org.neo4j.causalclustering.identity.StoreId; import org.neo4j.io.layout.DatabaseLayout; import org.neo4j.kernel.NeoStoreDataSource; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.availability.AvailabilityRequirement; import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; import org.neo4j.kernel.availability.DescriptiveAvailabilityRequirement; @@ -55,7 +56,7 @@ public class LocalDatabase implements Lifecycle private final StoreFiles storeFiles; private final DataSourceManager dataSourceManager; private final Supplier databaseHealthSupplier; - private final DatabaseAvailabilityGuard databaseAvailabilityGuard; + private final AvailabilityGuard databaseAvailabilityGuard; private final Log log; private volatile StoreId storeId; @@ -70,7 +71,7 @@ public LocalDatabase( DatabaseLayout databaseLayout, LogFiles logFiles, DataSourceManager dataSourceManager, Supplier databaseHealthSupplier, - DatabaseAvailabilityGuard databaseAvailabilityGuard, + AvailabilityGuard databaseAvailabilityGuard, LogProvider logProvider ) { this.databaseLayout = databaseLayout; diff --git a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/EnterpriseCoreEditionModule.java b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/EnterpriseCoreEditionModule.java index 66b6582b3de26..e815b428d6d06 100644 --- a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/EnterpriseCoreEditionModule.java +++ b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/EnterpriseCoreEditionModule.java @@ -237,7 +237,7 @@ public EnterpriseCoreEditionModule( final PlatformModule platformModule, logFiles, platformModule.dataSourceManager, databaseHealthSupplier, - platformModule.databaseAvailabilityGuard, + getGlobalAvailabilityGuard( platformModule.clock, platformModule.logging ), logProvider ); IdentityModule identityModule = new IdentityModule( platformModule, clusterStateDirectory.get() ); @@ -294,8 +294,9 @@ public EnterpriseCoreEditionModule( final PlatformModule platformModule, dependencies.satisfyDependency( consensusModule.raftMachine() ); - replicationModule = new ReplicationModule( identityModule.myself(), platformModule, config, consensusModule, - loggingOutbound, clusterStateDirectory.get(), fileSystem, logProvider ); + replicationModule = + new ReplicationModule( identityModule.myself(), platformModule, config, consensusModule, loggingOutbound, clusterStateDirectory.get(), + fileSystem, logProvider, getGlobalAvailabilityGuard( platformModule.clock, platformModule.logging ) ); coreStateMachinesModule = new CoreStateMachinesModule( identityModule.myself(), platformModule, clusterStateDirectory.get(), config, replicationModule.getReplicator(), diff --git a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/replication/RaftReplicator.java b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/replication/RaftReplicator.java index 43d2fd40c8b54..928d829f827bb 100644 --- a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/replication/RaftReplicator.java +++ b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/replication/RaftReplicator.java @@ -36,7 +36,7 @@ import org.neo4j.causalclustering.helper.TimeoutStrategy; import org.neo4j.causalclustering.identity.MemberId; import org.neo4j.causalclustering.messaging.Outbound; -import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.availability.UnavailableException; import org.neo4j.kernel.monitoring.Monitors; import org.neo4j.logging.Log; @@ -52,7 +52,7 @@ public class RaftReplicator implements Replicator, LeaderListener private final ProgressTracker progressTracker; private final LocalSessionPool sessionPool; private final TimeoutStrategy progressTimeoutStrategy; - private final DatabaseAvailabilityGuard databaseAvailabilityGuard; + private final AvailabilityGuard availabilityGuard; private final LeaderLocator leaderLocator; private final TimeoutStrategy leaderTimeoutStrategy; private final Log log; @@ -62,7 +62,7 @@ public class RaftReplicator implements Replicator, LeaderListener public RaftReplicator( LeaderLocator leaderLocator, MemberId me, Outbound outbound, LocalSessionPool sessionPool, ProgressTracker progressTracker, TimeoutStrategy progressTimeoutStrategy, TimeoutStrategy leaderTimeoutStrategy, long availabilityTimeoutMillis, - DatabaseAvailabilityGuard databaseAvailabilityGuard, LogProvider logProvider, long replicationLimit, Monitors monitors ) + AvailabilityGuard availabilityGuard, LogProvider logProvider, long replicationLimit, Monitors monitors ) { this.me = me; this.outbound = outbound; @@ -71,7 +71,7 @@ public RaftReplicator( LeaderLocator leaderLocator, MemberId me, Outbound writableCommitProcess = () -> new TransactionRepresentationCommitProcess( localDatabase.dataSource().getDependencyResolver().resolveDependency( TransactionAppender.class ), diff --git a/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/catchup/storecopy/LocalDatabaseTest.java b/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/catchup/storecopy/LocalDatabaseTest.java index 06741c64dd536..430b7f9753f97 100644 --- a/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/catchup/storecopy/LocalDatabaseTest.java +++ b/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/catchup/storecopy/LocalDatabaseTest.java @@ -28,6 +28,7 @@ import java.time.Clock; import org.neo4j.io.layout.DatabaseLayout; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; import org.neo4j.kernel.impl.transaction.log.files.LogFiles; import org.neo4j.kernel.impl.transaction.state.DataSourceManager; @@ -65,7 +66,7 @@ public void availabilityGuardRaisedOnCreation() @Test public void availabilityGuardDroppedOnStart() { - DatabaseAvailabilityGuard guard = newAvailabilityGuard(); + AvailabilityGuard guard = newAvailabilityGuard(); assertTrue( guard.isAvailable() ); LocalDatabase localDatabase = newLocalDatabase( guard ); @@ -110,7 +111,7 @@ public void availabilityGuardRaisedOnStopForStoreCopy() throws Throwable @Test public void availabilityGuardRaisedBeforeDataSourceManagerIsStopped() throws Throwable { - DatabaseAvailabilityGuard guard = mock( DatabaseAvailabilityGuard.class ); + AvailabilityGuard guard = mock( DatabaseAvailabilityGuard.class ); DataSourceManager dataSourceManager = mock( DataSourceManager.class ); LocalDatabase localDatabase = newLocalDatabase( guard, dataSourceManager ); @@ -125,7 +126,7 @@ public void availabilityGuardRaisedBeforeDataSourceManagerIsStopped() throws Thr @Test public void availabilityGuardRaisedBeforeDataSourceManagerIsStoppedForStoreCopy() throws Throwable { - DatabaseAvailabilityGuard guard = mock( DatabaseAvailabilityGuard.class ); + AvailabilityGuard guard = mock( DatabaseAvailabilityGuard.class ); DataSourceManager dataSourceManager = mock( DataSourceManager.class ); LocalDatabase localDatabase = newLocalDatabase( guard, dataSourceManager ); @@ -154,12 +155,12 @@ public void doNotRestartServicesIfAlreadyStarted() verify( dataSourceManager, never() ).start(); } - private static LocalDatabase newLocalDatabase( DatabaseAvailabilityGuard databaseAvailabilityGuard ) + private static LocalDatabase newLocalDatabase( AvailabilityGuard databaseAvailabilityGuard ) { return newLocalDatabase( databaseAvailabilityGuard, mock( DataSourceManager.class ) ); } - private static LocalDatabase newLocalDatabase( DatabaseAvailabilityGuard databaseAvailabilityGuard, DataSourceManager dataSourceManager ) + private static LocalDatabase newLocalDatabase( AvailabilityGuard databaseAvailabilityGuard, DataSourceManager dataSourceManager ) { return new LocalDatabase( mock( DatabaseLayout.class ), mock( StoreFiles.class ), mock( LogFiles.class ), dataSourceManager, () -> mock( DatabaseHealth.class ), databaseAvailabilityGuard, NullLogProvider.getInstance() ); diff --git a/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/scenarios/ReadReplicaReplicationIT.java b/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/scenarios/ReadReplicaReplicationIT.java index 921d25036c502..c302ff1b15d41 100644 --- a/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/scenarios/ReadReplicaReplicationIT.java +++ b/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/scenarios/ReadReplicaReplicationIT.java @@ -70,6 +70,7 @@ import org.neo4j.io.pagecache.monitoring.PageCacheCounters; import org.neo4j.kernel.api.labelscan.LabelScanStore; import org.neo4j.kernel.api.txtracking.TransactionIdTracker; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; import org.neo4j.kernel.impl.factory.GraphDatabaseFacade; import org.neo4j.kernel.impl.store.MetaDataStore; @@ -460,7 +461,7 @@ private static TransactionIdTracker transactionIdTracker( GraphDatabaseAPI datab { Supplier transactionIdStore = database.getDependencyResolver().provideDependency( TransactionIdStore.class ); - DatabaseAvailabilityGuard databaseAvailabilityGuard = + AvailabilityGuard databaseAvailabilityGuard = database.getDependencyResolver().resolveDependency( DatabaseAvailabilityGuard.class ); return new TransactionIdTracker( transactionIdStore, databaseAvailabilityGuard ); } diff --git a/enterprise/ha/src/main/java/org/neo4j/kernel/ha/PullerFactory.java b/enterprise/ha/src/main/java/org/neo4j/kernel/ha/PullerFactory.java index c285a3e0003e1..48621244cab87 100644 --- a/enterprise/ha/src/main/java/org/neo4j/kernel/ha/PullerFactory.java +++ b/enterprise/ha/src/main/java/org/neo4j/kernel/ha/PullerFactory.java @@ -25,7 +25,7 @@ import org.neo4j.cluster.InstanceId; import org.neo4j.dbms.database.DatabaseManager; import org.neo4j.graphdb.DependencyResolver; -import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.ha.cluster.HighAvailabilityMemberStateMachine; import org.neo4j.kernel.ha.com.RequestContextFactory; import org.neo4j.kernel.ha.com.master.Master; @@ -51,14 +51,14 @@ public class PullerFactory private final long pullInterval; private final JobScheduler jobScheduler; private final DependencyResolver dependencyResolver; - private final DatabaseAvailabilityGuard databaseAvailabilityGuard; + private final AvailabilityGuard availabilityGuard; private final HighAvailabilityMemberStateMachine memberStateMachine; private final Monitors monitors; public PullerFactory( RequestContextFactory requestContextFactory, Master master, LastUpdateTime lastUpdateTime, LogProvider logging, InstanceId serverId, InvalidEpochExceptionHandler invalidEpochHandler, long pullInterval, - JobScheduler jobScheduler, DependencyResolver dependencyResolver, DatabaseAvailabilityGuard databaseAvailabilityGuard, + JobScheduler jobScheduler, DependencyResolver dependencyResolver, AvailabilityGuard availabilityGuard, HighAvailabilityMemberStateMachine memberStateMachine, Monitors monitors ) { @@ -71,14 +71,14 @@ public PullerFactory( RequestContextFactory requestContextFactory, Master master this.pullInterval = pullInterval; this.jobScheduler = jobScheduler; this.dependencyResolver = dependencyResolver; - this.databaseAvailabilityGuard = databaseAvailabilityGuard; + this.availabilityGuard = availabilityGuard; this.memberStateMachine = memberStateMachine; this.monitors = monitors; } public SlaveUpdatePuller createSlaveUpdatePuller() { - return new SlaveUpdatePuller( requestContextFactory, master, lastUpdateTime, logging, serverId, databaseAvailabilityGuard, invalidEpochHandler, + return new SlaveUpdatePuller( requestContextFactory, master, lastUpdateTime, logging, serverId, availabilityGuard, invalidEpochHandler, jobScheduler, monitors.newMonitor( SlaveUpdatePuller.Monitor.class ) ); } diff --git a/enterprise/ha/src/main/java/org/neo4j/kernel/ha/SlaveUpdatePuller.java b/enterprise/ha/src/main/java/org/neo4j/kernel/ha/SlaveUpdatePuller.java index f1a7377315f2a..382fac261073c 100644 --- a/enterprise/ha/src/main/java/org/neo4j/kernel/ha/SlaveUpdatePuller.java +++ b/enterprise/ha/src/main/java/org/neo4j/kernel/ha/SlaveUpdatePuller.java @@ -34,7 +34,7 @@ import org.neo4j.com.TransactionStream; import org.neo4j.com.storecopy.TransactionCommittingResponseUnpacker; import org.neo4j.com.storecopy.TransactionObligationFulfiller; -import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.ha.com.RequestContextFactory; import org.neo4j.kernel.ha.com.master.InvalidEpochException; import org.neo4j.kernel.ha.com.master.Master; @@ -145,7 +145,7 @@ public interface Monitor private final CappedLogger comExceptionCappedLogger; private final LastUpdateTime lastUpdateTime; private final InstanceId instanceId; - private final DatabaseAvailabilityGuard databaseAvailabilityGuard; + private final AvailabilityGuard availabilityGuard; private final InvalidEpochExceptionHandler invalidEpochHandler; private final Monitor monitor; private final JobScheduler jobScheduler; @@ -158,7 +158,7 @@ public interface Monitor LastUpdateTime lastUpdateTime, LogProvider logging, InstanceId instanceId, - DatabaseAvailabilityGuard databaseAvailabilityGuard, + AvailabilityGuard availabilityGuard, InvalidEpochExceptionHandler invalidEpochHandler, JobScheduler jobScheduler, Monitor monitor ) @@ -167,7 +167,7 @@ public interface Monitor this.master = master; this.lastUpdateTime = lastUpdateTime; this.instanceId = instanceId; - this.databaseAvailabilityGuard = databaseAvailabilityGuard; + this.availabilityGuard = availabilityGuard; this.invalidEpochHandler = invalidEpochHandler; this.jobScheduler = jobScheduler; this.monitor = monitor; @@ -247,7 +247,7 @@ public void stop() // for removing throw declaration @Override public void pullUpdates() throws InterruptedException { - if ( !isActive() || !databaseAvailabilityGuard.isAvailable( AVAILABILITY_AWAIT_MILLIS ) ) + if ( !isActive() || !availabilityGuard.isAvailable( AVAILABILITY_AWAIT_MILLIS ) ) { return; } diff --git a/enterprise/ha/src/main/java/org/neo4j/kernel/ha/cluster/HighAvailabilityMemberStateMachine.java b/enterprise/ha/src/main/java/org/neo4j/kernel/ha/cluster/HighAvailabilityMemberStateMachine.java index e52f535789e20..d0e74b71c0d2a 100644 --- a/enterprise/ha/src/main/java/org/neo4j/kernel/ha/cluster/HighAvailabilityMemberStateMachine.java +++ b/enterprise/ha/src/main/java/org/neo4j/kernel/ha/cluster/HighAvailabilityMemberStateMachine.java @@ -30,8 +30,8 @@ import org.neo4j.cluster.protocol.election.Election; import org.neo4j.helpers.Listeners; import org.neo4j.helpers.collection.Iterables; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.availability.AvailabilityRequirement; -import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; import org.neo4j.kernel.availability.DescriptiveAvailabilityRequirement; import org.neo4j.kernel.ha.cluster.member.ObservedClusterMembers; import org.neo4j.kernel.ha.cluster.modeswitch.HighAvailabilityModeSwitcher; @@ -59,7 +59,7 @@ public class HighAvailabilityMemberStateMachine extends LifecycleAdapter impleme public static final AvailabilityRequirement AVAILABILITY_REQUIREMENT = new DescriptiveAvailabilityRequirement( "High Availability member state not ready" ); private final HighAvailabilityMemberContext context; - private final DatabaseAvailabilityGuard databaseAvailabilityGuard; + private final AvailabilityGuard databaseAvailabilityGuard; private final ClusterMemberEvents events; private final Log log; @@ -70,7 +70,7 @@ public class HighAvailabilityMemberStateMachine extends LifecycleAdapter impleme private final Election election; public HighAvailabilityMemberStateMachine( HighAvailabilityMemberContext context, - DatabaseAvailabilityGuard databaseAvailabilityGuard, + AvailabilityGuard databaseAvailabilityGuard, ObservedClusterMembers members, ClusterMemberEvents events, Election election, diff --git a/enterprise/ha/src/main/java/org/neo4j/kernel/ha/cluster/modeswitch/LockManagerSwitcher.java b/enterprise/ha/src/main/java/org/neo4j/kernel/ha/cluster/modeswitch/LockManagerSwitcher.java index 965f58d829ed4..82a2fde1b18f5 100644 --- a/enterprise/ha/src/main/java/org/neo4j/kernel/ha/cluster/modeswitch/LockManagerSwitcher.java +++ b/enterprise/ha/src/main/java/org/neo4j/kernel/ha/cluster/modeswitch/LockManagerSwitcher.java @@ -23,7 +23,7 @@ package org.neo4j.kernel.ha.cluster.modeswitch; import org.neo4j.function.Factory; -import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.configuration.Config; import org.neo4j.kernel.ha.DelegateInvocationHandler; import org.neo4j.kernel.ha.com.RequestContextFactory; @@ -37,19 +37,19 @@ public class LockManagerSwitcher extends AbstractComponentSwitcher { private final DelegateInvocationHandler master; private final RequestContextFactory requestContextFactory; - private final DatabaseAvailabilityGuard databaseAvailabilityGuard; + private final AvailabilityGuard availabilityGuard; private final Factory locksFactory; private final LogProvider logProvider; private final Config config; public LockManagerSwitcher( DelegateInvocationHandler delegate, DelegateInvocationHandler master, - RequestContextFactory requestContextFactory, DatabaseAvailabilityGuard databaseAvailabilityGuard, + RequestContextFactory requestContextFactory, AvailabilityGuard availabilityGuard, Factory locksFactory, LogProvider logProvider, Config config ) { super( delegate ); this.master = master; this.requestContextFactory = requestContextFactory; - this.databaseAvailabilityGuard = databaseAvailabilityGuard; + this.availabilityGuard = availabilityGuard; this.locksFactory = locksFactory; this.logProvider = logProvider; this.config = config; @@ -64,7 +64,7 @@ protected Locks getMasterImpl() @Override protected Locks getSlaveImpl() { - return new SlaveLockManager( locksFactory.newInstance(), requestContextFactory, master.cement(), databaseAvailabilityGuard, logProvider, config ); + return new SlaveLockManager( locksFactory.newInstance(), requestContextFactory, master.cement(), availabilityGuard, logProvider, config ); } @Override diff --git a/enterprise/ha/src/main/java/org/neo4j/kernel/ha/factory/HighlyAvailableEditionModule.java b/enterprise/ha/src/main/java/org/neo4j/kernel/ha/factory/HighlyAvailableEditionModule.java index 1d8bb5f428a34..0aa122c15f4f6 100644 --- a/enterprise/ha/src/main/java/org/neo4j/kernel/ha/factory/HighlyAvailableEditionModule.java +++ b/enterprise/ha/src/main/java/org/neo4j/kernel/ha/factory/HighlyAvailableEditionModule.java @@ -74,7 +74,7 @@ import org.neo4j.io.pagecache.PageCache; import org.neo4j.kernel.NeoStoreDataSource; import org.neo4j.kernel.api.net.NetworkConnectionTracker; -import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.configuration.Config; import org.neo4j.kernel.configuration.Settings; import org.neo4j.kernel.configuration.ssl.SslPolicyLoader; @@ -354,8 +354,8 @@ public void elected( String role, InstanceId instanceId, URI electedMember ) ObservedClusterMembers observedMembers = new ObservedClusterMembers( logging.getInternalLogProvider(), clusterClient, clusterClient, clusterEvents, config.get( ClusterSettings.server_id ) ); - memberStateMachine = new HighAvailabilityMemberStateMachine( memberContext, - platformModule.databaseAvailabilityGuard, observedMembers, clusterEvents, clusterClient, + AvailabilityGuard globalAvailabilityGuard = getGlobalAvailabilityGuard( platformModule.clock, platformModule.logging ); + memberStateMachine = new HighAvailabilityMemberStateMachine( memberContext, globalAvailabilityGuard, observedMembers, clusterEvents, clusterClient, logging.getInternalLogProvider() ); members = dependencies.satisfyDependency( new ClusterMembers( observedMembers, memberStateMachine ) ); @@ -366,7 +366,7 @@ public void elected( String role, InstanceId instanceId, URI electedMember ) HighAvailabilityLogger highAvailabilityLogger = new HighAvailabilityLogger( logging.getUserLogProvider(), config.get( ClusterSettings.server_id ) ); - platformModule.databaseAvailabilityGuard.addListener( highAvailabilityLogger ); + globalAvailabilityGuard.addListener( highAvailabilityLogger ); clusterEvents.addClusterMemberListener( highAvailabilityLogger ); clusterClient.addClusterListener( highAvailabilityLogger ); @@ -414,7 +414,7 @@ public void elected( String role, InstanceId instanceId, URI electedMember ) PullerFactory pullerFactory = new PullerFactory( requestContextFactory, master, lastUpdateTime, logging.getInternalLogProvider(), serverId, invalidEpochHandler, config.get( HaSettings.pull_interval ).toMillis(), platformModule.jobScheduler, - dependencies, platformModule.databaseAvailabilityGuard, memberStateMachine, monitors ); + dependencies, globalAvailabilityGuard, memberStateMachine, monitors ); dependencies.satisfyDependency( paxosLife.add( pullerFactory.createObligationFulfiller( updatePullerProxy ) ) ); @@ -497,7 +497,7 @@ public void elected( String role, InstanceId instanceId, URI electedMember ) // Create HA services LocksFactory lockFactory = createLockFactory( config, logging ); locksSupplier = () -> createLockManager( lockFactory, componentSwitcherContainer, config, masterDelegateInvocationHandler, - requestContextFactory, platformModule.databaseAvailabilityGuard, platformModule.clock, logging ); + requestContextFactory, globalAvailabilityGuard, platformModule.clock, logging ); statementLocksFactoryProvider = locks -> createStatementLocksFactory( locks, componentSwitcherContainer, config, logging ); DelegatingTokenHolder propertyKeyTokenHolder = new DelegatingTokenHolder( @@ -691,7 +691,7 @@ private IdGeneratorFactory createIdGeneratorFactory( private static Locks createLockManager( LocksFactory lockFactory, ComponentSwitcherContainer componentSwitcherContainer, Config config, DelegateInvocationHandler masterDelegateInvocationHandler, RequestContextFactory requestContextFactory, - DatabaseAvailabilityGuard databaseAvailabilityGuard, Clock clock, LogService logService ) + AvailabilityGuard availabilityGuard, Clock clock, LogService logService ) { DelegateInvocationHandler lockManagerDelegate = new DelegateInvocationHandler<>( Locks.class ); Locks lockManager = (Locks) newProxyInstance( Locks.class.getClassLoader(), new Class[]{Locks.class}, @@ -700,7 +700,7 @@ private static Locks createLockManager( LocksFactory lockFactory, ComponentSwitc Factory locksFactory = () -> EditionLocksFactories.createLockManager( lockFactory, config, clock ); LockManagerSwitcher lockManagerModeSwitcher = new LockManagerSwitcher( - lockManagerDelegate, masterDelegateInvocationHandler, requestContextFactory, databaseAvailabilityGuard, + lockManagerDelegate, masterDelegateInvocationHandler, requestContextFactory, availabilityGuard, locksFactory, logService.getInternalLogProvider(), config ); componentSwitcherContainer.add( lockManagerModeSwitcher ); diff --git a/enterprise/ha/src/main/java/org/neo4j/kernel/ha/lock/SlaveLockManager.java b/enterprise/ha/src/main/java/org/neo4j/kernel/ha/lock/SlaveLockManager.java index 07da053ce087b..52b99d36e4566 100644 --- a/enterprise/ha/src/main/java/org/neo4j/kernel/ha/lock/SlaveLockManager.java +++ b/enterprise/ha/src/main/java/org/neo4j/kernel/ha/lock/SlaveLockManager.java @@ -22,7 +22,7 @@ */ package org.neo4j.kernel.ha.lock; -import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.configuration.Config; import org.neo4j.kernel.ha.com.RequestContextFactory; import org.neo4j.kernel.ha.com.master.Master; @@ -34,14 +34,14 @@ public class SlaveLockManager implements Locks private final RequestContextFactory requestContextFactory; private final Locks local; private final Master master; - private final DatabaseAvailabilityGuard databaseAvailabilityGuard; + private final AvailabilityGuard availabilityGuard; private final LogProvider logProvider; public SlaveLockManager( Locks localLocks, RequestContextFactory requestContextFactory, Master master, - DatabaseAvailabilityGuard databaseAvailabilityGuard, LogProvider logProvider, Config config ) + AvailabilityGuard availabilityGuard, LogProvider logProvider, Config config ) { this.requestContextFactory = requestContextFactory; - this.databaseAvailabilityGuard = databaseAvailabilityGuard; + this.availabilityGuard = availabilityGuard; this.local = localLocks; this.master = master; this.logProvider = logProvider; @@ -51,7 +51,7 @@ public SlaveLockManager( Locks localLocks, RequestContextFactory requestContextF public Client newClient() { Client client = local.newClient(); - return new SlaveLocksClient( master, client, local, requestContextFactory, databaseAvailabilityGuard, logProvider ); + return new SlaveLocksClient( master, client, local, requestContextFactory, availabilityGuard, logProvider ); } @Override diff --git a/enterprise/ha/src/main/java/org/neo4j/kernel/ha/lock/SlaveLocksClient.java b/enterprise/ha/src/main/java/org/neo4j/kernel/ha/lock/SlaveLocksClient.java index b6371c315a694..37749c14e6393 100644 --- a/enterprise/ha/src/main/java/org/neo4j/kernel/ha/lock/SlaveLocksClient.java +++ b/enterprise/ha/src/main/java/org/neo4j/kernel/ha/lock/SlaveLocksClient.java @@ -40,7 +40,7 @@ import org.neo4j.com.Response; import org.neo4j.graphdb.TransientDatabaseFailureException; import org.neo4j.kernel.DeadlockDetectedException; -import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.availability.UnavailableException; import org.neo4j.kernel.ha.com.RequestContextFactory; import org.neo4j.kernel.ha.com.master.Master; @@ -72,7 +72,7 @@ class SlaveLocksClient implements Locks.Client private final Locks.Client client; private final Locks localLockManager; private final RequestContextFactory requestContextFactory; - private final DatabaseAvailabilityGuard databaseAvailabilityGuard; + private final AvailabilityGuard availabilityGuard; // Using atomic ints to avoid creating garbage through boxing. private final Log log; @@ -80,13 +80,13 @@ class SlaveLocksClient implements Locks.Client private volatile boolean stopped; SlaveLocksClient( Master master, Locks.Client local, Locks localLockManager, - RequestContextFactory requestContextFactory, DatabaseAvailabilityGuard databaseAvailabilityGuard, LogProvider logProvider ) + RequestContextFactory requestContextFactory, AvailabilityGuard availabilityGuard, LogProvider logProvider ) { this.master = master; this.client = local; this.localLockManager = localLockManager; this.requestContextFactory = requestContextFactory; - this.databaseAvailabilityGuard = databaseAvailabilityGuard; + this.availabilityGuard = availabilityGuard; this.log = logProvider.getLog( getClass() ); } @@ -441,7 +441,7 @@ private void makeSureTxHasBeenInitialized() { try { - databaseAvailabilityGuard.checkAvailable(); + availabilityGuard.checkAvailable(); } catch ( UnavailableException e ) { diff --git a/enterprise/ha/src/test/java/org/neo4j/kernel/ha/cluster/HighAvailabilityMemberStateMachineTest.java b/enterprise/ha/src/test/java/org/neo4j/kernel/ha/cluster/HighAvailabilityMemberStateMachineTest.java index 20a055ed437b8..da990f870ccdc 100644 --- a/enterprise/ha/src/test/java/org/neo4j/kernel/ha/cluster/HighAvailabilityMemberStateMachineTest.java +++ b/enterprise/ha/src/test/java/org/neo4j/kernel/ha/cluster/HighAvailabilityMemberStateMachineTest.java @@ -54,6 +54,7 @@ import org.neo4j.io.pagecache.PageCache; import org.neo4j.io.pagecache.PagedFile; import org.neo4j.kernel.NeoStoreDataSource; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.availability.AvailabilityRequirement; import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; import org.neo4j.kernel.configuration.Config; @@ -190,7 +191,7 @@ public void whenInMasterStateLosingQuorumFromTwoInstancesShouldRemainMaster() InstanceId other = new InstanceId( 2 ); HighAvailabilityMemberContext context = new SimpleHighAvailabilityMemberContext( me, false ); - DatabaseAvailabilityGuard guard = mock( DatabaseAvailabilityGuard.class ); + AvailabilityGuard guard = mock( DatabaseAvailabilityGuard.class ); ObservedClusterMembers members = mockClusterMembers( me, emptyList(), singletonList( other ) ); ClusterMemberEvents events = mock( ClusterMemberEvents.class ); @@ -227,7 +228,7 @@ public void whenInMasterStateLosingQuorumFromThreeInstancesShouldGoToPending() InstanceId other2 = new InstanceId( 3 ); HighAvailabilityMemberContext context = new SimpleHighAvailabilityMemberContext( me, false ); - DatabaseAvailabilityGuard guard = mock( DatabaseAvailabilityGuard.class ); + AvailabilityGuard guard = mock( DatabaseAvailabilityGuard.class ); List otherInstances = new LinkedList(); otherInstances.add( other1 ); otherInstances.add( other2 ); @@ -267,7 +268,7 @@ public void whenInSlaveStateLosingOtherSlaveShouldNotPutInPending() InstanceId master = new InstanceId( 2 ); InstanceId otherSlave = new InstanceId( 3 ); HighAvailabilityMemberContext context = new SimpleHighAvailabilityMemberContext( me, false ); - DatabaseAvailabilityGuard guard = mock( DatabaseAvailabilityGuard.class ); + AvailabilityGuard guard = mock( DatabaseAvailabilityGuard.class ); ObservedClusterMembers members = mockClusterMembers( me, singletonList( master ), singletonList( otherSlave ) ); ClusterMemberEvents events = mock( ClusterMemberEvents.class ); @@ -303,7 +304,7 @@ public void whenInSlaveStateWith3MemberClusterLosingMasterShouldPutInPending() InstanceId master = new InstanceId( 2 ); InstanceId otherSlave = new InstanceId( 3 ); HighAvailabilityMemberContext context = new SimpleHighAvailabilityMemberContext( me, false ); - DatabaseAvailabilityGuard guard = mock( DatabaseAvailabilityGuard.class ); + AvailabilityGuard guard = mock( DatabaseAvailabilityGuard.class ); ObservedClusterMembers members = mockClusterMembers( me, singletonList( otherSlave ), singletonList( master ) ); ClusterMemberEvents events = mock( ClusterMemberEvents.class ); @@ -341,7 +342,7 @@ public void whenInSlaveStateWith2MemberClusterLosingMasterShouldPutInPending() InstanceId me = new InstanceId( 1 ); InstanceId master = new InstanceId( 2 ); HighAvailabilityMemberContext context = new SimpleHighAvailabilityMemberContext( me, false ); - DatabaseAvailabilityGuard guard = mock( DatabaseAvailabilityGuard.class ); + AvailabilityGuard guard = mock( DatabaseAvailabilityGuard.class ); ObservedClusterMembers members = mockClusterMembers( me, emptyList(), singletonList( master ) ); ClusterMemberEvents events = mock( ClusterMemberEvents.class ); @@ -378,7 +379,7 @@ public void whenInToMasterStateLosingQuorumShouldPutInPending() InstanceId me = new InstanceId( 1 ); InstanceId other = new InstanceId( 2 ); HighAvailabilityMemberContext context = new SimpleHighAvailabilityMemberContext( me, false ); - DatabaseAvailabilityGuard guard = mock( DatabaseAvailabilityGuard.class ); + AvailabilityGuard guard = mock( DatabaseAvailabilityGuard.class ); ObservedClusterMembers members = mockClusterMembers( me, emptyList(), singletonList( other ) ); ClusterMemberEvents events = mock( ClusterMemberEvents.class ); @@ -413,7 +414,7 @@ public void whenInToSlaveStateLosingQuorumShouldPutInPending() InstanceId me = new InstanceId( 1 ); InstanceId other = new InstanceId( 2 ); HighAvailabilityMemberContext context = new SimpleHighAvailabilityMemberContext( me, false ); - DatabaseAvailabilityGuard guard = mock( DatabaseAvailabilityGuard.class ); + AvailabilityGuard guard = mock( DatabaseAvailabilityGuard.class ); ObservedClusterMembers members = mockClusterMembers( me, emptyList(), singletonList( other ) ); ClusterMemberEvents events = mock( ClusterMemberEvents.class ); @@ -469,7 +470,7 @@ public void whenHAModeSwitcherSwitchesToSlaveTheOtherModeSwitcherDoNotGetTheOldM StoreId storeId = newStoreIdForCurrentVersion(); HighAvailabilityMemberContext context = mock( HighAvailabilityMemberContext.class ); when( context.getMyId() ).thenReturn( me ); - DatabaseAvailabilityGuard guard = mock( DatabaseAvailabilityGuard.class ); + AvailabilityGuard guard = mock( DatabaseAvailabilityGuard.class ); ObservedClusterMembers members = mock( ObservedClusterMembers.class ); ClusterMember masterMember = mock( ClusterMember.class ); when( masterMember.getHARole() ).thenReturn( "master" ); @@ -691,7 +692,7 @@ private HighAvailabilityMemberStateMachine buildMockedStateMachine( HighAvailabi } private HighAvailabilityMemberStateMachine buildMockedStateMachine( HighAvailabilityMemberContext context, - ClusterMemberEvents events, ObservedClusterMembers clusterMembers, DatabaseAvailabilityGuard guard ) + ClusterMemberEvents events, ObservedClusterMembers clusterMembers, AvailabilityGuard guard ) { return new StateMachineBuilder().withContext( context ).withEvents( events ).withClusterMembers( clusterMembers ).withGuard( guard ).build(); @@ -702,7 +703,7 @@ static class StateMachineBuilder HighAvailabilityMemberContext context = mock( HighAvailabilityMemberContext.class ); ClusterMemberEvents events = mock( ClusterMemberEvents.class ); ObservedClusterMembers clusterMembers = mock( ObservedClusterMembers.class ); - DatabaseAvailabilityGuard guard = mock( DatabaseAvailabilityGuard.class ); + AvailabilityGuard guard = mock( DatabaseAvailabilityGuard.class ); Election election = mock( Election.class ); public StateMachineBuilder withContext( HighAvailabilityMemberContext context ) @@ -723,7 +724,7 @@ public StateMachineBuilder withClusterMembers( ObservedClusterMembers clusterMem return this; } - public StateMachineBuilder withGuard( DatabaseAvailabilityGuard guard ) + public StateMachineBuilder withGuard( AvailabilityGuard guard ) { this.guard = guard; return this; diff --git a/enterprise/kernel/src/test/java/org/neo4j/kernel/enterprise/builtinprocs/StubKernelTransaction.java b/enterprise/kernel/src/test/java/org/neo4j/kernel/enterprise/builtinprocs/StubKernelTransaction.java index 7401c72dcbb5e..33ee7c845385a 100644 --- a/enterprise/kernel/src/test/java/org/neo4j/kernel/enterprise/builtinprocs/StubKernelTransaction.java +++ b/enterprise/kernel/src/test/java/org/neo4j/kernel/enterprise/builtinprocs/StubKernelTransaction.java @@ -49,7 +49,7 @@ import org.neo4j.kernel.api.KernelTransaction; import org.neo4j.kernel.api.Statement; import org.neo4j.kernel.api.exceptions.Status; -import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; +import org.neo4j.kernel.availability.AvailabilityGuard; import org.neo4j.kernel.impl.api.ClockContext; import org.neo4j.storageengine.api.schema.IndexDescriptor; @@ -280,7 +280,7 @@ public void setMetaData( Map metaData ) } @Override - public DatabaseAvailabilityGuard getAvailabilityGuard() + public AvailabilityGuard getAvailabilityGuard() { return null; }