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);