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

chia/seeder/crawl_store.py

@@ -6,7 +6,6 @@ import random
 import time
 from dataclasses import dataclass, field, replace
 from datetime import datetime, timedelta
-from typing import Dict, List
 
 import aiosqlite
 
@@ -19,9 +18,9 @@ log = logging.getLogger(__name__)
 @dataclass
 class CrawlStore:
     crawl_db: aiosqlite.Connection
-    host_to_records: Dict[str, PeerRecord] = field(default_factory=dict)  # peer_id: PeerRecord
-    host_to_selected_time: Dict[str, float] = field(default_factory=dict)  # peer_id: timestamp (as a float)
-    host_to_reliability: Dict[str, PeerReliability] = field(default_factory=dict)  # peer_id: PeerReliability
+    host_to_records: dict[str, PeerRecord] = field(default_factory=dict)  # peer_id: PeerRecord
+    host_to_selected_time: dict[str, float] = field(default_factory=dict)  # peer_id: timestamp (as a float)
+    host_to_reliability: dict[str, PeerReliability] = field(default_factory=dict)  # peer_id: PeerReliability
     banned_peers: int = 0
     ignored_peers: int = 0
     reliable_peers: int = 0
@@ -184,17 +183,16 @@ class CrawlStore:
         else:
             await self.peer_failed_to_connect(record)
 
-    async def get_peers_to_crawl(self, min_batch_size: int, max_batch_size: int) -> List[PeerRecord]:
+    async def get_peers_to_crawl(self, min_batch_size: int, max_batch_size: int) -> list[PeerRecord]:
         now = int(time.time())
         records = []
         records_v6 = []
         counter = 0
         self.ignored_peers = 0
         self.banned_peers = 0
-        for peer_id in self.host_to_reliability:
+        for peer_id, reliability in self.host_to_reliability.items():
             add = False
             counter += 1
-            reliability = self.host_to_reliability[peer_id]
             if reliability.ignore_till < now and reliability.ban_till < now:
                 add = True
             else:
@@ -410,7 +408,7 @@ class CrawlStore:
         await self.crawl_db.commit()
         await self.crawl_db.execute("VACUUM")
 
-        to_delete: List[str] = []
+        to_delete: list[str] = []
 
         # Deletes the old records from the in memory Dicts
         for peer_id, peer_record in self.host_to_records.items():

chia/seeder/crawler.py

@@ -7,22 +7,10 @@ import logging
 import time
 import traceback
 from collections import defaultdict
+from collections.abc import AsyncIterator, Awaitable
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    AsyncIterator,
-    Awaitable,
-    Callable,
-    ClassVar,
-    Dict,
-    List,
-    Optional,
-    Set,
-    Tuple,
-    cast,
-)
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Optional, cast
 
 import aiosqlite
 
@@ -41,6 +29,7 @@ from chia.util.chia_version import chia_short_version
 from chia.util.ints import uint32, uint64
 from chia.util.network import resolve
 from chia.util.path import path_from_root
+from chia.util.task_referencer import create_referenced_task
 
 log = logging.getLogger(__name__)
 
@@ -52,7 +41,7 @@ class Crawler:
 
         _protocol_check: ClassVar[RpcServiceProtocol] = cast("Crawler", None)
 
-    config: Dict[str, Any]
+    config: dict[str, Any]
     root_path: Path
     constants: ConsensusConstants
     print_status: bool = True
@@ -63,15 +52,15 @@ class Crawler:
     log: logging.Logger = log
     _shut_down: bool = False
     peer_count: int = 0
-    with_peak: Set[PeerInfo] = field(default_factory=set)
-    seen_nodes: Set[str] = field(default_factory=set)
+    with_peak: set[PeerInfo] = field(default_factory=set)
+    seen_nodes: set[str] = field(default_factory=set)
     minimum_version_count: int = 0
