public async Task InvokeAsync(object[] args, string route, string serviceName, Dictionary <string, string> meta = default)
{
var service = ServiceFactory.Get(route);
using (var scope = ServiceProvider.CreateScope())
{
var context = new InterceptorContext
{
ServiceProvider = scope.ServiceProvider,
Args = args,
ServiceRoute = route,
Meta = meta,
MethodInfo = service.MethodInfo,
ServiceName = serviceName
};
context.Interceptors.Push(typeof(ClientDefaultInterceptor));
foreach (var interceptor in service.ClientInterceptors)
{
context.Interceptors.Push(interceptor);
}
if (UraganoSettings.ClientGlobalInterceptors.Any())
{
foreach (var interceptor in UraganoSettings.ClientGlobalInterceptors)
{
context.Interceptors.Push(interceptor);
}
}
await((IInterceptor)scope.ServiceProvider.GetRequiredService(context.Interceptors.Pop())).Intercept(context);
}
}
public virtual object Invoke(InterceptorContext context)
{
object returnValue = context.Invoke();
Console.WriteLine(string.Format("processed, return value: {0}", returnValue));
return(returnValue);
}
public T Save()
{
try
{
if (proxy == null)
{
Confirm.Assertion(register.Keys.Count > 0, "Proxy definition must specify what members have to be intercepted. Specify one or more members utilizing Intercept*() methods.");
Confirm.Assertion(register.All(vp => vp.Value.Count > 0), "One or more intercepted members do not specify how to handle interception. Specify interception behavior utilizing On*() methods.");
states = new InterceptorStateCollection();
foreach (var key in register.Keys)
{
states.Add(new InterceptorState(key, register[key]));
}
context = new InterceptorContext(states);
proxy = (target == null) ?
CilBuilder.Create <T>(context, implementedTypes.ToArray()) :
CilBuilder.Create <T>(target, context, implementedTypes.ToArray());
}
}
catch (Exception ex)
{
throw new ProxyInitializationException("Unable to create proxy: " + ex.Message, ex);
}
return(proxy);
}
public async Task <IServiceResult> Invoke(string route, object[] args, Dictionary <string, string> meta)
{
if (!ServiceInvokers.TryGetValue(route, out var service))
{
throw new NotFoundRouteException(route);
}
using (var scope = ServiceProvider.CreateScope())
{
var context = new InterceptorContext
{
ServiceRoute = service.Route,
ServiceProvider = scope.ServiceProvider,
Args = args,
Meta = meta,
MethodInfo = service.MethodInfo
};
context.Interceptors.Push(typeof(ServerDefaultInterceptor));
foreach (var interceptor in service.ServerInterceptors)
{
context.Interceptors.Push(interceptor);
}
if (UraganoSettings.ServerGlobalInterceptors.Any())
{
foreach (var interceptor in UraganoSettings.ServerGlobalInterceptors)
{
context.Interceptors.Push(interceptor);
}
}
return(await((IInterceptor)scope.ServiceProvider.GetRequiredService(context.Interceptors.Pop()))
.Intercept(context));
}
}
public InterceptControl BeforeProcess(InterceptorContext ctx)
{
Console.WriteLine(ctx.Target);
ctx.ReturnValue.SetValue("000");
ctx.Context["a"] = 1;
return(InterceptControl.SkipAll);
}
public ScenarioSetupAndTeardown(StreamInfoContainer streamInfoContainer,
InMemoryStoreSessionContainer sessionContainer,
InterceptorContext interceptorContext)
{
this.streamInfoContainer = streamInfoContainer;
this.sessionContainer = sessionContainer;
this.interceptorContext = interceptorContext;
}
public HttpResponseMessage Post([FromBody] InterceptorContext value)
{
if (Request.Headers.Contains("Authorization"))
{
return(Request.CreateResponse <String>(HttpStatusCode.OK, String.Join(",", Request.Headers.GetValues("Authorization"))));
// if the request header contains the auth token then strip it out.
}
return(Request.CreateResponse <String>(HttpStatusCode.OK, "NO AUTHORIZATION HEADER"));
}
public ScenarioSetupAndTeardown(StreamInfoContainer streamInfoContainer,
InMemoryStoreSessionContainer sessionContainer,
InterceptorContext interceptorContext,
PassThroughValidator passThroughValidator)
{
this.streamInfoContainer = streamInfoContainer;
this.sessionContainer = sessionContainer;
this.interceptorContext = interceptorContext;
this.passThroughValidator = passThroughValidator;
}
public InterceptControl AfterProcess(InterceptorContext ctx)
{
Console.WriteLine(ctx.Target);
foreach (var o in ctx.Parameters.Select(e => e.GetValue()))
{
Console.WriteLine(o);
}
Console.WriteLine(ctx.ReturnValue.GetValue());
Console.WriteLine(ctx.Context["a"] + "0");
ctx.ReturnValue.SetValue("AAAA");
return(InterceptControl.None);
}
public void BeforeInvoke(InterceptorContext context)
{
string strArgs = string.Empty;
foreach (var arg in context.Args)
{
strArgs += arg + " ";
}
Console.WriteLine(string.Format("Before Invoke in {0}::{1} Parameters: {2}", context.TargetMethodInfo.DeclaringType.FullName, context.TargetMethodInfo, strArgs));
LogAttribute logAttr = (context.TargetMethodInfo.GetCustomAttributes(typeof(LogAttribute), false) as LogAttribute[])[0];
Console.WriteLine("Log Level: {0}", logAttr.Level);
}
public virtual object Invoke(InterceptorContext context)
{
TransactionAttribute transAttr = (context.TargetMethodInfo.GetCustomAttributes(typeof(TransactionAttribute), true) as TransactionAttribute[])[0];
TransactionOptions options = new TransactionOptions();
options.IsolationLevel = transAttr.IsolationLevel;
options.Timeout = transAttr.TimeOut;
using (TransactionScope tran = new TransactionScope(transAttr.ScopeOption, options, transAttr.EnterpriseServicesInteropOption))
{
object returnValue = context.Invoke();
tran.Complete();
return(returnValue);
}
}
public async Task <T> InvokeAsync <T>(object[] args, string route, string serviceName, Dictionary <string, string> meta = default)
{
var service = ServiceFactory.Get(route);
using (var scope = ServiceProvider.CreateScope())
{
var context = new InterceptorContext
{
ServiceProvider = scope.ServiceProvider,
Args = args,
ServiceRoute = route,
Meta = meta,
MethodInfo = service.MethodInfo,
ReturnType = typeof(T),
ServiceName = serviceName
};
context.Interceptors.Push(typeof(ClientDefaultInterceptor));
if (service.CachingConfig != null)
{
context.Interceptors.Push(typeof(CachingDefaultInterceptor));
}
foreach (var interceptor in service.ClientInterceptors)
{
context.Interceptors.Push(interceptor);
}
if (UraganoSettings.ClientGlobalInterceptors.Any())
{
foreach (var interceptor in UraganoSettings.ClientGlobalInterceptors)
{
context.Interceptors.Push(interceptor);
}
}
var result = await((IInterceptor)scope.ServiceProvider.GetRequiredService(context.Interceptors.Pop())).Intercept(context);
if (result.Status != RemotingStatus.Ok)
{
throw new RemoteInvokeException(route, result.Result?.ToString(), result.Status);
}
return(result.Result == null ? default : (T)result.Result);
}
}
public virtual void OnException(InterceptorContext context, Exception e)
{
ThrowsAttribute throwAttr = (context.TargetMethodInfo.GetCustomAttributes(typeof(ThrowsAttribute), false) as ThrowsAttribute[])[0];
string strArgs = string.Empty;
foreach (var arg in context.Args)
{
strArgs += arg + " ";
}
string strErrMsg = string.Format("Error in: {0}::{1} \r\nArgs: {2} \r\nError Message: {3}\r\nCode: {4}",
context.TargetMethodInfo.DeclaringType,
context.TargetMethodInfo,
strArgs,
e.InnerException.Message,
throwAttr.Code);
Console.WriteLine(strErrMsg);
}
private static void BindInterceptorTypeMap <TInterface>(IServiceCollection services, TypeMap typeMap, ServiceLifetime lifetime)
{
var implementationType = typeMap.ImplementationType;
var serviceTypes = typeMap.ServiceTypes.Where(t => t != typeof(IProxySelector) &&
t != typeof(IInterceptorContext) &&
t != typeof(IProxyGenerator) &&
t != typeof(ISingletonType) &&
t != typeof(IScopedType) &&
t != typeof(ITransientType)).ToList();
foreach (var serviceType in serviceTypes)
{
var oldDescription = services.FirstOrDefault(t => t.ServiceType == typeof(TInterface));
if (oldDescription != null)
{
services.Remove(oldDescription);
}
services.Add(new ServiceDescriptor(implementationType, implementationType, lifetime));
services.AddTransient(serviceType, sp =>
{
IProxySelector proxySelector = sp.GetRequiredService <IProxySelector>();
bool isIncludeAspect = proxySelector.ShouldInterceptType(implementationType);
if (!implementationType.IsAssignableTo(serviceType))
{
throw new InvalidOperationException($@"Type ""{implementationType.ToFriendlyName()}"" is not assignable to ""${serviceType.ToFriendlyName()}"".");
}
object obj = sp.GetRequiredService(implementationType);
IProxyGenerator objProxy = new ProxyGenerator(proxySelector);
IInterceptorContext context = new InterceptorContext();
return(objProxy.Create(serviceType, implementationType, obj, context));
});
}
}
public async Task <IServiceResult> InvokeAsync(string route, object[] args, Dictionary <string, string> meta)
{
var service = Get(route);
using (var scope = ServiceProvider.CreateScope())
{
var context = new InterceptorContext
{
ServiceRoute = service.Route,
ServiceProvider = scope.ServiceProvider,
Args = args,
Meta = meta,
MethodInfo = service.ServerMethodInfo
};
context.Interceptors.Push(typeof(ServerDefaultInterceptor));
foreach (var interceptor in service.ServerInterceptors)
{
context.Interceptors.Push(interceptor);
}
return(await((IInterceptor)scope.ServiceProvider.GetRequiredService(context.Interceptors.Pop()))
.Intercept(context));
}
}
public void AfterInvoke(InterceptorContext context)
{
Console.WriteLine(string.Format("After Invoke in {0}::{1}", context.TargetMethodInfo.DeclaringType.FullName, context.TargetMethodInfo));
}
public ExceptionAspect(InterceptorContext context) : base(context)
{
}
public void BeforeInvoke(InterceptorContext context)
{
Console.WriteLine("before enter method oh yeah");
}
public object Invoke(InterceptorContext context)
{
return(context.Invoke());
}
public InterceptorSteps(InterceptorContext interceptorContext) => this.interceptorContext = interceptorContext;
protected override object Invoke(MethodInfo targetMethod, object[] args)
{
IInterceptorContext context = new InterceptorContext(this.ServiceProvider,
this.HttpClient,
targetMethod,
args,
new OriginalMethod(_args => this.Invoke(targetMethod, _args))
);
IEnumerable <IInterceptor> interceptors = this.ServiceProvider.GetServices <IInterceptor>();
foreach (var item in interceptors)
{
item.OnPreInvoke(context);
if (context.Result != null)
{
return(context.Result);
}
}
HttpProxyOptions option = this.ServiceProvider.GetService <HttpProxyOptions>();
IEnumerable <IContentSerializer> contentSerializers = this.ServiceProvider.GetServices <IContentSerializer>();
IUrlBuilder urlBuilder = this.ServiceProvider.GetService <IUrlBuilder>();
ClientMethodDescription description = new ClientMethodDescription(targetMethod);
string clientName = this.GetClientName(targetMethod);
string url = option.ClientNameToHostMap[clientName];
foreach (var item in interceptors)
{
item.OnClientUrlFound(context, ref url);
if (context.Result != null)
{
return(context.Result);
}
}
if (description.TypeRoute.Path != "")
{
url += description.TypeRoute.Path;
}
url += description.MethodRoute.Path;
urlBuilder.SetTemplate(url);
HttpContent content = null;
for (int i = 0; i < description.ParameterDescriptions.Length; i++)
{
var parameterDescr = description.ParameterDescriptions[i];
if (parameterDescr.PathVariableAttribute != null)
{
urlBuilder.SetPathVariable(parameterDescr.ParameterInfo.Name, args[i].ToString());
continue;
}
if (parameterDescr.QueryStringAttribute != null)
{
urlBuilder.AddQueryString(parameterDescr.QueryStringAttribute.Name, args[i].ToString());
continue;
}
if (parameterDescr.ContentAttribute != null)
{
foreach (var serializers in contentSerializers)
{
if (!serializers.MatchMediaType(parameterDescr.ContentAttribute.MediaType))
{
continue;
}
content = new StringContent(serializers.Serialize(args[i]));
content.Headers.ContentType = new MediaTypeHeaderValue(parameterDescr.ContentAttribute.MediaType);
break;
}
}
}
foreach (var item in interceptors)
{
item.OnHttpClientPrepaired(context);
if (context.Result != null)
{
return(context.Result);
}
}
HttpResponseMessage message;
switch (description.Verb)
{
case Verbs.Get:
message = AsyncHelper.ExecuteAndWait(HttpClient.GetAsync(url));
break;
case Verbs.Post:
message = AsyncHelper.ExecuteAndWait(HttpClient.PostAsync(url, content));
break;
case Verbs.Put:
message = AsyncHelper.ExecuteAndWait(HttpClient.PutAsync(url, content));
break;
case Verbs.Delete:
message = AsyncHelper.ExecuteAndWait(HttpClient.DeleteAsync(url));
break;
case Verbs.Patch:
message = AsyncHelper.ExecuteAndWait(HttpClient.PatchAsync(url, content));
break;
default:
throw new NotImplementedException();
}
foreach (var item in interceptors)
{
item.OnRespond(context, message);
if (context.Result != null)
{
return(context.Result);
}
}
if (targetMethod.ReturnType == typeof(void))
{
return(null);
}
if (targetMethod.ReturnType == typeof(HttpResponseMessage))
{
return(message);
}
if (targetMethod.ReturnType == typeof(HttpContent))
{
return(message.Content);
}
if (targetMethod.ReturnType == typeof(string))
{
return(AsyncHelper.ExecuteAndWait(message.Content.ReadAsStringAsync()));
}
if (targetMethod.ReturnType == typeof(Stream))
{
return(AsyncHelper.ExecuteAndWait(message.Content.ReadAsStreamAsync()));
}
if (targetMethod.ReturnType == typeof(byte[]))
{
return(AsyncHelper.ExecuteAndWait(message.Content.ReadAsByteArrayAsync()));
}
string mediaType = message.Content.Headers.ContentType.MediaType;
foreach (var serializer in contentSerializers)
{
if (!serializer.MatchMediaType(mediaType))
{
continue;
}
return(serializer.Deserialize(AsyncHelper.ExecuteAndWait(message.Content.ReadAsStringAsync()), targetMethod.ReturnType));
}
return(null);
}
public AfterAspect(InterceptorContext context) : base(context)
{
}
public BeforeAspect1(InterceptorContext context) : base(context)
{
}
