public async Task <AckResult> HandleMessageTask(IHandledMessage message)
{
Interlocked.Increment(ref _count);
while (Block)
{
await Task.Delay(500);
}
return(AckResult.Ack);
}
public Task <AckResult> HandleMessageTask(IHandledMessage message)
{
Interlocked.Increment(ref _count);
while (!TryAssignMessage(message))
{
_messagePopped.WaitOne(TimeSpan.FromMilliseconds(500));
}
return(Task.FromResult(AckResult.Ack));
}
private bool TryAssignMessage(IHandledMessage message)
{
lock (_messagePopped)
{
if (_message != null)
{
return(false);
}
_message = message;
return(true);
}
}
private static (Guid messageGroupId, Guid messageId)? GetMessageGroupInfo(IHandledMessage message)
{
//todo: make string constants (after work on generic listener and URI delivery method)
object groupIdObj = null;
if ((message.Properties.Headers?.TryGetValue(HeaderConstants.MessageGroupId, out groupIdObj) ?? false) &&
(groupIdObj is string groupIdStr) &&
Guid.TryParse(groupIdStr, out var messageGroupId) &&
Guid.TryParse(message.Properties.MessageId, out var messageId))
{
return(messageGroupId, messageId);
}
return(null);
}
public Task <AckResult> HandleMessageTask(IHandledMessage message)
{
Interlocked.Increment(ref _received);
while (!Block.WaitOne(500))
{
}
Interlocked.Increment(ref _handled);
if (Guid.TryParse(message.Properties.MessageId, out var messageId) &&
message.Properties.Headers.TryGetValue("MessageGroupId", out var groupIdObj))
{
var groupId = new Guid((byte[])groupIdObj);
_messageGroupHandler.MessageHandled(groupId, messageId);
}
else
{
}
return(Task.FromResult(AckResult.Ack));
}
private static bool CheckRequest(IFeatureCollection x, IHandledMessage message, byte[] body)
{
x.Get <IHttpRequestFeature>().Headers[HeaderConstants.MessageId].ToString().Should().Be(message.Properties.MessageId);
((MemoryStream)x.Get <IHttpRequestFeature>().Body).ToArray().Should().BeEquivalentTo(body);
return(true);
}
public Task <AckResult> HandleMessageTask(IHandledMessage message)
{
return(_msgNThenHttpAdapter.HandleMessageTask(message));
}
public async Task <AckResult> HandleMessageTask(IHandledMessage message)
{
if (_cancellationToken.IsCancellationRequested)
{
return(AckResult.NackRequeue);
}
try
{
var bytes = message.Body;
//note: This may not be the correct way to implement the FeatureCollection. In most of the available samples,
//features are static and the HttpContext is customized so it can be manipulated directly within this method.
//For the time being, this approach is very easy and provides better decoupling. When things get more complicated
//we may revert to the other approach.
//Typical webserver is a lot more complicated because it needs to handle the http protocol.HttpProtocol.ProcessRequests
//and can handle multiple requests via the same connection. MsgNThen is entirely reliant on RabbitMQ client to handle all
//such issues.
//The Protocol can't directly access the HttpContext itself (which is really strange at first glance). Instead it implements
//"IFeature"s that the HttpContext uses to implement its properties.
var requestFeatures = new FeatureCollection();
var messageRequestFeature = new HttpRequestFeature
{
Path = $"/{message.RoutingKey}",
//fix: use MemoryStream.WriteAsync(ReadOnlyMemory<Byte>)
Body = new MemoryStream(bytes.ToArray()),
Method = "GET",
Headers = new HeaderDictionary(),
};
if (message.Properties.Headers != null)
{
foreach (var property in message.Properties.Headers)
{
messageRequestFeature.Headers[property.Key] = property.Value?.ToString();
}
}
var groupInfo = GetMessageGroupInfo(message);
messageRequestFeature.Headers[HeaderConstants.MessageId] = message.Properties.MessageId;
messageRequestFeature.Headers[HeaderConstants.AppId] = message.Properties.AppId;
messageRequestFeature.Headers[HeaderConstants.ReplyTo] = message.Properties.ReplyTo;
messageRequestFeature.Headers[HeaderConstants.CorrelationId] = message.Properties.CorrelationId;
//note: https://www.rabbitmq.com/validated-user-id.html
messageRequestFeature.Headers[HeaderConstants.UserId] = message.Properties.UserId;
messageRequestFeature.Headers.ContentLength = message.Body.Length;
messageRequestFeature.Headers[HeaderNames.ContentType] = message.Properties.ContentType;
var responseStream = new MemoryStream();
var responseBody = new StreamResponseBodyFeature(responseStream);
var httpResponseFeature = new HttpResponseFeature()
{
Body = responseStream
};
requestFeatures.Set <IHttpResponseBodyFeature>(responseBody);
requestFeatures.Set <IHttpRequestFeature>(messageRequestFeature);
requestFeatures.Set <IHttpResponseFeature>(httpResponseFeature);
var context = _application.CreateContext(requestFeatures);
await _application.ProcessRequestAsync(context);
if (groupInfo != null)
{
_messageGroupHandler.MessageHandled(groupInfo.Value.messageGroupId, groupInfo.Value.messageId);
}
if (responseStream.Length > 0)
{
if (groupInfo != null)
{
//when the application populated the response we could either
// - store this information so that the andThen processor can pick it up later or
// - stream this request as data to the ReplyTo address for the same reason.
//use Redis and S3 as result stores so that the final andThen can use the data collected from
//those requests.
}
else
{
//since this isn't an andThen request, we should send this to the ReplyTo address
//todo: XXXX implement result forwarding (using something like IAndThenMessageDeliverer)
}
//any/all of the above scenarios are handled by the following interface by using the
//replyHandler to interpret the response and the message.Properties.ReplyTo address.
}
return(AckResult.Ack);
}
catch (Exception e)
{
_logger.LogError(e, "HandleMessageTask Failed");
return(AckResult.NackQuit);
}
}
