From 01051c71c8f405e9f40a088509d09f171aea1c7d Mon Sep 17 00:00:00 2001
From: Masanori Itoh <itoumsn@nttdata.co.jp>
Date: Thu, 7 Apr 2011 02:07:19 +0900
Subject: Enable RightAWS style signing on server_string without port number
 portion.

---
 nova/auth/manager.py |  9 +++++++++
 nova/utils.py        | 21 +++++++++++++++++++++
 2 files changed, 30 insertions(+)

diff --git a/nova/auth/manager.py b/nova/auth/manager.py
index 486845399..b51cc7f4b 100644
--- a/nova/auth/manager.py
+++ b/nova/auth/manager.py
@@ -315,6 +315,15 @@ class AuthManager(object):
             LOG.debug('expected_signature: %s', expected_signature)
             LOG.debug('signature: %s', signature)
             if signature != expected_signature:
+	        secondary = utils.get_secondary_server_string(server_string)
+                if secondary is not '':
+                    secondary_signature = signer.Signer(
+                        user.secret.encode()).generate(params, verb,
+                                                       secondary, path)
+                    LOG.debug('secondary_signature: %s', secondary_signature)
+                    if signature == secondary_signature:
+                        return (user, project)
+                        # NOTE(itoumsn): RightAWS success case.
                 LOG.audit(_("Invalid signature for user %s"), user.name)
                 raise exception.NotAuthorized(_('Signature does not match'))
         return (user, project)
diff --git a/nova/utils.py b/nova/utils.py
index 3f6f9fc8a..8fd464452 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -714,3 +714,24 @@ def check_isinstance(obj, cls):
     raise Exception(_("Expected object of type: %s") % (str(cls)))
     # TODO(justinsb): Can we make this better??
     return cls()  # Ugly PyLint hack
+
+def get_secondary_server_string(str):
+    """Returns host part only of the given server_string if it's a combination
+    of host part and port. Otherwise, return null string."""
+
+    # First of all, exclude pure IPv6 address (w/o port).
+    if netaddr.valid_ipv6(str):
+        return ''
+
+    # Next, check if this is IPv6 address with port number combination.
+    if str.find("]:") != -1: 
+        [address, sep, port] = str.replace('[', '', 1).partition(']:')
+        return address 
+
+    # Third, check if this is a combination of general address and port
+    if str.find(':') == -1: 
+	return ''
+
+    # This must be a combination of host part and port
+    [address, sep, port] = str.partition(':')
+    return address 
-- 
cgit 


From 8decff01ad8ee7e8f7d4103a727321b162280cbe Mon Sep 17 00:00:00 2001
From: Masanori Itoh <itoumsn@nttdata.co.jp>
Date: Thu, 7 Apr 2011 11:42:02 +0900
Subject: pep8 cleanup.

---
 nova/auth/manager.py |  2 +-
 nova/utils.py        | 11 ++++++-----
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/nova/auth/manager.py b/nova/auth/manager.py
index b51cc7f4b..f1d4a1e39 100644
--- a/nova/auth/manager.py
+++ b/nova/auth/manager.py
@@ -315,7 +315,7 @@ class AuthManager(object):
             LOG.debug('expected_signature: %s', expected_signature)
             LOG.debug('signature: %s', signature)
             if signature != expected_signature:
