wormhole-proxy 3.4.0__tar.gz → 3.4.2__tar.gz

{wormhole_proxy-3.4.0 → wormhole_proxy-3.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: wormhole-proxy
-Version: 3.4.0
+Version: 3.4.2
 Summary: Asynchronous I/O HTTP and HTTPS Proxy on Python >= 3.11
 License: MIT
 Keywords: wormhole,asynchronous,web,proxy

{wormhole_proxy-3.4.0 → wormhole_proxy-3.4.2}/pyproject.toml

@@ -1,7 +1,7 @@
 # Main project metadata (PEP 621 standard)
 [project]
 name = "wormhole-proxy"
-version = "3.4.0"
+version = "3.4.2"
 description = "Asynchronous I/O HTTP and HTTPS Proxy on Python >= 3.11"
 readme = "README.md"
 authors = [
@@ -77,4 +77,4 @@ filterwarnings = [
 # Build system configuration
 [build-system]
 requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"
+build-backend = "poetry.core.masonry.api"

{wormhole_proxy-3.4.0 → wormhole_proxy-3.4.2}/wormhole/handler.py

@@ -9,8 +9,9 @@ import random
 import time
 
 # --- DNS Cache for Performance ---
-DNS_CACHE: dict[str, tuple[list[str], float]] = {}
-DNS_CACHE_TTL: int = 300  # Cache DNS results for 5 minutes
+DNS_CACHE: dict[str, tuple[list[str], float, float]] = (
+    {}
+)  # (ip_list, timestamp, ttl_expiration)
 
 
 # --- Modernized Relay Stream Function ---
@@ -96,8 +97,8 @@ async def _resolve_and_validate_host(
 
     # Check cache first
     if host in DNS_CACHE:
-        ip_list, timestamp = DNS_CACHE[host]
-        if time.time() - timestamp < DNS_CACHE_TTL:
+        ip_list, timestamp, ttl_expiration = DNS_CACHE[host]
+        if time.time() < ttl_expiration:
             logger.debug(
                 flm(
                     f"DNS cache hit for '{host}'. ({len(DNS_CACHE)} hosts cached)",
@@ -107,9 +108,9 @@ async def _resolve_and_validate_host(
             )
             return ip_list
 
-    # Resolve hostname using aiodns resolver
+    # Resolve hostname using aiodns resolver with TTL information
     try:
-        resolved_ips = await resolver.resolve(host)
+        resolved_ips, min_ttl = await resolver.resolve_with_ttl(host)
     except OSError as e:
         raise OSError(f"Failed to resolve host: {host}") from e
 
@@ -154,13 +155,14 @@ async def _resolve_and_validate_host(
             f"Blocked access to '{host}' as it resolved to only private/reserved IPs."
         )
 
-    # Update cache
-    DNS_CACHE[host] = (final_ip_list, time.time())
+    # Update cache with TTL-based expiration
+    ttl_expiration = time.time() + min_ttl
+    DNS_CACHE[host] = (final_ip_list, time.time(), ttl_expiration)
     logger.debug(
         flm(
             (
                 f"DNS cache miss for '{host}'. "
-                f"Resolved to {final_ip_list}. Caching. "
+                f"Resolved to {final_ip_list} with TTL {min_ttl}s. Caching until {ttl_expiration}. "
                 f"({len(DNS_CACHE)} hosts cached)"
             ),
             context.ident,

{wormhole_proxy-3.4.0 → wormhole_proxy-3.4.2}/wormhole/logger.py

@@ -82,8 +82,13 @@ class LogThrottler:
         if self.timer:
             self.timer.cancel()
 
-        loop = asyncio.get_running_loop()
-        self.timer = loop.call_later(self.delay, self._flush_summary)
+        try:
+            loop = asyncio.get_running_loop()
+            self.timer = loop.call_later(self.delay, self._flush_summary)
+        except RuntimeError:
+            # If there's no running event loop, log the message directly
+            # This can happen in synchronous test cases
+            self._flush_summary()
 
 
 # In loguru, the logger is imported and ready to be configured.

{wormhole_proxy-3.4.0 → wormhole_proxy-3.4.2}/wormhole/proxy.py

@@ -281,8 +281,13 @@ def main() -> int:
     # Determine if we are running the full async server or a utility.
     is_server_mode = not args.update_ad_block_db
 
-    # Setup the uvloop before any other operations that might use the event loop.
-    if uvloop:
+    # Use the new uvloop.run() approach for Python 3.12+
+    # For older versions or if uvloop is not available, we'll use the standard approach
+    if uvloop and hasattr(uvloop, "run"):
+        # For Python 3.12+, we'll use uvloop.run() directly when starting the server
+        pass  # We'll handle this in the asyncio.run() call
+    elif uvloop:
+        # For older versions, use the deprecated install() method
         uvloop.install()
 
     # Setup logging. Disable async features for synchronous utility commands.
@@ -297,9 +302,16 @@ def main() -> int:
         # For this standalone utility, configure a simple logger to show progress.
         logger.info(f"Updating ad-block database at: {args.update_ad_block_db}")
         try:
-            asyncio.run(
-                update_database(args.update_ad_block_db, args.allowlist)
-            )
+            if uvloop and hasattr(uvloop, "run"):
+                # Use the new uvloop.run() method for Python 3.12+
+                uvloop.run(
+                    update_database(args.update_ad_block_db, args.allowlist)
+                )
+            else:
+                # Use the standard asyncio.run() for older versions or if uvloop is not available
+                asyncio.run(
+                    update_database(args.update_ad_block_db, args.allowlist)
+                )
         except Exception as e:
             logger.error(f"\nAn error occurred during update: {e}")
             return 1
@@ -313,7 +325,12 @@ def main() -> int:
         parser.error(f"Authentication file not found: {args.auth}")
 
     try:
-        asyncio.run(main_async(args))
+        if uvloop and hasattr(uvloop, "run"):
+            # Use the new uvloop.run() method for Python 3.12+
+            uvloop.run(main_async(args))
+        else:
+            # Use the standard asyncio.run() for older versions or if uvloop is not available
+            asyncio.run(main_async(args))
     except KeyboardInterrupt:
         print("\nInterrupted by user. Exiting.")
     except Exception as e:

{wormhole_proxy-3.4.0 → wormhole_proxy-3.4.2}/wormhole/resolver.py

@@ -137,18 +137,18 @@ class Resolver:
                 )
             )
 
-    async def resolve(self, hostname: str) -> list[str]:
+    async def resolve_with_ttl(self, hostname: str) -> tuple[list[str], int]:
         """
-        Resolves a hostname to a list of IP addresses.
+        Resolves a hostname to a list of IP addresses and the minimum TTL.
 
         1. Checks the local hosts file cache first.
-        2. If not found, queries DNS for A and AAAA records using aiodns.
+        2. If not found, queries DNS for A and AAAA records using aiodns and extracts TTL.
 
         Args:
             hostname (str): The hostname to resolve.
 
         Returns:
-            list[str]: A list of IP addresses associated with the hostname.
+            tuple[list[str], int]: A list of IP addresses and the minimum TTL value.
 
         Raises:
             OSError: If no IP addresses could be resolved.
@@ -171,7 +171,8 @@ class Resolver:
                     self.verbose,
                 )
             )
-            return [ip]
+            # Hosts file entries don't have TTL, use a default high value
+            return [ip], 3600
 
         # 2. Query DNS using aiodns for IPv4 and IPv6 addresses concurrently
         results = await asyncio.gather(
@@ -181,6 +182,8 @@ class Resolver:
         )
 
         resolved_ips: set[str] = set()
+        min_ttl = float("inf")
+
         for res in results:
             if isinstance(res, list):
                 for record in res:
@@ -188,6 +191,9 @@ class Resolver:
                         resolved_ips.add(record.host.decode())
                     else:
                         resolved_ips.add(record.host)
+                    # Extract TTL from record
+                    if hasattr(record, "ttl") and record.ttl < min_ttl:
+                        min_ttl = record.ttl
             elif isinstance(res, aiodns.error.DNSError):
                 # Ignore common "not found" errors. Log other DNS errors for debugging.
                 if res.args[0] not in (
@@ -209,7 +215,30 @@ class Resolver:
         if not resolved_ips:
             raise OSError(f"Failed to resolve host: {hostname}")
 
-        return list(resolved_ips)
+        # If no TTL was found (shouldn't happen but just in case), use default
+        if min_ttl == float("inf"):
+            min_ttl = 300
+
+        return list(resolved_ips), int(min_ttl)
+
+    async def resolve(self, hostname: str) -> list[str]:
+        """
+        Resolves a hostname to a list of IP addresses.
+
+        1. Checks the local hosts file cache first.
+        2. If not found, queries DNS for A and AAAA records using aiodns.
+
+        Args:
+            hostname (str): The hostname to resolve.
+
+        Returns:
+            list[str]: A list of IP addresses associated with the hostname.
+
+        Raises:
+            OSError: If no IP addresses could be resolved.
+        """
+        ips, _ = await self.resolve_with_ttl(hostname)
+        return ips
 
 
 # Initialize the singleton instance so it's ready for other modules to import