chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/server/signal_handlers.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import dataclasses
+import functools
+import signal
+import sys
+from collections.abc import AsyncIterator
+from types import FrameType
+from typing import Optional, final
+
+from typing_extensions import Protocol
+
+from chia.util.task_referencer import create_referenced_task
+
+
+class Handler(Protocol):
+    def __call__(
+        self,
+        signal_: signal.Signals,
+        stack_frame: Optional[FrameType],
+        loop: asyncio.AbstractEventLoop,
+    ) -> None: ...
+
+
+class AsyncHandler(Protocol):
+    async def __call__(
+        self,
+        signal_: signal.Signals,
+        stack_frame: Optional[FrameType],
+        loop: asyncio.AbstractEventLoop,
+    ) -> None: ...
+
+
+@final
+@dataclasses.dataclass
+class SignalHandlers:
+    tasks: list[asyncio.Task[None]] = dataclasses.field(default_factory=list)
+
+    @classmethod
+    @contextlib.asynccontextmanager
+    async def manage(cls) -> AsyncIterator[SignalHandlers]:
+        self = cls()
+        try:
+            yield self
+        finally:
+            # TODO: log errors?
+            # TODO: return to previous signal handlers?
+            await asyncio.gather(*self.tasks)
+
+    def remove_done_handlers(self) -> None:
+        self.tasks = [task for task in self.tasks if not task.done()]
+
+    def loop_safe_sync_signal_handler_for_async(
+        self,
+        signal_: signal.Signals,
+        stack_frame: Optional[FrameType],
+        loop: asyncio.AbstractEventLoop,
+        handler: AsyncHandler,
+    ) -> None:
+        self.remove_done_handlers()
+
+        task = create_referenced_task(
+            handler(signal_=signal_, stack_frame=stack_frame, loop=loop),
+        )
+        self.tasks.append(task)
+
+    def threadsafe_sync_signal_handler_for_async(
+        self,
+        signal_: signal.Signals,
+        stack_frame: Optional[FrameType],
+        loop: asyncio.AbstractEventLoop,
+        handler: AsyncHandler,
+    ) -> None:
+        loop.call_soon_threadsafe(
+            functools.partial(
+                self.loop_safe_sync_signal_handler_for_async,
+                signal_=signal_,
+                stack_frame=stack_frame,
+                loop=loop,
+                handler=handler,
+            ),
+        )
+
+    def setup_sync_signal_handler(self, handler: Handler) -> None:
+        loop = asyncio.get_event_loop()
+
+        if sys.platform == "win32" or sys.platform == "cygwin":
+
+            def ensure_signal_object_not_int(
+                signal_: int,
+                stack_frame: Optional[FrameType],
+                *,
+                handler: Handler = handler,
+                loop: asyncio.AbstractEventLoop = loop,
+            ) -> None:
+                signal_ = signal.Signals(signal_)
+                handler(signal_=signal_, stack_frame=stack_frame, loop=loop)
+
+            for signal_ in [signal.SIGBREAK, signal.SIGINT, signal.SIGTERM]:
+                signal.signal(signal_, ensure_signal_object_not_int)
+        else:
+            for signal_ in [signal.SIGINT, signal.SIGTERM]:
+                loop.add_signal_handler(
+                    signal_,
+                    functools.partial(handler, signal_=signal_, stack_frame=None, loop=loop),
+                )
+
+    def setup_async_signal_handler(self, handler: AsyncHandler) -> None:
+        # https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.loop.add_signal_handler
+        # > a callback registered with this function is allowed to interact with the event
+        # > loop
+        #
+        # This is a bit vague so let's just use a thread safe call for Windows
+        # compatibility.
+
+        self.setup_sync_signal_handler(
+            handler=functools.partial(self.threadsafe_sync_signal_handler_for_async, handler=handler)
+        )

