private async Task OnAfterHandleAsync(MessageHandlingContext context)
{
foreach (var listener in _messageListeners)
{
await listener.AfterHandleAsync(context);
}
}
public Task HandleAsync(MessageHandlingContext context)
{
if (context.Terminated)
{
return(Task.CompletedTask);
}
var message = context.Message;
switch (message.Type)
{
case MessageType.GQL_CONNECTION_INIT:
return(HandleInitAsync(context));
case MessageType.GQL_START:
return(HandleStartAsync(context));
case MessageType.GQL_STOP:
return(HandleStopAsync(context));
case MessageType.GQL_CONNECTION_TERMINATE:
return(HandleTerminateAsync(context));
default:
return(HandleUnknownAsync(context));
}
}
private Task HandleStopAsync(MessageHandlingContext context)
{
var message = context.Message;
_logger.LogDebug("Handle stop: {id}", message.Id);
return(context.Subscriptions.UnsubscribeAsync(message.Id));
}
private async Task OnHandleAsync(MessageHandlingContext context)
{
foreach (var listener in _messageListeners)
{
await listener.HandleAsync(context).ConfigureAwait(false);
}
}
/// <inheritdoc />
public async Task SubscribeOrExecuteAsync(
string id,
OperationMessagePayload payload,
MessageHandlingContext context)
{
if (id == null)
{
throw new ArgumentNullException(nameof(id));
}
if (payload == null)
{
throw new ArgumentNullException(nameof(payload));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var subscription = await ExecuteAsync(id, payload, context).ConfigureAwait(false);
if (subscription == null)
{
return;
}
_subscriptions[id] = subscription;
}
private Task HandleInitAsync(MessageHandlingContext context)
{
_logger.LogDebug("Handle init");
return(context.Writer.SendAsync(new OperationMessage
{
Type = MessageType.GQL_CONNECTION_ACK
}));
}
public Task HandleAsync(MessageHandlingContext context)
{
if (context.Terminated)
{
return(Task.CompletedTask);
}
return(context.Message.Type switch
{
MessageType.GQL_CONNECTION_INIT => HandleInitAsync(context),
MessageType.GQL_START => HandleStartAsync(context),
MessageType.GQL_STOP => HandleStopAsync(context),
MessageType.GQL_CONNECTION_TERMINATE => HandleTerminateAsync(context),
_ => HandleUnknownAsync(context),
});
private Task HandleStartAsync(MessageHandlingContext context)
{
var message = context.Message;
_logger.LogDebug("Handle start: {id}", message.Id);
var payload = ((JObject)message.Payload).ToObject <OperationMessagePayload>();
if (payload == null)
{
throw new InvalidOperationException($"Could not get OperationMessagePayload from message.Payload");
}
return(context.Subscriptions.SubscribeOrExecuteAsync(
message.Id,
payload,
context));
}
private Task HandleUnknownAsync(MessageHandlingContext context)
{
var message = context.Message;
_logger.LogError($"Unexpected message type: {message.Type}");
return(context.Writer.SendAsync(new OperationMessage
{
Type = MessageType.GQL_CONNECTION_ERROR,
Id = message.Id,
Payload = new ExecutionResult
{
Errors = new ExecutionErrors
{
new ExecutionError($"Unexpected message type {message.Type}")
}
}
}));
}
public Task AfterHandleAsync(MessageHandlingContext context)
{
return(Task.CompletedTask);
}
private Task HandleTerminateAsync(MessageHandlingContext context)
{
_logger.LogDebug("Handle terminate");
return(context.Terminate());
}
private async Task <Subscription> ExecuteAsync(
string id,
OperationMessagePayload payload,
MessageHandlingContext context)
{
var writer = context.Writer;
_logger.LogDebug("Executing operation: {operationName} query: {query}",
payload.OperationName,
payload.Query);
var result = await _executer.ExecuteAsync(
payload.OperationName,
payload.Query,
payload.Variables?.ToInputs(),
context,
null // TODO: find later a better way to specify services
).ConfigureAwait(false);
if (result.Errors != null && result.Errors.Any())
{
_logger.LogError("Execution errors: {errors}", ResultHelper.GetErrorString(result));
await writer.SendAsync(new OperationMessage
{
Type = MessageType.GQL_ERROR,
Id = id,
Payload = result
}).ConfigureAwait(false);
return(null);
}
// is sub
if (result is SubscriptionExecutionResult subscriptionExecutionResult)
{
using (_logger.BeginScope("Subscribing to: {subscriptionId}", id))
{
if (subscriptionExecutionResult.Streams?.Values.SingleOrDefault() == null)
{
_logger.LogError("Cannot subscribe as no result stream available");
await writer.SendAsync(new OperationMessage
{
Type = MessageType.GQL_ERROR,
Id = id,
Payload = result
}).ConfigureAwait(false);
return(null);
}
_logger.LogDebug("Creating subscription");
return(new Subscription(
id,
payload,
subscriptionExecutionResult,
writer,
sub => _subscriptions.TryRemove(id, out _),
_loggerFactory.CreateLogger <Subscription>()));
}
}
//is query or mutation
await writer.SendAsync(new OperationMessage
{
Type = MessageType.GQL_DATA,
Id = id,
Payload = result
}).ConfigureAwait(false);
await writer.SendAsync(new OperationMessage
{
Type = MessageType.GQL_COMPLETE,
Id = id
}).ConfigureAwait(false);
return(null);
}
public Task AfterHandleAsync(MessageHandlingContext context) => Task.CompletedTask;
public Task HandleAsync(MessageHandlingContext context)
{
_logger.LogDebug("Received message: {message}", context.Message);
return(Task.CompletedTask);
}
public Task BeforeHandleAsync(MessageHandlingContext context) => Task.FromResult(true);
public Task BeforeHandleAsync(MessageHandlingContext context)
{
return(Task.FromResult(true));
}