-    peers_retrieved: List[RespondPeers] = field(default_factory=list)
-    host_to_version: Dict[str, str] = field(default_factory=dict)
-    versions: Dict[str, int] = field(default_factory=lambda: defaultdict(int))
-    version_cache: List[Tuple[str, str]] = field(default_factory=list)
-    handshake_time: Dict[str, uint64] = field(default_factory=dict)
-    best_timestamp_per_peer: Dict[str, uint64] = field(default_factory=dict)
+    peers_retrieved: list[RespondPeers] = field(default_factory=list)
+    host_to_version: dict[str, str] = field(default_factory=dict)
+    versions: dict[str, int] = field(default_factory=lambda: defaultdict(int))
+    version_cache: list[tuple[str, str]] = field(default_factory=list)
+    handshake_time: dict[str, uint64] = field(default_factory=dict)
+    best_timestamp_per_peer: dict[str, uint64] = field(default_factory=dict)
     start_crawler_loop: bool = True
 
     @property
@@ -94,7 +83,7 @@ class Crawler:
         if self.start_crawler_loop:
             # Bootstrap the initial peers
             await self.load_bootstrap_peers()
-            self.crawl_task = asyncio.create_task(self.crawl())
+            self.crawl_task = create_referenced_task(self.crawl())
         try:
             yield
         finally:
@@ -129,7 +118,7 @@ class Crawler:
     def _set_state_changed_callback(self, callback: StateChangedProtocol) -> None:
         self.state_changed_callback = callback
 
