public TransactionActivityEntry(long transactionId, TransactionFlags flags, DebugActionType actionType, bool createdByJournalApplicator) { TransactionId = transactionId; Flags = flags; ActionType = actionType; CreatedByJournalApplicator = createdByJournalApplicator; }
public Transaction(StorageEnvironment env, long id, TransactionFlags flags, IFreeSpaceHandling freeSpaceHandling) { _dataPager = env.Options.DataPager; _env = env; _journal = env.Journal; _id = id; _freeSpaceHandling = freeSpaceHandling; Flags = flags; var scratchPagerStates = env.ScratchBufferPool.GetPagerStatesOfAllScratches(); foreach (var scratchPagerState in scratchPagerStates.Values) { scratchPagerState.AddRef(); _pagerStates.Add(scratchPagerState); } if (flags.HasFlag(TransactionFlags.ReadWrite) == false) { // for read transactions, we need to keep the pager state frozen // for write transactions, we can use the current one (which == null) _scratchPagerStates = scratchPagerStates; _state = env.State.Clone(this); _journal.GetSnapshots().ForEach(AddJournalSnapshot); return; } _state = env.State.Clone(this); InitTransactionHeader(); MarkTreesForWriteTransaction(); }
public Transaction NewTransaction(TransactionFlags flags) { bool txLockTaken = false; try { long txId = _transactionsCounter; if (flags == (TransactionFlags.ReadWrite)) { txId = _transactionsCounter + 1; _txWriter.Wait(); txLockTaken = true; } var tx = new Transaction(_pager, this, txId, flags, _freeSpaceRepository); _activeTransactions.TryAdd(txId, tx); var state = _pager.TransactionBegan(); tx.AddPagerState(state); if (flags == TransactionFlags.ReadWrite) { _freeSpaceRepository.UpdateSections(tx, OldestTransaction); } return(tx); } catch (Exception) { if (txLockTaken) { _txWriter.Release(); } throw; } }
/// <inheritdoc/> public int Commit(IEnumerable <Transaction> transactions, TransactionFlags flags = TransactionFlags.None) { var result = Table.Commit(transactions, flags); Cache.Commit(transactions, TransactionFlags.NoExceptions); return(result); }
/// <inheritdoc /> public int Commit(IEnumerable <Transaction> transactions, TransactionFlags flags = default) { lock (BaseTable) { return(BaseTable.Commit(transactions, flags)); } }
public Transaction(StorageEnvironment env, long id, TransactionFlags flags, IFreeSpaceHandling freeSpaceHandling) { _dataPager = env.Options.DataPager; _env = env; _journal = env.Journal; _id = id; _freeSpaceHandling = freeSpaceHandling; Flags = flags; var scratchPagerState = env.ScratchBufferPool.PagerState; scratchPagerState.AddRef(); _pagerStates.Add(scratchPagerState); if (flags.HasFlag(TransactionFlags.ReadWrite) == false) { _state = env.State; _journal.GetSnapshots().ForEach(AddJournalSnapshot); return; } _state = env.State.Clone(); InitTransactionHeader(); MarkTreesForWriteTransaction(); }
public Transaction(IVirtualPager pager, StorageEnvironment env, long id, TransactionFlags flags, IFreeSpaceRepository freeSpaceRepository) { _pager = pager; _env = env; _id = id; _freeSpaceRepository = freeSpaceRepository; Flags = flags; NextPageNumber = env.NextPageNumber; }
public LowLevelTransaction(StorageEnvironment env, long id, TransactionPersistentContext transactionPersistentContext, TransactionFlags flags, IFreeSpaceHandling freeSpaceHandling, ByteStringContext context = null) { env.AssertNoCatastrophicFailure(); DataPager = env.Options.DataPager; _env = env; _journal = env.Journal; _id = id; _freeSpaceHandling = freeSpaceHandling; _allocator = context ?? new ByteStringContext(); _disposeAllocator = context == null; _pagerStates = new HashSet <PagerState>(ReferenceEqualityComparer <PagerState> .Default); PersistentContext = transactionPersistentContext; Flags = flags; PageSize = DataPager.PageSize; var scratchPagerStates = env.ScratchBufferPool.GetPagerStatesOfAllScratches(); foreach (var scratchPagerState in scratchPagerStates.Values) { scratchPagerState.AddRef(); _pagerStates.Add(scratchPagerState); } if (flags != TransactionFlags.ReadWrite) { // for read transactions, we need to keep the pager state frozen // for write transactions, we can use the current one (which == null) _scratchPagerStates = scratchPagerStates; _state = env.State.Clone(); InitializeRoots(); JournalSnapshots = _journal.GetSnapshots(); return; } EnsureNoDuplicateTransactionId(id); _env.WriteTransactionPool.Reset(); _dirtyOverflowPages = _env.WriteTransactionPool.DirtyOverflowPagesPool; _scratchPagesTable = _env.WriteTransactionPool.ScratchPagesTablePool; _dirtyPages = _env.WriteTransactionPool.DirtyPagesPool; _freedPages = new HashSet <long>(NumericEqualityComparer.Instance); _unusedScratchPages = new List <PageFromScratchBuffer>(); _transactionPages = new HashSet <PageFromScratchBuffer>(PageFromScratchBufferEqualityComparer.Instance); _pagesToFreeOnCommit = new Stack <long>(); _state = env.State.Clone(); InitializeRoots(); InitTransactionHeader(); }
public ITransaction CreateTransaction(TransactionFlags flags = TransactionFlags.None) { if (UndoRedoInProgress) { return(new DummyTransaction()); } transactionCompletion = new TaskCompletionSource <int>(); return(stack.CreateTransaction(flags)); }
/// <inheritdoc /> public virtual int Commit(IEnumerable <Transaction> transactions, TransactionFlags flags = TransactionFlags.Default) { if (transactions == null) { throw new ArgumentNullException(nameof(transactions)); } var i = 0; foreach (var transaction in transactions) { try { switch (transaction.Type) { case TransactionType.Inserted: Insert(transaction.Row); break; case TransactionType.Replaced: Replace(transaction.Row); break; case TransactionType.Updated: Update(transaction.Row); break; case TransactionType.Deleted: Delete(transaction.Row); break; default: throw new NotImplementedException(); } i++; } catch (Exception ex) { Trace.TraceWarning("Error committing transaction to table <red>{0}.{1}\n{2}", Database.Name, Name, ex); if ((flags & TransactionFlags.ThrowExceptions) != 0) { throw; } break; } } return(i); }
/// <inheritdoc /> public override int Commit(IEnumerable <Transaction> transactions, TransactionFlags flags = TransactionFlags.Default) { try { return(InternalCommit(transactions, true)); } catch { if ((flags & TransactionFlags.ThrowExceptions) != 0) { throw; } return(-1); } }
public LowLevelTransaction(StorageEnvironment env, long id, TransactionFlags flags, IFreeSpaceHandling freeSpaceHandling, ByteStringContext context = null) { _dataPager = env.Options.DataPager; _pageSize = this.DataPager.PageSize; _env = env; _journal = env.Journal; _id = id; _freeSpaceHandling = freeSpaceHandling; _allocator = context ?? new ByteStringContext(); _pageCache = new PageCache(this, 8); Flags = flags; PageSize = _dataPager.PageSize; var scratchPagerStates = env.ScratchBufferPool.GetPagerStatesOfAllScratches(); foreach (var scratchPagerState in scratchPagerStates.Values) { scratchPagerState.AddRef(); _pagerStates.Add(scratchPagerState); } if (flags != TransactionFlags.ReadWrite) { // for read transactions, we need to keep the pager state frozen // for write transactions, we can use the current one (which == null) _scratchPagerStates = scratchPagerStates; _state = env.State.Clone(); InitializeRoots(); foreach (var snapshot in _journal.GetSnapshots()) { AddJournalSnapshot(snapshot); } return; } _state = env.State.Clone(); InitializeRoots(); InitTransactionHeader(); }
public TransactionRequest(byte[] buffer, int offset, bool isUnicode) : base(buffer, offset, isUnicode) { TotalParameterCount = LittleEndianConverter.ToUInt16(this.SMBParameters, 0); TotalDataCount = LittleEndianConverter.ToUInt16(this.SMBParameters, 2); MaxParameterCount = LittleEndianConverter.ToUInt16(this.SMBParameters, 4); MaxDataCount = LittleEndianConverter.ToUInt16(this.SMBParameters, 6); MaxSetupCount = ByteReader.ReadByte(this.SMBParameters, 8); Reserved1 = ByteReader.ReadByte(this.SMBParameters, 9); Flags = (TransactionFlags)LittleEndianConverter.ToUInt16(this.SMBParameters, 10); Timeout = LittleEndianConverter.ToUInt32(this.SMBParameters, 12); Reserved2 = LittleEndianConverter.ToUInt16(this.SMBParameters, 16); ushort ParameterCount = LittleEndianConverter.ToUInt16(this.SMBParameters, 18); ushort ParameterOffset = LittleEndianConverter.ToUInt16(this.SMBParameters, 20); ushort DataCount = LittleEndianConverter.ToUInt16(this.SMBParameters, 22); ushort DataOffset = LittleEndianConverter.ToUInt16(this.SMBParameters, 24); byte SetupCount = ByteReader.ReadByte(this.SMBParameters, 26); Reserved3 = ByteReader.ReadByte(this.SMBParameters, 27); Setup = ByteReader.ReadBytes(this.SMBParameters, 28, SetupCount * 2); if (this.SMBData.Length > 0) // Workaround, Some SAMBA clients will set ByteCount to 0 (Popcorn Hour A-400) { int dataOffset = 0; if (this is Transaction2Request) { Name = String.Empty; int nameLength = 1; dataOffset += nameLength; } else { if (isUnicode) { int namePadding = 1; dataOffset += namePadding; } Name = SMB1Helper.ReadSMBString(this.SMBData, ref dataOffset, isUnicode); } } TransParameters = ByteReader.ReadBytes(buffer, ParameterOffset, ParameterCount); TransData = ByteReader.ReadBytes(buffer, DataOffset, DataCount); }
/// <inheritdoc/> public ITransaction CreateTransaction(TransactionFlags flags = TransactionFlags.None) { lock (lockObject) { if (RollInProgress) { throw new TransactionException("Unable to create a transaction. A rollback or rollforward operation is in progress."); } var transaction = new Transaction(this, flags); if ((flags & TransactionFlags.KeepParentsAlive) != 0) { foreach (var parentTransaction in transactionsInProgress) { parentTransaction.AddReference(); } } transactionsInProgress.Push(transaction); TransactionInProgress = true; return(transaction); } }
/// <inheritdoc /> public int Commit(IEnumerable <Transaction> transactions, TransactionFlags flags = default) => BaseTable.Commit(transactions, flags);
/// <inheritdoc /> public int Commit(IEnumerable <Transaction> transactions, TransactionFlags flags = TransactionFlags.Default) => WriteLocked(() => BaseTable.Commit(transactions, flags));
internal LowLevelTransaction NewLowLevelTransaction(TransactionPersistentContext transactionPersistentContext, TransactionFlags flags, ByteStringContext context = null, TimeSpan?timeout = null) { bool txLockTaken = false; bool flushInProgressReadLockTaken = false; try { if (flags == TransactionFlags.ReadWrite) { var wait = timeout ?? (Debugger.IsAttached ? TimeSpan.FromMinutes(30) : TimeSpan.FromSeconds(30)); if (FlushInProgressLock.IsWriteLockHeld == false) { flushInProgressReadLockTaken = FlushInProgressLock.TryEnterReadLock(wait); } if (Monitor.IsEntered(_txWriter)) { ThrowOnRecursiveWriteTransaction(); } Monitor.TryEnter(_txWriter, wait, ref txLockTaken); if (txLockTaken == false || (flushInProgressReadLockTaken == false && FlushInProgressLock.IsWriteLockHeld == false)) { GlobalFlushingBehavior.GlobalFlusher.Value.MaybeFlushEnvironment(this); ThrowOnTimeoutWaitingForWriteTxLock(wait); } _writeTransactionRunning.SetByAsyncCompletion(); if (_endOfDiskSpace != null) { if (_endOfDiskSpace.CanContinueWriting) { CatastrophicFailure = null; _endOfDiskSpace = null; _cancellationTokenSource = new CancellationTokenSource(); Task.Run(IdleFlushTimer); GlobalFlushingBehavior.GlobalFlusher.Value.MaybeFlushEnvironment(this); } } } LowLevelTransaction tx; _txCommit.EnterReadLock(); try { long txId = flags == TransactionFlags.ReadWrite ? _transactionsCounter + 1 : _transactionsCounter; tx = new LowLevelTransaction(this, txId, transactionPersistentContext, flags, _freeSpaceHandling, context) { FlushInProgressLockTaken = flushInProgressReadLockTaken }; ActiveTransactions.Add(tx); } finally { _txCommit.ExitReadLock(); } var state = _dataPager.PagerState; tx.EnsurePagerStateReference(state); return(tx); } catch (Exception) { if (txLockTaken) { Monitor.Exit(_txWriter); } if (flushInProgressReadLockTaken) { FlushInProgressLock.ExitReadLock(); } throw; } }
public void BeginTransaction(TransactionScope scope, int objectId = -1, int subIdx = -1, TransactionFlags flags = TransactionFlags.None) { Debug.Assert(transactions.Count == 0 || transactions.Last().IsEnded); if (index != transactions.Count) { transactions.RemoveRange(index, transactions.Count - index); } var trans = new Transaction(project, app, scope, flags, objectId, subIdx); transactions.Add(trans); trans.Begin(); index++; TransactionBegan?.Invoke(scope, flags); project.Validate(); }
internal LowLevelTransaction NewLowLevelTransaction(TransactionPersistentContext transactionPersistentContext, TransactionFlags flags, ByteStringContext context = null, TimeSpan?timeout = null) { _cancellationTokenSource.Token.ThrowIfCancellationRequested(); bool txLockTaken = false; bool flushInProgressReadLockTaken = false; try { IncrementUsageOnNewTransaction(); if (flags == TransactionFlags.ReadWrite) { var wait = timeout ?? (Debugger.IsAttached ? TimeSpan.FromMinutes(30) : TimeSpan.FromSeconds(30)); if (FlushInProgressLock.IsWriteLockHeld == false) { flushInProgressReadLockTaken = FlushInProgressLock.TryEnterReadLock(wait); } txLockTaken = _transactionWriter.Wait(wait); if (txLockTaken == false || (flushInProgressReadLockTaken == false && FlushInProgressLock.IsWriteLockHeld == false)) { GlobalFlushingBehavior.GlobalFlusher.Value.MaybeFlushEnvironment(this); ThrowOnTimeoutWaitingForWriteTxLock(wait); } _cancellationTokenSource.Token.ThrowIfCancellationRequested(); _currentTransactionHolder = NativeMemory.ThreadAllocations.Value; WriteTransactionStarted(); if (_endOfDiskSpace != null) { _endOfDiskSpace.AssertCanContinueWriting(); _endOfDiskSpace = null; Task.Run(IdleFlushTimer); GlobalFlushingBehavior.GlobalFlusher.Value.MaybeFlushEnvironment(this); } } LowLevelTransaction tx; _txCommit.EnterReadLock(); try { _cancellationTokenSource.Token.ThrowIfCancellationRequested(); if (_currentTransactionHolder == null) { _currentTransactionHolder = NativeMemory.ThreadAllocations.Value; } long txId = flags == TransactionFlags.ReadWrite ? NextWriteTransactionId : CurrentReadTransactionId; tx = new LowLevelTransaction(this, txId, transactionPersistentContext, flags, _freeSpaceHandling, context) { FlushInProgressLockTaken = flushInProgressReadLockTaken, CurrentTransactionHolder = _currentTransactionHolder }; ActiveTransactions.Add(tx); } finally { _txCommit.ExitReadLock(); } var state = _dataPager.PagerState; tx.EnsurePagerStateReference(state); return(tx); } catch (Exception) { try { if (txLockTaken) { _transactionWriter.Release(); } if (flushInProgressReadLockTaken) { FlushInProgressLock.ExitReadLock(); } } finally { DecrementUsageOnTransactionCreationFailure(); } throw; } }
/// <summary> /// Initializes a new instance of the <see cref="Transaction"/> class. /// </summary> /// <param name="transactionStack">The <see cref="TransactionStack"/> associated to this transaction.</param> /// <param name="flags">The flags to apply to this transaction.</param>. public Transaction(TransactionStack transactionStack, TransactionFlags flags) { this.transactionStack = transactionStack; this.Flags = flags; synchronizationContext = SynchronizationContext.Current; }
public void BeginTransaction(TransactionScope scope, TransactionFlags flags) { BeginTransaction(scope, -1, -1, flags); }
public Transaction NewTransaction(TransactionFlags flags, TimeSpan? timeout = null) { bool txLockTaken = false; try { if (flags == (TransactionFlags.ReadWrite)) { var wait = timeout ?? (Debugger.IsAttached ? TimeSpan.FromMinutes(30) : TimeSpan.FromSeconds(30)); Monitor.TryEnter(_txWriter, wait, ref txLockTaken); if (txLockTaken == false) { throw new TimeoutException("Waited for " + wait + " for transaction write lock, but could not get it"); } if (_endOfDiskSpace != null) { if (_endOfDiskSpace.CanContinueWriting) { var flushingTask = _flushingTask; Debug.Assert(flushingTask != null && (flushingTask.Status == TaskStatus.Canceled || flushingTask.Status == TaskStatus.RanToCompletion)); _cancellationTokenSource = new CancellationTokenSource(); _flushingTask = FlushWritesToDataFileAsync(); _endOfDiskSpace = null; } } } Transaction tx; _txCommit.EnterReadLock(); try { long txId = flags == TransactionFlags.ReadWrite ? _transactionsCounter + 1 : _transactionsCounter; tx = new Transaction(this, txId, flags, _freeSpaceHandling); if (IsDebugRecording) { RecordTransactionState(tx, DebugActionType.TransactionStart); tx.RecordTransactionState = RecordTransactionState; } } finally { _txCommit.ExitReadLock(); } _activeTransactions.Add(tx); var state = _dataPager.TransactionBegan(); tx.AddPagerState(state); if (flags == TransactionFlags.ReadWrite) { tx.AfterCommit = TransactionAfterCommit; } return tx; } catch (Exception) { if (txLockTaken) Monitor.Exit(_txWriter); throw; } }
public Transaction NewTransaction(TransactionFlags flags, TimeSpan?timeout = null) { bool txLockTaken = false; try { if (flags == (TransactionFlags.ReadWrite)) { var wait = timeout ?? (Debugger.IsAttached ? TimeSpan.FromMinutes(30) : TimeSpan.FromSeconds(30)); if (_txWriter.Wait(wait) == false) { throw new TimeoutException("Waited for " + wait + " for transaction write lock, but could not get it"); } txLockTaken = true; if (_endOfDiskSpace != null) { if (_endOfDiskSpace.CanContinueWriting) { var flushingTask = _flushingTask; Debug.Assert(flushingTask != null && (flushingTask.Status == TaskStatus.Canceled || flushingTask.Status == TaskStatus.RanToCompletion)); _cancellationTokenSource = new CancellationTokenSource(); _flushingTask = FlushWritesToDataFileAsync(); _endOfDiskSpace = null; } } } Transaction tx; _txCommit.EnterReadLock(); try { long txId = flags == TransactionFlags.ReadWrite ? _transactionsCounter + 1 : _transactionsCounter; tx = new Transaction(this, txId, flags, _freeSpaceHandling); if (IsDebugRecording) { RecordTransactionState(tx, DebugActionType.TransactionStart); tx.RecordTransactionState = RecordTransactionState; } } finally { _txCommit.ExitReadLock(); } _activeTransactions.Add(tx); var state = _dataPager.TransactionBegan(); tx.AddPagerState(state); if (flags == TransactionFlags.ReadWrite) { tx.AfterCommit = TransactionAfterCommit; } return(tx); } catch (Exception) { if (txLockTaken) { _txWriter.Release(); } throw; } }
public LowLevelTransaction(StorageEnvironment env, long id, TransactionPersistentContext transactionPersistentContext, TransactionFlags flags, IFreeSpaceHandling freeSpaceHandling, ByteStringContext context = null) { TxStartTime = DateTime.UtcNow; if (flags == TransactionFlags.ReadWrite) { env.Options.AssertNoCatastrophicFailure(); } DataPager = env.Options.DataPager; _env = env; _journal = env.Journal; _id = id; _freeSpaceHandling = freeSpaceHandling; _allocator = context ?? new ByteStringContext(SharedMultipleUseFlag.None); _disposeAllocator = context == null; _pagerStates = new HashSet <PagerState>(ReferenceEqualityComparer <PagerState> .Default); PersistentContext = transactionPersistentContext; Flags = flags; var scratchPagerStates = env.ScratchBufferPool.GetPagerStatesOfAllScratches(); foreach (var scratchPagerState in scratchPagerStates.Values) { scratchPagerState.AddRef(); _pagerStates.Add(scratchPagerState); } _pageLocator = transactionPersistentContext.AllocatePageLocator(this); if (flags != TransactionFlags.ReadWrite) { // for read transactions, we need to keep the pager state frozen // for write transactions, we can use the current one (which == null) _scratchPagerStates = scratchPagerStates; _state = env.State.Clone(); InitializeRoots(); JournalSnapshots = _journal.GetSnapshots(); return; } EnsureNoDuplicateTransactionId(id); // we keep this copy to make sure that if we use async commit, we have a stable copy of the jounrals // as they were at the time we started the original transaction, this is required because async commit // may modify the list of files we have available JournalFiles = _journal.Files; foreach (var journalFile in JournalFiles) { journalFile.AddRef(); } _env.WriteTransactionPool.Reset(); _dirtyOverflowPages = _env.WriteTransactionPool.DirtyOverflowPagesPool; _scratchPagesTable = _env.WriteTransactionPool.ScratchPagesInUse; _dirtyPages = _env.WriteTransactionPool.DirtyPagesPool; _freedPages = new HashSet <long>(NumericEqualityComparer.BoxedInstanceInt64); _unusedScratchPages = new List <PageFromScratchBuffer>(); _transactionPages = new HashSet <PageFromScratchBuffer>(PageFromScratchBufferEqualityComparer.Instance); _pagesToFreeOnCommit = new Stack <long>(); _state = env.State.Clone(); InitializeRoots(); InitTransactionHeader(); }
public Transaction NewTransaction(TransactionFlags flags, TimeSpan? timeout = null) { var voronTransaction = _storageEnvironment.NewTransaction(flags, timeout); return new Transaction(voronTransaction, _nodeTreeName, _edgeTreeName, _disconnectedNodesTreeName); }
/// <summary> /// Give Money to destination Object or Avatar /// </summary> /// <param name="target">UUID of the Target Object/Avatar</param> /// <param name="amount">Amount in L$</param> /// <param name="description">Reason (Optional normally)</param> /// <param name="type">The type of transaction</param> /// <param name="flags">Transaction flags, mostly for identifying group /// transactions</param> public void GiveMoney(UUID target, int amount, string description, MoneyTransactionType type, TransactionFlags flags) { MoneyTransferRequestPacket money = new MoneyTransferRequestPacket(); money.AgentData.AgentID = this.id; money.AgentData.SessionID = Client.Self.SessionID; money.MoneyData.Description = Utils.StringToBytes(description); money.MoneyData.DestID = target; money.MoneyData.SourceID = this.id; money.MoneyData.TransactionType = (int)type; money.MoneyData.AggregatePermInventory = 0; // This is weird, apparently always set to zero though money.MoneyData.AggregatePermNextOwner = 0; // This is weird, apparently always set to zero though money.MoneyData.Flags = (byte)flags; money.MoneyData.Amount = amount; Client.Network.SendPacket(money); }
internal LowLevelTransaction NewLowLevelTransaction(TransactionFlags flags, ByteStringContext context = null, TimeSpan?timeout = null) { bool txLockTaken = false; bool flushInProgressReadLockTaken = false; try { if (flags == TransactionFlags.ReadWrite) { var wait = timeout ?? (Debugger.IsAttached ? TimeSpan.FromMinutes(30) : TimeSpan.FromSeconds(30)); if (FlushInProgressLock.IsWriteLockHeld == false) { flushInProgressReadLockTaken = FlushInProgressLock.TryEnterReadLock(wait); } Monitor.TryEnter(_txWriter, wait, ref txLockTaken); if (txLockTaken == false || (flushInProgressReadLockTaken == false && FlushInProgressLock.IsWriteLockHeld == false)) { GlobalFlusher.Value.MaybeFlushEnvironment(this); throw new TimeoutException("Waited for " + wait + " for transaction write lock, but could not get it"); } if (_endOfDiskSpace != null) { if (_endOfDiskSpace.CanContinueWriting) { _flushingTaskFailure = null; _endOfDiskSpace = null; _cancellationTokenSource = new CancellationTokenSource(); Task.Run(IdleFlushTimer); GlobalFlusher.Value.MaybeFlushEnvironment(this); } } } LowLevelTransaction tx; _txCommit.EnterReadLock(); try { long txId = flags == TransactionFlags.ReadWrite ? _transactionsCounter + 1 : _transactionsCounter; tx = new LowLevelTransaction(this, txId, flags, _freeSpaceHandling, context); } finally { _txCommit.ExitReadLock(); } _activeTransactions.Add(tx); var state = _dataPager.PagerState; tx.EnsurePagerStateReference(state); return(tx); } catch (Exception) { if (txLockTaken) { Monitor.Exit(_txWriter); } if (flushInProgressReadLockTaken) { FlushInProgressLock.ExitReadLock(); } throw; } }