@Override public Optional<Status> terminationReason() { return transaction.getReasonIfTerminated(); }
@Override public Optional<Status> terminationReason() { return currentTransaction.getReasonIfTerminated(); }
@Override public Optional<Status> getReasonIfTerminated() { return internal.getReasonIfTerminated(); }
@Override public Optional<Status> terminationReason() { return tx.getReasonIfTerminated(); }
@Override public void assertInOpenTransaction() { KernelTransaction transaction = transactionSupplier.get(); if ( transaction.isTerminated() ) { Status terminationReason = transaction.getReasonIfTerminated().orElse( Status.Transaction.Terminated ); throw new TransactionTerminatedException( terminationReason ); } } }
private static KernelTransaction safeAcquireTransaction( Supplier<KernelTransaction> transactionSupplier ) { KernelTransaction transaction = transactionSupplier.get(); if ( transaction.isTerminated() ) { Status terminationReason = transaction.getReasonIfTerminated().orElse( Status.Transaction.Terminated ); throw new TransactionTerminatedException( terminationReason ); } return transaction; }
private static void assertTransactionOpen( KernelTransaction transaction ) { if ( transaction.isTerminated() ) { Status terminationReason = transaction.getReasonIfTerminated().orElse( Status.Transaction.Terminated ); throw new TransactionTerminatedException( terminationReason ); } }
private KernelTransaction safeAcquireTransaction() { org.neo4j.kernel.api.KernelTransaction transaction = actions.kernelTransaction(); if ( transaction.isTerminated() ) { Status terminationReason = transaction.getReasonIfTerminated().orElse( Status.Transaction.Terminated ); throw new TransactionTerminatedException( terminationReason ); } return transaction; } }
private KernelTransaction safeAcquireTransaction() { KernelTransaction transaction = spi.kernelTransaction(); if ( transaction.isTerminated() ) { Status terminationReason = transaction.getReasonIfTerminated().orElse( Status.Transaction.Terminated ); throw new TransactionTerminatedException( terminationReason ); } return transaction; }
@Override public void validateTransaction() throws KernelException { KernelTransaction tx = ctx.currentTransaction; if ( tx != null ) { Optional<Status> statusOpt = tx.getReasonIfTerminated(); if ( statusOpt.isPresent() ) { if ( statusOpt.get().code().classification().rollbackTransaction() ) { ctx.pendingTerminationNotice = statusOpt.get(); reset(); } } } }
private static KernelTransaction newTimedOutTransaction() { KernelTransaction transaction = newTransaction(); when( transaction.getReasonIfTerminated() ).thenReturn( Optional.of( Status.Transaction.TransactionTimedOut ) ); return transaction; }
private void assertInUnterminatedTransaction( KernelTransaction transaction ) { if ( availabilityGuard.isShutdown() ) { throw new DatabaseShutdownException(); } if ( transaction == null ) { throw new BridgeNotInTransactionException(); } if ( transaction.isTerminated() ) { throw new TransactionTerminatedException( transaction.getReasonIfTerminated().orElse( Status.Transaction.Terminated ) ); } }
@Test public void disposeAllMarksAllTransactionsForTermination() throws Throwable { KernelTransactions kernelTransactions = newKernelTransactions(); KernelTransaction tx1 = getKernelTransaction( kernelTransactions ); KernelTransaction tx2 = getKernelTransaction( kernelTransactions ); KernelTransaction tx3 = getKernelTransaction( kernelTransactions ); kernelTransactions.disposeAll(); assertEquals( Status.General.DatabaseUnavailable, tx1.getReasonIfTerminated().get() ); assertEquals( Status.General.DatabaseUnavailable, tx2.getReasonIfTerminated().get() ); assertEquals( Status.General.DatabaseUnavailable, tx3.getReasonIfTerminated().get() ); }
@Test public void shouldReturnTerminationReason() { KernelTransaction kernelTransaction = mock( KernelTransaction.class ); when( kernelTransaction.getReasonIfTerminated() ).thenReturn( Optional.empty() ) .thenReturn( Optional.of( Status.Transaction.Interrupted ) ); PlaceboTransaction tx = new PlaceboTransaction( kernelTransaction ); Optional<Status> terminationReason1 = tx.terminationReason(); Optional<Status> terminationReason2 = tx.terminationReason(); assertFalse( terminationReason1.isPresent() ); assertTrue( terminationReason2.isPresent() ); assertEquals( Status.Transaction.Interrupted, terminationReason2.get() ); } }
@Test public void shouldReturnTerminationReason() { KernelTransaction kernelTransaction = mock( KernelTransaction.class ); when( kernelTransaction.getReasonIfTerminated() ).thenReturn( Optional.empty() ) .thenReturn( Optional.of( Status.Transaction.Terminated ) ); TopLevelTransaction tx = new TopLevelTransaction( kernelTransaction ); Optional<Status> terminationReason1 = tx.terminationReason(); Optional<Status> terminationReason2 = tx.terminationReason(); assertFalse( terminationReason1.isPresent() ); assertTrue( terminationReason2.isPresent() ); assertEquals( Status.Transaction.Terminated, terminationReason2.get() ); } }
@Test public void shouldRollbackOnClosingSuccessfulButTerminatedTransaction() throws Exception { try ( KernelTransaction transaction = newTransaction( loginContext() ) ) { // WHEN transactionInitializer.accept( transaction ); transaction.markForTermination( Status.General.UnknownError ); assertEquals( Status.General.UnknownError, transaction.getReasonIfTerminated().get() ); } // THEN verify( transactionMonitor, times( 1 ) ).transactionFinished( false, isWriteTx ); verify( transactionMonitor, times( 1 ) ).transactionTerminated( isWriteTx ); verifyExtraInteractionWithTheMonitor( transactionMonitor, isWriteTx ); }
@Test public void shouldNotDowngradeFailureState() throws Exception { try ( KernelTransaction transaction = newTransaction( loginContext() ) ) { // WHEN transactionInitializer.accept( transaction ); transaction.markForTermination( Status.General.UnknownError ); transaction.failure(); assertEquals( Status.General.UnknownError, transaction.getReasonIfTerminated().get() ); } // THEN verify( transactionMonitor, times( 1 ) ).transactionFinished( false, isWriteTx ); verify( transactionMonitor, times( 1 ) ).transactionTerminated( isWriteTx ); verifyExtraInteractionWithTheMonitor( transactionMonitor, isWriteTx ); }
@Test void shouldDoNothingInAutoCommitTransactionUponInitialisationWhenValidated() throws Exception { KernelTransaction transaction = newTimedOutTransaction(); TransactionStateMachineV1SPI stateMachineSPI = newTransactionStateMachineSPI( transaction ); TransactionStateMachine stateMachine = newTransactionStateMachine( stateMachineSPI ); // We're in auto-commit state assertThat( stateMachine.state, is( TransactionStateMachine.State.AUTO_COMMIT ) ); assertNull( stateMachine.ctx.currentTransaction ); // call validate transaction stateMachine.validateTransaction(); assertThat( stateMachine.state, is( TransactionStateMachine.State.AUTO_COMMIT ) ); assertNull( stateMachine.ctx.currentTransaction ); verify( transaction, never() ).getReasonIfTerminated(); verify( transaction, never() ).failure(); verify( transaction, never() ).close(); }
@Test void shouldResetInExplicitTransactionUponTxBeginWhenValidated() throws Exception { KernelTransaction transaction = newTimedOutTransaction(); TransactionStateMachineV1SPI stateMachineSPI = newTransactionStateMachineSPI( transaction ); TransactionStateMachine stateMachine = newTransactionStateMachine( stateMachineSPI ); // start an explicit transaction stateMachine.beginTransaction( null ); assertThat( stateMachine.state, is( TransactionStateMachine.State.EXPLICIT_TRANSACTION ) ); assertNotNull( stateMachine.ctx.currentTransaction ); // verify transaction, which is timed out stateMachine.validateTransaction(); assertThat( stateMachine.state, is( TransactionStateMachine.State.AUTO_COMMIT ) ); assertNull( stateMachine.ctx.currentTransaction ); assertNull( stateMachine.ctx.currentResult ); assertNull( stateMachine.ctx.currentResultHandle ); verify( transaction, times( 1 ) ).getReasonIfTerminated(); verify( transaction, times( 1 ) ).failure(); verify( transaction, times( 1 ) ).close(); }
@Test public void shouldDisposeTransactionsWhenAsked() throws Throwable { // Given KernelTransactions transactions = newKernelTransactions(); transactions.disposeAll(); KernelTransaction first = getKernelTransaction( transactions ); KernelTransaction second = getKernelTransaction( transactions ); KernelTransaction leftOpen = getKernelTransaction( transactions ); first.close(); second.close(); // When transactions.disposeAll(); // Then KernelTransaction postDispose = getKernelTransaction( transactions ); assertThat( postDispose, not( equalTo( first ) ) ); assertThat( postDispose, not( equalTo( second ) ) ); assertNotNull( leftOpen.getReasonIfTerminated() ); }