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 __init__(self):
self._log = logging.getLogger("WebInternalReader")
memcached_client = memcache.Client(_memcached_nodes)
self._central_connection = get_central_connection()
self._cluster_row = get_cluster_row(self._central_connection)
self._node_local_connection = get_node_local_connection()
self._deliverator = Deliverator()
self._zeromq_context = zmq.Context()
self._pull_server = GreenletPULLServer(
self._zeromq_context,
_web_internal_reader_pipeline_address,
self._deliverator
)
self._pull_server.link_exception(self._unhandled_greenlet_exception)
self._data_reader_clients = list()
self._data_readers = list()
for node_name, address in zip(_node_names, _data_reader_addresses):
resilient_client = GreenletResilientClient(
self._zeromq_context,
node_name,
address,
_client_tag,
_web_internal_reader_pipeline_address,
self._deliverator,
connect_messages=[]
)
resilient_client.link_exception(self._unhandled_greenlet_exception)
self._data_reader_clients.append(resilient_client)
data_reader = DataReader(
node_name, resilient_client
)
self._data_readers.append(data_reader)
self._space_accounting_dealer_client = GreenletDealerClient(
self._zeromq_context,
_local_node_name,
_space_accounting_server_address
)
self._space_accounting_dealer_client.link_exception(
self._unhandled_greenlet_exception
)
push_client = GreenletPUSHClient(
self._zeromq_context,
_local_node_name,
_space_accounting_pipeline_address,
)
self._accounting_client = SpaceAccountingClient(
_local_node_name,
self._space_accounting_dealer_client,
push_client
)
self._event_push_client = EventPushClient(
self._zeromq_context,
"web-internal-reader"
)
# message sent to data readers telling them the server
# is (re)starting, thereby invalidating any archvies or retrieved
# that are in progress for this node
timestamp = create_timestamp()
self._event_push_client.info("web-reader-start",
"web reader (re)start",
timestamp_repr=repr(timestamp),
source_node_name=_local_node_name)
self._watcher = Watcher(
_stats,
self._data_reader_clients,
self._event_push_client
)
self.application = Application(
memcached_client,
self._central_connection,
self._node_local_connection,
self._cluster_row,
self._data_readers,
self._accounting_client,
self._event_push_client,
_stats
)
self.wsgi_server = WSGIServer(
(_web_internal_reader_host, _web_internal_reader_port),
application=self.application,
backlog=_wsgi_backlog
)
def __init__(self):
self._log = logging.getLogger("WebInternalReader")
memcached_client = memcache.Client(_memcached_nodes)
self._central_connection = get_central_connection()
self._cluster_row = get_cluster_row(self._central_connection)
self._node_local_connection = get_node_local_connection()
self._deliverator = Deliverator()
self._zeromq_context = zmq.Context()
self._pull_server = GreenletPULLServer(
self._zeromq_context, _web_internal_reader_pipeline_address,
self._deliverator)
self._pull_server.link_exception(self._unhandled_greenlet_exception)
self._data_reader_clients = list()
self._data_readers = list()
for node_name, address in zip(_node_names, _data_reader_addresses):
resilient_client = GreenletResilientClient(
self._zeromq_context,
node_name,
address,
_client_tag,
_web_internal_reader_pipeline_address,
self._deliverator,
connect_messages=[])
resilient_client.link_exception(self._unhandled_greenlet_exception)
self._data_reader_clients.append(resilient_client)
data_reader = DataReader(node_name, resilient_client)
self._data_readers.append(data_reader)
self._space_accounting_dealer_client = GreenletDealerClient(
self._zeromq_context, _local_node_name,
_space_accounting_server_address)
self._space_accounting_dealer_client.link_exception(
self._unhandled_greenlet_exception)
push_client = GreenletPUSHClient(
self._zeromq_context,
_local_node_name,
_space_accounting_pipeline_address,
)
self._accounting_client = SpaceAccountingClient(
_local_node_name, self._space_accounting_dealer_client,
push_client)
self._event_push_client = EventPushClient(self._zeromq_context,
"web-internal-reader")
# message sent to data readers telling them the server
# is (re)starting, thereby invalidating any archvies or retrieved
# that are in progress for this node
timestamp = create_timestamp()
self._event_push_client.info("web-reader-start",
"web reader (re)start",
timestamp_repr=repr(timestamp),
source_node_name=_local_node_name)
self._watcher = Watcher(_stats, self._data_reader_clients,
self._event_push_client)
self.application = Application(memcached_client,
self._central_connection,
self._node_local_connection,
self._cluster_row, self._data_readers,
self._accounting_client,
self._event_push_client, _stats)
self.wsgi_server = WSGIServer(
(_web_internal_reader_host, _web_internal_reader_port),
application=self.application,
backlog=_wsgi_backlog)
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()
