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 test1(self): test_node_1_port = 21234 test_node_2_port = 21235 test_rpc_port = 21236 db_filename = "blockchain_test" if os.path.isfile(db_filename): os.remove(db_filename) store = await FullNodeStore.create(db_filename) await store._clear_database() blocks = bt.get_consecutive_blocks(test_constants, 10, [], 10) b: Blockchain = await Blockchain.create({}, test_constants) await store.add_block(blocks[0]) for i in range(1, 9): assert (await b.receive_block( blocks[i], blocks[i - 1].header_block)) == ReceiveBlockResult.ADDED_TO_HEAD await store.add_block(blocks[i]) config = load_config("config.yaml", "full_node") full_node_1 = FullNode(store, b, config) server_1 = ChiaServer(test_node_1_port, full_node_1, NodeType.FULL_NODE) _ = await server_1.start_server("127.0.0.1", None) full_node_1._set_server(server_1) def stop_node_cb(): full_node_1._shutdown() server_1.close_all() rpc_cleanup = await start_rpc_server(full_node_1, stop_node_cb, test_rpc_port) try: client = await RpcClient.create(test_rpc_port) state = await client.get_blockchain_state() assert state["lca"].header_hash is not None assert not state["sync_mode"] assert len(state["tips"]) > 0 assert state["difficulty"] > 0 assert state["ips"] > 0 block = await client.get_block(state["lca"].header_hash) assert block == blocks[6] assert (await client.get_block(bytes([1] * 32))) is None small_header_block = await client.get_header( state["lca"].header_hash) assert small_header_block.header == blocks[6].header_block.header assert len(await client.get_pool_balances()) > 0 assert len(await client.get_connections()) == 0 full_node_2 = FullNode(store, b, config) server_2 = ChiaServer(test_node_2_port, full_node_2, NodeType.FULL_NODE) full_node_2._set_server(server_2) _ = await server_2.start_server("127.0.0.1", None) await asyncio.sleep(2) # Allow server to start cons = await client.get_connections() assert len(cons) == 0 # Open a connection through the RPC await client.open_connection(host="127.0.0.1", port=test_node_2_port) cons = await client.get_connections() assert len(cons) == 1 # Close a connection through the RPC await client.close_connection(cons[0]["node_id"]) cons = await client.get_connections() assert len(cons) == 0 except AssertionError: # Checks that the RPC manages to stop the node await client.stop_node() client.close() await client.await_closed() server_2.close_all() await server_1.await_closed() await server_2.await_closed() await rpc_cleanup() await store.close() raise await client.stop_node() client.close() await client.await_closed() server_2.close_all() await server_1.await_closed() await server_2.await_closed() await rpc_cleanup() await store.close()
async def main(): config = load_config_cli("config.yaml", "full_node") setproctitle("chia_full_node") initialize_logging("FullNode %(name)-23s", config["logging"]) log = logging.getLogger(__name__) server_closed = False # Create the store (DB) and full node instance store = await FullNodeStore.create(f"blockchain_{config['database_id']}.db" ) genesis: FullBlock = FullBlock.from_bytes(constants["GENESIS_BLOCK"]) await store.add_block(genesis) log.info("Initializing blockchain from disk") small_header_blocks: Dict[ str, SmallHeaderBlock] = await load_header_blocks_from_store(store) blockchain = await Blockchain.create(small_header_blocks) full_node = FullNode(store, blockchain, config) if config["enable_upnp"]: log.info(f"Attempting to enable UPnP (open up port {config['port']})") try: upnp = miniupnpc.UPnP() upnp.discoverdelay = 5 upnp.discover() upnp.selectigd() upnp.addportmapping(config["port"], "TCP", upnp.lanaddr, config["port"], "chia", "") log.info(f"Port {config['port']} opened with UPnP.") except Exception as e: log.warning(f"UPnP failed: {e}") # Starts the full node server (which full nodes can connect to) server = ChiaServer(config["port"], full_node, NodeType.FULL_NODE) full_node._set_server(server) _ = await server.start_server(config["host"], full_node._on_connect) rpc_cleanup = None def master_close_cb(): nonlocal server_closed if not server_closed: # Called by the UI, when node is closed, or when a signal is sent log.info("Closing all connections, and server...") full_node._shutdown() server.close_all() server_closed = True if config["start_rpc_server"]: # Starts the RPC server if -r is provided rpc_cleanup = await start_rpc_server(full_node, master_close_cb, config["rpc_port"]) asyncio.get_running_loop().add_signal_handler(signal.SIGINT, master_close_cb) asyncio.get_running_loop().add_signal_handler(signal.SIGTERM, master_close_cb) full_node._start_bg_tasks() log.info("Waiting to connect to some peers...") await asyncio.sleep(3) log.info( f"Connected to {len(server.global_connections.get_connections())} peers." ) if config["connect_to_farmer"] and not server_closed: peer_info = PeerInfo( full_node.config["farmer_peer"]["host"], full_node.config["farmer_peer"]["port"], ) _ = await server.start_client(peer_info, None) if config["connect_to_timelord"] and not server_closed: peer_info = PeerInfo( full_node.config["timelord_peer"]["host"], full_node.config["timelord_peer"]["port"], ) _ = await server.start_client(peer_info, None) # Awaits for server and all connections to close await server.await_closed() log.info("Closed all node servers.") # Waits for the rpc server to close if rpc_cleanup is not None: await rpc_cleanup() log.info("Closed RPC server.") await store.close() log.info("Closed store.") await asyncio.get_running_loop().shutdown_asyncgens() log.info("Node fully closed.")
async def main(): # Create the store (DB) and full node instance db_id = 0 if "-id" in sys.argv: db_id = int(sys.argv[sys.argv.index("-id") + 1]) store = await FullNodeStore.create(f"blockchain_{db_id}.db") genesis: FullBlock = FullBlock.from_bytes(constants["GENESIS_BLOCK"]) await store.add_block(genesis) log.info("Initializing blockchain from disk") header_blocks: Dict[ str, HeaderBlock] = await load_header_blocks_from_store(store) blockchain = await Blockchain.create(header_blocks) full_node = FullNode(store, blockchain) # Starts the full node server (which full nodes can connect to) host, port = parse_host_port(full_node) if full_node.config["enable_upnp"]: log.info(f"Attempting to enable UPnP (open up port {port})") try: upnp = miniupnpc.UPnP() upnp.discoverdelay = 5 upnp.discover() upnp.selectigd() upnp.addportmapping(port, "TCP", upnp.lanaddr, port, "chia", "") log.info(f"Port {port} opened with UPnP.") except Exception as e: log.warning(f"UPnP failed: {e}") server = ChiaServer(port, full_node, NodeType.FULL_NODE) full_node._set_server(server) _ = await server.start_server(host, full_node._on_connect) rpc_cleanup = None def master_close_cb(): global server_closed if not server_closed: # Called by the UI, when node is closed, or when a signal is sent log.info("Closing all connections, and server...") full_node._shutdown() server.close_all() server_closed = True if "-r" in sys.argv: # Starts the RPC server if -r is provided index = sys.argv.index("-r") rpc_port = int(sys.argv[index + 1]) rpc_cleanup = await start_rpc_server(full_node, master_close_cb, rpc_port) asyncio.get_running_loop().add_signal_handler(signal.SIGINT, master_close_cb) asyncio.get_running_loop().add_signal_handler(signal.SIGTERM, master_close_cb) connect_to_farmer = "-f" in sys.argv connect_to_timelord = "-t" in sys.argv full_node._start_bg_tasks() log.info("Waiting to connect to some peers...") await asyncio.sleep(3) log.info( f"Connected to {len(server.global_connections.get_connections())} peers." ) if connect_to_farmer and not server_closed: peer_info = PeerInfo( full_node.config["farmer_peer"]["host"], full_node.config["farmer_peer"]["port"], ) _ = await server.start_client(peer_info, None) if connect_to_timelord and not server_closed: peer_info = PeerInfo( full_node.config["timelord_peer"]["host"], full_node.config["timelord_peer"]["port"], ) _ = await server.start_client(peer_info, None) # Awaits for server and all connections to close await server.await_closed() # Waits for the rpc server to close if rpc_cleanup is not None: await rpc_cleanup() await store.close() await asyncio.get_running_loop().shutdown_asyncgens() log.info("Node fully closed.")
async def main(): # Create the store (DB) and full node instance db_id = 0 if "-id" in sys.argv: db_id = int(sys.argv[sys.argv.index("-id") + 1]) store = FullNodeStore(f"fndb_{db_id}") blockchain = Blockchain(store) log.info("Initializing blockchain from disk") await blockchain.initialize() full_node = FullNode(store, blockchain) # Starts the full node server (which full nodes can connect to) host, port = parse_host_port(full_node) if full_node.config["enable_upnp"]: log.info(f"Attempting to enable UPnP (open up port {port})") try: upnp = miniupnpc.UPnP() upnp.discoverdelay = 5 upnp.discover() upnp.selectigd() upnp.addportmapping(port, "TCP", upnp.lanaddr, port, "chia", "") except Exception as e: log.warning(f"UPnP failed: {e}") server = ChiaServer(port, full_node, NodeType.FULL_NODE) full_node._set_server(server) _ = await server.start_server(host, full_node._on_connect) wait_for_ui, ui_close_cb = None, None def master_close_cb(): global server_closed if not server_closed: # Called by the UI, when node is closed, or when a signal is sent log.info("Closing all connections, and server...") full_node._shutdown() server.close_all() server_closed = True def signal_received(): if ui_close_cb: ui_close_cb() master_close_cb() asyncio.get_running_loop().add_signal_handler(signal.SIGINT, signal_received) asyncio.get_running_loop().add_signal_handler(signal.SIGTERM, signal_received) if "-u" in sys.argv: # Starts the UI if -u is provided index = sys.argv.index("-u") ui_ssh_port = int(sys.argv[index + 1]) from src.ui.prompt_ui import start_ssh_server wait_for_ui, ui_close_cb = await start_ssh_server( store, blockchain, server, port, ui_ssh_port, full_node.config["ssh_filename"], master_close_cb, ) connect_to_farmer = "-f" in sys.argv connect_to_timelord = "-t" in sys.argv full_node._start_bg_tasks() log.info("Waiting to connect to some peers...") await asyncio.sleep(3) log.info( f"Connected to {len(server.global_connections.get_connections())} peers." ) if connect_to_farmer and not server_closed: peer_info = PeerInfo( full_node.config["farmer_peer"]["host"], full_node.config["farmer_peer"]["port"], ) _ = await server.start_client(peer_info, None) if connect_to_timelord and not server_closed: peer_info = PeerInfo( full_node.config["timelord_peer"]["host"], full_node.config["timelord_peer"]["port"], ) _ = await server.start_client(peer_info, None) # Awaits for server and all connections to close await server.await_closed() # Awaits for all ui instances to close if wait_for_ui is not None: await wait_for_ui() await asyncio.get_running_loop().shutdown_asyncgens()
async def setup_two_nodes(): """ Setup and teardown of two full nodes, with blockchains and separate DBs. """ # SETUP store_1 = await FullNodeStore.create("blockchain_test") store_2 = await FullNodeStore.create("blockchain_test_2") await store_1._clear_database() await store_2._clear_database() b_1: Blockchain = await Blockchain.create({}, test_constants) b_2: Blockchain = await Blockchain.create({}, test_constants) await store_1.add_block(FullBlock.from_bytes(test_constants["GENESIS_BLOCK"])) await store_2.add_block(FullBlock.from_bytes(test_constants["GENESIS_BLOCK"])) full_node_1 = FullNode(store_1, b_1) server_1 = ChiaServer(21234, full_node_1, NodeType.FULL_NODE) _ = await server_1.start_server("127.0.0.1", full_node_1._on_connect) full_node_1._set_server(server_1) full_node_2 = FullNode(store_2, b_2) server_2 = ChiaServer(21235, full_node_2, NodeType.FULL_NODE) full_node_2._set_server(server_2) yield (full_node_1, full_node_2, server_1, server_2) # TEARDOWN full_node_1._shutdown() full_node_2._shutdown() server_1.close_all() server_2.close_all() await server_1.await_closed() await server_2.await_closed() await store_1.close() await store_2.close()