def tearDown(self): """ Setup (called on destroy) """ SolBase.logging_init(log_level='DEBUG', force_reset=True) Meters.write_to_logger() SolBase.logging_init(log_level='INFO', force_reset=True)
def _internal_test(self, client_count, ping_interval_ms, my_run_time_ms=20000): """ Test. :param client_count: Client count. :param ping_interval_ms: Ping interval in millis. :param my_run_time_ms: Run time in millis. :return: nothing. """ try: # Overrides statics (beuuurk but so gooood) self.clientMaxCount = client_count self.serverPingIntervalMs = ping_interval_ms self.clientPingIntervalMs = ping_interval_ms self.runTimeMs = my_run_time_ms # Expected server and client ping/src self.expectedPps = (float(self.clientMaxCount) / float(self.serverPingIntervalMs)) * 1000.0 logger.info("starting, client=%s, ping.ms=%s, expected.pps=%s", client_count, ping_interval_ms, self.expectedPps) # Instance self.tcp_server = None try: # Start server self._start_server_and_check() # Start client, check and stop client self._start_multi_client_checkallping_stop() # Stop server self._stop_server_and_check() except Exception as e: logger.error("Exception in test, ex=%s", SolBase.extostr(e)) raise finally: if self.tcp_server: self.tcp_server.stop_server() finally: # Final stats logger.info("Finished, final stats bellow") Meters.write_to_logger() # Reset self.tcp_server = None # Sleep Utility.test_wait()
def test_meters_with_tags_b(self): """ Test """ hca = Meters._tags_hash_compute_and_store({"flag1": "FA"}) hcb = Meters._tags_hash_compute_and_store({"flag2": "FB"}) Meters.aii("ai1") Meters.aii("ai1", tags={"flag1": "FA"}) Meters.aii("ai1", tags={"flag1": "FA"}) Meters.aii("ai1", tags={"flag2": "FB"}) Meters.aii("ai1", tags={"flag2": "FB"}) Meters.aii("ai1", tags={"flag2": "FB"}) Meters.dtci("dtc1", 0) Meters.dtci("dtc1", 50) Meters.dtci("dtc1", 100) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#"]._sorted_dict[0].get(), 1) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#"]._sorted_dict[50].get(), 1) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#"]._sorted_dict[100].get(), 1) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#"]._sorted_dict[500].get(), 0) Meters.dtci("dtc1", 0, tags={"flag1": "FA"}) Meters.dtci("dtc1", 50, tags={"flag1": "FA"}) Meters.dtci("dtc1", 100, tags={"flag1": "FA"}) Meters.dtci("dtc1", 0, tags={"flag2": "FB"}) Meters.dtci("dtc1", 50, tags={"flag2": "FB"}) Meters.dtci("dtc1", 100, tags={"flag2": "FB"}) Meters.dtci("dtc1", 0, tags={"flag2": "FB"}) Meters.dtci("dtc1", 50, tags={"flag2": "FB"}) Meters.dtci("dtc1", 100, tags={"flag2": "FB"}) self.assertEquals(Meters._hash_meter["a_int"]["ai1#"].get(), 1) self.assertEquals(Meters._hash_meter["a_int"]["ai1#" + hca].get(), 2) self.assertEquals(Meters._hash_meter["a_int"]["ai1#" + hcb].get(), 3) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#" + hca]._sorted_dict[0].get(), 1) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#" + hca]._sorted_dict[50].get(), 1) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#" + hca]._sorted_dict[100].get(), 1) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#" + hca]._sorted_dict[500].get(), 0) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#" + hcb]._sorted_dict[0].get(), 2) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#" + hcb]._sorted_dict[50].get(), 2) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#" + hcb]._sorted_dict[100].get(), 2) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#" + hcb]._sorted_dict[500].get(), 0) # Write Meters.write_to_logger()
def test_meters(self): """ Test """ ai1a = Meters.ai("ai1") self.assertIsInstance(ai1a, AtomicIntSafe) ai1b = Meters.ai("ai1") self.assertEqual(id(ai1a), id(ai1b)) ai1a = Meters.aii("ai1") self.assertEqual(ai1a.get(), 1) ai1a = Meters.aii("ai1", 2) self.assertEqual(ai1a.get(), 3) self.assertEqual(ai1a.get(), Meters.aig("ai1")) af1a = Meters.af("af1") self.assertIsInstance(af1a, AtomicFloatSafe) af1b = Meters.af("af1") self.assertEqual(id(af1a), id(af1b)) af1a = Meters.afi("af1") self.assertEqual(af1a.get(), 1.0) af1a = Meters.afi("af1", 2.0) self.assertEqual(af1a.get(), 3.0) self.assertEqual(af1a.get(), Meters.afg("af1")) dtc1a = Meters.dtc("dtc1") self.assertIsInstance(dtc1a, DelayToCountSafe) dtc1b = Meters.dtc("dtc1") self.assertEqual(id(dtc1a), id(dtc1b)) Meters.dtci("dtc1", 0) Meters.dtci("dtc1", 50) Meters.dtci("dtc1", 100) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#"]._sorted_dict[0].get(), 1) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#"]._sorted_dict[50].get(), 1) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#"]._sorted_dict[100].get(), 1) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#"]._sorted_dict[500].get(), 0) Meters.dtc("dtc1").to_dict() # Write Meters.write_to_logger()
def test_meters_to_udp(self): """ Test """ ai1a = Meters.ai("ai1") self.assertIsInstance(ai1a, AtomicIntSafe) ai1b = Meters.ai("ai1") self.assertEqual(id(ai1a), id(ai1b)) ai1a = Meters.aii("ai1") self.assertEqual(ai1a.get(), 1) ai1a = Meters.aii("ai1", 2) self.assertEqual(ai1a.get(), 3) self.assertEqual(ai1a.get(), Meters.aig("ai1")) af1a = Meters.af("af1") self.assertIsInstance(af1a, AtomicFloatSafe) af1b = Meters.af("af1") self.assertEqual(id(af1a), id(af1b)) af1a = Meters.afi("af1") self.assertEqual(af1a.get(), 1.0) af1a = Meters.afi("af1", 2.0) self.assertEqual(af1a.get(), 3.0) self.assertEqual(af1a.get(), Meters.afg("af1")) dtc1a = Meters.dtc("dtc1") self.assertIsInstance(dtc1a, DelayToCountSafe) dtc1b = Meters.dtc("dtc1") self.assertEqual(id(dtc1a), id(dtc1b)) Meters.dtci("dtc1", 0) Meters.dtci("dtc1", 50) Meters.dtci("dtc1", 100) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#"]._sorted_dict[0].get(), 1) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#"]._sorted_dict[50].get(), 1) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#"]._sorted_dict[100].get(), 1) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#"]._sorted_dict[500].get(), 0) # Write Meters.write_to_logger() # Serialize ar_json = Meters.meters_to_udp_format(send_pid=True, send_dtc=True) logger.info("Got ar_json=%s", ar_json) for cur_ar in ar_json: logger.info("Got cur_ar=%s", cur_ar) # Serialize, no dtc ar_json = Meters.meters_to_udp_format(send_pid=True, send_dtc=False) logger.info("Got ar_json=%s", ar_json) for cur_ar in ar_json: logger.info("Got cur_ar=%s", cur_ar) # Send to daemon (assuming its up locally) Meters.send_udp_to_knockdaemon() Meters.send_udp_to_knockdaemon(send_dtc=True) Meters.send_udp_to_knockdaemon(send_dtc=False) # ------------------------ # UDP Scheduler test # ------------------------ # Check self.assertIsNone(Meters.UDP_SCHEDULER_GREENLET) self.assertFalse(Meters.UDP_SCHEDULER_STARTED) # Start Meters.udp_scheduler_start(send_interval_ms=500) # Check self.assertIsNotNone(Meters.UDP_SCHEDULER_GREENLET) self.assertTrue(Meters.UDP_SCHEDULER_STARTED) # Start again Meters.udp_scheduler_start(send_interval_ms=500) # Check again self.assertIsNotNone(Meters.UDP_SCHEDULER_GREENLET) self.assertTrue(Meters.UDP_SCHEDULER_STARTED) # Interval is 500 => we sleep 3.250 sec, we assume we must have at least 500, 1000, 1500, 2000, 2500, 3000 run => 6 runs SolBase.sleep(3250) # Check self.assertGreaterEqual(Meters.aig("k.meters.udp.run.ok"), 6) self.assertEqual(Meters.aig("k.meters.udp.run.ex"), 0) self.assertIsNotNone(Meters.UDP_SCHEDULER_GREENLET) self.assertTrue(Meters.UDP_SCHEDULER_STARTED) # We stop Meters.udp_scheduler_stop() self.assertIsNone(Meters.UDP_SCHEDULER_GREENLET) self.assertFalse(Meters.UDP_SCHEDULER_STARTED) # Sleep again and check no more running cur_run = Meters.aig("k.meters.udp.run.ok") SolBase.sleep(2000) self.assertEqual(cur_run, Meters.aig("k.meters.udp.run.ok"))
def test_meters_with_tags_a_with_udp_check(self): """ Test """ hca = Meters._tags_hash_compute_and_store({"flag": "FA"}) hcb = Meters._tags_hash_compute_and_store({"flag": "FB"}) Meters.aii("ai1") Meters.aii("ai1", tags={"flag": "FA"}) Meters.aii("ai1", tags={"flag": "FA"}) Meters.aii("ai1", tags={"flag": "FB"}) Meters.aii("ai1", tags={"flag": "FB"}) Meters.aii("ai1", tags={"flag": "FB"}) Meters.dtci("dtc1", 0) Meters.dtci("dtc1", 50) Meters.dtci("dtc1", 100) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#"]._sorted_dict[0].get(), 1) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#"]._sorted_dict[50].get(), 1) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#"]._sorted_dict[100].get(), 1) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#"]._sorted_dict[500].get(), 0) Meters.dtci("dtc1", 0, tags={"flag": "FA"}) Meters.dtci("dtc1", 50, tags={"flag": "FA"}) Meters.dtci("dtc1", 100, tags={"flag": "FA"}) Meters.dtci("dtc1", 0, tags={"flag": "FB"}) Meters.dtci("dtc1", 50, tags={"flag": "FB"}) Meters.dtci("dtc1", 100, tags={"flag": "FB"}) Meters.dtci("dtc1", 0, tags={"flag": "FB"}) Meters.dtci("dtc1", 50, tags={"flag": "FB"}) Meters.dtci("dtc1", 100, tags={"flag": "FB"}) self.assertEquals(Meters._hash_meter["a_int"]["ai1#"].get(), 1) self.assertEquals(Meters._hash_meter["a_int"]["ai1#" + hca].get(), 2) self.assertEquals(Meters._hash_meter["a_int"]["ai1#" + hcb].get(), 3) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#" + hca]._sorted_dict[0].get(), 1) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#" + hca]._sorted_dict[50].get(), 1) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#" + hca]._sorted_dict[100].get(), 1) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#" + hca]._sorted_dict[500].get(), 0) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#" + hcb]._sorted_dict[0].get(), 2) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#" + hcb]._sorted_dict[50].get(), 2) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#" + hcb]._sorted_dict[100].get(), 2) self.assertEquals(Meters._hash_meter["dtc"]["dtc1#" + hcb]._sorted_dict[500].get(), 0) # Write Meters.write_to_logger() # Upd check ar_udp = Meters.meters_to_udp_format(send_pid=True, send_tags=True, send_dtc=True) total_check = 0 total_ok = 0 total_ko_not_found = 0 total_ko_multiple_found = 0 for s_key, d_tag, v in [ ("ai1", {}, 1), ("ai1", {"flag": "FA", }, 2), ("ai1", {"flag": "FB", }, 3), ("dtc1_0-50", {}, 1), ("dtc1_50-100", {}, 1), ("dtc1_100-500", {}, 1), ("dtc1_500-1000", {}, 0), ("dtc1_1000-2500", {}, 0), ("dtc1_2500-5000", {}, 0), ("dtc1_5000-10000", {}, 0), ("dtc1_10000-30000", {}, 0), ("dtc1_30000-60000", {}, 0), ("dtc1_60000-MAX", {}, 0), ("dtc1_0-50", {"flag": "FA", }, 1), ("dtc1_50-100", {"flag": "FA", }, 1), ("dtc1_100-500", {"flag": "FA", }, 1), ("dtc1_500-1000", {"flag": "FA", }, 0), ("dtc1_1000-2500", {"flag": "FA", }, 0), ("dtc1_2500-5000", {"flag": "FA", }, 0), ("dtc1_5000-10000", {"flag": "FA", }, 0), ("dtc1_10000-30000", {"flag": "FA", }, 0), ("dtc1_30000-60000", {"flag": "FA", }, 0), ("dtc1_60000-MAX", {"flag": "FA", }, 0), ("dtc1_0-50", {"flag": "FB", }, 2), ("dtc1_50-100", {"flag": "FB", }, 2), ("dtc1_100-500", {"flag": "FB", }, 2), ("dtc1_500-1000", {"flag": "FB", }, 0), ("dtc1_1000-2500", {"flag": "FB", }, 0), ("dtc1_2500-5000", {"flag": "FB", }, 0), ("dtc1_5000-10000", {"flag": "FB", }, 0), ("dtc1_10000-30000", {"flag": "FB", }, 0), ("dtc1_30000-60000", {"flag": "FB", }, 0), ("dtc1_60000-MAX", {"flag": "FB", }, 0), ]: total_check += 1 # Locate it found = 0 for check_key, check_tag, check_v, _, _ in ar_udp: if check_key == s_key and check_tag == d_tag and check_v == v: found += 1 # Check if found == 0: total_ko_not_found += 1 elif found > 1: total_ko_multiple_found += 1 else: total_ok += 1 # Final self.assertEquals(total_ko_multiple_found, 0) self.assertEquals(total_ko_multiple_found, 0) self.assertEquals(total_ok, total_check) self.assertEquals(len(ar_udp), total_check)
def _go_greenlet(self, greenlet_count, put_count, get_count, bench_item_count): """ Doc :param greenlet_count: greenlet_count :param put_count: put_count :param get_count: get_count :param bench_item_count: bench_item_count """ g_event = None g_array = None try: # Settings g_count = greenlet_count g_ms = 10000 # Continue callback loop self.callback_return = True # Go self.redis_cache = RedisCache() # Item count self.bench_item_count = bench_item_count self.bench_put_weight = put_count self.bench_get_weight = get_count self.bench_ttl_min_ms = 1000 self.bench_ttl_max_ms = int(g_ms / 2) # Go self.run_event = Event() self.exception_raised = 0 self.open_count = 0 self.thread_running = AtomicIntSafe() self.thread_running_ok = AtomicIntSafe() # Item per greenlet item_per_greenlet = self.bench_item_count / g_count # 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 cur_idx = 0 for idx in range(0, len(g_array)): greenlet = g_array[idx] event = g_event[idx] greenlet.spawn(self._run_cache_bench, event, cur_idx, cur_idx + item_per_greenlet) cur_idx += item_per_greenlet SolBase.sleep(0) # Signal self.gorun_event.set() # Wait a bit dt = SolBase.mscurrent() while SolBase.msdiff(dt) < g_ms: SolBase.sleep(500) # Stat ms = SolBase.msdiff(dt) sec = float(ms / 1000.0) total_put = Meters.aig("rcs.cache_put") per_sec_put = round(float(total_put) / sec, 2) total_get = Meters.aig("rcs.cache_get_hit") + Meters.aig( "rcs.cache_get_miss") per_sec_get = round(float(total_get) / sec, 2) logger.info( "Running..., count=%s, run=%s, ok=%s, put/sec=%s get/sec=%s, cache=%s", self.open_count, self.thread_running.get(), self.thread_running_ok.get(), per_sec_put, per_sec_get, self.redis_cache) self.assertEqual(self.exception_raised, 0) # Over, signal logger.info("Signaling, count=%s", self.open_count) self.run_event.set() # Wait for g in g_event: g.wait(30.0) self.assertTrue(g.isSet()) g_event = None g_array = None # Log Meters.write_to_logger() 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() if self.redis_cache: self.redis_cache.stop_cache() self.redis_cache = None
def _start_multi_client_checkallping_stop(self): """ Test """ # Start self._start_multi_client(self.clientMaxCount) # Here we must wait # 1) Client : already connected, must # - send hello, have a reply # - send a ping, have a reply # - reply to one server ping # 2) Server # - receive a hello and reply # - send a ping, have a reply # - reply to one client ping # => We check using the static PingStatXXX flush_stat_inloop = False dt = SolBase.datecurrent() dt_stat = SolBase.datecurrent() dt_loop = SolBase.datecurrent() client_prev_completed_ping = 0 server_prev_completed_ping = 0 while SolBase.datediff(dt) < self.runTimeMs: # Wait SolBase.sleep(1000) # Client client_ko = PingTestTools.get_client_ko_count( False, self.clientMaxCount) # Server server_ko = PingTestTools.get_server_ko_count( False, self.clientMaxCount) # Total ping client_total_completed_ping = Meters.aig( "ping.client.client_ping_server_reply") server_total_completed_ping = Meters.aig( "ping.server.serverPingClientReply") # Current ping client_local_completed_ping = client_total_completed_ping - client_prev_completed_ping server_local_completed_ping = server_total_completed_ping - server_prev_completed_ping # Store prev client_prev_completed_ping = client_total_completed_ping server_prev_completed_ping = server_total_completed_ping # Elapsed ms elapsed_ms = SolBase.datediff(dt_loop) elapsed_total_ms = SolBase.datediff(dt) # Ping per sec. client_local_pps = (client_local_completed_ping / (elapsed_ms / 1000.0)) server_local_pps = (server_local_completed_ping / (elapsed_ms / 1000.0)) client_avg_pps = (client_total_completed_ping / (elapsed_total_ms / 1000.0)) server_avg_pps = (server_total_completed_ping / (elapsed_total_ms / 1000.0)) # Reset date dt_loop = SolBase.datecurrent() # Wait logger.info( "Running : ko=%s:%s, sec=%s/%s, cli.ping=%s, svr.ping=%s, exp.pps=%.2f, " "cli.pps=%.2f, svr.pps=%.2f, cli.aps=%.2f, svr.aps=%.2f", client_ko, server_ko, int(SolBase.datediff(dt) / 1000), int(self.runTimeMs / 1000), client_local_completed_ping, server_local_completed_ping, self.expectedPps, client_local_pps, server_local_pps, client_avg_pps, server_avg_pps) # Stat if flush_stat_inloop and SolBase.datediff( dt_stat) > self.statEveryMs: Meters.write_to_logger() dt_stat = SolBase.datecurrent() # Final check client_ko = PingTestTools.get_client_ko_count(True, self.clientMaxCount) server_ko = PingTestTools.get_server_ko_count(True, self.clientMaxCount) self.assertEqual(client_ko, 0) self.assertEqual(server_ko, 0) # Stop self._stop_multi_client()
def _go_greenlet(self, greenlet_count, put_count, get_count, bench_item_count, watchdog_interval_ms=60000, max_item=128000, max_bytes=32 * 1024 * 1024, max_single_item_bytes=1 * 1024 * 1024, purge_min_bytes=8 * 1024 * 1024, purge_min_count=1000): """ Doc :param greenlet_count: greenlet_count :param put_count: put_count :param get_count: get_count :param bench_item_count: bench_item_count :param watchdog_interval_ms: watchdog_interval_ms :param max_item: max_item :param max_bytes: max_bytes :param max_single_item_bytes: max_single_item_bytes :param purge_min_bytes: purge_min_bytes :param purge_min_count: purge_min_count """ g_event = None g_array = None try: # Settings g_count = greenlet_count g_ms = 10000 # Continue callback loop self.callback_return = True # Go self.mem_cache = MemoryCache( watchdog_interval_ms=watchdog_interval_ms, max_item=max_item, max_bytes=max_bytes, max_single_item_bytes=max_single_item_bytes, purge_min_bytes=purge_min_bytes, purge_min_count=purge_min_count) # Item count self.bench_item_count = bench_item_count self.bench_put_weight = put_count self.bench_get_weight = get_count self.bench_ttl_min_ms = 1000 self.bench_ttl_max_ms = int(g_ms / 2) # Go self.run_event = Event() self.exception_raised = 0 self.open_count = 0 self.thread_running = AtomicIntSafe() self.thread_running_ok = AtomicIntSafe() # Item per greenlet item_per_greenlet = self.bench_item_count / g_count # 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 cur_idx = 0 for idx in range(0, len(g_array)): greenlet = g_array[idx] event = g_event[idx] greenlet.spawn(self._run_cache_bench, event, cur_idx, cur_idx + item_per_greenlet) cur_idx += item_per_greenlet SolBase.sleep(0) # Signal self.gorun_event.set() # Wait a bit dt = SolBase.mscurrent() while SolBase.msdiff(dt) < g_ms: SolBase.sleep(500) # Stat ms = SolBase.msdiff(dt) sec = float(ms / 1000.0) total_put = Meters.aig("mcs.cache_put") per_sec_put = round(float(total_put) / sec, 2) total_get = Meters.aig("mcs.cache_get_hit") + Meters.aig( "mcs.cache_get_miss") per_sec_get = round(float(total_get) / sec, 2) logger.info( "Running..., count=%s, run=%s, ok=%s, put/sec=%s get/sec=%s, cache=%s", self.open_count, self.thread_running.get(), self.thread_running_ok.get(), per_sec_put, per_sec_get, self.mem_cache) self.assertEqual(self.exception_raised, 0) # Over, signal logger.info("Signaling, count=%s", self.open_count) self.run_event.set() # Wait for g in g_event: g.wait(30.0) self.assertTrue(g.isSet()) g_event = None g_array = None # Log Meters.write_to_logger() 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() if self.mem_cache: max_count = 0 total_size = 0 i = 0 for (k, v) in self.mem_cache._hash_key.items(): i += 1 total_size += len(k) + len(v[1]) if i < max_count: logger.info("%s => %s", k, v) self.assertEqual(total_size, self.mem_cache._current_data_bytes.get()) self.mem_cache.stop_cache() self.mem_cache = None