public T Deserialize <T>(Amazon.SQS.Model.Message busMessage) where T : Message { var busBodyMessage = JsonConvert.DeserializeObject <BusBodyMessage>(busMessage.Body); var message = JsonConvert.DeserializeObject <T>(busBodyMessage.Message); return(message); }
private Message ToStandardMessage(Amazon.SQS.Model.Message sqsMessage) { if (sqsMessage == null) { throw new ArgumentNullException(nameof(sqsMessage)); } var message = new Message { Content = sqsMessage.Body }; foreach (var attributeKey in sqsMessage.MessageAttributes.Keys) { var attributeValue = sqsMessage.MessageAttributes[attributeKey].StringValue; if (attributeKey == PlatformAttributes.Id) { message.Id = attributeValue; } else { message.Attributes[attributeKey] = attributeValue; } } return(message); }
public void When_posting_a_message_via_the_messaging_gateway() { _messageProducer.Send(_message); _listenedMessage = _queueListener.Listen(); //should_send_the_message_to_aws_sqs Assert.NotNull(_listenedMessage.Body); }
protected HeaderResult <string> ReadReceiptHandle(Amazon.SQS.Model.Message sqsMessage) { if (sqsMessage.ReceiptHandle != null) { return(new HeaderResult <string>(sqsMessage.ReceiptHandle, true)); } return(new HeaderResult <string>(string.Empty, true)); }
public void Convert_throws_PossiblyPoisonMessageException_if_cant_deserialize() { var queue = new MarketDataRequestQueue(); var message = new Amazon.SQS.Model.Message { Body = "some garbage", }; Assert.Throws<PossiblyPoisonMessageException>(() => queue.Convert(message)); }
private static bool MessageIsExpiredUsingNativeSqsSentTimestamp(Message message, TimeSpan timeToBeReceived) { if (message.Attributes.TryGetValue("SentTimestamp", out var sentTimeStampString) == false) { return(false); } var sentTime = GetTimeFromUnixTimestamp(sentTimeStampString); return(RebusTime.Now.UtcDateTime - sentTime > timeToBeReceived); }
public static bool MessageIsExpired(this TransportMessage message, Message sqsMessage) { if (message.Headers.TryGetValue(Headers.TimeToBeReceived, out var value) == false) { return(false); } var timeToBeReceived = TimeSpan.Parse(value, CultureInfo.InvariantCulture); return(MessageIsExpiredUsingRebusSentTime(message, timeToBeReceived) || MessageIsExpiredUsingNativeSqsSentTimestamp(sqsMessage, timeToBeReceived)); }
/// <summary> /// This class encapsulates a messages context as it passes through a middleware pipeline. /// </summary> /// <param name="message">The JustSaying message that was deserialized from SQS.</param> /// <param name="messageType">The type of the JustSaying message contained in <see cref="Message"/>.</param> /// <param name="queueName">The queue from which this message was received.</param> /// <param name="visibilityUpdater">The <see cref="IMessageVisibilityUpdater"/> to use to update message visibilities on failure.</param> /// <param name="messageDeleter">The <see cref="IMessageDeleter"/> to use to remove a message from the queue on success.</param> public HandleMessageContext(string queueName, Amazon.SQS.Model.Message rawMessage, Message message, Type messageType, IMessageVisibilityUpdater visibilityUpdater, IMessageDeleter messageDeleter, Uri queueUri, MessageAttributes messageAttributes) { Message = message; MessageType = messageType; QueueName = queueName; VisibilityUpdater = visibilityUpdater; MessageDeleter = messageDeleter; QueueUri = queueUri; MessageAttributes = messageAttributes; RawMessage = rawMessage; }
/// <summary> /// GetNext: If no job available on queue return null /// </summary> /// <returns></returns> public IJobConsumerContract GetNext() { Amazon.SQS.Model.ReceiveMessageResponse receiveMsgResponse; Debug.WriteLine(String.Format("Register: Poll Queue {0} for response", jobQueueUrl), GetType().Name); receiveMsgResponse = Queue.ReceiveMessage(new Amazon.SQS.Model.ReceiveMessageRequest() .WithMaxNumberOfMessages(1) .WithWaitTimeSeconds(5) .WithQueueUrl(jobQueueUrl)); if (receiveMsgResponse.IsSetReceiveMessageResult() == false || receiveMsgResponse.ReceiveMessageResult.IsSetMessage() == false) { return(null); } // Response Message Should Have ResponseQueue & SNS Topic List <Amazon.SQS.Model.Message> msgResultMsg = receiveMsgResponse.ReceiveMessageResult.Message; if (msgResultMsg.Count != 1) { var exStr = String.Format("Protocol Error: Response should have 1 Message found: {0}", msgResultMsg.Count); Debug.WriteLine(exStr, GetType().Name); throw new Exception(exStr); } Amazon.SQS.Model.Message msg = msgResultMsg[0]; Turbine.Orchestrator.AWS.Data.Contract.Messages.SubmitJobMessage rsp = null; try { rsp = JsonConvert.DeserializeObject <Turbine.Orchestrator.AWS.Data.Contract.Messages.SubmitJobMessage>(msg.Body); } catch (Exception ex) { Debug.WriteLine(String.Format("Exception deserializing SubmitJobMessage: {0}", ex), GetType().Name); throw; } //Amazon.SQS.Model.DeleteMessageResponse delMsgRsp = Queue.DeleteMessage( var jobConsumer = new JobConsumer(rsp); jobConsumer.AddSetupCB(Queue.DeleteMessage, new Amazon.SQS.Model.DeleteMessageRequest() .WithReceiptHandle(msg.ReceiptHandle) .WithQueueUrl(jobQueueUrl), CheckDeleteMessageResponse); return(jobConsumer); }
private MessageBody ReadMessageBody(Amazon.SQS.Model.Message sqsMessage) { try { var jsonDocument = JsonDocument.Parse(sqsMessage.Body); if (jsonDocument.RootElement.TryGetProperty("Message", out var value)) { return(new MessageBody(value.GetString())); } } catch (Exception ex) { s_logger.LogWarning($"Failed to parse Sqs Message Body to valid Json Document, ex: {ex}"); } return(new MessageBody(string.Empty)); }
/// <summary>Creates the specified message.</summary> /// <param name="message">The message.</param> /// <returns></returns> public IAmazonMessageProcessor Create(Message message) { if (message.Body.StartsWith("{", false, CultureInfo.InvariantCulture)) { var messageJObject = JObject.Parse(message.Body); var isFromSnsTopic = messageJObject["Type"]?.Value <string>() == Amazon.SimpleNotificationService.Util.Message.MESSAGE_TYPE_NOTIFICATION; if (isFromSnsTopic) { return(new SnsTopicAmazonMessageProcessor(messageJObject, _amazonInternalSettings)); } else { return(new RebusMessageAmazonMessageProcessor(message, _amazonInternalSettings)); } } return(new RebusMessageAmazonMessageProcessor(message, _amazonInternalSettings)); }
private Dictionary <string, JsonElement> ReadMessageAttributes(Amazon.SQS.Model.Message sqsMessage) { var messageAttributes = new Dictionary <string, JsonElement>(); try { var jsonDocument = JsonDocument.Parse(sqsMessage.Body); if (jsonDocument.RootElement.TryGetProperty("MessageAttributes", out var attributes)) { messageAttributes = JsonSerializer.Deserialize <Dictionary <string, JsonElement> >( attributes.GetRawText(), JsonSerialisationOptions.Options); } } catch (Exception ex) { s_logger.LogWarning($"Failed while deserializing Sqs Message body, ex: {ex}"); } return(messageAttributes); }
public void DeserializeMessage() { var testMessage = new TestMessage(); testMessage.Name = "Test"; var testMessageJson = JsonConvert.SerializeObject(testMessage); BusBodyMessage busBodyMessage = new BusBodyMessage(); busBodyMessage.Message = testMessageJson; var busBodyJson = JsonConvert.SerializeObject(busBodyMessage); var message = new Amazon.SQS.Model.Message { Body = busBodyJson }; var sut = new MessageDeserializer(); var actual = sut.Deserialize <TestMessage>(message); actual.Name = "ExpectedMessage"; }
public async void ProcessNotification(object message) { try { Amazon.SQS.Model.Message msg = (Amazon.SQS.Model.Message)message; string queMessage = msg.Body; //LogInfo.Information("8 - bsubscription is {" + msg.MessageId + "} object"); SNSSubscription subscription = JsonConvert.DeserializeObject <SNSSubscription>(queMessage); //LogInfo.Information("8 - bsubscription is {" + subscription.MessageId + "} object"); NotificationMessage NotMessage = JsonConvert.DeserializeObject <NotificationMessage>(subscription.Message); //LogInfo.Information("9 - NotMessage is {" + NotMessage.Message +" "+ NotMessage.MessageType + "} object"); // SNSSubscription messageObject= new SNSSubscription { Message=me}; // NotificationMessage notification= JsonConvert.DeserializeObject<NotificationMessage>(messageObject.Message); if (NotMessage.MessageType == NotificationMsgType.Email.GetDescription()) { OutboundEmail _email = new OutboundEmail(); ConfigDataAccess _configAccess = new ConfigDataAccess(_iconfiguration); DatabaseResponse emailTemplate = await _configAccess.GetEmailNotificationTemplate(NotMessage.Message.messagetemplate.ToString()); EmailTemplate template = (EmailTemplate)emailTemplate.Results; var responses = await _email.SendEmail(NotMessage, _iconfiguration, template); foreach (Mandrill.Model.MandrillSendMessageResponse response in responses) { foreach (NotificationParams param in NotMessage.Message.parameters) { if (response.Email == param.emailaddress) { DatabaseResponse notificationLogResponse = await _configAccess.CreateEMailNotificationLog(new NotificationLog { Status = response.Status.ToString() == "Sent" ? 1 : 0, Email = response.Email, EmailTemplateID = template.EmailTemplateID, EmailBody = template.EmailBody, EmailSubject = template.EmailSubject, ScheduledOn = subscription.Timestamp, SendOn = DateTime.Now }); } } } } else if (NotMessage.MessageType == NotificationMsgType.SMS.GetDescription()) { OutboundSMS _SMS = new OutboundSMS(); TextMessage smsData = new TextMessage(); ConfigDataAccess _configAccess = new ConfigDataAccess(_iconfiguration); DatabaseResponse smsTemplate = await _configAccess.GetSMSNotificationTemplate(NotMessage.Message.messagetemplate.ToString()); SMSTemplates template = (SMSTemplates)smsTemplate.Results; foreach (var item in NotMessage.Message.parameters) { smsData.PhoneNumber = item.mobilenumber; smsData.SMSText = template.SMSTemplate.Replace("*|NAME|*", item.name) .Replace("*|PARAM1|*", item.param1) .Replace("*|PARAM2|*", item.param2) .Replace("*|PARAM3|*", item.param3) .Replace("*|PARAM4|*", item.param4) .Replace("*|PARAM5|*", item.param5) .Replace("*|PARAM6|*", item.param6) .Replace("*|PARAM7|*", item.param7) .Replace("*|PARAM8|*", item.param8) .Replace("*|PARAM9|*", item.param9) .Replace("*|PARAM10|*", item.param10); //LogInfo.Information("10 - SendSMS is { "+ smsData+ "}"); string response = await _SMS.SendSMSNotification(smsData, _iconfiguration); await _configAccess.CreateSMSNotificationLog(new SMSNotificationLog() { Email = NotMessage.Message.parameters.Select(x => x.emailaddress).FirstOrDefault(), Mobile = smsData.PhoneNumber, SMSTemplateID = template.SMSTemplateID, SMSText = smsData.SMSText, Status = response != "failure" ? 1 : 0, ScheduledOn = subscription.Timestamp, SendOn = DateTime.Now }); } //LogInfo.Information("10 - SendSMSLog is { " + NotMessage.Message.parameters.Select(x => x.emailaddress).FirstOrDefault() + " " + smsData.PhoneNumber + " "+ response + "}"); } } catch (Exception ex) { LogInfo.Error(new ExceptionHelper().GetLogString(ex, ErrorLevel.Critical)); } }
public void HandleError(Exception ex, Amazon.SQS.Model.Message message) { }
public MessageContext(SQSMessage message, Uri queueUri) { Message = message ?? throw new ArgumentNullException(nameof(message)); QueueUri = queueUri ?? throw new ArgumentNullException(nameof(queueUri)); }
private async Task CompleteMessageAsync(Amazon.SQS.Model.Message sqsMessage) { await sqsClient.DeleteMessageAsync(subscriberOptions.QueueUrl, sqsMessage.ReceiptHandle).ConfigureAwait(false); }
private async Task AbandonMessageAsync(Amazon.SQS.Model.Message sqsMessage) { await sqsClient.ChangeMessageVisibilityAsync(subscriberOptions.QueueUrl, sqsMessage.ReceiptHandle, 0).ConfigureAwait(false); }
public void PossiblyPoisonMessageException_contains_original_messageid() { var messageId = "baz bat"; var queue = new MarketDataRequestQueue(); var message = new Amazon.SQS.Model.Message { Body = "some garbage", MessageId = messageId, }; try { queue.Convert(message); } catch (PossiblyPoisonMessageException ppme) { Assert.That(ppme.MessageId, Is.EqualTo(messageId)); return; } Assert.Fail("Should not have gotten this far in the test!"); }
public Message CreateMessage(Amazon.SQS.Model.Message sqsMessage) { var topic = HeaderResult <string> .Empty(); var messageId = HeaderResult <Guid> .Empty(); var contentType = HeaderResult <string> .Empty(); var correlationId = HeaderResult <Guid> .Empty(); var handledCount = HeaderResult <int> .Empty(); var messageType = HeaderResult <MessageType> .Empty(); var timeStamp = HeaderResult <DateTime> .Empty(); var receiptHandle = HeaderResult <string> .Empty(); var replyTo = HeaderResult <string> .Empty(); Message message; try { _messageAttributes = ReadMessageAttributes(sqsMessage); topic = ReadTopic(); messageId = ReadMessageId(); contentType = ReadContentType(); correlationId = ReadCorrelationId(); handledCount = ReadHandledCount(); messageType = ReadMessageType(); timeStamp = ReadTimestamp(); replyTo = ReadReplyTo(); receiptHandle = ReadReceiptHandle(sqsMessage); var messageHeader = timeStamp.Success ? new MessageHeader(messageId.Result, topic.Result, messageType.Result, timeStamp.Result, handledCount.Result, 0) : new MessageHeader(messageId.Result, topic.Result, messageType.Result); if (correlationId.Success) { messageHeader.CorrelationId = correlationId.Result; } if (replyTo.Success) { messageHeader.ReplyTo = replyTo.Result; } if (contentType.Success) { messageHeader.ContentType = contentType.Result; } message = new Message(messageHeader, ReadMessageBody(sqsMessage)); //deserialize the bag var bag = ReadMessageBag(); foreach (var key in bag.Keys) { message.Header.Bag.Add(key, bag[key]); } if (receiptHandle.Success) { message.Header.Bag.Add("ReceiptHandle", ((Amazon.SQS.Model.Message)sqsMessage).ReceiptHandle); } } catch (Exception e) { s_logger.LogWarning(e, "Failed to create message from Aws Sqs message"); message = FailureMessage(topic, messageId); } return(message); }
public RebusMessageAmazonMessageProcessor(Message message, IAmazonInternalSettings amazonInternalSettings) { _amazonInternalSettings = amazonInternalSettings; _message = message; }