feat(orleans): added orleans aop

AElf.ExceptionHandler/AOPExceptionModule.cs

@@ -1,5 +1,6 @@
 using System.Collections.Concurrent;
 using Microsoft.Extensions.DependencyInjection;
+using Orleans;
 using Volo.Abp;
 using Volo.Abp.Modularity;
 
@@ -10,9 +11,10 @@ public class AOPExceptionModule : AbpModule
     public override void ConfigureServices(ServiceConfigurationContext context)
     {
         context.Services.AddTransient<ExceptionHandlerInterceptor>()
-                        .AddTransient<IInterceptor, ExceptionHandler>()
-                        .AddSingleton<ConcurrentDictionary<string, ExceptionHandlerInfo>>()
-                        .AddSingleton<ConcurrentDictionary<string, Func<object, object[], Task>>>();
+            .AddTransient<IInterceptor, ExceptionHandler>()
+            .AddSingleton<ConcurrentDictionary<string, ExceptionHandlerInfo>>()
+            .AddSingleton<ConcurrentDictionary<string, Func<object, object[], Task>>>()
+            .AddSingleton<IIncomingGrainCallFilter, AttributeCallFilter>();
 
         context.Services.OnRegistered(options =>
         {
@@ -31,4 +33,4 @@ public override void ConfigureServices(ServiceConfigurationContext context)
             }
         });
     }
-}
+}

AElf.ExceptionHandler/AttributeCallFilter.cs

@@ -0,0 +1,64 @@
+using Microsoft.Extensions.DependencyInjection;
+using Orleans;
+using Orleans.Serialization.Invocation;
+
+namespace AElf.ExceptionHandler;
+
+public class AttributeCallFilter : IIncomingGrainCallFilter
+{
+    public async Task Invoke(IIncomingGrainCallContext context)
+    {
+        if (context.ImplementationMethod.IsDefined(typeof(ExceptionHandlerAttribute), true))
+        {
+            var exceptionHandler = context.TargetContext.ActivationServices.GetService<ExceptionHandler>();
+
+            if (exceptionHandler == null)
+            {
+                throw new Exception("ExceptionHandler is not registered.");
+            }
+
+            var arguments = new object?[context.Request.GetArgumentCount()];
+            for (var i = 0; i < context.Request.GetArgumentCount(); ++i)
+            {
+                arguments[i] = context.Request.GetArgument(i);
+            }
+
+            var methodExecutionArgs = new MethodExecutionArgs
+            {
+                TargetObject = context.Grain,
+                MethodInfo = context.ImplementationMethod,
+                Arguments = arguments!,
+                ReturnValue = null,
+                Exception = null,
+                Invocation = async () =>
+                {
+                    await context.Invoke();
+                }
+            };
+
+            await exceptionHandler.InterceptAsync(methodExecutionArgs);
+
+            if (methodExecutionArgs.Exception != null)
+            {
+                context.Response = new ExceptionResponse
+                {
+                    Exception = methodExecutionArgs.Exception
+                };
+            }
+            else
+            {
+                if (methodExecutionArgs.ReturnValue != null)
+                {
+                    var responseType = typeof(Response<>).MakeGenericType(methodExecutionArgs.ReturnValue.GetType());
+                    var response = Activator.CreateInstance(responseType);
+                    responseType.GetProperty("Result")?.SetValue(response, methodExecutionArgs.ReturnValue);
+                    context.Response = (Response)response!;
+                }
+            }
+        }
+        else
+        {
+            await context.Invoke();
+        }
+    }
+}

AElf.ExceptionHandler/ExceptionHandler.cs

@@ -1,10 +1,11 @@
 using System.Collections.Concurrent;
 using System.Linq.Expressions;
 using System.Reflection;
+using Volo.Abp.DependencyInjection;
 
 namespace AElf.ExceptionHandler;
 
-public class ExceptionHandler : IInterceptor
+public class ExceptionHandler : ITransientDependency, IInterceptor
 {
     private readonly ConcurrentDictionary<string, ExceptionHandlerInfo> MethodCache;
     private readonly ConcurrentDictionary<string, Func<object, object[], Task>> FinallyCache;
@@ -162,6 +163,7 @@ private bool HandleInnerException(Exception exception, MethodExecutionArgs args,
 
         if(flowBehavior.ExceptionHandlingStrategy == ExceptionHandlingStrategy.Rethrow)
         {
+            args.Exception = exception;
             throw exception;
         }
 
@@ -172,9 +174,12 @@ private bool HandleInnerException(Exception exception, MethodExecutionArgs args,
 
         if(flowBehavior.ExceptionHandlingStrategy == ExceptionHandlingStrategy.Throw)
         {
-            throw (Exception)flowBehavior.ReturnValue!;
+            var newException = (Exception)flowBehavior.ReturnValue!;
+            args.Exception = newException;
+            throw newException;
         }
-
+
+        args.Exception = null;
         args.ReturnValue = flowBehavior.ReturnValue;
         return true;
     }

AElf.ExceptionHandler/MethodExecutionArgs.cs

@@ -9,4 +9,5 @@ public class MethodExecutionArgs
     public object[] Arguments { get; set; }
     public object? ReturnValue { get; set; }
     public Func<Task> Invocation { get; set; }
+    public Exception? Exception { get; set; }
 }