chia/server/ssl_context.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+
+def public_ssl_paths(path: Path, config: dict[str, Any]) -> tuple[Path, Path]:
+    return (
+        path / config["ssl"]["public_crt"],
+        path / config["ssl"]["public_key"],
+    )
+
+
+def private_ssl_paths(path: Path, config: dict[str, Any]) -> tuple[Path, Path]:
+    return (
+        path / config["ssl"]["private_crt"],
+        path / config["ssl"]["private_key"],
+    )
+
+
+def private_ssl_ca_paths(path: Path, config: dict[str, Any]) -> tuple[Path, Path]:
+    return (
+        path / config["private_ssl_ca"]["crt"],
+        path / config["private_ssl_ca"]["key"],
+    )
+
+
+def chia_ssl_ca_paths(path: Path, config: dict[str, Any]) -> tuple[Path, Path]:
+    return (
+        path / config["chia_ssl_ca"]["crt"],
+        path / config["chia_ssl_ca"]["key"],
+    )

chia/server/start_data_layer.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import logging
+import os
+import pathlib
+import sys
+from typing import Any, Optional, cast
+
+from chia.apis import ApiProtocolRegistry
+from chia.data_layer.data_layer import DataLayer
+from chia.data_layer.data_layer_api import DataLayerAPI
+from chia.data_layer.data_layer_util import PluginRemote
+from chia.data_layer.util.plugin import load_plugin_configurations
+from chia.rpc.data_layer_rpc_api import DataLayerRpcApi
+from chia.rpc.wallet_rpc_client import WalletRpcClient
+from chia.server.outbound_message import NodeType
+from chia.server.signal_handlers import SignalHandlers
+from chia.server.start_service import RpcInfo, Service, async_run
+from chia.ssl.create_ssl import create_all_ssl
+from chia.types.aliases import DataLayerService, WalletService
+from chia.util.chia_logging import initialize_logging
+from chia.util.config import load_config, load_config_cli
+from chia.util.default_root import resolve_root_path
+from chia.util.ints import uint16
+from chia.util.task_timing import maybe_manage_task_instrumentation
+
+# See: https://bugs.python.org/issue29288
+"".encode("idna")
+
+SERVICE_NAME = "data_layer"
+
+log = logging.getLogger(__name__)
+
+
+# TODO: Review need for config and if retained then hint it properly.
+def create_data_layer_service(
+    root_path: pathlib.Path,
+    config: dict[str, Any],
+    downloaders: list[PluginRemote],
+    uploaders: list[PluginRemote],  # dont add FilesystemUploader to this, it is the default uploader
+    wallet_service: Optional[WalletService] = None,
+    connect_to_daemon: bool = True,
+) -> DataLayerService:
+    if uploaders is None:
+        uploaders = []
+    if downloaders is None:
+        downloaders = []
+
+    service_config = config[SERVICE_NAME]
+
+    network_id = service_config["selected_network"]
+
+    self_hostname = config["self_hostname"]
+    wallet_rpc_port = service_config["wallet_peer"]["port"]
+    if wallet_service is None:
+        wallet_root_path = root_path
+        wallet_config = config
+    else:
+        wallet_root_path = wallet_service.root_path
+        wallet_config = wallet_service.config
+    wallet_rpc_init = WalletRpcClient.create(self_hostname, uint16(wallet_rpc_port), wallet_root_path, wallet_config)
+
+    # dont add Fil)
+    node = DataLayer.create(
+        config=service_config,
+        root_path=root_path,
+        wallet_rpc_init=wallet_rpc_init,
+        downloaders=downloaders,
+        uploaders=uploaders,
+    )
+    peer_api = DataLayerAPI(node)
+
+    rpc_info: Optional[RpcInfo[DataLayerRpcApi]] = None
+    if service_config.get("start_rpc_server", True):
+        rpc_info = (DataLayerRpcApi, cast(int, service_config["rpc_port"]))
+
+    return Service(
+        root_path=root_path,
+        config=config,
+        node=node,
+        # TODO: not for peers...
+        peer_api=peer_api,
+        node_type=NodeType.DATA_LAYER,
+        advertised_port=None,
+        service_name=SERVICE_NAME,
+        network_id=network_id,
+        max_request_body_size=service_config.get("rpc_server_max_request_body_size", 26214400),
+        rpc_info=rpc_info,
+        connect_to_daemon=connect_to_daemon,
+        class_for_type=ApiProtocolRegistry,
+    )
+
+
+async def async_main(root_path: pathlib.Path) -> int:
+    # TODO: refactor to avoid the double load
+    config = load_config(root_path, "config.yaml", fill_missing_services=True)
+    service_config = load_config_cli(root_path, "config.yaml", SERVICE_NAME, fill_missing_services=True)
+    config[SERVICE_NAME] = service_config
+    initialize_logging(
+        service_name=SERVICE_NAME,
+        logging_config=service_config["logging"],
+        root_path=root_path,
+    )
+
+    create_all_ssl(
+        root_path=root_path,
+        private_node_names=["data_layer"],
+        public_node_names=["data_layer"],
+        overwrite=False,
+    )
+
+    plugins_config = config["data_layer"].get("plugins", {})
+    service_dir = root_path / SERVICE_NAME
+
+    old_uploaders = config["data_layer"].get("uploaders", [])
+    new_uploaders = plugins_config.get("uploaders", [])
+    conf_file_uploaders = await load_plugin_configurations(service_dir, "uploaders", log)
+    uploaders: list[PluginRemote] = [
+        *(PluginRemote(url=url) for url in old_uploaders),
+        *(PluginRemote.unmarshal(marshalled=marshalled) for marshalled in new_uploaders),
+        *conf_file_uploaders,
+    ]
+
+    old_downloaders = config["data_layer"].get("downloaders", [])
+    new_downloaders = plugins_config.get("downloaders", [])
+    conf_file_uploaders = await load_plugin_configurations(service_dir, "downloaders", log)
+    downloaders: list[PluginRemote] = [
+        *(PluginRemote(url=url) for url in old_downloaders),
+        *(PluginRemote.unmarshal(marshalled=marshalled) for marshalled in new_downloaders),
+        *conf_file_uploaders,
+    ]
+
+    service = create_data_layer_service(root_path, config, downloaders, uploaders)
+    async with SignalHandlers.manage() as signal_handlers:
+        await service.setup_process_global_state(signal_handlers=signal_handlers)
+        await service.run()
+
+    return 0
+
+
+def main() -> int:
+    root_path = resolve_root_path(override=None)
+
+    with maybe_manage_task_instrumentation(
+        enable=os.environ.get(f"CHIA_INSTRUMENT_{SERVICE_NAME.upper()}") is not None
+    ):
+        return async_run(coro=async_main(root_path=root_path))
+
+
+if __name__ == "__main__":
+    sys.exit(main())

