Skip to content

Commit

Permalink
Revert "Merge pull request #8643 from MishaDemianenko/3.2-transaction…
Browse files Browse the repository at this point in the history 
…-statusv2"

This reverts commit 7cb4fb9, reversing
changes made to dc2b76c.
  • Loading branch information
@tinwelint
tinwelint committed Jan 30, 2017
1 parent 43da0dd commit 61eaf11
Show file tree
Hide file tree
Showing 8 changed files with 133 additions and 914 deletions.
316 changes: 107 additions & 209 deletions ...unity/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactionImplementation.java
View file

Large diffs are not rendered by default.

7 changes: 1 addition & 6 deletions community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactions.java
View file
Expand Up @@ -39,6 +39,7 @@
import org.neo4j.kernel.impl.api.state.LegacyIndexTransactionStateImpl;
import org.neo4j.kernel.impl.factory.AccessCapability;
import org.neo4j.kernel.impl.index.IndexConfigStore;
import org.neo4j.kernel.impl.locking.LockTracer;
import org.neo4j.kernel.impl.locking.StatementLocks;
import org.neo4j.kernel.impl.locking.StatementLocksFactory;
import org.neo4j.kernel.impl.proc.Procedures;
Expand Down Expand Up @@ -181,7 +182,6 @@ public Set<KernelTransactionHandle> activeTransactions()
public void disposeAll()
{
terminateTransactions();
markAllTransactionsAsShutdown();
localTxPool.disposeAll();
globalTxPool.disposeAll();
}
Expand All @@ -191,11 +191,6 @@ public void terminateTransactions()
markAllTransactionsAsTerminated();
}

private void markAllTransactionsAsShutdown()
{
allTransactions.forEach( KernelTransactionImplementation::markAsShutdown );
}

private void markAllTransactionsAsTerminated()
{
// we mark all transactions for termination since we want to make sure these transactions
Expand Down
2 changes: 1 addition & 1 deletion ...unity/kernel/src/main/java/org/neo4j/kernel/impl/core/ThreadToStatementContextBridge.java
View file
Expand Up @@ -115,7 +115,7 @@ public KernelTransaction getKernelTransactionBoundToThisThread( boolean strict )
return getTopLevelTransactionBoundToThisThread( strict );
}

// Exceptions below extend the public API exceptions with versions that have status codes.
// Exeptions below extend the public API exceptions with versions that have status codes.
private static class BridgeNotInTransactionException extends NotInTransactionException implements Status.HasStatus
{
@Override
Expand Down
202 changes: 9 additions & 193 deletions ...y/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionImplementationTest.java
View file
Expand Up @@ -24,7 +24,6 @@
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.mockito.Mockito;

import java.util.Arrays;
import java.util.Collection;
Expand All @@ -36,7 +35,6 @@

import org.neo4j.graphdb.TransactionTerminatedException;
import org.neo4j.kernel.api.KernelTransaction;
import org.neo4j.kernel.api.TransactionHook;
import org.neo4j.kernel.api.exceptions.Status;
import org.neo4j.kernel.api.exceptions.TransactionFailureException;
import org.neo4j.kernel.api.security.AnonymousContext;
Expand All @@ -47,13 +45,9 @@
import org.neo4j.kernel.impl.locking.SimpleStatementLocks;
import org.neo4j.kernel.impl.transaction.TransactionMonitor;
import org.neo4j.kernel.impl.transaction.command.Command;
import org.neo4j.kernel.impl.transaction.tracing.CommitEvent;
import org.neo4j.kernel.impl.transaction.tracing.TransactionEvent;
import org.neo4j.storageengine.api.StorageCommand;
import org.neo4j.storageengine.api.StorageStatement;
import org.neo4j.storageengine.api.StoreReadLayer;
import org.neo4j.storageengine.api.lock.ResourceLocker;
import org.neo4j.storageengine.api.txstate.ReadableTransactionState;
import org.neo4j.test.DoubleLatch;

import static java.util.concurrent.TimeUnit.MILLISECONDS;
Expand All @@ -70,7 +64,6 @@
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
Expand Down Expand Up @@ -476,6 +469,15 @@ public void shouldIncrementReuseCounterOnReuse() throws Exception
assertEquals( reuseCount + 1, transaction.getReuseCount() );
}

@Test
public void markForTerminationNotInitializedTransaction()
{
KernelTransactionImplementation tx = newNotInitializedTransaction();
tx.markForTermination( Status.General.UnknownError );

assertEquals( Status.General.UnknownError, tx.getReasonIfTerminated().get() );
}

@Test
public void markForTerminationInitializedTransaction()
{
Expand Down Expand Up @@ -708,79 +710,6 @@ public void markForTerminationWithIncorrectReuseCount() throws Exception
verify( locksClient, never() ).stop();
}

@Test
public void transactionIsOpenAfterInitialization()
{
KernelTransactionImplementation transaction = newNotInitializedTransaction();
assertFalse( transaction.isOpen() );

transaction.initialize( 100, 100, new SimpleStatementLocks( new NoOpClient() ),
KernelTransaction.Type.explicit, securityContext(), 100 );
assertTrue( transaction.isOpen() );
}

