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 async Task <PullResult> Pull(QueueClient client, HorseMessage request) { int index = 1; int count = FindCount(request); if (count < 1) { await client.Client.SendAsync(MessageBuilder.CreateNoContentPullResponse(request, HorseHeaders.UNACCEPTABLE)); return(PullResult.Unacceptable); } ClearDecision clear = FindClearDecision(request); bool sendInfo = FindInfoRequest(request); bool fifo = FindOrder(request); Tuple <QueueMessage, int, int> messageTuple = await DequeueMessage(fifo, sendInfo, count == index?clear : ClearDecision.None); //there is no pullable message if (messageTuple.Item1 == null) { await client.Client.SendAsync(MessageBuilder.CreateNoContentPullResponse(request, HorseHeaders.EMPTY)); return(PullResult.Empty); } List <KeyValuePair <string, string> > headers = new List <KeyValuePair <string, string> >(); KeyValuePair <string, string> requestId = new KeyValuePair <string, string>(HorseHeaders.REQUEST_ID, request.MessageId); KeyValuePair <string, string> countHeader = new KeyValuePair <string, string>(HorseHeaders.COUNT, count.ToString()); while (index <= count) { QueueMessage message = messageTuple.Item1; if (message == null) { break; } try { headers.Add(requestId); headers.Add(countHeader); headers.Add(new KeyValuePair <string, string>(HorseHeaders.INDEX, index.ToString())); if (sendInfo) { headers.Add(new KeyValuePair <string, string>(HorseHeaders.PRIORITY_MESSAGES, messageTuple.Item2.ToString())); headers.Add(new KeyValuePair <string, string>(HorseHeaders.MESSAGES, messageTuple.Item3.ToString())); } bool processed = await ProcessPull(client, request, message, headers); if (!processed) { break; } index++; messageTuple = await DequeueMessage(fifo, sendInfo, count == index?clear : ClearDecision.None); headers.Clear(); } catch (Exception ex) { _queue.Info.AddError(); try { Decision decision = await _queue.DeliveryHandler.ExceptionThrown(_queue, message, ex); await _queue.ApplyDecision(decision, message); if (!message.IsInQueue) { if (decision.PutBack == PutBackDecision.Start) { _queue.AddMessage(message, false); } else if (decision.PutBack == PutBackDecision.End) { _queue.AddMessage(message); } } } catch //if developer does wrong operation, we should not stop { } } } await client.Client.SendAsync(MessageBuilder.CreateNoContentPullResponse(request, HorseHeaders.END)); return(PullResult.Success); }
private async Task <PushResult> ProcessMessage(QueueMessage message) { //if we need acknowledge from receiver, it has a deadline. DateTime?ackDeadline = null; if (_queue.Options.Acknowledge != QueueAckDecision.None) { ackDeadline = DateTime.UtcNow.Add(_queue.Options.AcknowledgeTimeout); } //if to process next message is requires previous message acknowledge, wait here if (_queue.Options.Acknowledge == QueueAckDecision.WaitForAcknowledge) { await _queue.WaitForAcknowledge(message); } //if there are not receivers, complete send operation List <QueueClient> clients = _queue.ClientsClone; if (clients.Count == 0) { _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); Decision final = new Decision(false, false, PutBackDecision.No, DeliveryAcknowledgeDecision.None); bool messageIsSent = false; //to all receivers foreach (QueueClient client in clients) { //to only online receivers if (!client.Client.IsConnected) { continue; } //call before send and check decision Decision ccrd = await _queue.DeliveryHandler.CanConsumerReceive(_queue, message, client.Client); final = HorseQueue.CreateFinalDecision(final, ccrd); if (!ccrd.Allow) { continue; } //create delivery object MessageDelivery delivery = new MessageDelivery(message, client, ackDeadline); //send the message bool sent = await client.Client.SendAsync(messageData); if (sent) { if (_queue.Options.Acknowledge != QueueAckDecision.None) { client.CurrentlyProcessing = message; client.ProcessDeadline = ackDeadline ?? DateTime.UtcNow; } messageIsSent = true; message.CurrentDeliveryReceivers.Add(client); //adds the delivery to time keeper to check timing up _queue.TimeKeeper.AddAcknowledgeCheck(delivery); //mark message is sent delivery.MarkAsSent(); //do after send operations for per message _queue.Info.AddDelivery(); Decision d = await _queue.DeliveryHandler.ConsumerReceived(_queue, delivery, client.Client); final = HorseQueue.CreateFinalDecision(final, d); } else { Decision d = await _queue.DeliveryHandler.ConsumerReceiveFailed(_queue, delivery, client.Client); final = HorseQueue.CreateFinalDecision(final, d); } } message.Decision = final; if (!await _queue.ApplyDecision(final, message)) { return(PushResult.Success); } //after all sending operations completed, calls implementation send completed method and complete the operation if (messageIsSent) { _queue.Info.AddMessageSend(); } 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 async Task <PullResult> Pull(QueueClient client, HorseMessage request) { QueueMessage message = _queue.FindNextMessage(); if (message == null) { await client.Client.SendAsync(request.CreateResponse(HorseResultCode.NotFound)); return(PullResult.Empty); } if (message.CurrentDeliveryReceivers.Count > 0) { message.CurrentDeliveryReceivers.Clear(); } 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 queue message message.Message.SetMessageId(request.MessageId); bool sent = await client.Client.SendAsync(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); }
private async Task <PushResult> ProcessMessage(QueueMessage message) { //if there are not receivers, complete send operation List <QueueClient> clients = _queue.ClientsClone; if (clients.Count == 0) { _queue.Info.AddMessageRemove(); return(PushResult.NoConsumers); } 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); bool messageIsSent = false; //to all receivers foreach (QueueClient client in clients) { //to only online receivers if (!client.Client.IsConnected) { continue; } //call before send and check decision Decision ccrd = await _queue.DeliveryHandler.CanConsumerReceive(_queue, message, client.Client); if (!ccrd.Allow) { continue; } //send the message _ = client.Client.SendAsync(messageData); messageIsSent = true; //do after send operations for per message _queue.Info.AddDelivery(); } //after all sending operations completed, calls implementation send completed method and complete the operation if (messageIsSent) { _queue.Info.AddMessageSend(); } 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(); } return(PushResult.Success); }