public async Task CanRoundtripInternalMessages_DataBusAttachment()
{
var message = new DataBusAttachment("bimmelim!!!");
Console.WriteLine("Roundtripping {0}", message.GetType());
var roundtrippedMessage = (DataBusAttachment) await Roundtrip(message);
Assert.That(roundtrippedMessage.Id, Is.EqualTo("bimmelim!!!"));
}
public async Task <DataBusAttachment> CreateAttachment(Stream source, Dictionary <string, string> optionalMetadata = null)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
var id = Guid.NewGuid().ToString();
await _dataBusStorage.Save(id, source, optionalMetadata);
var attachment = new DataBusAttachment(id);
return(attachment);
}
public async Task Handle(EstimationReady message)
{
_logger.LogInformation(
"Receiving case number {caseNumber} to notify ready estimation.",
message.CaseNumber);
var estimationReader = new StreamReader(await DataBusAttachment.OpenRead(message.EstimationId));
var client = _httpClientFactory.CreateClient("notifications");
var contentString = System.Text.Json.JsonSerializer.Serialize(new
{
message.CaseNumber,
Result = "Success",
Estimation = await estimationReader.ReadToEndAsync()
});
try
{
await client.PostAsync(
message.CallbackUri,
new StringContent(contentString, Encoding.UTF8, MediaTypeNames.Application.Json));
_logger.LogInformation(
"Case {caseNumber} notified successfully.",
message.CaseNumber);
await _bus.Send(new NotificationCompleted
{
CaseNumber = message.CaseNumber
});
}
catch (Exception e)
{
_logger.LogWarning(
"Case number {caseNumber} notification error. {notificationError}",
message.CaseNumber,
e.Message);
await _bus.Send(new UnableToNotify
{
CaseNumber = message.CaseNumber
});
}
}
public async Task Handle(TMessage message)
{
_logger.Information("Executing handlers for command {0} & {1}", message.RequestId, _consumer);
try
{
foreach (var attachment in message.Attachments)
{
attachment.FileStream = await DataBusAttachment.OpenRead(attachment.Id);
}
await _consumer.Handle(message);
}
catch (Exception e)
{
_logger.Information("Error executing handler for command {0}", e);
throw;
}
}
public async Task Handle(ImageReady message)
{
_logger.LogInformation(
"New request to process image for case number {caseNumber}. ImageId: {imageId}, ImageTicket {ticket}",
message.CaseNumber,
message.ImageId,
message.ImageTicket);
var client = _httpClientFactory.CreateClient("process");
var content = new MultipartFormDataContent
{
{ new StringContent(message.CaseNumber.ToString("D")), "CaseNumber" },
{ new StringContent(message.ImageId.ToString("G")), "ImageId" },
{ new StringContent($"{_servicesConfiguration.Api.BaseUrl}/ExternalImageProcess/{message.CaseNumber:D}/images/{message.ImageId:G}"), "CallbackUrl" },
{ new StreamContent(await DataBusAttachment.OpenRead(message.ImageTicket)), "image" }
};
try
{
var response = await client.PostAsync(
new Uri($"{_servicesConfiguration.ImageProcess.BaseUrl}/ImageProcess"),
content);
await ProcessResponse(message, response);
}
catch (Exception e)
{
_logger.LogWarning(
"Process error for image {imageId} for case number {caseNumber}. {imageProcessError}",
message.ImageId,
message.CaseNumber,
e.Message);
await _bus.Send(new UnableToProcessImage
{
CaseNumber = message.CaseNumber,
ImageId = message.ImageId,
Error = e.Message
});
}
}
public async Task Handle(string message)
{
using (var destination = new MemoryStream())
{
var attachment = new DataBusAttachment(message);
using (var source = await attachment.OpenRead())
{
await source.CopyToAsync(destination);
}
_receivedTextData.Add(Encoding.UTF8.GetString(destination.ToArray()));
var metadata = await attachment.GetMetadata();
_receivedMetadata.Add(metadata);
}
_gotMessage.Set();
}
