public TestableTransactionAppender(TransactionIdStore transactionIdStore) { this._transactionIdStore = transactionIdStore; }
public DefaultRecoveryServiceAnonymousInnerClass3(RecoveryTest outerInstance, StorageEngine storageEngine, LogTailScanner tailScanner, TransactionIdStore transactionIdStore, LogicalTransactionStore txStore, SimpleLogVersionRepository versionRepository, UnknownType noMonitor, AtomicBoolean recoveryRequired) : base(storageEngine, tailScanner, transactionIdStore, txStore, versionRepository, noMonitor) { this.outerInstance = outerInstance; this._recoveryRequired = recoveryRequired; }
public HandlerAnonymousInnerClass(ResponsePackerTest outerInstance, long targetTransactionId, TransactionIdStore transactionIdStore, AtomicLong nextExpectedVisit) { this.outerInstance = outerInstance; this._targetTransactionId = targetTransactionId; this._transactionIdStore = transactionIdStore; this._nextExpectedVisit = nextExpectedVisit; }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void addATransactionAndRewind(org.neo4j.kernel.lifecycle.LifeSupport life, org.neo4j.kernel.impl.transaction.log.files.LogFiles logFiles, TransactionMetadataCache positionCache, TransactionIdStore transactionIdStore, byte[] additionalHeader, int masterId, int authorId, long timeStarted, long latestCommittedTxWhenStarted, long timeCommitted) throws java.io.IOException private void AddATransactionAndRewind(LifeSupport life, LogFiles logFiles, TransactionMetadataCache positionCache, TransactionIdStore transactionIdStore, sbyte[] additionalHeader, int masterId, int authorId, long timeStarted, long latestCommittedTxWhenStarted, long timeCommitted) { TransactionAppender appender = life.Add(new BatchingTransactionAppender(logFiles, NO_ROTATION, positionCache, transactionIdStore, BYPASS, _databaseHealth)); PhysicalTransactionRepresentation transaction = new PhysicalTransactionRepresentation(SingleCreateNodeCommand()); transaction.SetHeader(additionalHeader, masterId, authorId, timeStarted, latestCommittedTxWhenStarted, timeCommitted, -1); appender.Append(new TransactionToApply(transaction), Org.Neo4j.Kernel.impl.transaction.tracing.LogAppendEvent_Fields.Null); }
public BatchingTransactionAppender(LogFiles logFiles, LogRotation logRotation, TransactionMetadataCache transactionMetadataCache, TransactionIdStore transactionIdStore, IdOrderingQueue explicitIndexTransactionOrdering, DatabaseHealth databaseHealth) { this._logFile = logFiles.LogFile; this._logRotation = logRotation; this._transactionIdStore = transactionIdStore; this._explicitIndexTransactionOrdering = explicitIndexTransactionOrdering; this._databaseHealth = databaseHealth; this._transactionMetadataCache = transactionMetadataCache; }
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) { }
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())); }
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())); }
//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(); }
internal TransactionCommitment(bool hasExplicitIndexChanges, long transactionId, long transactionChecksum, long transactionCommitTimestamp, LogPosition logPosition, TransactionIdStore transactionIdStore) { this._hasExplicitIndexChanges = hasExplicitIndexChanges; this._transactionId = transactionId; this._transactionChecksum = transactionChecksum; this._transactionCommitTimestamp = transactionCommitTimestamp; this._logPosition = logPosition; this._transactionIdStore = transactionIdStore; }