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);
}
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();
}
/// <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);
}
public TransactionActivityEntry(long transactionId, TransactionFlags flags, DebugActionType actionType, bool createdByJournalApplicator)
{
TransactionId = transactionId;
Flags = flags;
ActionType = actionType;
CreatedByJournalApplicator = createdByJournalApplicator;
}
/// <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;
}
}
