/// <summary>
/// Only intended for testing.
/// </summary>
/// <param name="servicePublisher"></param>
/// <param name="serviceImplProvider"></param>
/// <param name="definitionsProvider"></param>
protected RpcServerHostBase(
IRpcServicePublisher servicePublisher, IRpcServiceActivator serviceImplProvider,
IRpcServiceDefinitionsProvider definitionsProvider, IRpcServerOptions?options,
ILoggerFactory?loggerFactory = null)
: base(servicePublisher, serviceImplProvider, definitionsProvider, options, loggerFactory)
{
}
public GrpcServer(
IRpcServicePublisher servicePublisher,
IRpcServiceActivator serviceImplProvider,
IRpcServiceDefinitionsProvider serviceDefinitionsProvider,
IServiceProvider?serviceProvider,
RpcServerOptions?options = null)
: base(servicePublisher, serviceImplProvider, serviceDefinitionsProvider, options)
{
this.ServiceProvider = serviceProvider;
List <GrpcCore.ChannelOption> channelOptions = new List <GrpcCore.ChannelOption>();
var maxReceiveMessageSize = options?.ReceiveMaxMessageSize;
if (maxReceiveMessageSize != null)
{
channelOptions.Add(new GrpcCore.ChannelOption(GrpcCore.ChannelOptions.MaxReceiveMessageLength, maxReceiveMessageSize.Value));
}
var maxSendMessageSize = options?.SendMaxMessageSize;
if (maxSendMessageSize != null)
{
channelOptions.Add(new GrpcCore.ChannelOption(GrpcCore.ChannelOptions.MaxSendMessageLength, maxSendMessageSize.Value));
}
this.grpcServer = new GrpcCore.Server(channelOptions);
}
protected RpcServerBase(
IRpcServicePublisher servicePublisher, IRpcServiceActivator serviceActivator,
IRpcServiceDefinitionsProvider definitionsProvider, IRpcServerOptions?options,
ILoggerFactory?loggerFactory)
{
this.ServicePublisher = servicePublisher ?? throw new ArgumentNullException(nameof(servicePublisher));
this.ServiceActivator = serviceActivator ?? throw new ArgumentNullException(nameof(serviceActivator));
this.ServiceDefinitionsProvider = definitionsProvider ?? throw new ArgumentNullException(nameof(definitionsProvider));
this.LoggerFactory = loggerFactory;
this.Logger = loggerFactory?.CreateLogger(this.GetType()) ?? RpcLogger.CreateLogger(this.GetType());
if (options != null)
{
this.serializer = options.Serializer;
this.AllowDiscovery = options.AllowDiscovery ?? true;
this.AllowAutoPublish = options.AllowAutoPublish ?? false;
this.CallInterceptors = options.Interceptors.ToImmutableArrayList();
this.ExceptionConverters = options.ExceptionConverters.ToImmutableArrayList();
}
if (this.ExceptionConverters.Count > 0)
{
this.CustomFaultHandler = new RpcServerFaultHandler(null, this.ExceptionConverters, null);
}
else
{
this.CustomFaultHandler = RpcServerFaultHandler.Default;
}
}
private void CreateSimpleServiceStub <TService>(TService serviceImpl, ILightweightMethodBinder methodBinder) where TService : class
{
var builder = new LightweightServiceStubBuilder <TService>(new RpcServiceOptions <TService> {
Serializer = DefaultSerializer
});
IRpcServiceDefinitionsProvider serviceDefinitionsProvider = CreateDefinitionsProviderMock();
var hostMock = new Mock <IRpcServerCore>(MockBehavior.Strict);
var servicePublisherMock = new Mock <IRpcServicePublisher>(MockBehavior.Strict);
var serviceImplProviderMock = new Mock <IRpcServiceActivator>(MockBehavior.Strict);
serviceImplProviderMock.Setup(p => p.GetActivatedService <TService>(It.IsAny <IServiceProvider>(), It.IsAny <RpcObjectId>())).Returns(new ActivatedService <TService>(serviceImpl, null));
hostMock.Setup(h => h.ServicePublisher).Returns(servicePublisherMock.Object);
hostMock.Setup(h => h.ServiceActivator).Returns(serviceImplProviderMock.Object);
hostMock.Setup(h => h.ServiceDefinitionsProvider).Returns(serviceDefinitionsProvider);
hostMock.Setup(h => h.CallInterceptors).Returns(ImmutableArrayList <RpcServerCallInterceptor> .Empty);
hostMock.Setup(h => h.AllowAutoPublish).Returns(false);
hostMock.Setup(h => h.Serializer).Returns(DefaultSerializer);
hostMock.Setup(h => h.CustomFaultHandler).Returns((RpcServerFaultHandler)null);
hostMock.Setup(p => p.HasContextAccessor).Returns(false);
hostMock.Setup(p => p.LoggerFactory).Returns(NullLoggerFactory.Instance);
builder.GenerateOperationHandlers(hostMock.Object, methodBinder);
}
internal NetGrpcServer(
IRpcServicePublisher servicePublisher,
IRpcServiceActivator serviceImplProvider,
IRpcServiceDefinitionsProvider serviceDefinitionsProvider,
//ServiceMethodProviderContext<NetGrpcServiceActivator>? context,
RpcServerOptions?options,
ILoggerFactory?loggerFactory)
: base(servicePublisher, serviceImplProvider, serviceDefinitionsProvider, options, loggerFactory)
{
}
/// <summary>
/// Internal to allow testing.
/// </summary>
internal LightweightRpcServer(
IRpcServicePublisher servicePublisher,
IRpcServiceActivator serviceImplProvider,
IRpcServiceDefinitionsProvider definitionsProvider,
IServiceProvider?serviceProvider,
IRpcServerOptions?options,
LightweightOptions?lightweightOptions = null,
ILoggerFactory?loggerFactory = null)
: base(servicePublisher, serviceImplProvider, definitionsProvider,
options,
loggerFactory)
{
this.ServiceProvider = serviceProvider;
this.MaxRequestSize = options?.ReceiveMaxMessageSize ?? DefaultMaxRequestMessageSize;
this.MaxResponseSize = options?.SendMaxMessageSize ?? DefaultMaxResponseMessageSize;
this.KeepSizeLimitedConnectionAlive = lightweightOptions?.KeepSizeLimitedConnectionAlive ?? true;
}
private static IRpcServerHost CreateNetGrpcServer(
IRpcServiceDefinitionsProvider serviceDefinitionsProvider,
RpcServerId serverId,
RpcServerOptions options,
Action <IServiceCollection> configureServices)
{
var hostBuilder = WebHost.CreateDefaultBuilder()
.ConfigureKestrel(options =>
{
options.ListenLocalhost(GrpcCoreFullStackTestsBase.GrpcTestPort, listenOptions =>
{
listenOptions.UseHttps(TestCertificates.ServerPFXPath, "1111");
//listenOptions.UseHttps(certPath, "1111", o =>
//{
// o.ClientCertificateMode = ClientCertificateMode.AllowCertificate;
//});
listenOptions.Protocols = HttpProtocols.Http2;
});
})
.ConfigureLogging(b => ConfigureLogging(b))
.ConfigureServices(s =>
{
s.AddSingleton(serviceDefinitionsProvider ?? new RpcServiceDefinitionsBuilder());
s.Configure <RpcServicePublisherOptions>(o => o.ServerId = serverId);
s.AddSingleton <IOptions <RpcServerOptions> >(new OptionsWrapper <RpcServerOptions>(options));
configureServices?.Invoke(s);
})
.UseStartup <NetStartup>();
var host = hostBuilder.Build();
var rpcServer = (NetGrpcServer)host.Services.GetService(typeof(NetGrpcServer));
return(new NetGrpcTestServer(host, rpcServer));
}
protected RpcServerHostBase(RpcServerId serverId, IRpcServiceDefinitionsProvider definitionsProvider, IRpcServerOptions?options, ILoggerFactory?loggerFactory = null) :
this(new RpcServicePublisher(definitionsProvider, serverId), options, loggerFactory)
{
}
public RpcServicePublisher(RpcConnectionInfo connectionInfo, IRpcServiceDefinitionsProvider serviceDefinitionsProvider)
{
this.InitConnectionInfo(connectionInfo);
this.DefinitionsProvider = serviceDefinitionsProvider ?? throw new ArgumentNullException(nameof(serviceDefinitionsProvider));
}
public RpcServicePublisher(IRpcServiceDefinitionsProvider serviceDefinitionsProvider, RpcServerId serverId = default)
{
this.DefinitionsProvider = serviceDefinitionsProvider ?? throw new ArgumentNullException(nameof(serviceDefinitionsProvider));
this.serverId = serverId;
}
/// <summary>
/// TODO: Use factories instead of using this.connnectionType.
/// </summary>
/// <param name="serviceDefinitionsProvider"></param>
/// <param name="proxyDefinitionsProvider"></param>
/// <returns></returns>
protected (IRpcServerHost, IRpcChannel) CreateServerAndConnection(
IRpcServiceDefinitionsProvider serviceDefinitionsProvider = null,
Action <RpcServerOptions> configServerOptions = null,
Action <RpcClientOptions> configClientOptions = null,
Action <IServiceCollection> configureServices = null)
{
var rpcServerId = RpcServerId.NewId();
var serverOptions = new RpcServerOptions {
Serializer = this.serializer
};
var clientOptions = new RpcClientOptions {
Serializer = this.serializer
};
configServerOptions?.Invoke(serverOptions);
configClientOptions?.Invoke(clientOptions);
IServiceProvider services = GetServiceProvider(configureServices);
switch (this.ConnectionType)
{
case RpcConnectionType.LightweightTcp:
case RpcConnectionType.LightweightSslTcp:
{
var host = new LightweightRpcServer(rpcServerId, serviceDefinitionsProvider, services, serverOptions, this.LightweightOptions,
loggerFactory: services.GetService <ILoggerFactory>());
SslServerOptions sslServerOptions = null;
if (this.ConnectionType == RpcConnectionType.LightweightSslTcp)
{
sslServerOptions = new SslServerOptions(new X509Certificate2(TestCertificates.ServerPFXPath, "1111"));
}
host.AddEndPoint(new TcpRpcEndPoint("127.0.0.1", TcpTestPort, false, sslServerOptions));
SslClientOptions sslClientOptions = null;
if (this.ConnectionType == RpcConnectionType.LightweightSslTcp)
{
sslClientOptions = new SslClientOptions {
RemoteCertificateValidationCallback = this.ValidateTestCertificate
};
}
var connection = new TcpRpcConnection(
new RpcConnectionInfo("TCP", new Uri($"lightweight.tcp://127.0.0.1:{TcpTestPort}"), rpcServerId),
sslClientOptions,
clientOptions.AsImmutable(),
this.LightweightOptions);
return(host, connection);
}
case RpcConnectionType.LightweightNamedPipe:
{
var server = new LightweightRpcServer(rpcServerId, serviceDefinitionsProvider, services, serverOptions, this.LightweightOptions,
loggerFactory: services.GetService <ILoggerFactory>());
server.AddEndPoint(new NamedPipeRpcEndPoint("testpipe"));
var connection = new NamedPipeRpcConnection(
new RpcConnectionInfo(new Uri("lightweight.pipe://./testpipe")),
clientOptions.AsImmutable(),
this.LightweightOptions);
return(server, connection);
}
case RpcConnectionType.LightweightInproc:
{
Pipe requestPipe = new Pipe(new PipeOptions(readerScheduler: PipeScheduler.ThreadPool));
Pipe responsePipe = new Pipe(new PipeOptions(readerScheduler: PipeScheduler.Inline));
var host = new LightweightRpcServer(rpcServerId, serviceDefinitionsProvider, services, serverOptions,
loggerFactory: services.GetService <ILoggerFactory>());
host.AddEndPoint(new InprocRpcEndPoint(new DirectDuplexPipe(requestPipe.Reader, responsePipe.Writer)));
var connection = new InprocRpcConnection(new RpcConnectionInfo("Direct", new Uri("direct:localhost"), rpcServerId),
new DirectDuplexPipe(responsePipe.Reader, requestPipe.Writer), clientOptions.AsImmutable());
return(host, connection);
}
case RpcConnectionType.Grpc:
{
var host = new GrpcServer(rpcServerId, serviceDefinitionsProvider, services, serverOptions);
host.AddEndPoint(GrpcCoreFullStackTestsBase.CreateEndPoint());
var connection = new GrpcConnection(
new RpcConnectionInfo("TCP", new Uri($"grpc://localhost:{GrpcCoreFullStackTestsBase.GrpcTestPort}"), rpcServerId),
TestCertificates.GrpcSslCredentials, clientOptions.AsImmutable());
return(host, connection);
}
#if PLAT_NET_GRPC
case RpcConnectionType.NetGrpc:
{
var server = CreateNetGrpcServer(serviceDefinitionsProvider, rpcServerId, serverOptions, configureServices);
//var host = new GrpcServer(rpcServerId, serviceDefinitionsBuilder, null, options);
//host.AddEndPoint(GrpcCoreFullStackTestsBase.CreateEndPoint());
var handler = new System.Net.Http.HttpClientHandler();
handler.ServerCertificateCustomValidationCallback =
(httpRequestMessage, cert, cetChain, policyErrors) =>
{
return(true);
};
var channelOptions = new GrpcNet.Client.GrpcChannelOptions()
{
HttpClient = new System.Net.Http.HttpClient(handler),
DisposeHttpClient = true
};
var connection = new NetGrpcConnection(
new RpcConnectionInfo("net-grpc", new Uri($"grpc://localhost:{GrpcCoreFullStackTestsBase.GrpcTestPort}"), rpcServerId),
clientOptions.AsImmutable(), channelOptions);
return(server, connection);
}
#endif
}
throw new NotSupportedException();
}
