public static async Task ExcuteTccMethod(this ILmsMethodInvocation invocation, TccMethodType tccMethodType)
{
var serviceEntry = invocation.ArgumentsDictionary["serviceEntry"] as ServiceEntry;
Debug.Assert(serviceEntry != null);
var serviceKey = invocation.ArgumentsDictionary["serviceKey"] as string;
var parameters = invocation.ArgumentsDictionary["parameters"] as object[];
if (serviceEntry.IsLocal)
{
var excutorInfo = serviceEntry.GetTccExcutorInfo(serviceKey, tccMethodType);
if (excutorInfo.Item2)
{
invocation.ReturnValue = await excutorInfo.Item1.ExecuteAsync(excutorInfo.Item3, parameters);
}
else
{
invocation.ReturnValue = excutorInfo.Item1.Execute(excutorInfo.Item3, parameters);
}
}
else
{
await invocation.ProceedAsync();
}
}
protected virtual void Validate(ILmsMethodInvocation invocation)
{
_methodInvocationValidator.Validate(
new MethodInvocationValidationContext(
invocation.Method,
invocation.Arguments
)
);
}
protected override void Validate(ILmsMethodInvocation invocation)
{
var serviceEntry = invocation.ArgumentsDictionary["serviceEntry"] as ServiceEntry;
Debug.Assert(serviceEntry != null);
var parameters = invocation.ArgumentsDictionary["parameters"] as object[];
parameters = serviceEntry.ConvertParameters(parameters);
_methodInvocationValidator.Validate(
new MethodInvocationValidationContext(
serviceEntry.MethodInfo,
parameters
)
);
}
public async override Task InterceptAsync(ILmsMethodInvocation invocation)
{
var argumentsDictionary = invocation.ArgumentsDictionary;
var serviceEntry = argumentsDictionary["serviceEntry"] as ServiceEntry;
Debug.Assert(serviceEntry != null);
if (!serviceEntry.IsTransactionServiceEntry())
{
await invocation.ProceedAsync();
}
else
{
var transactionContext = RpcContext.GetContext().GetTransactionContext();
await TransactionAspectInvoker.GetInstance().Invoke(transactionContext, invocation);
}
}
public async Task Handler(TransactionContext context, ILmsMethodInvocation invocation)
{
var transaction = executor.PreTry(invocation);
try
{
await invocation.ProceedAsync();
transaction.Status = ActionStage.Trying;
executor.UpdateStartStatus(transaction);
await executor.GlobalConfirm(transaction);
}
catch (Exception e)
{
await executor.GlobalCancel(transaction);
throw;
}
}
public async override Task InterceptAsync(ILmsMethodInvocation invocation)
{
var servcieId = _serviceIdGenerator.GenerateServiceId(invocation.Method);
var serviceEntry = _serviceEntryLocator.GetServiceEntryById(servcieId);
try
{
invocation.ReturnValue =
await _serviceExecutor.Execute(serviceEntry, invocation.Arguments, _currentServiceKey.ServiceKey);
}
catch (Exception e)
{
if (!e.IsBusinessException() && serviceEntry.FallBackExecutor != null)
{
await invocation.ProceedAsync();
}
else
{
throw;
}
}
}
public async Task Handler(TransactionContext context, ILmsMethodInvocation invocation)
{
IParticipant participant = null;
switch (context.Action)
{
case ActionStage.Trying:
try
{
participant = executor.PreTryParticipant(context, invocation);
await invocation.ProceedAsync();
if (participant != null)
{
participant.Status = ActionStage.Trying;
}
}
catch (Exception e)
{
if (participant != null)
{
LmsTransactionHolder.Instance.CurrentTransaction.RemoveParticipant(participant);
}
throw;
}
break;
case ActionStage.Confirming:
await invocation.ExcuteTccMethod(TccMethodType.Confirm);
break;
case ActionStage.Canceling:
await invocation.ExcuteTccMethod(TccMethodType.Cancel);
break;
}
}
public override async Task InterceptAsync(ILmsMethodInvocation invocation)
{
Validate(invocation);
await invocation.ProceedAsync();
}
public override async Task InterceptAsync(ILmsMethodInvocation invocation)
{
var serviceEntry = invocation.ArgumentsDictionary["serviceEntry"] as ServiceEntry;
var serviceKey = invocation.ArgumentsDictionary["serviceKey"] as string;
var parameters = invocation.ArgumentsDictionary["parameters"] as object[];
async Task <object> GetResultFirstFromCache(string cacheName, string cacheKey, ServiceEntry entry)
{
_distributedCache.UpdateCacheName(cacheName);
return(await _distributedCache.GetOrAddAsync(cacheKey,
serviceEntry.MethodInfo.GetReturnType(),
async() => await entry.Executor(serviceKey, parameters)));
}
if (serviceEntry.GovernanceOptions.CacheEnabled)
{
var removeCachingInterceptProviders = serviceEntry.RemoveCachingInterceptProviders;
if (removeCachingInterceptProviders.Any())
{
foreach (var removeCachingInterceptProvider in removeCachingInterceptProviders)
{
var removeCacheKey = serviceEntry.GetCachingInterceptKey(parameters, removeCachingInterceptProvider);
_distributedCache.UpdateCacheName(removeCachingInterceptProvider.CacheName);
await _distributedCache.RemoveAsync(removeCacheKey, true);
}
}
if (serviceEntry.GetCachingInterceptProvider != null)
{
if (serviceEntry.IsTransactionServiceEntry())
{
await invocation.ProceedAsync();
}
else
{
var getCacheKey = serviceEntry.GetCachingInterceptKey(parameters,
serviceEntry.GetCachingInterceptProvider);
invocation.ReturnValue = await GetResultFirstFromCache(
serviceEntry.GetCachingInterceptProvider.CacheName,
getCacheKey,
serviceEntry);
}
}
else if (serviceEntry.UpdateCachingInterceptProvider != null)
{
if (serviceEntry.IsTransactionServiceEntry())
{
await invocation.ProceedAsync();
}
else
{
var updateCacheKey = serviceEntry.GetCachingInterceptKey(parameters,
serviceEntry.UpdateCachingInterceptProvider);
await _distributedCache.RemoveAsync(updateCacheKey);
invocation.ReturnValue = await GetResultFirstFromCache(
serviceEntry.GetCachingInterceptProvider.CacheName,
updateCacheKey,
serviceEntry);
}
}
else
{
await invocation.ProceedAsync();
}
}
else
{
await invocation.ProceedAsync();
}
}
public async Task Handler(TransactionContext context, ILmsMethodInvocation invocation)
{
var serviceEntry = invocation.ArgumentsDictionary["serviceEntry"] as ServiceEntry;
Debug.Assert(serviceEntry != null);
if (serviceEntry.IsLocal)
{
context.Action = ActionStage.PreTry;
await executor.ConsumerParticipantExecute(context, invocation, TccMethodType.Try);
context.Action = ActionStage.Trying;
invocation.ReturnValue = await executor.ConsumerParticipantExecute(context, invocation, TccMethodType.Confirm);
context.Action = ActionStage.Confirming;
}
else
{
if (context.Action != ActionStage.PreTry)
{
context.TransactionRole = TransactionRole.Participant;
}
var participant = executor.PreTryParticipant(context, invocation);
try
{
await invocation.ProceedAsync();
if (participant != null)
{
participant.Status = ActionStage.Trying;
}
}
catch (Exception e)
{
var currentTrans = LmsTransactionHolder.Instance.CurrentTransaction;
foreach (var participantItem in currentTrans.Participants)
{
if (participantItem.Role == TransactionRole.Participant &&
participantItem.Status == ActionStage.Trying)
{
context.Action = ActionStage.Canceling;
context.TransactionRole = TransactionRole.Participant;
context.ParticipantId = participantItem.ParticipantId;
context.ParticipantRefId = participantItem.ParticipantRefId;
RpcContext.GetContext().SetTransactionContext(context);
await participantItem.Invocation.ProceedAsync();
}
if (participantItem.Role == TransactionRole.Consumer &&
participantItem.Status == ActionStage.Trying)
{
invocation.ReturnValue = await executor.ConsumerParticipantExecute(context, invocation, TccMethodType.Cancel);
context.Action = ActionStage.Canceling;
}
}
throw;
}
}
}
public abstract Task InterceptAsync(ILmsMethodInvocation invocation);
