public async Task <MagnetMessage> GetNextAsync(string name, CancellationToken cancellationToken)
{
using IModel channel = GetChannel();
var completion = new TaskCompletionSource <MagnetMessage>();
cancellationToken.Register(() => completion.SetCanceled());
try
{
channel.BasicQos(0, 1, false);
var consumer = new EventingBasicConsumer(channel);
EventHandler <BasicDeliverEventArgs> eventHandler = null;
eventHandler =
delegate(object obj, BasicDeliverEventArgs ea)
{
MagnetMessage msg = GetMessageFromBody(ea.Body.ToArray());
completion.SetResult(msg);
consumer.Received -= eventHandler;
};
consumer.Received += eventHandler;
string consumerTag = channel.BasicConsume(name, true, consumer);
}
catch (Exception ex)
{
completion.SetException(ex);
}
return(await completion.Task);
}
private static MagnetMessage GetMessageFromBody(byte[] body)
{
var json = Encoding.UTF8.GetString(body);
MagnetMessage message = JsonConvert.DeserializeObject <MagnetMessage>(json);
return(message);
}
public WorkItemEventMessage FromMagetMessage(MagnetMessage magnetMessage)
{
WorkItemEventMessage msg = JsonConvert.DeserializeObject <WorkItemEventMessage>(
magnetMessage.GetPropertyValue("Json"));
return(msg);
}
public async Task <MagnetMessage> GetNextAsync(string name, CancellationToken cancellationToken)
{
var client = new SubscriptionClient(_options.ConnectionString, _options.Topic, name);
var completion = new TaskCompletionSource <MagnetMessage>();
cancellationToken.Register(() => completion.SetCanceled());
try
{
client.RegisterMessageHandler(async(message, token) =>
{
string json = Encoding.UTF8.GetString(message.Body);
MagnetMessage magnetMsg = JsonConvert.DeserializeObject <MagnetMessage>(json);
await client.CompleteAsync(message.SystemProperties.LockToken);
await client.CloseAsync();
completion.SetResult(magnetMsg);
},
new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 1, AutoComplete = false
});
}
catch (Exception ex)
{
completion.SetException(ex);
}
return(await completion.Task);
}
public async Task <string> PublishAsync(MagnetMessage message)
{
Message msg = CreateMessage(message);
await _topicClient.SendAsync(msg);
return(msg.MessageId);
}
public static T GetPropertyValue <T>(this MagnetMessage message, string name)
{
if (message.Properties != null && message.Properties.ContainsKey(name))
{
return((T)Convert
.ChangeType(message.Properties[name], typeof(T)));
}
return(default);
public async Task <IActionResult> Hook()
{
using var reader = new StreamReader(Request.Body);
string json = reader.ReadToEnd();
WorkItemEvent workItemEvent = _deserializer.Deserialize(json);
MagnetMessage message = BuildMessage(workItemEvent);
await _messageSink.ProcessMessageAsync(message);
return(Ok());
}
public Task <string> PublishAsync(MagnetMessage message)
{
using IModel channel = GetChannel();
var body = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message));
channel.BasicPublish(exchange: _options.ExchangeName,
routingKey: "",
basicProperties: null,
body: body);
return(Task.FromResult(message.Id.ToString("N")));
}
private static Message CreateMessage(MagnetMessage message)
{
var jsonMessage = JsonConvert.SerializeObject(message);
var body = Encoding.UTF8.GetBytes(jsonMessage);
var sbMessage = new Message
{
MessageId = message.Id.ToString("N"),
Body = body,
Label = message.Type
};
return(sbMessage);
}
public async Task AddAsync(MagnetMessage message, CancellationToken cancellationToken)
{
_logger.LogInformation("Add message to store {messageId}", message.Id);
try
{
MessageRecord record = _mapper.Map <MessageRecord>(message);
record.ReceivedLog = new List <MessageReceivedLog>();
await _dbContext.Messages.InsertOneAsync(record, options : null, cancellationToken);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error in Add");
throw;
}
}
public SmsMessage FromMagetMessage(MagnetMessage magnetMessage)
{
var sms = new SmsMessage
{
Id = magnetMessage.Id,
From = magnetMessage.From,
To = magnetMessage.To[0],
ReceivedAt = magnetMessage.ReceivedAt,
Body = magnetMessage.Body,
Properties = new Dictionary <string, string>(
magnetMessage.GetPropertiesFiltered("Html", "Subject"))
};
return(sms);
}
public async Task <MagnetMessage> GetNextAsync(
string clientName,
CancellationToken cancellationToken)
{
HttpResponseMessage result = await SendRequestAsync(
HttpMethod.Get,
$"stream/{clientName}",
cancellationToken);
result.EnsureSuccessStatusCode();
string json = await result.Content.ReadAsStringAsync();
MagnetMessage message = JsonConvert.DeserializeObject <MagnetMessage>(json);
return(message);
}
public EmailMessage FromMagetMessage(MagnetMessage magnetMessage)
{
var email = new EmailMessage
{
Id = magnetMessage.Id,
From = magnetMessage.From,
To = new List <string>(magnetMessage.To),
ReceivedAt = magnetMessage.ReceivedAt,
Text = magnetMessage.Body,
Html = magnetMessage.GetPropertyValue <string>("Html"),
Subject = magnetMessage.GetPropertyValue <string>("Subject"),
Properties = new Dictionary <string, string>(
magnetMessage.GetPropertiesFiltered("Html", "Subject"))
};
return(email);
}
public async Task <TMessage> WaitFor <TMessage>(
WaitFilter waitFilter = null,
WaitOptions options = null)
{
options = options ?? new WaitOptions();
var timeoutToken = new CancellationTokenSource(TimeSpan.FromSeconds(options.Timeout));
waitFilter = waitFilter ?? new WaitFilter();
var typeName = _magnetClient.MessageMapper.ResolveTypeName <TMessage>();
waitFilter.Predicates.Add((m) => m.Type == typeName);
var completion = new TaskCompletionSource <TMessage>();
timeoutToken.Token.Register(() => completion.TrySetCanceled());
try
{
while (!timeoutToken.Token.IsCancellationRequested)
{
MagnetMessage message = await _magnetClient.MessageStreamClient
.GetNextAsync(_queueName, timeoutToken.Token);
var match = MatchFilter(waitFilter, message);
await AddReceiveReceiptAsync(message, match, timeoutToken.Token);
if (match)
{
TMessage mapped = _magnetClient.MessageMapper.Map <TMessage>(message);
completion.SetResult(mapped);
break;
}
}
}
catch (Exception ex)
{
completion.SetException(ex);
}
finally
{
timeoutToken.Dispose();
}
return(await completion.Task);
}
private bool MatchFilter(WaitFilter filter, MagnetMessage message)
{
foreach (Predicate <MagnetMessage> predicate in filter.Predicates)
{
try
{
if (!predicate(message))
{
return(false);
}
}
catch
{
return(false);
}
}
return(true);
}
public void RegisterMessageHandler(
string name,
Func <MagnetMessage, CancellationToken, Task> handler)
{
var client = new SubscriptionClient(_options.ConnectionString, _options.Topic, name);
client.RegisterMessageHandler(async(message, token) =>
{
string json = Encoding.UTF8.GetString(message.Body);
MagnetMessage magnetMsg = JsonConvert.DeserializeObject <MagnetMessage>(json);
await handler(magnetMsg, token);
await client.CompleteAsync(message.SystemProperties.LockToken);
},
new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 1, AutoComplete = false
});
}
private async Task AddReceiveReceiptAsync(
MagnetMessage message,
bool match,
CancellationToken cancellationToken)
{
try
{
await _magnetClient.MessageStreamClient.AddReceivedReceiptAsync(new MessageReceivedReceipt
{
ClientName = _magnetClient.Options.ClientName,
IsMatch = match,
MessageId = message.Id,
ReceivedAt = DateTime.UtcNow
}, cancellationToken);
}
catch
{
//dont fail...
}
}
public void RegisterMessageHandler(
string name,
Func <MagnetMessage, CancellationToken, Task> handler)
{
_logger.LogInformation("RegisterMessageHandler: {name}", name);
IModel channel = GetChannel();
var consumer = new AsyncEventingBasicConsumer(channel);
consumer.Received += async(model, ea) =>
{
try
{
MagnetMessage msg = GetMessageFromBody(ea.Body.ToArray());
await handler(msg, default);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error on Received");
}
};
string consumerTag = channel.BasicConsume(name, true, consumer);
}
public async Task <IActionResult> GetNext(string clientName, CancellationToken cancellationToken)
{
MagnetMessage msg = await _messageBus.GetNextAsync(clientName, Request.HttpContext.RequestAborted);
return(Ok(msg));
}
public async Task <IActionResult> New([FromBody] MagnetMessage message)
{
await _messageSink.ProcessMessageAsync(message);
return(Ok());
}
public static string GetPropertyValue(this MagnetMessage message, string name)
{
return(message.GetPropertyValue <string>(name));
}
public TMessage Map <TMessage>(MagnetMessage message)
{
MessageTypeRegistration map = GetMap <TMessage>();
return(((IMessageMapper <TMessage>)map.Mapper).FromMagetMessage(message));
}
