public IReadOnlyList <object> GenerateMethodStubs <TService>(IRpcServerCore rpcServer) where TService : class
{
var builder = new LightweightServiceStubBuilder <TService>(null);
var binder = new TestLightweightMethodBinder();
builder.GenerateOperationHandlers(rpcServer, binder);
return(binder.methods);
}
public IReadOnlyList <object> GenerateMethodStubs <TService>(IRpcServerCore rpcServer) where TService : class
{
var builder = new GrpcServiceStubBuilder <TService>(RpcBuilderUtil.GetServiceInfoFromType(typeof(TService)), null);
var binder = new TestGrpcMethodBinder();
builder.GenerateOperationHandlers(rpcServer, binder);
return(binder.stubs);
}
public GrpcCore.ServerServiceDefinition Build(IRpcServerCore server)
{
var grpcServiceBuilder = new GrpcCore.ServerServiceDefinition.Builder();
var binder = new GrpcMethodBinder(grpcServiceBuilder);
this.GenerateOperationHandlers(server, binder);
var serviceDefinition = grpcServiceBuilder.Build();
return(serviceDefinition);
}
where TResponseReturn : class; // Needs to be class due to gRPC constraint
protected virtual ImmutableRpcServerOptions CreateStubOptions(IRpcServerCore server)
{
if (server is null)
{
throw new ArgumentNullException(nameof(server));
}
var registeredOptions = server.ServiceDefinitionsProvider.GetServiceOptions(typeof(TService));
return(ImmutableRpcServerOptions.Combine(this.Options, registeredOptions));
}
protected override ImmutableRpcServerOptions CreateStubOptions(IRpcServerCore server)
{
var o = this.Options;
var registeredOptions = server.ServiceDefinitionsProvider.GetServiceOptions(typeof(TService));
if ((registeredOptions?.ReceiveMaxMessageSize != null && registeredOptions?.ReceiveMaxMessageSize != o?.ReceiveMaxMessageSize) ||
(registeredOptions?.SendMaxMessageSize != null && registeredOptions?.SendMaxMessageSize != o?.SendMaxMessageSize))
{
// TODO: Logger.Warn("Message settings in registered options do not match provided options. Registered settings will be ignored.");
}
return(ImmutableRpcServerOptions.Combine(this.Options, registeredOptions));
}
protected RpcStub(IRpcServerCore server, ImmutableRpcServerOptions options)
{
this.Server = server;
this.ServicePublisher = this.Server.ServicePublisher;
this.AllowAutoPublish = options?.AllowAutoPublish ?? this.Server.AllowAutoPublish;
this.Serializer = options?.Serializer ?? this.Server.Serializer;
if (options != null && options.ExceptionConverters.Length > 0)
{
this.CustomFaultHandler = new RpcServerFaultHandler(this.Server.CustomFaultHandler, options.ExceptionConverters, null);
}
else
{
this.CustomFaultHandler = this.Server.CustomFaultHandler;
}
}
/// <summary>
/// Generates the RPC method definitions and stub handlers and adds them to the provided methodBinder.
/// </summary>
/// <returns></returns>
public RpcStub <TService> GenerateOperationHandlers(IRpcServerCore server, TMethodBinder methodBinder)
{
this.serviceStub = this.CreateServiceStub(server);
foreach (var memberInfo in RpcBuilderUtil.EnumOperationHandlers(this.ServiceInfo, true))
{
if (memberInfo is RpcEventInfo eventInfo)
{
this.AddEventHandler(this.serviceStub, eventInfo, methodBinder);
}
else if (memberInfo is RpcOperationInfo opInfo)
{
switch (opInfo.MethodType)
{
case RpcMethodType.Unary:
this.CheckMethod(opInfo);
this.AddUnaryMethod(this.serviceStub, opInfo, methodBinder);
break;
case RpcMethodType.ServerStreaming:
this.CheckMethod(opInfo);
if (opInfo.CallbackParameterIndex == null)
{
// No callback. Implement using IAsyncEnumerable
this.AddServerStreamingMethod(this.serviceStub, opInfo, methodBinder);
}
else
{
// Implement using callback
this.AddCallbackMethod(this.serviceStub, opInfo, methodBinder);
}
break;
default:
throw new NotImplementedException();
}
}
else
{
throw new NotImplementedException();
}
}
return(this.serviceStub);
}