chia/server/start_farmer.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import os
+import pathlib
+import sys
+from typing import Any, Optional
+
+from chia.apis import ApiProtocolRegistry
+from chia.consensus.constants import ConsensusConstants, replace_str_to_bytes
+from chia.consensus.default_constants import DEFAULT_CONSTANTS, update_testnet_overrides
+from chia.farmer.farmer import Farmer
+from chia.farmer.farmer_api import FarmerAPI
+from chia.rpc.farmer_rpc_api import FarmerRpcApi
+from chia.server.outbound_message import NodeType
+from chia.server.signal_handlers import SignalHandlers
+from chia.server.start_service import RpcInfo, Service, async_run
+from chia.types.aliases import FarmerService
+from chia.util.chia_logging import initialize_service_logging
+from chia.util.config import get_unresolved_peer_infos, load_config, load_config_cli
+from chia.util.default_root import resolve_root_path
+from chia.util.keychain import Keychain
+from chia.util.task_timing import maybe_manage_task_instrumentation
+
+# See: https://bugs.python.org/issue29288
+"".encode("idna")
+
+SERVICE_NAME = "farmer"
+
+
+def create_farmer_service(
+    root_path: pathlib.Path,
+    config: dict[str, Any],
+    config_pool: dict[str, Any],
+    consensus_constants: ConsensusConstants,
+    keychain: Optional[Keychain] = None,
+    connect_to_daemon: bool = True,
+) -> FarmerService:
+    service_config = config[SERVICE_NAME]
+
+    network_id = service_config["selected_network"]
+    overrides = service_config["network_overrides"]["constants"][network_id]
+    update_testnet_overrides(network_id, overrides)
+    updated_constants = replace_str_to_bytes(consensus_constants, **overrides)
+
+    node = Farmer(
+        root_path, service_config, config_pool, consensus_constants=updated_constants, local_keychain=keychain
+    )
+    peer_api = FarmerAPI(node)
+
+    rpc_info: Optional[RpcInfo[FarmerRpcApi]] = None
+    if service_config.get("start_rpc_server", True):
+        rpc_info = (FarmerRpcApi, service_config["rpc_port"])
+
+    return Service(
+        root_path=root_path,
+        config=config,
+        node=node,
+        peer_api=peer_api,
+        node_type=NodeType.FARMER,
+        advertised_port=service_config["port"],
+        service_name=SERVICE_NAME,
+        connect_peers=get_unresolved_peer_infos(service_config, NodeType.FULL_NODE),
+        on_connect_callback=node.on_connect,
+        network_id=network_id,
+        rpc_info=rpc_info,
+        connect_to_daemon=connect_to_daemon,
+        class_for_type=ApiProtocolRegistry,
+    )
+
+
+async def async_main(root_path: pathlib.Path) -> int:
+    # TODO: refactor to avoid the double load
+    config = load_config(root_path, "config.yaml")
+    service_config = load_config_cli(root_path, "config.yaml", SERVICE_NAME)
+    config[SERVICE_NAME] = service_config
+    config_pool = load_config_cli(root_path, "config.yaml", "pool")
+    config["pool"] = config_pool
+    initialize_service_logging(service_name=SERVICE_NAME, config=config, root_path=root_path)
+
+    service = create_farmer_service(root_path, config, config_pool, DEFAULT_CONSTANTS)
+    async with SignalHandlers.manage() as signal_handlers:
+        await service.setup_process_global_state(signal_handlers=signal_handlers)
+        await service.run()
+
+    return 0
+
+
+def main() -> int:
+    root_path = resolve_root_path(override=None)
+
+    with maybe_manage_task_instrumentation(
+        enable=os.environ.get(f"CHIA_INSTRUMENT_{SERVICE_NAME.upper()}") is not None
+    ):
+        return async_run(coro=async_main(root_path=root_path))
+
+
+if __name__ == "__main__":
+    sys.exit(main())

