def setUp(self):
if not hasattr(self, "_log"):
self._log = logging.getLogger("TestHandoffServer")
self.tearDown()
database_connection = get_central_connection()
cluster_row = get_cluster_row(database_connection)
node_rows = get_node_rows(database_connection, cluster_row.id)
database_connection.close()
self._key_generator = generate_key()
self._event_publisher_processes = list()
self._data_writer_processes = list()
self._data_reader_processes = list()
self._handoff_server_processes = list()
for i in xrange(_node_count):
node_name = _generate_node_name(i)
repository_path = _repository_path(node_name)
os.makedirs(repository_path)
process = start_event_publisher(
node_name, _event_publisher_pull_addresses[i], _event_publisher_pub_addresses[i]
)
poll_result = poll_process(process)
self.assertEqual(poll_result, None)
self._event_publisher_processes.append(process)
time.sleep(1.0)
process = start_data_writer(
_cluster_name, node_name, _data_writer_addresses[i], _event_publisher_pull_addresses[i], repository_path
)
poll_result = poll_process(process)
self.assertEqual(poll_result, None)
self._data_writer_processes.append(process)
time.sleep(1.0)
process = start_data_reader(
node_name, _data_reader_addresses[i], _event_publisher_pull_addresses[i], repository_path
)
poll_result = poll_process(process)
self.assertEqual(poll_result, None)
self._data_reader_processes.append(process)
time.sleep(1.0)
process = start_handoff_server(
_cluster_name,
node_name,
_handoff_server_addresses,
_handoff_server_pipeline_addresses[i],
_data_reader_addresses,
_data_writer_addresses,
_event_publisher_pull_addresses[i],
_repository_path(node_name),
)
poll_result = poll_process(process)
self.assertEqual(poll_result, None)
self._handoff_server_processes.append(process)
time.sleep(1.0)
self._context = zmq.context.Context()
self._pollster = GreenletZeroMQPollster()
self._deliverator = Deliverator()
self._pull_server = GreenletPULLServer(self._context, _client_address, self._deliverator)
self._pull_server.register(self._pollster)
backup_nodes = random.sample(node_rows[1:], 2)
self._log.debug("backup nodes = %s" % ([n.name for n in backup_nodes],))
self._resilient_clients = list()
for node_row, address in zip(node_rows, _data_writer_addresses):
if not node_row in backup_nodes:
continue
resilient_client = GreenletResilientClient(
self._context,
self._pollster,
node_row.name,
address,
_local_node_name,
_client_address,
self._deliverator,
)
self._resilient_clients.append(resilient_client)
self._log.debug("%s resilient clients" % (len(self._resilient_clients),))
self._data_writer_handoff_client = DataWriterHandoffClient(node_rows[0].name, self._resilient_clients)
self._pollster.start()
def setUp(self):
if not hasattr(self, "_log"):
self._log = logging.getLogger("TestHandoffServer")
self.tearDown()
database_connection = get_central_connection()
cluster_row = get_cluster_row(database_connection)
node_rows = get_node_rows(database_connection, cluster_row.id)
database_connection.close()
self._key_generator = generate_key()
self._event_publisher_processes = list()
self._data_writer_processes = list()
self._data_reader_processes = list()
self._handoff_server_processes = list()
for i in xrange(_node_count):
node_name = _generate_node_name(i)
repository_path = _repository_path(node_name)
os.makedirs(repository_path)
process = start_event_publisher(node_name,
_event_publisher_pull_addresses[i],
_event_publisher_pub_addresses[i])
poll_result = poll_process(process)
self.assertEqual(poll_result, None)
self._event_publisher_processes.append(process)
time.sleep(1.0)
process = start_data_writer(_cluster_name, node_name,
_data_writer_addresses[i],
_event_publisher_pull_addresses[i],
repository_path)
poll_result = poll_process(process)
self.assertEqual(poll_result, None)
self._data_writer_processes.append(process)
time.sleep(1.0)
process = start_data_reader(node_name, _data_reader_addresses[i],
_event_publisher_pull_addresses[i],
repository_path)
poll_result = poll_process(process)
self.assertEqual(poll_result, None)
self._data_reader_processes.append(process)
time.sleep(1.0)
process = start_handoff_server(
_cluster_name, node_name, _handoff_server_addresses,
_handoff_server_pipeline_addresses[i], _data_reader_addresses,
_data_writer_addresses, _event_publisher_pull_addresses[i],
_repository_path(node_name))
poll_result = poll_process(process)
self.assertEqual(poll_result, None)
self._handoff_server_processes.append(process)
time.sleep(1.0)
self._context = zmq.context.Context()
self._pollster = GreenletZeroMQPollster()
self._deliverator = Deliverator()
self._pull_server = GreenletPULLServer(self._context, _client_address,
self._deliverator)
self._pull_server.register(self._pollster)
backup_nodes = random.sample(node_rows[1:], 2)
self._log.debug("backup nodes = %s" % ([n.name
for n in backup_nodes], ))
self._resilient_clients = list()
for node_row, address in zip(node_rows, _data_writer_addresses):
if not node_row in backup_nodes:
continue
resilient_client = GreenletResilientClient(
self._context,
self._pollster,
node_row.name,
address,
_local_node_name,
_client_address,
self._deliverator,
)
self._resilient_clients.append(resilient_client)
self._log.debug("%s resilient clients" %
(len(self._resilient_clients), ))
self._data_writer_handoff_client = DataWriterHandoffClient(
node_rows[0].name, self._resilient_clients)
self._pollster.start()
def _setup(state):
log = logging.getLogger("_setup")
# do the event push client first, because we may need to
# push an execption event from setup
state["event-push-client"] = EventPushClient(
state["zmq-context"],
"data_writer"
)
log.info("binding resilient-server to {0}".format(_data_writer_address))
state["resilient-server"] = ResilientServer(
state["zmq-context"],
_data_writer_address,
state["message-queue"]
)
state["resilient-server"].register(state["pollster"])
log.info("binding reply-pull-server to {0}".format(
_writer_thread_reply_address))
state["reply-pull-server"] = ReplyPULLServer(
state["zmq-context"],
_writer_thread_reply_address,
state["resilient-server"].send_reply
)
state["reply-pull-server"].register(state["pollster"])
log.info("binding anti-entropy-server to {0}".format(
_data_writer_anti_entropy_address))
state["anti-entropy-server"] = REPServer(
state["zmq-context"],
_data_writer_anti_entropy_address,
state["message-queue"]
)
state["anti-entropy-server"].register(state["pollster"])
topics = ["web-writer-start", ]
log.info("connecting sub-client to {0} subscribing to {1}".format(
_event_aggregator_pub_address,
topics))
state["sub-client"] = SUBClient(
state["zmq-context"],
_event_aggregator_pub_address,
topics,
state["message-queue"]
)
state["sub-client"].register(state["pollster"])
central_connection = get_central_connection()
state["cluster-row"] = get_cluster_row(central_connection)
state["node-rows"] = get_node_rows(
central_connection, state["cluster-row"].id
)
central_connection.close()
state["node-id-dict"] = dict(
[(node_row.name, node_row.id, ) for node_row in state["node-rows"]]
)
state["event-push-client"].info("program-start", "data_writer starts")
state["reply-push-client"] = PUSHClient(state["zmq-context"],
_writer_thread_reply_address)
state["writer-thread"] = WriterThread(state["halt-event"],
state["node-id-dict"],
state["message-queue"],
state["reply-push-client"])
state["writer-thread"].start()
state["sync-thread"] = SyncThread(state["halt-event"],
state["message-queue"])
state["sync-thread"].start()
