WL#10081: DevAPI IPv6 Support

amitab · amitab · commit 92563be53ee3 · 2017-03-07T10:09:02.000+05:30
This feature adds IPv6 support to Connector/Python.
Currently, the user can connect to a MySQL server running the XPlugin using
a hostname that resolves to an IPv4 address.
With this feature, the hostname maybe resolved as IPv4 or IPv6 address.

This patch also updates the address list parsing from URI string to correctly
parse IPv6 addresses.
diff --git a/lib/mysqlx/__init__.py b/lib/mysqlx/__init__.py
@@ -1,5 +1,5 @@
 # MySQL Connector/Python - MySQL driver written in Python.
-# Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved.
 
 # MySQL Connector/Python is licensed under the terms of the GPLv2
 # <http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
@@ -24,7 +24,6 @@
 """MySQL X DevAPI Python implementation"""
 
 import re
-
 from . import constants
 
 from .compat import STRING_TYPES, urlparse, unquote, parse_qsl
@@ -45,49 +44,42 @@
                         AlterViewStatement, ColumnDef,
                         GeneratedColumnDef, ForeignKeyDef, Expr)
 
+_SPLIT = re.compile(r',(?![^\(\)]*\))')
+_PRIORITY = re.compile(r'^\(address=(.+),priority=(\d+)\)$', re.VERBOSE)
 
-def _parse_address_list(address_list):
+def _parse_address_list(path):
     """Parses a list of host, port pairs
 
     Args:
-        address_list: String containing a list of routers or just router
+        path: String containing a list of routers or just router
 
     Returns:
         Returns a dict with parsed values of host, port and priority if
         specified.
     """
-    is_list  = re.compile(r'^\[(?![^,]*\]).*]$')
-    hst_list = re.compile(r',(?![^\(\)]*\))')
-    pri_addr = re.compile(r'^\(address\s*=\s*(?P<address>.+)\s*,\s*priority\s*=\s*(?P<priority>\d+)\)$')
+    path = path.replace(" ", "")
+    array  = not("," not in path and path.count(":") > 1
+                 and path.count("[") == 1) and \
+             path.startswith("[") and path.endswith("]")
 
     routers = []
-    if is_list.match(address_list):
-        address_list = address_list.strip("[]")
-        address_list = hst_list.split(address_list)
-    else:
-        match = urlparse("//{0}".format(address_list))
-        return {
-            "host": match.hostname,
-            "port": match.port
-        }
-
-    while address_list:
+    address_list = _SPLIT.split(path[1:-1] if array else path)
+    for address in address_list:
         router = {}
-        address = address_list.pop(0).strip()
-        match = pri_addr.match(address)
+
+        match = _PRIORITY.match(address)
         if match:
-            address = match.group("address").strip()
-            router["priority"] = int(match.group("priority"))
+            address = match.group(1)
+            router["priority"] = int(match.group(2))
 
         match = urlparse("//{0}".format(address))
         if not match.hostname:
             raise InterfaceError("Invalid address: {0}".format(address))
 
-        router["host"] = match.hostname
-        router["port"] = match.port
+        router.update(host=match.hostname, port=match.port)
         routers.append(router)
 
