QPID-153 Initial port of URL parsing from Java client. Due to .NET Uri parser must support "host" name. Use "default" when you don't want to really supply one.

git-svn-id: https://svn.apache.org/repos/asf/incubator/qpid/trunk/qpid@482237 13f79535-47bb-0310-9956-ffa450edef68

4 files changed, 506 insertions, 127 deletions

diff --git a/dotnet/Qpid.Client/Client/AMQConnection.cs b/dotnet/Qpid.Client/Client/AMQConnection.cs
index 5c0537429e..1bfa3b4c26 100644
--- a/dotnet/Qpid.Client/Client/AMQConnection.cs
+++ b/dotnet/Qpid.Client/Client/AMQConnection.cs
@@ -128,7 +128,7 @@ namespace Qpid.Client
             }
             _log.Info("ConnectionInfo: " + connectionInfo);
             _connectionInfo = connectionInfo;
-            _log.Info("password = " + _connectionInfo.getPassword());
+            _log.Info("password = " + _connectionInfo.GetPassword());
             _failoverPolicy = new FailoverPolicy(connectionInfo);
 
             // We are not currently connected.
@@ -503,7 +503,7 @@ namespace Qpid.Client
         {
             get
             {
-                return _connectionInfo.getUsername();
+                return _connectionInfo.GetUsername();
             }
         }
 
@@ -511,7 +511,7 @@ namespace Qpid.Client
         {
             get
             {
-                return _connectionInfo.getPassword();
+                return _connectionInfo.GetPassword();
             }
         }
 
@@ -519,7 +519,7 @@ namespace Qpid.Client
         {
             get
             {
-                return _connectionInfo.getVirtualHost();
+                return _connectionInfo.GetVirtualHost();
             }
         }
 
@@ -796,7 +796,7 @@ namespace Qpid.Client
 
         public String toURL()
         {
-            return _connectionInfo.asUrl();
+            return _connectionInfo.AsUrl();
         }
 
         class HeartBeatThread
diff --git a/dotnet/Qpid.Client/Client/AMQDestination.cs b/dotnet/Qpid.Client/Client/AMQDestination.cs
index 7ea6db4ee8..e2c4778a28 100644
--- a/dotnet/Qpid.Client/Client/AMQDestination.cs
+++ b/dotnet/Qpid.Client/Client/AMQDestination.cs
@@ -33,6 +33,7 @@ namespace Qpid.Client
 
         public bool IsDurable
         {
+           
             get { return _isDurable; }
         }
 
