public void SetUp()
{
advancedBusEventHandlers = new AdvancedBusEventHandlers(
connected: (s, e) => connectedCalled = true,
disconnected: (s, e) => disconnectedCalled = true,
blocked: (s, e) =>
{
blockedCalled = true;
connectionBlockedEventArgs = e;
},
unblocked: (s, e) => unBlockedCalled = true,
messageReturned: (s, e) =>
{
messageReturnedCalled = true;
messageReturnedEventArgs = e;
});
var connectionFactory = MockRepository.GenerateStub<IConnectionFactory>();
connectionFactory.Stub(x => x.Succeeded).Return(true);
connectionFactory.Stub(x => x.CreateConnection()).Return(MockRepository.GenerateStub<IConnection>());
connectionFactory.Stub(x => x.CurrentHost).Return(new HostConfiguration());
connectionFactory.Stub(x => x.Configuration).Return(new ConnectionConfiguration());
eventBus = new EventBus();
var advancedBus = new RabbitAdvancedBus(
connectionFactory,
MockRepository.GenerateStub<IConsumerFactory>(),
MockRepository.GenerateStub<IEasyNetQLogger>(),
MockRepository.GenerateStub<IClientCommandDispatcherFactory>(),
MockRepository.GenerateStub<IPublishConfirmationListener>(),
eventBus,
MockRepository.GenerateStub<IHandlerCollectionFactory>(),
MockRepository.GenerateStub<IContainer>(),
MockRepository.GenerateStub<ConnectionConfiguration>(),
MockRepository.GenerateStub<IProduceConsumeInterceptor>(),
MockRepository.GenerateStub<IMessageSerializationStrategy>(),
MockRepository.GenerateStub<IConventions>(),
advancedBusEventHandlers);
}
void OnConnectionBlocked(object sender, ConnectionBlockedEventArgs e)
{
logger.InfoWrite("Connection blocked. Reason: '{0}'", e.Reason);
eventBus.Publish(new ConnectionBlockedEvent(e.Reason));
}
public void HandleConnectionBlocked(string reason)
{
var args = new ConnectionBlockedEventArgs(reason);
OnConnectionBlocked(args);
}
public void OnConnectionBlocked(ConnectionBlockedEventArgs args)
{
EventHandler<ConnectionBlockedEventArgs> handler;
lock (m_eventLock)
{
handler = m_connectionBlocked;
}
if (handler != null)
{
foreach (EventHandler<ConnectionBlockedEventArgs> h in handler.GetInvocationList())
{
try
{
h(this, args);
}
catch (Exception e)
{
OnCallbackException(CallbackExceptionEventArgs.Build(e,
new Dictionary<string, object>
{
{"context", "OnConnectionBlocked"}
}));
}
}
}
}
void OnConnectionBlocked(IConnection sender, ConnectionBlockedEventArgs reason)
{
logger.InfoWrite("Connection blocked. Reason: '{0}'", reason.Reason);
eventBus.Publish(new ConnectionBlockedEvent(reason.Reason));
}
public void HandleBlocked(object sender, ConnectionBlockedEventArgs args)
{
Unblock();
}
private static void Connetion_ConnectionBlocked(object sender, RabbitMQ.Client.Events.ConnectionBlockedEventArgs e)
{
Console.WriteLine("Connetion_ConnectionBlocked");
}
public void OnConnectionBlocked(ConnectionBlockedEventArgs args)
{
ConnectionBlockedEventHandler handler;
lock (m_eventLock)
{
handler = m_connectionBlocked;
}
if (handler != null)
{
foreach (ConnectionBlockedEventHandler h in handler.GetInvocationList()) {
try {
h(this, args);
} catch (Exception e) {
CallbackExceptionEventArgs cee_args = new CallbackExceptionEventArgs(e);
cee_args.Detail["context"] = "OnConnectionBlocked";
OnCallbackException(cee_args);
}
}
}
}
private void Connection_ConnectionBlocked(object sender, ConnectionBlockedEventArgs e)
{
Console.WriteLine("[Error] Connection_ConnectionBlocked from rabbitMQ server.");
}
/// <summary>
/// 连接被阻止的异常
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Connection_ConnectionBlocked(object sender, RabbitMQ.Client.Events.ConnectionBlockedEventArgs e)
{
IsConnTryConn();
}
private void OnConnectionBlocked(object sender, ConnectionBlockedEventArgs e)
{
LogAdapter.LogWarn("Connection", "Connection blocked - broker running low on resources (memory or disk)");
}
