chia-blockchain 2.5.0rc1__py3-none-any.whl → 2.5.1__py3-none-any.whl

chia/server/start_service.py

@@ -6,26 +6,13 @@ import logging
 import logging.config
 import os
 import signal
+from collections.abc import AsyncIterator, Awaitable, Coroutine
 from pathlib import Path
 from types import FrameType
-from typing import (
-    Any,
-    AsyncIterator,
-    Awaitable,
-    Callable,
-    Coroutine,
-    Dict,
-    Generic,
-    List,
-    Optional,
-    Set,
-    Tuple,
-    Type,
-    TypeVar,
-    cast,
-)
+from typing import Any, Callable, Generic, Optional, TypeVar, cast
 
 from chia.daemon.server import service_launch_lock_path
+from chia.protocols.shared_protocol import default_capabilities
 from chia.rpc.rpc_server import RpcApiProtocol, RpcServer, RpcServiceProtocol, start_rpc_server
 from chia.server.api_protocol import ApiProtocol
 from chia.server.chia_policy import set_chia_policy
@@ -36,14 +23,13 @@ from chia.server.ssl_context import chia_ssl_ca_paths, private_ssl_ca_paths
 from chia.server.upnp import UPnP
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.peer_info import PeerInfo, UnresolvedPeerInfo
+from chia.util.chia_version import chia_short_version
 from chia.util.ints import uint16
 from chia.util.lock import Lockfile, LockfileError
 from chia.util.log_exceptions import log_exceptions
 from chia.util.network import resolve
 from chia.util.setproctitle import setproctitle
-
-from ..protocols.shared_protocol import default_capabilities
-from ..util.chia_version import chia_short_version
+from chia.util.task_referencer import create_referenced_task
 
 # this is used to detect whether we are running in the main process or not, in
 # signal handlers. We need to ignore signals in the sub processes.
@@ -54,7 +40,7 @@ _T_RpcServiceProtocol = TypeVar("_T_RpcServiceProtocol", bound=RpcServiceProtoco
 _T_ApiProtocol = TypeVar("_T_ApiProtocol", bound=ApiProtocol)
 _T_RpcApiProtocol = TypeVar("_T_RpcApiProtocol", bound=RpcApiProtocol)
 
-RpcInfo = Tuple[Type[_T_RpcApiProtocol], int]
+RpcInfo = tuple[type[_T_RpcApiProtocol], int]
 
 log = logging.getLogger(__name__)
 
@@ -74,14 +60,15 @@ class Service(Generic[_T_RpcServiceProtocol, _T_ApiProtocol, _T_RpcApiProtocol])
         service_name: str,
         network_id: str,
         *,
-        config: Dict[str, Any],
-        upnp_ports: Optional[List[int]] = None,
-        connect_peers: Optional[Set[UnresolvedPeerInfo]] = None,
+        config: dict[str, Any],
+        class_for_type: dict[NodeType, type[ApiProtocol]],
+        upnp_ports: Optional[list[int]] = None,
+        connect_peers: Optional[set[UnresolvedPeerInfo]] = None,
         on_connect_callback: Optional[Callable[[WSChiaConnection], Awaitable[None]]] = None,
         rpc_info: Optional[RpcInfo[_T_RpcApiProtocol]] = None,
         connect_to_daemon: bool = True,
         max_request_body_size: Optional[int] = None,
-        override_capabilities: Optional[List[Tuple[uint16, str]]] = None,
+        override_capabilities: Optional[list[tuple[uint16, str]]] = None,
     ) -> None:
         if upnp_ports is None:
             upnp_ports = []
@@ -117,7 +104,7 @@ class Service(Generic[_T_RpcServiceProtocol, _T_ApiProtocol, _T_RpcApiProtocol])
         if node_type == NodeType.WALLET:
             inbound_rlp = self.service_config.get("inbound_rate_limit_percent", inbound_rlp)
             outbound_rlp = 60
-        capabilities_to_use: List[Tuple[uint16, str]] = default_capabilities[node_type]
+        capabilities_to_use: list[tuple[uint16, str]] = default_capabilities[node_type]
         if override_capabilities is not None:
             capabilities_to_use = override_capabilities
 
@@ -136,6 +123,7 @@ class Service(Generic[_T_RpcServiceProtocol, _T_ApiProtocol, _T_RpcApiProtocol])
             self.service_config,
             (private_ca_crt, private_ca_key),
             (chia_ca_crt, chia_ca_key),
+            class_for_type=class_for_type,
             name=f"{service_name}_server",
         )
         f = getattr(node, "set_server", None)
@@ -158,7 +146,7 @@ class Service(Generic[_T_RpcServiceProtocol, _T_ApiProtocol, _T_RpcApiProtocol])
         self.stop_requested = asyncio.Event()
 
     async def _connect_peers_task_handler(self) -> None:
