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.")