class Receiver(object):
def __init__(self, min_port, max_port):
assert min_port <= max_port, "Expected min_port <= max_port, but instead: min_port: %s, max_port %s" % \
(min_port, max_port)
self.port = None
self.min_port = min_port
self.max_port = max_port
self.serde = SerDe()
self.zmq_context = zmq.Context()
self.socket = self.zmq_context.socket(zmq.REP)
def start(self):
"""Bind to a random port in the range [self.min_port, self.max_port], inclusive
"""
# note: bind_to_random_port may retry the same port multiple times
self.port = self.socket.bind_to_random_port(addr="tcp://*", min_port=self.min_port, max_port=self.max_port + 1,
max_tries=2 * (self.max_port + 1 - self.min_port))
def recv(self):
message = self.socket.recv()
return self.serde.deserialize(message)
def send(self, event):
self.socket.send(self.serde.serialize(event))
def close(self):
self.socket.setsockopt(zmq.LINGER, 0)
self.socket.close()
class Receiver(object):
def __init__(self, min_port, max_port):
assert min_port <= max_port, "Expected min_port <= max_port, but instead: min_port: %s, max_port %s" % \
(min_port, max_port)
self.port = None
self.min_port = min_port
self.max_port = max_port
self.serde = SerDe()
self.zmq_context = zmq.Context()
self.socket = self.zmq_context.socket(zmq.REP)
def start(self):
"""Bind to a random port in the range [self.min_port, self.max_port], inclusive
"""
# note: bind_to_random_port may retry the same port multiple times
self.port = self.socket.bind_to_random_port(
addr="tcp://*",
min_port=self.min_port,
max_port=self.max_port + 1,
max_tries=2 * (self.max_port + 1 - self.min_port))
def recv(self):
message = self.socket.recv()
return self.serde.deserialize(message)
def send(self, event):
self.socket.send(self.serde.serialize(event))
def close(self):
self.socket.setsockopt(zmq.LINGER, 0)
self.socket.close()
class Sender(object):
REQUEST_TIMEOUT_MS = 3000
NUM_RETRIES = 5
def __init__(self, server_host, server_port, message_supplier, logger):
self.serde = SerDe()
self.server_endpoint = "tcp://%s:%s" % (str(server_host),
str(server_port))
self.zmq_context = zmq.Context()
self.socket = None
self.poller = zmq.Poller()
self.message_supplier = message_supplier
self.logger = logger
self._init_socket()
def _init_socket(self):
self.socket = self.zmq_context.socket(zmq.REQ)
self.socket.connect(self.server_endpoint)
self.poller.register(self.socket, zmq.POLLIN)
def send(self, event, blocking=True):
retries_left = Sender.NUM_RETRIES
while retries_left > 0:
serialized_event = self.serde.serialize(event)
self.socket.send(serialized_event)
retries_left -= 1
waiting_for_reply = True
while waiting_for_reply:
sockets = dict(self.poller.poll(Sender.REQUEST_TIMEOUT_MS))
if sockets.get(self.socket) == zmq.POLLIN:
reply = self.socket.recv()
if reply:
return self.serde.deserialize(reply)
else:
# send another request...
break
else:
self.close()
self._init_socket()
waiting_for_reply = False
# Ensure each message we attempt to send has a unique id
# This copy constructor gives us a duplicate with a new message id
event = self.message_supplier.copy(event)
raise RuntimeError("Unable to receive response from driver")
def close(self):
self.socket.setsockopt(zmq.LINGER, 0)
self.socket.close()
self.poller.unregister(self.socket)
class Sender(object):
REQUEST_TIMEOUT_MS = 3000
NUM_RETRIES = 5
def __init__(self, server_host, server_port, message_supplier, logger):
self.serde = SerDe()
self.server_endpoint = "tcp://%s:%s" % (str(server_host), str(server_port))
self.zmq_context = zmq.Context()
self.socket = None
self.poller = zmq.Poller()
self.message_supplier = message_supplier
self.logger = logger
self._init_socket()
def _init_socket(self):
self.socket = self.zmq_context.socket(zmq.REQ)
self.socket.connect(self.server_endpoint)
self.poller.register(self.socket, zmq.POLLIN)
def send(self, event, blocking=True):
retries_left = Sender.NUM_RETRIES
while retries_left > 0:
serialized_event = self.serde.serialize(event)
self.socket.send(serialized_event)
retries_left -= 1
waiting_for_reply = True
while waiting_for_reply:
sockets = dict(self.poller.poll(Sender.REQUEST_TIMEOUT_MS))
if sockets.get(self.socket) == zmq.POLLIN:
reply = self.socket.recv()
if reply:
return self.serde.deserialize(reply)
else:
# send another request...
break
else:
self.close()
self._init_socket()
waiting_for_reply = False
# Ensure each message we attempt to send has a unique id
# This copy constructor gives us a duplicate with a new message id
event = self.message_supplier.copy(event)
raise RuntimeError("Unable to receive response from driver")
def close(self):
self.socket.setsockopt(zmq.LINGER, 0)
self.socket.close()
self.poller.unregister(self.socket)
def __init__(self, min_port, max_port):
assert min_port <= max_port, "Expected min_port <= max_port, but instead: min_port: %s, max_port %s" % \
(min_port, max_port)
self.port = None
self.min_port = min_port
self.max_port = max_port
self.serde = SerDe()
self.zmq_context = zmq.Context()
self.socket = self.zmq_context.socket(zmq.REP)
def __init__(self, server_host, server_port, message_supplier, logger):
self.serde = SerDe()
self.server_endpoint = "tcp://%s:%s" % (str(server_host), str(server_port))
self.zmq_context = zmq.Context()
self.socket = None
self.poller = zmq.Poller()
self.message_supplier = message_supplier
self.logger = logger
self._init_socket()
def __init__(self, server_hostname, server_port, test_id, test_index,
logger_name, log_dir, debug):
signal.signal(signal.SIGTERM,
self._sigterm_handler) # register a SIGTERM handler
self.serde = SerDe()
self.logger = test_logger(logger_name, log_dir, debug)
self.runner_port = server_port
self.test_id = test_id
self.test_index = test_index
self.id = "test-runner-%d-%d" % (os.getpid(), id(self))
self.message = ClientEventFactory(self.test_id, self.test_index,
self.id)
self.sender = Sender(server_hostname, str(self.runner_port),
self.message, self.logger)
ready_reply = self.sender.send(self.message.ready())
self.session_context = ready_reply["session_context"]
self.test_metadata = ready_reply["test_metadata"]
self.cluster = ready_reply["cluster"]
# Wait to instantiate the test object until running the test
self.test = None
self.test_context = None
def __init__(self, min_port, max_port):
assert min_port <= max_port, "Expected min_port <= max_port, but instead: min_port: %s, max_port %s" % \
(min_port, max_port)
self.port = None
self.min_port = min_port
self.max_port = max_port
self.serde = SerDe()
self.zmq_context = zmq.Context()
self.socket = self.zmq_context.socket(zmq.REP)
def __init__(self, server_host, server_port, message_supplier, logger):
self.serde = SerDe()
self.server_endpoint = "tcp://%s:%s" % (str(server_host), str(server_port))
self.zmq_context = zmq.Context()
self.socket = None
self.poller = zmq.Poller()
self.message_supplier = message_supplier
self.logger = logger
self._init_socket()
class Receiver(object):
def __init__(self, min_port, max_port):
assert min_port <= max_port, "Expected min_port <= max_port, but instead: min_port: %s, max_port %s" % \
(min_port, max_port)
self.port = None
self.min_port = min_port
self.max_port = max_port
self.serde = SerDe()
self.zmq_context = zmq.Context()
self.socket = self.zmq_context.socket(zmq.REP)
def start(self):
"""Bind to a random port in the range [self.min_port, self.max_port], inclusive
"""
# note: bind_to_random_port may retry the same port multiple times
self.port = self.socket.bind_to_random_port(
addr="tcp://*",
min_port=self.min_port,
max_port=self.max_port + 1,
max_tries=2 * (self.max_port + 1 - self.min_port))
def recv(self, timeout=1800000):
if timeout is None:
# use default value of 1800000 or 30 minutes
timeout = 1800000
self.socket.RCVTIMEO = timeout
try:
message = self.socket.recv()
except zmq.Again:
raise TimeoutError("runner client unresponsive")
return self.serde.deserialize(message)
def send(self, event):
self.socket.send(self.serde.serialize(event))
def close(self):
self.socket.setsockopt(zmq.LINGER, 0)
self.socket.close()
