public RedisGroupRepository(IFormatterResolver resolver, ConnectionMultiplexer connection, IMagicOnionLogger logger) { this.resolver = resolver; this.logger = logger; this.factory = CreateGroup; this.connection = connection; }
public DuplexStreamingContext(ServiceContext context) { this.context = context; this.innerReader = context.RequestStream !; this.innerWriter = context.ResponseStream !; this.logger = context.MagicOnionLogger; }
public ServiceContext( Type serviceType, MethodInfo methodInfo, ILookup <Type, Attribute> attributeLookup, MethodType methodType, ServerCallContext context, MessagePackSerializerOptions serializerOptions, IMagicOnionLogger logger, MethodHandler methodHandler, IServiceProvider serviceProvider ) { this.ContextId = Guid.NewGuid(); this.ServiceType = serviceType; this.MethodInfo = methodInfo; this.AttributeLookup = attributeLookup; this.MethodType = methodType; this.CallContext = context; this.Timestamp = DateTime.UtcNow; this.SerializerOptions = serializerOptions; this.MagicOnionLogger = logger; this.MethodHandler = methodHandler; this.ServiceProvider = serviceProvider; // streaming hub if (methodType == MethodType.DuplexStreaming) { this.streamingResponseWriter = new Lazy <QueuedResponseWriter>(new Func <QueuedResponseWriter>(CreateQueuedResponseWriter)); } else { this.streamingResponseWriter = null !; } }
public ImmutableArrayGroup(string groupName, IGroupRepository parent, MessagePackSerializerOptions serializerOptions, IMagicOnionLogger logger) { this.GroupName = groupName; this.parent = parent; this.serializerOptions = serializerOptions; this.logger = logger; this.members = ImmutableArray <ServiceContext> .Empty; }
public RedisGroupRepository(MessagePackSerializerOptions serializerOptions, RedisGroupOptions redisGroupOptions, IMagicOnionLogger logger) { this.serializerOptions = serializerOptions; this.logger = logger; this.factory = CreateGroup; this.connection = redisGroupOptions.ConnectionMultiplexer ?? throw new InvalidOperationException("RedisGroup requires add ConnectionMultiplexer to MagicOnionOptions.ServiceLocator before create it. Please try new MagicOnionOptions{DefaultServiceLocator.Register(new ConnectionMultiplexer)}"); this.db = redisGroupOptions.Db; }
public ConcurrentDictionaryGroup(string groupName, IGroupRepository parent, MessagePackSerializerOptions serializerOptions, IMagicOnionLogger logger) { this.GroupName = groupName; this.parent = parent; this.serializerOptions = serializerOptions; this.logger = logger; this.members = new ConcurrentDictionary <Guid, ServiceContext>(); }
public RedisGroupRepository(MessagePackSerializerOptions serializerOptions, RedisGroupOptions redisGroupOptions, IMagicOnionLogger logger) { this.serializerOptions = serializerOptions; this.logger = logger; this.factory = CreateGroup; this.connection = redisGroupOptions.ConnectionMultiplexer; this.db = redisGroupOptions.Db; }
public ConcurrentDictionaryGroup(string groupName, IGroupRepository parent, IFormatterResolver resolver, IMagicOnionLogger logger) { this.GroupName = groupName; this.parent = parent; this.resolver = resolver; this.logger = logger; this.members = new ConcurrentDictionary <Guid, ServiceContext>(); }
public ImmutableArrayGroup(string groupName, IGroupRepository parent, IFormatterResolver resolver, IMagicOnionLogger logger) { this.GroupName = groupName; this.parent = parent; this.resolver = resolver; this.logger = logger; this.members = ImmutableArray <ServiceContext> .Empty; }
public ServiceContext(Type serviceType, MethodInfo methodInfo, ILookup <Type, Attribute> attributeLookup, MethodType methodType, ServerCallContext context, IMagicOnionLogger logger) { this.ServiceType = serviceType; this.MethodInfo = methodInfo; this.AttributeLookup = attributeLookup; this.MethodType = methodType; this.CallContext = context; this.Timestamp = DateTime.UtcNow; this.MagicOnionLogger = logger; }
public ServiceContext( Type serviceType, MethodInfo methodInfo, ILookup <Type, Attribute> attributeLookup, MethodType methodType, ServerCallContext context, MessagePackSerializerOptions serializerOptions, IMagicOnionLogger logger, MethodHandler methodHandler, IServiceProvider serviceProvider ) { this.ContextId = Guid.NewGuid(); this.ServiceType = serviceType; this.MethodInfo = methodInfo; this.AttributeLookup = attributeLookup; this.MethodType = methodType; this.CallContext = context; this.Timestamp = DateTime.UtcNow; this.SerializerOptions = serializerOptions; this.MagicOnionLogger = logger; this.MethodHandler = methodHandler; this.ServiceProvider = serviceProvider; }
public ClientStreamingContext(ServiceContext context) { this.context = context; this.inner = context.RequestStream; this.logger = context.MagicOnionLogger; }
public ServiceContext(Type serviceType, MethodInfo methodInfo, ILookup <Type, Attribute> attributeLookup, MethodType methodType, ServerCallContext context, IFormatterResolver resolver, IMagicOnionLogger logger, MethodHandler methodHandler, IServiceLocator serviceLocator) { this.ContextId = Guid.NewGuid(); this.ServiceType = serviceType; this.MethodInfo = methodInfo; this.AttributeLookup = attributeLookup; this.MethodType = methodType; this.CallContext = context; this.Timestamp = DateTime.UtcNow; this.FormatterResolver = resolver; this.MagicOnionLogger = logger; this.MethodHandler = methodHandler; this.ServiceLocator = serviceLocator; }
public MethodHandler(MagicOnionOptions options, Type classType, MethodInfo methodInfo) { this.ServiceType = classType; this.ServiceName = classType.GetInterfaces().First(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IService <>)).GetGenericArguments()[0].Name; this.MethodInfo = methodInfo; MethodType mt; this.UnwrappedResponseType = UnwrapResponseType(methodInfo, out mt, out responseIsTask, out this.RequestType); this.MethodType = mt; this.resolver = options.FormatterResolver; var parameters = methodInfo.GetParameters(); if (RequestType == null) { this.RequestType = MagicOnionMarshallers.CreateRequestTypeAndSetResolver(classType.Name + "/" + methodInfo.Name, parameters, ref resolver); } this.AttributeLookup = classType.GetCustomAttributes(true) .Concat(methodInfo.GetCustomAttributes(true)) .Cast <Attribute>() .ToLookup(x => x.GetType()); this.filters = options.GlobalFilters .Concat(classType.GetCustomAttributes <MagicOnionFilterAttribute>(true)) .Concat(methodInfo.GetCustomAttributes <MagicOnionFilterAttribute>(true)) .OrderBy(x => x.Order) .ToArray(); // options this.isReturnExceptionStackTraceInErrorDetail = options.IsReturnExceptionStackTraceInErrorDetail; this.logger = options.MagicOnionLogger; // prepare lambda parameters var contextArg = Expression.Parameter(typeof(ServiceContext), "context"); var contextBind = Expression.Bind(classType.GetProperty("Context"), contextArg); var instance = Expression.MemberInit(Expression.New(classType), contextBind); switch (MethodType) { case MethodType.Unary: case MethodType.ServerStreaming: // (ServiceContext context) => // { // var request = LZ4MessagePackSerializer.Deserialize<T>(context.Request, context.Resolver); // var result = new FooService() { Context = context }.Bar(request.Item1, request.Item2); // return MethodHandlerResultHelper.SerializeUnaryResult(result, context); // }; try { var flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic; var staticFlags = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic; var requestArg = Expression.Parameter(RequestType, "request"); var getResolver = Expression.Property(contextArg, typeof(ServiceContext).GetProperty("FormatterResolver", flags)); var contextRequest = Expression.Property(contextArg, typeof(ServiceContext).GetProperty("Request", flags)); var callDeserialize = Expression.Call(messagePackDeserialize.MakeGenericMethod(RequestType), contextRequest, getResolver); var assignRequest = Expression.Assign(requestArg, callDeserialize); Expression[] arguments = new Expression[parameters.Length]; if (parameters.Length == 1) { arguments[0] = requestArg; } else { for (int i = 0; i < parameters.Length; i++) { arguments[i] = Expression.Field(requestArg, "Item" + (i + 1)); } } var callBody = Expression.Call(instance, methodInfo, arguments); if (MethodType == MethodType.Unary) { var finalMethod = (responseIsTask) ? typeof(MethodHandlerResultHelper).GetMethod("SerializeTaskUnaryResult", staticFlags).MakeGenericMethod(UnwrappedResponseType) : typeof(MethodHandlerResultHelper).GetMethod("SerializeUnaryResult", staticFlags).MakeGenericMethod(UnwrappedResponseType); callBody = Expression.Call(finalMethod, callBody, contextArg); } else { if (!responseIsTask) { callBody = Expression.Call(typeof(Task).GetMethod("FromResult").MakeGenericMethod(MethodInfo.ReturnType), callBody); } } var body = Expression.Block(new[] { requestArg }, assignRequest, callBody); var compiledBody = Expression.Lambda(body, contextArg).Compile(); this.methodBody = BuildMethodBodyWithFilter((Func <ServiceContext, Task>)compiledBody); } catch (Exception ex) { throw new InvalidOperationException($"Can't create handler. Path:{ToString()}", ex); } break; case MethodType.ClientStreaming: case MethodType.DuplexStreaming: if (parameters.Length != 0) { throw new InvalidOperationException($"{MethodType} does not support method parameters. If you need to send initial parameter, use header instead. Path:{ToString()}"); } // (ServiceContext context) => new FooService() { Context = context }.Bar(); try { var body = Expression.Call(instance, methodInfo); if (MethodType == MethodType.ClientStreaming) { var staticFlags = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic; var finalMethod = (responseIsTask) ? typeof(MethodHandlerResultHelper).GetMethod("SerializeTaskClientStreamingResult", staticFlags).MakeGenericMethod(RequestType, UnwrappedResponseType) : typeof(MethodHandlerResultHelper).GetMethod("SerializeClientStreamingResult", staticFlags).MakeGenericMethod(RequestType, UnwrappedResponseType); body = Expression.Call(finalMethod, body, contextArg); } else { if (!responseIsTask) { body = Expression.Call(typeof(Task).GetMethod("FromResult").MakeGenericMethod(MethodInfo.ReturnType), body); } } var compiledBody = Expression.Lambda(body, contextArg).Compile(); this.methodBody = BuildMethodBodyWithFilter((Func <ServiceContext, Task>)compiledBody); } catch (Exception ex) { throw new InvalidOperationException($"Can't create handler. Path:{ToString()}", ex); } break; default: throw new InvalidOperationException("Unknown MethodType:" + MethodType + $"Path:{ToString()}"); } }
public ConcurrentDictionaryGroupRepository(IFormatterResolver resolver, IMagicOnionLogger logger) { this.resolver = resolver; this.factory = CreateGroup; this.logger = logger; }
public IGroupRepository CreateRepository(MessagePackSerializerOptions serializerOptions, IMagicOnionLogger logger, IServiceLocator serviceLocator) { var connection = serviceLocator.GetService <ConnectionMultiplexer>(); if (connection == null) { throw new InvalidOperationException("RedisGroup requires add ConnectionMultiplexer to MagicOnionOptions.ServiceLocator before create it. Please try new MagicOnionOptions{DefaultServiceLocator.Register(new ConnectionMultiplexer)}"); } return(new RedisGroupRepository(serializerOptions, connection, logger)); }
public ConcurrentDictionaryGroupRepository(MessagePackSerializerOptions serializerOptions, IMagicOnionLogger logger) { this.serializerOptions = serializerOptions; this.factory = CreateGroup; this.logger = logger; }
public IGroupRepository CreateRepository(MessagePackSerializerOptions serializerOptions, IMagicOnionLogger logger, IServiceLocator serviceLocator) { return(new ConcurrentDictionaryGroupRepository(serializerOptions, logger)); }
public ImmutableArrayGroupRepository(IFormatterResolver resolver, IMagicOnionLogger logger) { this.resolver = resolver; this.factory = CreateGroup; this.logger = logger; }
public MethodHandler(MagicOnionOptions options, Type classType, MethodInfo methodInfo) { this.ServiceType = classType; this.ServiceName = classType.GetInterfaces().First(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IService <>)).GetGenericArguments()[0].Name; this.MethodInfo = methodInfo; MethodType mt; this.UnwrappedResponseType = UnwrapResponseType(methodInfo, out mt, out responseIsTask, out this.RequestType); this.MethodType = mt; var parameters = methodInfo.GetParameters(); if (RequestType == null) { this.RequestType = MagicOnionMarshallers.CreateRequestTypeAndMarshaller(options.ZeroFormatterTypeResolverType, classType.Name + "/" + methodInfo.Name, parameters, out requestMarshaller); } else { this.requestMarshaller = MagicOnionMarshallers.CreateZeroFormattertMarshallerReflection(options.ZeroFormatterTypeResolverType, RequestType); } this.responseMarshaller = MagicOnionMarshallers.CreateZeroFormattertMarshallerReflection(options.ZeroFormatterTypeResolverType, UnwrappedResponseType); this.AttributeLookup = classType.GetCustomAttributes(true) .Concat(methodInfo.GetCustomAttributes(true)) .Cast <Attribute>() .ToLookup(x => x.GetType()); this.filters = options.GlobalFilters .Concat(classType.GetCustomAttributes <MagicOnionFilterAttribute>(true)) .Concat(methodInfo.GetCustomAttributes <MagicOnionFilterAttribute>(true)) .OrderBy(x => x.Order) .ToArray(); // options this.isReturnExceptionStackTraceInErrorDetail = options.IsReturnExceptionStackTraceInErrorDetail; this.logger = options.MagicOnionLogger; // prepare lambda parameters var contextArg = Expression.Parameter(typeof(ServiceContext), "context"); var contextBind = Expression.Bind(classType.GetProperty("Context"), contextArg); var instance = Expression.MemberInit(Expression.New(classType), contextBind); switch (MethodType) { case MethodType.Unary: case MethodType.ServerStreaming: // (ServiceContext context) => // { // var request = ((Marshaller<TRequest>)context.RequestMarshaller).Deserializer.Invoke(context.Request); // return new FooService() { Context = context }.Bar(request.Item1, request.Item2); // }; { var flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic; var marshallerType = typeof(Marshaller <>).MakeGenericType(RequestType); var requestArg = Expression.Parameter(RequestType, "request"); var requestMarshalleExpr = Expression.Convert(Expression.Property(contextArg, typeof(ServiceContext).GetProperty("RequestMarshaller", flags)), marshallerType); var deserializer = Expression.Property(requestMarshalleExpr, "Deserializer"); var callDeserialize = Expression.Call(deserializer, typeof(Func <,>).MakeGenericType(typeof(byte[]), RequestType).GetMethod("Invoke"), Expression.Property(contextArg, typeof(ServiceContext).GetProperty("Request", flags))); var assignRequest = Expression.Assign(requestArg, callDeserialize); Expression[] arguments = new Expression[parameters.Length]; if (parameters.Length == 1) { arguments[0] = requestArg; } else { for (int i = 0; i < parameters.Length; i++) { arguments[i] = Expression.Field(requestArg, "Item" + (i + 1)); } } var callBody = Expression.Call(instance, methodInfo, arguments); if (!responseIsTask) { callBody = Expression.Call(typeof(Task).GetMethod("FromResult").MakeGenericMethod(MethodInfo.ReturnType), callBody); } var body = Expression.Block(new[] { requestArg }, assignRequest, callBody); var compiledBody = Expression.Lambda(body, contextArg).Compile(); this.methodBody = BuildMethodBodyWithFilter((Func <ServiceContext, Task>)compiledBody); } break; case MethodType.ClientStreaming: case MethodType.DuplexStreaming: if (parameters.Length != 0) { throw new InvalidOperationException($"{MethodType} does not support method parameters. If you need to send initial parameter, use header instead."); } // (ServiceContext context) => new FooService() { Context = context }.Bar(); { var body = Expression.Call(instance, methodInfo); if (!responseIsTask) { body = Expression.Call(typeof(Task).GetMethod("FromResult").MakeGenericMethod(MethodInfo.ReturnType), body); } var compiledBody = Expression.Lambda(body, contextArg).Compile(); this.methodBody = BuildMethodBodyWithFilter((Func <ServiceContext, Task>)compiledBody); } break; default: throw new InvalidOperationException("Unknown MethodType:" + MethodType); } // Utility { // (object requestMarshaller, object value) => ((Marshaller<TRequest>)requestMarshaller).Serializer.Invoke((TRequest)value); var marshallerType = typeof(Marshaller <>).MakeGenericType(RequestType); var requestMarshallerArg = Expression.Parameter(typeof(object), "requestMarshaller"); var valueArg = Expression.Parameter(typeof(object), "value"); var serializer = Expression.Property(Expression.Convert(requestMarshallerArg, marshallerType), "Serializer"); var callSerialize = Expression.Call(serializer, typeof(Func <,>).MakeGenericType(RequestType, typeof(byte[])).GetMethod("Invoke"), Expression.Convert(valueArg, RequestType)); boxedRequestSerialize = Expression.Lambda <Func <object, object, byte[]> >(callSerialize, requestMarshallerArg, valueArg).Compile(); } { // (object responseMarshaller, byte[] value) => ((Marshaller<TResponse>)requestMarshaller).Deserializer.Invoke(value); var marshallerType = typeof(Marshaller <>).MakeGenericType(UnwrappedResponseType); var responseMarshallerArg = Expression.Parameter(typeof(object), "responseMarshaller"); var valueArg = Expression.Parameter(typeof(byte[]), "value"); var deserializer = Expression.Property(Expression.Convert(responseMarshallerArg, marshallerType), "Deserializer"); var callDeserialize = Expression.Convert(Expression.Call(deserializer, typeof(Func <,>).MakeGenericType(typeof(byte[]), UnwrappedResponseType).GetMethod("Invoke"), valueArg), typeof(object)); boxedResponseDeserialize = Expression.Lambda <Func <object, byte[], object> >(callDeserialize, responseMarshallerArg, valueArg).Compile(); } }
public IGroupRepository CreateRepository(IFormatterResolver formatterResolver, IMagicOnionLogger logger, IServiceLocator serviceLocator) { return(new ImmutableArrayGroupRepository(formatterResolver, logger)); }
public ServerStreamingContext(ServiceContext context) { this.context = context; this.inner = context.ResponseStream; this.logger = context.MagicOnionLogger; }
public LoggableStreamWriter(IMagicOnionLogger logger, ServiceContext context, IAsyncStreamWriter <T> writer) { this.logger = logger; this.context = context; this.writer = writer; }
public ImmutableArrayGroupRepository(MessagePackSerializerOptions serializerOptions, IMagicOnionLogger logger) { this.serializerOptions = serializerOptions; this.factory = CreateGroup; this.logger = logger; }
public IGroupRepository CreateRepository(MessagePackSerializerOptions serializerOptions, IMagicOnionLogger logger) { return(new ImmutableArrayGroupRepository(serializerOptions, logger)); }
public IGroupRepository CreateRepository(MessagePackSerializerOptions serializerOptions, IMagicOnionLogger logger) { return(new RedisGroupRepository(serializerOptions, _options, logger)); }
public IGroupRepository CreateRepository(IFormatterResolver formatterResolver, IMagicOnionLogger logger, IServiceLocator serviceLocator) { return(new ConcurrentDictionaryGroupRepository(formatterResolver, logger)); }
public LoggableStreamReader(IMagicOnionLogger logger, ServiceContext context, IAsyncStreamReader <T> reader) { this.logger = logger; this.context = context; this.reader = reader; }