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