public override void Rollback()
{
if (state == I_TRANSACTION_STATE.PARENT_CONFLICT)
{
Monitor.Enter(parentTransaction.SubTransactionsLocker);
try
{
if (parentTransaction.State != I_TRANSACTION_STATE.ROLLBACKED_BY_SUBTRANSACTION)
{
ParentTransaction.SetMemoryVersionsToCurrent();
}
}
finally
{
Monitor.Exit(parentTransaction.SubTransactionsLocker);
}
}
if (state == I_TRANSACTION_STATE.COMMITED)
{
//
//set memory to previous version
//
}
memoryRefsToUpdate.Clear();
memoryChanges.Clear();
memoryStartVersions.Clear();
}
public Common.Contracts.Tracking.Transaction ToCommonTransaction()
{
Common.Contracts.Tracking.Transaction tx = new Common.Contracts.Tracking.Transaction()
{
TransactionId = TransactionId,
Action = Action,
Purpose = Purpose,
Event = Event,
ParentTransaction = ParentTransaction?.ToCommonTransaction(),
SecretKey = SecretKey,
SecretUri = SecretUri
};
DateTime start = DateTime.UtcNow; DateTime?end = null;
Common.Contracts.ProcessResult.ProcessingStatus startingStatus = Common.Contracts.ProcessResult.ProcessingStatus.Pending;
Common.Contracts.ProcessResult.ProcessingStatus?endingStatus = null;
List <Common.Contracts.Tracking.ProcessingAttempt> attempts = new List <Common.Contracts.Tracking.ProcessingAttempt>();
if (null != Attempts)
{
foreach (var attempt in Attempts)
{
if (attempt.StartTimeUtc <= start)
{
start = attempt.StartTimeUtc;
startingStatus = attempt.StartingStatus;
}
if (false == end.HasValue)
{
end = attempt.EndTimeUtc;
}
if (attempt.EndTimeUtc.HasValue && attempt.EndTimeUtc.Value >= end.Value)
{
end = attempt.EndTimeUtc;
endingStatus = attempt.EndingStatus;
}
attempts.Add(attempt);
}
}
tx.Attempts = attempts;
tx.StartedOnUtc = start;
tx.EndedOnUtc = end;
tx.Status = endingStatus.HasValue ? endingStatus.Value : startingStatus;
return(tx);
}
public void FixMemoryVersion(IInnerTransactionStmMemory memoryRef, MemoryTuple memoryTuple)
{
lock (subTransactionsLocker)
{
if (!memoryStartVersions.ContainsKey(memoryRef))
{
memoryStartVersions.Add(memoryRef, memoryTuple.version[imbrication]);
if (parentTransaction != null)
{
ParentTransaction.FixMemoryVersion(memoryRef, memoryTuple);
}
}
}
}
public object GetTransactionMemoryValue(IInnerTransactionStmMemory memoryRef)
{
if (memoryChanges.ContainsKey(memoryRef))
{
return(memoryChanges[memoryRef]);
}
else
{
if (parentTransaction != null)
{
return(ParentTransaction.GetTransactionMemoryValue(memoryRef));
}
else
{
return(memoryRef.GetValue());
}
}
}
public bool ValidateMemoryVersion(IInnerTransactionStmMemory memoryRef)//ok
{
if (parentTransaction != null)
{
if (!ParentTransaction.ValidateMemoryVersion(memoryRef))
{
state = I_TRANSACTION_STATE.PARENT_CONFLICT;
return(false);
}
}
int currentImbricationMemoryVersion = memoryRef.GetVersionForImbrication(imbrication);
if (currentImbricationMemoryVersion != memoryStartVersions[memoryRef])
{
state = I_TRANSACTION_STATE.CONFLICT;
return(false);
}
return(true);
}