-        resolved_peers: Dict[UnresolvedPeerInfo, PeerInfo] = {}
+        resolved_peers: dict[UnresolvedPeerInfo, PeerInfo] = {}
         prefer_ipv6 = self.config.get("prefer_ipv6", False)
         while True:
             for unresolved in self._connect_peers:
@@ -231,7 +219,7 @@ class Service(Generic[_T_RpcServiceProtocol, _T_ApiProtocol, _T_RpcApiProtocol])
                     except ValueError:
                         pass
 
-                    self._connect_peers_task = asyncio.create_task(self._connect_peers_task_handler())
+                    self._connect_peers_task = create_referenced_task(self._connect_peers_task_handler())
 
                     self._log.info(
                         f"Started {self._service_name} service on network_id: {self._network_id} "
@@ -248,7 +236,8 @@ class Service(Generic[_T_RpcServiceProtocol, _T_ApiProtocol, _T_RpcApiProtocol])
                             self.stop_requested.set,
                             self.root_path,
                             self.config,
-                            self._connect_to_daemon,
+                            service_config=self.service_config,
+                            connect_to_daemon=self._connect_to_daemon,
                             max_request_body_size=self.max_request_body_size,
                         )
                 yield
@@ -304,7 +293,6 @@ class Service(Generic[_T_RpcServiceProtocol, _T_ApiProtocol, _T_RpcApiProtocol])
         # we only handle signals in the main process. In the ProcessPoolExecutor
         # processes, we have to ignore them. We'll shut them down gracefully
         # from the main process
-        global main_pid
         ignore = os.getpid() != main_pid
 
         # TODO: if we remove this conditional behavior, consider moving logging to common signal handling

chia/server/start_timelord.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
-import logging
+import os
 import pathlib
 import sys
-from typing import Any, Dict, Optional
+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.rpc.timelord_rpc_api import TimelordRpcApi
@@ -16,7 +17,8 @@ from chia.timelord.timelord_api import TimelordAPI
 from chia.types.aliases import TimelordService
 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 DEFAULT_ROOT_PATH
+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")
@@ -24,22 +26,20 @@ from chia.util.default_root import DEFAULT_ROOT_PATH
 SERVICE_NAME = "timelord"
 
 
-log = logging.getLogger(__name__)
-
-
 def create_timelord_service(
     root_path: pathlib.Path,
-    config: Dict[str, Any],
-    constants: ConsensusConstants,
+    config: dict[str, Any],
+    consensus_constants: ConsensusConstants,
     connect_to_daemon: bool = True,
 ) -> TimelordService:
     service_config = config[SERVICE_NAME]
-    overrides = service_config["network_overrides"]["constants"][service_config["selected_network"]]
-    updated_constants = replace_str_to_bytes(constants, **overrides)
+
+    network_id = service_config["selected_network"]
+    overrides = service_config["network_overrides"]["constants"][network_id]
+    updated_constants = replace_str_to_bytes(consensus_constants, **overrides)
 
     node = Timelord(root_path, service_config, updated_constants)
     peer_api = TimelordAPI(node)
-    network_id = service_config["selected_network"]
 
     rpc_info: Optional[RpcInfo[TimelordRpcApi]] = None
     if service_config.get("start_rpc_server", True):
