public TwoWayRemoteCallInterceptor(IOutputChannel channel, IMessageDispatcher messageDispatcher, IMessageFactory messageFactory, string interfaceName, RemoteExecutionPolicies policies)
{
_interfaceName = interfaceName;
_channel = channel;
_durableConnection = _channel as IDurableConnection;
_messageDispatcher = messageDispatcher;
_policies = policies;
_messageFactory = messageFactory;
GenerateNewCancellationToken();
if (_durableConnection != null)
{
_durableConnection.ConnectionAborted += () =>
{
_tokenSource.Aborted = true;
_tokenSource.Cancel();
};
_durableConnection.ConnectionRestored += () =>
{
_tokenSource.Restored = true;
_tokenSource.Cancel();
GenerateNewCancellationToken();
};
_durableConnection.ConnectionInterrupted += () =>
{
_tokenSource.Cancel();
GenerateNewCancellationToken();
};
}
}
public static RabbitTunnel CreateTunnel(IModel channel, out IDurableConnection durableConnection, bool isChannelOpen = true)
{
if (channel != null)
{
channel.IsOpen.Returns(isChannelOpen);
}
var routeFinder = Substitute.For<IRouteFinder>();
routeFinder.FindQueueName<Customer>(null).ReturnsForAnyArgs("Queue");
durableConnection = Substitute.For<IDurableConnection>();
//durableConnection.ConnectionFactory.Returns(Substitute.For<ConnectionFactory>());
var conn = durableConnection;
durableConnection.When(x => x.Connect()).Do(callInfo => // Because this is a mock objectd
{
//Rase connected event
conn.Connected += Raise.Event<Action>();
conn.IsConnected.Returns(true);
});
durableConnection.CreateChannel().Returns(channel);
var tunnel = new RabbitTunnelForTest(routeFinder, durableConnection);
tunnel.OnOpened += () => { };
tunnel.OnClosed += () => { };
return tunnel;
}
public static RabbitTunnel CreateTunnel(IModel channel, out IDurableConnection durableConnection, bool isChannelOpen = true)
{
if (channel != null)
{
channel.IsOpen.Returns(isChannelOpen);
}
var routeFinder = Substitute.For <IRouteFinder>();
routeFinder.FindQueueName <Customer>(null).ReturnsForAnyArgs("Queue");
durableConnection = Substitute.For <IDurableConnection>();
//durableConnection.ConnectionFactory.Returns(Substitute.For<ConnectionFactory>());
var conn = durableConnection;
durableConnection.When(x => x.Connect()).Do(callInfo => // Because this is a mock objectd
{
//Rase connected event
conn.Connected += Raise.Event <Action>();
conn.IsConnected.Returns(true);
});
durableConnection.CreateChannel().Returns(channel);
var tunnel = new RabbitTunnelForTest(routeFinder, durableConnection);
tunnel.OnOpened += () => { };
tunnel.OnClosed += () => { };
return(tunnel);
}
private string CreateConnectionCheckMessage(IDurableConnection durableConnection)
{
return
("Please check connection string and that the RabbitMQ Service is running at the specified endpoint.\n" +
$"\tHostname: '{durableConnection.HostName}'\n" +
$"\tVirtualHost: '{durableConnection.VirtualHost}'\n" +
$"\tUserName: '******'\n" +
"Failed to write error message to error queue");
}
public RabbitTunnelWithPriorityQueuesSupport(IConsumerManager consumerManager,
IRabbitWatcher watcher,
IRouteFinder routeFinder,
IDurableConnection connection,
ISerializer serializer,
ICorrelationIdGenerator correlationIdGenerator,
bool setPersistent)
: base(consumerManager, watcher, routeFinder, connection, serializer, correlationIdGenerator, setPersistent)
{
_priorityConsumerManager = new PriorityConsumerManager(watcher, consumerManager.MessageHandlerFactory, serializer);
}
private IDurableConnection CreateConnection()
{
lock (_syncObj)
{
if (_connection == null || !_connection.IsConnected)
{
var clusterConnections = _connectionString.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
var factories = clusterConnections.Select(x => new ManagedConnectionFactory(new ConnectionString(x))).ToList();
_connection = new HaConnection(new DefaultRetryPolicy(), Global.DefaultWatcher, factories);
_connection.Connect();
}
return(_connection);
}
}
public RabbitTunnelWithPriorityQueuesSupport(IRouteFinder routeFinder, IDurableConnection connection)
: this(new ConsumerManager(Global.DefaultWatcher,
new DefaultMessageHandlerFactory(new ConsumerErrorHandler(connection.ConnectionFactory,
Global.DefaultSerializer,
Global.DefaultWatcher),
Global.DefaultSerializer,
Global.DefaultWatcher),
Global.DefaultSerializer),
Global.DefaultWatcher,
routeFinder,
connection,
Global.DefaultSerializer,
Global.DefaultCorrelationIdGenerator,
Global.DefaultPersistentMode)
{
}
private ITunnel Create(IDurableConnection durableConnection, IRabbitWatcher rabbitWatcher)
{
var errorHandler = new ConsumerErrorHandler(durableConnection, Global.DefaultSerializer, rabbitWatcher);
var msgHandlerFactory = new DefaultMessageHandlerFactory(errorHandler, Global.DefaultSerializer, rabbitWatcher);
var consumerManager = new ConsumerManager(rabbitWatcher, msgHandlerFactory, Global.DefaultSerializer);
var tunnel = new RabbitTunnel(consumerManager,
rabbitWatcher,
new DefaultRouteFinder(),
durableConnection,
Global.DefaultSerializer,
Global.DefaultCorrelationIdGenerator,
Global.DefaultPersistentMode);
tunnel.AddSerializerObserver(errorHandler);
tunnel.AddSerializerObserver(msgHandlerFactory);
tunnel.AddSerializerObserver(consumerManager);
return(tunnel);
}
/// <summary>
/// Initialize an error handler
/// </summary>
/// <param name="durableConnection"></param>
/// <param name="serializer"></param>
/// <param name="watcher"></param>
public ConsumerErrorHandler(IDurableConnection durableConnection, ISerializer serializer, IRabbitWatcher watcher)
{
if (durableConnection == null)
{
throw new ArgumentNullException(nameof(durableConnection));
}
if (serializer == null)
{
throw new ArgumentNullException(nameof(serializer));
}
if (watcher == null)
{
throw new ArgumentNullException(nameof(watcher));
}
_durableConnection = durableConnection;
_serializer = serializer;
_watcher = watcher;
_errorQueue = Global.DefaultErrorQueueName ?? "Burrow.Queue.Error";
_errorExchange = Global.DefaultErrorExchangeName ?? "Burrow.Exchange.Error";
}
/// <summary>
/// Create a tunnel by <see cref="IConsumerManager"/>, <see cref="IRouteFinder"/>, <see cref="IDurableConnection"/>, <see cref="ISerializer"/> and <see cref="ICorrelationIdGenerator"/>
/// </summary>
/// <param name="consumerManager"></param>
/// <param name="watcher"></param>
/// <param name="routeFinder"></param>
/// <param name="connection"></param>
/// <param name="serializer"></param>
/// <param name="correlationIdGenerator"></param>
/// <param name="setPersistent"></param>
public RabbitTunnel(IConsumerManager consumerManager,
IRabbitWatcher watcher,
IRouteFinder routeFinder,
IDurableConnection connection,
ISerializer serializer,
ICorrelationIdGenerator correlationIdGenerator,
bool setPersistent)
{
if (consumerManager == null)
{
throw new ArgumentNullException("consumerManager");
}
if (watcher == null)
{
throw new ArgumentNullException("watcher");
}
if (connection == null)
{
throw new ArgumentNullException("connection");
}
if (correlationIdGenerator == null)
{
throw new ArgumentNullException("correlationIdGenerator");
}
_consumerManager = consumerManager;
_watcher = watcher;
_connection = connection;
_correlationIdGenerator = correlationIdGenerator;
_observers = new ConcurrentBag <IObserver <ISerializer> >();
SetRouteFinder(routeFinder);
SetSerializer(serializer);
SetPersistentMode(setPersistent);
_connection.Connected += OpenTunnel;
_connection.Disconnected += CloseTunnel;
_subscribeActions = new ConcurrentDictionary <Guid, Action>();
}
public RabbitTunnelWithPriorityQueuesSupportForTest(IConsumerManager consumerManager, IRabbitWatcher watcher, IRouteFinder routeFinder, IDurableConnection connection, ISerializer serializer, ICorrelationIdGenerator correlationIdGenerator, bool setPersistent)
: base(consumerManager, watcher, routeFinder, connection, serializer, correlationIdGenerator, setPersistent)
{
}
public RabbitTunnelWithPriorityQueuesSupportForTest(IRouteFinder routeFinder, IDurableConnection connection)
: base(routeFinder, connection)
{
}
public RabbitTunnelWithPriorityQueuesSupportForTest(IRouteFinder routeFinder, IDurableConnection connection)
: base(routeFinder, connection)
{
}
public RabbitTunnelForTest(IConsumerManager consumerManager, IRabbitWatcher watcher, IRouteFinder routeFinder, IDurableConnection connection, ISerializer serializer, ICorrelationIdGenerator correlationIdGenerator, bool setPersistent)
: base(consumerManager, watcher, routeFinder, connection, serializer, correlationIdGenerator, setPersistent)
{
}
public RabbitTunnelForTest(IRouteFinder routeFinder, IDurableConnection connection) : base(routeFinder, connection)
{
}
private ITunnel Create(IDurableConnection durableConnection, IRabbitWatcher rabbitWatcher)
{
var errorHandler = new ConsumerErrorHandler(durableConnection, Global.DefaultSerializer, rabbitWatcher);
var msgHandlerFactory = new DefaultMessageHandlerFactory(errorHandler, Global.DefaultSerializer, rabbitWatcher);
var consumerManager = new ConsumerManager(rabbitWatcher, msgHandlerFactory, Global.DefaultSerializer);
var tunnel = new RabbitTunnel(consumerManager,
rabbitWatcher,
new DefaultRouteFinder(),
durableConnection,
Global.DefaultSerializer,
Global.DefaultCorrelationIdGenerator,
Global.DefaultPersistentMode);
tunnel.AddSerializerObserver(errorHandler);
tunnel.AddSerializerObserver(msgHandlerFactory);
tunnel.AddSerializerObserver(consumerManager);
return tunnel;
}
public RabbitTunnelForTest(IRouteFinder routeFinder, IDurableConnection connection) : base(routeFinder, connection)
{
}
