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 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; }