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