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()