/// <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(); }