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);
}
/// <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 ImplicitServiceProviderServiceImpl(IRpcServicePublisher publisher)
{
this.simpleServiceScopes = Array.ConvertAll(this.serviceImpls,
s => publisher.PublishInstance <ISimpleService>(s));
this.blockingServiceScopes = Array.ConvertAll(this.blockingServiceImpls,
s => publisher.PublishInstance <IBlockingService>(s));
}
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;
}
}
public static IOwned <RpcObjectRef <TService> > PublishInstance <TService>(this IRpcServicePublisher servicePublisher, TService serviceInstance, bool takeOwnership = false) where TService : class
{
if (servicePublisher is null)
{
throw new ArgumentNullException(nameof(servicePublisher));
}
return(servicePublisher.PublishInstance(takeOwnership ? OwnedObject.Create(serviceInstance) : OwnedObject.CreateUnowned(serviceInstance)));
}
public static void UnpublishSingleton <TService>(this IRpcServicePublisher publisher) where TService : class
{
if (publisher is null)
{
throw new ArgumentNullException(nameof(publisher));
}
publisher.UnpublishSingletonAsync <TService>().AsTask().AwaiterResult();
}
public static void UnpublishInstance(this IRpcServicePublisher publisher, RpcObjectId serviceInstanceId)
{
if (publisher is null)
{
throw new ArgumentNullException(nameof(publisher));
}
publisher.UnpublishInstanceAsync(serviceInstanceId).AsTask().AwaiterResult();
}
internal NetGrpcServer(
IRpcServicePublisher servicePublisher,
IRpcServiceActivator serviceImplProvider,
IRpcServiceDefinitionsProvider serviceDefinitionsProvider,
//ServiceMethodProviderContext<NetGrpcServiceActivator>? context,
RpcServerOptions?options,
ILoggerFactory?loggerFactory)
: base(servicePublisher, serviceImplProvider, serviceDefinitionsProvider, options, loggerFactory)
{
}
/// <summary>
/// Publishes an RPC service instance using an instance factory.
/// </summary>
/// <typeparam name="TService">The type of the published instance.</typeparam>
/// <param name="factory">A factory function that should create the service instance specified by the <see cref="RpcObjectId"/>. If the created
/// instance implements <see cref="IDisposable"/> the instance will be disposed when the RPC call has finished.
/// </param>
/// <returns>A scoped object including the <see cref="RpcObjectRef"/> identifying the published instance. The scoped object will unpublish
/// the service instance when disposed.</returns>
public static IOwned <RpcObjectRef <TService> > PublishInstance <TService>(this IRpcServicePublisher servicePublisher, Func <RpcObjectId, TService> factory)
where TService : class
{
if (servicePublisher is null)
{
throw new ArgumentNullException(nameof(servicePublisher));
}
IOwned <TService> CreateActivatedService(IServiceProvider?services, RpcObjectId objectId)
{
return(OwnedObject.Create(factory(objectId)));
}
return(servicePublisher.PublishInstance(CreateActivatedService));
}
/// <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;
}
/// <summary>
/// Publishes an RPC service instance with the help of a service provider factory.
/// </summary>
/// <typeparam name="TService">The type of the published instance.</typeparam>
/// <param name="factory">A factory function that should create the service instance specified by the <see cref="RpcObjectId"/>
/// with the help of the provided <see cref="IServiceProvider"/>.</param>
/// <returns>A scoped object including the <see cref="RpcObjectRef"/> identifying the published instance. The scoped object will unpublish
/// the service instance when disposed.</returns>
public static IOwned <RpcObjectRef <TService> > PublishInstance <TService>(this IRpcServicePublisher servicePublisher, Func <IServiceProvider, RpcObjectId, TService> factory)
where TService : class
{
if (servicePublisher is null)
{
throw new ArgumentNullException(nameof(servicePublisher));
}
IOwned <TService> CreateActivatedService(IServiceProvider?services, RpcObjectId objectId)
{
if (services == null)
{
throw new RpcDefinitionException("An IServiceProvider must be supplied when services are published using IServiceProvider factories.");
}
return(OwnedObject.CreateUnowned(factory(services, objectId)));
}
return(servicePublisher.PublishInstance(CreateActivatedService));
}
/// <summary>
/// Publishes an RPC singleton under the service name of the <typeparamref name="TService"/> RPC interface.
/// The service instance will be created using the <see cref="IServiceProvider"/> associated with the RPC call.
/// </summary>
/// <typeparam name="TService">The interface of the service type. Must be an interface type with the <see cref="RpcServiceAttribute"/> (or <c>ServiceContractAttribute</c>)
/// applied.</typeparam>
/// <returns>A scoped object including the <see cref="RpcSingletonRef{TService}"/> identifying the published singleton. The scoped object will unpublish
/// the service singleton when disposed.</returns>
public static IOwned <RpcSingletonRef <TService> > PublishSingleton <TService>(this IRpcServicePublisher publisher)
where TService : class
=> PublishSingleton <TService, TService>(publisher);
/// <summary>
/// Publishes an RPC singleton under the service name of the <typeparamref name="TService"/> RPC interface,
/// using <typeparamref name="TServiceImpl"/> as the implementation.
/// The service instance will be created using the <see cref="IServiceProvider"/> associated with the RPC call.
/// </summary>
/// <typeparam name="TService">The interface of the service type. Must be an interface type with the <see cref="RpcServiceAttribute"/> (or <c>ServiceContractAttribute</c>)
/// applied.</typeparam>
/// <typeparam name="TServiceImpl">The type that implements the service interface.</typeparam>
/// <returns>A scoped object including the <see cref="RpcSingletonRef{TService}"/> identifying the published singleton. The scoped object will unpublish
/// the service singleton when disposed.</returns>
public static IOwned <RpcSingletonRef <TService> > PublishSingleton <TService, TServiceImpl>(this IRpcServicePublisher publisher)
where TServiceImpl : class, TService
where TService : class
{
if (publisher is null)
{
throw new ArgumentNullException(nameof(publisher));
}
return(publisher.PublishSingleton(ServiceActivator <TService, TServiceImpl> .CreateActivatedService));
}
public static IList <RpcObjectRef <TService>?> GetPublishedServiceInstances <TService>(this IRpcServicePublisher servicePublisher,
IReadOnlyList <TService> serviceInstances, bool allowUnpublished) where TService : class
{
if (servicePublisher is null)
{
throw new ArgumentNullException(nameof(servicePublisher));
}
if (serviceInstances == null)
{
return(null !);
}
var publishedServices = new List <RpcObjectRef <TService>?>();
foreach (var s in serviceInstances)
{
if (s != null)
{
var publishedService = s != null?servicePublisher.GetPublishedInstance(s) : null;
if (publishedService != null)
{
publishedServices.Add(publishedService);
}
else if (!allowUnpublished)
{
throw new InvalidOperationException("Service has not been published.");
}
}
else
{
publishedServices.Add(null);
}
}
return(publishedServices);
}
public static IOwned <RpcSingletonRef <TService> > PublishSingleton <TService>(this IRpcServicePublisher servicePublisher, Func <TService> factory)
where TService : class
{
if (servicePublisher is null)
{
throw new ArgumentNullException(nameof(servicePublisher));
}
IOwned <TService> CreateActivatedService(IServiceProvider?_) => OwnedObject.Create(factory());
return(servicePublisher.PublishSingleton(CreateActivatedService));
}
public ServiceProviderServiceImpl(IRpcServicePublisher publisher)
{
this.simpleServiceScope = publisher.PublishInstance <ISimpleService>(new TestSimpleServiceImpl());
}