-	        secondary = utils.get_secondary_server_string(server_string)
+                secondary = utils.get_secondary_server_string(server_string)
                 if secondary is not '':
                     secondary_signature = signer.Signer(
                         user.secret.encode()).generate(params, verb,
diff --git a/nova/utils.py b/nova/utils.py
index 8fd464452..3e938247f 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -715,6 +715,7 @@ def check_isinstance(obj, cls):
     # TODO(justinsb): Can we make this better??
     return cls()  # Ugly PyLint hack
 
+
 def get_secondary_server_string(str):
     """Returns host part only of the given server_string if it's a combination
     of host part and port. Otherwise, return null string."""
@@ -724,14 +725,14 @@ def get_secondary_server_string(str):
         return ''
 
     # Next, check if this is IPv6 address with port number combination.
-    if str.find("]:") != -1: 
+    if str.find("]:") != -1:
         [address, sep, port] = str.replace('[', '', 1).partition(']:')
-        return address 
+        return address
 
     # Third, check if this is a combination of general address and port
-    if str.find(':') == -1: 
-	return ''
+    if str.find(':') == -1:
+        return ''
 
     # This must be a combination of host part and port
     [address, sep, port] = str.partition(':')
-    return address 
+    return address
-- 
cgit 


From 8c4fa0f16ac170662e113edfdc0f8d3c8863f082 Mon Sep 17 00:00:00 2001
From: Masanori Itoh <itoumsn@nttdata.co.jp>
Date: Thu, 7 Apr 2011 23:48:00 +0900
Subject: Blush up a bit.

---
 nova/auth/manager.py | 14 +++++++-------
 nova/utils.py        |  8 +++++---
 2 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/nova/auth/manager.py b/nova/auth/manager.py
index f1d4a1e39..c8a3a46a2 100644
--- a/nova/auth/manager.py
+++ b/nova/auth/manager.py
@@ -315,15 +315,15 @@ class AuthManager(object):
             LOG.debug('expected_signature: %s', expected_signature)
             LOG.debug('signature: %s', signature)
             if signature != expected_signature:
-                secondary = utils.get_secondary_server_string(server_string)
-                if secondary is not '':
-                    secondary_signature = signer.Signer(
+                host_only = utils.get_host_only_server_string(server_string)
+                # If the given server_string contains port num, try without it.
+                if host_only is not '':
+                    host_only_signature = signer.Signer(
                         user.secret.encode()).generate(params, verb,
-                                                       secondary, path)
-                    LOG.debug('secondary_signature: %s', secondary_signature)
-                    if signature == secondary_signature:
+                                                       host_only, path)
+                    LOG.debug('host_only_signature: %s', host_only_signature)
+                    if signature == host_only_signature:
                         return (user, project)
-                        # NOTE(itoumsn): RightAWS success case.
                 LOG.audit(_("Invalid signature for user %s"), user.name)
                 raise exception.NotAuthorized(_('Signature does not match'))
         return (user, project)
diff --git a/nova/utils.py b/nova/utils.py
index 3e938247f..8b7cbf30c 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -716,9 +716,11 @@ def check_isinstance(obj, cls):
     return cls()  # Ugly PyLint hack
 
 
-def get_secondary_server_string(str):
-    """Returns host part only of the given server_string if it's a combination
-    of host part and port. Otherwise, return null string."""
+def get_host_only_server_string(str):
+    """
+    Returns host part only of the given server_string if it's a combination
+    of host part and port. Otherwise, return null string.
+    """
 
     # First of all, exclude pure IPv6 address (w/o port).
     if netaddr.valid_ipv6(str):
-- 
cgit 


From 32d081f8f0a50b87f7b5d3f5bab4cf4ba92b1b4d Mon Sep 17 00:00:00 2001
From: Masanori Itoh <itoumsn@nttdata.co.jp>
Date: Wed, 13 Apr 2011 02:11:36 +0900
Subject: Blushed up a little bit.

---
 nova/auth/manager.py |  2 +-
 nova/utils.py        | 12 ++++++------
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/nova/auth/manager.py b/nova/auth/manager.py
index c8a3a46a2..01aa87e31 100644
--- a/nova/auth/manager.py
+++ b/nova/auth/manager.py
@@ -317,7 +317,7 @@ class AuthManager(object):
             if signature != expected_signature:
                 host_only = utils.get_host_only_server_string(server_string)
                 # If the given server_string contains port num, try without it.
-                if host_only is not '':
+                if host_only != '':
                     host_only_signature = signer.Signer(
                         user.secret.encode()).generate(params, verb,
                                                        host_only, path)
diff --git a/nova/utils.py b/nova/utils.py
index 8b7cbf30c..369b5265c 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -716,25 +716,25 @@ def check_isinstance(obj, cls):
     return cls()  # Ugly PyLint hack
 
 
-def get_host_only_server_string(str):
+def get_host_only_server_string(server_str):
     """
     Returns host part only of the given server_string if it's a combination
     of host part and port. Otherwise, return null string.
     """
 
     # First of all, exclude pure IPv6 address (w/o port).
-    if netaddr.valid_ipv6(str):
+    if netaddr.valid_ipv6(server_str):
         return ''
 
     # Next, check if this is IPv6 address with port number combination.
-    if str.find("]:") != -1:
-        [address, sep, port] = str.replace('[', '', 1).partition(']:')
+    if server_str.find("]:") != -1:
+        [address, sep, port] = server_str.replace('[', '', 1).partition(']:')
         return address
 
     # Third, check if this is a combination of general address and port
-    if str.find(':') == -1:
+    if server_str.find(':') == -1:
         return ''
 
     # This must be a combination of host part and port
-    [address, sep, port] = str.partition(':')
+    [address, sep, port] = server_str.partition(':')
     return address
-- 
cgit 


From b501eb0748ba629a4a742431a42af591f94b6b4c Mon Sep 17 00:00:00 2001
From: Masanori Itoh <itoumsn@nttdata.co.jp>
Date: Thu, 14 Apr 2011 10:47:37 +0900
Subject: Updated following to RIck's comments.

---
 nova/auth/manager.py | 15 ++++++++-------
 nova/utils.py        |  2 +-
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/nova/auth/manager.py b/nova/auth/manager.py
index 01aa87e31..dc37ae063 100644
--- a/nova/auth/manager.py
+++ b/nova/auth/manager.py
@@ -300,9 +300,9 @@ class AuthManager(object):
         if check_type == 's3':
             sign = signer.Signer(user.secret.encode())
             expected_signature = sign.s3_authorization(headers, verb, path)
-            LOG.debug('user.secret: %s', user.secret)
-            LOG.debug('expected_signature: %s', expected_signature)
-            LOG.debug('signature: %s', signature)
+            LOG.debug(_('user.secret: %s'), user.secret)
+            LOG.debug(_('expected_signature: %s'), expected_signature)
+            LOG.debug(_('signature: %s'), signature)
             if signature != expected_signature:
                 LOG.audit(_("Invalid signature for user %s"), user.name)
                 raise exception.NotAuthorized(_('Signature does not match'))
@@ -311,9 +311,9 @@ class AuthManager(object):
             #             secret isn't unicode
             expected_signature = signer.Signer(user.secret.encode()).generate(
                     params, verb, server_string, path)
-            LOG.debug('user.secret: %s', user.secret)
-            LOG.debug('expected_signature: %s', expected_signature)
-            LOG.debug('signature: %s', signature)
+            LOG.debug(_('user.secret: %s'), user.secret)
+            LOG.debug(_('expected_signature: %s'), expected_signature)
+            LOG.debug(_('signature: %s'), signature)
             if signature != expected_signature:
                 host_only = utils.get_host_only_server_string(server_string)
                 # If the given server_string contains port num, try without it.
@@ -321,7 +321,8 @@ class AuthManager(object):
                     host_only_signature = signer.Signer(
                         user.secret.encode()).generate(params, verb,
                                                        host_only, path)
-                    LOG.debug('host_only_signature: %s', host_only_signature)
+                    LOG.debug(_('host_only_signature: %s'),
+                              host_only_signature)
                     if signature == host_only_signature:
                         return (user, project)
                 LOG.audit(_("Invalid signature for user %s"), user.name)
diff --git a/nova/utils.py b/nova/utils.py
index 369b5265c..b0f961b90 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -736,5 +736,5 @@ def get_host_only_server_string(server_str):
         return ''
 
     # This must be a combination of host part and port
-    [address, sep, port] = server_str.partition(':')
+    (address, port) = server_str.split(':')
     return address
-- 
cgit 


From 891eb82afacc10795e4ac05a0c8f817645db85c2 Mon Sep 17 00:00:00 2001
From: Masanori Itoh <itoumsn@nttdata.co.jp>
Date: Fri, 22 Apr 2011 01:26:59 +0900
Subject: Utility method reworked, etc.

---
 nova/auth/authutils.py  | 48 ++++++++++++++++++++++++++++++++++++++++++++++++
 nova/auth/manager.py    |  4 +++-
 nova/tests/test_auth.py | 24 ++++++++++++++++++++++++
 nova/utils.py           | 24 ------------------------
 4 files changed, 75 insertions(+), 25 deletions(-)
 create mode 100644 nova/auth/authutils.py

diff --git a/nova/auth/authutils.py b/nova/auth/authutils.py
new file mode 100644
index 000000000..429e86ef9
--- /dev/null
+++ b/nova/auth/authutils.py
@@ -0,0 +1,48 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 NTT DATA CORPORATION.
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Auth module specific utilities and helper functions.
+"""
+
+import netaddr
+import string
+
+
+def get_host_only_server_string(server_str):
+    """
+    Returns host part only of the given server_string if it's a combination
+    of host part and port. Otherwise, return null string.
+    """
+
+    # First of all, exclude pure IPv6 address (w/o port).
+    if netaddr.valid_ipv6(server_str):
+        return ''
+
+    # Next, check if this is IPv6 address with port number combination.
+    if server_str.find("]:") != -1:
+        [address, sep, port] = server_str.replace('[', '', 1).partition(']:')
+        return address
+
+    # Third, check if this is a combination of general address and port
+    if server_str.find(':') == -1:
+        return ''
+
+    # This must be a combination of host part and port
+    (address, port) = server_str.split(':')
+    return address
diff --git a/nova/auth/manager.py b/nova/auth/manager.py
index 06def220a..775b38af1 100644
--- a/nova/auth/manager.py
+++ b/nova/auth/manager.py
@@ -35,6 +35,7 @@ from nova import flags
 from nova import log as logging
 from nova import utils
 from nova.auth import signer
+from nova.auth import authutils
 
 
 FLAGS = flags.FLAGS
@@ -315,7 +316,8 @@ class AuthManager(object):
             LOG.debug(_('expected_signature: %s'), expected_signature)
             LOG.debug(_('signature: %s'), signature)
             if signature != expected_signature:
-                host_only = utils.get_host_only_server_string(server_string)
+                host_only = authutils.get_host_only_server_string(
+                    server_string)
                 # If the given server_string contains port num, try without it.
                 if host_only != '':
                     host_only_signature = signer.Signer(
diff --git a/nova/tests/test_auth.py b/nova/tests/test_auth.py
index f8a1b1564..3886e9e6b 100644
--- a/nova/tests/test_auth.py
+++ b/nova/tests/test_auth.py
@@ -25,6 +25,7 @@ from nova import log as logging
 from nova import test
 from nova.auth import manager
 from nova.api.ec2 import cloud
+from nova.auth import authutils
 
 FLAGS = flags.FLAGS
 LOG = logging.getLogger('nova.tests.auth_unittest')
@@ -339,6 +340,29 @@ class AuthManagerDbTestCase(_AuthManagerBaseTestCase):
     auth_driver = 'nova.auth.dbdriver.DbDriver'
 
 
+class AuthManagerUtilTestCase(test.TestCase):
+    def test_get_host_only_server_string(self):
+        result = authutils.get_host_only_server_string('::1')
+        self.assertEqual('', result)
+        result = authutils.get_host_only_server_string('[::1]:8773')
+        self.assertEqual('::1', result)
+        result = authutils.get_host_only_server_string('2001:db8::192.168.1.1')
+        self.assertEqual('', result)
+        result = authutils.get_host_only_server_string(
+            '[2001:db8::192.168.1.1]:8773')
+        self.assertEqual('2001:db8::192.168.1.1', result)
+        result = authutils.get_host_only_server_string('192.168.1.1')
+        self.assertEqual('', result)
+        result = authutils.get_host_only_server_string('192.168.1.2:8773')
+        self.assertEqual('192.168.1.2', result)
+        result = authutils.get_host_only_server_string('192.168.1.3')
+        self.assertEqual('', result)
+        result = authutils.get_host_only_server_string('www.example.com:8443')
+        self.assertEqual('www.example.com', result)
+        result = authutils.get_host_only_server_string('www.example.com')
+        self.assertEqual('', result)
+
+
 if __name__ == "__main__":
     # TODO: Implement use_fake as an option
     unittest.main()
diff --git a/nova/utils.py b/nova/utils.py
index 5060b1ef6..76cba1a08 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -714,27 +714,3 @@ def check_isinstance(obj, cls):
     raise Exception(_("Expected object of type: %s") % (str(cls)))
     # TODO(justinsb): Can we make this better??
     return cls()  # Ugly PyLint hack
-
-
-def get_host_only_server_string(server_str):
-    """
-    Returns host part only of the given server_string if it's a combination
-    of host part and port. Otherwise, return null string.
-    """
-
-    # First of all, exclude pure IPv6 address (w/o port).
-    if netaddr.valid_ipv6(server_str):
-        return ''
-
-    # Next, check if this is IPv6 address with port number combination.
-    if server_str.find("]:") != -1:
-        [address, sep, port] = server_str.replace('[', '', 1).partition(']:')
-        return address
-
-    # Third, check if this is a combination of general address and port
-    if server_str.find(':') == -1:
-        return ''
-
-    # This must be a combination of host part and port
-    (address, port) = server_str.split(':')
-    return address
-- 
cgit 


From edc63f9734a4b053a3b57fd6febe94824c83815f Mon Sep 17 00:00:00 2001
From: Masanori Itoh <itoumsn@nttdata.co.jp>
Date: Fri, 22 Apr 2011 21:35:54 +0900
Subject: Rework completed. Added test cases, changed helper method name, etc.

---
 nova/auth/authutils.py   | 48 ------------------------------------
 nova/auth/manager.py     |  8 +++---
 nova/tests/test_auth.py  | 64 ++++++++++++++++++++++++++++--------------------
 nova/tests/test_utils.py | 25 +++++++++++++++++++
 nova/utils.py            | 30 +++++++++++++++++++++++
 5 files changed, 95 insertions(+), 80 deletions(-)
 delete mode 100644 nova/auth/authutils.py

diff --git a/nova/auth/authutils.py b/nova/auth/authutils.py
deleted file mode 100644
index 429e86ef9..000000000
--- a/nova/auth/authutils.py
+++ /dev/null
@@ -1,48 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2011 NTT DATA CORPORATION.
-# Copyright 2011 OpenStack LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-"""
-Auth module specific utilities and helper functions.
-"""
-
-import netaddr
-import string
-
-
-def get_host_only_server_string(server_str):
-    """
-    Returns host part only of the given server_string if it's a combination
-    of host part and port. Otherwise, return null string.
-    """
-
-    # First of all, exclude pure IPv6 address (w/o port).
-    if netaddr.valid_ipv6(server_str):
-        return ''
-
-    # Next, check if this is IPv6 address with port number combination.
-    if server_str.find("]:") != -1:
-        [address, sep, port] = server_str.replace('[', '', 1).partition(']:')
-        return address
-
-    # Third, check if this is a combination of general address and port
-    if server_str.find(':') == -1:
-        return ''
-
-    # This must be a combination of host part and port
-    (address, port) = server_str.split(':')
-    return address
diff --git a/nova/auth/manager.py b/nova/auth/manager.py
index 775b38af1..d42594c84 100644
--- a/nova/auth/manager.py
+++ b/nova/auth/manager.py
@@ -35,7 +35,6 @@ from nova import flags
 from nova import log as logging
 from nova import utils
 from nova.auth import signer
-from nova.auth import authutils
 
 
 FLAGS = flags.FLAGS
@@ -316,13 +315,12 @@ class AuthManager(object):
             LOG.debug(_('expected_signature: %s'), expected_signature)
             LOG.debug(_('signature: %s'), signature)
             if signature != expected_signature:
-                host_only = authutils.get_host_only_server_string(
-                    server_string)
+                (addr_str, port_str) = utils.parse_server_string(server_string)
                 # If the given server_string contains port num, try without it.
-                if host_only != '':
+                if port_str != '':
                     host_only_signature = signer.Signer(
                         user.secret.encode()).generate(params, verb,
-                                                       host_only, path)
+                                                       addr_str, path)
                     LOG.debug(_('host_only_signature: %s'),
                               host_only_signature)
                     if signature == host_only_signature:
diff --git a/nova/tests/test_auth.py b/nova/tests/test_auth.py
index 3886e9e6b..f02dd94b7 100644
--- a/nova/tests/test_auth.py
+++ b/nova/tests/test_auth.py
@@ -25,7 +25,6 @@ from nova import log as logging
 from nova import test
 from nova.auth import manager
 from nova.api.ec2 import cloud
-from nova.auth import authutils
 
 FLAGS = flags.FLAGS
 LOG = logging.getLogger('nova.tests.auth_unittest')
@@ -102,9 +101,43 @@ class _AuthManagerBaseTestCase(test.TestCase):
             self.assertEqual('private-party', u.access)
 
     def test_004_signature_is_valid(self):
-        #self.assertTrue(self.manager.authenticate(**boto.generate_url ...? ))
-        pass
-        #raise NotImplementedError
+        with user_generator(self.manager, name='admin', secret='admin',
+                            access='admin'):
+            with project_generator(self.manager, name="admin",
+                                   manager_user='admin'):
+                accesskey = 'admin:admin'
+                expected_result = (self.manager.get_user('admin'),
+                                   self.manager.get_project('admin'))
+                # captured sig and query string using boto 1.9b/euca2ools 1.2
+                sig = 'd67Wzd9Bwz8xid9QU+lzWXcF2Y3tRicYABPJgrqfrwM='
+                auth_params = {'AWSAccessKeyId': 'admin:admin',
+                               'Action': 'DescribeAvailabilityZones',
+                               'SignatureMethod': 'HmacSHA256',
+                               'SignatureVersion': '2',
+                               'Timestamp': '2011-04-22T11:29:29',
+                               'Version': '2009-11-30'}
+                self.assertTrue(expected_result, self.manager.authenticate(
+                        accesskey,
+                        sig,
+                        auth_params,
+                        'GET',
+                        '127.0.0.1:8773',
+                        '/services/Cloud/'))
+                # captured sig and query string using RightAWS 1.10.0
+                sig = 'ECYLU6xdFG0ZqRVhQybPJQNJ5W4B9n8fGs6+/fuGD2c='
+                auth_params = {'AWSAccessKeyId': 'admin:admin',
+                               'Action': 'DescribeAvailabilityZones',
+                               'SignatureMethod': 'HmacSHA256',
+                               'SignatureVersion': '2',
+                               'Timestamp': '2011-04-22T11:29:49.000Z',
+                               'Version': '2008-12-01'}
+                self.assertTrue(expected_result, self.manager.authenticate(
+                        accesskey,
+                        sig,
+                        auth_params,
+                        'GET',
+                        '127.0.0.1',
+                        '/services/Cloud'))
 
     def test_005_can_get_credentials(self):
         return
@@ -340,29 +373,6 @@ class AuthManagerDbTestCase(_AuthManagerBaseTestCase):
     auth_driver = 'nova.auth.dbdriver.DbDriver'
 
 
-class AuthManagerUtilTestCase(test.TestCase):
-    def test_get_host_only_server_string(self):
-        result = authutils.get_host_only_server_string('::1')
-        self.assertEqual('', result)
-        result = authutils.get_host_only_server_string('[::1]:8773')
-        self.assertEqual('::1', result)
-        result = authutils.get_host_only_server_string('2001:db8::192.168.1.1')
-        self.assertEqual('', result)
-        result = authutils.get_host_only_server_string(
-            '[2001:db8::192.168.1.1]:8773')
-        self.assertEqual('2001:db8::192.168.1.1', result)
-        result = authutils.get_host_only_server_string('192.168.1.1')
-        self.assertEqual('', result)
-        result = authutils.get_host_only_server_string('192.168.1.2:8773')
-        self.assertEqual('192.168.1.2', result)
-        result = authutils.get_host_only_server_string('192.168.1.3')
-        self.assertEqual('', result)
-        result = authutils.get_host_only_server_string('www.example.com:8443')
-        self.assertEqual('www.example.com', result)
-        result = authutils.get_host_only_server_string('www.example.com')
-        self.assertEqual('', result)
-
-
 if __name__ == "__main__":
     # TODO: Implement use_fake as an option
     unittest.main()
diff --git a/nova/tests/test_utils.py b/nova/tests/test_utils.py
index e08d229b0..e7b5c826e 100644
--- a/nova/tests/test_utils.py
+++ b/nova/tests/test_utils.py
@@ -250,3 +250,28 @@ class GetFromPathTestCase(test.TestCase):
         input = {'a': [1, 2, {'b': 'b_1'}]}
         self.assertEquals([1, 2, {'b': 'b_1'}], f(input, "a"))
         self.assertEquals(['b_1'], f(input, "a/b"))
+
+
+class GenericUtilsTestCase(test.TestCase):
+    def test_parse_server_string(self):
+        result = utils.parse_server_string('::1')
+        self.assertEqual(('::1', ''), result)
+        result = utils.parse_server_string('[::1]:8773')
+        self.assertEqual(('::1', '8773'), result)
+        result = utils.parse_server_string('2001:db8::192.168.1.1')
+        self.assertEqual(('2001:db8::192.168.1.1', ''), result)
+        result = utils.parse_server_string('[2001:db8::192.168.1.1]:8773')
+        self.assertEqual(('2001:db8::192.168.1.1', '8773'), result)
+        result = utils.parse_server_string('192.168.1.1')
+        self.assertEqual(('192.168.1.1', ''), result)
+        result = utils.parse_server_string('192.168.1.2:8773')
+        self.assertEqual(('192.168.1.2', '8773'), result)
+        result = utils.parse_server_string('192.168.1.3')
+        self.assertEqual(('192.168.1.3', ''), result)
+        result = utils.parse_server_string('www.example.com:8443')
+        self.assertEqual(('www.example.com', '8443'), result)
+        result = utils.parse_server_string('www.example.com')
+        self.assertEqual(('www.example.com', ''), result)
+        # error case
+        result = utils.parse_server_string('www.exa:mple.com:8443')
+        self.assertEqual(('', ''), result)
diff --git a/nova/utils.py b/nova/utils.py
index b783f6c14..82ab3fc9e 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -709,3 +709,33 @@ def check_isinstance(obj, cls):
     raise Exception(_('Expected object of type: %s') % (str(cls)))
     # TODO(justinsb): Can we make this better??
     return cls()  # Ugly PyLint hack
+
+
+def parse_server_string(server_str):
+    """
+    Parses the given server_string and returns a list of host and port.
+    If it's not a combination of host part and port, the port element
+    is a null string. If the input is invalid expression, return a null
+    list.
+    """
+    try:
+        # First of all, exclude pure IPv6 address (w/o port).
+        if netaddr.valid_ipv6(server_str):
+            return (server_str, '')
+
+        # Next, check if this is IPv6 address with a port number combination.
+        if server_str.find("]:") != -1:
+            (address, port) = server_str.replace('[', '', 1).split(']:')
+            return (address, port)
+
+        # Third, check if this is a combination of an address and a port
+        if server_str.find(':') == -1:
+            return (server_str, '')
+
+        # This must be a combination of an address and a port
+        (address, port) = server_str.split(':')
+        return (address, port)
+
+    except:
+        LOG.debug(_('Invalid server_string: %s' % server_str))
+        return ('', '')
-- 
cgit