diff --git a/dotnet/Qpid.Client/Client/AmqBrokerInfo.cs b/dotnet/Qpid.Client/Client/AmqBrokerInfo.cs
index 88569b4fc0..3fc2512efb 100644
--- a/dotnet/Qpid.Client/Client/AmqBrokerInfo.cs
+++ b/dotnet/Qpid.Client/Client/AmqBrokerInfo.cs
@@ -28,7 +28,7 @@ namespace Qpid.Client
     public class AmqBrokerInfo : BrokerInfo
     {
         public readonly string URL_FORMAT_EXAMPLE =
-            "<transport>://<hostname>[:<port Default=\""+BrokerDetailsConstants.DEFAULT_PORT+"\">][?<option>='<value>'[,<option>='<value>']]";
+            "<transport>://<hostname>[:<port Default=\""+BrokerInfoConstants.DEFAULT_PORT+"\">][?<option>='<value>'[,<option>='<value>']]";
 
         public const long DEFAULT_CONNECT_TIMEOUT = 30000L;
 
@@ -41,106 +41,133 @@ namespace Qpid.Client
         {
         }
 
-        // TODO: port URL parsing.
         public AmqBrokerInfo(string url)
         {
-            throw new NotImplementedException();
-//            this();
-//            // URL should be of format tcp://host:port?option='value',option='value'
-//            try
-//            {
-//                URI connection = new URI(url);
-//
-//                string transport = connection.getScheme();
-//
-//                // Handles some defaults to minimise changes to existing broker URLS e.g. localhost
-//                if (transport != null)
-//                {
-//                    //todo this list of valid transports should be enumerated somewhere
-//                    if ((!(transport.equalsIgnoreCase("vm") ||
-//                            transport.equalsIgnoreCase("tcp"))))
-//                    {
-//                        if (transport.equalsIgnoreCase("localhost"))
-//                        {
-//                            connection = new URI(DEFAULT_TRANSPORT + "://" + url);
-//                            transport = connection.getScheme();
-//                        }
-//                        else
-//                        {
-//                            if (url.charAt(transport.length()) == ':' && url.charAt(transport.length()+1) != '/' )
-//                            {
-//                                //Then most likely we have a host:port value
-//                                connection = new URI(DEFAULT_TRANSPORT + "://" + url);
-//                                transport = connection.getScheme();
-//                            }
-//                            else
-//                            {
-//                                URLHelper.parseError(0, transport.length(), "Unknown transport", url);
-//                            }
-//                        }
-//                    }
-//                }
-//                else
-//                {
-//                    //Default the transport
-//                    connection = new URI(DEFAULT_TRANSPORT + "://" + url);
-//                    transport = connection.getScheme();
-//                }
-//
-//                if (transport == null)
-//                {
-//                    URLHelper.parseError(-1, "Unknown transport:'" + transport + "'" +
-//                            " In broker URL:'" + url + "' Format: " + URL_FORMAT_EXAMPLE, "");
-//                }
-//
-//                setTransport(transport);
-//
-//                string host = connection.getHost();
-//
-//                // Fix for Java 1.5
-//                if (host == null)
-//                {
-//                    host = "";
-//                }
-//
-//                setHost(host);
-//
-//                int port = connection.getPort();
-//
-//                if (port == -1)
-//                {
-//                    // Another fix for Java 1.5 URI handling
-//                    string auth = connection.getAuthority();
-//
-//                    if (auth != null && auth.startsWith(":"))
-//                    {
-//                        setPort(Integer.parseInt(auth.substring(1)));
-//                    }
-//                    else
-//                    {
-//                        setPort(DEFAULT_PORT);
-//                    }
-//                }
-//                else
-//                {
-//                    setPort(port);
-//                }
-//
-//                string querystring = connection.getQuery();
-//
-//                URLHelper.parseOptions(_options, querystring);
-//
-//                //Fragment is #string (not used)
-//            }
-//            catch (URISyntaxException uris)
-//            {
-//                if (uris instanceof URLSyntaxException)
+            // URL should be of format tcp://host:port?option='value',option='value'
+            try
+            {
+                Uri connection = new Uri(url);
+
+                String transport = connection.Scheme;
+
+                // Handles some defaults to minimise changes to existing broker URLS e.g. localhost
+                if (transport != null)
+                {
+                    transport = transport.ToLower();
+                    //todo this list of valid transports should be enumerated somewhere
+                    if ((!(transport.Equals("vm") || transport.Equals("tcp"))))
+                    {
+                        if (transport.Equals("localhost"))
+                        {
+                            connection = new Uri(BrokerInfoConstants.DEFAULT_TRANSPORT + "://" + url);
+                            transport = connection.Scheme;
+                        }
+                        else
+                        {
+                            if (url[transport.Length] == ':' && url[transport.Length + 1] != '/')
+                            {
+                                //Then most likely we have a host:port value
+                                connection = new Uri(BrokerInfoConstants.DEFAULT_TRANSPORT + "://" + url);
+                                transport = connection.Scheme;
+                            }
+                            else
+                            {
+                                URLHelper.parseError(0, transport.Length, "Unknown transport", url);
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    //Default the transport
+                    connection = new Uri(BrokerInfoConstants.DEFAULT_TRANSPORT + "://" + url);
+                    transport = connection.Scheme;
+                }
+
+                if (transport == null)
+                {
+                    URLHelper.parseError(-1, "Unknown transport:'" + transport + "'" +
+                                             " In broker URL:'" + url + "' Format: " + URL_FORMAT_EXAMPLE, "");
+                }
+
+                setTransport(transport);
+
+                String host = connection.Host;
+                if (!host.Equals("default")) setHost(host);
+
+                int port = connection.Port;
+
+                if (port == -1)
+                {
+                    // Fix for when there is port data but it is not automatically parseable by getPort().
+                    String auth = connection.Authority;
+
+                    if (auth != null && auth.Contains(":"))
+                    {
+                        int start = auth.IndexOf(":") + 1;
+                        int end = start;
+                        bool looking = true;
+                        bool found = false;
+                        //Walk the authority looking for a port value.
+                        while (looking)
+                        {
+                            try
+                            {
+                                end++;
+                                int.Parse(auth.Substring(start, end-start+1));
+
+                                if (end >= auth.Length)
+                                {
+                                    looking = false;
+                                    found = true;
+                                }
+                            }
+                            catch (Exception nfe) // XXX: should catch only "NumberFormatException" here
+                            {
+                                looking = false;
+                            }
+
+                        }
+                        if (found)
+                        {
+                            setPort(int.Parse(auth.Substring(start, end-start+1)));
+                        }
+                        else
+                        {
+                            URLHelper.parseError(connection.ToString().IndexOf(connection.Authority) + end - 1,
+                                                 "Illegal character in port number", connection.ToString());
+                        }
+                    }
+                    else
+                    {
+                        setPort(BrokerInfoConstants.DEFAULT_PORT);
+                    }
+                }
+                else
+                {
+                    setPort(port);
+                }
+
+                String queryString = connection.Query;
+                if (queryString.Length > 0 && queryString[0] == '?')
+                {
+                    queryString = queryString.Substring(1);
+                }
+
+                URLHelper.parseOptions(_options, queryString);
+
+                //Fragment is #string (not used)
+            }
+            catch (UriFormatException uris)
+            {
+                throw uris;
+//                if (uris is UrlSyntaxException)
 //                {
-//                    throw (URLSyntaxException) uris;
+//                    throw uris;
 //                }
 //
 //                URLHelper.parseError(uris.getIndex(), uris.getReason(), uris.getInput());
-//            }
+            }
         }
 
         public AmqBrokerInfo(string transport, string host, int port, bool useSSL) : this()
@@ -151,7 +178,7 @@ namespace Qpid.Client
 
             if (useSSL)
             {
-                setOption(BrokerDetailsConstants.OPTIONS_SSL, "true");
+                setOption(BrokerInfoConstants.OPTIONS_SSL, "true");
             }
         }
 
@@ -197,11 +224,11 @@ namespace Qpid.Client
 
         public long getTimeout()
         {
-            if (_options.ContainsKey(BrokerDetailsConstants.OPTIONS_CONNECT_TIMEOUT))
+            if (_options.ContainsKey(BrokerInfoConstants.OPTIONS_CONNECT_TIMEOUT))
             {
                 try
                 {
-                    return long.Parse((string)_options[BrokerDetailsConstants.OPTIONS_CONNECT_TIMEOUT]);
+                    return long.Parse((string)_options[BrokerInfoConstants.OPTIONS_CONNECT_TIMEOUT]);
                 }
                 catch (FormatException)
                 {
@@ -209,12 +236,12 @@ namespace Qpid.Client
                 }
             }
 
-            return BrokerDetailsConstants.DEFAULT_CONNECT_TIMEOUT;
+            return BrokerInfoConstants.DEFAULT_CONNECT_TIMEOUT;
         }
 
         public void setTimeout(long timeout)
         {
-            setOption(BrokerDetailsConstants.OPTIONS_CONNECT_TIMEOUT, timeout.ToString());
+            setOption(BrokerInfoConstants.OPTIONS_CONNECT_TIMEOUT, timeout.ToString());
         }
 
         public override string ToString()
@@ -247,8 +274,9 @@ namespace Qpid.Client
 	
 	        BrokerInfo bd = (BrokerInfo) obj;
 	        return StringEqualsIgnoreCase(_host, bd.getHost()) &&
-	        	_port == bd.getPort();
-		}
+	        	_port == bd.getPort() &&
+                _transport == bd.getTransport();
+        }
     	
 		public override int GetHashCode()
 		{
@@ -296,9 +324,9 @@ namespace Qpid.Client
             // or simply force users to conform to OPTIONS_SSL
             // todo make case insensitive by trying ssl Ssl sSl ssL SSl SsL sSL SSL
 
-            if (_options.ContainsKey(BrokerDetailsConstants.OPTIONS_SSL))
+            if (_options.ContainsKey(BrokerInfoConstants.OPTIONS_SSL))
             {
-                return StringEqualsIgnoreCase((string)_options[BrokerDetailsConstants.OPTIONS_SSL], "true");
+                return StringEqualsIgnoreCase((string)_options[BrokerInfoConstants.OPTIONS_SSL], "true");
             }
 
             return false;
@@ -306,7 +334,7 @@ namespace Qpid.Client
 
         public void useSSL(bool ssl)
         {
-            setOption(BrokerDetailsConstants.OPTIONS_SSL, ssl.ToString());
+            setOption(BrokerInfoConstants.OPTIONS_SSL, ssl.ToString());
         }
     }
 }
