def test_wait_for_deferred_requests__abandon(self):
with async_server_context(FooService(), interval_to_keep_result=0.1,
result_garbage_collector_interval=0.1) as server:
client_transport = ZeroRPCClientTransport.create_tcp(8192)
client = Client(client_transport)
client.bar(async_rpc=True)
self.assertTrue(server.has_deferred_requests())
self.assertTrue(server.wait_for_empty_deferred_requests(0.4))
def test_abandon_deferred_requests(self):
with async_server_context(FooService(), interval_to_keep_result=0.1) as server:
client_transport = ZeroRPCClientTransport.create_tcp(8192)
client = Client(client_transport)
client.bar(async_rpc=True)
self.assertTrue(server.has_deferred_requests())
gevent.sleep(0.2)
server.garbage_collect_deferred_results()
self.assertFalse(server.has_deferred_requests())
def test_wait_for_deferred_requests__abort(self):
with async_server_context(FooService(),
interval_to_keep_result=5) as server:
client_transport = ZeroRPCClientTransport.create_tcp(8192)
client = Client(client_transport)
client.bar(async_rpc=True)
self.assertTrue(server.has_deferred_requests())
self.assertFalse(server.wait_for_empty_deferred_requests(0.1))
server.garbage_collect_deferred_results()
def test_abandon_deferred_requests(self):
with async_server_context(FooService(),
interval_to_keep_result=0.1) as server:
client_transport = ZeroRPCClientTransport.create_tcp(8192)
client = Client(client_transport)
client.bar(async_rpc=True)
self.assertTrue(server.has_deferred_requests())
gevent.sleep(0.2)
server.garbage_collect_deferred_results()
self.assertFalse(server.has_deferred_requests())
def test_straightforward(self):
try:
server_transport = ZeroRPCServerTransport.create_tcp(8192)
server = SyncServer(transport=server_transport, service=FooService())
server.bind()
client_transport = ZeroRPCClientTransport.create_tcp(8192)
client = Client(client_transport)
self.assertEqual(client.foo(), 42)
finally:
server.unbind()
def test_wait_for_deferred_requests__finish(self):
with async_server_context(FooService(), interval_to_keep_result=5) as server:
client_transport = ZeroRPCClientTransport.create_tcp(8192)
client = Client(client_transport)
deferred = client.bar(async_rpc=True)
self.assertTrue(server.has_deferred_requests())
g = gevent.spawn(deferred.get_result)
server.wait_for_empty_deferred_requests()
self.assertEqual(24, g.get())
server.garbage_collect_deferred_results()
self.assertFalse(server.has_deferred_requests())
def test_wait_for_deferred_requests__finish(self):
with async_server_context(FooService(),
interval_to_keep_result=5) as server:
client_transport = ZeroRPCClientTransport.create_tcp(8192)
client = Client(client_transport)
deferred = client.bar(async_rpc=True)
self.assertTrue(server.has_deferred_requests())
g = gevent.spawn(deferred.get_result)
server.wait_for_empty_deferred_requests()
self.assertEqual(24, g.get())
server.garbage_collect_deferred_results()
self.assertFalse(server.has_deferred_requests())
def test_auto_timeout_client__short_timeout_on_stuck_server(self):
import time
from threading import Event
wait_for_start = Event()
wait_for_close = Event()
def thread_server(wait_for_start, wait_for_close):
try:
print(
("starting server, hub: {}".format(gevent.hub.get_hub())))
with logbook.NullHandler().applicationbound():
with server_context(FooService(), max_response_time=0.1):
print("server started.")
wait_for_start.set()
while not wait_for_close.is_set():
gevent.sleep(0.1)
except:
import traceback
traceback.print_exc()
from gevent.threadpool import ThreadPool
t = ThreadPool(1)
t.size = 1
t.spawn(thread_server, wait_for_start, wait_for_close)
try:
print(("starting client, hub: {}".format(gevent.hub.get_hub())))
client = AutoTimeoutClient(ZeroRPCClientTransport.create_tcp(8192),
timeout_calc_func=lambda n: n * 2)
wait_for_start.wait()
print("client started.")
t1 = time.time()
self.assertRaises(TimeoutExpired, client.stuck_call)
t2 = time.time()
# This test should always pass although we're dealing with timing and non-deterministic measures since
# stuck_call() is stuck for an entire second while we're comparing time to 0.2 (almost an order of a
# magnitude)
self.assertAlmostEqual(0.2, t2 - t1, delta=0.2)
finally:
wait_for_close.set()
t.join()
def test_auto_timeout_client__short_timeout_on_stuck_server(self):
import time
from threading import Event
wait_for_start = Event()
wait_for_close = Event()
def thread_server(wait_for_start, wait_for_close):
try:
print(("starting server, hub: {}".format(gevent.hub.get_hub())))
with logbook.NullHandler().applicationbound():
with server_context(FooService(), max_response_time=0.1):
print("server started.")
wait_for_start.set()
while not wait_for_close.is_set():
gevent.sleep(0.1)
except:
import traceback
traceback.print_exc()
from gevent.threadpool import ThreadPool
t = ThreadPool(1)
t.size = 1
t.spawn(thread_server, wait_for_start, wait_for_close)
try:
print(("starting client, hub: {}".format(gevent.hub.get_hub())))
client = AutoTimeoutClient(ZeroRPCClientTransport.create_tcp(8192), timeout_calc_func=lambda n: n * 2)
wait_for_start.wait()
print("client started.")
t1 = time.time()
self.assertRaises(TimeoutExpired, client.stuck_call)
t2 = time.time()
# This test should always pass although we're dealing with timing and non-deterministic measures since
# stuck_call() is stuck for an entire second while we're comparing time to 0.2 (almost an order of a
# magnitude)
self.assertAlmostEqual(0.2, t2 - t1, delta=0.2)
finally:
wait_for_close.set()
t.join()
def get_client(config):
from infi.rpc import ZeroRPCClientTransport
client_transport = ZeroRPCClientTransport("tcp://127.0.0.1:{}".format(
config.rpcserver.port))
return Client(client_transport)
def create_client():
return Client(ZeroRPCClientTransport.create_tcp(8192))
def test_auto_timeout_client__timeout_implicilty_found(self):
with server_context(FooService(), max_response_time=0.5):
client = AutoTimeoutClient(ZeroRPCClientTransport.create_tcp(8192))
client.no_delay_call()
self.assertEqual(0.5, client.get_server_max_response_time())
def test_auto_timeout_client__timeout_implicilty_found(self):
with server_context(FooService(), max_response_time=0.5):
client = AutoTimeoutClient(ZeroRPCClientTransport.create_tcp(8192))
client.no_delay_call()
self.assertEqual(0.5, client.get_server_max_response_time())
def create_client():
return Client(ZeroRPCClientTransport.create_tcp(8192))
def test_straightforward(self):
with async_server_context(FooService()) as server:
client_transport = ZeroRPCClientTransport.create_tcp(8192)
client = Client(client_transport)
self.assertEqual(client.foo(), 42)
self.assertFalse(server.has_deferred_requests())
def test_straightforward(self):
with async_server_context(FooService()) as server:
client_transport = ZeroRPCClientTransport.create_tcp(8192)
client = Client(client_transport)
self.assertEqual(client.foo(), 42)
self.assertFalse(server.has_deferred_requests())