def service_kwargs_for_farmer(root_path):
service_name = "farmer"
config = load_config_cli(root_path, "config.yaml", service_name)
keychain = Keychain()
connect_peers = [
PeerInfo(config["full_node_peer"]["host"],
config["full_node_peer"]["port"])
]
# TOD: Remove once we have pool server
config_pool = load_config_cli(root_path, "config.yaml", "pool")
api = Farmer(config, config_pool, keychain, constants)
kwargs = dict(
root_path=root_path,
api=api,
node_type=NodeType.FARMER,
advertised_port=config["port"],
service_name=service_name,
server_listen_ports=[config["port"]],
connect_peers=connect_peers,
auth_connect_peers=False,
on_connect_callback=api._on_connect,
)
if config["start_rpc_server"]:
kwargs["rpc_info"] = (FarmerRpcApi, config["rpc_port"])
return kwargs
def main():
config = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml", SERVICE_NAME)
config_pool = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml", "pool")
keychain = Keychain()
kwargs = service_kwargs_for_farmer(DEFAULT_ROOT_PATH, config, config_pool,
keychain, DEFAULT_CONSTANTS)
return run_service(**kwargs)
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", "farmer")
# TOD: Remove once we have pool server
config_pool = load_config_cli(root_path, "config.yaml", "pool")
initialize_logging("Farmer %(name)-25s", config["logging"], root_path)
log = logging.getLogger(__name__)
setproctitle("chia_farmer")
keychain = Keychain()
farmer = Farmer(config, config_pool, keychain)
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"],
farmer,
NodeType.FARMER,
ping_interval,
network_id,
root_path,
config,
)
try:
asyncio.get_running_loop().add_signal_handler(signal.SIGINT,
server.close_all)
asyncio.get_running_loop().add_signal_handler(signal.SIGTERM,
server.close_all)
except NotImplementedError:
log.info("signal handlers unsupported")
_ = await server.start_server(farmer._on_connect)
farmer.set_server(server)
rpc_cleanup = None
if config["start_rpc_server"]:
# Starts the RPC server
rpc_cleanup = await start_farmer_rpc_server(farmer, server.close_all,
config["rpc_port"])
await asyncio.sleep(10) # Allows full node to startup
farmer._start_bg_tasks()
await server.await_closed()
farmer._shut_down = True
# Waits for the rpc server to close
if rpc_cleanup is not None:
await rpc_cleanup()
log.info("Closed RPC server.")
log.info("Farmer fully 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", "harvester")
try:
plot_config = load_config(root_path, "plots.yaml")
except FileNotFoundError:
raise RuntimeError("Plots not generated. Run chia-create-plots")
initialize_logging("Harvester %(name)-22s", config["logging"])
log = logging.getLogger(__name__)
setproctitle("chia_harvester")
harvester = Harvester(config, plot_config)
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"], harvester, NodeType.HARVESTER,
ping_interval, network_id)
_ = await server.start_server(None, config)
asyncio.get_running_loop().add_signal_handler(signal.SIGINT,
server.close_all)
asyncio.get_running_loop().add_signal_handler(signal.SIGTERM,
server.close_all)
peer_info = PeerInfo(harvester.config["farmer_peer"]["host"],
harvester.config["farmer_peer"]["port"])
_ = await server.start_client(peer_info, None, config)
await server.await_closed()
harvester._shutdown()
await harvester._await_shutdown()
log.info("Harvester fully closed.")
def service_kwargs_for_harvester(root_path=DEFAULT_ROOT_PATH):
service_name = "harvester"
config = load_config_cli(root_path, "config.yaml", service_name)
try:
plot_config = load_config(root_path, "plots.yaml")
except FileNotFoundError:
raise RuntimeError("Plots not generated. Run chia-create-plots")
connect_peers = [
PeerInfo(config["farmer_peer"]["host"], config["farmer_peer"]["port"])
]
api = Harvester(config, plot_config, root_path)
kwargs = dict(
root_path=root_path,
api=api,
node_type=NodeType.HARVESTER,
advertised_port=config["port"],
service_name=service_name,
server_listen_ports=[config["port"]],
connect_peers=connect_peers,
rpc_start_callback_port=(start_harvester_rpc_server,
config["rpc_port"]),
)
return kwargs
def service_kwargs_for_harvester(root_path=DEFAULT_ROOT_PATH):
service_name = "harvester"
config = load_config_cli(root_path, "config.yaml", service_name)
connect_peers = [
PeerInfo(config["farmer_peer"]["host"], config["farmer_peer"]["port"])
]
api = Harvester(root_path, constants)
async def start_callback():
await api._start()
def stop_callback():
api._close()
async def await_closed_callback():
await api._await_closed()
kwargs = dict(
root_path=root_path,
api=api,
node_type=NodeType.HARVESTER,
advertised_port=config["port"],
service_name=service_name,
server_listen_ports=[config["port"]],
connect_peers=connect_peers,
auth_connect_peers=True,
start_callback=start_callback,
stop_callback=stop_callback,
await_closed_callback=await_closed_callback,
)
if config["start_rpc_server"]:
kwargs["rpc_info"] = (HarvesterRpcApi, config["rpc_port"])
return kwargs
async def main():
root_path = DEFAULT_ROOT_PATH
net_config = load_config(root_path, "config.yaml")
config = load_config_cli(root_path, "config.yaml", "introducer")
initialize_logging("Introducer %(name)-21s", config["logging"])
log = logging.getLogger(__name__)
setproctitle("chia_introducer")
introducer = Introducer(config)
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"], introducer, NodeType.INTRODUCER,
ping_interval, network_id)
introducer.set_server(server)
_ = await server.start_server(None, config)
asyncio.get_running_loop().add_signal_handler(signal.SIGINT,
server.close_all)
asyncio.get_running_loop().add_signal_handler(signal.SIGTERM,
server.close_all)
await server.await_closed()
log.info("Introducer fully closed.")
def main():
config = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml", SERVICE_NAME)
overrides = config["network_overrides"][config["selected_network"]]
updated_constants = DEFAULT_CONSTANTS.replace_str_to_bytes(**overrides)
kwargs = service_kwargs_for_full_node(DEFAULT_ROOT_PATH, config,
updated_constants)
return run_service(**kwargs)
def service_kwargs_for_timelord(root_path):
service_name = "timelord"
config = load_config_cli(root_path, "config.yaml", service_name)
connect_peers = [
PeerInfo(config["full_node_peer"]["host"],
config["full_node_peer"]["port"])
]
api = Timelord(config, constants["DISCRIMINANT_SIZE_BITS"])
async def start_callback():
await api._start()
def stop_callback():
api._close()
async def await_closed_callback():
await api._await_closed()
kwargs = dict(
root_path=root_path,
api=api,
node_type=NodeType.TIMELORD,
advertised_port=config["port"],
service_name=service_name,
server_listen_ports=[config["port"]],
start_callback=start_callback,
stop_callback=stop_callback,
await_closed_callback=await_closed_callback,
connect_peers=connect_peers,
auth_connect_peers=False,
)
return kwargs
def __init__(
self,
root_path,
api: Any,
node_type: NodeType,
advertised_port: int,
service_name: str,
server_listen_ports: List[int] = [],
connect_peers: List[PeerInfo] = [],
on_connect_callback: Optional[OutboundMessage] = None,
rpc_start_callback_port: Optional[Tuple[Callable, int]] = None,
start_callback: Optional[Callable] = None,
stop_callback: Optional[Callable] = None,
await_closed_callback: Optional[Callable] = None,
periodic_introducer_poll: Optional[Tuple[PeerInfo, int, int]] = None,
):
net_config = load_config(root_path, "config.yaml")
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
self._node_type = node_type
proctitle_name = f"chia_{service_name}"
setproctitle(proctitle_name)
self._log = logging.getLogger(service_name)
config = load_config_cli(root_path, "config.yaml", service_name)
initialize_logging(f"{service_name:<30s}", config["logging"],
root_path)
self._rpc_start_callback_port = rpc_start_callback_port
self._server = ChiaServer(
config["port"],
api,
node_type,
ping_interval,
network_id,
root_path,
config,
)
for _ in ["set_server", "_set_server"]:
f = getattr(api, _, None)
if f:
f(self._server)
self._connect_peers = connect_peers
self._server_listen_ports = server_listen_ports
self._api = api
self._task = None
self._is_stopping = False
self._periodic_introducer_poll = periodic_introducer_poll
self._on_connect_callback = on_connect_callback
self._start_callback = start_callback
self._stop_callback = stop_callback
self._await_closed_callback = await_closed_callback
async def main():
config = load_config_cli("config.yaml", "harvester")
try:
key_config = load_config("keys.yaml")
except FileNotFoundError:
raise RuntimeError(
"Keys not generated. Run python3 ./scripts/regenerate_keys.py.")
try:
plot_config = load_config("plots.yaml")
except FileNotFoundError:
raise RuntimeError(
"Plots not generated. Run python3.7 ./scripts/create_plots.py.")
initialize_logging("Harvester %(name)-22s", config["logging"])
log = logging.getLogger(__name__)
setproctitle("chia_harvester")
harvester = Harvester(config, key_config, plot_config)
server = ChiaServer(config["port"], harvester, NodeType.HARVESTER)
_ = await server.start_server(config["port"], None)
asyncio.get_running_loop().add_signal_handler(signal.SIGINT,
server.close_all)
asyncio.get_running_loop().add_signal_handler(signal.SIGTERM,
server.close_all)
peer_info = PeerInfo(harvester.config["farmer_peer"]["host"],
harvester.config["farmer_peer"]["port"])
_ = await server.start_client(peer_info, None)
await server.await_closed()
harvester._shutdown()
await harvester._await_shutdown()
log.info("Harvester fully closed.")
def service_kwargs_for_full_node(root_path):
service_name = "full_node"
config = load_config_cli(root_path, "config.yaml", service_name)
api = FullNode(config, root_path=root_path, consensus_constants=constants)
async def start_callback():
if config["enable_upnp"]:
upnp_remap_port(config["port"])
await api._start()
def stop_callback():
api._close()
async def await_closed_callback():
await api._await_closed()
kwargs = dict(
root_path=root_path,
api=api,
node_type=NodeType.FULL_NODE,
advertised_port=config["port"],
service_name=service_name,
server_listen_ports=[config["port"]],
on_connect_callback=api._on_connect,
start_callback=start_callback,
stop_callback=stop_callback,
await_closed_callback=await_closed_callback,
)
if config["start_rpc_server"]:
kwargs["rpc_info"] = (FullNodeRpcApi, config["rpc_port"])
return kwargs
def service_kwargs_for_introducer(root_path=DEFAULT_ROOT_PATH):
service_name = "introducer"
config = load_config_cli(root_path, "config.yaml", service_name)
introducer = Introducer(
config["max_peers_to_send"], config["recent_peer_threshold"]
)
async def start_callback():
await introducer._start()
def stop_callback():
introducer._close()
async def await_closed_callback():
await introducer._await_closed()
kwargs = dict(
root_path=root_path,
api=introducer,
node_type=NodeType.INTRODUCER,
advertised_port=config["port"],
service_name=service_name,
server_listen_ports=[config["port"]],
start_callback=start_callback,
stop_callback=stop_callback,
await_closed_callback=await_closed_callback,
)
return kwargs
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.set_server(server)
coro = asyncio.start_server(
timelord._handle_client,
config["vdf_server"]["host"],
config["vdf_server"]["port"],
loop=asyncio.get_running_loop(),
)
def stop_all():
server.close_all()
timelord._shutdown()
try:
asyncio.get_running_loop().add_signal_handler(signal.SIGINT, stop_all)
asyncio.get_running_loop().add_signal_handler(signal.SIGTERM, stop_all)
except NotImplementedError:
log.info("signal handlers unsupported")
await asyncio.sleep(10) # Allows full node to startup
peer_info = PeerInfo(config["full_node_peer"]["host"],
config["full_node_peer"]["port"])
bg_task = start_timelord_bg_task(server, peer_info, log)
vdf_server = asyncio.ensure_future(coro)
await timelord._manage_discriminant_queue()
log.info("Closed discriminant queue.")
log.info("Shutdown timelord.")
await server.await_closed()
vdf_server.cancel()
bg_task.cancel()
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.")
def main():
config = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml", SERVICE_NAME)
config["database_path"] = config["simulator_database_path"]
kwargs = service_kwargs_for_full_node_simulator(
DEFAULT_ROOT_PATH,
config,
test_constants,
BlockTools(),
)
return run_service(**kwargs)
async def get_transaction(args: dict, wallet_client: WalletRpcClient,
fingerprint: int) -> None:
wallet_id = args["id"]
transaction_id = hexstr_to_bytes(args["tx_id"])
config = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml", SERVICE_NAME)
name = config["network_overrides"]["config"][
config["selected_network"]]["address_prefix"]
tx: TransactionRecord = await wallet_client.get_transaction(
wallet_id, transaction_id=transaction_id)
print_transaction(tx, verbose=(args["verbose"] > 0), name=name)
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", "harvester")
try:
plot_config = load_config(root_path, "plots.yaml")
except FileNotFoundError:
raise RuntimeError("Plots not generated. Run chia-create-plots")
initialize_logging("Harvester %(name)-22s", config["logging"], root_path)
log = logging.getLogger(__name__)
setproctitle("chia_harvester")
harvester = await Harvester.create(config, plot_config, root_path)
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"],
harvester,
NodeType.HARVESTER,
ping_interval,
network_id,
DEFAULT_ROOT_PATH,
config,
)
try:
asyncio.get_running_loop().add_signal_handler(signal.SIGINT, server.close_all)
asyncio.get_running_loop().add_signal_handler(signal.SIGTERM, server.close_all)
except NotImplementedError:
log.info("signal handlers unsupported")
rpc_cleanup = None
if config["start_rpc_server"]:
# Starts the RPC server
rpc_cleanup = await start_harvester_rpc_server(
harvester, server.close_all, config["rpc_port"]
)
harvester.set_server(server)
await asyncio.sleep(1)
harvester._start_bg_tasks()
await server.await_closed()
harvester._shutdown()
await harvester._await_shutdown()
# Waits for the rpc server to close
if rpc_cleanup is not None:
await rpc_cleanup()
log.info("Closed RPC server.")
log.info("Harvester fully closed.")
def __init__(self, keychain: Keychain, root_path: Path):
self.config = load_config_cli(root_path, "config.yaml", "wallet")
initialize_logging("Wallet %(name)-25s", self.config["logging"], root_path)
self.log = log
self.keychain = keychain
self.websocket = None
self.root_path = root_path
self.wallet_node: Optional[WalletNode] = None
self.trade_manager: Optional[TradeManager] = None
self.shut_down = False
if self.config["testing"] is True:
self.config["database_path"] = "test_db_wallet.db"
def main():
config = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml", SERVICE_NAME)
config["database_path"] = config["simulator_database_path"]
config["peer_db_path"] = config["simulator_peer_db_path"]
config["introducer_peer"]["host"] = "127.0.0.1"
config["introducer_peer"]["port"] = 58555
config["selected_network"] = "testnet0"
kwargs = service_kwargs_for_full_node_simulator(
DEFAULT_ROOT_PATH,
config,
BlockTools(test_constants),
)
return run_service(**kwargs)
def main():
config = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml", SERVICE_NAME)
# This is simulator
local_test = config["testing"]
if local_test is True:
constants = test_constants
current = config["database_path"]
config["database_path"] = f"{current}_simulation"
else:
constants = DEFAULT_CONSTANTS
keychain = Keychain(testing=False)
kwargs = service_kwargs_for_wallet(DEFAULT_ROOT_PATH, config, constants,
keychain)
return run_service(**kwargs)
async def main():
config = load_config_cli("config.yaml", "ui")
initialize_logging("UI %(name)-29s", config["logging"])
setproctitle("chia_full_node_ui")
await_all_closed, ui_close_cb = await start_ssh_server(
config["port"], config["ssh_filename"], config["rpc_port"])
asyncio.get_running_loop().add_signal_handler(signal.SIGINT,
lambda: ui_close_cb(False))
asyncio.get_running_loop().add_signal_handler(signal.SIGTERM,
lambda: ui_close_cb(False))
await await_all_closed()
def service_kwargs_for_introducer(root_path=DEFAULT_ROOT_PATH):
service_name = "introducer"
config = load_config_cli(root_path, "config.yaml", service_name)
introducer = Introducer(config["max_peers_to_send"],
config["recent_peer_threshold"])
kwargs = dict(
root_path=root_path,
api=introducer,
node_type=NodeType.INTRODUCER,
advertised_port=config["port"],
service_name=service_name,
server_listen_ports=[config["port"]],
)
return kwargs
def service_kwargs_for_wallet(root_path):
service_name = "wallet"
config = load_config_cli(root_path, "config.yaml", service_name)
keychain = Keychain(testing=False)
wallet_constants = consensus_constants
if config["testing"] is True:
config["database_path"] = "test_db_wallet.db"
wallet_constants = test_constants
api = WalletNode(config,
keychain,
root_path,
consensus_constants=wallet_constants)
if "full_node_peer" in config:
connect_peers = [
PeerInfo(config["full_node_peer"]["host"],
config["full_node_peer"]["port"])
]
else:
connect_peers = []
async def start_callback():
await api._start()
def stop_callback():
api._close()
async def await_closed_callback():
await api._await_closed()
kwargs = dict(
root_path=root_path,
api=api,
node_type=NodeType.WALLET,
advertised_port=config["port"],
service_name=service_name,
server_listen_ports=[config["port"]],
on_connect_callback=api._on_connect,
stop_callback=stop_callback,
start_callback=start_callback,
await_closed_callback=await_closed_callback,
rpc_info=(WalletRpcApi, config["rpc_port"]),
connect_peers=connect_peers,
auth_connect_peers=False,
)
return kwargs
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", "farmer")
try:
check_keys(root_path)
key_config = load_config(root_path, "keys.yaml")
except FileNotFoundError:
raise RuntimeError("Keys not generated. Run `chia generate keys`")
initialize_logging("Farmer %(name)-25s", config["logging"], root_path)
log = logging.getLogger(__name__)
setproctitle("chia_farmer")
farmer = Farmer(config, key_config)
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"],
farmer,
NodeType.FARMER,
ping_interval,
network_id,
root_path,
config,
)
try:
asyncio.get_running_loop().add_signal_handler(signal.SIGINT, server.close_all)
asyncio.get_running_loop().add_signal_handler(signal.SIGTERM, server.close_all)
except NotImplementedError:
log.info("signal handlers unsupported")
_ = await server.start_server(farmer._on_connect)
farmer.set_server(server)
await asyncio.sleep(10) # Allows full node to startup
farmer._start_bg_tasks()
await server.await_closed()
farmer._shut_down = True
log.info("Farmer fully closed.")
def main():
config = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml", SERVICE_NAME)
# This is simulator
local_test = config["testing"]
if local_test is True:
constants = test_constants
current = config["database_path"]
config["database_path"] = f"{current}_simulation"
else:
constants = DEFAULT_CONSTANTS
genesis_challenge = bytes32(
bytes.fromhex(config["network_genesis_challenges"][
config["selected_network"]]))
constants = constants.replace(GENESIS_CHALLENGE=genesis_challenge)
keychain = Keychain(testing=False)
kwargs = service_kwargs_for_wallet(DEFAULT_ROOT_PATH, config, constants,
keychain)
return run_service(**kwargs)
async def main():
config = load_config_cli("config.yaml", "introducer")
initialize_logging("Introducer %(name)-21s", config["logging"])
log = logging.getLogger(__name__)
setproctitle("chia_introducer")
introducer = Introducer(config)
server = ChiaServer(config["port"], introducer, NodeType.INTRODUCER)
introducer.set_server(server)
_ = await server.start_server(config["host"], None)
asyncio.get_running_loop().add_signal_handler(signal.SIGINT,
server.close_all)
asyncio.get_running_loop().add_signal_handler(signal.SIGTERM,
server.close_all)
await server.await_closed()
log.info("Introducer fully closed.")
async def main():
config = load_config_cli("config.yaml", "farmer")
try:
key_config = load_config("keys.yaml")
except FileNotFoundError:
raise RuntimeError(
"Keys not generated. Run python3 ./scripts/regenerate_keys.py.")
initialize_logging("Farmer %(name)-25s", config["logging"])
log = logging.getLogger(__name__)
setproctitle("chia_farmer")
farmer = Farmer(config, key_config)
harvester_peer = PeerInfo(config["harvester_peer"]["host"],
config["harvester_peer"]["port"])
full_node_peer = PeerInfo(config["full_node_peer"]["host"],
config["full_node_peer"]["port"])
server = ChiaServer(config["port"], farmer, NodeType.FARMER)
asyncio.get_running_loop().add_signal_handler(signal.SIGINT,
server.close_all)
asyncio.get_running_loop().add_signal_handler(signal.SIGTERM,
server.close_all)
async def on_connect():
# Sends a handshake to the harvester
pool_sks: List[PrivateKey] = [
PrivateKey.from_bytes(bytes.fromhex(ce))
for ce in key_config["pool_sks"]
]
msg = HarvesterHandshake([sk.get_public_key() for sk in pool_sks])
yield OutboundMessage(NodeType.HARVESTER,
Message("harvester_handshake", msg),
Delivery.BROADCAST)
_ = await server.start_server(config["host"], on_connect)
await asyncio.sleep(1) # Prevents TCP simultaneous connect with harvester
_ = await server.start_client(harvester_peer, None)
_ = await server.start_client(full_node_peer, None)
await server.await_closed()
log.info("Farmer 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", "farmer")
try:
key_config = load_config(root_path, "keys.yaml")
except FileNotFoundError:
raise RuntimeError("Keys not generated. Run chia-generate-keys")
initialize_logging("Farmer %(name)-25s", config["logging"])
log = logging.getLogger(__name__)
setproctitle("chia_farmer")
farmer = Farmer(config, key_config)
harvester_peer = PeerInfo(config["harvester_peer"]["host"],
config["harvester_peer"]["port"])
full_node_peer = PeerInfo(config["full_node_peer"]["host"],
config["full_node_peer"]["port"])
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"], farmer, NodeType.FARMER, ping_interval,
network_id)
asyncio.get_running_loop().add_signal_handler(signal.SIGINT,
server.close_all)
asyncio.get_running_loop().add_signal_handler(signal.SIGTERM,
server.close_all)
_ = await server.start_server(farmer._on_connect, config)
await asyncio.sleep(2) # Prevents TCP simultaneous connect with harvester
_ = await server.start_client(harvester_peer, None, config)
_ = await server.start_client(full_node_peer, None, config)
farmer.set_server(server)
farmer._start_bg_tasks()
await server.await_closed()
farmer._shut_down = True
log.info("Farmer fully closed.")
