def trinity_boot(args: Namespace, trinity_config: TrinityConfig,
extra_kwargs: Dict[str, Any], plugin_manager: PluginManager,
listener: logging.handlers.QueueListener, event_bus: EventBus,
main_endpoint: Endpoint, logger: logging.Logger) -> None:
# start the listener thread to handle logs produced by other processes in
# the local logger.
listener.start()
event_bus.start()
# First initialize the database process.
database_server_process = ctx.Process(
name="DB",
target=run_database_process,
args=(
trinity_config,
LevelDB,
),
kwargs=extra_kwargs,
)
# start the processes
database_server_process.start()
logger.info("Started DB server process (pid=%d)",
database_server_process.pid)
# networking process needs the IPC socket file provided by the database process
try:
wait_for_ipc(trinity_config.database_ipc_path)
except TimeoutError as e:
logger.error("Timeout waiting for database to start. Exiting...")
kill_process_gracefully(database_server_process, logger)
ArgumentParser().error(message="Timed out waiting for database start")
def kill_trinity_with_reason(reason: str) -> None:
kill_trinity_gracefully(logger, (database_server_process, ),
plugin_manager,
main_endpoint,
event_bus,
reason=reason)
main_endpoint.subscribe(ShutdownRequest,
lambda ev: kill_trinity_with_reason(ev.reason))
plugin_manager.prepare(args, trinity_config, extra_kwargs)
kill_trinity_with_reason("No beacon support yet. SOON!")
try:
loop = asyncio.get_event_loop()
loop.add_signal_handler(signal.SIGTERM,
lambda: kill_trinity_with_reason("SIGTERM"))
loop.run_forever()
loop.close()
except KeyboardInterrupt:
kill_trinity_with_reason("CTRL+C / Keyboard Interrupt")
async def run_proc1():
endpoint = Endpoint()
await endpoint.start_serving(ConnectionConfig.from_name('e1'))
await endpoint.connect_to_endpoints(ConnectionConfig.from_name('e2'), )
print("subscribing")
# Listen for `GetSomethingRequest`'s
endpoint.subscribe(
GetSomethingRequest,
lambda event:
# Send a response back to *only* who made that request
endpoint.broadcast_nowait(DeliverSomethingResponse("Yay"),
event.broadcast_config()))
async def proc2_worker():
endpoint = Endpoint()
await endpoint.start_serving(ConnectionConfig.from_name('e2'))
await endpoint.connect_to_endpoints(ConnectionConfig.from_name('e1'))
asyncio.ensure_future(display_proc1_events(endpoint))
endpoint.subscribe(
FirstThingHappened, lambda event: print(
"Received via SUBSCRIBE API in proc2:", event.payload))
while True:
print("Hello from proc2")
if is_nth_second(2):
await endpoint.broadcast(
SecondThingHappened("Hit from proc2 ({})".format(time.time())))
await asyncio.sleep(1)
def trinity_boot(args: Namespace,
trinity_config: TrinityConfig,
extra_kwargs: Dict[str, Any],
plugin_manager: PluginManager,
listener: logging.handlers.QueueListener,
event_bus: EventBus,
main_endpoint: Endpoint,
logger: logging.Logger) -> None:
# start the listener thread to handle logs produced by other processes in
# the local logger.
listener.start()
event_bus.start()
def kill_trinity_with_reason(reason: str) -> None:
kill_trinity_gracefully(
logger,
(),
plugin_manager,
main_endpoint,
event_bus,
reason=reason
)
main_endpoint.subscribe(
ShutdownRequest,
lambda ev: kill_trinity_with_reason(ev.reason)
)
plugin_manager.prepare(args, trinity_config, extra_kwargs)
try:
loop = asyncio.get_event_loop()
loop.add_signal_handler(signal.SIGTERM, lambda: kill_trinity_with_reason("SIGTERM"))
loop.run_forever()
loop.close()
except KeyboardInterrupt:
kill_trinity_with_reason("CTRL+C / Keyboard Interrupt")
def trinity_boot(args: Namespace,
trinity_config: TrinityConfig,
extra_kwargs: Dict[str, Any],
plugin_manager: PluginManager,
listener: logging.handlers.QueueListener,
event_bus: EventBus,
main_endpoint: Endpoint,
logger: logging.Logger) -> None:
# start the listener thread to handle logs produced by other processes in
# the local logger.
listener.start()
networking_endpoint = event_bus.create_endpoint(NETWORKING_EVENTBUS_ENDPOINT)
event_bus.start()
# First initialize the database process.
database_server_process = ctx.Process(
target=run_database_process,
args=(
trinity_config,
LevelDB,
),
kwargs=extra_kwargs,
)
networking_process = ctx.Process(
target=launch_node,
args=(args, trinity_config, networking_endpoint,),
kwargs=extra_kwargs,
)
# start the processes
database_server_process.start()
logger.info("Started DB server process (pid=%d)", database_server_process.pid)
# networking process needs the IPC socket file provided by the database process
try:
wait_for_ipc(trinity_config.database_ipc_path)
except TimeoutError as e:
logger.error("Timeout waiting for database to start. Exiting...")
kill_process_gracefully(database_server_process, logger)
ArgumentParser().error(message="Timed out waiting for database start")
networking_process.start()
logger.info("Started networking process (pid=%d)", networking_process.pid)
main_endpoint.subscribe(
ShutdownRequest,
lambda ev: kill_trinity_gracefully(
logger,
database_server_process,
networking_process,
plugin_manager,
main_endpoint,
event_bus
)
)
plugin_manager.prepare(args, trinity_config, extra_kwargs)
plugin_manager.broadcast(TrinityStartupEvent(
args,
trinity_config
))
try:
loop = asyncio.get_event_loop()
loop.run_forever()
loop.close()
except KeyboardInterrupt:
kill_trinity_gracefully(
logger,
database_server_process,
networking_process,
plugin_manager,
main_endpoint,
event_bus
)
def helios_boot(args: Namespace, chain_config: ChainConfig,
extra_kwargs: Dict[str, Any], plugin_manager: PluginManager,
listener: logging.handlers.QueueListener, event_bus: EventBus,
main_endpoint: Endpoint, logger: logging.Logger) -> None:
# start the listener thread to handle logs produced by other processes in
# the local logger.
listener.start()
logger.info(
"Checking for any already running Helios Protocol processes that need shutting down. Remember that you can only run 1 instance at a time."
)
fix_unclean_shutdown(chain_config, logger)
with chain_config.process_id_file('main'):
networking_endpoint = event_bus.create_endpoint(
NETWORKING_EVENTBUS_ENDPOINT)
event_bus.start()
# First initialize the database process.
database_server_process = ctx.Process(
target=run_database_process,
args=(
chain_config,
LevelDB,
),
kwargs=extra_kwargs,
)
chain_processes = []
for i in range(chain_config.num_chain_processes):
chain_process = ctx.Process(
target=run_chain_process,
args=(chain_config, i),
kwargs=extra_kwargs,
)
chain_processes.append(chain_process)
networking_process = ctx.Process(
target=launch_node,
args=(
args,
chain_config,
networking_endpoint,
),
kwargs=extra_kwargs,
)
# start the processes
database_server_process.start()
logger.info("Started DB server process (pid=%d)",
database_server_process.pid)
# networking process needs the IPC socket file provided by the database process
try:
wait_for_ipc(chain_config.database_ipc_path)
except TimeoutError as e:
logger.error("Timeout waiting for database to start. Exiting...")
kill_process_gracefully(database_server_process, logger)
ArgumentParser().error(
message="Timed out waiting for database start")
for i in range(chain_config.num_chain_processes):
chain_process = chain_processes[i]
chain_process.start()
logger.info("Started chain instance {} process (pid={})".format(
i, chain_process.pid))
try:
wait_for_ipc(chain_config.get_chain_ipc_path(i))
except TimeoutError as e:
logger.error(
"Timeout waiting for chain instance {} to start. Exiting..."
.format(i))
kill_process_gracefully(chain_process, logger)
for j in range(i + 1):
kill_process_gracefully(chain_processes[j], logger)
ArgumentParser().error(
message="Timed out waiting for chain instance {} start".
format(i))
networking_process.start()
logger.info("Started networking process (pid=%d)",
networking_process.pid)
main_endpoint.subscribe(
ShutdownRequest, lambda ev: kill_helios_gracefully(
logger, database_server_process, chain_processes,
networking_process, plugin_manager, main_endpoint, event_bus))
plugin_manager.prepare(args, chain_config, extra_kwargs)
plugin_manager.broadcast(HeliosStartupEvent(args, chain_config))
try:
loop = asyncio.get_event_loop()
loop.run_forever()
loop.close()
except KeyboardInterrupt:
kill_helios_gracefully(logger, database_server_process,
chain_processes, networking_process,
plugin_manager, main_endpoint, event_bus)