//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; } }