@Test
public void transactionIsClosedAfterCommit() throws TransactionFailureException
{
KernelTransactionImplementation tx = newTransaction( 1000 );
assertTrue( tx.isOpen() );

tx.success();
tx.close();

assertTrue( tx.isClosed() );
}

@Test
public void transactionIsClosedAfterRollback() throws TransactionFailureException
{
KernelTransactionImplementation tx = newTransaction( 1000 );
assertTrue( tx.isOpen() );

tx.failure();
tx.close();

assertTrue( tx.isClosed() );
}

@Test
public void closeShutdownTransactionIsNotAllowed() throws TransactionFailureException
{
KernelTransactionImplementation transaction = newTransaction( 1000 );
transaction.markAsShutdown();

expectedException.expect( TransactionTerminatedException.class );
expectedException.expectMessage( "The transaction has been terminated. Retry your operation in a " +
"new transaction, and you should see a successful result. " +
"The database is not currently available to serve your request, " +
"refer to the database logs for more details. Retrying your request at a later time may succeed." );
transaction.close();
}

@Test
public void closeLocksOnTransactionShutdown()
{
Locks.Client locksClient = mock( Locks.Client.class );
KernelTransactionImplementation transaction = newTransaction( securityContext(), locksClient );
transaction.markAsShutdown();

verify( locksClient ).close();
}

@Test
public void closeClosingTransactionNotAllowed() throws TransactionFailureException
{
Locks.Client locksClient = mock( Locks.Client.class );
KernelTransactionImplementation transaction = newTransaction( securityContext(), locksClient );
transaction.txState().nodeDoCreate( 42L );
hooks.register( new ClosingTransactionHook() );
transaction.success();

expectedException.expect( IllegalStateException.class );
expectedException.expectMessage("Transaction is already closing. Repeated execution of transactions are not allowed." );
transaction.closeTransaction();
}

@Test
public void closeClosedTransactionIsNotAllowed() throws TransactionFailureException
{
Expand All @@ -792,43 +721,6 @@ public void closeClosedTransactionIsNotAllowed() throws TransactionFailureExcept
transaction.close();
}

@Test
public void returnTransactionToPoolWhenLocksCloseFailOrRelease() throws TransactionFailureException
{
Locks.Client client = Mockito.mock( Locks.Client.class );
RuntimeException locksCloseException = new RuntimeException( "Locks close exception." );
doThrow( locksCloseException ).when( client ).close();
KernelTransactionImplementation transaction =
newTransaction( 1L, SecurityContext.AUTH_DISABLED, client, 2L );

try
{
transaction.close();
fail("Locks close are expected to throw exception.");
}
catch ( Throwable e )
{
assertSame( "Same as supplier exception for locks close.", locksCloseException, e.getCause() );
}
verify( txPool ).release( transaction );
assertTrue( transaction.isClosed() );
}

@Test
public void postFailedtransactionEventWhenClosingTerminatedTransaction() throws TransactionFailureException
{
TrackingTransactionEvent transactionEvent = new TrackingTransactionEvent();
KernelTransactionImplementation transaction = newNotInitializedTransaction( () -> transactionEvent );
SimpleStatementLocks statementLocks = new SimpleStatementLocks( new NoOpClient() );

transaction.initialize( 1L, 2L, statementLocks,
KernelTransaction.Type.explicit, SecurityContext.AUTH_DISABLED, 3L );
transaction.markForTermination( Status.Transaction.Terminated );
transaction.close();

assertTrue( transactionEvent.isFailure() );
}

private SecurityContext securityContext()
{
return isWriteTx ? AnonymousContext.write() : AnonymousContext.read();
Expand All @@ -843,80 +735,4 @@ private void initializeAndClose( KernelTransactionImplementation tx, int times )
tx.close();
}
}

private static class ClosingTransactionHook implements TransactionHook
{
@Override
public Outcome beforeCommit( ReadableTransactionState state, KernelTransaction transaction,
StoreReadLayer storeReadLayer, StorageStatement statement )
{
try
{
transaction.closeTransaction();
}
catch ( TransactionFailureException e )
{
throw new RuntimeException( e );
}
return null;
}

@Override
public void afterCommit( ReadableTransactionState state, KernelTransaction transaction, Outcome outcome )
{

}

@Override
public void afterRollback( ReadableTransactionState state, KernelTransaction transaction, Outcome outcome )
{

}
}

private static class TrackingTransactionEvent implements TransactionEvent
{
private boolean failure;

@Override
public void setSuccess( boolean success )
{

}

@Override
public void setFailure( boolean failure )
{
this.failure = failure;
}

@Override
public CommitEvent beginCommitEvent()
{
return null;
}

@Override
public void close()
{

}

@Override
public void setTransactionType( String transactionTypeName )
{

}

@Override
public void setReadOnly( boolean wasReadOnly )
{

}

public boolean isFailure()
{
return failure;
}
}
}

0 comments on commit 61eaf11

Please sign in to comment.