//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void whenInToSlaveStateLosingQuorumShouldPutInPending()
public virtual void WhenInToSlaveStateLosingQuorumShouldPutInPending()
{
// Given
InstanceId me = new InstanceId(1);
InstanceId other = new InstanceId(2);
HighAvailabilityMemberContext context = new SimpleHighAvailabilityMemberContext(me, false);
AvailabilityGuard guard = mock(typeof(DatabaseAvailabilityGuard));
ObservedClusterMembers members = MockClusterMembers(me, emptyList(), singletonList(other));
ClusterMemberEvents events = mock(typeof(ClusterMemberEvents));
ClusterMemberListenerContainer memberListenerContainer = MockAddClusterMemberListener(events);
HighAvailabilityMemberStateMachine stateMachine = BuildMockedStateMachine(context, events, members, guard);
stateMachine.Init();
ClusterMemberListener memberListener = memberListenerContainer.Get();
HAStateChangeListener probe = new HAStateChangeListener();
stateMachine.AddHighAvailabilityMemberListener(probe);
// Send it to MASTER
memberListener.MemberIsAvailable(MASTER, other, URI.create("ha://whatever"), StoreId.DEFAULT);
assertThat(stateMachine.CurrentState, equalTo(HighAvailabilityMemberState.ToSlave));
// When
memberListener.MemberIsFailed(new InstanceId(2));
// Then
assertThat(stateMachine.CurrentState, equalTo(HighAvailabilityMemberState.Pending));
assertThat(probe.InstanceStopsConflict, @is(false));
assertThat(probe.InstanceDetachedConflict, @is(true));
verify(guard, times(1)).require(any(typeof(AvailabilityRequirement)));
}
private static TransactionIdTracker TransactionIdTracker(GraphDatabaseAPI database)
{
System.Func <TransactionIdStore> transactionIdStore = database.DependencyResolver.provideDependency(typeof(TransactionIdStore));
AvailabilityGuard databaseAvailabilityGuard = database.DependencyResolver.resolveDependency(typeof(DatabaseAvailabilityGuard));
return(new TransactionIdTracker(transactionIdStore, databaseAvailabilityGuard));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void whenInMasterStateLosingQuorumFromTwoInstancesShouldRemainMaster()
public virtual void WhenInMasterStateLosingQuorumFromTwoInstancesShouldRemainMaster()
{
// Given
InstanceId me = new InstanceId(1);
InstanceId other = new InstanceId(2);
HighAvailabilityMemberContext context = new SimpleHighAvailabilityMemberContext(me, false);
AvailabilityGuard guard = mock(typeof(DatabaseAvailabilityGuard));
ObservedClusterMembers members = MockClusterMembers(me, emptyList(), singletonList(other));
ClusterMemberEvents events = mock(typeof(ClusterMemberEvents));
ClusterMemberListenerContainer memberListenerContainer = MockAddClusterMemberListener(events);
HighAvailabilityMemberStateMachine stateMachine = BuildMockedStateMachine(context, events, members, guard);
stateMachine.Init();
ClusterMemberListener memberListener = memberListenerContainer.Get();
HAStateChangeListener probe = new HAStateChangeListener();
stateMachine.AddHighAvailabilityMemberListener(probe);
// Send it to MASTER
memberListener.CoordinatorIsElected(me);
memberListener.MemberIsAvailable(MASTER, me, URI.create("ha://whatever"), StoreId.DEFAULT);
assertThat(stateMachine.CurrentState, equalTo(HighAvailabilityMemberState.Master));
// When
memberListener.MemberIsFailed(new InstanceId(2));
// Then
assertThat(stateMachine.CurrentState, equalTo(HighAvailabilityMemberState.Master));
assertThat(probe.InstanceStopsConflict, @is(false));
assertThat(probe.InstanceDetachedConflict, @is(false));
}
private static TransactionIdTracker NewTransactionIdTracker(GraphDatabaseAPI db)
{
System.Func <TransactionIdStore> transactionIdStoreSupplier = Db.DependencyResolver.provideDependency(typeof(TransactionIdStore));
AvailabilityGuard guard = ResolveDependency(db, typeof(DatabaseAvailabilityGuard));
return(new TransactionIdTracker(transactionIdStoreSupplier, guard));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void whenInSlaveStateLosingOtherSlaveShouldNotPutInPending()
public virtual void WhenInSlaveStateLosingOtherSlaveShouldNotPutInPending()
{
// Given
InstanceId me = new InstanceId(1);
InstanceId master = new InstanceId(2);
InstanceId otherSlave = new InstanceId(3);
HighAvailabilityMemberContext context = new SimpleHighAvailabilityMemberContext(me, false);
AvailabilityGuard guard = mock(typeof(DatabaseAvailabilityGuard));
ObservedClusterMembers members = MockClusterMembers(me, singletonList(master), singletonList(otherSlave));
ClusterMemberEvents events = mock(typeof(ClusterMemberEvents));
ClusterMemberListenerContainer memberListenerContainer = MockAddClusterMemberListener(events);
HighAvailabilityMemberStateMachine stateMachine = BuildMockedStateMachine(context, events, members, guard);
stateMachine.Init();
ClusterMemberListener memberListener = memberListenerContainer.Get();
HAStateChangeListener probe = new HAStateChangeListener();
stateMachine.AddHighAvailabilityMemberListener(probe);
// Send it to MASTER
memberListener.MemberIsAvailable(MASTER, master, URI.create("ha://whatever"), StoreId.DEFAULT);
memberListener.MemberIsAvailable(SLAVE, me, URI.create("ha://whatever3"), StoreId.DEFAULT);
memberListener.MemberIsAvailable(SLAVE, otherSlave, URI.create("ha://whatever2"), StoreId.DEFAULT);
assertThat(stateMachine.CurrentState, equalTo(HighAvailabilityMemberState.Slave));
// When
memberListener.MemberIsFailed(otherSlave);
// Then
assertThat(stateMachine.CurrentState, equalTo(HighAvailabilityMemberState.Slave));
assertThat(probe.InstanceStopsConflict, @is(false));
}
public virtual AvailabilityGuard GetGlobalAvailabilityGuard(Clock clock, LogService logService, Config config)
{
if (GlobalAvailabilityGuard == null)
{
GlobalAvailabilityGuard = new DatabaseAvailabilityGuard(config.Get(GraphDatabaseSettings.active_database), clock, logService.GetInternalLog(typeof(DatabaseAvailabilityGuard)));
}
return(GlobalAvailabilityGuard);
}
internal SlaveLocksClient(Master master, Org.Neo4j.Kernel.impl.locking.Locks_Client local, Locks localLockManager, RequestContextFactory requestContextFactory, AvailabilityGuard availabilityGuard, LogProvider logProvider)
{
this._master = master;
this._client = local;
this._localLockManager = localLockManager;
this._requestContextFactory = requestContextFactory;
this._availabilityGuard = availabilityGuard;
this._log = logProvider.getLog(this.GetType());
}
private void TryShutdownAvailabiltyGuard()
{
AvailabilityGuard guard = _availabilityGuardSupplier.get();
if (guard != null)
{
guard.Shutdown();
}
}
public HighAvailabilityMemberStateMachine(HighAvailabilityMemberContext context, AvailabilityGuard databaseAvailabilityGuard, ObservedClusterMembers members, ClusterMemberEvents events, Election election, LogProvider logProvider)
{
this._context = context;
this._databaseAvailabilityGuard = databaseAvailabilityGuard;
this._members = members;
this._events = events;
this._election = election;
this._log = logProvider.getLog(this.GetType());
_state = HighAvailabilityMemberState.Pending;
}
public DatabaseAvailability(AvailabilityGuard databaseAvailabilityGuard, TransactionCounters transactionCounters, Clock clock, long awaitActiveTransactionDeadlineMillis)
{
this._databaseAvailabilityGuard = databaseAvailabilityGuard;
this._transactionCounters = transactionCounters;
this._awaitActiveTransactionDeadlineMillis = awaitActiveTransactionDeadlineMillis;
this._clock = clock;
// On initial setup, deny availability
databaseAvailabilityGuard.Require(_availabilityRequirement);
}
public LocalDatabase(DatabaseLayout databaseLayout, StoreFiles storeFiles, LogFiles logFiles, DataSourceManager dataSourceManager, System.Func <DatabaseHealth> databaseHealthSupplier, AvailabilityGuard availabilityGuard, LogProvider logProvider)
{
this._databaseLayout = databaseLayout;
this._storeFiles = storeFiles;
this._logFiles = logFiles;
this._dataSourceManager = dataSourceManager;
this._databaseHealthSupplier = databaseHealthSupplier;
this._availabilityGuard = availabilityGuard;
this._log = logProvider.getLog(this.GetType());
RaiseAvailabilityGuard(_notStopped);
}
private volatile BinaryLatch _shutdownLatch; // Store under synchronised(this), load in update puller thread
internal SlaveUpdatePuller(RequestContextFactory requestContextFactory, Master master, LastUpdateTime lastUpdateTime, LogProvider logging, InstanceId instanceId, AvailabilityGuard availabilityGuard, InvalidEpochExceptionHandler invalidEpochHandler, JobScheduler jobScheduler, Monitor monitor)
{
this._requestContextFactory = requestContextFactory;
this._master = master;
this._lastUpdateTime = lastUpdateTime;
this._instanceId = instanceId;
this._availabilityGuard = availabilityGuard;
this._invalidEpochHandler = invalidEpochHandler;
this._jobScheduler = jobScheduler;
this._monitor = monitor;
this._logger = logging.getLog(this.GetType());
this._invalidEpochCappedLogger = (new CappedLogger(_logger)).setCountLimit(LogCap);
this._comExceptionCappedLogger = (new CappedLogger(_logger)).setCountLimit(LogCap);
}
public RaftReplicator(LeaderLocator leaderLocator, MemberId me, Outbound <MemberId, Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage> outbound, LocalSessionPool sessionPool, ProgressTracker progressTracker, TimeoutStrategy progressTimeoutStrategy, long availabilityTimeoutMillis, AvailabilityGuard availabilityGuard, LogProvider logProvider, LocalDatabase localDatabase, Monitors monitors)
{
this._me = me;
this._outbound = outbound;
this._progressTracker = progressTracker;
this._sessionPool = sessionPool;
this._progressTimeoutStrategy = progressTimeoutStrategy;
this._availabilityTimeoutMillis = availabilityTimeoutMillis;
this._availabilityGuard = availabilityGuard;
this._log = logProvider.getLog(this.GetType());
this._localDatabase = localDatabase;
this._replicationMonitor = monitors.NewMonitor(typeof(ReplicationMonitor));
this._leaderProvider = new LeaderProvider();
leaderLocator.RegisterListener(this);
}
public KernelTransactions(Config config, StatementLocksFactory statementLocksFactory, ConstraintIndexCreator constraintIndexCreator, StatementOperationParts statementOperations, SchemaWriteGuard schemaWriteGuard, TransactionHeaderInformationFactory txHeaderFactory, TransactionCommitProcess transactionCommitProcess, AuxiliaryTransactionStateManager auxTxStateManager, TransactionHooks hooks, TransactionMonitor transactionMonitor, AvailabilityGuard databaseAvailabilityGuard, Tracers tracers, StorageEngine storageEngine, Procedures procedures, TransactionIdStore transactionIdStore, SystemNanoClock clock, AtomicReference <CpuClock> cpuClockRef, AtomicReference <HeapAllocation> heapAllocationRef, AccessCapability accessCapability, AutoIndexing autoIndexing, ExplicitIndexStore explicitIndexStore, VersionContextSupplier versionContextSupplier, CollectionsFactorySupplier collectionsFactorySupplier, ConstraintSemantics constraintSemantics, SchemaState schemaState, IndexingService indexingService, TokenHolders tokenHolders, string currentDatabaseName, Dependencies dataSourceDependencies)
{
if (!InstanceFieldsInitialized)
{
InitializeInstanceFields();
InstanceFieldsInitialized = true;
}
this._config = config;
this._statementLocksFactory = statementLocksFactory;
this._constraintIndexCreator = constraintIndexCreator;
this._statementOperations = statementOperations;
this._schemaWriteGuard = schemaWriteGuard;
this._transactionHeaderInformationFactory = txHeaderFactory;
this._transactionCommitProcess = transactionCommitProcess;
this._auxTxStateManager = auxTxStateManager;
this._hooks = hooks;
this._transactionMonitor = transactionMonitor;
this._databaseAvailabilityGuard = databaseAvailabilityGuard;
this._tracers = tracers;
this._storageEngine = storageEngine;
this._procedures = procedures;
this._transactionIdStore = transactionIdStore;
this._cpuClockRef = cpuClockRef;
this._heapAllocationRef = heapAllocationRef;
this._accessCapability = accessCapability;
this._autoIndexing = autoIndexing;
this._explicitIndexStore = explicitIndexStore;
this._indexingService = indexingService;
this._tokenHolders = tokenHolders;
this._currentDatabaseName = currentDatabaseName;
this._dataSourceDependencies = dataSourceDependencies;
this._versionContextSupplier = versionContextSupplier;
this._clock = clock;
DoBlockNewTransactions();
this._collectionsFactorySupplier = collectionsFactorySupplier;
this._constraintSemantics = constraintSemantics;
this._schemaState = schemaState;
}
internal TestKernelTransactions(StatementLocksFactory statementLocksFactory, ConstraintIndexCreator constraintIndexCreator, StatementOperationParts statementOperations, SchemaWriteGuard schemaWriteGuard, TransactionHeaderInformationFactory txHeaderFactory, TransactionCommitProcess transactionCommitProcess, AuxiliaryTransactionStateManager auxTxStateManager, TransactionHooks hooks, TransactionMonitor transactionMonitor, AvailabilityGuard databaseAvailabilityGuard, Tracers tracers, StorageEngine storageEngine, Procedures procedures, TransactionIdStore transactionIdStore, SystemNanoClock clock, AccessCapability accessCapability, AutoIndexing autoIndexing, VersionContextSupplier versionContextSupplier, TokenHolders tokenHolders, Dependencies dataSourceDependencies) : base(Config.defaults(), statementLocksFactory, constraintIndexCreator, statementOperations, schemaWriteGuard, txHeaderFactory, transactionCommitProcess, auxTxStateManager, hooks, transactionMonitor, databaseAvailabilityGuard, tracers, storageEngine, procedures, transactionIdStore, clock, new AtomicReference <CpuClock>(CpuClock.NOT_AVAILABLE), new AtomicReference <HeapAllocation>(HeapAllocation.NOT_AVAILABLE), accessCapability, autoIndexing, mock(typeof(ExplicitIndexStore)), versionContextSupplier, ON_HEAP, new StandardConstraintSemantics(), mock(typeof(SchemaState)), mock(typeof(IndexingService)), tokenHolders, DEFAULT_DATABASE_NAME, dataSourceDependencies)
{
}
internal virtual StateMachineBuilder WithGuard(AvailabilityGuard guard)
{
this.Guard = guard;
return(this);
}
private static KernelTransactions CreateTransactions(StorageEngine storageEngine, TransactionCommitProcess commitProcess, TransactionIdStore transactionIdStore, Tracers tracers, StatementLocksFactory statementLocksFactory, StatementOperationParts statementOperations, SystemNanoClock clock, AvailabilityGuard databaseAvailabilityGuard)
{
return(new KernelTransactions(Config.defaults(), statementLocksFactory, null, statementOperations, null, DEFAULT, commitProcess, mock(typeof(AuxiliaryTransactionStateManager)), new TransactionHooks(), mock(typeof(TransactionMonitor)), databaseAvailabilityGuard, tracers, storageEngine, new Procedures(), transactionIdStore, clock, new AtomicReference <CpuClock>(CpuClock.NOT_AVAILABLE), new AtomicReference <HeapAllocation>(HeapAllocation.NOT_AVAILABLE), new CanWrite(), AutoIndexing.UNSUPPORTED, mock(typeof(ExplicitIndexStore)), EmptyVersionContextSupplier.EMPTY, ON_HEAP, mock(typeof(ConstraintSemantics)), mock(typeof(SchemaState)), mock(typeof(IndexingService)), mockedTokenHolders(), DEFAULT_DATABASE_NAME, new Dependencies()));
}
public ThreadToStatementContextBridge(AvailabilityGuard availabilityGuard)
{
this._availabilityGuard = availabilityGuard;
}
private static TestKernelTransactions CreateTestTransactions(StorageEngine storageEngine, TransactionCommitProcess commitProcess, TransactionIdStore transactionIdStore, Tracers tracers, StatementLocksFactory statementLocksFactory, StatementOperationParts statementOperations, SystemNanoClock clock, AvailabilityGuard databaseAvailabilityGuard)
{
return(new TestKernelTransactions(statementLocksFactory, null, statementOperations, null, DEFAULT, commitProcess, mock(typeof(AuxiliaryTransactionStateManager)), new TransactionHooks(), mock(typeof(TransactionMonitor)), databaseAvailabilityGuard, tracers, storageEngine, new Procedures(), transactionIdStore, clock, new CanWrite(), AutoIndexing.UNSUPPORTED, EmptyVersionContextSupplier.EMPTY, mockedTokenHolders(), new Dependencies()));
}
public StartupWaiter(AvailabilityGuard availabilityGuard, long timeout)
{
this._availabilityGuard = availabilityGuard;
this._timeout = timeout;
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: static org.neo4j.causalclustering.catchup.storecopy.LocalDatabase create(System.Func<org.neo4j.kernel.internal.DatabaseHealth> databaseHealthSupplier, org.neo4j.kernel.availability.AvailabilityGuard availabilityGuard) throws java.io.IOException
internal static LocalDatabase Create(System.Func <DatabaseHealth> databaseHealthSupplier, AvailabilityGuard availabilityGuard)
{
StoreFiles storeFiles = mock(typeof(StoreFiles));
when(storeFiles.ReadStoreId(any())).thenReturn(new StoreId(1, 2, 3, 4));
DataSourceManager dataSourceManager = mock(typeof(DataSourceManager));
return(new StubLocalDatabase(storeFiles, dataSourceManager, databaseHealthSupplier, availabilityGuard));
}
private HighAvailabilityMemberStateMachine BuildMockedStateMachine(HighAvailabilityMemberContext context, ClusterMemberEvents events, ObservedClusterMembers clusterMembers, AvailabilityGuard guard)
{
return((new StateMachineBuilder()).WithContext(context).withEvents(events).withClusterMembers(clusterMembers).withGuard(guard).build());
}
internal StubLocalDatabase(StoreFiles storeFiles, DataSourceManager dataSourceManager, System.Func <DatabaseHealth> databaseHealthSupplier, AvailabilityGuard availabilityGuard) : base(null, storeFiles, null, dataSourceManager, databaseHealthSupplier, availabilityGuard, NullLogProvider.Instance)
{
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: public EnterpriseCoreEditionModule(final org.neo4j.graphdb.factory.module.PlatformModule platformModule, final org.neo4j.causalclustering.discovery.DiscoveryServiceFactory discoveryServiceFactory)
public EnterpriseCoreEditionModule(PlatformModule platformModule, DiscoveryServiceFactory discoveryServiceFactory)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.util.Dependencies dependencies = platformModule.dependencies;
Dependencies dependencies = platformModule.Dependencies;
Config = platformModule.Config;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.logging.internal.LogService logging = platformModule.logging;
LogService logging = platformModule.Logging;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.io.fs.FileSystemAbstraction fileSystem = platformModule.fileSystem;
FileSystemAbstraction fileSystem = platformModule.FileSystem;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.io.layout.DatabaseLayout databaseLayout = platformModule.storeLayout.databaseLayout(config.get(org.neo4j.graphdb.factory.GraphDatabaseSettings.active_database));
DatabaseLayout databaseLayout = platformModule.StoreLayout.databaseLayout(Config.get(GraphDatabaseSettings.active_database));
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.lifecycle.LifeSupport life = platformModule.life;
LifeSupport life = platformModule.Life;
CoreMonitor.register(logging.InternalLogProvider, logging.UserLogProvider, platformModule.Monitors);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.io.File dataDir = config.get(org.neo4j.graphdb.factory.GraphDatabaseSettings.data_directory);
File dataDir = Config.get(GraphDatabaseSettings.data_directory);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.causalclustering.core.state.ClusterStateDirectory clusterStateDirectory = new org.neo4j.causalclustering.core.state.ClusterStateDirectory(dataDir, databaseLayout.databaseDirectory(), false);
ClusterStateDirectory clusterStateDirectory = new ClusterStateDirectory(dataDir, databaseLayout.DatabaseDirectory(), false);
try
{
clusterStateDirectory.Initialize(fileSystem);
}
catch (ClusterStateException e)
{
throw new Exception(e);
}
dependencies.SatisfyDependency(clusterStateDirectory);
AvailabilityGuard globalGuard = GetGlobalAvailabilityGuard(platformModule.Clock, logging, platformModule.Config);
ThreadToTransactionBridgeConflict = dependencies.SatisfyDependency(new ThreadToStatementContextBridge(globalGuard));
LogProvider = logging.InternalLogProvider;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final System.Func<org.neo4j.kernel.internal.DatabaseHealth> databaseHealthSupplier = () -> platformModule.dataSourceManager.getDataSource().getDependencyResolver().resolveDependency(org.neo4j.kernel.internal.DatabaseHealth.class);
System.Func <DatabaseHealth> databaseHealthSupplier = () => platformModule.DataSourceManager.DataSource.DependencyResolver.resolveDependency(typeof(DatabaseHealth));
WatcherServiceFactoryConflict = directory => CreateFileSystemWatcherService(fileSystem, directory, logging, platformModule.JobScheduler, Config, FileWatcherFileNameFilter());
dependencies.SatisfyDependencies(WatcherServiceFactoryConflict);
LogFiles logFiles = BuildLocalDatabaseLogFiles(platformModule, fileSystem, databaseLayout);
LocalDatabase localDatabase = new LocalDatabase(databaseLayout, new StoreFiles(fileSystem, platformModule.PageCache), logFiles, platformModule.DataSourceManager, databaseHealthSupplier, globalGuard, LogProvider);
IdentityModule identityModule = new IdentityModule(platformModule, clusterStateDirectory.Get());
ClusteringModule clusteringModule = GetClusteringModule(platformModule, discoveryServiceFactory, clusterStateDirectory, identityModule, dependencies, databaseLayout);
// We need to satisfy the dependency here to keep users of it, such as BoltKernelExtension, happy.
dependencies.SatisfyDependency(SslPolicyLoader.create(Config, LogProvider));
PipelineWrapper clientPipelineWrapper = PipelineWrapperFactory().forClient(Config, dependencies, LogProvider, CausalClusteringSettings.SslPolicy);
PipelineWrapper serverPipelineWrapper = PipelineWrapperFactory().forServer(Config, dependencies, LogProvider, CausalClusteringSettings.SslPolicy);
PipelineWrapper backupServerPipelineWrapper = PipelineWrapperFactory().forServer(Config, dependencies, LogProvider, OnlineBackupSettings.ssl_policy);
NettyPipelineBuilderFactory clientPipelineBuilderFactory = new NettyPipelineBuilderFactory(clientPipelineWrapper);
NettyPipelineBuilderFactory serverPipelineBuilderFactory = new NettyPipelineBuilderFactory(serverPipelineWrapper);
NettyPipelineBuilderFactory backupServerPipelineBuilderFactory = new NettyPipelineBuilderFactory(backupServerPipelineWrapper);
_topologyService = clusteringModule.TopologyService();
long logThresholdMillis = Config.get(CausalClusteringSettings.UnknownAddressLoggingThrottle).toMillis();
SupportedProtocolCreator supportedProtocolCreator = new SupportedProtocolCreator(Config, LogProvider);
ApplicationSupportedProtocols supportedRaftProtocols = supportedProtocolCreator.CreateSupportedRaftProtocol();
ICollection <ModifierSupportedProtocols> supportedModifierProtocols = supportedProtocolCreator.CreateSupportedModifierProtocols();
ApplicationProtocolRepository applicationProtocolRepository = new ApplicationProtocolRepository(Org.Neo4j.causalclustering.protocol.Protocol_ApplicationProtocols.values(), supportedRaftProtocols);
ModifierProtocolRepository modifierProtocolRepository = new ModifierProtocolRepository(Org.Neo4j.causalclustering.protocol.Protocol_ModifierProtocols.values(), supportedModifierProtocols);
ProtocolInstallerRepository <Org.Neo4j.causalclustering.protocol.ProtocolInstaller_Orientation_Client> protocolInstallerRepository = new ProtocolInstallerRepository <Org.Neo4j.causalclustering.protocol.ProtocolInstaller_Orientation_Client>(asList(new RaftProtocolClientInstallerV2.Factory(clientPipelineBuilderFactory, LogProvider), new RaftProtocolClientInstallerV1.Factory(clientPipelineBuilderFactory, LogProvider)), Org.Neo4j.causalclustering.protocol.ModifierProtocolInstaller_Fields.AllClientInstallers);
Duration handshakeTimeout = Config.get(CausalClusteringSettings.HandshakeTimeout);
HandshakeClientInitializer channelInitializer = new HandshakeClientInitializer(applicationProtocolRepository, modifierProtocolRepository, protocolInstallerRepository, clientPipelineBuilderFactory, handshakeTimeout, LogProvider, platformModule.Logging.UserLogProvider);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.causalclustering.messaging.SenderService raftSender = new org.neo4j.causalclustering.messaging.SenderService(channelInitializer, logProvider);
SenderService raftSender = new SenderService(channelInitializer, LogProvider);
life.Add(raftSender);
this._clientInstalledProtocols = raftSender.installedProtocols;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.causalclustering.logging.MessageLogger<org.neo4j.causalclustering.identity.MemberId> messageLogger = createMessageLogger(config, life, identityModule.myself());
MessageLogger <MemberId> messageLogger = CreateMessageLogger(Config, life, identityModule.Myself());
RaftOutbound raftOutbound = new RaftOutbound(_topologyService, raftSender, clusteringModule.ClusterIdentity(), LogProvider, logThresholdMillis);
Outbound <MemberId, Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage> loggingOutbound = new LoggingOutbound <MemberId, Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage>(raftOutbound, identityModule.Myself(), messageLogger);
_consensusModule = new ConsensusModule(identityModule.Myself(), platformModule, loggingOutbound, clusterStateDirectory.Get(), _topologyService);
dependencies.SatisfyDependency(_consensusModule.raftMachine());
_replicationModule = new ReplicationModule(_consensusModule.raftMachine(), identityModule.Myself(), platformModule, Config, loggingOutbound, clusterStateDirectory.Get(), fileSystem, LogProvider, globalGuard, localDatabase);
_coreStateMachinesModule = new CoreStateMachinesModule(identityModule.Myself(), platformModule, clusterStateDirectory.Get(), Config, _replicationModule.Replicator, _consensusModule.raftMachine(), dependencies, localDatabase);
IdContextFactoryConflict = IdContextFactoryBuilder.of(_coreStateMachinesModule.idTypeConfigurationProvider, platformModule.JobScheduler).withIdGenerationFactoryProvider(ignored => _coreStateMachinesModule.idGeneratorFactory).withFactoryWrapper(generator => new FreeIdFilteredIdGeneratorFactory(generator, _coreStateMachinesModule.freeIdCondition)).build();
// TODO: this is broken, coreStateMachinesModule.tokenHolders should be supplier, somehow...
this.TokenHoldersProviderConflict = databaseName => _coreStateMachinesModule.tokenHolders;
this.LocksSupplierConflict = _coreStateMachinesModule.locksSupplier;
this.CommitProcessFactoryConflict = _coreStateMachinesModule.commitProcessFactory;
this.AccessCapabilityConflict = new LeaderCanWrite(_consensusModule.raftMachine());
InstalledProtocolHandler serverInstalledProtocolHandler = new InstalledProtocolHandler();
this._coreServerModule = new CoreServerModule(identityModule, platformModule, _consensusModule, _coreStateMachinesModule, clusteringModule, _replicationModule, localDatabase, databaseHealthSupplier, clusterStateDirectory.Get(), clientPipelineBuilderFactory, serverPipelineBuilderFactory, backupServerPipelineBuilderFactory, serverInstalledProtocolHandler);
TypicallyConnectToRandomReadReplicaStrategy defaultStrategy = new TypicallyConnectToRandomReadReplicaStrategy(2);
defaultStrategy.Inject(_topologyService, Config, LogProvider, identityModule.Myself());
UpstreamDatabaseStrategySelector catchupStrategySelector = CreateUpstreamDatabaseStrategySelector(identityModule.Myself(), Config, LogProvider, _topologyService, defaultStrategy);
Org.Neo4j.causalclustering.catchup.CatchupAddressProvider_PrioritisingUpstreamStrategyBasedAddressProvider catchupAddressProvider = new Org.Neo4j.causalclustering.catchup.CatchupAddressProvider_PrioritisingUpstreamStrategyBasedAddressProvider(_consensusModule.raftMachine(), _topologyService, catchupStrategySelector);
RaftServerModule.CreateAndStart(platformModule, _consensusModule, identityModule, _coreServerModule, localDatabase, serverPipelineBuilderFactory, messageLogger, catchupAddressProvider, supportedRaftProtocols, supportedModifierProtocols, serverInstalledProtocolHandler);
_serverInstalledProtocols = serverInstalledProtocolHandler.installedProtocols;
EditionInvariants(platformModule, dependencies, Config, logging, life);
life.Add(_coreServerModule.membershipWaiterLifecycle);
}
public TransactionIdTracker(System.Func <TransactionIdStore> transactionIdStoreSupplier, AvailabilityGuard databaseAvailabilityGuard)
{
this._databaseAvailabilityGuard = databaseAvailabilityGuard;
this._transactionIdStoreSupplier = transactionIdStoreSupplier;
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void whenHAModeSwitcherSwitchesToSlaveTheOtherModeSwitcherDoNotGetTheOldMasterClient() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void WhenHAModeSwitcherSwitchesToSlaveTheOtherModeSwitcherDoNotGetTheOldMasterClient()
{
InstanceId me = new InstanceId(1);
StoreId storeId = newStoreIdForCurrentVersion();
HighAvailabilityMemberContext context = mock(typeof(HighAvailabilityMemberContext));
when(context.MyId).thenReturn(me);
AvailabilityGuard guard = mock(typeof(DatabaseAvailabilityGuard));
ObservedClusterMembers members = mock(typeof(ObservedClusterMembers));
ClusterMember masterMember = mock(typeof(ClusterMember));
when(masterMember.HARole).thenReturn("master");
when(masterMember.HasRole("master")).thenReturn(true);
when(masterMember.InstanceId).thenReturn(new InstanceId(2));
when(masterMember.StoreId).thenReturn(storeId);
ClusterMember self = new ClusterMember(me);
when(members.Members).thenReturn(Arrays.asList(self, masterMember));
when(members.CurrentMember).thenReturn(self);
DependencyResolver dependencyResolver = mock(typeof(DependencyResolver));
FileSystemAbstraction fs = mock(typeof(FileSystemAbstraction));
when(fs.FileExists(any(typeof(File)))).thenReturn(true);
when(dependencyResolver.ResolveDependency(typeof(FileSystemAbstraction))).thenReturn(fs);
when(dependencyResolver.ResolveDependency(typeof(Monitors))).thenReturn(new Monitors());
NeoStoreDataSource dataSource = mock(typeof(NeoStoreDataSource));
when(dataSource.DependencyResolver).thenReturn(dependencyResolver);
when(dataSource.StoreId).thenReturn(storeId);
when(dependencyResolver.ResolveDependency(typeof(NeoStoreDataSource))).thenReturn(dataSource);
when(dependencyResolver.ResolveDependency(typeof(TransactionIdStore))).thenReturn(new SimpleTransactionIdStore());
when(dependencyResolver.ResolveDependency(typeof(ObservedClusterMembers))).thenReturn(members);
UpdatePuller updatePuller = mock(typeof(UpdatePuller));
when(updatePuller.TryPullUpdates()).thenReturn(true);
when(dependencyResolver.ResolveDependency(typeof(UpdatePuller))).thenReturn(updatePuller);
ClusterMemberAvailability clusterMemberAvailability = mock(typeof(ClusterMemberAvailability));
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final TriggerableClusterMemberEvents events = new TriggerableClusterMemberEvents();
TriggerableClusterMemberEvents events = new TriggerableClusterMemberEvents();
Election election = mock(typeof(Election));
HighAvailabilityMemberStateMachine stateMachine = new HighAvailabilityMemberStateMachine(context, guard, members, events, election, NullLogProvider.Instance);
ClusterMembers clusterMembers = new ClusterMembers(members, stateMachine);
when(dependencyResolver.ResolveDependency(typeof(ClusterMembers))).thenReturn(clusterMembers);
stateMachine.Init();
stateMachine.Start();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.ha.DelegateInvocationHandler<org.neo4j.kernel.ha.com.master.Master> handler = new org.neo4j.kernel.ha.DelegateInvocationHandler<>(org.neo4j.kernel.ha.com.master.Master.class);
DelegateInvocationHandler <Master> handler = new DelegateInvocationHandler <Master>(typeof(Master));
MasterClientResolver masterClientResolver = mock(typeof(MasterClientResolver));
MasterClient masterClient = mock(typeof(MasterClient));
when(masterClient.ProtocolVersion).thenReturn(MasterClient214.PROTOCOL_VERSION);
when(masterClient.Handshake(anyLong(), any(typeof(StoreId)))).thenReturn(new ResponseAnonymousInnerClass(this, storeId, mock(typeof(ResourceReleaser)), handler));
when(masterClient.ToString()).thenReturn("TheExpectedMasterClient!");
when(masterClientResolver.Instantiate(anyString(), anyInt(), anyString(), any(typeof(Monitors)), any(typeof(StoreId)), any(typeof(LifeSupport)))).thenReturn(masterClient);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch latch = new java.util.concurrent.CountDownLatch(2);
System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(2);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicBoolean switchedSuccessfully = new java.util.concurrent.atomic.AtomicBoolean();
AtomicBoolean switchedSuccessfully = new AtomicBoolean();
SwitchToSlave.Monitor monitor = new MonitorAnonymousInnerClass(this, latch, switchedSuccessfully);
Config config = Config.defaults(ClusterSettings.server_id, me.ToString());
DatabaseTransactionStats transactionCounters = mock(typeof(DatabaseTransactionStats));
when(transactionCounters.NumberOfActiveTransactions).thenReturn(0L);
PageCache pageCacheMock = mock(typeof(PageCache));
PagedFile pagedFileMock = mock(typeof(PagedFile));
when(pagedFileMock.LastPageId).thenReturn(1L);
when(pageCacheMock.Map(any(typeof(File)), anyInt())).thenReturn(pagedFileMock);
TransactionIdStore transactionIdStoreMock = mock(typeof(TransactionIdStore));
when(transactionIdStoreMock.LastCommittedTransaction).thenReturn(new TransactionId(0, 0, 0));
SwitchToSlaveCopyThenBranch switchToSlave = new SwitchToSlaveCopyThenBranch(DatabaseLayout.of(new File("")), NullLogService.Instance, mock(typeof(FileSystemAbstraction)), config, mock(typeof(HaIdGeneratorFactory)), handler, mock(typeof(ClusterMemberAvailability)), mock(typeof(RequestContextFactory)), mock(typeof(PullerFactory), RETURNS_MOCKS), Iterables.empty(), masterClientResolver, monitor, new Org.Neo4j.com.storecopy.StoreCopyClientMonitor_Adapter(), Suppliers.singleton(dataSource), Suppliers.singleton(transactionIdStoreMock), slave =>
{
SlaveServer mock = mock(typeof(SlaveServer));
when(mock.SocketAddress).thenReturn(new InetSocketAddress("localhost", 123));
return(mock);
}, updatePuller, pageCacheMock, mock(typeof(Monitors)), () => transactionCounters);
ComponentSwitcherContainer switcherContainer = new ComponentSwitcherContainer();
HighAvailabilityModeSwitcher haModeSwitcher = new HighAvailabilityModeSwitcher(switchToSlave, mock(typeof(SwitchToMaster)), election, clusterMemberAvailability, mock(typeof(ClusterClient)), storeSupplierMock(), me, switcherContainer, NeoStoreDataSourceSupplierMock(), NullLogService.Instance);
haModeSwitcher.Init();
haModeSwitcher.Start();
haModeSwitcher.ListeningAt(URI.create("http://localhost:12345"));
stateMachine.AddHighAvailabilityMemberListener(haModeSwitcher);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicReference<org.neo4j.kernel.ha.com.master.Master> ref = new java.util.concurrent.atomic.AtomicReference<>(null);
AtomicReference <Master> @ref = new AtomicReference <Master>(null);
//noinspection unchecked
AbstractComponentSwitcher <object> otherModeSwitcher = new AbstractComponentSwitcherAnonymousInnerClass(this, mock(typeof(DelegateInvocationHandler)), handler, latch, @ref);
switcherContainer.Add(otherModeSwitcher);
// When
events.SwitchToSlave(me);
// Then
latch.await();
assertTrue("mode switch failed", switchedSuccessfully.get());
Master actual = @ref.get();
// let's test the toString()s since there are too many wrappers of proxies
assertEquals(masterClient.ToString(), actual.ToString());
stateMachine.Stop();
stateMachine.Shutdown();
haModeSwitcher.Stop();
haModeSwitcher.Shutdown();
}
