/// <summary>
/// Process pull request and sends queue message to requester as response
/// </summary>
private async Task ProcessPull(ChannelClient requester, TmqMessage request, QueueMessage message)
{
//if we need acknowledge, we are sending this information to receivers that we require response
message.Message.AcknowledgeRequired = _queue.Options.RequestAcknowledge;
//if we need acknowledge from receiver, it has a deadline.
DateTime?deadline = null;
if (_queue.Options.RequestAcknowledge)
{
deadline = DateTime.UtcNow.Add(_queue.Options.AcknowledgeTimeout);
}
//if to process next message is requires previous message acknowledge, wait here
if (_queue.Options.RequestAcknowledge && _queue.Options.WaitForAcknowledge)
{
await _queue.WaitForAcknowledge(message);
}
message.Decision = await _queue.DeliveryHandler.BeginSend(_queue, message);
if (!await _queue.ApplyDecision(message.Decision, message))
{
return;
}
//if message is sent before and this is second client, skip the process
bool skip = !message.Message.FirstAcquirer && _queue.Options.SendOnlyFirstAcquirer;
if (skip)
{
if (!message.Decision.KeepMessage)
{
_queue.Info.AddMessageRemove();
_ = _queue.DeliveryHandler.MessageRemoved(_queue, message);
}
return;
}
//call before send and check decision
message.Decision = await _queue.DeliveryHandler.CanConsumerReceive(_queue, message, requester.Client);
if (!await _queue.ApplyDecision(message.Decision, message))
{
return;
}
//create delivery object
MessageDelivery delivery = new MessageDelivery(message, requester, deadline);
delivery.FirstAcquirer = message.Message.FirstAcquirer;
//change to response message, send, change back to channel message
string mid = message.Message.MessageId;
message.Message.SetMessageId(request.MessageId);
message.Message.Type = MessageType.Response;
bool sent = requester.Client.Send(message.Message);
message.Message.SetMessageId(mid);
message.Message.Type = MessageType.Channel;
if (sent)
{
_queue.TimeKeeper.AddAcknowledgeCheck(delivery);
delivery.MarkAsSent();
//do after send operations for per message
_queue.Info.AddDelivery();
message.Decision = await _queue.DeliveryHandler.ConsumerReceived(_queue, delivery, requester.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;
}
}
else
{
message.Decision = await _queue.DeliveryHandler.ConsumerReceiveFailed(_queue, delivery, requester.Client);
if (!await _queue.ApplyDecision(message.Decision, message))
{
return;
}
}
message.Decision = await _queue.DeliveryHandler.EndSend(_queue, message);
await _queue.ApplyDecision(message.Decision, message);
if (message.Decision.Allow && !message.Decision.KeepMessage)
{
_queue.Info.AddMessageRemove();
_ = _queue.DeliveryHandler.MessageRemoved(_queue, message);
}
}
private async Task <PushResult> ProcessMessage(QueueMessage message)
{
//if we need acknowledge from receiver, it has a deadline.
DateTime?ackDeadline = null;
if (_queue.Options.RequestAcknowledge)
{
ackDeadline = DateTime.UtcNow.Add(_queue.Options.AcknowledgeTimeout);
}
//if there are not receivers, complete send operation
List <ChannelClient> clients = _queue.Channel.ClientsClone;
if (clients.Count == 0)
{
_queue.AddMessage(message, false);
return(PushResult.NoConsumers);
}
//if to process next message is requires previous message acknowledge, wait here
if (_queue.Options.RequestAcknowledge && _queue.Options.WaitForAcknowledge)
{
await _queue.WaitForAcknowledge(message);
}
message.Decision = await _queue.DeliveryHandler.BeginSend(_queue, message);
if (!await _queue.ApplyDecision(message.Decision, message))
{
return(PushResult.Success);
}
//create prepared message data
byte[] messageData = await _writer.Create(message.Message);
Decision final = new Decision(false, false, false, DeliveryAcknowledgeDecision.None);
bool messageIsSent = false;
//to all receivers
foreach (ChannelClient client in clients)
{
//to only online receivers
if (!client.Client.IsConnected)
{
continue;
}
//somehow if code comes here (it should not cuz of last "break" in this foreach, break
if (!message.Message.FirstAcquirer && _queue.Options.SendOnlyFirstAcquirer)
{
break;
}
//call before send and check decision
Decision ccrd = await _queue.DeliveryHandler.CanConsumerReceive(_queue, message, client.Client);
final = ChannelQueue.CreateFinalDecision(final, ccrd);
if (!ccrd.Allow)
{
continue;
}
//create delivery object
MessageDelivery delivery = new MessageDelivery(message, client, ackDeadline);
delivery.FirstAcquirer = message.Message.FirstAcquirer;
//send the message
bool sent = client.Client.Send(messageData);
if (sent)
{
messageIsSent = true;
//adds the delivery to time keeper to check timing up
_queue.TimeKeeper.AddAcknowledgeCheck(delivery);
//set as sent, if message is sent to it's first acquirer,
//set message first acquirer false and re-create byte array data of the message
bool firstAcquirer = message.Message.FirstAcquirer;
//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 = ChannelQueue.CreateFinalDecision(final, d);
//if we are sending to only first acquirer, break
if (_queue.Options.SendOnlyFirstAcquirer && firstAcquirer)
{
break;
}
if (firstAcquirer && clients.Count > 1)
{
messageData = await _writer.Create(message.Message);
}
}
else
{
Decision d = await _queue.DeliveryHandler.ConsumerReceiveFailed(_queue, delivery, client.Client);
final = ChannelQueue.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.KeepMessage)
{
_queue.Info.AddMessageRemove();
_ = _queue.DeliveryHandler.MessageRemoved(_queue, message);
}
return(PushResult.Success);
}
private async Task <PushResult> ProcessMessage(QueueMessage message, ChannelClient receiver)
{
//if we need acknowledge from receiver, it has a deadline.
DateTime?deadline = null;
if (_queue.Options.RequestAcknowledge)
{
deadline = DateTime.UtcNow.Add(_queue.Options.AcknowledgeTimeout);
}
//if to process next message is requires previous message acknowledge, wait here
if (_queue.Options.RequestAcknowledge && _queue.Options.WaitForAcknowledge)
{
await _queue.WaitForAcknowledge(message);
}
message.Decision = await _queue.DeliveryHandler.BeginSend(_queue, message);
if (!await _queue.ApplyDecision(message.Decision, message))
{
return(PushResult.Success);
}
//create prepared message data
byte[] messageData = await _writer.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);
delivery.FirstAcquirer = message.Message.FirstAcquirer;
//send the message
bool sent = receiver.Client.Send(messageData);
if (sent)
{
//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.KeepMessage)
{
_queue.Info.AddMessageRemove();
_ = _queue.DeliveryHandler.MessageRemoved(_queue, message);
}
return(PushResult.Success);
}