chia/server/start_full_node.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import os
+import pathlib
+import sys
+from multiprocessing import freeze_support
+from typing import Any, Optional
+
+from chia.apis import ApiProtocolRegistry
+from chia.consensus.constants import ConsensusConstants, replace_str_to_bytes
+from chia.consensus.default_constants import DEFAULT_CONSTANTS, update_testnet_overrides
+from chia.full_node.full_node import FullNode
+from chia.full_node.full_node_api import FullNodeAPI
+from chia.rpc.full_node_rpc_api import FullNodeRpcApi
+from chia.server.outbound_message import NodeType
+from chia.server.signal_handlers import SignalHandlers
+from chia.server.start_service import RpcInfo, Service, async_run
+from chia.types.aliases import FullNodeService
+from chia.util.chia_logging import initialize_service_logging
+from chia.util.config import get_unresolved_peer_infos, load_config, load_config_cli
+from chia.util.default_root import resolve_root_path
+from chia.util.ints import uint16
+from chia.util.task_timing import maybe_manage_task_instrumentation
+
+# See: https://bugs.python.org/issue29288
+"".encode("idna")
+
+SERVICE_NAME = "full_node"
+
+
+async def create_full_node_service(
+    root_path: pathlib.Path,
+    config: dict[str, Any],
+    consensus_constants: ConsensusConstants,
+    connect_to_daemon: bool = True,
+    override_capabilities: Optional[list[tuple[uint16, str]]] = None,
+) -> FullNodeService:
+    service_config = config[SERVICE_NAME]
+
+    network_id = service_config["selected_network"]
+    upnp_list = []
+    if service_config["enable_upnp"]:
+        upnp_list = [service_config["port"]]
+
+    node = await FullNode.create(
+        service_config,
+        root_path=root_path,
+        consensus_constants=consensus_constants,
+    )
+    peer_api = FullNodeAPI(node)
+
+    rpc_info: Optional[RpcInfo[FullNodeRpcApi]] = None
+    if service_config.get("start_rpc_server", True):
+        rpc_info = (FullNodeRpcApi, service_config["rpc_port"])
+
+    return Service(
+        root_path=root_path,
+        config=config,
+        node=node,
+        peer_api=peer_api,
+        node_type=NodeType.FULL_NODE,
+        advertised_port=service_config["port"],
+        service_name=SERVICE_NAME,
+        upnp_ports=upnp_list,
+        connect_peers=get_unresolved_peer_infos(service_config, NodeType.FULL_NODE),
+        on_connect_callback=node.on_connect,
+        network_id=network_id,
+        rpc_info=rpc_info,
+        connect_to_daemon=connect_to_daemon,
+        override_capabilities=override_capabilities,
+        class_for_type=ApiProtocolRegistry,
+    )
+
+
+async def async_main(service_config: dict[str, Any], root_path: pathlib.Path) -> int:
+    # TODO: refactor to avoid the double load
+    config = load_config(root_path, "config.yaml")
+    config[SERVICE_NAME] = service_config
+    network_id = service_config["selected_network"]
+    overrides = service_config["network_overrides"]["constants"][network_id]
+    update_testnet_overrides(network_id, overrides)
+    updated_constants = replace_str_to_bytes(DEFAULT_CONSTANTS, **overrides)
+    initialize_service_logging(service_name=SERVICE_NAME, config=config, root_path=root_path)
+
+    service = await create_full_node_service(root_path, config, updated_constants)
+    async with SignalHandlers.manage() as signal_handlers:
+        await service.setup_process_global_state(signal_handlers=signal_handlers)
+        await service.run()
+
+    return 0
+
+
+def main() -> int:
+    freeze_support()
+    root_path = resolve_root_path(override=None)
+
+    with maybe_manage_task_instrumentation(
+        enable=os.environ.get(f"CHIA_INSTRUMENT_{SERVICE_NAME.upper()}") is not None
+    ):
+        service_config = load_config_cli(root_path, "config.yaml", SERVICE_NAME)
+        target_peer_count = service_config.get("target_peer_count", 40) - service_config.get(
+            "target_outbound_peer_count", 8
+        )
+        if target_peer_count < 0:
+            target_peer_count = None
+        if not service_config.get("use_chia_loop_policy", True):
+            target_peer_count = None
+        return async_run(coro=async_main(service_config, root_path=root_path), connection_limit=target_peer_count)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

