//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void apply(org.neo4j.storageengine.api.CommandsToApply batch, org.neo4j.storageengine.api.TransactionApplicationMode mode) throws Exception
public override void Apply(CommandsToApply batch, TransactionApplicationMode mode)
{
// Have these command appliers as separate try-with-resource to have better control over
// point between closing this and the locks above
try
{
using (IndexActivator indexActivator = new IndexActivator(_indexingService), LockGroup locks = new LockGroup(), BatchTransactionApplier batchApplier = Applier(mode, indexActivator))
{
while (batch != null)
{
using (TransactionApplier txApplier = batchApplier.StartTx(batch, locks))
{
batch.Accept(txApplier);
}
batch = batch.Next();
}
}
}
catch (Exception cause)
{
TransactionApplyKernelException kernelException = new TransactionApplyKernelException(cause, "Failed to apply transaction: %s", batch);
_databaseHealth.panic(kernelException);
throw kernelException;
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldCloseLockGroupAfterAppliers() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldCloseLockGroupAfterAppliers()
{
// given
long nodeId = 5;
LockService lockService = mock(typeof(LockService));
Lock nodeLock = mock(typeof(Lock));
when(lockService.AcquireNodeLock(nodeId, Org.Neo4j.Kernel.impl.locking.LockService_LockType.WriteLock)).thenReturn(nodeLock);
System.Action <bool> applierCloseCall = mock(typeof(System.Action)); // <-- simply so that we can use InOrder mockito construct
CapturingBatchTransactionApplierFacade applier = new CapturingBatchTransactionApplierFacade(this, applierCloseCall);
RecordStorageEngine engine = RecordStorageEngineBuilder().lockService(lockService).transactionApplierTransformer(applier.wrapAroundActualApplier).build();
CommandsToApply commandsToApply = mock(typeof(CommandsToApply));
when(commandsToApply.Accept(any())).thenAnswer(invocationOnMock =>
{
// Visit one node command
Visitor <StorageCommand, IOException> visitor = invocationOnMock.getArgument(0);
NodeRecord after = new NodeRecord(nodeId);
after.InUse = true;
visitor.visit(new Command.NodeCommand(new NodeRecord(nodeId), after));
return(null);
});
// when
engine.Apply(commandsToApply, TransactionApplicationMode.INTERNAL);
// then
InOrder inOrder = inOrder(lockService, applierCloseCall, nodeLock);
inOrder.verify(lockService).acquireNodeLock(nodeId, Org.Neo4j.Kernel.impl.locking.LockService_LockType.WriteLock);
inOrder.verify(applierCloseCall).accept(true);
inOrder.verify(nodeLock, times(1)).release();
inOrder.verifyNoMoreInteractions();
}
public override TransactionApplier StartTx(CommandsToApply transaction)
{
Optional <CountsAccessor_Updater> result = _countsTracker.apply(transaction.TransactionId());
result.ifPresent(updater => this._countsUpdater = updater);
Debug.Assert(this._countsUpdater != null || _mode == TransactionApplicationMode.RECOVERY);
return(new CountsStoreTransactionApplier(_mode, _countsUpdater));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void panicOnExceptionDuringCommandsApply()
public virtual void PanicOnExceptionDuringCommandsApply()
{
System.InvalidOperationException failure = new System.InvalidOperationException("Too many open files");
RecordStorageEngine engine = _storageEngineRule.getWith(_fsRule.get(), _pageCacheRule.getPageCache(_fsRule.get()), _testDirectory.databaseLayout()).databaseHealth(_databaseHealth).transactionApplierTransformer(facade => TransactionApplierFacadeTransformer(facade, failure)).build();
CommandsToApply commandsToApply = mock(typeof(CommandsToApply));
try
{
engine.Apply(commandsToApply, TransactionApplicationMode.INTERNAL);
fail("Exception expected");
}
catch (Exception exception)
{
assertSame(failure, Exceptions.rootCause(exception));
}
verify(_databaseHealth).panic(any(typeof(Exception)));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public TransactionApplier startTx(org.neo4j.storageengine.api.CommandsToApply transaction) throws java.io.IOException
public override TransactionApplier StartTx(CommandsToApply transaction)
{
long activeTransactionId = transaction.TransactionId();
try
{
// Cache transactionApplier because it has some expensive lookups
if (_txApplier == null)
{
_txApplier = new ExplicitIndexTransactionApplier(_applierLookup, _indexConfigStore, _mode, _transactionOrdering);
}
if (transaction.RequiresApplicationOrdering())
{
// Index operations must preserve order so wait for previous tx to finish
_transactionOrdering.waitFor(activeTransactionId);
// And set current tx so we can notify the next transaction when we are finished
if (transaction.Next() != null)
{
// Let each transaction notify the next
_txApplier.TransactionId = activeTransactionId;
}
else
{
// except the last transaction, which notifies that it is done after appliers have been closed
_lastTransactionId = activeTransactionId;
}
}
return(_txApplier);
}
catch (InterruptedException e)
{
Thread.CurrentThread.Interrupt();
throw new IOException("Interrupted while waiting for applying tx:" + activeTransactionId + " explicit index updates", e);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.neo4j.kernel.impl.api.TransactionApplier startTx(org.neo4j.storageengine.api.CommandsToApply transaction, org.neo4j.kernel.impl.locking.LockGroup lockGroup) throws java.io.IOException
public override TransactionApplier StartTx(CommandsToApply transaction, LockGroup lockGroup)
{
return(Actual.startTx(transaction, lockGroup));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.neo4j.kernel.impl.api.TransactionApplier startTx(org.neo4j.storageengine.api.CommandsToApply transaction) throws java.io.IOException
public override TransactionApplier StartTx(CommandsToApply transaction)
{
return(Actual.startTx(transaction));
}
public override TransactionApplier StartTx(CommandsToApply transaction, LockGroup lockGroup)
{
return(new NeoStoreTransactionApplier(_version, _neoStores, _cacheAccess, _lockService, transaction.TransactionId(), lockGroup));
}
public override TransactionApplier StartTx(CommandsToApply transaction)
{
throw new Exception("NeoStoreTransactionApplier requires a LockGroup");
}
public override TransactionApplier StartTx(CommandsToApply transaction)
{
_txId = transaction.TransactionId();
return(_transactionApplier);
}
