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) { }