-    return { "routers": routers }
+    return {"routers": routers} if array else routers[0]
 
 def _parse_connection_uri(uri):
     """Parses the connection string and returns a dictionary with the
diff --git a/lib/mysqlx/connection.py b/lib/mysqlx/connection.py
@@ -52,7 +52,10 @@ def __init__(self):
         self._is_ssl = False
 
     def connect(self, params):
-        s_type = socket.AF_INET if isinstance(params, tuple) else socket.AF_UNIX
+        if isinstance(params, tuple):
+            s_type = socket.AF_INET6 if ":" in params[0] else socket.AF_INET
+        else:
+            s_type = socket.AF_UNIX
         self._socket = socket.socket(s_type, socket.SOCK_STREAM)
         self._socket.connect(params)
 
diff --git a/tests/mysqld.py b/tests/mysqld.py
@@ -1,5 +1,5 @@
 # MySQL Connector/Python - MySQL driver written in Python.
-# Copyright (c) 2009, 2015, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2009, 2017, Oracle and/or its affiliates. All rights reserved.
 
 # MySQL Connector/Python is licensed under the terms of the GPLv2
 # <http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
@@ -344,8 +344,9 @@ class MySQLServer(MySQLServerBase):
     """Class for managing a MySQL server"""
 
     def __init__(self, basedir, topdir, cnf, bind_address, port, mysqlx_port,
-                 name, datadir=None, tmpdir=None,
+                 name, datadir=None, tmpdir=None, extra_args={},
                  unix_socket_folder=None, ssl_folder=None, sharedir=None):
+        self._extra_args = extra_args
         self._cnf = cnf
         self._option_file = os.path.join(topdir, 'my.cnf')
         self._bind_address = bind_address
@@ -458,6 +459,11 @@ def bootstrap(self):
             "'Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y',"
             "'Y','Y','Y','Y','Y','','','','',0,0,0,0,"
             "@@default_authentication_plugin,'','N',"
+            "CURRENT_TIMESTAMP,NULL{1}), ('::1','root'{0},"
+            "'Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y',"
+            "'Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y',"
+            "'Y','Y','Y','Y','Y','','','','',0,0,0,0,"
+            "@@default_authentication_plugin,'','N',"
             "CURRENT_TIMESTAMP,NULL{1});"
         )
         # MySQL 5.7.5+ creates no user while bootstrapping
@@ -573,6 +579,13 @@ def start(self):
             'lc_messages_dir': _convert_forward_slash(
                 self._lc_messages_dir),
         }
+
+        for arg in self._extra_args:
+            if self._version < arg["version"]:
+                options.update(dict([(key, '') for key in
+                                     arg["options"].keys()]))
+            else:
+                options.update(arg["options"])
         try:
             fp = open(self._option_file, 'w')
             fp.write(self._cnf.format(**options))
diff --git a/tests/test_mysqlx_connection.py b/tests/test_mysqlx_connection.py
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 # MySQL Connector/Python - MySQL driver written in Python.
-# Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved.
 
 # MySQL Connector/Python is licensed under the terms of the GPLv2
 # <http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
@@ -32,9 +32,9 @@
 import mysqlx
 
 if mysqlx.compat.PY3:
-    from urllib.parse import quote
+    from urllib.parse import quote_plus
 else:
-    from urllib import quote
+    from urllib import quote_plus
 
 LOGGER = logging.getLogger(tests.LOGGER_NAME)
 
@@ -72,6 +72,26 @@
     ("unicode:áé'í'óú@127.0.0.1",
      {"schema": "", "host": "127.0.0.1", "password": "áé'í'óú",
       "port": 33060, "user": "unicode"}),
+    ("root:@[localhost, 127.0.0.1:88, [::]:99, [a1:b1::]]",
+     {"routers": [{"host": "localhost", "port": 33060},
+                  {"host": "127.0.0.1", "port": 88},
+                  {"host": "::", "port": 99},
+                  {"host": "a1:b1::", "port": 33060}],
+      "user": "root", "password": "", "schema": ""}),
+     ("root:@[a1:a2:a3:a4:a5:a6:a7:a8]]",
+      {"host": "a1:a2:a3:a4:a5:a6:a7:a8", "schema": "",
+              "port": 33060, "user": "root", "password": ""}),
+     ("root:@localhost", {"user": "root", "password": "",
+      "host": "localhost", "port": 33060, "schema": ""}),
+     ("root:@[a1:b1::]", {"user": "root", "password": "",
+      "host": "a1:b1::", "port": 33060, "schema": ""}),
+     ("root:@[a1:b1::]:88", {"user": "root", "password": "",
+      "host": "a1:b1::", "port": 88, "schema": ""}),
+     ("root:@[[a1:b1::]:88]", {"user": "root", "password": "",
+      "routers": [{"host": "a1:b1::", "port":88}], "schema": ""}),
+     ("root:@[(address=localhost:99, priority=99)]",
+      {"user": "root", "password": "", "schema": "",
+      "routers": [{"host": "localhost", "port": 99, "priority": 99}]})
 )
 
 
@@ -89,6 +109,47 @@
      "priority": 98}], "password": "password", "user": "user"}),
 )
 
+def build_uri(**kwargs):
+    uri = "mysqlx://{0}:{1}".format(kwargs["user"], kwargs["password"])
+
+    if "host" in kwargs:
+        host = "[{0}]".format(kwargs["host"]) \
+                if ":" in kwargs["host"] else kwargs["host"]
+        uri = "{0}@{1}".format(uri, host)
+    elif "routers" in kwargs:
+        routers = []
+        for router in kwargs["routers"]:
+            fmt = "(address={host}{port}, priority={priority})" \
+                   if "priority" in router else "{host}{port}"
+            host = "[{0}]".format(router["host"]) if ":" in router["host"] \
+                    else router["host"]
+            port = ":{0}".format(router["port"]) if "port" in router else ""
+
+            routers.append(fmt.format(host=host, port=port,
+                                      priority=router.get("priority", None)))
+
+        uri = "{0}@[{1}]".format(uri, ",".join(routers))
+    else:
+        raise mysqlx.errors.ProgrammingError("host or routers required.")
+
+    if "port" in kwargs:
+        uri = "{0}:{1}".format(uri, kwargs["port"])
+    if "schema" in kwargs:
+        uri = "{0}/{1}".format(uri, kwargs["schema"])
+
+    query = []
+    if "ssl_ca" in kwargs:
+        query.append("ssl-ca={0}".format(kwargs["ssl_ca"]))
+    if "ssl_cert" in kwargs:
+        query.append("ssl-cert={0}".format(kwargs["ssl_cert"]))
+    if "ssl_key" in kwargs:
+        query.append("ssl-key={0}".format(kwargs["ssl_key"]))
+
+    if len(query) > 0:
+        uri = "{0}?{1}".format(uri, "&".join(query))
+
+    return uri
+
 
 @unittest.skipIf(tests.MYSQL_VERSION < (5, 7, 12), "XPlugin not compatible")
 class MySQLxXSessionTests(tests.MySQLxTests):
@@ -117,15 +178,16 @@ def test___init__(self):
 
         # XSession to a farm using one of many routers (prios)
         # Loop during connect because of network error (succeed)
-        uri = ("mysqlx://{0}:{1}@[(address=bad_host, priority=100),"
-               "(address={2}:{3}, priority=98)]"
-               "".format(user, password, host, port))
+        routers = [{"host": "bad_host","priority": 100},
+                   {"host": host, "port": port, "priority": 98}]
+        uri = build_uri(user=user, password=password, routers=routers)
         session = mysqlx.get_session(uri)
         session.close()
 
         # XSession to a farm using one of many routers (incomplete prios)
-        uri = ("mysqlx://{0}:{1}@[(address=bad_host, priority=100), {2}:{3}]"
-               "".format(user, password, host, port))
+        routers = [{"host": "bad_host", "priority": 100},
+                   {"host": host, "port": port}]
+        uri = build_uri(user=user, password=password, routers=routers)
         self.assertRaises(mysqlx.errors.ProgrammingError,
                           mysqlx.get_session, uri)
         try:
@@ -134,9 +196,9 @@ def test___init__(self):
             self.assertEqual(4000, err.errno)
 
         # XSession to a farm using invalid priorities (out of range)
-        uri = ("mysqlx://{0}:{1}@[(address=bad_host, priority=100), "
-               "(address={2}:{3}, priority=101)]"
-               "".format(user, password, host, port))
+        routers = [{"host": "bad_host", "priority": 100},
+                   {"host": host, "port": port, "priority": 101}]
+        uri = build_uri(user=user, password=password, routers=routers)
         self.assertRaises(mysqlx.errors.ProgrammingError,
                           mysqlx.get_session, uri)
         try:
@@ -145,19 +207,18 @@ def test___init__(self):
             self.assertEqual(4007, err.errno)
 
         # Establish an XSession to a farm using one of many routers (no prios)
-        uri = ("mysqlx://{0}:{1}@[bad_host, {2}:{3}]"
-               "".format(user, password, host, port))
+        routers = [{"host": "bad_host"}, {"host": host, "port": port}]
+        uri = build_uri(user=user, password=password, routers=routers)
         session = mysqlx.get_session(uri)
         session.close()
 
         # Break loop during connect (non-network error)
-        uri = ("mysqlx://{0}:{1}@[bad_host, {2}:{3}]"
-               "".format(user, "bad_pass", host, port))
+        uri = build_uri(user=user, password="bad_pass", routers=routers)
         self.assertRaises(mysqlx.errors.InterfaceError,
                           mysqlx.get_session, uri)
 
         # Break loop during connect (none left)
-        uri = "mysqlx://{0}:{1}@[bad_host, another_bad_host]"
+        uri = "mysqlx://{0}:{1}@[bad_host, another_bad_host]".format(user, password)
         self.assertRaises(mysqlx.errors.InterfaceError,
                           mysqlx.get_session, uri)
         try:
@@ -211,12 +272,11 @@ def test_mysqlx_socket(self):
 
 
     def test_connection_uri(self):
-        uri = ("mysqlx://{user}:{password}@{host}:{port}/{schema}"
-               "".format(user=self.connect_kwargs["user"],
+        uri = build_uri(user=self.connect_kwargs["user"],
                          password=self.connect_kwargs["password"],
                          host=self.connect_kwargs["host"],
                          port=self.connect_kwargs["port"],
-                         schema=self.connect_kwargs["schema"]))
+                         schema=self.connect_kwargs["schema"])
         session = mysqlx.get_session(uri)
         self.assertIsInstance(session, mysqlx.XSession)
 
@@ -361,16 +421,23 @@ def test_ssl_connection(self):
 
         session.close()
 
-        uri = ("mysqlx://{0}:{1}@{2}?ssl-ca={3}&ssl-cert={4}&ssl-key={5}"
-               "".format(config["user"], config["password"], config["host"],
-                         quote(config["ssl-ca"]), quote(config["ssl-cert"]),
-                         quote(config["ssl-key"])))
+        ssl_ca="{0}{1}".format(config["ssl-ca"][0],
+                               quote_plus(config["ssl-ca"][1:]))
+        ssl_key="{0}{1}".format(config["ssl-key"][0],
+                                quote_plus(config["ssl-key"][1:]))
+        ssl_cert="{0}{1}".format(config["ssl-ca"][0],
+                                 quote_plus(config["ssl-cert"][1:]))
+        uri = build_uri(user=config["user"], password=config["password"],
+                        host=config["host"], ssl_ca=ssl_ca,
+                        ssl_cert=ssl_cert, ssl_key=ssl_key)
         session = mysqlx.get_session(uri)
 
-        uri = ("mysqlx://{0}:{1}@{2}?ssl-ca=({3})&ssl-cert=({4})&ssl-key=({5})"
-               "".format(config["user"], config["password"], config["host"],
-                         config["ssl-ca"], config["ssl-cert"],
-                         config["ssl-key"]))
+        ssl_ca = "({0})".format(config["ssl-ca"])
+        ssl_cert = "({0})".format(config["ssl-cert"])
+        ssl_key = "({0})".format(config["ssl-key"])
+        uri = build_uri(user=config["user"], password=config["password"],
+                        host=config["host"], ssl_ca=ssl_ca,
+                        ssl_cert=ssl_cert, ssl_key=ssl_key)
         session = mysqlx.get_session(uri)
 
 
@@ -395,12 +462,11 @@ def test___init__(self):
         self.assertRaises(TypeError, mysqlx.NodeSession, bad_config)
 
     def test_connection_uri(self):
-        uri = ("mysqlx://{user}:{password}@{host}:{port}/{schema}"
-               "".format(user=self.connect_kwargs["user"],
-                         password=self.connect_kwargs["password"],
-                         host=self.connect_kwargs["host"],
-                         port=self.connect_kwargs["port"],
-                         schema=self.connect_kwargs["schema"]))
+        uri = build_uri(user=self.connect_kwargs["user"],
+                        password=self.connect_kwargs["password"],
+                        host=self.connect_kwargs["host"],
+                        port=self.connect_kwargs["port"],
+                        schema=self.connect_kwargs["schema"])
         session = mysqlx.get_node_session(uri)
         self.assertIsInstance(session, mysqlx.NodeSession)
 
@@ -535,14 +601,21 @@ def test_ssl_connection(self):
 
         session.close()
 
-        uri = ("mysqlx://{0}:{1}@{2}?ssl-ca={3}&ssl-cert={4}&ssl-key={5}"
-               "".format(config["user"], config["password"], config["host"],
-                         quote(config["ssl-ca"]), quote(config["ssl-cert"]),
-                         quote(config["ssl-key"])))
+        ssl_ca="{0}{1}".format(config["ssl-ca"][0],
+                               quote_plus(config["ssl-ca"][1:]))
+        ssl_key="{0}{1}".format(config["ssl-key"][0],
+                                quote_plus(config["ssl-key"][1:]))
+        ssl_cert="{0}{1}".format(config["ssl-ca"][0],
+                                 quote_plus(config["ssl-cert"][1:]))
+        uri = build_uri(user=config["user"], password=config["password"],
+                        host=config["host"], ssl_ca=ssl_ca,
+                        ssl_cert=ssl_cert, ssl_key=ssl_key)
         session = mysqlx.get_node_session(uri)
 
-        uri = ("mysqlx://{0}:{1}@{2}?ssl-ca=({3})&ssl-cert=({4})&ssl-key=({5})"
-               "".format(config["user"], config["password"], config["host"],
-                         config["ssl-ca"], config["ssl-cert"],
-                         config["ssl-key"]))
+        ssl_ca = "({0})".format(config["ssl-ca"])
+        ssl_cert = "({0})".format(config["ssl-cert"])
+        ssl_key = "({0})".format(config["ssl-key"])
+        uri = build_uri(user=config["user"], password=config["password"],
+                        host=config["host"], ssl_ca=ssl_ca,
+                        ssl_cert=ssl_cert, ssl_key=ssl_key)
         session = mysqlx.get_node_session(uri)
diff --git a/unittests.py b/unittests.py
