/// <summary>
/// サービスメソッドを追加します。
/// </summary>
/// <typeparam name="TRequest">リクエストの型</typeparam>
/// <typeparam name="TResponse">レスポンスの型</typeparam>
/// <param name="builder">サービスビルダー</param>
/// <param name="context">コンテキスト</param>
private void AddServiceMethodGeneric <TRequest, TResponse>(ServerServiceDefinition.Builder builder, MethodBuildContext context)
where TRequest : class where TResponse : class
{
Method <TRequest, TResponse> method = CreateServiceMethodFieldGeneric <TRequest, TResponse>(context);
switch (method.Type)
{
case MethodType.Unary:
builder.AddMethod <TRequest, TResponse>(method, CreateUnaryServerMethod <TRequest, TResponse>(context));
break;
case MethodType.ClientStreaming:
builder.AddMethod <TRequest, TResponse>(method, CreateClientStreamingServerMethod <TRequest, TResponse>(context));
break;
case MethodType.ServerStreaming:
builder.AddMethod <TRequest, TResponse>(method, CreateServerStreamingServerMethod <TRequest, TResponse>(context));
break;
case MethodType.DuplexStreaming:
builder.AddMethod <TRequest, TResponse>(method, CreateDuplexStreamingServerMethod <TRequest, TResponse>(context));
break;
}
}
private void AddMethod(ServerServiceDefinition.Builder serverServiceDefinitionBuilder, Method <TRequest, TResponse> method)
{
switch (method.Type)
{
case MethodType.Unary:
var unaryHandler = _methodHandlerProvider.GetUnaryHandler();
serverServiceDefinitionBuilder.AddMethod(method, unaryHandler);
break;
case MethodType.ClientStreaming:
var clientStreamingHandler = _methodHandlerProvider.GetClientStreamingServerHandler();
serverServiceDefinitionBuilder.AddMethod(method, clientStreamingHandler);
break;
case MethodType.ServerStreaming:
var serverStreamingHandler = _methodHandlerProvider.GetServerStreamingServerHandler();
serverServiceDefinitionBuilder.AddMethod(method, serverStreamingHandler);
break;
case MethodType.DuplexStreaming:
var duplexStreamingServerHandler = _methodHandlerProvider.GetDuplexStreamingServerHandler();
serverServiceDefinitionBuilder.AddMethod(method, duplexStreamingServerHandler);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public void AddUnaryMethod <TRequest, TResponse>(
Method <TRequest, TResponse> method,
IList <object> metadata,
Func <TService, TRequest, ServerCallContext, Task <TResponse> > handler)
where TRequest : class
where TResponse : class
{
var invoker = new UnaryServerCallHandler <TService, TRequest, TResponse>(_serviceFactory, handler);
_builder.AddMethod(method, invoker.Handle);
}
internal void RegisterHandler(ServerServiceDefinition.Builder builder)
{
var method = new Method <byte[], byte[]>(this.MethodType, this.ServiceName, this.MethodName, MagicOnionMarshallers.ThroughMarshaller, MagicOnionMarshallers.ThroughMarshaller);
switch (this.MethodType)
{
case MethodType.Unary:
{
var genericMethod = this.GetType()
.GetMethod(nameof(UnaryServerMethod), BindingFlags.Instance | BindingFlags.NonPublic)
.MakeGenericMethod(RequestType, UnwrappedResponseType);
var handler = (UnaryServerMethod <byte[], byte[]>)genericMethod.CreateDelegate(typeof(UnaryServerMethod <byte[], byte[]>), this);
builder.AddMethod(method, handler);
}
break;
case MethodType.ClientStreaming:
{
var genericMethod = this.GetType()
.GetMethod(nameof(ClientStreamingServerMethod), BindingFlags.Instance | BindingFlags.NonPublic)
.MakeGenericMethod(RequestType, UnwrappedResponseType);
var handler = (ClientStreamingServerMethod <byte[], byte[]>)genericMethod.CreateDelegate(typeof(ClientStreamingServerMethod <byte[], byte[]>), this);
builder.AddMethod(method, handler);
}
break;
case MethodType.ServerStreaming:
{
var genericMethod = this.GetType()
.GetMethod(nameof(ServerStreamingServerMethod), BindingFlags.Instance | BindingFlags.NonPublic)
.MakeGenericMethod(RequestType, UnwrappedResponseType);
var handler = (ServerStreamingServerMethod <byte[], byte[]>)genericMethod.CreateDelegate(typeof(ServerStreamingServerMethod <byte[], byte[]>), this);
builder.AddMethod(method, handler);
}
break;
case MethodType.DuplexStreaming:
{
var genericMethod = this.GetType()
.GetMethod(nameof(DuplexStreamingServerMethod), BindingFlags.Instance | BindingFlags.NonPublic)
.MakeGenericMethod(RequestType, UnwrappedResponseType);
var handler = (DuplexStreamingServerMethod <byte[], byte[]>)genericMethod.CreateDelegate(typeof(DuplexStreamingServerMethod <byte[], byte[]>), this);
builder.AddMethod(method, handler);
}
break;
default:
throw new InvalidOperationException("Unknown RegisterType:" + this.MethodType);
}
}
public GrpcHostBuilder <TService> AddUnaryMethod <TRequest, TResponse>(
Func <TService, TRequest, CancellationToken, Task <TResponse> > handler,
string serviceName,
string methodName
)
where TRequest : class
where TResponse : class
{
_builder.AddMethod(
MethodDefinitionGenerator.CreateMethodDefinition <TRequest, TResponse>(MethodType.Unary, serviceName, methodName, _serializer),
async(request, context) =>
{
using (var scope = _appServices.CreateScope())
{
var service = scope.ServiceProvider.GetRequiredService <TService>();
var baseService = service as GrpcServiceBase;
if (baseService != null)
{
baseService.Context = context;
}
return(await handler(service, request, context.CancellationToken).ConfigureAwait(false));
}
}
);
return(this);
}
/// <summary>
/// サービスメソッド名を指定してサービス定義を生成します。
/// </summary>
/// <param name="serviceName">サービス名</param>
/// <param name="methodName">メソッド名</param>
/// <returns>サービス定義</returns>
public static ServerServiceDefinition BuildService(string serviceName, string methodName)
{
ServerServiceDefinition.Builder builder = ServerServiceDefinition.CreateBuilder();
builder.AddMethod <byte[], byte[]>(CreateMethod(serviceName, methodName), CreateHandler());
return(builder.Build());
}
public static void AddServerStreamingMethod <T>(ServerServiceDefinition.Builder builder, Method <Void, T> method, Forwarder <T> forwarder) where T : class
{
builder.AddMethod(method, async(Void _, IServerStreamWriter <T> responseStream, ServerCallContext context) =>
{
await forwarder.Subscribe(async reader =>
{
while (context.CancellationToken.IsCancellationRequested == false)
{
var success = false;
try
{
var x = await reader.ReadAsync();
await responseStream.WriteAsync(x);
success = true;
}
catch (OperationCanceledException)
{
}
if (success == false)
{
break;
}
}
});
});
}
/// <summary>
/// Adds a definition for a single request - single response method without type restrictions.
/// </summary>
/// <typeparam name="TRequest">The type of the request.</typeparam>
/// <typeparam name="TResponse">The type of the response.</typeparam>
/// <param name="builder"></param>
/// <param name="method"></param>
/// <param name="handler"></param>
/// <returns></returns>
public static ServerServiceDefinition.Builder AddStructMethod <TRequest, TResponse>(this ServerServiceDefinition.Builder builder, Method <TRequest, TResponse> method, StructUnaryServerMethod <TRequest, TResponse> handler)
{
async Task <byte[]> func(byte[] request, ServerCallContext context)
{
TResponse response = await handler(method.RequestMarshaller.Deserializer(request), context).ConfigureAwait(false);
return(method.ResponseMarshaller.Serializer(response));
};
return(builder.AddMethod(s_StructMethodCache.GetMethod(method), func));
}
/// <summary>
/// Adds a definition for a duplex streaming method without type restrictions.
/// </summary>
/// <typeparam name="TRequest">The type of the request.</typeparam>
/// <typeparam name="TResponse">The type of the response.</typeparam>
/// <param name="builder"></param>
/// <param name="method"></param>
/// <param name="handler"></param>
/// <returns></returns>
public static ServerServiceDefinition.Builder AddStructMethod <TRequest, TResponse>(this ServerServiceDefinition.Builder builder, Method <TRequest, TResponse> method, StructDuplexStreamingServerMethod <TRequest, TResponse> handler)
{
Task func(IAsyncStreamReader <byte[]> requestStream, IServerStreamWriter <byte[]> responseStream, ServerCallContext context)
{
return(handler(
requestStream.Convert(bytes => method.RequestMarshaller.Deserializer(bytes))
, responseStream.ConvertResponse(method.ResponseMarshaller.Serializer)
, context
));
};
return(builder.AddMethod(s_StructMethodCache.GetMethod(method), func));
}
/// <summary>
/// Creates the RPC method description.
/// </summary>
/// <typeparam name="TRequest">The type of the request.</typeparam>
/// <typeparam name="TResponse">The type of the response.</typeparam>
/// <param name="builder">The service builder.</param>
/// <param name="serviceName">The service name.</param>
/// <param name="handler">The method information.</param>
/// <param name="marshallerFactory">The factory of the marshaller.</param>
/// <param name="serviceInstance">The service instance.</param>
/// <returns>The method description.</returns>
private static ServerServiceDefinition.Builder AddMethodCore <TRequest, TResponse>(ServerServiceDefinition.Builder builder, string serviceName, RpcMethodHandlerInfo handler, IRpcMarshallerFactory marshallerFactory, object serviceInstance)
where TRequest : class
where TResponse : class
{
Method <TRequest, TResponse> method = new Method <TRequest, TResponse>(handler.MethodType, serviceName, handler.Handler.Name, marshallerFactory.GetMarshaller <TRequest>(), marshallerFactory.GetMarshaller <TResponse>());
switch (handler.MethodType)
{
case MethodType.Unary:
return(builder.AddMethod(method, (UnaryServerMethod <TRequest, TResponse>)handler.Handler.CreateDelegate(typeof(UnaryServerMethod <TRequest, TResponse>), serviceInstance)));
case MethodType.ClientStreaming:
return(builder.AddMethod(method, (ClientStreamingServerMethod <TRequest, TResponse>)handler.Handler.CreateDelegate(typeof(ClientStreamingServerMethod <TRequest, TResponse>), serviceInstance)));
case MethodType.ServerStreaming:
return(builder.AddMethod(method, (ServerStreamingServerMethod <TRequest, TResponse>)handler.Handler.CreateDelegate(typeof(ServerStreamingServerMethod <TRequest, TResponse>), serviceInstance)));
case MethodType.DuplexStreaming:
return(builder.AddMethod(method, (DuplexStreamingServerMethod <TRequest, TResponse>)handler.Handler.CreateDelegate(typeof(DuplexStreamingServerMethod <TRequest, TResponse>), serviceInstance)));
default:
return(builder);
}
}
/// <summary>
/// Registers a method in GRPC service.
/// </summary>
/// <typeparam name="TRequest"></typeparam>
/// <typeparam name="TResponse"></typeparam>
/// <param name="name"></param>
/// <param name="handler"></param>
protected void RegisterMethod <TRequest, TResponse>(string name, UnaryServerMethod <TRequest, TResponse> handler)
where TRequest : class, IMessage <TRequest>, new()
where TResponse : class, IMessage <TResponse>, new()
{
var requestParser = GetOrCreateMessageParser <TRequest>();
var responseParser = GetOrCreateMessageParser <TResponse>();
var method = new Method <TRequest, TResponse>(
MethodType.Unary,
_serviceName,
name,
Marshallers.Create((arg) => arg != null ? MessageExtensions.ToByteArray(arg) : Array.Empty <byte>(), requestParser.ParseFrom),
Marshallers.Create((arg) => arg != null ? MessageExtensions.ToByteArray(arg) : Array.Empty <byte>(), responseParser.ParseFrom));
_builder.AddMethod(method, handler);
}
private static void AddMethod <TRequest, TResult>(ServerServiceDefinition.Builder builder, string name, Func <TRequest, TResult> handler)
where TRequest : class
where TResult : class
{
var method = new Method <TRequest, TResult>(
MethodType.Unary,
nameof(ICustomerData),
name,
new Marshaller <TRequest>(MessagePackSerializer.Serialize, MessagePackSerializer.Deserialize <TRequest>),
new Marshaller <TResult>(MessagePackSerializer.Serialize, MessagePackSerializer.Deserialize <TResult>));
builder.AddMethod(method, (request, context) =>
{
var result = handler(request);
return(Task.FromResult(result));
});
}
public void Accept <TReq, TResp>(MethodDesciptorTyped <TReq, TResp> desc)
where TReq : class
where TResp : class
{
builder.AddMethod(desc.GetMethod(), async(requestStream, responseStream, context) =>
{
var reqStream = requestStream.ToObservable();
await requestStream.ForEachAsync(async request =>
{
// handle incoming request
// push response into stream
await responseStream.WriteAsync(new CustomResponse {
Payload = request.Payload
});
});
});
}
/// <summary>
/// Add grpc method to definition builder
/// </summary>
/// <typeparam name="TRequest"></typeparam>
/// <typeparam name="TResponse"></typeparam>
/// <typeparam name="TService"></typeparam>
/// <param name="provider"></param>
/// <param name="builder"></param>
/// <param name="method"></param>
/// <param name="handler"></param>
/// <param name="cfg"></param>
public static void AddGrpcMethodToDefinitionBuilder <TRequest, TResponse, TService>(
IServiceProvider provider,
ServerServiceDefinition.Builder builder,
Method <TRequest, TResponse> method,
Func <TService, TRequest, CancellationToken,
Task <TResponse> > handler,
GrpcServerConfiguration cfg)
where TService : class
where TRequest : class
where TResponse : class
{
// get host stats
var stats = provider.GetServices <GrpcHost>().FirstOrDefault(h => h.Name == cfg.Name)?.Stats;
// add method
builder.AddMethod(method, async(req, responseStream, context) => {
await RequestHandler.HandleRequest <TRequest, TResponse, TService>(provider, req, handler, cfg.Name, method.Name, context, responseStream);
});
}
/// <summary>
/// 注册服务方法
/// </summary>
public void RegisterMethod(ServerServiceDefinition.Builder builder)
{
builder.AddMethod(this.BuildMethod <AddDelThrottleRQ, CmdRS>("AddDelThrottle", "grpc", Consts.BaseServiceName), AddDelThrottle);
builder.AddMethod(this.BuildMethod <AddDelSaveResponseEnableRQ, CmdRS>("AddDelSaveResponseEnable", "grpc", Consts.BaseServiceName), AddDelSaveResponseEnable);
}
public void RegisterMethod(ServerServiceDefinition.Builder builder)
{
builder.AddMethod(this.BuildMethod <AddRequest, IntMessage>("Add", null), Add);
builder.AddMethod(this.BuildMethod <SubRequest, IntMessage>("Sub", null), Sub);
builder.AddMethod(this.BuildMethod <SumRequest, IntMessage>("Sum", null, mType: MethodType.ClientStreaming), Sum);
}
/// <summary>
/// 注册grpc服务方法
/// </summary>
public void RegisterMethod(ServerServiceDefinition.Builder builder)
{
builder.AddMethod(this.BuildMethod <InfoRQ, InfoRS>("Info", "grpc", Consts.BaseServiceName), Info);
builder.AddMethod(this.BuildMethod <MethodInfoRQ, MethodInfoRS>("MethodInfo", "grpc", Consts.BaseServiceName), MethodInfo);
builder.AddMethod(this.BuildMethod <MethodInvokeRQ, MethodInvokeRS>("MethodInvoke", "grpc", Consts.BaseServiceName), MethodInvoke);
}
/// <summary>
///
/// </summary>
/// <typeparam name="TRequest"></typeparam>
/// <typeparam name="TResponse"></typeparam>
/// <param name="method"></param>
/// <param name="handler"></param>
protected void AddMethod <TRequest, TResponse>(Method <TRequest, TResponse> method, UnaryServerMethod <TRequest, TResponse> handler)
where TRequest : class
where TResponse : class
{
m_Service = m_Service.AddMethod(method, handler);
}
public override void AddMethod <TRequest, TResponse>(
Method <TRequest, TResponse> method,
UnaryServerMethod <TRequest, TResponse> handler)
{
builder.AddMethod(method, (request, context) => interceptor.UnaryServerHandler(request, context, handler));
}