-    def get_connections(self, request_node_type: Optional[NodeType]) -> List[Dict[str, Any]]:
+    def get_connections(self, request_node_type: Optional[NodeType]) -> list[dict[str, Any]]:
         return default_get_connections(server=self.server, request_node_type=request_node_type)
 
     async def create_client(
@@ -231,7 +220,7 @@ class Crawler:
                         total_nodes += 1
                         if peer.ip_address not in tried_nodes:
                             tried_nodes.add(peer.ip_address)
-                        task = asyncio.create_task(self.connect_task(peer))
+                        task = create_referenced_task(self.connect_task(peer))
                         tasks.add(task)
                         if len(tasks) >= 250:
                             await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
@@ -300,18 +289,16 @@ class Crawler:
                     self.versions[version] += 1
 
                 # clear caches
-                self.version_cache: List[Tuple[str, str]] = []
+                self.version_cache: list[tuple[str, str]] = []
                 self.peers_retrieved = []
                 self.server.banned_peers = {}
                 self.with_peak = set()
 
-                if len(peers_to_crawl) == 0:
-                    continue
-
-                peer_cutoff = int(self.config.get("crawler", {}).get("prune_peer_days", 90))
-                await self.save_to_db()
-                await self.crawl_store.prune_old_peers(older_than_days=peer_cutoff)
-                await self.print_summary(t_start, total_nodes, tried_nodes)
+                if len(peers_to_crawl) > 0:
+                    peer_cutoff = int(self.config.get("crawler", {}).get("prune_peer_days", 90))
+                    await self.save_to_db()
+                    await self.crawl_store.prune_old_peers(older_than_days=peer_cutoff)
+                    await self.print_summary(t_start, total_nodes, tried_nodes)
                 await asyncio.sleep(15)  # 15 seconds between db updates
                 self._state_changed("crawl_batch_completed")
         except Exception as e:
@@ -335,7 +322,7 @@ class Crawler:
     def set_server(self, server: ChiaServer) -> None:
         self._server = server
 
-    def _state_changed(self, change: str, change_data: Optional[Dict[str, Any]] = None) -> None:
+    def _state_changed(self, change: str, change_data: Optional[dict[str, Any]] = None) -> None:
         if self.state_changed_callback is not None:
             self.state_changed_callback(change, change_data)
 
@@ -362,7 +349,7 @@ class Crawler:
     async def on_connect(self, connection: WSChiaConnection) -> None:
         pass
 
-    async def print_summary(self, t_start: float, total_nodes: int, tried_nodes: Set[str]) -> None:
+    async def print_summary(self, t_start: float, total_nodes: int, tried_nodes: set[str]) -> None:
         assert self.crawl_store is not None  # this is only ever called from the crawl task
         if not self.print_status:
             return

chia/seeder/crawler_api.py

@@ -1,19 +1,25 @@
 from __future__ import annotations
 
 import logging
-from typing import Optional
+from typing import TYPE_CHECKING, ClassVar, Optional, cast
 
 from chia.protocols import full_node_protocol, wallet_protocol
 from chia.seeder.crawler import Crawler
+from chia.server.api_protocol import ApiMetadata
 from chia.server.outbound_message import Message
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
-from chia.util.api_decorators import api_request
 
 
 class CrawlerAPI:
+    if TYPE_CHECKING:
+        from chia.server.api_protocol import ApiProtocol
+
+        _protocol_check: ClassVar[ApiProtocol] = cast("CrawlerAPI", None)
+
     log: logging.Logger
     crawler: Crawler
+    metadata: ClassVar[ApiMetadata] = ApiMetadata()
 
     def __init__(self, crawler: Crawler) -> None:
         self.log = logging.getLogger(__name__)
@@ -27,80 +33,80 @@ class CrawlerAPI:
     def ready(self) -> bool:
         return True
 
-    @api_request(peer_required=True)
+    @metadata.request(peer_required=True)
     async def request_peers(
         self, _request: full_node_protocol.RequestPeers, peer: WSChiaConnection
     ) -> Optional[Message]:
         pass
 
-    @api_request(peer_required=True)
+    @metadata.request(peer_required=True)
     async def respond_peers(
         self, request: full_node_protocol.RespondPeers, peer: WSChiaConnection
     ) -> Optional[Message]:
         pass
 
-    @api_request(peer_required=True)
+    @metadata.request(peer_required=True)
     async def new_peak(self, request: full_node_protocol.NewPeak, peer: WSChiaConnection) -> Optional[Message]:
         await self.crawler.new_peak(request, peer)
         return None
 
-    @api_request()
+    @metadata.request()
     async def new_transaction(self, transaction: full_node_protocol.NewTransaction) -> Optional[Message]:
         pass
 
-    @api_request(peer_required=True)
+    @metadata.request(peer_required=True)
     async def new_signage_point_or_end_of_sub_slot(
         self, new_sp: full_node_protocol.NewSignagePointOrEndOfSubSlot, peer: WSChiaConnection
     ) -> Optional[Message]:
         pass
 
-    @api_request()
+    @metadata.request()
     async def new_unfinished_block(
         self, new_unfinished_block: full_node_protocol.NewUnfinishedBlock
     ) -> Optional[Message]:
         pass
 
-    @api_request()
+    @metadata.request()
     async def new_unfinished_block2(
         self, new_unfinished_block: full_node_protocol.NewUnfinishedBlock2
     ) -> Optional[Message]:
         pass
 
-    @api_request(peer_required=True)
+    @metadata.request(peer_required=True)
     async def new_compact_vdf(
         self, request: full_node_protocol.NewCompactVDF, peer: WSChiaConnection
     ) -> Optional[Message]:
         pass
 
-    @api_request()
+    @metadata.request()
     async def request_transaction(self, request: full_node_protocol.RequestTransaction) -> Optional[Message]:
         pass
 
-    @api_request()
+    @metadata.request()
     async def request_proof_of_weight(self, request: full_node_protocol.RequestProofOfWeight) -> Optional[Message]:
         pass
 
-    @api_request()
+    @metadata.request()
     async def request_block(self, request: full_node_protocol.RequestBlock) -> Optional[Message]:
         pass
 
-    @api_request()
+    @metadata.request()
     async def request_blocks(self, request: full_node_protocol.RequestBlocks) -> Optional[Message]:
         pass
 
-    @api_request()
+    @metadata.request()
     async def request_unfinished_block(
         self, request_unfinished_block: full_node_protocol.RequestUnfinishedBlock
     ) -> Optional[Message]:
         pass
 
-    @api_request()
+    @metadata.request()
     async def request_signage_point_or_end_of_sub_slot(
         self, request: full_node_protocol.RequestSignagePointOrEndOfSubSlot
     ) -> Optional[Message]:
         pass
 
-    @api_request(peer_required=True)
+    @metadata.request(peer_required=True)
     async def request_mempool_transactions(
         self,
         request: full_node_protocol.RequestMempoolTransactions,
@@ -108,22 +114,22 @@ class CrawlerAPI:
     ) -> Optional[Message]:
         pass
 
-    @api_request()
+    @metadata.request()
     async def request_block_header(self, request: wallet_protocol.RequestBlockHeader) -> Optional[Message]:
         pass
 
-    @api_request()
+    @metadata.request()
     async def request_additions(self, request: wallet_protocol.RequestAdditions) -> Optional[Message]:
         pass
 
-    @api_request()
+    @metadata.request()
     async def request_removals(self, request: wallet_protocol.RequestRemovals) -> Optional[Message]:
         pass
 
-    @api_request()
+    @metadata.request()
     async def request_puzzle_solution(self, request: wallet_protocol.RequestPuzzleSolution) -> Optional[Message]:
         pass
 
-    @api_request()
+    @metadata.request()
     async def request_header_blocks(self, request: wallet_protocol.RequestHeaderBlocks) -> Optional[Message]:
         pass

chia/seeder/dns_server.py

@@ -5,23 +5,26 @@ import logging
 import signal
 import sys
 import traceback
+from collections.abc import AsyncIterator, Awaitable
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from ipaddress import IPv4Address, IPv6Address, ip_address
 from multiprocessing import freeze_support
 from pathlib import Path
 from types import FrameType
-from typing import Any, AsyncIterator, Awaitable, Callable, Dict, List, Optional
+from typing import Any, Callable, Optional
 
 import aiosqlite
+import dns.asyncresolver
 from dnslib import AAAA, EDNS0, NS, QTYPE, RCODE, RD, RR, SOA, A, DNSError, DNSHeader, DNSQuestion, DNSRecord
 
 from chia.seeder.crawl_store import CrawlStore
 from chia.server.signal_handlers import SignalHandlers
 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 DEFAULT_ROOT_PATH
+from chia.util.default_root import resolve_root_path
 from chia.util.path import path_from_root
+from chia.util.task_referencer import create_referenced_task
 
 SERVICE_NAME = "seeder"
 log = logging.getLogger(__name__)
@@ -38,8 +41,8 @@ class DomainName(str):
 
 @dataclass(frozen=True)
 class PeerList:
-    ipv4: List[IPv4Address]
-    ipv6: List[IPv6Address]
+    ipv4: list[IPv4Address]
+    ipv6: list[IPv6Address]
 
     @property
     def no_peers(self) -> bool:
@@ -58,7 +61,7 @@ class UDPDNSServerProtocol(asyncio.DatagramProtocol):
     queue_task: Optional[asyncio.Task[None]] = field(init=False, default=None)
 
     def start(self) -> None:
-        self.queue_task = asyncio.create_task(self.respond())  # This starts the dns respond loop.
+        self.queue_task = create_referenced_task(self.respond())  # This starts the dns respond loop.
 
     async def stop(self) -> None:
         if self.queue_task is not None:
@@ -79,11 +82,12 @@ class UDPDNSServerProtocol(asyncio.DatagramProtocol):
         dns_request: Optional[DNSRecord] = parse_dns_request(data)
         if dns_request is None:  # Invalid Request, we can just drop it and move on.
             return
-        asyncio.create_task(self.handler(dns_request, addr))
+        create_referenced_task(self.handler(dns_request, addr), known_unreferenced=True)
 
     async def respond(self) -> None:
         log.info("UDP DNS responder started.")
-        while self.transport is None:  # we wait for the transport to be set.
+        # TODO: switch to event driven code
+        while self.transport is None:  # we wait for the transport to be set.  # noqa: ASYNC110
             await asyncio.sleep(0.1)
         while not self.transport.is_closing():
             try:
@@ -121,7 +125,7 @@ class TCPDNSServerProtocol(asyncio.BufferedProtocol):
     peer_info: str = field(init=False, default="")
     expected_length: int = 0
     buffer: bytearray = field(init=False, default_factory=lambda: bytearray(2))
-    futures: List[asyncio.Future[None]] = field(init=False, default_factory=list)
+    futures: list[asyncio.Future[None]] = field(init=False, default_factory=list)
 
     def connection_made(self, transport: asyncio.BaseTransport) -> None:
         """
@@ -176,7 +180,7 @@ class TCPDNSServerProtocol(asyncio.BufferedProtocol):
                 if dns_request is None:  # Invalid Request, so we disconnect and don't send anything back.
                     self.transport.close()
                     return
-                self.futures.append(asyncio.create_task(self.handle_and_respond(dns_request)))
+                self.futures.append(create_referenced_task(self.handle_and_respond(dns_request)))
 
         self.buffer = bytearray(2 if self.expected_length == 0 else self.expected_length)  # Reset the buffer if empty.
 
@@ -191,7 +195,7 @@ class TCPDNSServerProtocol(asyncio.BufferedProtocol):
                     f"Received incomplete TCP DNS request of length {self.expected_length} from {self.peer_info}, "
                     f"closing connection after dns replies are sent."
                 )
-            asyncio.create_task(self.wait_for_futures())
+            create_referenced_task(self.wait_for_futures(), known_unreferenced=True)
             return True  # Keep connection open, until the futures are done.
         log.info(f"Received early EOF from {self.peer_info}, closing connection.")
         return False
@@ -263,7 +267,7 @@ async def get_dns_reply(callback: DnsCallback, dns_request: DNSRecord) -> DNSRec
 
 @dataclass
 class DNSServer:
-    config: Dict[str, Any]
+    config: dict[str, Any]
     root_path: Path
     lock: asyncio.Lock = field(default_factory=asyncio.Lock)
     shutdown_event: asyncio.Event = field(default_factory=asyncio.Event)
@@ -282,11 +286,14 @@ class DNSServer:
     db_path: Path = field(init=False)
     domain: DomainName = field(init=False)
     ns1: DomainName = field(init=False)
-    ns_records: List[RR] = field(init=False)
+    ns_records: list[RR] = field(init=False)
     ttl: int = field(init=False)
     soa_record: RR = field(init=False)
-    reliable_peers_v4: List[IPv4Address] = field(default_factory=list)
-    reliable_peers_v6: List[IPv6Address] = field(default_factory=list)
+    reliable_peers_v4: list[IPv4Address] = field(default_factory=list)
+    reliable_peers_v6: list[IPv6Address] = field(default_factory=list)
+    static_peers_v4: list[IPv4Address] = field(default_factory=list)
+    static_peers_v6: list[IPv6Address] = field(default_factory=list)
+    resolver: Optional[dns.asyncresolver.Resolver] = field(init=False)
     pointer_v4: int = 0
     pointer_v6: int = 0
 
@@ -307,7 +314,7 @@ class DNSServer:
         if not self.domain.endswith("."):
             self.domain = DomainName(self.domain + ".")  # Make sure the domain ends with a period, as per RFC 1035.
         self.ns1: DomainName = DomainName(self.config["nameserver"])
-        self.ns_records: List[NS] = [NS(self.ns1)]
+        self.ns_records: list[NS] = [NS(self.ns1)]
         self.ttl: int = self.config["ttl"]
         self.soa_record: SOA = SOA(
             mname=self.ns1,  # primary name server
@@ -320,6 +327,11 @@ class DNSServer:
                 self.config["soa"]["minimum"],
             ),
         )
+        try:
+            self.resolver: Optional[dns.asyncresolver.Resolver] = dns.asyncresolver.Resolver()
+        except Exception:
+            self.resolver = None
+            log.exception("Error initializing asyncresolver for dns_server")
 
     @asynccontextmanager
     async def run(self) -> AsyncIterator[None]:
@@ -329,7 +341,7 @@ class DNSServer:
 
         # Set up the crawl store and the peer update task.
         self.crawl_store = await CrawlStore.create(await aiosqlite.connect(self.db_path, timeout=120))
-        self.reliable_task = asyncio.create_task(self.periodically_get_reliable_peers())
+        self.reliable_task = create_referenced_task(self.periodically_get_reliable_peers())
 
         # One protocol instance will be created for each udp transport, so that we can accept ipv4 and ipv6
         self.udp_transport_ipv6, self.udp_protocol_ipv6 = await loop.create_datagram_endpoint(
@@ -392,42 +404,78 @@ class DNSServer:
     async def periodically_get_reliable_peers(self) -> None:
         sleep_interval = 0
         while not self.shutdown_event.is_set() and self.crawl_store is not None:
+            await self.refresh_reliable_peers()
+            sleep_interval = min(15, sleep_interval + 1)
+            await asyncio.sleep(sleep_interval * 60)
+
+    async def refresh_reliable_peers(self) -> None:
+        if self.crawl_store is None:
+            return
+        new_reliable_peers: list[str] = []
+        while not self.shutdown_event.is_set():
             try:
                 new_reliable_peers = await self.crawl_store.get_good_peers()
             except Exception as e:
                 log.error(f"Error loading reliable peers from database: {e}. Traceback: {traceback.format_exc()}.")
+                await asyncio.sleep(2)
                 continue
-            if len(new_reliable_peers) == 0:
-                log.warning("No reliable peers found in database, waiting for db to be populated.")
-                await asyncio.sleep(2)  # sleep for 2 seconds, because the db has not been populated yet.
-                continue
-            async with self.lock:
-                self.reliable_peers_v4 = []
-                self.reliable_peers_v6 = []
-                self.pointer_v4 = 0
-                self.pointer_v6 = 0
-                for peer in new_reliable_peers:
+
+            static_peers = self.config.get("static_peers", [])
+            if len(static_peers) > 0:
+                log.warning("have static peers, resolving ip addresses")
+                for static_peer in static_peers:
                     try:
-                        validated_peer = ip_address(peer)
-                        if validated_peer.version == 4:
-                            self.reliable_peers_v4.append(validated_peer)
-                        elif validated_peer.version == 6:
-                            self.reliable_peers_v6.append(validated_peer)
+                        log.warning(f"Handling static peer {static_peer}")
+                        # Attempt to parse as an IP address
+                        # If this doesn't throw, we can just add to the list
+                        # Otherwise, we have to resolve the hostname
+                        ip_address(static_peer)
+                        new_reliable_peers.append(static_peer)
                     except ValueError:
-                        log.error(f"Invalid peer: {peer}")
-                        continue
-                log.warning(
-                    f"Number of reliable peers discovered in dns server:"
-                    f" IPv4 count - {len(self.reliable_peers_v4)}"
-                    f" IPv6 count - {len(self.reliable_peers_v6)}"
-                )
-            sleep_interval = min(15, sleep_interval + 1)
-            await asyncio.sleep(sleep_interval * 60)
+                        # Wasn't an IP address, so resolve the hostname
+                        log.warning(f"Not an IP address, trying to resolve {static_peer} to an IP address")
+                        if self.resolver is not None:
+                            for rdtype in ["A", "AAAA"]:
+                                result = await self.resolver.resolve(qname=static_peer, rdtype=rdtype, lifetime=30)
+                                for ip in result:
+                                    try:
+                                        ip_as_string = ip.to_text()
+                                        ip_address(ip_as_string)
+                                        new_reliable_peers.append(ip_as_string)
+                                    except ValueError:
+                                        pass
+
+            if len(new_reliable_peers) > 0:
+                break
+
+            log.warning("No reliable peers found in database, waiting for db to be populated.")
+            await asyncio.sleep(2)  # sleep for 2 seconds, because the db has not been populated yet.
+
+        async with self.lock:
+            self.reliable_peers_v4 = []
+            self.reliable_peers_v6 = []
+            self.pointer_v4 = 0
+            self.pointer_v6 = 0
+            for peer in new_reliable_peers:
+                try:
+                    validated_peer = ip_address(peer)
+                    if validated_peer.version == 4:
+                        self.reliable_peers_v4.append(validated_peer)
+                    elif validated_peer.version == 6:
+                        self.reliable_peers_v6.append(validated_peer)
+                except ValueError:
+                    log.error(f"Invalid peer: {peer}")
+                    continue
+            log.warning(
+                f"Number of reliable peers discovered in dns server:"
+                f" IPv4 count - {len(self.reliable_peers_v4)}"
+                f" IPv6 count - {len(self.reliable_peers_v6)}"
+            )
 
     async def get_peers_to_respond(self, ipv4_count: int, ipv6_count: int) -> PeerList:
         async with self.lock:
             # Append IPv4.
-            ipv4_peers: List[IPv4Address] = []
+            ipv4_peers: list[IPv4Address] = []
             size = len(self.reliable_peers_v4)
             if ipv4_count > 0 and size <= ipv4_count:
                 ipv4_peers = self.reliable_peers_v4
@@ -437,7 +485,7 @@ class DNSServer:
                 ]
                 self.pointer_v4 = (self.pointer_v4 + ipv4_count) % size  # mark where we left off
             # Append IPv6.
-            ipv6_peers: List[IPv6Address] = []
+            ipv6_peers: list[IPv6Address] = []
             size = len(self.reliable_peers_v6)
             if ipv6_count > 0 and size <= ipv6_count:
                 ipv6_peers = self.reliable_peers_v6
@@ -473,7 +521,7 @@ class DNSServer:
 
         ttl: int = self.ttl
         # we add these to the list as it will allow us to respond to ns and soa requests
-        ips: List[RD] = [self.soa_record] + self.ns_records
+        ips: list[RD] = [self.soa_record, *self.ns_records]
         ipv4_count = 0
         ipv6_count = 0
         if question_type is QTYPE.A:
@@ -493,7 +541,7 @@ class DNSServer:
         ips.extend([A(str(peer)) for peer in peers.ipv4])
         ips.extend([AAAA(str(peer)) for peer in peers.ipv6])
 
-        records: Dict[DomainName, List[RD]] = {  # this is where we can add other records we want to serve
+        records: dict[DomainName, list[RD]] = {  # this is where we can add other records we want to serve
             self.domain: ips,
         }
 
@@ -503,7 +551,7 @@ class DNSServer:
                 valid_domain = True
                 for response in domain_responses:
                     rqt: int = getattr(QTYPE, response.__class__.__name__)
-                    if question_type == rqt or question_type == QTYPE.ANY:
+                    if question_type in {rqt, QTYPE.ANY}:
                         reply.add_answer(RR(rname=qname, rtype=rqt, rclass=1, ttl=ttl, rdata=response))
         if not valid_domain and len(reply.rr) == 0:  # if we didn't find any records to return
             reply.header.rcode = RCODE.NXDOMAIN
@@ -521,7 +569,7 @@ async def run_dns_server(dns_server: DNSServer) -> None:  # pragma: no cover
             await dns_server.shutdown_event.wait()  # this is released on SIGINT or SIGTERM or any unhandled exception
 
 
-def create_dns_server_service(config: Dict[str, Any], root_path: Path) -> DNSServer:
+def create_dns_server_service(config: dict[str, Any], root_path: Path) -> DNSServer:
     service_config = config[SERVICE_NAME]
 
     return DNSServer(service_config, root_path)
@@ -529,12 +577,13 @@ def create_dns_server_service(config: Dict[str, Any], root_path: Path) -> DNSSer
 
 def main() -> None:  # pragma: no cover
     freeze_support()
-    root_path = DEFAULT_ROOT_PATH
+    root_path = resolve_root_path(override=None)
+
     # 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)
+    initialize_service_logging(service_name=SERVICE_NAME, config=config, root_path=root_path)
 
     dns_server = create_dns_server_service(config, root_path)
     asyncio.run(run_dns_server(dns_server))