public void BecauseOf()
{
_azureQueueService.PutMessage(_queueUri, "some data");
_azureQueueService.PutMessage(_queueUri, "some data");
_azureQueueService.ClearMessages(_queueUri);
_actualMessage = _azureQueueService.GetMessageWithDefaultTimeout(_queueUri);
}
public void AddQueueMessage(QueueMessage queueMessage)
{
CloudQueue queue = _queueClient.GetQueueReference(_queueName);
queue.CreateIfNotExists();
string messJSON = JsonConvert.SerializeObject(queueMessage);
queue.AddMessage(new CloudQueueMessage(messJSON));
}
private static Message ToMessage(QueueMessage message)
{
var m = new Message(message.ToJson().ToString());
if (message.Timeout > 0)
{
var to = message.Timeout / 1000;
m.Timeout += to;
m.ExpiresIn += to;
}
return m;
}
public void ArchiveQueueMessage(QueueMessage message, string status = "success")
{
CloudTableClient tableClient = _storageAccount.CreateCloudTableClient();
// Create the CloudTable object that represents the "people" table.
CloudTable table = tableClient.GetTableReference(_archiveTableName);
//save message to AZURE Table?
QueueMessageArchiveEntry entry = new QueueMessageArchiveEntry
{
Message = JsonConvert.SerializeObject(message),
Status = status
};
TableOperation insertOperation = TableOperation.Insert(entry);
table.Execute(insertOperation);
}
/// <summary>
/// Handle Messages
/// </summary>
/// <param name = "message"></param>
private void OnMessageReceive(QueueMessage message)
{
string action = message.MessageData["action"] as string;
switch (action.ToLower())
{
// Message sent, when a Theme is changing
case "themechanged":
{
BackColor = themeManager.CurrentTheme.BackColor;
break;
}
}
}
//public Boolean AddMessage(String databaseName, String filePath, String fileName)
//{
// //byte[] file = VanLeeuwen.Framework.IO.ByteArray.GetByteArrayFromString(xmlMessage);
// return this.AddMessage(databaseName, filePath, fileName);
//}
public Boolean AddMessage(String databaseName, String filePath, String fileName)
{
// Move to Queuefolder
VanLeeuwen.Framework.IO.File.WaitForRelease(filePath, 10);
VanLeeuwen.Framework.IO.File.MoveAndOverwrite(filePath, Path.Combine(Parameters_DataTransfer.QueueFolder, fileName));
// Add Message to Queue
QueueMessage message = new QueueMessage();
message.DatabaseName = databaseName;
message.FilePath = Path.Combine(Parameters_DataTransfer.QueueFolder, fileName);
message.FileName = fileName;
message.NumberOfTries = -1;
return this.AddMessage(message);
}
static void MessageReceived(QueueMessage<string> message)
{
Console.WriteLine("Message Received: " + message.Payload + " - Schedule: " + message.Schedule + " - Interval: " + message.Interval);
if (message.Interval != null)
{
queue.PushMessage(new QueueMessage<string>()
{
Payload = message.Payload,
Schedule = message.Schedule.Value.AddSeconds(Convert.ToDouble(message.Interval)),
Interval = message.Interval
});
}
queue.DeleteMessage(message);
}
public Boolean AddMessage(QueueMessage queueMessage)
{
try
{
queueMessage.NumberOfTries++;
mq.Send(queueMessage);
Trace.WriteLine(String.Format("Added message to Queue. NumberOfTries: {0}", queueMessage.NumberOfTries), "AddMessage");
}
catch (Exception ex)
{
return false;
}
return true;
}
public Task<IQueueMessage> Peek()
{
return Task.Factory.StartNew(() =>
{
var queueMessage = default(IQueueMessage);
var messageQueue = FindOrCreateQueue(QueuePath);
try
{
var message = messageQueue.Peek(new TimeSpan(0, 0, 1));
message.Formatter = message.Formatter = new XmlMessageFormatter(new String[] { "System.String,mscorlib" });
queueMessage = new QueueMessage
{
Id = message.Id,
Data = message.Body as string
};
}
catch { }
return queueMessage;
});
}
/// <summary>
/// Handle Messages
/// </summary>
/// <param name = "message"></param>
private void OnMessageReceive(QueueMessage message)
{
string action = message.MessageData["action"] as string;
switch (action.ToLower())
{
// Message sent, when a Theme is changing
case "themechanged":
{
BackColor = themeManager.CurrentTheme.BackColor;
CaptionColorOne = themeManager.CurrentTheme.PanelHeadingBackColor;
CaptionFont = themeManager.CurrentTheme.PanelHeadingFont;
CaptionTextColor = themeManager.CurrentTheme.LabelForeColor;
DirectionCtrlColor = themeManager.CurrentTheme.PanelHeadingDirectionCtrlColor;
break;
}
case "languagechanged":
Refresh();
break;
}
}
public VoidResponseDto PublishMessage(TestObjectDto testObjectDto)
{
var queueMessage = new QueueMessage<OrderPrintingMessage>
{
MessageContent = new OrderPrintingMessage
{
OrderDetail = testObjectDto.Message,
}
};
var response = new VoidResponseDto();
try
{
OrderPrintingMessageBusClient.Publish(queueMessage);
response.IsSuccessful = true;
}
catch (Exception e)
{
response.IsSuccessful = false;
}
return response;
}
public void SendMessage_WhenQueueMessageIsNull_ThrowsArgumentNullException(string queueName)
{
QueueMessage queueMessage = null;
Assert.Throws <ArgumentNullException>(() => queueHandler.SendMessage(queueName, queueMessage));
}
public MessageCollection(QueueMessage message)
{
Messages.Add(message);
}
public static void Run([QueueTrigger(QueueName)] QueueMessage message, string id)
{
TaskSource.TrySetResult(id);
}
public static void ProcessQueueMessage([ServiceBusTrigger("signin")] QueueMessage message, TextWriter log)
{
HandleMessage(message);
}
public DomainEventStreamProcessContext(DomainEventConsumer eventConsumer, DomainEventStreamMessage domainEventStreamMessage, QueueMessage queueMessage, IMessageContext messageContext)
: base(queueMessage, messageContext)
{
_eventConsumer = eventConsumer;
_domainEventStreamMessage = domainEventStreamMessage;
}
private static void processMsg(QueueMessage msg)
{
Console.WriteLine("Processing: {0}", msg.Body);
Thread.Sleep(actualMsgProcTimeMS);
}
public void BecauseOf()
{
_azureQueueService.PutMessage(_queueUri, "original data");
_initialMessage = _azureQueueService.GetMessageWithDefaultTimeout(_queueUri);
_newContent = "new content";
_updateMessageResult = _azureQueueService.UpdateMessage(_queueUri, _initialMessage, _newContent, TimeSpan.FromSeconds(0));
_actualMessage = _azureQueueService.GetMessageWithDefaultTimeout(_queueUri);
}
/// <summary>
/// Selects the peek message response.
/// </summary>
/// <param name="protocolMessage">The protocol message.</param>
/// <returns>The parsed message.</returns>
private CloudQueueMessage SelectPeekMessageResponse(QueueMessage protocolMessage)
{
CloudQueueMessage message = null;
if (this.EncodeMessage)
{
// if EncodeMessage is true, we assume the string returned from server is Base64 encoding of original message;
// if this is not true, exception will likely be thrown.
// it is user's responsibility to make sure EncodeMessage setting matches the queue that is being read.
message = new CloudQueueMessage(protocolMessage.Text, true);
}
else
{
message = new CloudQueueMessage(protocolMessage.Text);
}
message.Id = protocolMessage.Id;
message.InsertionTime = protocolMessage.InsertionTime;
message.ExpirationTime = protocolMessage.ExpirationTime;
message.DequeueCount = protocolMessage.DequeueCount;
// PopReceipt and TimeNextVisible are not returned during peek
return message;
}
/// <summary>
/// Selects the get message response.
/// </summary>
/// <param name="protocolMessage">The protocol message.</param>
/// <returns>The parsed message.</returns>
private CloudQueueMessage SelectGetMessageResponse(QueueMessage protocolMessage)
{
var message = this.SelectPeekMessageResponse(protocolMessage);
message.PopReceipt = protocolMessage.PopReceipt;
if (protocolMessage.TimeNextVisible.HasValue)
{
message.NextVisibleTime = protocolMessage.TimeNextVisible.Value;
}
return message;
}
public bool Remove(QueueMessage message)
{
NumberOfRequestsMade++;
return _provider.RemoveMessage(_queueName, message.ID);
}
public UpdateServicePayload(QueueMessage message)
{
this._message = message;
}
public AudioEncoder()
{
log = ServiceScope.Get<ILogger>();
queue = ServiceScope.Get<IMessageBroker>().GetOrCreate("encoding");
msg = new QueueMessage();
}
// [END pullonce]
/// <summary>
/// Publish a message asking for a book to be processed.
/// </summary>
// [START enqueuebook]
public void EnqueueBook(long bookId)
{
var message = new QueueMessage() { BookId = bookId };
var json = JsonConvert.SerializeObject(message);
_pub.Publish(_topicName, new[] { new PubsubMessage()
{
Data = Google.Protobuf.ByteString.CopyFromUtf8(json)
} });
}
public void BecauseOf()
{
_azureQueueService.PutMessage(_queueUri, "some data");
var gotMessage = _azureQueueService.GetMessageWithVisibilityTimeout(_queueUri, TimeSpan.FromSeconds(1));
Thread.Sleep(2000);
_azureQueueService.DeleteMessage(_queueUri, gotMessage);
_actualMessage = _azureQueueService.GetMessageWithDefaultTimeout(_queueUri);
}
public static void Run([QueueTrigger(QueueName)] QueueMessage message, DateTimeOffset nextVisibleTime)
{
TaskSource.TrySetResult(nextVisibleTime);
}
public void BecauseOf()
{
var putMessageOptions = new PutMessageOptions {TimeToLive = TimeSpan.FromSeconds(1)};
_azureQueueService.PutMessage(_queueUri, _expectedMessage, putMessageOptions);
Thread.Sleep(2000);
_actualMessage = _azureQueueService.GetMessageWithDefaultTimeout(_queueUri);
}
public override Task DeadLetterAsync(QueueMessage message, string reason, string errorDescription, CancellationToken cancellationToken = default)
{
throw new NotSupportedException();
}
public void Publish(QueueMessage<BillPrintingMessage> queueMessage)
{
throw new NotImplementedException();
}
public QueueMessage Get(QueueMessage message)
{
return(new QueueMessage());
}
private async Task HandleQueueMessageAsync(QueueMessage obj)
{
await _QueueHubContext.Clients.All
.SendAsync("ReceiveQueueMessage", $"{DateTime.Now.ToString("HH:mm:ss.ffff")} - {obj.Text}");
}
public async Task DeadLetterAsync(QueueMessage message, string reason, string errorDescription, CancellationToken cancellationToken = default)
{
await _parentReceiver.DeadLetterAsync(message, reason, errorDescription, cancellationToken);
await DeleteBlobAsync(message);
}
public abstract void OnMessage(QueueMessage message);
public static void Run(
[QueueTrigger("sample-queue")] QueueMessage message,
ILogger logger)
{
logger.LogInformation("Received message from sample-queue, content={content}", message.Body.ToString());
}
public static void Run([QueueTrigger(QueueName)] QueueMessage message, long dequeueCount)
{
TaskSource.TrySetResult(dequeueCount);
}
private void ReturnMessageForNextPop(QueueMessage message)
{
Try.Safely(() =>
this.client.UpdateMessage(message?.MessageId, message?.PopReceipt, (string)null, TimeSpan.Zero));
}
public static void Run([QueueTrigger(QueueName)] QueueMessage message, DateTimeOffset insertionTime)
{
TaskSource.TrySetResult(insertionTime);
}
public static void setQueue(string p1, string p2, string p3, string p4)
{
QueueMessage message = new QueueMessage();
message.playerOneName = p1;
message.playerTwoName = p2;
message.playerThreeName = p3;
message.playerFourName = p4;
// Set info to display usernames in MultiplayerLobbyScript
playerQueue[0] = p1;
playerQueue[1] = p2;
playerQueue[2] = p3;
playerQueue[3] = p4;
Debug.Log("Does Player 1 == my username? " + p1 + " == " + myUsername + "?");
Debug.Log("Does Player 1 == my username? " + p2 + " == " + myUsername + "?");
if (p1 == myUsername)
myPlayerNumber = "1";
else if (p2 == myUsername)
myPlayerNumber = "2";
else if (p3 == myUsername)
myPlayerNumber = "3";
else if (p4 == myUsername)
myPlayerNumber = "4";
messageQueue.Enqueue(message);
}
public static void Run([QueueTrigger(QueueName)] QueueMessage message, string popReceipt)
{
TaskSource.TrySetResult(popReceipt);
}
public void Schedule(string message)
{
var queueMessage = new QueueMessage("web", message);
queueClient.SendAsync(queueMessage);
}
public void Push(QueueMessage message)
{
}
public ConsumingMessage(QueueMessage message, ProcessQueue processQueue)
{
Message = message;
ProcessQueue = processQueue;
}
public async Task BadQueueMessageE2ETests()
{
// This test ensures that the host does not crash on a bad message (it previously did)
// Insert a bad message into a queue that should:
// - trigger BadMessage_CloudQueueMessage, which will put it into a second queue that will
// - trigger BadMessage_String, which should fail
// - BadMessage_String should fail repeatedly until it is moved to the poison queue
// The test will watch that poison queue to know when to complete
// Reinitialize the name resolver to avoid conflicts
_resolver = new RandomNameResolver();
IHost host = new HostBuilder()
.ConfigureDefaultTestHost <AzureStorageEndToEndTests>(b =>
{
b.AddAzureStorageBlobs().AddAzureStorageQueues();
})
.ConfigureServices(services =>
{
// use a custom processor so we can grab the Id and PopReceipt
services.AddSingleton <IQueueProcessorFactory>(new TestQueueProcessorFactory());
services.AddSingleton <INameResolver>(_resolver);
})
.Build();
TestLoggerProvider loggerProvider = host.GetTestLoggerProvider();
// The jobs host is started
host.Start();
// Construct a bad message:
// - use a GUID as the content, which is not a valid base64 string
// - pass 'true', to indicate that it is a base64 string
string messageContent = Guid.NewGuid().ToString();
// var message = new CloudQueueMessage(messageContent, true); // TODO (kasobol-msft) check this base64 thing
var queue = _queueServiceClient.GetQueueClient(_resolver.ResolveInString(BadMessageQueue1));
await queue.CreateIfNotExistsAsync();
await queue.ClearMessagesAsync();
// the poison queue will end up off of the second queue
var poisonQueue = _queueServiceClient.GetQueueClient(_resolver.ResolveInString(BadMessageQueue2) + "-poison");
await poisonQueue.DeleteIfExistsAsync();
await queue.SendMessageAsync(messageContent);
QueueMessage poisonMessage = null;
await TestHelpers.Await(async() =>
{
bool done = false;
if (await poisonQueue.ExistsAsync())
{
poisonMessage = (await poisonQueue.ReceiveMessagesAsync(1)).Value.FirstOrDefault();
done = poisonMessage != null;
if (done)
{
// Sleep briefly, then make sure the other message has been deleted.
// If so, trying to delete it again will throw an error.
Thread.Sleep(1000);
// The message is in the second queue
var queue2 = _queueServiceClient.GetQueueClient(_resolver.ResolveInString(BadMessageQueue2));
RequestFailedException ex = Assert.ThrowsAsync <RequestFailedException>(
() => queue2.DeleteMessageAsync(_lastMessageId, _lastMessagePopReceipt));
Assert.AreEqual("MessageNotFound", ex.ErrorCode);
}
}
var logs = loggerProvider.GetAllLogMessages();
return(done);
});
await host.StopAsync();
// find the raw string to compare it to the original
Assert.NotNull(poisonMessage);
Assert.AreEqual(messageContent, poisonMessage.MessageText);
// Make sure the functions were called correctly
Assert.AreEqual(1, _badMessage1Calls);
Assert.AreEqual(0, _badMessage2Calls);
// Validate Logger
var loggerErrors = loggerProvider.GetAllLogMessages().Where(l => l.Level == Microsoft.Extensions.Logging.LogLevel.Error);
Assert.True(loggerErrors.All(t => t.Exception.InnerException.InnerException is FormatException));
}
public void OnMessageHandled(QueueMessage queueMessage)
{
MessageHandledAction(queueMessage);
}
public Task KeepAliveAsync(QueueMessage message, TimeSpan?timeToLive = null, CancellationToken cancellationToken = default) => _parentReceiver.KeepAliveAsync(message, timeToLive, cancellationToken);
/// <summary>
/// Push message default priority (normal)
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public async Task PushAsync(QueueMessage <T> message)
{
await PushAsync(message, MessagePriority.Normal);
}
public QMsgSample()
{
var y = new QueueMessage()
{
Header = new Header(),
Body = new Body()
};
y.Operation = new Operation()
{
Name = "Dell.B2BOnlineTools.OfferDirector.Batch.SmartPriceCaching",
Type = Constants.QMsg.Operation.Type.Batch,
Services = new List <Service>()
};
y.Operation.Services.Add(new Service()
{
Index = 0,
Name = "GetConfig",
Type = Constants.QMsg.Service.Type.URL,
Provider = new Url()
{
Endpoint = "https://dma-g4.cfapps.pcf1.vc1.pcf.dell.com/api/dma/{0}/{1}/{2}/{3}/config/smartprice",
},
Parameters = new List <Parameter>()
});
y.Operation.Services[0].Parameters.Add(new Parameter()
{
Index = 0,
Name = "customersetId",
Type = Constants.QMsg.Parameter.Type.Url,
DefaultValue = "g_8"
});
y.Operation.Services[0].Parameters.Add(new Parameter()
{
Index = 1,
Name = "catalogId",
DataType = typeof(int).Name,
Type = Constants.QMsg.Parameter.Type.Url,
DefaultValue = 8
});
y.Operation.Services[0].Parameters.Add(new Parameter()
{
Index = 2,
Name = "orderCode",
Type = Constants.QMsg.Parameter.Type.Url
});
y.Operation.Services[0].Parameters.Add(new Parameter()
{
Index = 3,
Name = "languageId",
DataType = typeof(int).Name,
Type = Constants.QMsg.Parameter.Type.Url
});
y.Header.Channel = new Channel()
{
Name = "channelName",
Type = Constants.QMsg.Channel.Type.RabbitMQ
};
y.Header.Destination = new Destination
{
Name = "destName",
Type = new string[] { "ado", "WebApi" },
Services = new List <Service>()
};
y.Header.Destination.Services.Add(new Service()
{
Index = 0,
Type = Constants.QMsg.Service.Type.ADO,
Name = "SavePayload",
Provider = new Ado
{
Type = Constants.QMsg.Ado.Type.MsSql,
CommandType = Constants.QMsg.Ado.CommandType.StoredProcedure,
CommandText = "Abcd",
ConnectionString = "",
},
});
y.Header.Source = new Source {
Name = "SourceAppName"
};
y.Body.Items = new Items()
{
Arguments = new System.Collections.Generic.List <ArgInfo>(),
Values = new System.Collections.Generic.List <object[]>()
};
y.Body.Items.Arguments.Add(new ArgInfo()
{
Index = 0,
Name = "customersetId",
});
y.Body.Items.Arguments.Add(new ArgInfo()
{
Index = 1,
Name = "catalogId",
DataType = typeof(int).Name
});
y.Body.Items.Arguments.Add(new ArgInfo()
{
Index = 2,
Name = "orderCode",
});
y.Body.Items.Arguments.Add(new ArgInfo()
{
Index = 3,
Name = "languageId",
DataType = typeof(int).Name
});
y.Body.Items.Values.Add(new object[] { "g_8", 8, "CUP5810XLW7PM", 5 });
y.Body.Items.Values.Add(new object[] { "g_8", 8, "DST_Latitude_100_Automation", 1 });
Instance = y;
}
public void Publish(QueueMessage<OrderPrintingMessage> queueMessage)
{
_messageBus.PublishToExchangeWithProperties(queueMessage,
SetTransportProperties, MessageBusRoutingKeys.OrderSubmitted);
}
protected abstract Task ProcessMessage(QueueMessage <TBody> message);
private void SetTransportProperties(QueueMessage<OrderPrintingMessage> queueMessage)
{
// Delivery Mode 2 is for a persistent message i.e. persist to disk
queueMessage.TransportProperties.DeliveryMode = 2;
}
private async Task <PushResult> ProcessMessage(QueueMessage message, QueueClient receiver)
{
//if we need acknowledge from receiver, it has a deadline.
DateTime?deadline = null;
if (_queue.Options.Acknowledge != QueueAckDecision.None)
{
deadline = DateTime.UtcNow.Add(_queue.Options.AcknowledgeTimeout);
}
//return if client unsubsribes while waiting ack of previous message
if (!_queue.ClientsClone.Contains(receiver))
{
_queue.AddMessage(message, false);
return(PushResult.NoConsumers);
}
if (message.CurrentDeliveryReceivers.Count > 0)
{
message.CurrentDeliveryReceivers.Clear();
}
message.Decision = await _queue.DeliveryHandler.BeginSend(_queue, message);
if (!await _queue.ApplyDecision(message.Decision, message))
{
return(PushResult.Success);
}
//create prepared message data
byte[] messageData = HmqWriter.Create(message.Message);
//call before send and check decision
message.Decision = await _queue.DeliveryHandler.CanConsumerReceive(_queue, message, receiver.Client);
if (!await _queue.ApplyDecision(message.Decision, message))
{
return(PushResult.Success);
}
//create delivery object
MessageDelivery delivery = new MessageDelivery(message, receiver, deadline);
//send the message
bool sent = await receiver.Client.SendAsync(messageData);
if (sent)
{
if (_queue.Options.Acknowledge != QueueAckDecision.None)
{
receiver.CurrentlyProcessing = message;
receiver.ProcessDeadline = deadline ?? DateTime.UtcNow;
}
message.CurrentDeliveryReceivers.Add(receiver);
//adds the delivery to time keeper to check timing up
_queue.TimeKeeper.AddAcknowledgeCheck(delivery);
//mark message is sent
delivery.MarkAsSent();
_queue.Info.AddMessageSend();
//do after send operations for per message
_queue.Info.AddDelivery();
message.Decision = await _queue.DeliveryHandler.ConsumerReceived(_queue, delivery, receiver.Client);
}
else
{
message.Decision = await _queue.DeliveryHandler.ConsumerReceiveFailed(_queue, delivery, receiver.Client);
}
if (!await _queue.ApplyDecision(message.Decision, message))
{
return(PushResult.Success);
}
message.Decision = await _queue.DeliveryHandler.EndSend(_queue, message);
await _queue.ApplyDecision(message.Decision, message);
if (message.Decision.Allow && message.Decision.PutBack == PutBackDecision.No)
{
_queue.Info.AddMessageRemove();
_ = _queue.DeliveryHandler.MessageDequeued(_queue, message);
}
return(PushResult.Success);
}
public Task <PushResult> Push(QueueMessage message)
{
return(Task.FromResult(PushResult.Success));
}
public void BecauseOf()
{
_azureQueueService.PutMessage(_queueUri, _expectedMessage1);
_azureQueueService.PutMessage(_queueUri, _expectedMessage2);
_actualMessage1 = _azureQueueService.GetMessageWithDefaultTimeout(_queueUri);
_actualMessage2 = _azureQueueService.GetMessageWithDefaultTimeout(_queueUri);
}
public async Task <PullResult> Pull(ChannelClient client, TmqMessage request)
{
QueueMessage message = _queue.FindNextMessage();
if (message == null)
{
await client.Client.SendAsync(MessageBuilder.ResponseStatus(request, KnownContentTypes.NotFound));
return(PullResult.Empty);
}
ProcessingMessage = message;
message.Decision = await _queue.DeliveryHandler.BeginSend(_queue, message);
if (!await _queue.ApplyDecision(message.Decision, message))
{
return(PullResult.Success);
}
//call before send and check decision
message.Decision = await _queue.DeliveryHandler.CanConsumerReceive(_queue, message, client.Client);
if (!await _queue.ApplyDecision(message.Decision, message))
{
return(PullResult.Success);
}
//create delivery object
MessageDelivery delivery = new MessageDelivery(message, client);
//change to response message, send, change back to channel message
message.Message.SetMessageId(request.MessageId);
bool sent = client.Client.Send(message.Message);
if (sent)
{
delivery.MarkAsSent();
//do after send operations for per message
_queue.Info.AddDelivery();
message.Decision = await _queue.DeliveryHandler.ConsumerReceived(_queue, delivery, client.Client);
//after all sending operations completed, calls implementation send completed method and complete the operation
_queue.Info.AddMessageSend();
if (!await _queue.ApplyDecision(message.Decision, message))
{
return(PullResult.Success);
}
}
else
{
message.Decision = await _queue.DeliveryHandler.ConsumerReceiveFailed(_queue, delivery, client.Client);
if (!await _queue.ApplyDecision(message.Decision, message))
{
return(PullResult.Success);
}
}
message.Decision = await _queue.DeliveryHandler.EndSend(_queue, message);
await _queue.ApplyDecision(message.Decision, message);
return(PullResult.Success);
}
public void BecauseOf()
{
var putMessageOptions = new PutMessageOptions {VisibilityTimeout = TimeSpan.FromSeconds(2)};
_azureQueueService.PutMessage(_queueUri, _expectedMessage, putMessageOptions);
_actualMessage = _azureQueueService.GetMessageWithDefaultTimeout(_queueUri);
_messageFoundAfterFirstCall = _actualMessage == null;
Thread.Sleep(4000);
_actualMessage = _azureQueueService.GetMessageWithDefaultTimeout(_queueUri);
}
public async Task BadQueueMessageE2ETests()
{
// This test ensures that the host does not crash on a bad message (it previously did)
// Insert a bad message into a queue that should:
// - trigger BadMessage_String, which should fail
// - BadMessage_String should be transfered to poison queue.
// The test will watch that poison queue to know when to complete
// Reinitialize the name resolver to avoid conflicts
_resolver = new RandomNameResolver();
IHost host = new HostBuilder()
.ConfigureDefaultTestHost <AzureStorageEndToEndTests>(b =>
{
b.AddAzureStorageBlobs().AddAzureStorageQueues();
})
.ConfigureServices(services =>
{
// use a custom processor so we can grab the Id and PopReceipt
services.AddSingleton <IQueueProcessorFactory>(new TestQueueProcessorFactory());
services.AddSingleton <INameResolver>(_resolver);
})
.Build();
TestLoggerProvider loggerProvider = host.GetTestLoggerProvider();
// The jobs host is started
host.Start();
// Construct a bad message:
// - use a GUID as the content, which is not a valid base64 string
// - pass 'true', to indicate that it is a base64 string
string messageContent = Guid.NewGuid().ToString();
var queue = _queueServiceClientWithoutEncoding.GetQueueClient(_resolver.ResolveInString(BadMessageQueue));
await queue.CreateIfNotExistsAsync();
await queue.ClearMessagesAsync();
var poisonQueue = _queueServiceClientWithoutEncoding.GetQueueClient(_resolver.ResolveInString(BadMessageQueue) + "-poison");
await poisonQueue.DeleteIfExistsAsync();
await queue.SendMessageAsync(messageContent);
QueueMessage poisonMessage = null;
await TestHelpers.Await(async() =>
{
bool done = false;
if (await poisonQueue.ExistsAsync())
{
poisonMessage = await poisonQueue.ReceiveMessageAsync();
done = poisonMessage != null;
}
var logs = loggerProvider.GetAllLogMessages();
return(done);
});
await host.StopAsync();
// find the raw string to compare it to the original
Assert.NotNull(poisonMessage);
Assert.AreEqual(messageContent, poisonMessage.MessageText);
// Make sure the functions were called correctly
Assert.AreEqual(0, _badMessageCalls);
// Validate Logger
var loggerErrors = loggerProvider.GetAllLogMessages().Where(l => l.Level == Microsoft.Extensions.Logging.LogLevel.Error);
Assert.True(loggerErrors.All(t => t.Exception.InnerException.InnerException is FormatException));
}
public void BecauseOf()
{
_azureQueueService.PutMessage(_queueUri, _expectedMessage);
var initialMessage = _azureQueueService.GetMessageWithVisibilityTimeout(_queueUri, TimeSpan. FromSeconds (100));
_azureQueueService.UpdateMessage(_queueUri, initialMessage, _expectedMessage, TimeSpan.FromSeconds(2));
_isNotFoundDuringTimeoutInterval = _azureQueueService.GetMessageWithDefaultTimeout(_queueUri);
Thread.Sleep(4000);
_isFoundAfterTimeoutInterval = _azureQueueService.GetMessageWithDefaultTimeout(_queueUri);
}
public Task ConfirmMessageAsync(QueueMessage message, CancellationToken cancellationToken)
{
return(Task.FromResult(true));
}
/// <summary>
/// Handle Messages
/// </summary>
/// <param name = "message"></param>
private void OnMessageReceive(QueueMessage message)
{
string action = message.MessageData["action"] as string;
switch (action.ToLower())
{
// Message sent, when a Theme is changing
case "themechanged":
{
Font = themeManager.CurrentTheme.LabelFont;
break;
}
case "languagechanged":
Text = MPTWinControlsCommon.Localise(_localisationContext, _localisation);
Refresh();
break;
}
}
public Task DeadLetterAsync(QueueMessage message, string reason, string errorDescription, CancellationToken cancellationToken)
{
return(Task.FromResult(true));
}