chia/server/start_harvester.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import os
+import pathlib
+import sys
+from typing import Any, Optional
+
+from chia.apis import ApiProtocolRegistry
+from chia.consensus.constants import ConsensusConstants, replace_str_to_bytes
+from chia.consensus.default_constants import DEFAULT_CONSTANTS
+from chia.harvester.harvester import Harvester
+from chia.harvester.harvester_api import HarvesterAPI
+from chia.rpc.harvester_rpc_api import HarvesterRpcApi
+from chia.server.outbound_message import NodeType
+from chia.server.signal_handlers import SignalHandlers
+from chia.server.start_service import RpcInfo, Service, async_run
+from chia.types.aliases import HarvesterService
+from chia.types.peer_info import UnresolvedPeerInfo
+from chia.util.chia_logging import initialize_service_logging
+from chia.util.config import get_unresolved_peer_infos, load_config, load_config_cli
+from chia.util.default_root import resolve_root_path
+from chia.util.task_timing import maybe_manage_task_instrumentation
+
+# See: https://bugs.python.org/issue29288
+"".encode("idna")
+
+SERVICE_NAME = "harvester"
+
+
+def create_harvester_service(
+    root_path: pathlib.Path,
+    config: dict[str, Any],
+    consensus_constants: ConsensusConstants,
+    farmer_peers: set[UnresolvedPeerInfo],
+    connect_to_daemon: bool = True,
+) -> HarvesterService:
+    service_config = config[SERVICE_NAME]
+
+    network_id = service_config["selected_network"]
+    overrides = service_config["network_overrides"]["constants"][network_id]
+    updated_constants = replace_str_to_bytes(consensus_constants, **overrides)
+
+    node = Harvester(root_path, service_config, updated_constants)
+    peer_api = HarvesterAPI(node)
+    network_id = service_config["selected_network"]
+
+    rpc_info: Optional[RpcInfo[HarvesterRpcApi]] = None
+    if service_config.get("start_rpc_server", True):
+        rpc_info = (HarvesterRpcApi, service_config["rpc_port"])
+
+    return Service(
+        root_path=root_path,
+        config=config,
+        node=node,
+        peer_api=peer_api,
+        node_type=NodeType.HARVESTER,
+        advertised_port=None,
+        service_name=SERVICE_NAME,
+        connect_peers=farmer_peers,
+        network_id=network_id,
+        rpc_info=rpc_info,
+        connect_to_daemon=connect_to_daemon,
+        class_for_type=ApiProtocolRegistry,
+    )
+
+
+async def async_main(root_path: pathlib.Path) -> int:
+    # TODO: refactor to avoid the double load
+    config = load_config(root_path, "config.yaml")
+    service_config = load_config_cli(root_path, "config.yaml", SERVICE_NAME)
+    config[SERVICE_NAME] = service_config
+    initialize_service_logging(service_name=SERVICE_NAME, config=config, root_path=root_path)
+    farmer_peers = get_unresolved_peer_infos(service_config, NodeType.FARMER)
+
+    service = create_harvester_service(root_path, config, DEFAULT_CONSTANTS, farmer_peers)
+    async with SignalHandlers.manage() as signal_handlers:
+        await service.setup_process_global_state(signal_handlers=signal_handlers)
+        await service.run()
+
+    return 0
+
+
+def main() -> int:
+    root_path = resolve_root_path(override=None)
+
+    with maybe_manage_task_instrumentation(
+        enable=os.environ.get(f"CHIA_INSTRUMENT_{SERVICE_NAME.upper()}") is not None
+    ):
+        return async_run(coro=async_main(root_path=root_path))
+
+
+if __name__ == "__main__":
+    sys.exit(main())

