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)); }