public async Task OnConnectionBlocked(ConnectionBlockedEventArgs args)
{
AsyncEventHandler <ConnectionBlockedEventArgs> handler;
lock (m_eventLock)
{
handler = m_connectionBlocked;
}
if (handler != null)
{
foreach (AsyncEventHandler <ConnectionBlockedEventArgs> h in handler.GetInvocationList())
{
try
{
await h(this, args);
}
catch (Exception e)
{
await OnCallbackException(CallbackExceptionEventArgs.Build(e,
new Dictionary <string, object>
{
{ "context", "OnConnectionBlocked" }
}));
}
}
}
}
protected override async Task Execute(ModelBase model, IAsyncBasicConsumer consumer)
{
try
{
await consumer.HandleBasicDeliver(_consumerTag,
_deliveryTag,
_redelivered,
_exchange,
_routingKey,
_basicProperties,
_body).ConfigureAwait(false);
}
catch (Exception e)
{
var details = new Dictionary <string, object>()
{
{ "consumer", consumer },
{ "context", "HandleBasicDeliver" }
};
model.OnCallbackException(CallbackExceptionEventArgs.Build(e, details));
}
finally
{
if (MemoryMarshal.TryGetArray(_body, out ArraySegment <byte> segment))
{
ArrayPool <byte> .Shared.Return(segment.Array);
}
}
}
private static async Task HandleConcurrent(Work work, IModel model, SemaphoreSlim limiter)
{
try
{
Task task = work.Execute();
if (!task.IsCompleted)
{
await task.ConfigureAwait(false);
}
}
catch (Exception e)
{
if (!(model is ModelBase modelBase))
{
return;
}
var details = new Dictionary <string, object>
{
{ "consumer", work.Consumer },
{ "context", work.Consumer }
};
modelBase.OnCallbackException(CallbackExceptionEventArgs.Build(e, details));
}
finally
{
work.PostExecute();
limiter.Release();
}
}
protected override async Task ProcessChannelAsync()
{
while (await _reader.WaitToReadAsync().ConfigureAwait(false))
{
while (_reader.TryRead(out var work))
{
try
{
var task = work.WorkType switch
{
WorkType.Deliver => work.AsyncConsumer.HandleBasicDeliver(work.ConsumerTag, work.DeliveryTag, work.Redelivered, work.Exchange, work.RoutingKey, work.BasicProperties, work.Body),
WorkType.Cancel => work.AsyncConsumer.HandleBasicCancel(work.ConsumerTag),
WorkType.CancelOk => work.AsyncConsumer.HandleBasicCancelOk(work.ConsumerTag),
WorkType.ConsumeOk => work.AsyncConsumer.HandleBasicConsumeOk(work.ConsumerTag),
WorkType.Shutdown => work.AsyncConsumer.HandleModelShutdown(_model, work.Reason),
_ => Task.CompletedTask
};
await task.ConfigureAwait(false);
}
catch (Exception e)
{
_model.OnCallbackException(CallbackExceptionEventArgs.Build(e, work.WorkType.ToString(), work.Consumer));
}
finally
{
if (work.RentedArray != null)
{
ArrayPool <byte> .Shared.Return(work.RentedArray);
}
}
}
}
}
private async Task Loop()
{
while (await _channel.Reader.WaitToReadAsync().ConfigureAwait(false))
{
while (_channel.Reader.TryRead(out Work work))
{
try
{
Task task = work.Execute();
if (!task.IsCompleted)
{
await task.ConfigureAwait(false);
}
}
catch (Exception e)
{
if (!(_model is ModelBase modelBase))
{
return;
}
var details = new Dictionary <string, object>
{
{ "consumer", work.Consumer },
{ "context", work.Consumer }
};
modelBase.OnCallbackException(CallbackExceptionEventArgs.Build(e, details));
}
finally
{
work.PostExecute();
}
}
}
}
public void HandleBasicDeliver(IBasicConsumer consumer,
string consumerTag,
ulong deliveryTag,
bool redelivered,
string exchange,
string routingKey,
IBasicProperties basicProperties,
byte[] body)
{
UnlessShuttingDown(() =>
{
try
{
consumer.HandleBasicDeliver(consumerTag,
deliveryTag,
redelivered,
exchange,
routingKey,
basicProperties,
body);
}
catch (Exception e)
{
var details = new Dictionary <string, object>()
{
{ "consumer", consumer },
{ "context", "HandleBasicDeliver" }
};
model.OnCallbackException(CallbackExceptionEventArgs.Build(e, details));
}
});
}
public void OnConnectionUnblocked()
{
EventHandler <EventArgs> handler;
lock (m_eventLock)
{
handler = m_connectionUnblocked;
}
if (handler != null)
{
foreach (EventHandler <EventArgs> h in handler.GetInvocationList())
{
try
{
h(this, EventArgs.Empty);
}
catch (Exception e)
{
OnCallbackException(CallbackExceptionEventArgs.Build(e,
new Dictionary <string, object>
{
{ "context", "OnConnectionUnblocked" }
}));
}
}
}
}
protected override async Task Execute(ModelBase model, IAsyncBasicConsumer consumer)
{
try
{
await consumer.HandleBasicDeliver(_consumerTag,
_deliveryTag,
_redelivered,
_exchange,
_routingKey,
_basicProperties,
_body.Memory.Slice(0, _bodyLength)).ConfigureAwait(false);
}
catch (Exception e)
{
var details = new Dictionary <string, object>()
{
{ "consumer", consumer },
{ "context", "HandleBasicDeliver" }
};
model.OnCallbackException(CallbackExceptionEventArgs.Build(e, details));
}
finally
{
_body.Dispose();
}
}
///<summary>Broadcasts notification of the final shutdown of the connection.</summary>
public void OnShutdown()
{
EventHandler <ShutdownEventArgs> handler;
ShutdownEventArgs reason;
lock (m_eventLock)
{
handler = m_connectionShutdown;
reason = m_closeReason;
m_connectionShutdown = null;
}
if (handler != null)
{
foreach (EventHandler <ShutdownEventArgs> h in handler.GetInvocationList())
{
try
{
h(this, reason);
}
catch (Exception e)
{
OnCallbackException(CallbackExceptionEventArgs.Build(e,
new Dictionary <string, object>
{
{ "context", "OnShutdown" }
}));
}
}
}
}
protected override async Task Execute(ModelBase model, IBasicConsumer consumer)
{
try
{
await consumer.HandleModelShutdown(model, reason).ConfigureAwait(false);
}
catch (Exception e)
{
var details = new Dictionary <string, object>()
{
{ "consumer", consumer },
{ "context", "HandleModelShutdown" }
};
await model.OnCallbackException(CallbackExceptionEventArgs.Build(e, details));
}
}
protected override async Task Execute(ModelBase model, IAsyncBasicConsumer consumer)
{
try
{
await consumer.HandleBasicCancelOk(_consumerTag).ConfigureAwait(false);
}
catch (Exception e)
{
var details = new Dictionary <string, object>()
{
{ "consumer", consumer },
{ "context", "HandleBasicCancelOk" }
};
model.OnCallbackException(CallbackExceptionEventArgs.Build(e, details));
}
}
protected override async Task ProcessChannelAsync()
{
while (await _reader.WaitToReadAsync().ConfigureAwait(false))
{
while (_reader.TryRead(out var work))
{
try
{
var consumer = work.Consumer;
var consumerTag = work.ConsumerTag;
switch (work.WorkType)
{
case WorkType.Deliver:
consumer.HandleBasicDeliver(consumerTag, work.DeliveryTag, work.Redelivered, work.Exchange, work.RoutingKey, work.BasicProperties, work.Body);
break;
case WorkType.Cancel:
consumer.HandleBasicCancel(consumerTag);
break;
case WorkType.CancelOk:
consumer.HandleBasicCancelOk(consumerTag);
break;
case WorkType.ConsumeOk:
consumer.HandleBasicConsumeOk(consumerTag);
break;
case WorkType.Shutdown:
consumer.HandleModelShutdown(_model, work.Reason);
break;
}
}
catch (Exception e)
{
_model.OnCallbackException(CallbackExceptionEventArgs.Build(e, work.WorkType.ToString(), work.Consumer));
}
finally
{
if (work.RentedArray != null)
{
ArrayPool <byte> .Shared.Return(work.RentedArray);
}
}
}
}
}
public void HandleModelShutdown(IBasicConsumer consumer, ShutdownEventArgs reason)
{
// the only case where we ignore the shutdown flag.
try
{
consumer.HandleModelShutdown(model, reason);
}
catch (Exception e)
{
var details = new Dictionary <string, object>()
{
{ "consumer", consumer },
{ "context", "HandleModelShutdown" }
};
model.OnCallbackException(CallbackExceptionEventArgs.Build(e, details));
}
}
///<summary>Broadcasts notification of the final shutdown of the connection.</summary>
public void OnShutdown()
{
EventHandler <ShutdownEventArgs> handler;
ShutdownEventArgs reason;
lock (m_eventLock)
{
handler = m_connectionShutdown;
reason = m_closeReason;
m_connectionShutdown = null;
}
if (handler != null)
{
foreach (EventHandler <ShutdownEventArgs> h in handler.GetInvocationList())
{
try
{
h(this, reason);
}
catch (Exception e)
{
OnCallbackException(CallbackExceptionEventArgs.Build(e,
new Dictionary <string, object>
{
{ "context", "OnShutdown" }
}));
}
}
}
#if NETFX_CORE
#pragma warning disable 0168
try
{
Windows.UI.Xaml.Application.Current.Suspending -= this.HandleApplicationSuspend;
}
catch (Exception ex)
{
// If called from a desktop app (i.e. unit tests), then there is no current application
}
#pragma warning restore 0168
#else
AppDomain.CurrentDomain.DomainUnload -= HandleDomainUnload;
#endif
}
public void HandleBasicCancelOk(IBasicConsumer consumer, string consumerTag)
{
UnlessShuttingDown(() =>
{
try
{
consumer.HandleBasicCancelOk(consumerTag);
}
catch (Exception e)
{
var details = new Dictionary <string, object>()
{
{ "consumer", consumer },
{ "context", "HandleBasicCancelOk" }
};
model.OnCallbackException(CallbackExceptionEventArgs.Build(e, details));
}
});
}
public AutorecoveringConnection(ConnectionConfig config, IEndpointResolver endpoints)
{
_config = config;
_endpoints = endpoints;
IFrameHandler fh = _endpoints.SelectOne(_config.FrameHandlerFactory);
_innerConnection = new Connection(_config, fh);
Action <Exception, string> onException =
(exception, context) =>
_innerConnection.OnCallbackException(CallbackExceptionEventArgs.Build(exception, context));
_recoverySucceededWrapper = new EventingWrapper <EventArgs>("OnConnectionRecovery", onException);
_connectionRecoveryErrorWrapper = new EventingWrapper <ConnectionRecoveryErrorEventArgs>("OnConnectionRecoveryError", onException);
_consumerTagChangeAfterRecoveryWrapper = new EventingWrapper <ConsumerTagChangedAfterRecoveryEventArgs>("OnConsumerRecovery", onException);
_queueNameChangeAfterRecoveryWrapper = new EventingWrapper <QueueNameChangedAfterRecoveryEventArgs>("OnQueueRecovery", onException);
ConnectionShutdown += HandleConnectionShutdown;
}
public void HandleBasicDeliver(IBasicConsumer consumer,
string consumerTag,
ulong deliveryTag,
bool redelivered,
string exchange,
string routingKey,
IBasicProperties basicProperties,
ReadOnlySpan <byte> body)
{
byte[] memoryCopyArray = ArrayPool <byte> .Shared.Rent(body.Length);
Memory <byte> memoryCopy = new Memory <byte>(memoryCopyArray, 0, body.Length);
body.CopyTo(memoryCopy.Span);
UnlessShuttingDown(() =>
{
try
{
consumer.HandleBasicDeliver(consumerTag,
deliveryTag,
redelivered,
exchange,
routingKey,
basicProperties,
memoryCopy);
}
catch (Exception e)
{
var details = new Dictionary <string, object>()
{
{ "consumer", consumer },
{ "context", "HandleBasicDeliver" }
};
_model.OnCallbackException(CallbackExceptionEventArgs.Build(e, details));
}
finally
{
ArrayPool <byte> .Shared.Return(memoryCopyArray);
}
});
}
public void HandleBasicDeliver(IBasicConsumer consumer,
string consumerTag,
ulong deliveryTag,
bool redelivered,
string exchange,
string routingKey,
IBasicProperties basicProperties,
ReadOnlyMemory <byte> body,
byte[] rentedArray)
{
UnlessShuttingDown(() =>
{
var bodyData = new BodyData(body, rentedArray);
try
{
consumer.HandleBasicDeliver(consumerTag,
deliveryTag,
redelivered,
exchange,
routingKey,
basicProperties,
in bodyData);
}
catch (Exception e)
{
var details = new Dictionary <string, object>
{
{ "consumer", consumer },
{ "context", "HandleBasicDeliver" }
};
_model.OnCallbackException(CallbackExceptionEventArgs.Build(e, details));
}
finally
{
bodyData.ReturnPayload();
}
});
}
protected override async Task Execute(ModelBase model, IAsyncBasicConsumer consumer)
{
try
{
await consumer.HandleBasicDeliver(consumerTag,
deliveryTag,
redelivered,
exchange,
routingKey,
basicProperties,
body).ConfigureAwait(false);
}
catch (Exception e)
{
var details = new Dictionary <string, object>()
{
{ "consumer", consumer },
{ "context", "HandleBasicDeliver" }
};
model.OnCallbackException(CallbackExceptionEventArgs.Build(e, details));
}
}
public Connection(IConnectionFactory factory, IFrameHandler frameHandler, string clientProvidedName = null)
{
ClientProvidedName = clientProvidedName;
_factory = factory;
_frameHandler = frameHandler;
ConsumerWorkService = factory.DispatchConsumersAsync
? new AsyncConsumerWorkService(factory.ConsumerDispatchConcurrency)
: new ConsumerWorkService(factory.ConsumerDispatchConcurrency);
Action <Exception, string> onException = (exception, context) => OnCallbackException(CallbackExceptionEventArgs.Build(exception, context));
_callbackExceptionWrapper = new EventingWrapper <CallbackExceptionEventArgs>(string.Empty, (exception, context) => { });
_connectionBlockedWrapper = new EventingWrapper <ConnectionBlockedEventArgs>("OnConnectionBlocked", onException);
_connectionUnblockedWrapper = new EventingWrapper <EventArgs>("OnConnectionUnblocked", onException);
_connectionShutdownWrapper = new EventingWrapper <ShutdownEventArgs>("OnShutdown", onException);
_sessionManager = new SessionManager(this, 0);
_session0 = new MainSession(this)
{
Handler = NotifyReceivedCloseOk
};
_model0 = (ModelBase)Protocol.CreateModel(_session0);
StartMainLoop();
Open();
}
protected ModelBase(ISession session, ConsumerWorkService workService)
{
if (workService is AsyncConsumerWorkService asyncConsumerWorkService)
{
ConsumerDispatcher = new AsyncConsumerDispatcher(this, asyncConsumerWorkService);
}
else
{
ConsumerDispatcher = new ConcurrentConsumerDispatcher(this, workService);
}
_emptyBasicProperties = CreateBasicProperties();
Action <Exception, string> onException = (exception, context) => OnCallbackException(CallbackExceptionEventArgs.Build(exception, context));
_basicAcksWrapper = new EventingWrapper <BasicAckEventArgs>("OnBasicAck", onException);
_basicNacksWrapper = new EventingWrapper <BasicNackEventArgs>("OnBasicNack", onException);
_basicRecoverOkWrapper = new EventingWrapper <EventArgs>("OnBasicRecover", onException);
_basicReturnWrapper = new EventingWrapper <BasicReturnEventArgs>("OnBasicReturn", onException);
_callbackExceptionWrapper = new EventingWrapper <CallbackExceptionEventArgs>(string.Empty, (exception, context) => { });
_flowControlWrapper = new EventingWrapper <FlowControlEventArgs>("OnFlowControl", onException);
_modelShutdownWrapper = new EventingWrapper <ShutdownEventArgs>("OnModelShutdown", onException);
_recoveryWrapper = new EventingWrapper <EventArgs>("OnModelRecovery", onException);
Initialise(session);
}
public AutorecoveringConnection(ConnectionFactory factory, string clientProvidedName = null)
{
_factory = factory;
ClientProvidedName = clientProvidedName;
Action <Exception, string> onException = (exception, context) => _innerConnection.OnCallbackException(CallbackExceptionEventArgs.Build(exception, context));
_recoverySucceededWrapper = new EventingWrapper <EventArgs>("OnConnectionRecovery", onException);
_connectionRecoveryErrorWrapper = new EventingWrapper <ConnectionRecoveryErrorEventArgs>("OnConnectionRecoveryError", onException);
_consumerTagChangeAfterRecoveryWrapper = new EventingWrapper <ConsumerTagChangedAfterRecoveryEventArgs>("OnConsumerRecovery", onException);
_queueNameChangeAfterRecoveryWrapper = new EventingWrapper <QueueNameChangedAfterRecoveryEventArgs>("OnQueueRecovery", onException);
}
public Connection(IConnectionFactory factory, IFrameHandler frameHandler, string?clientProvidedName = null)
{
ClientProvidedName = clientProvidedName;
_factory = factory;
_frameHandler = frameHandler;
Action <Exception, string> onException = (exception, context) => OnCallbackException(CallbackExceptionEventArgs.Build(exception, context));
_callbackExceptionWrapper = new EventingWrapper <CallbackExceptionEventArgs>(string.Empty, (exception, context) => { });
_connectionBlockedWrapper = new EventingWrapper <ConnectionBlockedEventArgs>("OnConnectionBlocked", onException);
_connectionUnblockedWrapper = new EventingWrapper <EventArgs>("OnConnectionUnblocked", onException);
_connectionShutdownWrapper = new EventingWrapper <ShutdownEventArgs>("OnShutdown", onException);
_sessionManager = new SessionManager(this, 0);
_session0 = new MainSession(this);
_model0 = (ModelBase)Protocol.CreateModel(factory, _session0);
ClientProperties = new Dictionary <string, object?>(factory.ClientProperties)
{
["capabilities"] = Protocol.Capabilities,
["connection_name"] = ClientProvidedName
};
_mainLoopTask = Task.Factory.StartNew(MainLoop, TaskCreationOptions.LongRunning);
Open();
}
protected ModelBase(bool dispatchAsync, int concurrency, ISession session)
{
ConsumerDispatcher = dispatchAsync ?
(IConsumerDispatcher) new AsyncConsumerDispatcher(this, concurrency) :
new ConsumerDispatcher(this, concurrency);
_emptyBasicProperties = CreateBasicProperties();
Action <Exception, string> onException = (exception, context) => OnCallbackException(CallbackExceptionEventArgs.Build(exception, context));
_basicAcksWrapper = new EventingWrapper <BasicAckEventArgs>("OnBasicAck", onException);
_basicNacksWrapper = new EventingWrapper <BasicNackEventArgs>("OnBasicNack", onException);
_basicRecoverOkWrapper = new EventingWrapper <EventArgs>("OnBasicRecover", onException);
_basicReturnWrapper = new EventingWrapper <BasicReturnEventArgs>("OnBasicReturn", onException);
_callbackExceptionWrapper = new EventingWrapper <CallbackExceptionEventArgs>(string.Empty, (exception, context) => { });
_flowControlWrapper = new EventingWrapper <FlowControlEventArgs>("OnFlowControl", onException);
_modelShutdownWrapper = new EventingWrapper <ShutdownEventArgs>("OnModelShutdown", onException);
_recoveryWrapper = new EventingWrapper <EventArgs>("OnModelRecovery", onException);
session.CommandReceived = HandleCommand;
session.SessionShutdown += OnSessionShutdown;
Session = session;
}
public Connection(ConnectionConfig config, IFrameHandler frameHandler)
{
_config = config;
_frameHandler = frameHandler;
Action <Exception, string> onException = (exception, context) => OnCallbackException(CallbackExceptionEventArgs.Build(exception, context));
_callbackExceptionWrapper = new EventingWrapper <CallbackExceptionEventArgs>(string.Empty, (exception, context) => { });
_connectionBlockedWrapper = new EventingWrapper <ConnectionBlockedEventArgs>("OnConnectionBlocked", onException);
_connectionUnblockedWrapper = new EventingWrapper <EventArgs>("OnConnectionUnblocked", onException);
_connectionShutdownWrapper = new EventingWrapper <ShutdownEventArgs>("OnShutdown", onException);
_sessionManager = new SessionManager(this, 0);
_session0 = new MainSession(this);
_model0 = new Model(_config, _session0);;
ClientProperties = new Dictionary <string, object?>(_config.ClientProperties)
{
["capabilities"] = Protocol.Capabilities,
["connection_name"] = ClientProvidedName
};
_mainLoopTask = Task.Factory.StartNew(MainLoop, TaskCreationOptions.LongRunning);
try
{
Open();
}
catch
{
var ea = new ShutdownEventArgs(ShutdownInitiator.Library, Constants.InternalError, "FailedOpen");
Close(ea, true, TimeSpan.FromSeconds(5));
throw;
}
}
protected ModelBase(ConnectionConfig config, ISession session)
{
ContinuationTimeout = config.ContinuationTimeout;
ConsumerDispatcher = config.DispatchConsumersAsync ?
(IConsumerDispatcher) new AsyncConsumerDispatcher(this, config.DispatchConsumerConcurrency) :
new ConsumerDispatcher(this, config.DispatchConsumerConcurrency);
Action <Exception, string> onException = (exception, context) => OnCallbackException(CallbackExceptionEventArgs.Build(exception, context));
_basicAcksWrapper = new EventingWrapper <BasicAckEventArgs>("OnBasicAck", onException);
_basicNacksWrapper = new EventingWrapper <BasicNackEventArgs>("OnBasicNack", onException);
_basicRecoverOkWrapper = new EventingWrapper <EventArgs>("OnBasicRecover", onException);
_basicReturnWrapper = new EventingWrapper <BasicReturnEventArgs>("OnBasicReturn", onException);
_callbackExceptionWrapper = new EventingWrapper <CallbackExceptionEventArgs>(string.Empty, (exception, context) => { });
_flowControlWrapper = new EventingWrapper <FlowControlEventArgs>("OnFlowControl", onException);
_modelShutdownWrapper = new EventingWrapper <ShutdownEventArgs>("OnModelShutdown", onException);
_recoveryWrapper = new EventingWrapper <EventArgs>("OnModelRecovery", onException);
session.CommandReceived = HandleCommand;
session.SessionShutdown += OnSessionShutdown;
Session = session;
}