diff --git a/dotnet/Qpid.Client/Client/QpidConnectionInfo.cs b/dotnet/Qpid.Client/Client/QpidConnectionInfo.cs
index f0c4c91db8..6c49a6c7ff 100644
--- a/dotnet/Qpid.Client/Client/QpidConnectionInfo.cs
+++ b/dotnet/Qpid.Client/Client/QpidConnectionInfo.cs
@@ -21,11 +21,341 @@
 using System;
 using System.Collections;
 using System.Net;
+using System.Text;
+using System.Text.RegularExpressions;
 using log4net;
 using Qpid.Client.qms;
 
 namespace Qpid.Client
 {
+
+    public class URLHelper
+    {
+        public static char DEFAULT_OPTION_SEPERATOR = '&';
+        public static char ALTERNATIVE_OPTION_SEPARATOR = ',';
+        public static char BROKER_SEPARATOR = ';';
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="optionMap"></param>
+        /// <param name="options"></param>
+        public static void parseOptions(IDictionary optionMap, string options)
+        {
+            //options looks like this
+            //brokerlist='tcp://host:port?option='value',option='value';vm://:3/virtualpath?option='value'',failover='method?option='value',option='value''
+
+            if (options == null || options.IndexOf('=') == -1)
+            {
+                return;
+            }
+
+            int optionIndex = options.IndexOf('=');
+
+            String option = options.Substring(0, optionIndex);
+
+            int length = options.Length;
+
+            int nestedQuotes = 0;
+
+            // to store index of final "'"
+            int valueIndex = optionIndex;
+
+            //Walk remainder of url.
+            while (nestedQuotes > 0 || valueIndex < length)
+            {
+                valueIndex++;
+
+                if (valueIndex >= length)
+                {
+                    break;
+                }
+
+                if (options[valueIndex] == '\'')
+                {
+                    if (valueIndex + 1 < options.Length)
+                    {
+                        if (options[valueIndex + 1] == DEFAULT_OPTION_SEPERATOR ||
+                                options[valueIndex + 1] == ALTERNATIVE_OPTION_SEPARATOR ||
+                                options[valueIndex + 1] == BROKER_SEPARATOR ||
+                                options[valueIndex + 1] == '\'')
+                        {
+                            nestedQuotes--;
+                            //                        System.out.println(
+                            //                                options + "\n" + "-" + nestedQuotes + ":" + getPositionString(valueIndex - 2, 1));
+                            if (nestedQuotes == 0)
+                            {
+                                //We've found the value of an option
+                                break;
+                            }
+                        }
+                        else
+                        {
+                            nestedQuotes++;
+                            //                        System.out.println(
+                            //                                options + "\n" + "+" + nestedQuotes + ":" + getPositionString(valueIndex - 2, 1));
+                        }
+                    }
+                    else
+                    {
+                        // We are at the end of the string
+                        // Check to see if we are corectly closing quotes
+                        if (options[valueIndex] == '\'')
+                        {
+                            nestedQuotes--;
+                        }
+
+                        break;
+                    }
+                }
+            }
+
+            if (nestedQuotes != 0 || valueIndex < (optionIndex + 2))
+            {
+                int sepIndex = 0;
+
+                //Try and identify illegal separator character
+                if (nestedQuotes > 1)
+                {
+                    for (int i = 0; i < nestedQuotes; i++)
+                    {
+                        sepIndex = options.IndexOf('\'', sepIndex);
+                        sepIndex++;
+                    }
+                }
+
+                if (sepIndex >= options.Length || sepIndex == 0)
+                {
+                    parseError(valueIndex, "Unterminated option", options);
+                }
+                else
+                {
+                    parseError(sepIndex, "Unterminated option. Possible illegal option separator:'" +
+                            options[sepIndex] + "'", options);
+                }
+            }
+
+            // optionIndex +2 to skip "='"
+            int sublen = valueIndex - (optionIndex + 2);
+            String value = options.Substring(optionIndex + 2, sublen);
+
+            optionMap.Add(option, value);
+
+            if (valueIndex < (options.Length - 1))
+            {
+                //Recurse to get remaining options
+                parseOptions(optionMap, options.Substring(valueIndex + 2));
+            }
+        }
+
+
+        public static void parseError(int index, String error, String url)
+        {
+            parseError(index, 1, error, url);
+        }
+
+        public static void parseError(int index, int length, String error, String url)
+        {
+            throw new UrlSyntaxException(url, error, index, length);
+        }
+
+        public static String printOptions(Hashtable options)
+        {
+            if (options.Count == 0)
+            {
+                return "";
+            }
+            else
+            {
+                StringBuilder sb = new StringBuilder();
+                sb.Append('?');
+                foreach (String key in options.Keys)
+                {
+                    sb.Append(key);
+
+                    sb.Append("='");
+
+                    sb.Append(options[key]);
+
+                    sb.Append("'");
+                    sb.Append(DEFAULT_OPTION_SEPERATOR);
+                }
+
+                sb.Remove(sb.Length - 1, 1);
+                //                sb.deleteCharAt(sb.length() - 1);
+
+                return sb.ToString();
+            }
+        }
+
+    }
+
+    public class QpidConnectionUrl
+    {
+        internal static ConnectionInfo FromUrl(string fullURL)
+        {
+            //_url = fullURL;
+            ConnectionInfo connectionInfo = new QpidConnectionInfo();
+
+
+            //            _options = new HashMap<String, String>();
+            //            _brokers = new LinkedList();
+            //            _failoverOptions = new HashMap<String, String>();
+
+            // Connection URL format
+            //amqp://[user:pass@][clientid]/virtualhost?brokerlist='tcp://host:port?option=\'value\',option=\'value\';vm://:3/virtualpath?option=\'value\'',failover='method?option=\'value\',option='value''"
+            // Options are of course optional except for requiring a single broker in the broker list.
+            try
+            {
+                Uri connection = new Uri(fullURL);
+
+                if (connection.Scheme == null || !(connection.Scheme.Equals(ConnectionUrlConstants.AMQ_PROTOCOL)))
+                {
+                    throw new UrlSyntaxException(fullURL, "Not an AMQP URL");
+                }
+
+                if (connection.Host != null && connection.Host.Length > 0 && !connection.Host.Equals("default"))
+                {
+                    connectionInfo.SetClientName(connection.Host);
+                }
+
+                String userInfo = connection.UserInfo;
+                if (userInfo == null || userInfo.Length == 0)
+                {
+                    URLHelper.parseError(ConnectionUrlConstants.AMQ_PROTOCOL.Length + 3,
+                            "User information not found on url", fullURL);
+                }
+                else
+                {
+                    parseUserInfo(userInfo, fullURL, connectionInfo);
+                }
+                String virtualHost = connection.AbsolutePath; // XXX: is AbsolutePath corrrect?
+
+                if (virtualHost != null && (!virtualHost.Equals("")))
+                {
+                    connectionInfo.SetVirtualHost(virtualHost);
+                }
+                else
+                {
+                    int authLength = connection.Authority.Length;
+                    int start = ConnectionUrlConstants.AMQ_PROTOCOL.Length + 3;
+                    int testIndex = start + authLength;
+                    if (testIndex < fullURL.Length && fullURL[testIndex] == '?')
+                    {
+                        URLHelper.parseError(start, testIndex - start, "Virtual host found", fullURL);
+                    }
+                    else
+                    {
+                        URLHelper.parseError(-1, "Virtual host not specified", fullURL);
+                    }
+
+                }
+
+                QpidConnectionInfo qci = (QpidConnectionInfo)connectionInfo;
+                string query = connection.Query;
+                if (query[0] == '?') query = query.Substring(1);
+                URLHelper.parseOptions(qci.GetOptions(), query);
+
+                processOptions(connectionInfo);
+
+                //Fragment is #string (not used)
+                //System.out.println(connection.getFragment());
+                return connectionInfo;
+            }
+            catch (UriFormatException uris)
+            {
+                throw uris;
+                //                if (uris is UrlSyntaxException)
+                //                {
+                //                    throw uris;
+                //                }
+                //
+                //                int slash = fullURL.IndexOf("\\");
+                //
+                //                if (slash == -1)
+                //                {
+                //                    URLHelper.parseError(uris.GetIndex(), uris.getReason(), uris.getInput());
+                //                }
+                //                else
+                //                {
+                //                    if (slash != 0 && fullURL.charAt(slash - 1) == ':')
+                //                    {
+                //                        URLHelper.parseError(slash - 2, fullURL.indexOf('?') - slash + 2, "Virtual host looks like a windows path, forward slash not allowed in URL", fullURL);
+                //                    }
+                //                    else
+                //                    {
+                //                        URLHelper.parseError(slash, "Forward slash not allowed in URL", fullURL);
+                //                    }
+                //                }
+            }
+        }
+
+        private static void parseUserInfo(String userinfo, string fullUrl, ConnectionInfo connectionInfo)
+        {
+            //user info = user:pass
+
+            int colonIndex = userinfo.IndexOf(':');
+
+            if (colonIndex == -1)
+            {
+                URLHelper.parseError(ConnectionUrlConstants.AMQ_PROTOCOL.Length + 3,
+                    userinfo.Length, "Null password in user information not allowed.", fullUrl);
+            }
+            else
+            {
+                connectionInfo.setUsername(userinfo.Substring(0, colonIndex));
+                connectionInfo.SetPassword(userinfo.Substring(colonIndex + 1));
+            }
+        }
+
+        private static void processOptions(ConnectionInfo connectionInfo)
+        {
+            string brokerlist = connectionInfo.GetOption(ConnectionUrlConstants.OPTIONS_BROKERLIST);
+            if (brokerlist != null)
+            {
+                //brokerlist tcp://host:port?option='value',option='value';vm://:3/virtualpath?option='value'
+                Regex splitter = new Regex("" + URLHelper.BROKER_SEPARATOR);
+
+                foreach (string broker in splitter.Split(brokerlist))
+                {
+                    connectionInfo.AddBrokerInfo(new AmqBrokerInfo(broker));
+                }
+
+                connectionInfo.SetOption(ConnectionUrlConstants.OPTIONS_BROKERLIST, null);
+                //                _options.remove(OPTIONS_BROKERLIST);
+            }
+
+            string failover = connectionInfo.GetOption(ConnectionUrlConstants.OPTIONS_FAILOVER);
+            if (failover != null)
+            {
+                // failover='method?option='value',option='value''
+
+                int methodIndex = failover.IndexOf('?');
+
+                if (methodIndex > -1)
+                {
+                    connectionInfo.SetFailoverMethod(failover.Substring(0, methodIndex));
+                    QpidConnectionInfo qpidConnectionInfo = (QpidConnectionInfo)connectionInfo;
+                    URLHelper.parseOptions(qpidConnectionInfo.GetFailoverOptions(),
+                        failover.Substring(methodIndex + 1));
+                }
+                else
+                {
+                    connectionInfo.SetFailoverMethod(failover);
+                }
+
+                connectionInfo.SetOption(ConnectionUrlConstants.OPTIONS_FAILOVER, null);
+                //                _options.remove(OPTIONS_FAILOVER);
+            }
+        }
+
+        internal static ConnectionInfo FromUri(Uri uri)
+        {
+            return null; // FIXME
+
+        }
+    }
+
     public class QpidConnectionInfo : ConnectionInfo
     {
         private static readonly ILog _logger = LogManager.GetLogger(typeof(QpidConnectionInfo));
@@ -40,7 +370,22 @@ namespace Qpid.Client
         IList _brokerInfos = new ArrayList(); // List<BrokerInfo>
         string _clientName = String.Format("{0}{1:G}", Dns.GetHostName(), DateTime.Now.Ticks);
 
-        public string asUrl()
+        public IDictionary GetFailoverOptions()
+        {
+            return _failoverOptions;
+        }
+
+        public IDictionary GetOptions()
+        {
+            return _options;
+        }
+
+        public static ConnectionInfo FromUrl(String url)
+        {
+            return QpidConnectionUrl.FromUrl(url);
+        }
+
+        public string AsUrl()
         {
             string result = "amqp://";
             foreach (BrokerInfo info in _brokerInfos)
@@ -48,25 +393,30 @@ namespace Qpid.Client
                 result += info.ToString();
             }
             return result;
-            
+
         }
 
-        public string getFailoverMethod()
+        public string GetFailoverMethod()
         {
             return _failoverMethod;
         }
 
-        public string getFailoverOption(string key)
+        public void SetFailoverMethod(string failoverMethod)
+        {
+            _failoverMethod = failoverMethod;
+        }
+
+        public string GetFailoverOption(string key)
         {
-            return (string) _failoverOptions[key];
+            return (string)_failoverOptions[key];
         }
 
-        public int getBrokerCount()
+        public int GetBrokerCount()
         {
             return _brokerInfos.Count;
         }
 
-        public BrokerInfo GetBrokerDetails(int index)
+        public BrokerInfo GetBrokerInfo(int index)
         {
             return (BrokerInfo)_brokerInfos[index];
         }
@@ -94,7 +444,7 @@ namespace Qpid.Client
             _clientName = clientName;
         }
 
-        public string getUsername()
+        public string GetUsername()
         {
             return _username;
         }
@@ -104,39 +454,39 @@ namespace Qpid.Client
             _username = username;
         }
 
-        public string getPassword()
+        public string GetPassword()
         {
             return _password;
         }
 
-        public void setPassword(string password)
+        public void SetPassword(string password)
         {
             _password = password;
         }
 
-        public string getVirtualHost()
+        public string GetVirtualHost()
         {
             return _virtualHost;
         }
 
-        public void setVirtualHost(string virtualHost)
+        public void SetVirtualHost(string virtualHost)
         {
             _virtualHost = virtualHost;
         }
 
-        public string getOption(string key)
+        public string GetOption(string key)
         {
-            return (string) _options[key];
+            return (string)_options[key];
         }
 
-        public void setOption(string key, string value)
+        public void SetOption(string key, string value)
         {
             _options[key] = value;
         }
-        
+
         public override string ToString()
         {
-            return asUrl();
+            return AsUrl();
         }
     }
 }