private void OnCallbackException(object sender, CallbackExceptionEventArgs e)
{
if (this._disposed)
{
return;
}
this._logger.LogWarning(message: "A RabbitMQ connection throw exception. Trying to re-connect...");
this.TryConnect();
}
void OnCallbackException(object sender, CallbackExceptionEventArgs e)
{
if (_disposed)
{
return;
}
Console.WriteLine("rabbitmq connection threw exception, reconnecting");
TryConnect();
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void OnCallbackException(object sender, CallbackExceptionEventArgs e)
{
if (this._disposed)
{
return;
}
// LogHelperNLog.Info("A RabbitMQ connection throw exception. Trying to re-connect...");
this.TryConnect();
}
void OnCallbackException(object sender, CallbackExceptionEventArgs e)
{
if (_disposed)
{
return;
}
Console.WriteLine("一个RabbitMQ连接抛出异常。在贯通……");
TryConnect();
}
void OnCallbackException(object sender, CallbackExceptionEventArgs reason)
{
if (_disposed)
{
return;
}
_logger.LogError("RabbitMQ connection is throw because {@reason}. Trying to re-connect...", reason);
this.PersistentConnect();
}
void OnCallbackException(object sender, CallbackExceptionEventArgs e)
{
if (_disposed)
{
return;
}
_logger.Warn("OnCallbackException", "DefaultRabbitMQPersistentConnection", "A RabbitMQ connection throw exception. Trying to re-connect...");
TryConnect();
}
private void OnCallbackException(object sender, CallbackExceptionEventArgs args)
{
if (_disposed)
{
return;
}
logger.LogWarning("RabbitMQ Connect is callback exception, now reconnect...");
TryConnect();
}
protected virtual void OnCallbackException(object sender, CallbackExceptionEventArgs e)
{
if (disposed)
{
return;
}
logger.LogDebug("A RabbitMQ connection throw exception. Trying to re-connect...");
TryConnect();
}
private void OnCallbackException(object sender, CallbackExceptionEventArgs e)
{
if (_disposed)
{
return;
}
_logger.LogWarning("A conexão com o RabbitMq lançou uma excessão. Tente conectar novamente...");
TryConnect();
}
private void OnCallbackException(object sender, CallbackExceptionEventArgs args)
{
if (_disposed)
{
return;
}
_logger.LogWarning($"Uma conexão RabbitMQ lançou uma exceção. Detalhe: {args.Detail} + Exceção: {args.Exception.Message}. Trying to re-connect...");
TryConnect();
}
private void ConnectionCallbackExceptionHandler(object sender, CallbackExceptionEventArgs eventArgs)
{
if (eventArgs is null)
{
return;
}
//logger.LogError(new EventId(), eventArgs.Exception, eventArgs.Exception.Message, eventArgs);
throw eventArgs.Exception;
}
void OnCallbackException(object sender, CallbackExceptionEventArgs e)
{
if (_disposed)
{
return;
}
Console.WriteLine("A RabbitMQ connection throw exception. Trying to re-connect...");
TryConnect();
}
private void OnCallbackException(object sender, CallbackExceptionEventArgs e)
{
if (_dispose)
{
return;
}
_logger.LogWarning("");
TryConnect();
}
void OnCallbackException(object sender, CallbackExceptionEventArgs e)
{
if (_disposed)
{
return;
}
_logger.LogWarning("Uma conexão RabbitMQ lança exceção. Tentando reconectar ...");
TryConnect();
}
void OnCallbackException(object sender, CallbackExceptionEventArgs e)
{
if (_disposed)
{
return;
}
_logger.LogWarning("A RabbitMQ connection throw exception. Trying to re-connect...");
TryConnect();
}
protected async Task RecoverQueues()
{
foreach (KeyValuePair <string, RecordedQueue> pair in m_recordedQueues)
{
string oldName = pair.Key;
RecordedQueue rq = pair.Value;
try
{
await rq.Recover();
string newName = rq.Name;
// Make sure server-named queues are re-added with
// their new names.
// We only remove old name after we've updated the bindings and consumers,
// plus only for server-named queues, both to make sure we don't lose
// anything to recover. MK.
PropagateQueueNameChangeToBindings(oldName, newName);
PropagateQueueNameChangeToConsumers(oldName, newName);
// see rabbitmq/rabbitmq-dotnet-client#43
if (rq.IsServerNamed)
{
DeleteRecordedQueue(oldName);
}
RecordQueue(newName, rq);
if (m_queueNameChange != null)
{
foreach (AsyncEventHandler <QueueNameChangedAfterRecoveryEventArgs> h in m_queueNameChange.GetInvocationList())
{
try
{
var eventArgs = new QueueNameChangedAfterRecoveryEventArgs(oldName, newName);
await h(this, eventArgs);
}
catch (Exception e)
{
var args = new CallbackExceptionEventArgs(e);
args.Detail["context"] = "OnQueueRecovery";
await m_delegate.OnCallbackException(args);
}
}
}
}
catch (Exception cause)
{
string s = String.Format("Caught an exception while recovering queue {0}: {1}",
oldName, cause.Message);
HandleTopologyRecoveryException(new TopologyRecoveryException(s, cause));
}
}
}
private void OnCallbackException(object sender, CallbackExceptionEventArgs e)
{
if (disposed)
{
return;
}
Console.WriteLine("Connection has thrown an exception. Exception Details");
Console.WriteLine($"{e.Exception}");
Console.WriteLine("Attempting to reconnect");
Console.WriteLine();
TryConnect();
}
private void RecoverConsumers()
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
Dictionary <string, RecordedConsumer> recordedConsumersCopy;
lock (_recordedConsumers)
{
recordedConsumersCopy = new Dictionary <string, RecordedConsumer>(_recordedConsumers);
}
foreach (KeyValuePair <string, RecordedConsumer> pair in recordedConsumersCopy)
{
string tag = pair.Key;
RecordedConsumer cons = pair.Value;
try
{
string newTag = cons.Recover();
lock (_recordedConsumers)
{
// make sure server-generated tags are re-added
_recordedConsumers.Remove(tag);
_recordedConsumers.Add(newTag, cons);
}
foreach (EventHandler <ConsumerTagChangedAfterRecoveryEventArgs> h in ConsumerTagChangeAfterRecovery?.GetInvocationList() ?? Array.Empty <Delegate>())
{
try
{
var eventArgs = new ConsumerTagChangedAfterRecoveryEventArgs(tag, newTag);
h(this, eventArgs);
}
catch (Exception e)
{
var args = new CallbackExceptionEventArgs(e);
args.Detail["context"] = "OnConsumerRecovery";
_delegate.OnCallbackException(args);
}
}
}
catch (Exception cause)
{
string s = string.Format("Caught an exception while recovering consumer {0} on queue {1}: {2}",
tag, cons.Queue, cause.Message);
HandleTopologyRecoveryException(new TopologyRecoveryException(s, cause));
}
}
}
protected void RecoverQueues()
{
lock (m_recordedQueues)
{
var rqs = new Dictionary <string, RecordedQueue>(m_recordedQueues);
foreach (KeyValuePair <string, RecordedQueue> pair in rqs)
{
string oldName = pair.Key;
RecordedQueue rq = pair.Value;
try
{
rq.Recover();
string newName = rq.Name;
// make sure server-named queues are re-added with
// their new names. MK.
DeleteRecordedQueue(oldName);
RecordQueue(newName, rq);
PropagateQueueNameChangeToBindings(oldName, newName);
PropagateQueueNameChangeToConsumers(oldName, newName);
if (m_queueNameChange != null)
{
foreach (EventHandler <QueueNameChangedAfterRecoveryEventArgs> h in m_queueNameChange.GetInvocationList())
{
try
{
var eventArgs = new QueueNameChangedAfterRecoveryEventArgs(oldName, newName);
h(this, eventArgs);
}
catch (Exception e)
{
var args = new CallbackExceptionEventArgs(e);
args.Detail["context"] = "OnQueueRecovery";
m_delegate.OnCallbackException(args);
}
}
}
}
catch (Exception cause)
{
string s = String.Format("Caught an exception while recovering queue {0}: {1}",
oldName, cause.Message);
HandleTopologyRecoveryException(new TopologyRecoveryException(s, cause));
}
}
}
}
void OnCallbackException(object sender, CallbackExceptionEventArgs e)
{
logger.Info("Se inicia la ejecución del event handler OnCallbackException");
logger.Debug("Argumentos del event handler OnCallbackException: sender - {}, eventArgs - {}",
sender, e);
if (_disposed)
{
logger.Trace("La instancia ha sido dispuesta, se finaliza la ejecución el event handler");
return;
}
logger.Warn("La conexión al Message Broker ha lanzado una excepción, intentando conectar");
TryConnect();
}
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));
}
}
private void RunRecoveryEventHandlers()
{
foreach (EventHandler <EventArgs> reh in Recovery?.GetInvocationList() ?? Array.Empty <Delegate>())
{
try
{
reh(this, EventArgs.Empty);
}
catch (Exception e)
{
var args = new CallbackExceptionEventArgs(e);
args.Detail["context"] = "OnModelRecovery";
_delegate.OnCallbackException(args);
}
}
}
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>
/// 消费回调以后的异常函数
/// </summary>
/// <param name="sender"></param>
/// <param name="ea"></param>
private void OnConsumerMessageException(object sender, CallbackExceptionEventArgs ea)
{
consumerchannel.Close();
consumerchannel = null;
var mres = new ManualResetEventSlim(false);
while (!mres.Wait(3000))
{
try
{
if (!rabbitMQPersistentConnection.IsConnected)
{
rabbitMQPersistentConnection.TryConnect();
}
consumerchannel = rabbitMQPersistentConnection.CreateModel();
consumerchannel.ExchangeDeclare("order", "direct", true, false);
consumerchannel.QueueDeclare("order", true, false, false);
consumerchannel.QueueBind("order", "order", "order");
var retryArgs = new Dictionary <string, object>
{
{ "x-dead-letter-exchange", "order" },
{ "x-dead-letter-routing-key", "order" }
};
consumerchannel.ExchangeDeclare("order" + ".retry", "direct", true, false);
consumerchannel.QueueDeclare("order" + ".retry", true, false, false, retryArgs);
consumerchannel.QueueBind("order" + ".retry", "order" + ".retry", "order" + ".retry");
var consumer = new EventingBasicConsumer(consumerchannel);
consumer.Received += OnConsumerMessage;
consumerchannel.BasicConsume("order", false, consumer);
consumerchannel.CallbackException += OnConsumerMessageException;
mres.Set();
}
catch (Exception ex)
{
throw new Exception("rabbitMQ宕机了", ex);
}
}
}
protected void RecoverConsumers()
{
var dict = new Dictionary <string, RecordedConsumer>(m_recordedConsumers);
foreach (KeyValuePair <string, RecordedConsumer> pair in dict)
{
string tag = pair.Key;
RecordedConsumer cons = pair.Value;
try
{
string newTag = cons.Recover();
lock (m_recordedConsumers)
{
// make sure server-generated tags are re-added
m_recordedConsumers.Remove(tag);
m_recordedConsumers.Add(newTag, cons);
}
if (m_consumerTagChange != null)
{
foreach (EventHandler <ConsumerTagChangedAfterRecoveryEventArgs> h in m_consumerTagChange.GetInvocationList())
{
try
{
var eventArgs = new ConsumerTagChangedAfterRecoveryEventArgs(tag, newTag);
h(this, eventArgs);
}
catch (Exception e)
{
var args = new CallbackExceptionEventArgs(e);
args.Detail["context"] = "OnConsumerRecovery";
m_delegate.OnCallbackException(args);
}
}
}
}
catch (Exception cause)
{
string s = String.Format("Caught an exception while recovering consumer {0} on queue {1}: {2}",
tag, cons.Queue, cause.Message);
HandleTopologyRecoveryException(new TopologyRecoveryException(s, cause));
}
}
}
///<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));
}
});
}
protected bool RecoverConnectionDelegate()
{
while (!ManuallyClosed)
{
try
{
var fh = endpoints.SelectOne(m_factory.CreateFrameHandler);
m_delegate = new Connection(m_factory, false, fh, this.ClientProvidedName);
return(true);
}
catch (Exception e)
{
ESLog.Error("Connection recovery exception.", e);
// Trigger recovery error events
var handler = m_connectionRecoveryError;
if (handler != null)
{
var args = new ConnectionRecoveryErrorEventArgs(e);
foreach (EventHandler <ConnectionRecoveryErrorEventArgs> h in handler.GetInvocationList())
{
try
{
h(this, args);
}
catch (Exception ex)
{
var a = new CallbackExceptionEventArgs(ex);
a.Detail["context"] = "OnConnectionRecoveryError";
m_delegate.OnCallbackException(a);
}
}
}
#if NETFX_CORE
System.Threading.Tasks.Task.Delay(m_factory.NetworkRecoveryInterval).Wait();
#else
Thread.Sleep(m_factory.NetworkRecoveryInterval);
#endif
}
}
return(false);
}