public void Should_unsubscribe_to_ConnectionEstablished_event() { var connectionFactory = new ManagedConnectionFactory { HostName = "localhost", Port = 5672, VirtualHost = "/", UserName = "******", Password = "******" }; var connection = new HaConnection(Substitute.For<IRetryPolicy>(), Substitute.For<IRabbitWatcher>(), new List<ManagedConnectionFactory> { connectionFactory }); var fired = false; connection.Connected += () => { fired = true; }; ManagedConnectionFactory.ConnectionEstablished += (a, b) => { }; //NOTE: To make it not null connection.Dispose(); var model = Substitute.For<IModel>(); model.IsOpen.Returns(true); var c = Substitute.For<IConnection>(); c.CreateModel().Returns(model); c.IsOpen.Returns(true); c.Endpoint.Returns(connectionFactory.Endpoint); ManagedConnectionFactory.SharedConnections[connectionFactory.Endpoint + connectionFactory.VirtualHost] = c; ManagedConnectionFactory.ConnectionEstablished.Invoke(new AmqpTcpEndpoint("localhost"), "/"); Assert.IsFalse(fired); }
/// <summary> /// Create queues required by Burrow.RPC library /// </summary> /// <param name="connectionString"></param> /// <param name="createExchangesAndQueues"></param> public void CreateQueues(string connectionString, Action<IModel> createExchangesAndQueues) { var clusterConnections = connectionString.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries); if (clusterConnections.Length > 1) { Global.DefaultWatcher.InfoFormat("Found multiple Connection String, will use '{0}' to setup queues", clusterConnections[0]); } ConnectionString connectionValues = clusterConnections.Length > 1 ? new ConnectionString(clusterConnections[0]) : new ConnectionString(connectionString); var connectionFactory = new ManagedConnectionFactory { HostName = connectionValues.Host, Port = connectionValues.Port, VirtualHost = connectionValues.VirtualHost, UserName = connectionValues.UserName, Password = connectionValues.Password, }; using (var connection = connectionFactory.CreateConnection()) { using (var model = connection.CreateModel()) { try { createExchangesAndQueues(model); } catch (OperationInterruptedException oie) { if (oie.ShutdownReason.ReplyText.StartsWith("PRECONDITION_FAILED - ")) { Global.DefaultWatcher.ErrorFormat(oie.ShutdownReason.ReplyText); } else { Global.DefaultWatcher.Error(oie); } } catch (Exception ex) { Global.DefaultWatcher.Error(ex); } } } }
/// <summary> /// Initialize a <see cref="DurableConnection"/> object /// </summary> /// <param name="retryPolicy"></param> /// <param name="watcher"></param> /// <param name="connectionFactory"></param> public DurableConnection(IRetryPolicy retryPolicy, IRabbitWatcher watcher, ConnectionFactory connectionFactory) { if (retryPolicy == null) { throw new ArgumentNullException("retryPolicy"); } if (watcher == null) { throw new ArgumentNullException("watcher"); } if (connectionFactory == null) { throw new ArgumentNullException("connectionFactory"); } _retryPolicy = retryPolicy; _watcher = watcher; _connectionFactory = ManagedConnectionFactory.CreateFromConnectionFactory(connectionFactory); }
public void Should_copy_all_value_from_privided_factory() { // Arrange var originalFactory = new ConnectionFactory { HostName = "localhost", Port = 5672, VirtualHost = "/", UserName = "******", Password = "******" }; // Action var factory = new ManagedConnectionFactory(originalFactory); // Assert Assert.AreEqual(JsonConvert.SerializeObject(originalFactory), JsonConvert.SerializeObject(factory)); }
public override ITunnel Create(string hostName, int port, string virtualHost, string username, string password, IRabbitWatcher watcher) { if (RabbitTunnel.Factory is DependencyInjectionTunnelFactory) { return RabbitTunnel.Factory.Create(hostName, port, virtualHost, username, password, watcher); } var rabbitWatcher = watcher ?? Global.DefaultWatcher; var connectionFactory = new ManagedConnectionFactory { HostName = hostName, Port = port, VirtualHost = virtualHost, UserName = username, Password = password }; var durableConnection = new DurableConnection(new DefaultRetryPolicy(), rabbitWatcher, connectionFactory); return Create(durableConnection, rabbitWatcher); }
/// <summary> /// Initialize a <see cref="DurableConnection"/> object /// </summary> /// <param name="retryPolicy"></param> /// <param name="watcher"></param> /// <param name="connectionFactory"></param> public DurableConnection(IRetryPolicy retryPolicy, IRabbitWatcher watcher, ConnectionFactory connectionFactory) : this(retryPolicy, watcher) { if (connectionFactory == null) { throw new ArgumentNullException(nameof(connectionFactory)); } _connectionFactory = ManagedConnectionFactory.CreateFromConnectionFactory(connectionFactory); ConnectionEstablished handler = (endpoint, virtualHost) => { if (_connectionFactory.Endpoint + _connectionFactory.VirtualHost == endpoint + virtualHost) { //NOTE: Fire connected event whenever a new connection to 1 of the servers in the cluster is made FireConnectedEvent(); } }; ManagedConnectionFactory.ConnectionEstablished += handler; _unsubscribeEvents = () => { ManagedConnectionFactory.ConnectionEstablished -= handler; }; }
/// <summary> /// Create a tunnel with provided params /// </summary> /// <param name="hostName"></param> /// <param name="port"></param> /// <param name="virtualHost"></param> /// <param name="username"></param> /// <param name="password"></param> /// <param name="watcher"></param> /// <returns></returns> public virtual ITunnel Create(string hostName, int port, string virtualHost, string username, string password, IRabbitWatcher watcher) { var connectionFactory = new ManagedConnectionFactory { HostName = hostName, Port = port, VirtualHost = virtualHost, UserName = username, Password = password }; return Create(connectionFactory, watcher); }