@@ -48,8 +48,8 @@ def create_timelord_service(
     return Service(
         root_path=root_path,
         config=config,
-        peer_api=peer_api,
         node=node,
+        peer_api=peer_api,
         node_type=NodeType.TIMELORD,
         advertised_port=None,
         service_name=SERVICE_NAME,
@@ -57,16 +57,18 @@ def create_timelord_service(
         network_id=network_id,
         rpc_info=rpc_info,
         connect_to_daemon=connect_to_daemon,
+        class_for_type=ApiProtocolRegistry,
     )
 
 
-async def async_main() -> int:
+async def async_main(root_path: pathlib.Path) -> int:
     # TODO: refactor to avoid the double load
-    config = load_config(DEFAULT_ROOT_PATH, "config.yaml")
-    service_config = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml", SERVICE_NAME)
+    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)
-    service = create_timelord_service(DEFAULT_ROOT_PATH, config, DEFAULT_CONSTANTS)
+    initialize_service_logging(service_name=SERVICE_NAME, config=config, root_path=root_path)
+
+    service = create_timelord_service(root_path, config, DEFAULT_CONSTANTS)
     async with SignalHandlers.manage() as signal_handlers:
         await service.setup_process_global_state(signal_handlers=signal_handlers)
         await service.run()
@@ -75,7 +77,12 @@ async def async_main() -> int:
 
 
 def main() -> int:
-    return async_run(async_main())
+    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__":

chia/server/start_wallet.py

@@ -4,8 +4,9 @@ import os
 import pathlib
 import sys
 from multiprocessing import freeze_support
-from typing import Any, Dict, Optional
+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.rpc.wallet_rpc_api import WalletRpcApi
@@ -15,7 +16,7 @@ from chia.server.start_service import RpcInfo, Service, async_run
 from chia.types.aliases import WalletService
 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 DEFAULT_ROOT_PATH
+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
 from chia.wallet.wallet_node import WalletNode
@@ -30,17 +31,17 @@ SERVICE_NAME = "wallet"
 
 def create_wallet_service(
     root_path: pathlib.Path,
-    config: Dict[str, Any],
+    config: dict[str, Any],
     consensus_constants: ConsensusConstants,
     keychain: Optional[Keychain] = None,
     connect_to_daemon: bool = True,
 ) -> WalletService:
     service_config = config[SERVICE_NAME]
 
-    overrides = service_config["network_overrides"]["constants"][service_config["selected_network"]]
+    network_id = service_config["selected_network"]
+    overrides = service_config["network_overrides"]["constants"][network_id]
     updated_constants = replace_str_to_bytes(consensus_constants, **overrides)
-    if "short_sync_blocks_behind_threshold" not in service_config:
-        service_config["short_sync_blocks_behind_threshold"] = 20
+    service_config.setdefault("short_sync_blocks_behind_threshold", 20)
 
     node = WalletNode(
         service_config,
@@ -50,10 +51,8 @@ def create_wallet_service(
     )
     peer_api = WalletNodeAPI(node)
 
-    network_id = service_config["selected_network"]
-    rpc_port = service_config.get("rpc_port")
     rpc_info: Optional[RpcInfo[WalletRpcApi]] = None
-    if rpc_port is not None:
+    if service_config.get("start_rpc_server", True):
         rpc_info = (WalletRpcApi, service_config["rpc_port"])
 
     return Service(
@@ -62,20 +61,21 @@ def create_wallet_service(
         node=node,
         peer_api=peer_api,
         node_type=NodeType.WALLET,
+        advertised_port=None,
         service_name=SERVICE_NAME,
-        on_connect_callback=node.on_connect,
         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,
-        advertised_port=None,
         connect_to_daemon=connect_to_daemon,
+        class_for_type=ApiProtocolRegistry,
     )
 
 
-async def async_main() -> int:
+async def async_main(root_path: pathlib.Path) -> int:
     # TODO: refactor to avoid the double load
-    config = load_config(DEFAULT_ROOT_PATH, "config.yaml")
-    service_config = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml", SERVICE_NAME)
+    config = load_config(root_path, "config.yaml")
+    service_config = load_config_cli(root_path, "config.yaml", SERVICE_NAME)
     config[SERVICE_NAME] = service_config
 
     # This is simulator
@@ -89,8 +89,9 @@ async def async_main() -> int:
         service_config["selected_network"] = "testnet0"
     else:
         constants = DEFAULT_CONSTANTS
-    initialize_service_logging(service_name=SERVICE_NAME, config=config)
-    service = create_wallet_service(DEFAULT_ROOT_PATH, config, constants)
+    initialize_service_logging(service_name=SERVICE_NAME, config=config, root_path=root_path)
+
+    service = create_wallet_service(root_path, config, constants)
     async with SignalHandlers.manage() as signal_handlers:
         await service.setup_process_global_state(signal_handlers=signal_handlers)
         await service.run()
@@ -100,9 +101,12 @@ async def async_main() -> int:
 
 def main() -> int:
     freeze_support()
+    root_path = resolve_root_path(override=None)
 
-    with maybe_manage_task_instrumentation(enable=os.environ.get("CHIA_INSTRUMENT_WALLET") is not None):
-        return async_run(async_main())
+    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__":

chia/server/upnp.py

@@ -3,9 +3,10 @@ from __future__ import annotations
 import contextlib
 import logging
 import threading
+from collections.abc import Iterator
 from dataclasses import dataclass, field
 from queue import Queue
-from typing import Iterator, List, Optional, Tuple, Union
+from typing import Optional, Union
 
 from typing_extensions import Literal
 
@@ -24,13 +25,13 @@ except ImportError:
 @dataclass
 class UPnP:
     _thread: Optional[threading.Thread] = None
-    _queue: Queue[Union[Tuple[Literal["remap", "release"], int], Tuple[Literal["shutdown"]]]] = field(
+    _queue: Queue[Union[tuple[Literal["remap", "release"], int], tuple[Literal["shutdown"]]]] = field(
         default_factory=Queue,
     )
     _upnp: Optional[miniupnpc.UPnP] = None
 
     @contextlib.contextmanager
-    def manage(self, ports: List[int]) -> Iterator[None]:
+    def manage(self, ports: list[int]) -> Iterator[None]:
         self.setup()
         try:
             for port in ports: