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()