def _schedule_next_watchdog(self): """ Schedule next run. """ try: # Started ? if not self._is_started: return with self._run_lock: # Re-check if not self._is_started: return # Yes, schedule self._watchdog_greenlet = gevent.spawn_later( self._watchdog_interval_ms * 0.001, self._watchdog_run) # Wait SolBase.sleep(0) except Exception as e: logger.error("_schedule_next_watchdog : Exception, e=%s", SolBase.extostr(e)) finally: pass
def _server_forever(self): """ Exec loop """ try: # Alloc logger.info("Allocating WSGIServer") self._wsgi_server = WSGIServer(listener=('localhost', 7900), application=self.on_request) logger.info("Starting, %s, %s", self._wsgi_server.address, _parse_address(self._wsgi_server.address)) SolBase.sleep(0) # Signal logger.info("Signaling _start_event") self._start_event.set() SolBase.sleep(0) # This will block until signaled logger.info("Calling serve_forever") self._wsgi_server.serve_forever() except Exception as e: logger.error("Ex=%s", SolBase.extostr(e)) # This is fatal, we exit, we cannot serve exit(-1) finally: logger.info("Clearing _start_event") self._start_event.clear()
def test_basic_eviction_with_get_ttl(self): """ Test :return: """ # Alloc self.mem_cache = MemoryCache(cb_evict=self.eviction_callback) # Put self.mem_cache.put("keyA", b"valA", 60000) self.mem_cache.put("keyB", b"valB", 500) logger.info("ms cur=%s", SolBase.mscurrent()) logger.info("A : %s", self.mem_cache.get_raw("keyA")) logger.info("B : %s", self.mem_cache.get_raw("keyB")) # Wait a bit SolBase.sleep(600) logger.info("ms after sleep=%s", SolBase.mscurrent()) # A : must be present # B : must be evicted (TTL elapsed) self.assertEqual(self.mem_cache.get("keyA"), b"valA") self.assertIsNone(self.mem_cache.get("keyB")) self.assertEqual(self.evict_count, 1) self.assertEqual(self.evict_last_key, "keyB") self.assertEqual(self.evict_last_value, b"valB") self.assertEqual(Meters.aig("mcs.cache_evict_ttl_get"), 1) # Stop self.mem_cache.stop_cache() self.mem_cache = None
def start(self): """ Start """ with self._locker: try: lifecyclelogger.info("Start : starting") # Check if self._is_running: logger.warning("Already running, doing nothing") # Start self._server_greenlet = gevent.spawn(self._server_forever) SolBase.sleep(0) # Wait lifecyclelogger.debug("Start : waiting") self._start_event.wait() SolBase.sleep(0) # Signal self._is_running = True lifecyclelogger.info("Start : started") except Exception as e: logger.error("Exception, e=%s", SolBase.extostr(e))
def test_basic_ttl(self): """ Test :return: """ # Alloc self.redis_cache = RedisCache() # Put self.redis_cache.put(self.key_prefix + "keyA", b"valA", 60000) self.redis_cache.put(self.key_prefix + "keyB", b"valB", 1000) logger.info("ms cur=%s", SolBase.mscurrent()) logger.info("A : %s", self.redis_cache.get(self.key_prefix + "keyA")) logger.info("B : %s", self.redis_cache.get(self.key_prefix + "keyB")) # Wait a bit SolBase.sleep(2000) logger.info("ms after sleep=%s", SolBase.mscurrent()) # A : must be present # B : must be evicted (TTL elapsed) self.assertEqual(self.redis_cache.get(self.key_prefix + "keyA"), b"valA") self.assertIsNone(self.redis_cache.get(self.key_prefix + "keyB")) self.assertEqual(Meters.aig("rcs.cache_put"), 2) self.assertEqual(Meters.aig("rcs.cache_get_hit"), 3) self.assertEqual(Meters.aig("rcs.cache_get_miss"), 1) # Stop self.redis_cache.stop_cache() self.redis_cache = None
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 _remove_client_asynch(self, client_id): """ Remove a client, asynch. :param client_id: The client id. :type client_id: int """ # Spawn logger.debug("entering, client_id=%s", client_id) # Signal event (mantis 1280) evt = Event() # Spawn gevent.spawn(self._remove_client, client_id, evt) # Switch SolBase.sleep(0) # And wait # Note : remove this wait do not impact unittest... logger.debug("waiting, client_id=%s", client_id) evt.wait() # Over logger.debug("done, client_id=%s", client_id)
def _wait_process_exit(self, p): """ Wait process exit :param p: multiprocessing.Process,Popen :type p: multiprocessing.Process,Popen """ logger.info("Waiting process exit") ms = SolBase.mscurrent() while SolBase.msdiff(ms) < self.test_timeout_ms: if isinstance(p, Process): if not p.is_alive(): logger.info("Waiting process exit ok") return else: SolBase.sleep(10) elif isinstance(p, subprocess.Popen): # Popen sc = p.poll() if sc is not None and sc == 0: logger.info("Waiting process exit ok") return else: SolBase.sleep(10) raise Exception("Waiting process exit timeout")
def _start_all(self, server_config): """ Start server and client. :param server_config: Server config. :return: tuple pysoltcp.tcpserver.TcpServer.TcpServer,pysoltcp.tcp_client.TcpSimpleClient.TcpSimpleClient :rtype tuple """ # Allocate self.tcp_server = TcpServer(server_config) # Check self.assertIsNotNone(self.tcp_server) self.assertFalse(self.tcp_server._is_started) self.assertTrue(self.tcp_server._server is None) # Start self.assertTrue(self.tcp_server.start_server()) self.assertTrue(self.tcp_server._is_started) self.assertFalse(self.tcp_server._server is None) # Client config client_config = TcpClientConfig() client_config.target_addr = "127.0.0.1" client_config.target_port = 3201 client_config.debug_log = True # Client self.tcp_client = TcpSimpleClient(client_config) # Check self.assertTrue(self.tcp_client.current_socket is None) self.assertTrue(not self.tcp_client.is_connected) # Connect logger.info("Starting connect()") self.assertTrue(self.tcp_client.connect()) logger.info("Starting connect() : done") # Check client self.assertIsNotNone(self.tcp_client.current_socket) self.assertTrue(self.tcp_client.is_connected) # Wait for server logger.info("TestLog : server : wait connection") dt_start = SolBase.datecurrent() while SolBase.datediff(dt_start) < self.checkTimeOut: if len(self.tcp_server._client_connected_hash) > 0: break SolBase.sleep(int(self.checkTimeOut / 100)) logger.info("TestLog : server : wait connection : done") # Check self.assertEqual(len(self.tcp_server._client_connected_hash), 1) # Ok logger.info("Started and connected, effectiveMs=%s", self.tcp_server.get_effective_controlinterval_ms()) return self.tcp_server, self.tcp_client
def test_log_to_file_time_file_seconds(self): """ Test """ log_file = "/tmp/pythonsol_unittest.log" # Clean if FileUtility.is_file_exist(log_file): os.remove(log_file) for f in glob.glob("/tmp/pythonsol_unittest.log.*"): os.remove(f) # Init SolBase.logging_init(log_level="INFO", log_to_file=log_file, log_to_console=True, log_to_syslog=False, log_callback=self._on_log, force_reset=True, log_to_file_mode="time_file_seconds") SolBase.set_compo_name("COMPO_XXX") # Emit a log logger.info("TEST LOG 888") # Emit a log (str) logger.info(u"BUF \u001B\u0BD9\U0001A10D\u1501\xc3 FUB") # Check the file buf = FileUtility.file_to_textbuffer(log_file, "utf-8") self.assertIsNotNone(buf) self.assertGreaterEqual(buf.find("TEST LOG 888"), 0) self.assertGreaterEqual(buf.find("BUF "), 0) self.assertGreaterEqual(buf.find(" FUB"), 0) self.assertGreaterEqual( buf.find(u"BUF \u001B\u0BD9\U0001A10D\u1501\xc3 FUB"), 0) # Wait 5 sec for i in range(0, 10): SolBase.sleep(1100) logger.info("Log i=%s", i) # Emit a log logger.info("TEST LOG 999") # We should have "pythonsol_unittest.log.*" but no more than 7 f_count = 0 for f in glob.glob("/tmp/pythonsol_unittest.log.*"): logger.info("Found %s", f) f_count += 1 self.assertGreater(f_count, 0) self.assertLessEqual(f_count, 7) # Reset SolBase.logging_init("INFO", True)
def _http_basic_internal(self, force_implementation, proxy=False, https=False): """ Test """ logger.info("Starting, impl=%s", force_implementation) hc = HttpClient() for _ in range(0, 8): # Setup request hreq = HttpRequest() hreq.force_http_implementation = force_implementation if https: hreq.uri = "https://s.knock.center/static/k/k.notif.sample.png" else: # This will redirect https hreq.uri = "http://s.knock.center/static/k/k.notif.sample.png" # Http proxy if proxy: hreq.http_proxy_host = "127.0.0.1" hreq.http_proxy_port = 1180 hresp = hc.go_http(hreq) self.assertIsNotNone(hresp) self.assertIsInstance(hresp, HttpResponse) self.assertIsNotNone(hresp.http_request) self.assertEqual(id(hreq), id(hresp.http_request)) self.assertIsNotNone(hresp.elapsed_ms) self.assertIsNone(hresp.exception) if proxy and https: # Force to urllib3 self.assertEqual(hresp.http_implementation, HttpClient.HTTP_IMPL_URLLIB3) else: self.assertEqual(hresp.http_implementation, force_implementation) self.assertIsNotNone(hresp.content_length) self.assertIsNotNone(hresp.buffer) self.assertEqual(hresp.content_length, len(hresp.buffer)) self.assertGreater(len(hresp.headers), 0) self.assertIn(hresp.status_code, [200, 302, 301]) SolBase.sleep(250)
def gevent_from_pool(self, url, http_request): """ Get a gevent client from url and request :param url: geventhttpclient.url.URL :type url: geventhttpclient.url.URL :param http_request: HttpRequest :type http_request: HttpRequest :return HTTPClient :rtype HTTPClient """ # Compute key key = "{0}#{1}#{2}#{3}#{4}#{5}#{6}#{7}#{8}#{9}#".format( # host and port url.host, url.port, # Ssl url.scheme == PROTO_HTTPS, # Other dynamic stuff http_request.https_insecure, http_request.disable_ipv6, http_request.connection_timeout_ms / 1000, http_request.network_timeout_ms / 1000, http_request.http_concurrency, http_request.http_proxy_host, http_request.http_proxy_port, ) # Check if key in self._gevent_pool: SolBase.sleep(0) return self._gevent_pool[key] # Allocate (in lock) with self._gevent_locker: # Check maxed if len(self._gevent_pool) >= self._gevent_pool_max: raise Exception("gevent pool maxed, cur={0}, max={1}".format( len(self._gevent_pool), self._gevent_pool_max )) # Ok, allocate http = HTTPClient.from_url( url, insecure=http_request.https_insecure, disable_ipv6=http_request.disable_ipv6, connection_timeout=http_request.connection_timeout_ms / 1000, network_timeout=http_request.network_timeout_ms / 1000, concurrency=http_request.http_concurrency, proxy_host=http_request.http_proxy_host, proxy_port=http_request.http_proxy_port, headers={}, ) self._gevent_pool[key] = http logger.info("Started new pool for key=%s", key) SolBase.sleep(0) return http
def test_basic_eviction_with_watchdog_ttl(self): """ Test :return: """ # Go self.mem_cache = MemoryCache(watchdog_interval_ms=1000, cb_watchdog=self.watchdog_callback, cb_evict=self.eviction_callback) # Put self.mem_cache.put("keyA", b"valA", 60000) self.mem_cache.put("keyB", b"valB", 500) self.mem_cache.put("keyC", b"valC", 500) self.mem_cache.put("keyD", b"valD", 60000) logger.info("ms cur=%s", SolBase.mscurrent()) logger.info("A : %s", self.mem_cache.get_raw("keyA")) logger.info("B : %s", self.mem_cache.get_raw("keyB")) logger.info("C : %s", self.mem_cache.get_raw("keyC")) logger.info("D : %s", self.mem_cache.get_raw("keyD")) # Wait a bit ms_start = SolBase.mscurrent() while SolBase.msdiff(ms_start) < (1000.0 * 2.0): if self.callback_call > 0: break else: SolBase.sleep(10) logger.info("ms after wait=%s", SolBase.mscurrent()) logger.info("_hash_key = %s", self.mem_cache._hash_key) logger.info("_hash_context = %s", self.mem_cache._hash_context) # A : must be present # B : must be evicted (TTL elapsed, by watchdog) self.assertEqual(self.callback_call, 1) self.assertEqual(self.callback_evicted, 2) self.assertFalse("valB" in self.mem_cache._hash_key) self.assertFalse("valB" in self.mem_cache._hash_context) self.assertFalse("valC" in self.mem_cache._hash_key) self.assertFalse("valC" in self.mem_cache._hash_context) self.assertIsNone(self.mem_cache.get("keyB")) self.assertIsNone(self.mem_cache.get("keyC")) self.assertEqual(self.mem_cache.get("keyA"), b"valA") self.assertEqual(self.mem_cache.get("keyD"), b"valD") self.assertEqual(self.evict_count, 2) self.assertTrue(self.evict_last_key == "keyB" or self.evict_last_key == "keyC") self.assertTrue(self.evict_last_value == b"valB" or self.evict_last_value == b"valC") self.assertEqual(Meters.aig("mcs.cache_evict_ttl_watchdog"), 2) # Stop self.mem_cache.stop_cache() self.mem_cache = None
def _daemon_stop(self): """ Stop the Daemon # Status : OK, implemented # - Running : exit 0 => OK # - Not running and pid file exist : exit 1 => OK # - Not running : exit 3 => OK # - Other : 4 => NOT TESTED """ logger.debug("entering") # Get the pid from the pidfile pid = self._get_running_pid() if not pid: logger.info("Daemon is not running, pidFile=%s", self._pidfile) return # Stop it logger.debug("sending SIGTERM, pid=%s, pidFile=%s", pid, self._pidfile) try: os.kill(pid, SIGTERM) except OSError as ex: if ex.errno == errno.ESRCH: logger.info("SIGTERM failed, ESRCH, ex=%s", SolBase.extostr(ex)) else: logger.info("SIGTERM failed, not an ESRCH, ex=%s", SolBase.extostr(ex)) except Exception as ex: logger.info("SIGTERM failed, not an OSError, going exit(1), ex=%s", SolBase.extostr(ex)) sys.exit(1) finally: if os.path.exists(self._pidfile): logger.debug("Removing pidFile=%s", self._pidfile) self._remove_pid_file() # Ok logger.debug("SIGTERM sent") ms_start = SolBase.mscurrent() # Validate proc_target = "/proc/%d" % pid while SolBase.msdiff(ms_start) < self._timeout_ms: if os.path.exists(proc_target): SolBase.sleep(10) continue # Over logger.info("SIGTERM success, pid=%s", pid) self._remove_pid_file() return # Not cool logger.warning("SIGTERM timeout=%s ms, pid=%s", self._timeout_ms, pid)
def test_date(self): """ Test """ dt = SolBase.datecurrent() SolBase.sleep(100) # Gevent 1.3 : this is buggy (may be related to https://github.com/gevent/gevent/issues/1227) self.assertGreaterEqual(SolBase.datediff(dt), 100) self.assertLessEqual(SolBase.datediff(dt), 200)
def _stop_one_client(self): """ Test """ # Check logger.info("TestLog : server : get server context") self.assertTrue(len(self.tcp_server._client_connected_hash) == 1) ctx = None for cur in self.tcp_server._client_connected_hash.values(): ctx = cur break self.assertIsNotNone(ctx) self.assertEqual(ctx.stop_synchCalled, False) self.assertEqual(ctx.stop_synch_internalCalled, False) # Kill client self.tcpClient.disconnect() # Check client self.assertTrue(self.tcpClient.current_socket is None) self.assertFalse(self.tcpClient.is_connected) # Reset client self.tcpClient = None # Server should be disconnected from client # Wait for server logger.info("TestLog : server : wait for disconnection") dt_start = SolBase.datecurrent() while SolBase.datediff(dt_start) < self.checkTimeOutMs: ok = True if len(self.tcp_server._client_connected_hash) != 0: ok = False elif not ctx.stop_synchCalled: ok = False elif not ctx.stop_synch_internalCalled: ok = False if ok: logger.info("TestLog : server : wait for disconnection : done") break else: SolBase.sleep(int(self.checkTimeOutMs / 100)) # Check logger.info("TestLog : server : check for disconnection") self.assertTrue(len(self.tcp_server._client_connected_hash) == 0) # Check self.assertEqual(ctx.stop_synchCalled, True) self.assertEqual(ctx.stop_synch_internalCalled, True)
def stop_synch(self): """ Stop synch """ # Stop calls PingServerContext.stop_synch(self) # Deadlock while True: SolBase.sleep(50)
def stop_synch_internal(self): """ Disconnect from server. :return Return true upon success. """ # Stop calls PingServerContext.stop_synch_internal(self) # Deadlock while True: SolBase.sleep(50)
def _run_filter(self, ip_addr): lo = logging.getLogger("new_logger") SolBase.context_set("k_ip", ip_addr) SolBase.context_set("z_value", ip_addr) SolBase.context_set("zz_uc", u"B\u001BB") # Emit a log ms = SolBase.mscurrent() while SolBase.msdiff(ms) < 2000.0: logger.info("TEST LOG ip_addr=%s", ip_addr) lo.info("TEST LOG ip_addr=%s", ip_addr) SolBase.sleep(0)
def test_do_not_close(self): """ Test """ # Instances self.tcp_server = None self.tcp_client = None try: # Config server_config = TcpServerConfig() server_config.listen_addr = "127.0.0.1" server_config.listen_port = 3201 server_config.socket_absolute_timeout_ms = 60000 server_config.socket_relative_timeout_ms = 60000 server_config.socket_min_checkinterval_ms = 0 # Start self.tcp_server, self.tcp_client = self._start_all(server_config) # Wait a bit SolBase.sleep(5000) # Check client self.assertIsNotNone(self.tcp_client.current_socket) self.assertTrue(self.tcp_client.is_connected) # Disconnect self.tcp_client.disconnect() # Check client self.assertTrue(self.tcp_client.current_socket is None) self.assertFalse(self.tcp_client.is_connected) # Reset client self.tcp_client = None # Stop server self.tcp_server.stop_server() # Reset self.tcp_server = None self.tcp_client = None finally: if self.tcp_server: self.tcp_server.stop_server() if self.tcp_client: self.tcp_client.disconnect()
def _start_one_client_checkstop(self): """ Test """ # Start self._start_one_client() # Wait SolBase.sleep(1000) # Stop self._stop_one_client()
def _write_loop(self): """ High level read loop on socket """ logger.debug("entering now, self=%s", self) try: self._write_loop_internal() except GreenletExit: logger.debug("exiting due to GreenletExit, self=%s", self) return except Exception as e: logger.error("Exception raised, ex=%s, self=%s", SolBase.extostr(e), self) finally: logger.debug("exiting now, , self=%s", self) SolBase.sleep(0)
def test_ms(self): """ Test """ ms = SolBase.mscurrent() SolBase.sleep(100) # Gevent 1.3 : this is buggy (may be related to https://github.com/gevent/gevent/issues/1227) self.assertGreaterEqual(SolBase.msdiff(ms), 100) self.assertLessEqual(SolBase.msdiff(ms), 200) sec = SolBase.securrent() SolBase.sleep(1100) # Gevent 1.3 : this is buggy (may be related to https://github.com/gevent/gevent/issues/1227) self.assertGreaterEqual(SolBase.msdiff(sec*1000), 1000) self.assertLessEqual(SolBase.msdiff(sec*1000), 1200)
def _run_cache_bench(self, event, idx_min, idx_max): """ Run :param idx_min: Index min :param idx_max: Index max """ idx_max -= 1 # Wait self.gorun_event.wait() # Go cur_count = 0 logger.debug("Entering now, idx_min=%s, idx_max=%s", idx_min, idx_max) self.thread_running.increment() self.thread_running_ok.increment() try: while not self.run_event.isSet(): cur_count += 1 try: cur_item = random.randint(idx_min, idx_max) s_cur_item = "%s" % cur_item b_cur_item = SolBase.unicode_to_binary(s_cur_item, "utf-8") cur_ttl = random.randint(self.bench_ttl_min_ms, self.bench_ttl_max_ms) for _ in range(0, self.bench_put_weight): self.redis_cache.put(s_cur_item, b_cur_item, cur_ttl) SolBase.sleep(0) for _ in range(0, self.bench_get_weight): v = self.redis_cache.get(s_cur_item) if v: self.assertEqual(v, b_cur_item) SolBase.sleep(0) except Exception as e: self.exception_raised += 1 logger.warning("Ex=%s", SolBase.extostr(e)) self.thread_running_ok.increment(-1) return finally: pass finally: self.assertGreater(cur_count, 0) logger.debug("Exiting") event.set() self.thread_running.increment(-1)
def _on_start(self): """ Test """ logger.info("Called") self.start_count += 1 self.last_action = "start" self._write_state() logger.info("Engaging running loop") while self.is_running: SolBase.sleep(10) logger.info("Exited running loop") self._write_state() self.start_loop_exited.set() logger.debug("Exited")
def _start_one_client_checkallping_stop(self): """ Test """ # Start self._start_one_client() # 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 dt = SolBase.datecurrent() while SolBase.datediff(dt) < self.checkPingTimeOutMs: # Client client_ko = PingTestTools.get_client_ko_count() # Server server_ko = PingTestTools.get_server_ko_count() # Check full ok if client_ko == 0 and server_ko == 0: break # Wait logger.info("Test : client_ko=%s, server_ko=%s", client_ko, server_ko) SolBase.sleep(1000) # Final check client_ko = PingTestTools.get_client_ko_count(True) server_ko = PingTestTools.get_server_ko_count(True) self.assertEqual(client_ko, 0) self.assertEqual(server_ko, 0) # Stop self._stop_one_client()
def _start_one_client(self): """ Test """ # Client config client_config = TcpClientConfig() client_config.target_addr = "127.0.0.1" client_config.target_port = 3201 client_config.debug_log = True # ssl if self.testSsl: client_config.ssl_enable = True # Client self.tcpClient = PingSimpleClient(client_config, self.clientHelloTimeOutMs, self.clientPingIntervalMs, self.clientPingTimeOutMs) # Check self.assertTrue(self.tcpClient.current_socket is None) self.assertFalse(self.tcpClient.is_connected) # Connect self.assertTrue(self.tcpClient.connect()) # Check client self.assertIsNotNone(self.tcpClient.current_socket) self.assertTrue(self.tcpClient.is_connected) # Wait for server logger.info("TestLog : server : wait connection") dt_start = SolBase.datecurrent() while SolBase.datediff(dt_start) < self.checkTimeOutMs: if len(self.tcp_server._client_connected_hash) > 0: break SolBase.sleep(int(self.checkTimeOutMs / 100)) logger.info("TestLog : server : wait connection : done") # Check self.assertEqual(len(self.tcp_server._client_connected_hash), 1)
def _waitforserver_disconnection(self, timeout_ms): """ Wait for client disconnection at server level :return: Nothing """ logger.info("server : wait for disconnection") dt_start = SolBase.datecurrent() while SolBase.datediff(dt_start) < timeout_ms: if len(self.tcp_server._client_connected_hash ) == 0 and self.tcp_client.current_socket is None: break SolBase.sleep(timeout_ms / 1000) logger.info("server : wait for disconnection : done, ms=%s", SolBase.datediff(dt_start)) # Check self.assertEqual(len(self.tcp_server._client_connected_hash), 0) self.assertIsNone(self.tcp_client.current_socket)
def _get_std_err(self): """ Get :return: list :rtype: list """ try: sys.stderr.flush() except ValueError: pass ms_start = SolBase.mscurrent() while True: ar = self._file_to_list(self.daemon_std_err) if len(ar) > 0: return ar elif SolBase.msdiff(ms_start) > self.std_err_timeout_ms: return list() else: SolBase.sleep(10)
def test_meters_bench_chunk_udp_array_via_serialization(self): """ Test """ # For logs format SolBase.sleep(100) logger.info("Bench now") self.per_loop = 1 self._meters_inject(count=5000) ar_json = Meters.meters_to_udp_format(send_pid=True, send_tags=True, send_dtc=False) self._bench(1, "udp_chunk_no_dtc", Meters.chunk_udp_array_via_serialization, ar_json, 60000) self._meters_inject(count=5000) ar_json = Meters.meters_to_udp_format(send_pid=True, send_tags=True, send_dtc=True) self._bench(1, "udp_chunk_dtc", Meters.chunk_udp_array_via_serialization, ar_json, 60000) # For logs format SolBase.sleep(100) logger.info("Bench over")