async def main():
timelord = Timelord()
host, port = parse_host_port(timelord)
server = ChiaServer(port, timelord, NodeType.TIMELORD)
_ = await server.start_server(host, None)
def signal_received():
server.close_all()
asyncio.create_task(timelord._shutdown())
asyncio.get_running_loop().add_signal_handler(signal.SIGINT,
signal_received)
asyncio.get_running_loop().add_signal_handler(signal.SIGTERM,
signal_received)
full_node_peer = PeerInfo(
timelord.config["full_node_peer"]["host"],
timelord.config["full_node_peer"]["port"],
)
await asyncio.sleep(1) # Prevents TCP simultaneous connect with full node
await server.start_client(full_node_peer, None)
async for msg in timelord._manage_discriminant_queue():
server.push_message(msg)
await server.await_closed()
async def main():
config = load_config_cli("config.yaml", "timelord")
initialize_logging("Timelord %(name)-23s", config["logging"])
log = logging.getLogger(__name__)
setproctitle("chia_timelord")
timelord = Timelord(config)
server = ChiaServer(config["port"], timelord, NodeType.TIMELORD)
_ = await server.start_server(config["host"], None)
def signal_received():
server.close_all()
asyncio.create_task(timelord._shutdown())
asyncio.get_running_loop().add_signal_handler(signal.SIGINT, signal_received)
asyncio.get_running_loop().add_signal_handler(signal.SIGTERM, signal_received)
full_node_peer = PeerInfo(
timelord.config["full_node_peer"]["host"],
timelord.config["full_node_peer"]["port"],
)
await asyncio.sleep(1) # Prevents TCP simultaneous connect with full node
await server.start_client(full_node_peer, None)
async for msg in timelord._manage_discriminant_queue():
server.push_message(msg)
await server.await_closed()
log.info("Timelord fully closed.")
async def main():
root_path = DEFAULT_ROOT_PATH
net_config = load_config(root_path, "config.yaml")
config = load_config_cli(root_path, "config.yaml", "timelord")
initialize_logging("Timelord %(name)-23s", config["logging"])
log = logging.getLogger(__name__)
setproctitle("chia_timelord")
timelord = Timelord(config, constants)
ping_interval = net_config.get("ping_interval")
network_id = net_config.get("network_id")
assert ping_interval is not None
assert network_id is not None
server = ChiaServer(config["port"], timelord, NodeType.TIMELORD,
ping_interval, network_id)
_ = await server.start_server(None, config)
timelord_shutdown_task: Optional[asyncio.Task] = None
coro = asyncio.start_server(
timelord._handle_client,
config["vdf_server"]["host"],
config["vdf_server"]["port"],
loop=asyncio.get_running_loop(),
)
def signal_received():
nonlocal timelord_shutdown_task
server.close_all()
timelord_shutdown_task = asyncio.create_task(timelord._shutdown())
asyncio.get_running_loop().add_signal_handler(signal.SIGINT,
signal_received)
asyncio.get_running_loop().add_signal_handler(signal.SIGTERM,
signal_received)
full_node_peer = PeerInfo(
timelord.config["full_node_peer"]["host"],
timelord.config["full_node_peer"]["port"],
)
await asyncio.sleep(1) # Prevents TCP simultaneous connect with full node
await server.start_client(full_node_peer, None, config)
vdf_server = asyncio.ensure_future(coro)
async for msg in timelord._manage_discriminant_queue():
server.push_message(msg)
log.info("Closed discriminant queue.")
if timelord_shutdown_task is not None:
await timelord_shutdown_task
log.info("Shutdown timelord.")
await server.await_closed()
vdf_server.cancel()
log.info("Timelord fully closed.")
async def test1(self):
store = FullNodeStore("fndb_test")
await store._clear_database()
blocks = bt.get_consecutive_blocks(test_constants, 10, [], 10)
b: Blockchain = Blockchain(test_constants)
await store.add_block(blocks[0])
await b.initialize({})
for i in range(1, 9):
assert (await
b.receive_block(blocks[i]
)) == ReceiveBlockResult.ADDED_TO_HEAD
await store.add_block(blocks[i])
full_node_1 = FullNode(store, b)
server_1 = ChiaServer(21234, full_node_1, NodeType.FULL_NODE)
_ = await server_1.start_server("127.0.0.1", None)
full_node_1._set_server(server_1)
full_node_2 = FullNode(store, b)
server_2 = ChiaServer(21235, full_node_2, NodeType.FULL_NODE)
full_node_2._set_server(server_2)
await server_2.start_client(PeerInfo("127.0.0.1", uint16(21234)), None)
await asyncio.sleep(2) # Allow connections to get made
num_unfinished_blocks = 1000
start_unf = time.time()
for i in range(num_unfinished_blocks):
msg = Message("unfinished_block",
peer_protocol.UnfinishedBlock(blocks[9]))
server_1.push_message(
OutboundMessage(NodeType.FULL_NODE, msg, Delivery.BROADCAST))
# Send the whole block ast the end so we can detect when the node is done
block_msg = Message("block", peer_protocol.Block(blocks[9]))
server_1.push_message(
OutboundMessage(NodeType.FULL_NODE, block_msg, Delivery.BROADCAST))
while time.time() - start_unf < 300:
if max([h.height for h in b.get_current_tips()]) == 9:
print(
f"Time taken to process {num_unfinished_blocks} is {time.time() - start_unf}"
)
server_1.close_all()
server_2.close_all()
await server_1.await_closed()
await server_2.await_closed()
return
await asyncio.sleep(0.1)
server_1.close_all()
server_2.close_all()
await server_1.await_closed()
await server_2.await_closed()
raise Exception("Took too long to process blocks")
async def test2(self):
num_blocks = 100
store = FullNodeStore("fndb_test")
await store._clear_database()
blocks = bt.get_consecutive_blocks(test_constants, num_blocks, [], 10)
b: Blockchain = Blockchain(test_constants)
await store.add_block(blocks[0])
await b.initialize({})
full_node_1 = FullNode(store, b)
server_1 = ChiaServer(21236, full_node_1, NodeType.FULL_NODE)
_ = await server_1.start_server("127.0.0.1", None)
full_node_1._set_server(server_1)
full_node_2 = FullNode(store, b)
server_2 = ChiaServer(21237, full_node_2, NodeType.FULL_NODE)
full_node_2._set_server(server_2)
await server_2.start_client(PeerInfo("127.0.0.1", uint16(21236)), None)
await asyncio.sleep(2) # Allow connections to get made
start_unf = time.time()
for i in range(1, num_blocks):
msg = Message("block", peer_protocol.Block(blocks[i]))
server_1.push_message(
OutboundMessage(NodeType.FULL_NODE, msg, Delivery.BROADCAST))
while time.time() - start_unf < 300:
if max([h.height for h in b.get_current_tips()]) == num_blocks - 1:
print(
f"Time taken to process {num_blocks} is {time.time() - start_unf}"
)
server_1.close_all()
server_2.close_all()
await server_1.await_closed()
await server_2.await_closed()
return
await asyncio.sleep(0.1)
server_1.close_all()
server_2.close_all()
await server_1.await_closed()
await server_2.await_closed()
raise Exception("Took too long to process blocks")
async def async_main():
root_path = DEFAULT_ROOT_PATH
net_config = load_config(root_path, "config.yaml")
config = load_config_cli(root_path, "config.yaml", "timelord")
initialize_logging("Timelord %(name)-23s", config["logging"], root_path)
log = logging.getLogger(__name__)
setproctitle("chia_timelord")
timelord = Timelord(config, constants)
ping_interval = net_config.get("ping_interval")
network_id = net_config.get("network_id")
assert ping_interval is not None
assert network_id is not None
server = ChiaServer(
config["port"],
timelord,
NodeType.TIMELORD,
ping_interval,
network_id,
DEFAULT_ROOT_PATH,
config,
)
timelord_shutdown_task: Optional[asyncio.Task] = None
coro = asyncio.start_server(
timelord._handle_client,
config["vdf_server"]["host"],
config["vdf_server"]["port"],
loop=asyncio.get_running_loop(),
)
def signal_received():
nonlocal timelord_shutdown_task
server.close_all()
timelord_shutdown_task = asyncio.create_task(timelord._shutdown())
try:
asyncio.get_running_loop().add_signal_handler(signal.SIGINT,
signal_received)
asyncio.get_running_loop().add_signal_handler(signal.SIGTERM,
signal_received)
except NotImplementedError:
log.info("signal handlers unsupported")
await asyncio.sleep(10) # Allows full node to startup
timelord.set_server(server)
timelord._start_bg_tasks()
vdf_server = asyncio.ensure_future(coro)
async for msg in timelord._manage_discriminant_queue():
server.push_message(msg)
log.info("Closed discriminant queue.")
if timelord_shutdown_task is not None:
await timelord_shutdown_task
log.info("Shutdown timelord.")
await server.await_closed()
vdf_server.cancel()
log.info("Timelord fully closed.")