private void checkExpiredTransactions( Set<KernelTransactionHandle> activeTransactions, long now ) { for ( KernelTransactionHandle activeTransaction : activeTransactions ) { long transactionTimeoutMillis = activeTransaction.timeoutMillis(); if ( transactionTimeoutMillis > 0 ) { if ( isTransactionExpired( activeTransaction, now, transactionTimeoutMillis ) ) { if ( activeTransaction.markForTermination( Status.Transaction.TransactionTimedOut ) ) { log.warn( "Transaction %s timeout.", activeTransaction ); } } } } }
private static boolean isTransactionExpired( KernelTransactionHandle activeTransaction, long nowMillis, long transactionTimeoutMillis ) { return nowMillis > (activeTransaction.startTime() + transactionTimeoutMillis); } }
protected void terminateTransactionsForValidUser( String username ) { KernelTransaction currentTx = getCurrentTx(); getActiveTransactions() .stream() .filter( tx -> tx.subject().hasUsername( username ) && !tx.isUnderlyingTransaction( currentTx ) ).forEach( tx -> tx.markForTermination( Status.Transaction.Terminated ) ); }
Map<KernelTransactionHandle,List<QuerySnapshot>> handleSnapshotsMap, ZoneId zoneId ) throws InvalidArgumentsException this.transactionId = transaction.getUserTransactionName(); this.username = transaction.subject().username(); this.startTime = ProceduresTimeFormatHelper.formatTime( transaction.startTime(), zoneId ); Optional<Status> terminationReason = transaction.terminationReason(); this.activeLockCount = transaction.activeLocks().count(); List<QuerySnapshot> querySnapshots = handleSnapshotsMap.get( transaction ); TransactionExecutionStatistic statistic = transaction.transactionStatistic(); elapsedTimeMillis = statistic.getElapsedTimeMillis(); cpuTimeMillis = statistic.getCpuTimeMillis(); this.metaData = transaction.getMetaData();
long commitTimestamp = txHandle.lastTransactionTimestampWhenStarted(); if ( txHandle.markForTermination( Status.Transaction.Outdated ) ) "\n" + " Transaction: lastCommittedTimestamp:" + informativeTimestamp( txHandle.lastTransactionTimestampWhenStarted() ) + ", lastCommittedTxId:" + txHandle.lastTransactionIdWhenStarted() + ", localStartTimestamp:" + informativeTimestamp( txHandle.startTime() ) );
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 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 ) ); }
@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; } }
private Function<KernelTransactionHandle,List<ActiveLock>> getTransactionLocks() { return transactionHandle -> transactionHandle.activeLocks().collect( toList() ); }
public static Stream<TransactionTerminationResult> terminateTransactionsForValidUser( DependencyResolver dependencyResolver, String username, KernelTransaction currentTx ) { long terminatedCount = getActiveTransactions( dependencyResolver ) .stream() .filter( tx -> tx.subject().hasUsername( username ) && !tx.isUnderlyingTransaction( currentTx ) ) .map( tx -> tx.markForTermination( Status.Transaction.Terminated ) ) .filter( marked -> marked ) .count(); return Stream.of( new TransactionTerminationResult( username, terminatedCount ) ); }
private QueryTerminationResult killQueryTransaction( Pair<KernelTransactionHandle, ExecutingQuery> pair ) throws InvalidArgumentsException { ExecutingQuery query = pair.other(); if ( isAdminOrSelf( query.username() ) ) { pair.first().markForTermination( Status.Transaction.Terminated ); return new QueryTerminationResult( ofInternalId( query.internalQueryId() ), query.username() ); } else { throw new AuthorizationViolationException( PERMISSION_DENIED ); } }
private Stream<ActiveLocksResult> getActiveLocksForQuery( Pair<KernelTransactionHandle, ExecutingQuery> pair ) { ExecutingQuery query = pair.other(); if ( isAdminOrSelf( query.username() ) ) { return pair.first().activeLocks().map( ActiveLocksResult::new ); } else { throw new AuthorizationViolationException( PERMISSION_DENIED ); } }
private void checkExpiredTransactions( Set<KernelTransactionHandle> activeTransactions, long now ) { for ( KernelTransactionHandle activeTransaction : activeTransactions ) { long transactionTimeoutMillis = activeTransaction.timeoutMillis(); if ( transactionTimeoutMillis > 0 ) { if ( isTransactionExpired( activeTransaction, now, transactionTimeoutMillis ) ) { if ( activeTransaction.markForTermination( Status.Transaction.TransactionTimedOut ) ) { log.warn( "Transaction %s timeout.", activeTransaction ); } } } } }
private static boolean isTransactionExpired( KernelTransactionHandle activeTransaction, long nowMillis, long transactionTimeoutMillis ) { return nowMillis > (activeTransaction.startTime() + transactionTimeoutMillis); } }