chia/server/start_introducer.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import os
+import pathlib
+import sys
+from typing import Any, Optional
+
+from chia.apis import ApiProtocolRegistry
+from chia.introducer.introducer import Introducer
+from chia.introducer.introducer_api import IntroducerAPI
+from chia.server.outbound_message import NodeType
+from chia.server.signal_handlers import SignalHandlers
+from chia.server.start_service import Service, async_run
+from chia.types.aliases import IntroducerService
+from chia.util.chia_logging import initialize_service_logging
+from chia.util.config import load_config, load_config_cli
+from chia.util.default_root import resolve_root_path
+from chia.util.task_timing import maybe_manage_task_instrumentation
+
+# See: https://bugs.python.org/issue29288
+"".encode("idna")
+
+SERVICE_NAME = "introducer"
+
+
+def create_introducer_service(
+    root_path: pathlib.Path,
+    config: dict[str, Any],
+    advertised_port: Optional[int] = None,
+    connect_to_daemon: bool = True,
+) -> IntroducerService:
+    service_config = config[SERVICE_NAME]
+
+    network_id = service_config["selected_network"]
+
+    if advertised_port is None:
+        advertised_port = service_config["port"]
+
+    node = Introducer(service_config["max_peers_to_send"], service_config["recent_peer_threshold"])
+    peer_api = IntroducerAPI(node)
+
+    return Service(
+        root_path=root_path,
+        config=config,
+        node=node,
+        peer_api=peer_api,
+        node_type=NodeType.INTRODUCER,
+        advertised_port=advertised_port,
+        service_name=SERVICE_NAME,
+        network_id=network_id,
+        connect_to_daemon=connect_to_daemon,
+        class_for_type=ApiProtocolRegistry,
+    )
+
+
+async def async_main(root_path: pathlib.Path) -> int:
+    # TODO: refactor to avoid the double load
+    config = load_config(root_path, "config.yaml")
+    service_config = load_config_cli(root_path, "config.yaml", SERVICE_NAME)
+    config[SERVICE_NAME] = service_config
+    initialize_service_logging(service_name=SERVICE_NAME, config=config, root_path=root_path)
+
+    service = create_introducer_service(root_path, config)
+    async with SignalHandlers.manage() as signal_handlers:
+        await service.setup_process_global_state(signal_handlers=signal_handlers)
+        await service.run()
+
+    return 0
+
+
+def main() -> int:
+    root_path = resolve_root_path(override=None)
+
+    with maybe_manage_task_instrumentation(
+        enable=os.environ.get(f"CHIA_INSTRUMENT_{SERVICE_NAME.upper()}") is not None
+    ):
+        return async_run(coro=async_main(root_path=root_path))
+
+
+if __name__ == "__main__":
+    sys.exit(main())