private async Task <MessageContext> ProcessMessage(IAgentContext agentContext, MessageContext messageContext)
{
UnpackResult unpacked = null;
UnpackedMessageContext inboundMessageContext = null;
if (messageContext is PackedMessageContext packedMessageContext)
{
(inboundMessageContext, unpacked) = await UnpackAsync(agentContext, packedMessageContext);
Logger.LogInformation($"Agent Message Received : {inboundMessageContext.ToJson()}");
}
if (Handlers.Where(handler => handler != null).FirstOrDefault(
handler => handler.SupportedMessageTypes.Any(
type => type == inboundMessageContext.GetMessageType())) is
IMessageHandler messageHandler)
{
Logger.LogDebug("Processing message type {MessageType}, {MessageData}",
inboundMessageContext.GetMessageType(),
inboundMessageContext.Payload.GetUTF8String());
// Process message in handler
var response = await messageHandler.ProcessAsync(agentContext, inboundMessageContext);
// Process message with any registered middlewares
foreach (var middleware in Middlewares)
{
await middleware.OnMessageAsync(agentContext, inboundMessageContext);
}
if (response != null)
{
if (inboundMessageContext.ReturnRoutingRequested())
{
var result = inboundMessageContext.Connection != null
? await CryptoUtils.PackAsync(agentContext.Wallet, inboundMessageContext.Connection.TheirVk, response.ToByteArray())
: await CryptoUtils.PackAsync(agentContext.Wallet, unpacked.SenderVerkey, response.ToByteArray());
return(new PackedMessageContext(result));
}
if (inboundMessageContext.Connection != null)
{
await MessageService.SendAsync(agentContext.Wallet, response, inboundMessageContext.Connection);
}
else
{
Logger.LogWarning("Return response available, but connection was not found or was in invalid state");
}
}
return(null);
}
throw new AriesFrameworkException(ErrorCode.InvalidMessage,
$"Couldn't locate a message handler for type {inboundMessageContext.GetMessageType()}");
}
private async Task <(UnpackedMessageContext, UnpackResult)> UnpackAsync(IAgentContext agentContext, PackedMessageContext message)
{
UnpackResult unpacked;
try
{
unpacked = await CryptoUtils.UnpackAsync(agentContext.Wallet, message.Payload);
}
catch (Exception e)
{
Logger.LogError("Failed to un-pack message", e);
throw new AriesFrameworkException(ErrorCode.InvalidMessage, "Failed to un-pack message", e);
}
UnpackedMessageContext result = null;
if (unpacked.SenderVerkey != null && message.Connection == null)
{
try
{
if (await ConnectionService.ResolveByMyKeyAsync(agentContext, unpacked.RecipientVerkey) is ConnectionRecord connection)
{
result = new UnpackedMessageContext(unpacked.Message, connection);
}
else
{
result = new UnpackedMessageContext(unpacked.Message, unpacked.SenderVerkey);
}
}
catch (AriesFrameworkException ex) when(ex.ErrorCode == ErrorCode.RecordNotFound)
{
// OK if not resolved. Example: authpacked forward message in routing agent.
// Downstream consumers should throw if Connection is required
}
}
else
{
if (message.Connection != null)
{
result = new UnpackedMessageContext(unpacked.Message, message.Connection);
}
else
{
result = new UnpackedMessageContext(unpacked.Message, unpacked.SenderVerkey);
}
}
return(result, unpacked);
}
/// <inheritdoc /> public Task <AgentMessage> ProcessAsync(IAgentContext agentContext, UnpackedMessageContext messageContext) => ProcessAsync(messageContext.GetMessage <T>(), agentContext, messageContext);
/// <summary> /// Processes the incoming <see cref="AgentMessage"/> /// </summary> /// <param name="message">The message.</param> /// <param name="agentContext">The message agentContext.</param> /// <param name="messageContext">The message context.</param> /// <returns></returns> protected abstract Task <AgentMessage> ProcessAsync(T message, IAgentContext agentContext, UnpackedMessageContext messageContext);
