A simple wrapper of ConnectionFactory which will store any created IConnection to memory and share them within the AppDomain. The purpose of this is keeping the amount of connection to RabbitMQ server as low as possible
Inheritance: RabbitMQ.Client.ConnectionFactory
Example #1
0
        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);
        }
Example #2
0
        /// <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);
                    }
                }
            }
        }
Example #3
0
        /// <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);
        }
Example #4
0
        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; };
        }
Example #7
0
 /// <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);
 }