Reverting changeset erroneously commited on wrong branch

Author: Matthew Sackman

projects/client/RabbitMQ.Client/src/client/api/AMQPParameters.cs

@@ -90,27 +90,11 @@ public class AMQPParameters : ICloneable
         private uint m_requestedFrameMax = DefaultFrameMax;
         private ushort m_requestedHeartbeat = DefaultHeartbeat;
         private SslOption m_ssl = new SslOption();
-        private IProtocol m_protocol;
 
         ///<summary>Construct a fresh instance, with all fields set to
         ///their respective defaults.</summary>
         public AMQPParameters() { }
 
-        ///<summary>Retrieve or set the IProtocol of this AmqpTcpEndpoint.</summary>
-        public IProtocol Protocol
-        {
-            get { return m_protocol; }
-            set { m_protocol = value; }
-        }
-
-        private string m_hostName;
-        ///<summary>Retrieve or set the hostname of this AmqpTcpEndpoint.</summary>
-        public string HostName
-        {
-            get { return m_hostName; }
-            set { m_hostName = value; }
-        }
-
         /// <summary>Username to use when authenticating to the server</summary>
         public string UserName
         {

projects/client/RabbitMQ.Client/src/client/api/ConnectionFactory.cs

@@ -103,8 +103,17 @@ namespace RabbitMQ.Client
     ///</remarks>
     public class ConnectionFactory
     {
-        public ConnectionParameters[] ConnectionParameters = { new ConnectionParameters() };
-        
+        private AMQPParameters m_parameters = new AMQPParameters();
+        ///<summary>Retrieve the parameters this factory uses to
+        ///construct IConnection instances.</summary>
+        public AMQPParameters Parameters
+        {
+            get
+            {
+                return m_parameters;
+            }
+        }
+
         ///<summary>Constructs a ConnectionFactory with default values
         ///for Parameters.</summary>
         public ConnectionFactory()
@@ -115,10 +124,10 @@ protected virtual IConnection FollowRedirectChain
             (int maxRedirects,
              IDictionary connectionAttempts,
              IDictionary connectionErrors,
-             ref ConnectionParameters[] mostRecentKnownHosts,
-             ConnectionParameters endpoint)
+             ref AmqpTcpEndpoint[] mostRecentKnownHosts,
+             AmqpTcpEndpoint endpoint)
         {
-            ConnectionParameters candidate = endpoint;
+            AmqpTcpEndpoint candidate = endpoint;
             try {
                 while (true) {
                     int attemptCount =
@@ -129,13 +138,13 @@ protected virtual IConnection FollowRedirectChain
                     bool insist = attemptCount >= maxRedirects;
 
                     try {
-                        IProtocol p = candidate.AMQP.Protocol;
-                        IFrameHandler fh = p.CreateFrameHandler(candidate.TCP);
+                        IProtocol p = candidate.Protocol;
+                        IFrameHandler fh = p.CreateFrameHandler(candidate);
                         // At this point, we may be able to create
                         // and fully open a successful connection,
                         // in which case we're done, and the
                         // connection should be returned.
-                        return p.CreateConnection(candidate.AMQP, insist, fh);
+                        return p.CreateConnection(m_parameters, insist, fh);
                     } catch (RedirectException re) {
                         if (insist) {
                             // We've been redirected, but we insisted that
@@ -151,12 +160,9 @@ protected virtual IConnection FollowRedirectChain
                             // mostRecentKnownHosts (in case the chain
                             // runs out), and updating candidate for the
                             // next time round the loop.
-                            connectionErrors[candidate] = re;      
-                            mostRecentKnownHosts = new ConnectionParameters[re.KnownHosts.Length];
-                            for(int i = 0; i < re.KnownHosts.Length; i++){
-                              mostRecentKnownHosts[i] = new ConnectionParameters(candidate.AMQP, re.KnownHosts[i]);
-                            }
-                            candidate = new ConnectionParameters(candidate.AMQP, re.Host);
+                            connectionErrors[candidate] = re;
+                            mostRecentKnownHosts = re.KnownHosts;
+                            candidate = re.Host;
                         }
                     }
                 }
@@ -169,14 +175,13 @@ protected virtual IConnection FollowRedirectChain
         protected virtual IConnection CreateConnection(int maxRedirects,
                                                        IDictionary connectionAttempts,
                                                        IDictionary connectionErrors,
-                                                       ConnectionParameters[] endpoints)
+                                                       params AmqpTcpEndpoint[] endpoints)
         {
-            foreach (ConnectionParameters endpoint in endpoints)
+            foreach (AmqpTcpEndpoint endpoint in endpoints)
             {
-                ConnectionParameters[] mostRecentKnownHosts = new ConnectionParameters[0];
+                AmqpTcpEndpoint[] mostRecentKnownHosts = new AmqpTcpEndpoint[0];
                 // ^^ holds a list of known-hosts that came back with
-                // a connection.redirect, together with the AMQPParameters
-                // used for that connection attempt. If, once we reach the end of
+                // a connection.redirect. If, once we reach the end of
                 // a chain of redirects, we still haven't managed to
                 // get a usable connection, we recurse on
                 // mostRecentKnownHosts, trying each of those in
@@ -225,14 +230,15 @@ protected virtual IConnection CreateConnection(int maxRedirects,
         ///endpoint in the list provided. Up to a maximum of
         ///maxRedirects broker-originated redirects are permitted for
         ///each endpoint tried.</summary>
-        public virtual IConnection CreateConnection(int maxRedirects)
+        public virtual IConnection CreateConnection(int maxRedirects,
+                                                    params AmqpTcpEndpoint[] endpoints)
         {
             IDictionary connectionAttempts = new Hashtable();
             IDictionary connectionErrors = new Hashtable();
             IConnection conn = CreateConnection(maxRedirects,
                                                 connectionAttempts,
                                                 connectionErrors,
-                                                ConnectionParameters);
+                                                endpoints);
             if (conn != null) {
                 return conn;
             }
@@ -242,9 +248,61 @@ public virtual IConnection CreateConnection(int maxRedirects)
         ///<summary>Create a connection to the first available
         ///endpoint in the list provided. No broker-originated
         ///redirects are permitted.</summary>
-        public virtual IConnection CreateConnection()
+        public virtual IConnection CreateConnection(params AmqpTcpEndpoint[] endpoints)
         {
-            return CreateConnection(0);
+            return CreateConnection(0, endpoints);
+        }
+
+        ///<summary>Create a connection to the endpoint specified.</summary>
+        ///<exception cref="ArgumentException"/>
+        public IConnection CreateConnection(IProtocol version,
+                                            string hostName,
+                                            int portNumber)
+        {
+            return CreateConnection(new AmqpTcpEndpoint(version,
+                                                        hostName,
+                                                        portNumber,
+                                                        m_parameters.Ssl));
+        }
+
+        ///<summary>Create a connection to the endpoint specified. The
+        ///port used is the default for the protocol.</summary>
+        ///<exception cref="ArgumentException"/>
+        public IConnection CreateConnection(IProtocol version, string hostName)
+        {
+            return CreateConnection(new AmqpTcpEndpoint(version, hostName));
+        }
+
+        ///<summary>Create a connection to the endpoint specified.</summary>
+        ///<remarks>
+        /// Please see the class overview documentation for
+        /// information about the Uri format in use.
+        ///</remarks>
+        ///<exception cref="ArgumentException"/>
+        public IConnection CreateConnection(IProtocol version, Uri uri)
+        {
+            return CreateConnection(new AmqpTcpEndpoint(version, uri));
+        }
+
+        ///<summary>Create a connection to the endpoint specified,
+        ///with the IProtocol from
+        ///Protocols.FromEnvironment().</summary>
+        ///<remarks>
+        /// Please see the class overview documentation for
+        /// information about the Uri format in use.
+        ///</remarks>
+        public IConnection CreateConnection(Uri uri)
+        {
+            return CreateConnection(new AmqpTcpEndpoint(uri));
+        }
+
+        ///<summary>Create a connection to the host (and optional
+        ///port) specified, with the IProtocol from
+        ///Protocols.FromEnvironment(). The format of the address
+        ///string is the same as that accepted by
+        ///AmqpTcpEndpoint.Parse().</summary>
+        public IConnection CreateConnection(string address) {
+            return CreateConnection(AmqpTcpEndpoint.Parse(Protocols.FromEnvironment(), address));
         }
     }
 }