public void OnServiceMethodDiscovery(ServiceMethodProviderContext <TService> context)
{
var serviceType = typeof(TService);
if (ServiceContract.IsNativeGrpcService(serviceType))
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("Ignore service {0} binding: native grpc service.", serviceType.FullName);
}
return;
}
var filterContext = new ServiceMethodFilterRegistration(_serviceProvider);
filterContext.Add(_rootConfiguration.GetFilters());
filterContext.Add(_serviceConfiguration.GetFilters());
var marshallerFactory = (_serviceConfiguration.MarshallerFactory ?? _rootConfiguration.DefaultMarshallerFactory).ThisOrDefault();
var serviceBinder = new AspNetCoreServiceMethodBinder <TService>(
context,
marshallerFactory,
filterContext,
_rootConfiguration.IsApiDescriptionRequested);
CreateEndpointBinder().Bind(serviceBinder);
}
public AspNetCoreServiceMethodBinder(
ServiceMethodProviderContext <TService> context,
IMarshallerFactory marshallerFactory)
{
_context = context;
MarshallerFactory = marshallerFactory;
}
public void OnServiceMethodDiscovery(ServiceMethodProviderContext <GenericService> context)
{
context.AddDuplexStreamingMethod(
GenericService.StreamingCallMethod,
new List <object>(),
GenericService.DuplexStreamingServerMethod);
}
internal List <IEndpointConventionBuilder> Build(IEndpointRouteBuilder endpointRouteBuilder)
{
Log.DiscoveringServiceMethods(_logger, typeof(TService));
var serviceMethodProviderContext = new ServiceMethodProviderContext <TService>(_serverCallHandlerFactory);
foreach (var serviceMethodProvider in _serviceMethodProviders)
{
serviceMethodProvider.OnServiceMethodDiscovery(serviceMethodProviderContext);
}
var endpointConventionBuilders = new List <IEndpointConventionBuilder>();
if (serviceMethodProviderContext.Methods.Count > 0)
{
foreach (var method in serviceMethodProviderContext.Methods)
{
var endpointBuilder = endpointRouteBuilder.Map(method.Pattern, method.RequestDelegate);
endpointBuilder.Add(ep =>
{
ep.DisplayName = $"gRPC - {method.Pattern.RawText}";
ep.Metadata.Add(new GrpcMethodMetadata(typeof(TService), method.Method));
foreach (var item in method.Metadata)
{
ep.Metadata.Add(item);
}
});
endpointConventionBuilders.Add(endpointBuilder);
// Report the last HttpMethodMetadata added. It's the metadata used by routing.
var httpMethod = method.Metadata.OfType <HttpMethodMetadata>().LastOrDefault();
Log.AddedServiceMethod(
_logger,
method.Method.Name,
method.Method.ServiceName,
method.Method.Type,
httpMethod?.HttpMethods ?? Array.Empty <string>(),
method.Pattern.RawText ?? string.Empty);
}
}
else
{
Log.NoServiceMethodsDiscovered(_logger, typeof(TService));
}
CreateUnimplementedEndpoints(
endpointRouteBuilder,
_serviceMethodsRegistry,
_serverCallHandlerFactory,
serviceMethodProviderContext.Methods,
endpointConventionBuilders);
_serviceMethodsRegistry.Methods.AddRange(serviceMethodProviderContext.Methods);
return(endpointConventionBuilders);
}
internal ProviderServiceBinder(ServiceMethodProviderContext <TService> context, Type declaringType)
{
_context = context;
_declaringType = declaringType;
_isIGrpcService = typeof(IGrpcService).IsAssignableFrom(typeof(TService));
_isIGrpcBaseService = typeof(IGrpcBaseService).IsAssignableFrom(typeof(TService));
}
public void OnServiceMethodDiscovery(ServiceMethodProviderContext <TService> context)
{
var bindMethodInfo = BindMethodFinder.GetBindMethod(typeof(TService));
// Invoke BindService(ServiceBinderBase, BaseType)
if (bindMethodInfo != null)
{
// The second parameter is always the service base type
var serviceParameter = bindMethodInfo.GetParameters()[1];
var binder = new ProviderServiceBinder <TService>(context, serviceParameter.ParameterType);
try
{
bindMethodInfo.Invoke(null, new object?[] { binder, null });
}
catch (Exception ex)
{
throw new InvalidOperationException($"Error binding gRPC service '{typeof(TService).Name}'.", ex);
}
}
else
{
Log.BindMethodNotFound(_logger, typeof(TService));
}
}
void AddUnaryMethod <TRequest, TResponse>(ServiceMethodProviderContext <TService> context, string serviceName, MethodInfo method)
where TRequest : class
where TResponse : class
{
var serviceMethodAttribute = method.GetCustomAttribute <GrpcMethodAttribute>();
var unaryMethod = new Method <TRequest, TResponse>(
MethodType.Unary,
serviceName,
serviceMethodAttribute?.Name ?? method.Name,
CreateRequestMarshaller <TRequest>(
serviceMethodAttribute?.RequestMarshallerType ?? FindRequestMarshaller <TRequest>(method)),
CreateResponseMarshaller <TResponse>(
serviceMethodAttribute?.ResponseMarshallerType ?? FindResponseMarshaller <TResponse>(method)));
context.AddUnaryMethod(
unaryMethod,
Array.Empty <object>(),
_unaryServerMethodBuilder.Build <TRequest, TResponse>(method),
options =>
{
foreach (var interceptor in FindInterceptors(method))
{
options.Interceptors.Add(interceptor.InterceptorType, interceptor.Args);
}
});
}
void IServiceMethodProvider <TService> .OnServiceMethodDiscovery(
ServiceMethodProviderContext <TService> context)
{
if (m_adapterFactory.TryGetDefinition <TService>(out var definition))
{
definition.Visit(new Adapter(m_logger, context));
}
}
public void OnServiceMethodDiscovery(ServiceMethodProviderContext <NetGrpcServer> context)
{
context.AddUnaryMethod(GrpcMethodDefinition.Create <RpcObjectRequest, RpcServicesQueryResponse>(
GrpcCore.MethodType.Unary,
"SciTech.Rpc.RpcService", "QueryServices",
this.server.Serializer),
new List <object>(),
NetGrpcServer.QueryServices);// (s, request, context) => Task.FromResult(s.QueryServices(request)));
}
public void OnServiceMethodDiscovery(ServiceMethodProviderContext <TService> context)
{
var binder = new MagicOnionGlueServiceBinder <TService>(context);
foreach (var methodHandler in _magicOnionServiceDefinition.MethodHandlers)
{
methodHandler.BindHandler(binder);
}
}
void IServiceMethodProvider <TService> .OnServiceMethodDiscovery(ServiceMethodProviderContext <TService> context)
{
int count = Binder.Instance.Bind <TService>(context, _binderConfiguration);
if (count != 0)
{
_logger.Log(LogLevel.Information, "RPC services being provided by {0}: {1}", typeof(TService), count);
}
}
public AspNetCoreServiceMethodBinder(
ServiceMethodProviderContext <TService> context,
IMarshallerFactory marshallerFactory,
ServiceMethodFilterRegistration filterRegistration,
bool requiresGrpcMarker)
{
_context = context;
_filterRegistration = filterRegistration;
_requiresGrpcMarker = requiresGrpcMarker;
MarshallerFactory = marshallerFactory;
}
public ServiceMethodProviderContext OnServiceMethodDiscovery()
{
var context = new ServiceMethodProviderContext();
var methods = DashboardActionRoute.GetMethods();
foreach (var method in methods)
{
context.AddMethod(method);
}
return(context);
}
internal List <IEndpointConventionBuilder> Build(IEndpointRouteBuilder endpointRouteBuilder)
{
Log.DiscoveringServiceMethods(_logger, typeof(TService));
var serviceMethodProviderContext = new ServiceMethodProviderContext <TService>(_serverCallHandlerFactory);
foreach (var serviceMethodProvider in _serviceMethodProviders)
{
serviceMethodProvider.OnServiceMethodDiscovery(serviceMethodProviderContext);
}
var endpointConventionBuilders = new List <IEndpointConventionBuilder>();
if (serviceMethodProviderContext.Methods.Count > 0)
{
foreach (var method in serviceMethodProviderContext.Methods)
{
var pattern = method.Method.FullName;
var endpointBuilder = endpointRouteBuilder.MapPost(pattern, method.RequestDelegate);
endpointBuilder.Add(ep =>
{
ep.DisplayName = $"gRPC - {pattern}";
ep.Metadata.Add(new GrpcMethodMetadata(typeof(TService), method.Method));
foreach (var item in method.Metadata)
{
ep.Metadata.Add(item);
}
});
endpointConventionBuilders.Add(endpointBuilder);
Log.AddedServiceMethod(_logger, method.Method.Name, method.Method.ServiceName, method.Method.Type, pattern);
}
}
else
{
Log.NoServiceMethodsDiscovered(_logger, typeof(TService));
}
CreateUnimplementedEndpoints(
endpointRouteBuilder,
_serviceMethodsRegistry,
_serverCallHandlerFactory,
serviceMethodProviderContext.Methods);
_serviceMethodsRegistry.Methods.AddRange(serviceMethodProviderContext.Methods);
return(endpointConventionBuilders);
}
public void OnServiceMethodDiscovery(ServiceMethodProviderContext <TService> context)
{
var serviceType = typeof(TService);
if (ServiceContract.IsNativeGrpcService(serviceType))
{
_logger.LogDebug("Ignore service {0} binding: native grpc service.", serviceType.FullName);
return;
}
var marshallerFactory = (_serviceConfiguration.MarshallerFactory ?? _rootConfiguration.DefaultMarshallerFactory).ThisOrDefault();
var serviceBinder = new AspNetCoreServiceMethodBinder <TService>(context, marshallerFactory);
CreateEndpointBinder().Bind(serviceBinder);
}
public void OnServiceMethodDiscovery(ServiceMethodProviderContext <TService> context)
{
// ignore any services that are known to be the default handler
if (Attribute.IsDefined(typeof(TService), typeof(BindServiceMethodAttribute)))
{
return;
}
// we support methods that match suitable signatures, where the method is on an
// interface that TService implements, and the interface is marked [ServiceContract]
foreach (var iType in ContractOperation.ExpandInterfaces(typeof(TService)))
{
AddMethodsForService(context, iType);
}
}
public void OnServiceMethodDiscovery(ServiceMethodProviderContext <TService> context)
{
var bindMethodInfo = BindMethodFinder.GetBindMethod(typeof(TService));
// Invoke BindService(ServiceBinderBase, BaseType)
if (bindMethodInfo != null)
{
// The second parameter is always the service base type
var serviceParameter = bindMethodInfo.GetParameters()[1];
ServiceDescriptor?serviceDescriptor = null;
try
{
serviceDescriptor = ServiceDescriptorHelpers.GetServiceDescriptor(bindMethodInfo.DeclaringType !);
}
catch (Exception ex)
{
Log.ServiceDescriptorError(_logger, typeof(TService), ex);
}
if (serviceDescriptor != null)
{
var binder = new HttpApiProviderServiceBinder <TService>(
context,
serviceParameter.ParameterType,
serviceDescriptor,
_globalOptions,
_serviceOptions,
_serviceProvider,
_loggerFactory,
_serviceActivator);
try
{
bindMethodInfo.Invoke(null, new object[] { binder, null });
}
catch (Exception ex)
{
throw new InvalidOperationException($"Error binding gRPC service '{typeof(TService).Name}'.",
ex);
}
}
}
else
{
Log.BindMethodNotFound(_logger, typeof(TService));
}
}
public void OnServiceMethodDiscovery(ServiceMethodProviderContext <TActivator> context)
{
var activatorType = typeof(TActivator);
if (activatorType.IsGenericType &&
activatorType.GetGenericTypeDefinition().Equals(typeof(NetGrpcServiceActivator <>)))
{
var serviceType = activatorType.GetGenericArguments()[0];
//MethodInfo buildServiceStubMethod = typeof(NetGrpcServiceMethodProvider<TActivator>)
// .GetMethod(nameof(BuildServiceStub), BindingFlags.Instance | BindingFlags.NonPublic)!;
var typedBuildServiceStubMethod = BuildServiceStubMethod.MakeGenericMethod(serviceType);
typedBuildServiceStubMethod.Invoke(this, new object[] { context });
}
}
public void OnServiceMethodDiscovery(ServiceMethodProviderContext <TService> context)
{
var serviceAttribute = typeof(TService).GetCustomAttribute <GrpcServiceAttribute>();
if (serviceAttribute == null)
{
// we should allow this and treat the GrpcServiceAttribute as an override to the default
// conventions but that means that we could potentially duplicate the methods as the
// binder service works first
return;
}
var serviceName = serviceAttribute.Name ?? typeof(TService).FullName;
if (serviceName == null)
{
throw new ArgumentException("Could not determine Service Name.");
}
foreach (var(serviceMethod, serviceMethodAttribute) in FindMethods())
{
MethodInfo method;
switch (serviceMethodAttribute.MethodType ?? GuessMethodType(serviceMethod))
{
case MethodType.Unary:
method = RegisterUnaryMethod
.MakeGenericMethod(
serviceMethodAttribute.RequestType ?? FindRequestType(MethodType.Unary, serviceMethod),
serviceMethodAttribute.ResponseType ?? FindResponseType(MethodType.Unary, serviceMethod));
break;
case MethodType.ServerStreaming:
method = RegisterServerStreamingMethod
.MakeGenericMethod(
serviceMethodAttribute.RequestType ?? FindRequestType(MethodType.ServerStreaming, serviceMethod),
serviceMethodAttribute.ResponseType ?? FindResponseType(MethodType.ServerStreaming, serviceMethod));
break;
//case MethodType.ClientStreaming:
//case MethodType.DuplexStreaming:
default:
continue;
}
method.Invoke(this, new object[] { context, serviceName, serviceMethod });
}
}
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 async Task OnServiceMethodDiscovery_ServiceWithDuplicateMethodNames_Success()
{
// Arrange
var services = new ServiceCollection();
services.AddSingleton <GreeterServiceWithDuplicateNames>();
var serverCallHandlerFactory = new ServerCallHandlerFactory <GreeterServiceWithDuplicateNames>(
NullLoggerFactory.Instance,
Options.Create <GrpcServiceOptions>(new GrpcServiceOptions()),
Options.Create <GrpcServiceOptions <GreeterServiceWithDuplicateNames> >(new GrpcServiceOptions <GreeterServiceWithDuplicateNames>()),
new TestGrpcServiceActivator <GreeterServiceWithDuplicateNames>());
var provider = new BinderServiceMethodProvider <GreeterServiceWithDuplicateNames>(NullLoggerFactory.Instance);
var context = new ServiceMethodProviderContext <GreeterServiceWithDuplicateNames>(serverCallHandlerFactory);
var httpContext = HttpContextHelpers.CreateContext();
httpContext.RequestServices = services.BuildServiceProvider();
// Act
provider.OnServiceMethodDiscovery(context);
// Assert
Assert.AreEqual(2, context.Methods.Count);
var methodModel = context.Methods[0];
Assert.AreEqual("SayHello", methodModel.Method.Name);
var ms = new MemoryStream();
MessageHelpers.WriteMessage(ms, new HelloRequest
{
Name = "World"
});
ms.Seek(0, SeekOrigin.Begin);
httpContext.Request.Body = ms;
await methodModel.RequestDelegate(httpContext);
// Expect 12 (unimplemented) from base type
Assert.AreEqual("12", httpContext.Response.Headers["grpc-status"]);
}
public void OnServiceMethodDiscovery(ServiceMethodProviderContext <GrpcService> context)
{
// mapper
var mapperValidator = _cfg.MapperValidator != null?Activator.CreateInstance(_cfg.MapperValidator) as IPropertyMapValidator : null;
var mapper = _cqrs.CreateMapper(mapperValidator);
// set server id for logging
var serverId = !string.IsNullOrWhiteSpace(_cfg.ServerId) ? _cfg.ServerId : Assembly.GetEntryAssembly().FullName.Split(',')[0];
// create methos
var methodAddGeneric = GetType().GetMethods(BindingFlags.NonPublic | BindingFlags.Instance).First(x => x.Name == nameof(AddMethod));
_cqrs.ToCqrsChannelInfo().ToList().ForEach(x => {
var method = GrpcMethodFactoryUtil.CreateGrpcMethodGeneric(x);
var invokeMethod = GrpcServerMethodFactoryUtil.CreateServerMethodGeneric(_container, serverId, x, mapper, _cfg.TimeoutMs);
var methodAdd = methodAddGeneric.MakeGenericMethod(x.ChReqType, x.ChRspEnvType);
methodAdd.Invoke(this, new object[] { context, method, invokeMethod });
});
}
private JsonTranscodingProviderServiceBinder <DynamicService> CreateJsonTranscodingBinder <TRequest, TResponse>(
MethodDescriptor methodDescriptor,
ServiceMethodProviderContext <DynamicService> context,
DynamicServiceInvokerResolver invokerResolver)
where TRequest : class, IMessage, new()
where TResponse : class, IMessage, new()
{
var JsonTranscodingOptions = _serviceProvider.GetRequiredService <IOptions <GrpcJsonTranscodingOptions> >().Value;
var binder = new JsonTranscodingProviderServiceBinder <DynamicService>(
context,
invokerResolver,
methodDescriptor.Service,
_serviceProvider.GetRequiredService <IOptions <GrpcServiceOptions> >().Value,
_serviceProvider.GetRequiredService <IOptions <GrpcServiceOptions <DynamicService> > >().Value,
_serviceProvider.GetRequiredService <ILoggerFactory>(),
_serviceProvider.GetRequiredService <IGrpcServiceActivator <DynamicService> >(),
JsonTranscodingOptions);
return(binder);
}
private void AddMethodsForService(ServiceMethodProviderContext <TService> context, Type serviceContract)
{
bool isPublicContract = typeof(TService) == serviceContract;
if (!ContractOperation.TryGetServiceName(serviceContract, out var serviceName, !isPublicContract))
{
return;
}
_logger.Log(LogLevel.Trace, "pb-net processing {0}/{1} as {2}", typeof(TService).Name, serviceContract.Name, serviceName);
object?[]? argsBuffer = null;
Type[] typesBuffer = Array.Empty <Type>();
int count = 0;
foreach (var op in ContractOperation.FindOperations(serviceContract, isPublicContract))
{
if (_invokers.TryGetValue((op.MethodType, op.Context, op.Result, op.Void), out var invoker) &&
AddMethod(op.From, op.To, op.Method, op.MethodType, invoker))
{
// yay!
count++;
}
private void BuildServiceStub <TService>(ServiceMethodProviderContext <TActivator> context) where TService : class
{
var typedContext = context as ServiceMethodProviderContext <NetGrpcServiceActivator <TService> >;
if (typedContext == null)
{
// This shouldn't happen, since OnServiceMethodDiscovery should have already checked the type
throw new InvalidCastException("Unexpected failure when casting to ServiceMethodProviderContext<NetGrpcServiceActivator<TService>>.");
}
var serviceInfo = this.rpcServer.ServiceDefinitionsProvider.GetRegisteredServiceInfo(typeof(TService));
if (serviceInfo == null)
{
throw new InvalidOperationException($"Service '{typeof(TService)}' not registered.");
}
var stubBuilder = new NetGrpcServiceStubBuilder <TService>(
serviceInfo,
this.serviceProvider.GetService <IOptions <RpcServiceOptions <TService> > >()?.Value);
stubBuilder.Bind(this.rpcServer, typedContext);
}
public MagicOnionGlueServiceBinder(ServiceMethodProviderContext <TService> context)
{
_context = context;
}
internal void Bind(NetGrpcServer server, ServiceMethodProviderContext <NetGrpcServiceActivator <TService> > providerContext)
{
var binder = new NetGrpcServiceStubBuilder <TService> .Binder(providerContext);
this.GenerateOperationHandlers(server, binder);
}
private void AddMethod <TChReq, TchRsp>(ServiceMethodProviderContext <GrpcService> context, Method <TChReq, TchRsp> method, UnaryServerMethod <GrpcService, TChReq, TchRsp> unaryServerMethod)
where TChReq : class
where TchRsp : class
{
context.AddUnaryMethod(method, new List <object>(), unaryServerMethod);
}
public Adapter(ILogger <CodeFirstServiceMethodProvider <TService> > logger,
ServiceMethodProviderContext <TService> context)
{
m_logger = logger;
m_context = context;
}
internal ProviderServiceBinder(ServiceMethodProviderContext <TService> context, Type declaringType)
{
_context = context;
_declaringType = declaringType;
}
