def test_single_request(self, mock_request):
# mock http server
Response = NamedTuple('Response',
status_code=int,
text=str,
url=str,
method=str)
def fake_response(method, url):
return Response(200, 'ok', url, method)
mock_request.side_effect = fake_response
# overwrite `Context` used by client
ctx = Context()
ctx.create_redis = lambda: self.redis_resource.rds
# create routing record
self.rtbl.set_routing(
RoutingRecord('myservice', ['localhost:8000'], [1]))
# make request
response = single_request(ClientConfig('myservice'),
ctx,
router_type='SymmetryHostRouter')
self.assertEqual(200, response.status_code)
def _init(module=None):
from galileo.worker.context import Context
from galileo.shell.shell import init_module
import atexit
import pymq
ctx = Context()
rds = ctx.create_redis()
init_module(rds, name=module)
atexit.register(pymq.shutdown)
def run(ctx: Context, trace_queue: Queue, description: ClientDescription):
logger.info('starting new client process %s', description)
bus = RedisEventBus(rds=ctx.create_redis())
bus_thread = threading.Thread(target=bus.run)
bus_thread.start()
client = Client(ctx, trace_queue, description, eventbus=bus)
def handler(signum, frame):
logger.debug('client %s received signal %s', client.client_id, signum)
client.close()
raise KeyboardInterrupt
signal.signal(signal.SIGINT, handler)
signal.signal(signal.SIGTERM, handler)
try:
logger.info("%s starting", client)
client.run()
except KeyboardInterrupt:
pass
logger.debug('shutting down eventbus')
bus.close()
bus_thread.join(2)
logger.info("%s exitting", client)
def __init__(self,
ctx: Context,
trace_queue: Queue,
description: ClientDescription,
eventbus=None) -> None:
super().__init__()
self.ctx = ctx
self.description = description
self.client_id = description.client_id
self.cfg = description.config
self.traces = trace_queue
self.eventbus = eventbus or pymq
self.router = ctx.create_router()
self.request_generator = RequestGenerator(
self._create_request_factory(), self.ctx)
# used for generating request ids
self.client_uuid = util.uuid()[-10:]
self.request_counter = 0
# used for statistics
self.failed_counter = 0
# expose methods
self.eventbus.subscribe(self._on_set_workload_command)
self.eventbus.subscribe(self._on_stop_workload_command)
self.eventbus.expose(self.get_info, 'Client.get_info')
self.request_executor = ThreadPoolExecutor(max_workers=50)
def test_debug_router(self):
env = dict(os.environ)
env['galileo_router_type'] = 'DebugRouter'
client_id = 'unittest_client'
ctx = Context(env)
trace_queue = Queue()
description = ClientDescription(client_id, 'unittest_worker',
ClientConfig('aservice'))
# ctx: Context, trace_queue: Queue, description: ClientDescription
client = Client(ctx,
trace_queue,
description,
eventbus=SimpleEventBus())
client.request_generator = StaticRequestGenerator(
[ServiceRequest('aservice') for _ in range(self.n)])
then = time.time()
client.run()
now = time.time()
total = now - then
print('DebugRouter: %.2f req/sec (%.4fs total)' %
(self.n / total, total))
def test_symmetry_router(self, mock_request):
# mock http server
Response = NamedTuple('Response',
status_code=int,
text=str,
url=str,
method=str)
def fake_response(method, url):
return Response(200, 'ok', url, method)
mock_request.side_effect = fake_response
self.rtbl.set_routing(
RoutingRecord('aservice', ['host1', 'host2', 'host3'], [1, 2, 3]))
env = dict(os.environ)
env['galileo_router_type'] = 'CachingSymmetryHostRouter'
client_id = 'unittest_client'
ctx = Context(env)
ctx.create_redis = lambda: self.rds
trace_queue = Queue()
description = ClientDescription(client_id, 'unittest_worker',
ClientConfig('aservice'))
# ctx: Context, trace_queue: Queue, description: ClientDescription
client = Client(ctx,
trace_queue,
description,
eventbus=SimpleEventBus())
client.request_generator = StaticRequestGenerator(
[ServiceRequest('aservice') for _ in range(self.n)])
then = time.time()
client.run()
now = time.time()
total = now - then
print('CachingSymmetryHostRouter: %.2f req/sec (%.4f total)' %
(self.n / total, total))
def pre_recorded_profile(ctx: Context, list_key: str):
rds = ctx.create_redis()
start = time.time()
values = rds.lrange(list_key, 0, rds.llen(list_key))
rds.delete(list_key)
# Values need to be reversed since we originally treated this like a stack
values.reverse()
end = time.time()
logger.debug(
f'loaded {len(values)} ia values in {end - start}s from redis')
for value in values:
yield float(value)
logger.info('done')
def test_with_router_fault(self):
class FaultInjectingRouter(DebugRouter):
def request(self, req: ServiceRequest) -> 'requests.Response':
if req.path == '/api/nonexisting':
raise ValueError('some error')
return super().request(req)
router = FaultInjectingRouter()
ctx = Context()
ctx.create_router = lambda: router
client_id = 'unittest_client'
trace_queue = Queue()
description = ClientDescription(client_id, 'unittest_worker',
ClientConfig('aservice'))
# ctx: Context, trace_queue: Queue, description: ClientDescription
client = Client(ctx,
trace_queue,
description,
eventbus=SimpleEventBus())
client.request_generator = StaticRequestGenerator([
ServiceRequest('aservice', path='/api/nonexisting'),
ServiceRequest('aservice', path='/api/unittest'),
])
client.run()
trace1 = trace_queue.get(timeout=2)
trace2 = trace_queue.get(timeout=2)
self.assertEqual(-1, trace1.sent)
self.assertAlmostEqual(trace2.sent, time.time(), delta=2)
def single_request(cfg: ClientConfig,
ctx=None,
router_type=None) -> requests.Response:
ctx = ctx or Context()
if cfg.client:
app_loader = ctx.create_app_loader()
app = app_loader.load(cfg.client, cfg.parameters)
else:
app = DefaultAppClient(cfg.parameters)
factory = AppClientRequestFactory(cfg.service, app)
router = ctx.create_router(router_type)
return router.request(factory.create_request())
def test_client_integration(self):
env = dict(os.environ)
env['galileo_router_type'] = 'DebugRouter'
client_id = 'unittest_client'
ctx = Context(env)
trace_queue = Queue()
description = ClientDescription(client_id, 'unittest_worker',
ClientConfig('aservice'))
# ctx: Context, trace_queue: Queue, description: ClientDescription
client = Client(ctx,
trace_queue,
description,
eventbus=SimpleEventBus())
client.request_generator = StaticRequestGenerator([
ServiceRequest('aservice'),
ServiceRequest('aservice'),
])
client.run()
trace1 = trace_queue.get(timeout=2)
trace2 = trace_queue.get(timeout=2)
self.assertEqual('aservice', trace1.service)
self.assertEqual('aservice', trace2.service)
self.assertEqual('debughost', trace1.server)
self.assertEqual('debughost', trace2.server)
now = time.time()
self.assertAlmostEqual(now, trace1.done, delta=2)
self.assertAlmostEqual(now, trace2.done, delta=2)