public static Task HandleNotification(IHandlerDescriptor instance)
{
var method = instance.HandlerType.GetTypeInfo()
.GetMethod(nameof(INotificationHandler.Handle), BindingFlags.Public | BindingFlags.Instance);
return((Task)method.Invoke(instance.Handler, new object[0]));
}
public static Task HandleRequest(IHandlerDescriptor instance, object @params, CancellationToken token)
{
var method = instance.HandlerType.GetTypeInfo()
.GetMethod(nameof(IRequestHandler <object, object> .Handle), BindingFlags.Public | BindingFlags.Instance);
return((Task)method.Invoke(instance.Handler, new[] { @params, token }));
}
protected virtual async Task <ErrorResponse> RouteRequest(IHandlerDescriptor handler, Request request, CancellationToken token)
{
if (request.Method is null)
{
return(new MethodNotFound(request.Id, request.Method));
}
object @params;
try
{
@params = request.Params.ToObject(handler.Params, _serializer.JsonSerializer);
}
catch
{
return(new InvalidParams(request.Id));
}
var result = ReflectionRequestHandlers.HandleRequest(handler, @params, token);
await result.ConfigureAwait(false);
object responseValue = null;
if (result.GetType().GetTypeInfo().IsGenericType)
{
var property = typeof(Task <>)
.MakeGenericType(result.GetType().GetTypeInfo().GetGenericArguments()[0]).GetTypeInfo()
.GetProperty(nameof(Task <object> .Result), BindingFlags.Public | BindingFlags.Instance);
responseValue = property.GetValue(result);
}
return(new Client.Response(request.Id, responseValue));
}
public async Task RouteNotification(IHandlerDescriptor descriptor, Notification notification)
{
using (_logger.TimeDebug("Routing Notification {Method}", notification.Method))
{
using (_logger.BeginScope(new KeyValuePair <string, string>[] {
new KeyValuePair <string, string>("Method", notification.Method),
new KeyValuePair <string, string>("Params", notification.Params?.ToString())
}))
{
try
{
if (descriptor.Params is null)
{
await ReflectionRequestHandlers.HandleNotification(descriptor);
}
else
{
_logger.LogDebug("Converting params for Notification {Method} to {Type}", notification.Method, descriptor.Params.FullName);
var @params = notification.Params.ToObject(descriptor.Params, _serializer.JsonSerializer);
await ReflectionRequestHandlers.HandleNotification(descriptor, @params);
}
}
catch (Exception e)
{
_logger.LogCritical(Events.UnhandledRequest, e, "Failed to handle request {Method}", notification.Method);
}
}
}
}
public RequestProcessType Identify(IHandlerDescriptor descriptor)
{
if (_cache.TryGetValue(descriptor.HandlerType, out var type))
{
return(type);
}
type = _defaultRequestProcessType;
var handlerType = descriptor.ImplementationType;
var processAttribute = descriptor.ImplementationType
.GetCustomAttributes(true)
.Concat(descriptor.HandlerType.GetCustomAttributes(true))
.Concat(descriptor.ImplementationType.GetInterfaces().SelectMany(x => x.GetCustomAttributes()))
.Concat(descriptor.HandlerType.GetInterfaces().SelectMany(x => x.GetCustomAttributes()))
.OfType <ProcessAttribute>()
.FirstOrDefault();
if (processAttribute != null)
{
type = processAttribute.Type;
}
_cache.TryAdd(descriptor.HandlerType, type);
return(type);
}
public async Task RouteNotification(IHandlerDescriptor descriptor, Notification notification)
{
using (_logger.TimeDebug("Routing Notification {Method}", notification.Method))
{
using (_logger.BeginScope(new[] {
new KeyValuePair <string, string>("Method", notification.Method),
new KeyValuePair <string, string>("Params", notification.Params?.ToString())
}))
using (var scope = _serviceScopeFactory.CreateScope())
{
var context = scope.ServiceProvider.GetRequiredService <IRequestContext>();
context.Descriptor = descriptor;
var mediator = scope.ServiceProvider.GetRequiredService <IMediator>();
try
{
if (descriptor.Params is null)
{
await MediatRHandlers.HandleNotification(mediator, descriptor, EmptyRequest.Instance, CancellationToken.None);
}
else
{
_logger.LogDebug("Converting params for Notification {Method} to {Type}", notification.Method, descriptor.Params.FullName);
var @params = (notification.Params ?? new JObject()).ToObject(descriptor.Params, _serializer.JsonSerializer);
await MediatRHandlers.HandleNotification(mediator, descriptor, @params ?? EmptyRequest.Instance, CancellationToken.None);
}
}
catch (Exception e)
{
_logger.LogCritical(Events.UnhandledRequest, e, "Failed to handle request {Method}", notification.Method);
}
}
}
}
public async Task RouteNotification(IHandlerDescriptor handler, Notification notification)
{
using (var scope = _serviceScopeFactory.CreateScope())
{
var context = scope.ServiceProvider.GetRequiredService <IRequestContext>();
context.Descriptor = handler;
object @params = null;
if (!(handler.Params is null))
{
@params = notification.Params.ToObject(handler.Params, _serializer.JsonSerializer);
}
await MediatRHandlers.HandleNotification(scope.ServiceProvider.GetRequiredService <IMediator>(), handler, @params ?? EmptyRequest.Instance, CancellationToken.None).ConfigureAwait(false);
}
}
public static Task HandleRequest(IMediator mediator, IHandlerDescriptor descriptor, object @params, CancellationToken token)
{
if (!descriptor.HasReturnType)
{
return((Task)SendRequestUnit
.MakeGenericMethod(descriptor.Params)
.Invoke(null, new object[] { mediator, @params, token }));
}
else
{
return((Task)SendRequestResponse
.MakeGenericMethod(descriptor.Params, descriptor.Response)
.Invoke(null, new object[] { mediator, @params, token }));
}
}
public async Task RouteNotification(IHandlerDescriptor handler, Notification notification)
{
Task result;
if (handler.Params is null)
{
result = ReflectionRequestHandlers.HandleNotification(handler);
}
else
{
var @params = notification.Params.ToObject(handler.Params, _serializer.JsonSerializer);
result = ReflectionRequestHandlers.HandleNotification(handler, @params);
}
await result.ConfigureAwait(false);
}
public static Task HandleRequest(IMediator mediator, IHandlerDescriptor handler, object @params, CancellationToken token)
{
if (handler.HandlerType.GetInterfaces().Any(x =>
x.IsGenericType && typeof(IRequestHandler <>).IsAssignableFrom(x.GetGenericTypeDefinition())))
{
return((Task)SendRequestUnit
.MakeGenericMethod(handler.Params)
.Invoke(null, new object[] { mediator, @params, token }));
}
else
{
return((Task)SendRequestResponse
.MakeGenericMethod(handler.Params, handler.Response)
.Invoke(null, new object[] { mediator, @params, token }));
}
}
protected virtual async Task <ErrorResponse> RouteRequest(IHandlerDescriptor handler, Request request, CancellationToken token)
{
using (var scope = _serviceScopeFactory.CreateScope())
{
var context = scope.ServiceProvider.GetRequiredService <IRequestContext>();
context.Descriptor = handler;
if (request.Method is null)
{
return(new MethodNotFound(request.Id, request.Method));
}
object @params;
try
{
@params = request.Params.ToObject(handler.Params, _serializer.JsonSerializer);
}
catch
{
return(new InvalidParams(request.Id));
}
var result = MediatRHandlers.HandleRequest(scope.ServiceProvider.GetRequiredService <IMediator>(), handler, @params, token);
await result.ConfigureAwait(false);
object responseValue = null;
if (result.GetType().GetTypeInfo().IsGenericType)
{
var property = typeof(Task <>)
.MakeGenericType(result.GetType().GetTypeInfo().GetGenericArguments()[0]).GetTypeInfo()
.GetProperty(nameof(Task <object> .Result), BindingFlags.Public | BindingFlags.Instance);
responseValue = property.GetValue(result);
if (responseValue?.GetType() == typeof(Unit))
{
responseValue = null;
}
}
return(new Client.Response(request.Id, responseValue));
}
}
public async Task RouteNotification(IHandlerDescriptor handler, Notification notification)
{
try
{
Task result;
if (handler.Params is null)
{
result = ReflectionRequestHandlers.HandleNotification(handler);
}
else
{
var @params = notification.Params.ToObject(handler.Params);
result = ReflectionRequestHandlers.HandleNotification(handler, @params);
}
await result;
}
catch (Exception e)
{
_logger.LogCritical(Events.UnhandledRequest, e, "Failed to handle request {Method}", notification.Method);
}
}
public async Task RouteNotification(IHandlerDescriptor descriptor, Notification notification)
{
using (_logger.TimeDebug("Routing Notification {Method}", notification.Method))
{
using (_logger.BeginScope(new KeyValuePair <string, string>[] {
new KeyValuePair <string, string>("Method", notification.Method),
new KeyValuePair <string, string>("Params", notification.Params?.ToString())
}))
{
try
{
if (descriptor.Params is null)
{
await ReflectionRequestHandlers.HandleNotification(descriptor);
}
else
{
_logger.LogDebug("Converting params for Notification {Method} to {Type}", notification.Method, descriptor.Params.FullName);
var @params = notification.Params.ToObject(descriptor.Params, _serializer.JsonSerializer);
var lspDescriptor = descriptor as ILspHandlerDescriptor;
foreach (var preProcessor in _routeMatchers.ForHandlerPreProcessorMatcher()
.SelectMany(strat => strat.FindPreProcessor(lspDescriptor, @params)))
{
@params = preProcessor.Process(lspDescriptor, @params);
}
await ReflectionRequestHandlers.HandleNotification(descriptor, @params);
}
}
catch (Exception e)
{
_logger.LogCritical(Events.UnhandledRequest, e, "Failed to handle request {Method}", notification.Method);
}
}
}
}
public RequestProcessType Identify(IHandlerDescriptor descriptor)
{
if (descriptor.RequestProcessType.HasValue)
{
return(descriptor.RequestProcessType.Value);
}
if (_cache.TryGetValue(descriptor.HandlerType, out var type))
{
return(type);
}
type = _defaultRequestProcessType;
var typeDescriptor = HandlerTypeDescriptorHelper.GetHandlerTypeDescriptor(descriptor.HandlerType);
if (typeDescriptor?.RequestProcessType.HasValue == true)
{
type = typeDescriptor.RequestProcessType.Value;
}
else
{
var processAttribute = descriptor.ImplementationType
.GetCustomAttributes(true)
.Concat(descriptor.HandlerType.GetCustomAttributes(true))
.OfType <ProcessAttribute>()
.FirstOrDefault();
if (processAttribute != null)
{
type = processAttribute.Type;
}
}
_cache.TryAdd(descriptor.HandlerType, type);
return(type);
}
public RequestProcessType Identify(IHandlerDescriptor descriptor)
{
if (_cache.TryGetValue(descriptor.HandlerType, out var type))
{
return(type);
}
type = _defaultRequestProcessType;
var handlerType = descriptor.Handler.GetType().GetTypeInfo();
var processAttribute = handlerType
.GetCustomAttributes(true)
.Concat(descriptor.HandlerType.GetTypeInfo().GetCustomAttributes(true))
.OfType <ProcessAttribute>()
.FirstOrDefault();
if (processAttribute != null)
{
type = processAttribute.Type;
}
_cache.TryAdd(descriptor.HandlerType, type);
return(type);
}
public async Task <ErrorResponse> RouteRequest(IHandlerDescriptor descriptor, Request request)
{
using (_logger.TimeDebug("Routing Request ({Id}) {Method}", request.Id, request.Method))
{
using (_logger.BeginScope(new[] {
new KeyValuePair <string, string>("Id", request.Id?.ToString()),
new KeyValuePair <string, string>("Method", request.Method),
new KeyValuePair <string, string>("Params", request.Params?.ToString())
}))
using (var scope = _serviceScopeFactory.CreateScope())
{
var context = scope.ServiceProvider.GetRequiredService <IRequestContext>();
context.Descriptor = descriptor;
var mediator = scope.ServiceProvider.GetRequiredService <IMediator>();
var id = GetId(request.Id);
var cts = new CancellationTokenSource();
_requests.TryAdd(id, cts);
// TODO: Try / catch for Internal Error
try
{
if (descriptor is null)
{
_logger.LogDebug("descriptor not found for Request ({Id}) {Method}", request.Id, request.Method);
return(new MethodNotFound(request.Id, request.Method));
}
object @params;
try
{
_logger.LogDebug("Converting params for Request ({Id}) {Method} to {Type}", request.Id, request.Method, descriptor.Params.FullName);
@params = request.Params?.ToObject(descriptor.Params, _serializer.JsonSerializer);
}
catch (Exception cannotDeserializeRequestParams)
{
_logger.LogError(new EventId(-32602), cannotDeserializeRequestParams, "Failed to deserialise request parameters.");
return(new InvalidParams(request.Id));
}
var result = MediatRHandlers.HandleRequest(mediator, descriptor, @params ?? EmptyRequest.Instance, cts.Token);
await result;
_logger.LogDebug("Result was {Type}", result.GetType().FullName);
object responseValue = null;
if (result.GetType().GetTypeInfo().IsGenericType)
{
var property = typeof(Task <>)
.MakeGenericType(result.GetType().GetTypeInfo().GetGenericArguments()[0]).GetTypeInfo()
.GetProperty(nameof(Task <object> .Result), BindingFlags.Public | BindingFlags.Instance);
responseValue = property.GetValue(result);
if (responseValue?.GetType() == typeof(Unit))
{
responseValue = null;
}
_logger.LogDebug("Response value was {Type}", responseValue?.GetType().FullName);
}
return(new JsonRpc.Client.Response(request.Id, responseValue));
}
catch (TaskCanceledException e)
{
_logger.LogDebug("Request {Id} was cancelled", id);
return(new RequestCancelled());
}
catch (Exception e)
{
_logger.LogCritical(Events.UnhandledRequest, e, "Failed to handle notification {Method}", request.Method);
return(new InternalError(id, e.ToString()));
}
finally
{
_requests.TryRemove(id, out var _);
}
}
}
}
public RequestProcessType Identify(IHandlerDescriptor descriptor)
{
return(descriptor.RequestProcessType ?? RequestProcessType.Parallel);
}
public Task <ErrorResponse> RouteRequest(IHandlerDescriptor descriptor, Request request)
{
return(RouteRequest(descriptor, request, CancellationToken.None));
}
public async Task <ErrorResponse> RouteRequest(IHandlerDescriptor descriptor, Request request)
{
var id = GetId(request.Id);
var cts = new CancellationTokenSource();
_requests.TryAdd(id, cts);
// TODO: Try / catch for Internal Error
try
{
if (descriptor is null)
{
return(new MethodNotFound(request.Id, request.Method));
}
Task result;
if (descriptor.Params is null)
{
result = ReflectionRequestHandlers.HandleRequest(descriptor, cts.Token);
}
else
{
object @params;
try
{
@params = request.Params.ToObject(descriptor.Params);
}
catch
{
return(new InvalidParams(request.Id));
}
result = ReflectionRequestHandlers.HandleRequest(descriptor, @params, cts.Token);
}
await result.ConfigureAwait(false);
object responseValue = null;
if (result.GetType().GetTypeInfo().IsGenericType)
{
var property = typeof(Task <>)
.MakeGenericType(result.GetType().GetTypeInfo().GetGenericArguments()[0]).GetTypeInfo()
.GetProperty(nameof(Task <object> .Result), BindingFlags.Public | BindingFlags.Instance);
responseValue = property.GetValue(result);
}
return(new JsonRpc.Client.Response(request.Id, responseValue));
}
catch (TaskCanceledException)
{
return(new RequestCancelled());
}
catch (Exception e)
{
_logger.LogCritical(Events.UnhandledRequest, e, "Failed to handle notification {Method}", request.Method);
return(new InternalError(id));
}
finally
{
_requests.TryRemove(id, out var _);
}
}
public static Task HandleNotification(IMediator mediator, IHandlerDescriptor handler, object @params, CancellationToken token)
{
return((Task)SendRequestUnit
.MakeGenericMethod(handler.Params ?? typeof(EmptyRequest))
.Invoke(null, new object[] { mediator, @params, token }));
}
public async Task <ErrorResponse> RouteRequest(IHandlerDescriptor descriptor, Request request)
{
using (_logger.TimeDebug("Routing Request ({Id}) {Method}", request.Id, request.Method))
{
using (_logger.BeginScope(new KeyValuePair <string, string>[] {
new KeyValuePair <string, string>("Id", request.Id?.ToString()),
new KeyValuePair <string, string>("Method", request.Method),
new KeyValuePair <string, string>("Params", request.Params?.ToString())
}))
{
var id = GetId(request.Id);
var cts = new CancellationTokenSource();
_requests.TryAdd(id, cts);
// TODO: Try / catch for Internal Error
try
{
if (descriptor is null)
{
_logger.LogDebug("descriptor not found for Request ({Id}) {Method}", request.Id, request.Method);
return(new MethodNotFound(request.Id, request.Method));
}
object @params;
try
{
_logger.LogDebug("Converting params for Request ({Id}) {Method} to {Type}", request.Id, request.Method, descriptor.Params.FullName);
@params = request.Params?.ToObject(descriptor.Params, _serializer.JsonSerializer);
}
catch (Exception cannotDeserializeRequestParams)
{
_logger.LogError(new EventId(-32602), cannotDeserializeRequestParams, "Failed to deserialise request parameters.");
return(new InvalidParams(request.Id));
}
var lspDescriptor = descriptor as ILspHandlerDescriptor;
foreach (var preProcessor in _routeMatchers.ForHandlerPreProcessorMatcher()
.SelectMany(strat => strat.FindPreProcessor(lspDescriptor, @params)))
{
@params = preProcessor.Process(lspDescriptor, @params);
}
var result = ReflectionRequestHandlers.HandleRequest(descriptor, @params, cts.Token);
await result;
_logger.LogDebug("Result was {Type}", result.GetType().FullName);
object responseValue = null;
if (result.GetType().GetTypeInfo().IsGenericType)
{
var property = typeof(Task <>)
.MakeGenericType(result.GetType().GetTypeInfo().GetGenericArguments()[0]).GetTypeInfo()
.GetProperty(nameof(Task <object> .Result), BindingFlags.Public | BindingFlags.Instance);
responseValue = property.GetValue(result);
_logger.LogDebug("Response value was {Type}", responseValue?.GetType().FullName);
foreach (var postProcessor in _routeMatchers.ForHandlerPostProcessorMatcher()
.SelectMany(strat => strat.FindPostProcessor(lspDescriptor, @params, responseValue)))
{
responseValue = postProcessor.Process(lspDescriptor, @params, responseValue);
}
}
return(new JsonRpc.Client.Response(request.Id, responseValue));
}
catch (TaskCanceledException e)
{
_logger.LogDebug("Request {Id} was cancelled", id);
return(new RequestCancelled());
}
catch (Exception e)
{
_logger.LogCritical(Events.UnhandledRequest, e, "Failed to handle notification {Method}", request.Method);
return(new InternalError(id));
}
finally
{
_requests.TryRemove(id, out var _);
}
}
}
}
public LinkedHandler(string method, IHandlerDescriptor descriptor, Action disposeAction)
{
_descriptor = descriptor;
_disposeAction = disposeAction;
Method = method;
}
Task IRequestRouter <IHandlerDescriptor> .RouteNotification(IHandlerDescriptor descriptor, Notification notification, CancellationToken token) => RouteNotification(
public RequestProcessType Identify(IHandlerDescriptor descriptor) => descriptor.RequestProcessType ?? RequestProcessType.Serial;
public RequestProcessType Identify(IHandlerDescriptor descriptor)
{
return(RequestProcessType.Serial);
}
