def test_pools_are_not_shared(self):
settings = tests.get_mysqlx_config()
pooling_dict = {"max_size": 1, "max_idle_time": 0,}
cnx_options = {"pooling": pooling_dict}
uri = ("mysqlx://{user}:{pwd}@["
" (address={host}:{port}, priority=50)]"
"".format(user=self.user, pwd=self.password,
host=settings["host"], port=settings["port"]))
client1 = mysqlx.get_client(uri, cnx_options)
# Getting a session from client1
session1 = client1.get_session()
session1.sql("SELECT 1").execute()
session1.get_schema(settings["schema"])
# Getting a session from client2
client2 = mysqlx.get_client(uri, cnx_options)
# Getting a session must success, the higher priority will cause to a
# valid address to be used
session2 = client2.get_session()
session2.sql("SELECT 2").execute()
# Verify the server connections
connections = get_current_connections(self.session)
open_connections = connections.get(self.user, -1)
self.assertEqual(len(open_connections), 2)
# Closing pools in client1 must not close connections in client2
client1.close()
with self.assertRaises(mysqlx.errors.OperationalError):
session1.sql("SELECT 1").execute()
session2.sql("SELECT 2").execute()
session2.get_schema(settings["schema"])
client2.close()
def setUp(self):
self.connect_kwargs = tests.get_mysqlx_config()
self.configs = mysqlx.config.SessionConfigManager()
self.usr_file = os.path.join(os.getcwd(), "mysqlx_usr_sessions.json")
self.sys_file = os.path.join(os.getcwd(), "mysqlx_sys_sessions.json")
self.configs.set_persistence_handler(
mysqlx.config.PersistenceHandler(self.sys_file, self.usr_file))
def test_pools_are_not_shared(self):
settings = tests.get_mysqlx_config()
pooling_dict = {"max_size": 1, "max_idle_time": 0,}
cnx_options = {"pooling": pooling_dict}
uri = ("mysqlx://{user}:{pwd}@["
" (address={host}:{port}, priority=50)]"
"".format(user=self.user, pwd=self.password,
host=settings["host"], port=settings["port"]))
client1 = mysqlx.get_client(uri, cnx_options)
# Getting a session from client1
session1 = client1.get_session()
session1.sql("SELECT 1").execute()
session1.get_schema(settings["schema"])
# Getting a session from client2
client2 = mysqlx.get_client(uri, cnx_options)
# Getting a session must success, the higher priority will cause to a
# valid address to be used
session2 = client2.get_session()
session2.sql("SELECT 2").execute()
# Verify the server connections
connections = get_current_connections(self.session)
open_connections = connections.get(self.user, -1)
self.assertEqual(len(open_connections), 2)
# Closing pools in client1 must not close connections in client2
client1.close()
with self.assertRaises(mysqlx.errors.OperationalError):
session1.sql("SELECT 1").execute()
session2.sql("SELECT 2").execute()
session2.get_schema(settings["schema"])
client2.close()
def setUp(self):
self.connect_kwargs = tests.get_mysqlx_config()
self.schema_name = self.connect_kwargs["schema"]
try:
self.session = mysqlx.get_session(self.connect_kwargs)
except mysqlx.Error as err:
self.fail("{0}".format(err))
def setUp(self):
settings = tests.get_mysqlx_config()
self.schema_name = settings["schema"]
self.host = settings["host"]
self.user = "******"
self.password = "******"
self.hosts = "127.0.0.1", "localhost"
try:
self.session = mysqlx.get_session(settings)
except mysqlx.Error as err:
self.fail("{0}".format(err))
for host in self.hosts:
self.session.sql(DROP_USER.format(user=self.user,
host=host)).execute()
for host in self.hosts:
self.session.sql(
CREATE_USER.format(user=self.user,
host=host,
password=self.password)).execute()
# Grant all to new user on database
self.session.sql(
GRANT_USER.format(database=self.schema_name,
user=self.user, host=host,
password=self.password)).execute()
def setUp(self):
settings = tests.get_mysqlx_config()
self.schema_name = settings["schema"]
self.host = settings["host"]
self.user = "******"
self.password = "******"
self.hosts = "127.0.0.1", "localhost"
try:
self.session = mysqlx.get_session(settings)
except mysqlx.Error as err:
self.fail("{0}".format(err))
for host in self.hosts:
self.session.sql(DROP_USER.format(user=self.user,
host=host)).execute()
for host in self.hosts:
self.session.sql(
CREATE_USER.format(user=self.user,
host=host,
password=self.password)).execute()
# Grant all to new user on database
self.session.sql(
GRANT_USER.format(database=self.schema_name,
user=self.user,
host=host,
password=self.password)).execute()
def setUp(self):
self.connect_kwargs = tests.get_mysqlx_config()
self.schema_name = self.connect_kwargs["schema"]
try:
self.client = mysqlx.get_client(self.connect_kwargs, "{}")
self.session = self.client.get_session()
except mysqlx.Error as err:
self.fail("{0}".format(err))
if os.name == "nt":
if "64" in platform.architecture()[0]:
self.platform_arch = "x86_64"
elif "32" in platform.architecture()[0]:
self.platform_arch = "i386"
else:
self.platform_arch = platform.architecture()
self.os_ver = "Windows-{}".format(platform.win32_ver()[1])
else:
self.platform_arch = platform.machine()
if platform.system() == "Darwin":
self.os_ver = "{}-{}".format("macOS", platform.mac_ver()[0])
else:
self.os_ver = "-".join(platform.linux_distribution()[0:2])
license_chunks = LICENSE.split(" ")
if license_chunks[0] == "GPLv2":
self.client_license = "GPL-2.0"
else:
self.client_license = "Commercial"
def setUp(self):
self.connect_kwargs = tests.get_mysqlx_config()
self.schema_name = self.connect_kwargs["schema"]
try:
self.client = mysqlx.get_client(self.connect_kwargs, "{}")
self.session = self.client.get_session()
except mysqlx.Error as err:
self.fail("{0}".format(err))
if os.name == "nt":
if "64" in platform.architecture()[0]:
self.platform_arch = "x86_64"
elif "32" in platform.architecture()[0]:
self.platform_arch = "i386"
else:
self.platform_arch = platform.architecture()
self.os_ver = "Windows-{}".format(platform.win32_ver()[1])
else:
self.platform_arch = platform.machine()
if platform.system() == "Darwin":
self.os_ver = "{}-{}".format("macOS", platform.mac_ver()[0])
else:
self.os_ver = "-".join(linux_distribution()[0:2])
license_chunks = LICENSE.split(" ")
if license_chunks[0] == "GPLv2":
self.client_license = "GPL-2.0"
else:
self.client_license = "Commercial"
def setUp(self):
self.connect_kwargs = tests.get_mysqlx_config()
self.schema_name = self.connect_kwargs["schema"]
try:
self.session = mysqlx.get_session(self.connect_kwargs)
except mysqlx.Error as err:
self.fail("{0}".format(err))
def setUp(self):
self.connect_kwargs = tests.get_mysqlx_config()
self.schema_name = self.connect_kwargs["database"]
try:
self.session = mysqlx.get_session(self.connect_kwargs)
self.node_session = mysqlx.get_node_session(self.connect_kwargs)
except mysqlx.Error as err:
self.fail("{0}".format(err))
self.schema = self.session.create_schema(self.schema_name)
def setUp(self):
self.connect_kwargs = tests.get_mysqlx_config()
self.settings = {
"user": "******",
"password": "",
"host": "localhost",
"ssl-mode": "disabled",
"use_pure": True
}
def test_routing(self):
settings = tests.get_mysqlx_config()
pooling_dict = {"enabled": True}
cnx_options = {"pooling": pooling_dict}
uri = ("mysqlx://{user}:{pwd}@[(address=1.0.0.2:{port}, priority=30),"
" (address=1.0.0.1:{port}, priority=40),"
" (address=127.0.0.1:{port}, priority=80),"
" (address=localhost:{port}, priority=50)]"
"".format(user=settings["user"], pwd=settings["password"],
port=settings["port"]))
client = mysqlx.get_client(uri, cnx_options)
# Getting a session must success, the higher priority will cause to a
# valid address to be used
client.get_session()
client.close()
def test_routing(self):
settings = tests.get_mysqlx_config()
pooling_dict = {"enabled": True}
cnx_options = {"pooling": pooling_dict}
uri = ("mysqlx://{user}:{pwd}@[(address=1.0.0.2:{port}, priority=30),"
" (address=1.0.0.1:{port}, priority=40),"
" (address=127.0.0.1:{port}, priority=80),"
" (address=localhost:{port}, priority=50)]"
"".format(user=settings["user"], pwd=settings["password"],
port=settings["port"]))
client = mysqlx.get_client(uri, cnx_options)
# Getting a session must success, the higher priority will cause to a
# valid address to be used
client.get_session()
client.close()
def test_pools_recycle(self):
settings = tests.get_mysqlx_config()
pooling_dict = {
"max_size": 1,
"max_idle_time": 3000,
"queue_timeout": 1000
}
cnx_options = {"pooling": pooling_dict}
uri = ("mysqlx://{user}:{pwd}@["
" (address={host}:{port}, priority=50)]?connect_timeout=20000"
"".format(user=self.user,
pwd=self.password,
host=settings["host"],
port=settings["port"]))
client = mysqlx.get_client(uri, cnx_options)
def thread1(client):
# Getting a session from client
session1 = client.get_session()
session1.sql("SELECT 1").execute()
sleep(2)
session1.close()
def thread2(client):
# Getting a session from client
session2 = client.get_session()
session2.sql("SELECT 2").execute()
sleep(1)
session2.close()
worker1 = Thread(target=thread1, args=[client])
worker1.start()
worker1.join()
sleep(0.5)
worker2 = Thread(target=thread2, args=[client])
worker2.start()
worker2.join()
# Verify the server connections
connections = get_current_connections(self.session)
open_connections = connections.get("unauthenticated user", [])
if tests.MYSQL_VERSION < (8, 0, 16):
# Send reset message requires the user to re-authentificate
# the connection user stays in unauthenticated user
self.assertTrue(len(open_connections) >= 1)
else:
self.assertEqual(len(open_connections), 0)
client.close()
def test_pools_recycle(self):
settings = tests.get_mysqlx_config()
pooling_dict = {"max_size": 1, "max_idle_time": 3000,
"queue_timeout": 1000}
cnx_options = {"pooling": pooling_dict}
uri = ("mysqlx://{user}:{pwd}@["
" (address={host}:{port}, priority=50)]?connect_timeout=20000"
"".format(user=self.user, pwd=self.password,
host=settings["host"], port=settings["port"]))
client = mysqlx.get_client(uri, cnx_options)
def thread1(client):
# Getting a session from client
session1 = client.get_session()
session1.sql("SELECT 1").execute()
sleep(2)
session1.close()
def thread2(client):
# Getting a session from client
session2 = client.get_session()
session2.sql("SELECT 2").execute()
sleep(1)
session2.close()
worker1 = Thread(target=thread1, args=[client])
worker1.start()
worker1.join()
sleep(0.5)
worker2 = Thread(target=thread2, args=[client])
worker2.start()
worker2.join()
# Verify the server connections
connections = get_current_connections(self.session)
open_connections = connections.get("unauthenticated user", [])
if tests.MYSQL_VERSION < (8, 0, 16):
# Send reset message requires the user to re-authentificate
# the connection user stays in unauthenticated user
self.assertTrue(len(open_connections) >= 1)
else:
self.assertEqual(len(open_connections), 0)
client.close()
def setUp(self):
self.connect_kwargs = tests.get_mysqlx_config()
self.schema_name = self.connect_kwargs["schema"]
self.host = self.connect_kwargs['host']
try:
self.session = mysqlx.get_session(self.connect_kwargs)
except mysqlx.Error as err:
self.fail("{0}".format(err))
self.users = [("client_user", "passclient"), ("max_size", "max_pass")]
for user, password in self.users:
self.session.sql(DROP_USER.format(user=user, host=self.host)) \
.execute()
self.session.sql(CREATE_USER.format(user=user, host=self.host,
password=password)).execute()
# Grant all to new user on database
self.session.sql(GRANT_USER.format(database=self.schema_name,
user=user, host=self.host)) \
.execute()
def setUp(self):
self.connect_kwargs = tests.get_mysqlx_config()
self.schema_name = self.connect_kwargs["schema"]
self.host = self.connect_kwargs['host']
try:
self.session = mysqlx.get_session(self.connect_kwargs)
except mysqlx.Error as err:
self.fail("{0}".format(err))
self.users = [("client_user", "passclient"), ("max_size", "max_pass")]
for user, password in self.users:
self.session.sql(DROP_USER.format(user=user, host=self.host)) \
.execute()
self.session.sql(CREATE_USER.format(user=user, host=self.host,
password=password)).execute()
# Grant all to new user on database
self.session.sql(GRANT_USER.format(database=self.schema_name,
user=user, host=self.host)) \
.execute()
def setUp(self):
self.connect_kwargs = tests.get_mysqlx_config()
self.session = mysqlx.get_session(self.connect_kwargs)
self.session.sql('DROP DATABASE IF EXISTS my_test_schema').execute()
def setUp(self):
self.connect_kwargs = tests.get_mysqlx_config()
self.session = mysqlx.get_session(self.connect_kwargs)
self.session.sql('DROP DATABASE IF EXISTS my_test_schema').execute()
def tearDown(self):
session = mysqlx.get_session(tests.get_mysqlx_config())
for host in self.hosts:
session.sql(DROP_USER.format(user=self.user, host=host)).execute()
def test_routing_random(self):
settings = tests.get_mysqlx_config()
pooling_dict = {"enabled": True, "max_size": 5, 'queue_timeout': 1000}
cnx_options = {"pooling": pooling_dict}
uri = ("mysqlx://{user}:{pwd}@["
"(address=1.0.0.1:{port}, priority=20),"
" (address=1.0.0.2:{port}, priority=20),"
" (address=127.0.0.1:{port}, priority=30),"
" (address=localhost:{port}, priority=30),"
" (address=1.0.0.3:{port}, priority=60),"
" (address=1.0.0.4:{port}, priority=60)]"
"".format(user=settings["user"],
pwd=settings["password"],
port=settings["port"]))
client = mysqlx.get_client(uri, cnx_options)
# Getting a session must success, the higher priority will cause to a
# valid address to be used
sessions = []
for _ in range(10):
session = client.get_session()
sessions.append(session)
client.close()
# Test routers without priority
settings = tests.get_mysqlx_config()
pooling_dict = {"enabled": True, "max_size": 5, 'queue_timeout': 1000}
cnx_options = {"pooling": pooling_dict}
uri = ("mysqlx://{user}:{pwd}@["
"(address=1.0.0.2:{port}),"
" (address=1.0.0.1:{port}),"
" (address=127.0.0.1:{port}),"
" (address=localhost:{port}),"
" (address=127.0.0.1:{port}),"
" (address=localhost:{port})]"
"".format(user=settings["user"],
pwd=settings["password"],
port=settings["port"]))
client = mysqlx.get_client(uri, cnx_options)
# Getting the total of 10 sessions must success
sessions = []
for _ in range(10):
session = client.get_session()
sessions.append(session)
# verify error is thrown when the total sum of the pool sizes is reached
with self.assertRaises(mysqlx.errors.PoolError) as context:
_ = client.get_session()
self.assertTrue(
("pool max size has been reached" in context.exception.msg),
"Unexpected exception message found: {}"
"".format(context.exception.msg))
client.close()
# Verify "Unable to connect to any of the target hosts" error message
settings = tests.get_mysqlx_config()
pooling_dict = {"enabled": True, "max_size": 5, 'queue_timeout': 50}
cnx_options = {"pooling": pooling_dict}
uri = ("mysqlx://{user}:{pwd}@["
"(address=1.0.0.1:{port}),"
" (address=1.0.0.2:{port}),"
" (address=1.0.0.3:{port}),"
" (address=1.0.0.4:{port}),"
" (address=1.0.0.5:{port}),"
" (address=1.0.0.6:{port}),"
" (address=1.0.0.7:{port}),"
" (address=1.0.0.8:{port}),"
" (address=1.0.0.9:{port}),"
" (address=1.0.0.10:{port})]?connect-timeout=500"
"".format(user=settings["user"],
pwd=settings["password"] + "$%^",
port=settings["port"]))
client = mysqlx.get_client(uri, cnx_options)
with self.assertRaises(mysqlx.errors.PoolError) as context:
_ = client.get_session()
self.assertTrue(("Unable to connect to any of the target hosts"
in context.exception.msg),
"Unexpected exception message found: {}"
"".format(context.exception.msg))
try:
client.close()
except:
# due to the small connect-timeout closing the client may fail.
pass
# Verify random order of the pools
ip_orders = {}
attempts = 10
for _ in range(attempts):
client = mysqlx.get_client(uri, cnx_options)
with self.assertRaises(mysqlx.errors.PoolError) as context:
_ = client.get_session()
re_ip = re.compile(" pool: 1.0.0.(\d+).*")
order_list = []
for line in context.exception.msg.splitlines():
if "pool:" not in line:
continue
match = re_ip.match(line)
if match:
order_list.append(match.group(1))
# Verify the 10 pools were verified
self.assertEqual(
len(order_list), 10,
"10 exception messages were expected but found: {}"
"".format(context.exception.msg))
key = ",".join(order_list)
if not key in ip_orders:
ip_orders[key] = 1
else:
ip_orders[key] = ip_orders[key] + 1
try:
client.close()
except:
# due to the small connect-timeout closing the client may fail.
pass
max_repeated = -1
for ip_order in ip_orders:
cur = ip_orders[ip_order]
max_repeated = cur if cur > max_repeated else max_repeated
# The possiblility of getting 2 times the same order is : ((1/(10!))^2)*9
# Getting the same number of different orders than attempts ensures no repetitions.
self.assertEqual(
len(ip_orders), attempts, "Expected less repetions found: {}"
"".format([
"ip_order: {} reps: {}".format(ip_order, ip_orders[ip_order])
for ip_order in ip_orders
]))
