def setUp(self):
"""
Setup
"""
MysqlApi.reset_pools()
Meters.reset()
d_conf_root = {
"host": "localhost",
"port": 3306,
"database": None,
"user": "******",
"password": "******",
"autocommit": True,
}
# exec_n
try:
ar = MysqlApi.exec_n(d_conf_root,
"DROP DATABASE IF EXISTS pysolmysql_test;")
logger.info("ar=%s", ar)
except Exception as e:
logger.debug("Ex=%s", SolBase.extostr(e))
MysqlApi.exec_n(d_conf_root,
"CREATE DATABASE IF NOT EXISTS pysolmysql_test;")
# Full reset
MysqlApi.reset_pools()
Meters.reset()
def test_pool_basic_x2(self):
"""
Test pool, basic
"""
MysqlApi.reset_pools()
Meters.reset()
d_conf = {
"hosts": ["localhost", "127.0.0.1"],
"port": 3306,
"database": None,
"user": "******",
"password": "******",
"autocommit": True,
}
for _ in range(0, 10):
MysqlApi.exec_1(d_conf,
"SELECT user, host FROM mysql.user LIMIT 1;")
d_conf = {
"hosts": ["localhost", "localhost"],
"port": 3306,
"database": None,
"user": "******",
"password": "******",
"autocommit": True,
}
for _ in range(0, 10):
MysqlApi.exec_1(d_conf,
"SELECT user, host FROM mysql.user LIMIT 1;")
# Check it
self.assertEquals(Meters.aig("k.db_pool.hash.cur"), 1 * 2)
self.assertEquals(Meters.aig("k.db_pool.base.cur_size"), 1 * 2)
self.assertEquals(Meters.aig("k.db_pool.base.call.connection_acquire"),
10 * 2)
self.assertEquals(Meters.aig("k.db_pool.base.call.connection_release"),
10 * 2)
self.assertEquals(Meters.aig("k.db_pool.mysql.call.__init"), 1 * 2)
self.assertEquals(
Meters.aig("k.db_pool.mysql.call._connection_create"), 1 * 2)
self.assertEquals(Meters.aig("k.db_pool.mysql.call._get_connection"),
1 * 2)
self.assertEquals(Meters.aig("k.db_pool.mysql.call._connection_ping"),
10 * 2)
def setUp(self):
"""
Setup (called before each test)
"""
# Initialize asap
SolBase.voodoo_init()
SolBase.set_compo_name("CompoNotSet")
self.assertTrue(SolBase._voodoo_initialized)
self.assertTrue(SolBase._logging_initialized)
# Reset
Meters.reset()
# Bench
self.per_loop = 10000
self.max_ms = 2000
def setUp(self):
"""
Setup
"""
SolBase.voodoo_init()
Utility.gevent_reset()
Utility.test_wait()
# Init
self.tcp_server = None
self.arTcpClient = None
# Config server
self.serverHelloTimeOutMs = 30000
self.serverPingIntervalMs = 10000
self.serverPingTimeOutMs = 60000
# Config client
self.clientHelloTimeOutMs = 30000
self.clientPingIntervalMs = 10000
self.clientPingTimeOutMs = 60000
# Config test
self.runTimeMs = 20000
self.statEveryMs = 10000
self.checkTimeOutMs = 60000
# Client config test
self.clientMaxCount = 5
# Misc
self.expectedPps = 0
# Debug
self.debug_log = False
# Reset
Meters.reset()
# ssl
self.testSsl = False
self.testProxy = False
self.certificatesPath = Utility.generate_server_keys()
def test_pool_basic_host_multi(self):
"""
Test pool, basic
"""
MysqlApi.reset_pools()
Meters.reset()
d_conf = {
"host": "localhost,127.0.0.1",
"port": 3306,
"database": None,
"user": "******",
"password": "******",
"autocommit": True,
}
for _ in range(0, 10):
MysqlApi.exec_1(d_conf,
"SELECT user, host FROM mysql.user LIMIT 1;")
# Check it
self.assertEquals(Meters.aig("k.db_pool.hash.cur"), 1)
self.assertEquals(Meters.aig("k.db_pool.base.cur_size"), 1)
self.assertEquals(Meters.aig("k.db_pool.base.call.connection_acquire"),
10)
self.assertEquals(Meters.aig("k.db_pool.base.call.connection_release"),
10)
self.assertEquals(Meters.aig("k.db_pool.mysql.call.__init"), 1)
self.assertEquals(
Meters.aig("k.db_pool.mysql.call._connection_create"), 1)
self.assertEquals(Meters.aig("k.db_pool.mysql.call._get_connection"),
1)
self.assertEquals(Meters.aig("k.db_pool.mysql.call._connection_ping"),
10)
s_hash = MysqlApi._get_pool_hash(d_conf)
self.assertEquals(len(MysqlApi.D_POOL_INSTANCES[s_hash].host_status),
2)
self.assertIn("localhost",
MysqlApi.D_POOL_INSTANCES[s_hash].host_status)
self.assertIn("127.0.0.1",
MysqlApi.D_POOL_INSTANCES[s_hash].host_status)
def setUp(self):
"""
Setup
"""
# Reset counters
Meters.reset()
# Clear
self.redis_cache = None
# Key prefix
self.key_prefix = "rk_" + str(int(SolBase.mscurrent())) + "_"
# Temp redis : clear ALL
r = redis.Redis()
r.flushall()
del r
def setUp(self):
"""
Setup
"""
# Reset counters
Meters.reset()
# Clear
self.mem_cache = None
self.callback_call = 0
self.callback_evicted = 0
self.callback_return = False
self.evict_count = 0
self.evict_last_key = None
self.evict_last_value = None
def test_pool_basic_bad_db(self):
"""
Test pool, basic
"""
MysqlApi.reset_pools()
Meters.reset()
d_conf = {
"hosts": ["localhost", "127.0.0.1"],
"port": 3306,
"database": "no_db",
"user": "******",
"password": "******",
"autocommit": True,
}
try:
MysqlApi.exec_1(d_conf,
"SELECT user, host FROM no_db.user LIMIT 1;")
except Exception as e:
logger.debug("Expected ex=%s", SolBase.extostr(e))
# Check it
self.assertEquals(Meters.aig("k.db_pool.hash.cur"), 1)
self.assertEquals(Meters.aig("k.db_pool.base.cur_size"), 0)
self.assertEquals(Meters.aig("k.db_pool.base.call.connection_acquire"),
1)
self.assertEquals(Meters.aig("k.db_pool.base.call.connection_release"),
1)
self.assertEquals(Meters.aig("k.db_pool.mysql.call.__init"), 1)
self.assertEquals(
Meters.aig("k.db_pool.mysql.call._connection_create"), 1)
self.assertEquals(Meters.aig("k.db_pool.mysql.call._get_connection"),
2)
self.assertEquals(Meters.aig("k.db_pool.mysql.call._connection_close"),
2)
self.assertEquals(Meters.aig("k.db_pool.mysql.hosts.deactivate_one"),
2)
self.assertEquals(Meters.aig("k.db_pool.mysql.hosts.all_down"), 1)
def test_pool_basic_err(self):
"""
Test pool, basic
"""
MysqlApi.reset_pools()
Meters.reset()
d_conf = {
"hosts": ["localhost", "127.0.0.1"],
"port": 3306,
"database": None,
"user": "******",
"password": "******",
"autocommit": True,
}
for _ in range(0, 10):
MysqlApi.exec_1(d_conf,
"SELECT user, host FROM mysql.user LIMIT 1;")
# Error
try:
MysqlApi.exec_1(d_conf, "SELECT zzz FROM mysql.no_table;")
except ProgrammingError as e:
logger.debug("Expected ex=%s", SolBase.extostr(e))
# Check it
self.assertEquals(Meters.aig("k.db_pool.hash.cur"), 1)
self.assertEquals(Meters.aig("k.db_pool.base.cur_size"), 1)
self.assertEquals(Meters.aig("k.db_pool.base.call.connection_acquire"),
11)
self.assertEquals(Meters.aig("k.db_pool.base.call.connection_release"),
11)
self.assertEquals(Meters.aig("k.db_pool.mysql.call.__init"), 1)
self.assertEquals(
Meters.aig("k.db_pool.mysql.call._connection_create"), 1)
self.assertEquals(Meters.aig("k.db_pool.mysql.call._get_connection"),
1)
self.assertEquals(Meters.aig("k.db_pool.mysql.call._connection_ping"),
11)
def _meters_inject(cls, count):
"""
Inject meters for chunk test
:param count: int
:type count: int
"""
# Inject meters
Meters.reset()
for i in range(0, count):
# 10 tags each
d_tags = dict()
for k in range(0, 10):
d_tags["TAG_aaaaaaaaaaaaaaaaa_%s_%s" % (i, k)] = "VAL_aaaaaaaaaaaaaaaaa_%s_%s" % (i, k)
# Inject
Meters.aii("k.meters.aii_udp_check_%s" % i, tags=d_tags)
# Dtc
for ms in [0, 10, 100, 500, 5000, 10000, 60000]:
Meters.dtci("k.meters.dtci_udp_check_%s" % i, ms, tags=d_tags)
def setUp(self):
"""
Setup
"""
Utility.gevent_reset()
SolBase.voodoo_init()
Utility.test_wait()
# Init
self.tcp_server = None
self.tcpClient = None
# Config server
self.serverHelloTimeOutMs = 10000
self.serverPingIntervalMs = 10000
self.serverPingTimeoutMs = 10000
# Config client
self.clientHelloTimeOutMs = 10000
self.clientPingIntervalMs = 10000
self.clientPingTimeOutMs = 10000
# Config test
self.checkTimeOutMs = 10000
self.checkPingTimeOutMs = 30000
# Client config test
self.clientMaxCount = 10000
self.clientWaitMsBetweenSegment = 5000
self.clientSegment = 100
# Reset
Meters.reset()
# ssl
self.testSsl = False
self.certificatesPath = Utility.generate_server_keys()
def test_tags_hash(self):
"""
Test
"""
d1 = {"a": "va", "b": "vb"}
s1 = Meters._tags_hash_compute_and_store(d1)
self.assertIsNotNone(s1)
self.assertGreater(len(s1), 0)
self.assertIn(s1, Meters._hash_meter["tags_hash"])
self.assertEquals(d1, Meters._hash_meter["tags_hash"][s1])
d2 = {"b": "vb", "a": "va"}
s2 = Meters._tags_hash_compute_and_store(d2)
self.assertIsNotNone(s2)
self.assertGreater(len(s2), 0)
self.assertIn(s2, Meters._hash_meter["tags_hash"])
self.assertEquals(d2, Meters._hash_meter["tags_hash"][s2])
d3 = {"a": "za", "b": "zb"}
s3 = Meters._tags_hash_compute_and_store(d3)
self.assertIsNotNone(s3)
self.assertGreater(len(s3), 0)
self.assertIn(s3, Meters._hash_meter["tags_hash"])
self.assertNotEqual(s1, s3)
self.assertEquals(s1, s2)
self.assertEquals(len(Meters._hash_meter["tags_hash"]), 2)
Meters.reset()
self.assertEquals(len(Meters._hash_meter["tags_hash"]), 0)
s_tags_1 = Meters.tags_format_for_logger(d1)
s_tags_2 = Meters.tags_format_for_logger(d2)
logger.info("Got s_tags_1=%s", s_tags_1)
logger.info("Got s_tags_2=%s", s_tags_2)
self.assertEquals(s_tags_1, s_tags_2)
self.assertEquals(s_tags_1, " (a:va,b:vb) ")
def test_meters_bench(self):
"""
Test
"""
# For logs format
SolBase.sleep(100)
logger.info("Bench now")
Meters.reset()
self._bench(1, "aii_tags_NO", Meters.aii, "aii1", 1, None)
Meters.reset()
self._bench(1, "aii_tags_go", Meters.aii, "aii1", 1, {"T1": "V1", "T2": "V2"})
Meters.reset()
self._bench(1, "dtc_tags_NO", Meters.dtci, "aii1", 0.1, 1, None)
Meters.reset()
self._bench(1, "dtc_tags_go", Meters.dtci, "aii1", 0.1, 1, {"T1": "V1", "T2": "V2"})
Meters.reset()
self._bench(1, "dtc_tags_big_NO", Meters.dtci, "aii1", 1000000000, 1, None)
Meters.reset()
self._bench(1, "dtc_tags_big_go", Meters.dtci, "aii1", 1000000000, 1, {"T1": "V1", "T2": "V2"})
# For logs format
SolBase.sleep(100)
logger.info("Bench over")
def _go_greenlet(self,
greenlet_count,
pool_max,
sql="SELECT user, host FROM mysql.user LIMIT 1;",
check_exception=True):
"""
Doc
:param greenlet_count: greenlet_count
:type greenlet_count: int
:param pool_max: Pool max size
:type pool_max: int
:param sql: str
:type sql: str
:param check_exception: bool
:type check_exception: bool
"""
MysqlApi.reset_pools()
Meters.reset()
g_event = None
g_array = None
try:
# Settings
g_count = greenlet_count
g_ms = 5000
# Go
self.pool_max = pool_max
self.run_event = Event()
self.exception_raised = 0
self.pool_sql = sql
self.thread_running = AtomicIntSafe()
self.thread_running_ok = AtomicIntSafe()
# Signal
self.gorun_event = Event()
# Alloc greenlet
g_array = list()
g_event = list()
for _ in range(0, g_count):
greenlet = Greenlet()
g_array.append(greenlet)
g_event.append(Event())
# Run them
for idx in range(0, len(g_array)):
greenlet = g_array[idx]
event = g_event[idx]
greenlet.spawn(self._run_mysql_bench, event)
SolBase.sleep(0)
# Signal
self.gorun_event.set()
# Wait a bit
dt = SolBase.mscurrent()
while SolBase.msdiff(dt) < g_ms:
SolBase.sleep(1000)
# Stat
ms = SolBase.msdiff(dt)
sec = float(ms / 1000.0)
total_acquire = Meters.aig(
"k.db_pool.base.call.connection_acquire")
per_sec_acquire = round(float(total_acquire) / sec, 2)
total_release = Meters.aig(
"k.db_pool.base.call.connection_release")
per_sec_release = round(float(total_release) / sec, 2)
logger.info("Running..., run=%s, ok=%s, ps.ack/rel=%s/%s",
self.thread_running.get(),
self.thread_running_ok.get(), per_sec_acquire,
per_sec_release)
if check_exception:
self.assertEqual(self.exception_raised, 0)
# Over, signal
logger.info("Signaling")
self.run_event.set()
# Wait
for g in g_event:
g.wait(30.0)
self.assertTrue(g.isSet())
g_event = None
g_array = None
# Check it
self.assertEquals(
Meters.aig("k.db_pool.base.call.connection_acquire"),
Meters.aig("k.db_pool.base.call.connection_release"))
if check_exception:
self.assertEquals(
Meters.aig("k.db_pool.base.call.connection_acquire"),
Meters.aig("k.db_pool.mysql.call._connection_ping"))
self.assertLessEqual(
Meters.aig("k.db_pool.mysql.call._get_connection"), pool_max)
self.assertLessEqual(
Meters.aig("k.db_pool.mysql.call._connection_create"),
pool_max)
self.assertLessEqual(Meters.aig("k.db_pool.hash.cur"), 1)
self.assertLessEqual(Meters.aig("k.db_pool.base.cur_size"),
pool_max)
self.assertLessEqual(Meters.aig("k.db_pool.base.max_size"),
pool_max)
self.assertEquals(Meters.aig("k.db_pool.mysql.call.__init"), 1)
finally:
self.run_event.set()
if g_event:
for g in g_event:
g.set()
if g_array:
for g in g_array:
g.kill()
