@Override public KernelTransactionsSnapshot get() { return new KernelTransactionsSnapshot( activeTransactions(), clock.millis() ); }
@Override public synchronized void run() { long now = clock.millis(); Set<KernelTransactionHandle> activeTransactions = kernelTransactions.activeTransactions(); checkExpiredTransactions( activeTransactions, now ); }
private static boolean isStatementExecuting( KernelTransactions kernelTransactions, String statement ) { return kernelTransactions.activeTransactions().stream() .flatMap( KernelTransactionHandle::executingQueries ) .anyMatch( executingQuery -> statement.equals( executingQuery.queryText() ) ); } }
private void terminateOngoingTransaction() { Set<KernelTransactionHandle> kernelTransactionHandles = database.resolveDependency( KernelTransactions.class ).activeTransactions(); assertThat( kernelTransactionHandles, hasSize( 1 ) ); for ( KernelTransactionHandle kernelTransactionHandle : kernelTransactionHandles ) { kernelTransactionHandle.markForTermination( Status.Transaction.Terminated ); } }
@Test public void shouldNotLeakTransactionOnSecurityContextFreezeFailure() throws Throwable { KernelTransactions kernelTransactions = newKernelTransactions(); LoginContext loginContext = mock( LoginContext.class ); when( loginContext.authorize( any(), any() ) ).thenThrow( new AuthorizationExpiredException( "Freeze failed." ) ); assertException(() -> kernelTransactions.newInstance(KernelTransaction.Type.explicit, loginContext, 0L), AuthorizationExpiredException.class, "Freeze failed."); assertThat("We should not have any transaction", kernelTransactions.activeTransactions(), is(empty())); }
private Set<KernelTransactionHandle> getActiveTransactions( Neo4jWithSocket server ) { GraphDatabaseAPI gdb = (GraphDatabaseAPI) server.graphDatabaseService(); return gdb.getDependencyResolver().resolveDependency( KernelTransactions.class ).activeTransactions(); } };
@Test void skipTransactionWithoutTimeout() { HashSet<KernelTransactionHandle> transactions = new HashSet<>(); KernelTransactionImplementation tx1 = prepareTxMock( 7, 3, 0 ); KernelTransactionImplementation tx2 = prepareTxMock( 8, 4, 0 ); KernelTransactionImplementationHandle handle1 = new KernelTransactionImplementationHandle( tx1, fakeClock ); KernelTransactionImplementationHandle handle2 = new KernelTransactionImplementationHandle( tx2, fakeClock ); transactions.add( handle1 ); transactions.add( handle2 ); when( kernelTransactions.activeTransactions()).thenReturn( transactions ); KernelTransactionMonitor transactionMonitor = buildTransactionMonitor(); fakeClock.forward( 300, TimeUnit.MILLISECONDS ); transactionMonitor.run(); verify( tx1, never() ).markForTermination( Status.Transaction.TransactionTimedOut ); verify( tx2, never() ).markForTermination( Status.Transaction.TransactionTimedOut ); logProvider.assertNoMessagesContaining( "timeout" ); }
@Test public void incrementalUserTransactionId() throws Throwable { KernelTransactions kernelTransactions = newKernelTransactions(); try ( KernelTransaction kernelTransaction = kernelTransactions .newInstance( KernelTransaction.Type.explicit, AnonymousContext.none(), 0L ) ) { assertEquals( 1, kernelTransactions.activeTransactions().iterator().next().getUserTransactionId() ); } try ( KernelTransaction kernelTransaction = kernelTransactions .newInstance( KernelTransaction.Type.explicit, AnonymousContext.none(), 0L ) ) { assertEquals( 2, kernelTransactions.activeTransactions().iterator().next().getUserTransactionId() ); } try ( KernelTransaction kernelTransaction = kernelTransactions .newInstance( KernelTransaction.Type.explicit, AnonymousContext.none(), 0L ) ) { assertEquals( 3, kernelTransactions.activeTransactions().iterator().next().getUserTransactionId() ); } }
@Test void terminateExpiredTransactions() { HashSet<KernelTransactionHandle> transactions = new HashSet<>(); KernelTransactionImplementation tx1 = prepareTxMock( 3, 1, 3 ); KernelTransactionImplementation tx2 = prepareTxMock( 4, 1, 8 ); KernelTransactionImplementationHandle handle1 = new KernelTransactionImplementationHandle( tx1, fakeClock ); KernelTransactionImplementationHandle handle2 = new KernelTransactionImplementationHandle( tx2, fakeClock ); transactions.add( handle1 ); transactions.add( handle2 ); when( kernelTransactions.activeTransactions()).thenReturn( transactions ); KernelTransactionMonitor transactionMonitor = buildTransactionMonitor(); fakeClock.forward( 3, TimeUnit.MILLISECONDS ); transactionMonitor.run(); verify( tx1, never() ).markForTermination( Status.Transaction.TransactionTimedOut ); verify( tx2, never() ).markForTermination( Status.Transaction.TransactionTimedOut ); logProvider.assertNoMessagesContaining( "timeout" ); fakeClock.forward( 2, TimeUnit.MILLISECONDS ); transactionMonitor.run(); verify( tx1 ).markForTermination( EXPECTED_REUSE_COUNT, Status.Transaction.TransactionTimedOut ); verify( tx2, never() ).markForTermination( Status.Transaction.TransactionTimedOut ); logProvider.assertContainsLogCallContaining( "timeout" ); logProvider.clear(); fakeClock.forward( 10, TimeUnit.MILLISECONDS ); transactionMonitor.run(); verify( tx2 ).markForTermination( EXPECTED_REUSE_COUNT, Status.Transaction.TransactionTimedOut ); logProvider.assertContainsLogCallContaining( "timeout" ); }
@Test public void shouldListActiveTransactions() throws Throwable { // Given KernelTransactions transactions = newTestKernelTransactions(); // When KernelTransaction first = getKernelTransaction( transactions ); KernelTransaction second = getKernelTransaction( transactions ); KernelTransaction third = getKernelTransaction( transactions ); first.close(); // Then assertThat( transactions.activeTransactions(), equalTo( asSet( newHandle( second ), newHandle( third ) ) ) ); }
@Test public void shouldSetTxMetadata() throws Throwable { // Given negotiateBoltV3(); Map<String,Object> txMetadata = map( "who-is-your-boss", "Molly-mostly-white" ); Map<String,Object> msgMetadata = map( "tx_metadata", txMetadata ); MapValue meta = asMapValue( msgMetadata ); connection.send( util.chunk( new BeginMessage( meta ), new RunMessage( "RETURN 1" ), PullAllMessage.INSTANCE ) ); // When assertThat( connection, util.eventuallyReceives( msgSuccess(), msgSuccess(), msgRecord( eqRecord( equalTo( longValue( 1L ) ) ) ), msgSuccess() ) ); // Then GraphDatabaseAPI gdb = (GraphDatabaseAPI) server.graphDatabaseService(); Set<KernelTransactionHandle> txHandles = gdb.getDependencyResolver().resolveDependency( KernelTransactions.class ).activeTransactions(); assertThat( txHandles.size(), equalTo( 1 ) ); for ( KernelTransactionHandle txHandle: txHandles ) { assertThat( txHandle.getMetaData(), equalTo( txMetadata ) ); } connection.send( util.chunk( ROLLBACK_MESSAGE ) ); }
@Test public void transactionCloseRemovesTxFromActiveTransactions() throws Throwable { KernelTransactions kernelTransactions = newTestKernelTransactions(); KernelTransaction tx1 = getKernelTransaction( kernelTransactions ); KernelTransaction tx2 = getKernelTransaction( kernelTransactions ); KernelTransaction tx3 = getKernelTransaction( kernelTransactions ); tx1.close(); tx3.close(); assertEquals( asSet( newHandle( tx2 ) ), kernelTransactions.activeTransactions() ); }
public static Set<KernelTransactionHandle> getActiveTransactions( DependencyResolver dependencyResolver ) { return dependencyResolver.resolveDependency( KernelTransactions.class ).activeTransactions(); }
@Override public KernelTransactionsSnapshot get() { return new KernelTransactionsSnapshot( activeTransactions(), clock.millis() ); }
@Override public synchronized void run() { long now = clock.millis(); Set<KernelTransactionHandle> activeTransactions = kernelTransactions.activeTransactions(); checkExpiredTransactions( activeTransactions, now ); }
private Set<KernelTransactionHandle> getActiveTransactions() { return graph.getDependencyResolver().resolveDependency( KernelTransactions.class ).activeTransactions(); }
@Description( "List all transactions currently executing at this instance that are visible to the user." ) @Procedure( name = "dbms.listTransactions", mode = DBMS ) public Stream<TransactionStatusResult> listTransactions() throws InvalidArgumentsException { securityContext.assertCredentialsNotExpired(); try { Set<KernelTransactionHandle> handles = getKernelTransactions().activeTransactions().stream() .filter( transaction -> isAdminOrSelf( transaction.subject().username() ) ) .collect( toSet() ); Map<KernelTransactionHandle,List<QuerySnapshot>> handleQuerySnapshotsMap = handles.stream() .collect( toMap( identity(), getTransactionQueries() ) ); TransactionDependenciesResolver transactionBlockerResolvers = new TransactionDependenciesResolver( handleQuerySnapshotsMap ); ZoneId zoneId = getConfiguredTimeZone(); return handles.stream() .map( catchThrown( InvalidArgumentsException.class, tx -> new TransactionStatusResult( tx, transactionBlockerResolvers, handleQuerySnapshotsMap, zoneId ) ) ); } catch ( UncaughtCheckedException uncaught ) { throwIfPresent( uncaught.getCauseIfOfType( InvalidArgumentsException.class ) ); throw uncaught; } }
@Description( "List all queries currently executing at this instance that are visible to the user." ) @Procedure( name = "dbms.listQueries", mode = DBMS ) public Stream<QueryStatusResult> listQueries() throws InvalidArgumentsException { securityContext.assertCredentialsNotExpired(); EmbeddedProxySPI nodeManager = resolver.resolveDependency( EmbeddedProxySPI.class ); ZoneId zoneId = getConfiguredTimeZone(); try { return getKernelTransactions().activeTransactions().stream() .flatMap( KernelTransactionHandle::executingQueries ) .filter( query -> isAdminOrSelf( query.username() ) ) .map( catchThrown( InvalidArgumentsException.class, query -> new QueryStatusResult( query, nodeManager, zoneId ) ) ); } catch ( UncaughtCheckedException uncaught ) { throwIfPresent( uncaught.getCauseIfOfType( InvalidArgumentsException.class ) ); throw uncaught; } }
long earliestSafeTimestamp = lastCommittedTimestamp - idReuseSafeZoneTime; for ( KernelTransactionHandle txHandle : kernelTransactions.activeTransactions() )