private void CloseAmqpModel(AmqpModelContainer model)
{
if (model != null)
{
model.Close();
}
}
internal static void WaitForResponse(HttpRequestMessage request, ExpectedResponse arrival, TimeSpan requestTimeout, AmqpModelContainer model, bool closeModel, CancellationToken cancellationToken, TaskCompletionSource <HttpResponseMessage> taskSource, Action cleanup)
{
var localVariableInitLock = new object();
lock (localVariableInitLock)
{
//TODO: Have cancellationToken signal WaitHandle so that threadpool stops waiting.
RegisteredWaitHandle callbackHandle = null;
callbackHandle = ThreadPool.RegisterWaitForSingleObject(arrival.ReceivedEvent.WaitHandle,
(state, timedOut) =>
{
//TODO: Investigate, this memorybarrier might be unnecessary since the thread is released from the threadpool
//after deserializationException and responsePacket is set.
Interlocked.MemoryBarrier(); //Ensure non-cached versions of arrival are read
try
{
//TODO: Check Cancelation Token when it's implemented
if (closeModel)
{
model.Close();
}
SetResponseResult(request, timedOut, arrival, taskSource);
lock (localVariableInitLock)
{
callbackHandle.Unregister(null);
}
}
catch
{
//TODO: Log this:
// the code in the try block should be safe so this catch block should never be called,
// hoewever, this delegate is called on a separate thread and should be protected.
}
finally
{
cleanup();
}
},
null,
requestTimeout == System.Threading.Timeout.InfiniteTimeSpan ? System.Threading.Timeout.Infinite : (long)requestTimeout.TotalMilliseconds,
true);
}
}
private void StartCallbackQueueConsumer(AmqpChannelPooler pool)
{
//TODO: Double-checked locking -- make this better
if (callbackConsumer == null || !isInConsumerLoop || !pool.Connection.IsOpen)
{
lock (restartConsumerSync)
{
if (!(callbackConsumer == null || !isInConsumerLoop || !pool.Connection.IsOpen))
{
return;
}
//This method waits on this signal to make sure the callbackprocessor thread either started successfully or failed.
ManualResetEventSlim consumerSignal = new ManualResetEventSlim(false);
Exception consumerSignalException = null;
Thread callBackProcessor = new Thread(p =>
{
ConcurrentQueueingConsumer consumer = null;
try
{
//Start consumer
AmqpModelContainer channelContainer = null;
try
{
channelContainer = pool.GetModel(ChannelFlags.Consumer);
IModel channel = channelContainer.Channel;
if (clientSettings.DisableDirectReplies || !channelContainer.IsDirectReplyToCapable)
{
DeclareIndirectReplyToQueue(channel, indirectReplyToQueueName);
}
consumer = new ConcurrentQueueingConsumer(channel, responseQueued);
//Set consumerCancelled to true on consumer cancellation
consumerCancelled = false;
consumer.ConsumerCancelled += (s, e) => { consumerCancelled = true; };
channel.BasicQos(0, (ushort)clientSettings.PrefetchCount, false);
//Start consumer:
string replyToQueueName;
if (clientSettings.DisableDirectReplies || !channelContainer.IsDirectReplyToCapable)
{
channel.BasicConsume(indirectReplyToQueueName, clientSettings.AckBehavior == ClientAckBehavior.Automatic, consumer);
replyToQueueName = indirectReplyToQueueName;
}
else
{
//TODO: REMOVE LATER: This clause is never called because in this case the DirectReplyToRPCStrategy would be in use
//instead of this strategy.
//throw an InvalidOperationException instead
channel.BasicConsume(RPCStrategyHelpers.DIRECT_REPLY_TO_QUEUENAME_ARG, true, consumer);
//Discover direct reply to queue name
replyToQueueName = DiscoverDirectReplyToQueueName(channel, indirectReplyToQueueName);
}
//Set callbackConsumer to consumer
callbackQueueName = replyToQueueName;
callbackConsumer = consumer;
//Notify outer thread that channel has started consumption
consumerSignal.Set();
BasicDeliverEventArgs evt;
ExpectedResponse expected;
isInConsumerLoop = true;
while (true)
{
try
{
evt = DequeueCallbackQueue();
}
catch
{
//TODO: Log this exception except it's ObjectDisposedException or OperationCancelledException
throw;
}
expected = null;
if (!String.IsNullOrEmpty(evt.BasicProperties.CorrelationId) && expectedResponses.TryRemove(evt.BasicProperties.CorrelationId, out expected))
{
RPCStrategyHelpers.ReadAndSignalDelivery(expected, evt);
}
//Acknowledge receipt:
//In ClientBehavior.Automatic mode
//Client acks all received messages, even if it wasn't the expected one or even if it wasn't expecting anything.
//This prevents a situation where crap messages are sent to the client but the good expected message is stuck behind the
//crap ones and isn't delivered because the crap ones in front of the queue aren't acked and crap messages exceed prefetchCount.
//In ClientAckBehavior.ValidResponses mode (and Direct Reply to is not in effect):
//Client only acks expected messages if they could be deserialized
//If not, they are rejected.
if ((clientSettings.DisableDirectReplies || !channelContainer.IsDirectReplyToCapable) && clientSettings.AckBehavior == ClientAckBehavior.ValidResponses)
{
if (expected != null && expected.DeserializationException != null)
{
channel.BasicAck(evt.DeliveryTag, false);
}
else
{
channel.BasicReject(evt.DeliveryTag, false);
}
}
//Exit loop if consumer is cancelled.
if (consumerCancelled)
{
break;
}
}
}
finally
{
isInConsumerLoop = false;
pool.SetRecycle();
if (channelContainer != null)
{
if (consumer != null && !consumerCancelled)
{
try
{
channelContainer.Channel.BasicCancel(consumer.ConsumerTag);
}
catch { }
}
channelContainer.Close();
}
}
}
catch (Exception ex)
{
//TODO: Log error (Except it's object disposed exception)
//Set Exception object which will be throw by signal waiter
consumerSignalException = ex;
//Notify outer thread to move on, in case it's still waiting
try
{
consumerSignal.Set();
}
catch { }
}
finally
{
if (pool != null)
{
pool.Dispose();
}
}
});
//Start Thread
callBackProcessor.Name = "RestBus RabbitMQ Client Callback Queue Consumer";
callBackProcessor.IsBackground = true;
callBackProcessor.Start();
//Wait for Thread to start consuming messages
consumerSignal.Wait();
consumerSignal.Dispose();
//Examine exception if it were set and rethrow it
Thread.MemoryBarrier(); //Ensure we have the non-cached version of consumerSignalException
if (consumerSignalException != null)
{
throw consumerSignalException;
}
//No more code from this point in this method
}
}
}
internal static void WaitForResponse(HttpRequestMessage request, ExpectedResponse arrival, TimeSpan requestTimeout, AmqpModelContainer model, bool closeModel, CancellationToken cancellationToken, TaskCompletionSource <HttpResponseMessage> taskSource, Action cleanup)
{
//Spawning a new task to wait on the MRESlim is slower than using ThreadPool.RegisterWaitForSingleObject
//
//TODO: Test task vs RegisterWaitForSingleObject modes in a super fast network environment with 40, 100, 200 all the way to 1000 threads to see what method has fastest throughput.
#if WAIT_FOR_RESPONSE_IN_TASK_MODE
//Wait for response arrival event on a new task
Task.Factory.StartNew(() =>
{
bool succeeded = arrival.ReceivedEvent.Wait(
requestTimeout.TotalMilliseconds > Int32.MaxValue ? TimeSpan.FromMilliseconds(Int32.MaxValue) : requestTimeout /* Covers InfiniteTimeSpan */,
cancellationToken);
Thread.MemoryBarrier(); //Ensure non-cached versions of arrival are read
//It failed either because it timed out or was cancelled
//HttpClient treats both scenarios the same way.
try
{
if (closeModel)
{
model.Close();
}
SetResponseResult(request, !succeeded, arrival, taskSource);
}
catch
{
//TODO: Log this:
// the code in the try block should be safe so this catch block should never be called,
// hoewever, this delegate is called on a separate thread and should be protected.
}
finally
{
CleanupMessagingResources(correlationId, arrival);
}
}, cancellationToken);
#else
//Wait for response arrival event on the ThreadPool:
var localVariableInitLock = new object();
lock (localVariableInitLock)
{
//TODO: Have cancellationToken signal WaitHandle so that threadpool stops waiting.
RegisteredWaitHandle callbackHandle = null;
callbackHandle = ThreadPool.RegisterWaitForSingleObject(arrival.ReceivedEvent.WaitHandle,
(state, timedOut) =>
{
//TODO: Investigate, this memorybarrier might be unnecessary since the thread is released from the threadpool
//after deserializationException and responsePacket is set.
Thread.MemoryBarrier(); //Ensure non-cached versions of arrival are read
try
{
//TODO: Check Cancelation Token when it's implemented
if (closeModel)
{
model.Close();
}
SetResponseResult(request, timedOut, arrival, taskSource);
lock (localVariableInitLock)
{
callbackHandle.Unregister(null);
}
}
catch
{
//TODO: Log this:
// the code in the try block should be safe so this catch block should never be called,
// hoewever, this delegate is called on a separate thread and should be protected.
}
finally
{
cleanup();
}
},
null,
requestTimeout == System.Threading.Timeout.InfiniteTimeSpan ? System.Threading.Timeout.Infinite : (long)requestTimeout.TotalMilliseconds,
true);
}
#endif
}
public void SendResponse(MessageContext context, HttpResponsePacket response)
{
if (disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
var dispatch = context.Dispatch as MessageDispatch;
if (dispatch != null)
{
//Ack request
if (Settings.AckBehavior != SubscriberAckBehavior.Automatic && dispatch.Consumer.Model.IsOpen)
{
dispatch.Consumer.Model.BasicAck(dispatch.Delivery.DeliveryTag, false);
//NOTE: The call above takes place in different threads silmultaneously
//In which case multiple threads will be using the same channel at the same time.
//It's okay in this case, because transmissions within a channel are synchronized, as seen in:
//https://github.com/rabbitmq/rabbitmq-dotnet-client/blob/f16c093f6409e11d9d77115038cb224eb39468ec/projects/client/RabbitMQ.Client/src/client/impl/ModelBase.cs#L459
//and
//https://github.com/rabbitmq/rabbitmq-dotnet-client/blob/f16c093f6409e11d9d77115038cb224eb39468ec/projects/client/RabbitMQ.Client/src/client/impl/SessionBase.cs#L177
}
}
//Exit method if no replyToQueue was specified.
if (String.IsNullOrEmpty(context.ReplyToQueue))
{
return;
}
if (_subscriberPool.Connection == null)
{
//TODO: Log this -- it technically shouldn't happen. Also translate to a HTTP Unreachable because it means StartCallbackQueueConsumer didn't create a connection
throw new InvalidOperationException("This is Bad");
}
//Add/Update Subscriber-Id header
response.Headers[Common.Shared.SUBSCRIBER_ID_HEADER] = subscriberIdHeader;
//Send response
var pooler = _subscriberPool;
AmqpModelContainer model = null;
try
{
model = pooler.GetModel(ChannelFlags.None);
BasicProperties basicProperties = new BasicProperties {
CorrelationId = context.CorrelationId
};
model.Channel.BasicPublish(String.Empty,
context.ReplyToQueue,
basicProperties,
response.Serialize());
}
finally
{
if (model != null)
{
model.Close();
}
}
}
public void Restart()
{
hasStarted.Set(true);
//CLose connections and channels
if (subscriberChannel != null)
{
if (subscriberConsumer != null)
{
try
{
subscriberChannel.Channel.BasicCancel(subscriberConsumer.ConsumerTag);
}
catch { }
}
try
{
subscriberChannel.Close();
}
catch
{
}
}
if (workChannel != null)
{
if (workConsumer != null)
{
try
{
workChannel.Channel.BasicCancel(workConsumer.ConsumerTag);
}
catch { }
}
try
{
workChannel.Close();
}
catch
{
}
}
if (_subscriberPool != null)
{
_subscriberPool.Dispose();
}
//NOTE: CreateConnection() can throw BrokerUnreachableException
//That's okay because the exception needs to propagate to Reconnect() or Start()
var conn = connectionFactory.CreateConnection();
if (connectionBroken != null)
{
connectionBroken.Dispose();
}
connectionBroken = new CancellationTokenSource();
if (stopWaitingOnQueue != null)
{
stopWaitingOnQueue.Dispose();
}
stopWaitingOnQueue = CancellationTokenSource.CreateLinkedTokenSource(disposedCancellationSource.Token, connectionBroken.Token);
var pool = new AmqpChannelPooler(conn);
_subscriberPool = pool;
//Use pool reference henceforth.
//Create work channel and declare exchanges and queues
workChannel = pool.GetModel(ChannelFlags.Consumer);
//Redeclare exchanges and queues
AmqpUtils.DeclareExchangeAndQueues(workChannel.Channel, messageMapper, messagingConfig, serviceName, exchangeDeclareSync, Id);
//Listen on work queue
workConsumer = new ConcurrentQueueingConsumer(workChannel.Channel, requestQueued);
string workQueueName = AmqpUtils.GetWorkQueueName(messagingConfig, serviceName);
workChannel.Channel.BasicQos(0, (ushort)Settings.PrefetchCount, false);
workChannel.Channel.BasicConsume(workQueueName, Settings.AckBehavior == SubscriberAckBehavior.Automatic, workConsumer);
//Listen on subscriber queue
subscriberChannel = pool.GetModel(ChannelFlags.Consumer);
subscriberConsumer = new ConcurrentQueueingConsumer(subscriberChannel.Channel, requestQueued);
string subscriberWorkQueueName = AmqpUtils.GetSubscriberQueueName(serviceName, Id);
subscriberChannel.Channel.BasicQos(0, (ushort)Settings.PrefetchCount, false);
subscriberChannel.Channel.BasicConsume(subscriberWorkQueueName, Settings.AckBehavior == SubscriberAckBehavior.Automatic, subscriberConsumer);
//Cancel connectionBroken on connection/consumer problems
pool.Connection.ConnectionShutdown += (s, e) => { connectionBroken.Cancel(); };
workConsumer.ConsumerCancelled += (s, e) => { connectionBroken.Cancel(); };
subscriberConsumer.ConsumerCancelled += (s, e) => { connectionBroken.Cancel(); };
}
