//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private int applyToStore(java.util.Collection<org.neo4j.storageengine.api.StorageCommand> commands, long logIndex) throws org.neo4j.kernel.impl.util.collection.NoSuchEntryException
private int ApplyToStore(ICollection <StorageCommand> commands, long logIndex)
{
int tokenId = ExtractTokenId(commands);
PhysicalTransactionRepresentation representation = new PhysicalTransactionRepresentation(commands);
representation.SetHeader(encodeLogIndexAsTxHeader(logIndex), 0, 0, 0, 0L, 0L, 0);
try
{
using (LockGroup ignored = new LockGroup())
{
_commitProcess.commit(new TransactionToApply(representation, _versionContext), CommitEvent.NULL, TransactionApplicationMode.EXTERNAL);
}
}
catch (TransactionFailureException e)
{
throw new Exception(e);
}
return(tokenId);
}
//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));
}
// check for transactions in the lock stage that can exit it,
// and for transactions in the wait stage that can enter the lock stage,
// and for expired group lock
private Task LockWork()
{
logger.Trace("/LockWork");
if (currentGroup != null)
{
// check if there are any group members that are ready to exit the lock
if (currentGroup.Count > 0)
{
if (LockExits(out var single, out var multiple))
{
if (single != null)
{
EnqueueCommit(single);
}
else if (multiple != null)
{
foreach (var r in multiple)
{
EnqueueCommit(r);
}
}
lockWorker.Notify();
storageWorker.Notify();
}
else if (currentGroup.Deadline < DateTime.UtcNow)
{
// the lock group has timed out.
var txlist = string.Join(",", currentGroup.Keys.Select(g => g.ToString()));
logger.Warn(555, $"break-lock timeout for {currentGroup.Count} transactions {txlist}");
AbortExecutingTransactions("after lock timeout");
lockWorker.Notify();
}
else if (currentGroup.Deadline.HasValue)
{
// check again when the group expires
lockWorker.Notify(currentGroup.Deadline.Value);
}
}
else
{
// the lock is empty, a new group can enter
currentGroup = currentGroup.Next;
if (currentGroup != null)
{
if (logger.IsEnabled(LogLevel.Trace))
{
logger.Trace($"lock groupsize={currentGroup.Count}");
}
// discard expired waiters that have no chance to succeed
// because they have been waiting for the lock for a longer timespan than the
// total transaction timeout
var now = DateTime.UtcNow;
List <Guid> expiredWaiters = null;
foreach (var kvp in currentGroup)
{
if (now > kvp.Value.Deadline)
{
if (expiredWaiters == null)
{
expiredWaiters = new List <Guid>();
}
expiredWaiters.Add(kvp.Key);
if (logger.IsEnabled(LogLevel.Trace))
{
logger.Trace($"expire-lock-waiter {kvp.Key}");
}
}
else
{
if (logger.IsEnabled(LogLevel.Trace))
{
logger.Trace($"enter-lock {kvp.Key}");
}
}
}
if (expiredWaiters != null)
{
foreach (var guid in expiredWaiters)
{
currentGroup.Remove(guid);
}
}
// execute all the read and update tasks
if (currentGroup.Tasks != null)
{
foreach (var t in currentGroup.Tasks)
{
t.RunSynchronously();
// look at exception to avoid UnobservedException
var ignore = t.Exception;
}
}
lockWorker.Notify();
}
}
}
logger.Trace($"\\LockWork");
return(Task.CompletedTask);
}
public FileStorage(FileStorageConfig fileStorageConfig)
{
this.fileStorageConfig = fileStorageConfig;
lockGroup = new LockGroup <string>(fileStorageConfig.LockCount, s => s.GetHashCode());
Init(fileStorageConfig);
}
public override TransactionApplier StartTx(CommandsToApply transaction, LockGroup lockGroup)
{
return(new NeoStoreTransactionApplier(_version, _neoStores, _cacheAccess, _lockService, transaction.TransactionId(), lockGroup));
}
//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;
}
}
