public ServerStreamingServerCallHandler(
Method <TRequest, TResponse> method,
ServerStreamingServerMethod <TService, TRequest, TResponse> invoker,
GrpcServiceOptions serviceOptions,
ILoggerFactory loggerFactory,
IGrpcServiceActivator <TService> serviceActivator,
IServiceProvider serviceProvider)
: base(method, serviceOptions, loggerFactory, serviceActivator, serviceProvider)
{
_invoker = invoker;
if (ServiceOptions.HasInterceptors)
{
ServerStreamingServerMethod <TRequest, TResponse> resolvedInvoker = async(resolvedRequest, responseStream, resolvedContext) =>
{
GrpcActivatorHandle <TService> serviceHandle = default;
try
{
serviceHandle = ServiceActivator.Create(resolvedContext.GetHttpContext().RequestServices);
await _invoker(serviceHandle.Instance, resolvedRequest, responseStream, resolvedContext);
}
finally
{
if (serviceHandle.Instance != null)
{
ServiceActivator.Release(serviceHandle);
}
}
};
var interceptorPipeline = new InterceptorPipelineBuilder <TRequest, TResponse>(ServiceOptions.Interceptors, ServiceProvider);
_pipelineInvoker = interceptorPipeline.ServerStreamingPipeline(resolvedInvoker);
}
}
/// <summary>
/// Creates a new instance of <see cref="ServerMethodInvokerBase{TService, TRequest, TResponse}"/>.
/// </summary>
/// <param name="method">The description of the gRPC method.</param>
/// <param name="options">The options used to execute the method.</param>
/// <param name="serviceActivator">The service activator used to create service instances.</param>
private protected ServerMethodInvokerBase(
Method <TRequest, TResponse> method,
MethodOptions options,
IGrpcServiceActivator <TService> serviceActivator)
{
Method = method;
Options = options;
ServiceActivator = serviceActivator;
}
public ServerCallHandlerFactory(
ILoggerFactory loggerFactory,
IOptions <GrpcServiceOptions> globalOptions,
IOptions <GrpcServiceOptions <TService> > serviceOptions,
IGrpcServiceActivator <TService> serviceActivator)
{
_loggerFactory = loggerFactory;
_serviceActivator = serviceActivator;
_serviceOptions = serviceOptions.Value;
_globalOptions = globalOptions.Value;
}
protected ServerCallHandlerBase(
Method <TRequest, TResponse> method,
GrpcServiceOptions serviceOptions,
ILoggerFactory loggerFactory,
IGrpcServiceActivator <TService> serviceActivator,
IServiceProvider serviceProvider)
{
Method = method;
ServiceOptions = serviceOptions;
ServiceActivator = serviceActivator;
ServiceProvider = serviceProvider;
Logger = loggerFactory.CreateLogger(typeof(TService));
}
protected ServerCallHandlerBase(
Method <TRequest, TResponse> method,
MethodContext methodContext,
ILoggerFactory loggerFactory,
IGrpcServiceActivator serviceActivator,
IServiceProvider serviceProvider)
{
Method = method;
MethodContext = methodContext;
ServiceActivator = serviceActivator;
ServiceProvider = serviceProvider;
Logger = loggerFactory.CreateLogger(LoggerName);
}
public HttpApiServiceMethodProvider(
ILoggerFactory loggerFactory,
IOptions <GrpcServiceOptions> globalOptions,
IOptions <GrpcServiceOptions <TService> > serviceOptions,
IServiceProvider serviceProvider,
IGrpcServiceActivator <TService> serviceActivator)
{
_logger = loggerFactory.CreateLogger <HttpApiServiceMethodProvider <TService> >();
_globalOptions = globalOptions.Value;
_serviceOptions = serviceOptions.Value;
_loggerFactory = loggerFactory;
_serviceProvider = serviceProvider;
_serviceActivator = serviceActivator;
}
public JsonTranscodingServiceMethodProvider(
ILoggerFactory loggerFactory,
IOptions <GrpcServiceOptions> globalOptions,
IOptions <GrpcServiceOptions <TService> > serviceOptions,
IGrpcServiceActivator <TService> serviceActivator,
IOptions <GrpcJsonTranscodingOptions> JsonTranscodingOptions)
{
_logger = loggerFactory.CreateLogger <JsonTranscodingServiceMethodProvider <TService> >();
_globalOptions = globalOptions.Value;
_serviceOptions = serviceOptions.Value;
_JsonTranscodingOptions = JsonTranscodingOptions.Value;
_loggerFactory = loggerFactory;
_serviceActivator = serviceActivator;
}
/// <summary>
/// Creates a new instance of <see cref="ClientStreamingServerMethodInvoker{TService, TRequest, TResponse}"/>.
/// </summary>
/// <param name="invoker">The client streaming method to invoke.</param>
/// <param name="method">The description of the gRPC method.</param>
/// <param name="options">The options used to execute the method.</param>
/// <param name="serviceActivator">The service activator used to create service instances.</param>
public ClientStreamingServerMethodInvoker(
ClientStreamingServerMethod <TService, TRequest, TResponse> invoker,
Method <TRequest, TResponse> method,
MethodOptions options,
IGrpcServiceActivator <TService> serviceActivator)
: base(method, options, serviceActivator)
{
_invoker = invoker;
if (Options.HasInterceptors)
{
var interceptorPipeline = new InterceptorPipelineBuilder <TRequest, TResponse>(Options.Interceptors);
_pipelineInvoker = interceptorPipeline.ClientStreamingPipeline(ResolvedInterceptorInvoker);
}
}
public ServerStreamingServerCallHandler(
Method <TRequest, TResponse> method,
ServerStreamingServerMethod <TService, TRequest, TResponse> invoker,
MethodContext methodContext,
ILoggerFactory loggerFactory,
IGrpcServiceActivator serviceActivator,
IServiceProvider serviceProvider)
: base(method, methodContext, loggerFactory, serviceActivator, serviceProvider)
{
_invoker = invoker;
if (MethodContext.HasInterceptors)
{
var interceptorPipeline = new InterceptorPipelineBuilder <TRequest, TResponse>(MethodContext.Interceptors, ServiceProvider);
_pipelineInvoker = interceptorPipeline.ServerStreamingPipeline(ResolvedInterceptorInvoker);
}
}
public UnaryServerCallHandler(
Method <TRequest, TResponse> method,
UnaryServerMethod <TService, TRequest, TResponse> invoker,
GrpcServiceOptions serviceOptions,
ILoggerFactory loggerFactory,
IGrpcServiceActivator <TService> serviceActivator,
IServiceProvider serviceProvider)
: base(method, serviceOptions, loggerFactory, serviceActivator, serviceProvider)
{
_invoker = invoker;
if (ServiceOptions.HasInterceptors)
{
var interceptorPipeline = new InterceptorPipelineBuilder <TRequest, TResponse>(ServiceOptions.Interceptors, ServiceProvider);
_pipelineInvoker = interceptorPipeline.UnaryPipeline(ResolvedInterceptorInvoker);
}
}
public ServerCallHandlerFactory(
ILoggerFactory loggerFactory,
IOptions <GrpcServiceOptions> globalOptions,
IOptions <GrpcServiceOptions <TService> > serviceOptions,
IGrpcServiceActivator <TService> serviceActivator,
IServiceProvider serviceProvider)
{
_loggerFactory = loggerFactory;
_serviceActivator = serviceActivator;
_serviceProvider = serviceProvider;
var so = serviceOptions.Value;
var go = globalOptions.Value;
// This is required to get ensure that service methods without any explicit configuration
// will continue to get the global configuration options
_resolvedOptions = new GrpcServiceOptions
{
EnableDetailedErrors = so.EnableDetailedErrors ?? go.EnableDetailedErrors,
MaxReceiveMessageSize = so.MaxReceiveMessageSize ?? go.MaxReceiveMessageSize,
MaxSendMessageSize = so.MaxSendMessageSize ?? go.MaxSendMessageSize,
ResponseCompressionAlgorithm = so.ResponseCompressionAlgorithm ?? go.ResponseCompressionAlgorithm,
ResponseCompressionLevel = so.ResponseCompressionLevel ?? go.ResponseCompressionLevel
};
var resolvedCompressionProviders = new Dictionary <string, ICompressionProvider>(StringComparer.Ordinal);
AddCompressionProviders(resolvedCompressionProviders, so._compressionProviders);
AddCompressionProviders(resolvedCompressionProviders, go._compressionProviders);
_resolvedOptions.ResolvedCompressionProviders = resolvedCompressionProviders;
_resolvedOptions.Interceptors.AddRange(go.Interceptors);
_resolvedOptions.Interceptors.AddRange(so.Interceptors);
_resolvedOptions.HasInterceptors = _resolvedOptions.Interceptors.Count > 0;
_resolvedServiceMethods = so.Methods.ToDictionary(k => k.Name);
if (_resolvedOptions.ResponseCompressionAlgorithm != null)
{
if (!_resolvedOptions.ResolvedCompressionProviders.TryGetValue(_resolvedOptions.ResponseCompressionAlgorithm, out var _))
{
throw new InvalidOperationException($"The configured response compression algorithm '{_resolvedOptions.ResponseCompressionAlgorithm}' does not have a matching compression provider.");
}
}
}
internal HttpApiProviderServiceBinder(
ServiceMethodProviderContext <TService> context,
Type declaringType,
ServiceDescriptor serviceDescriptor,
GrpcServiceOptions globalOptions,
GrpcServiceOptions <TService> serviceOptions,
IServiceProvider serviceProvider,
ILoggerFactory loggerFactory,
IGrpcServiceActivator <TService> serviceActivator)
{
_context = context;
_declaringType = declaringType;
_serviceDescriptor = serviceDescriptor;
_globalOptions = globalOptions;
_serviceOptions = serviceOptions;
_serviceActivator = serviceActivator;
_logger = loggerFactory.CreateLogger <HttpApiProviderServiceBinder <TService> >();
}
public ServerCallHandlerFactory(
ILoggerFactory loggerFactory,
IOptions <GrpcServiceOptions> globalOptions,
IOptions <GrpcServiceOptions <TService> > serviceOptions,
IGrpcServiceActivator <TService> serviceActivator,
IServiceProvider serviceProvider)
{
_loggerFactory = loggerFactory;
_serviceActivator = serviceActivator;
_serviceProvider = serviceProvider;
var so = serviceOptions.Value;
var go = globalOptions.Value;
// This is required to get ensure that service methods without any explicit configuration
// will continue to get the global configuration options
_resolvedOptions = new GrpcServiceOptions
{
EnableDetailedErrors = so.EnableDetailedErrors ?? go.EnableDetailedErrors,
ReceiveMaxMessageSize = so.ReceiveMaxMessageSize ?? go.ReceiveMaxMessageSize,
SendMaxMessageSize = so.SendMaxMessageSize ?? go.SendMaxMessageSize,
ResponseCompressionAlgorithm = so.ResponseCompressionAlgorithm ?? go.ResponseCompressionAlgorithm,
ResponseCompressionLevel = so.ResponseCompressionLevel ?? go.ResponseCompressionLevel,
CompressionProviders = so._compressionProviders ?? go._compressionProviders ?? new List <ICompressionProvider>()
};
_resolvedOptions.Interceptors.AddRange(go.Interceptors);
_resolvedOptions.Interceptors.AddRange(so.Interceptors);
_resolvedOptions.HasInterceptors = _resolvedOptions.Interceptors.Count > 0;
if (_resolvedOptions.ResponseCompressionAlgorithm != null)
{
var responseCompressionProvider = _resolvedOptions.CompressionProviders?.FirstOrDefault(p => string.Equals(_resolvedOptions.ResponseCompressionAlgorithm, p.EncodingName, StringComparison.Ordinal));
if (responseCompressionProvider == null)
{
throw new InvalidOperationException($"The configured response compression algorithm '{_resolvedOptions.ResponseCompressionAlgorithm}' does not have a matching compression provider.");
}
}
}
