Fix inotify watch exhaustion on large resolver lists

This release fixes a critical issue where processing large lists of DNS
resolvers (65k+) would exhaust system inotify watches, causing c-ares
initialization failures and resulting in incomplete validation results.

Changes:
- Implemented DNS resolver instance caching to reuse resolver objects
- Added thread-safe resolver cache with async lock protection
- Each unique server now uses a single resolver instance instead of
  creating a new one for every query
- Prevents "Failed to initialize c-ares channel" errors
- Significantly reduces system resource usage during large batch processing

Tested with 65k+ resolver lists - now processes all resolvers successfully
without resource exhaustion.

Version bumped to 2.3.1

Author: StasonJatham

CHANGELOG.md

@@ -5,6 +5,14 @@ All notable changes to PyResolvers will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.3.1] - 2025-01-11
+
+### Fixed
+- Fixed inotify watch exhaustion when processing large resolver lists (65k+)
+- Implemented DNS resolver instance caching to prevent resource exhaustion
+- Resolvers are now reused per unique server, reducing system resource usage
+- Eliminated "Failed to initialize c-ares channel" errors on large batches
+
 ## [1.1.0] - 2025-01-11
 
 ### Added

pyresolvers/lib/core/__version__.py

@@ -1,2 +1,2 @@
-__version__ = '2.3.0'
+__version__ = '2.3.1'
 

pyresolvers/validator.py

@@ -77,6 +77,9 @@ def __init__(
         self.verbose = verbose
         self._baseline_ip = ""
         self._baseline_data: Dict[str, Dict] = {}
+        # Resolver cache to prevent creating too many instances
+        self._resolver_cache: Dict[str, aiodns.DNSResolver] = {}
+        self._cache_lock: Optional[asyncio.Lock] = None
 
     @staticmethod
     def _random_subdomain(length: int = SUBDOMAIN_LENGTH) -> str:
@@ -96,11 +99,31 @@ def _log(self, msg: str) -> None:
         if self.verbose:
             print(msg)
 
+    async def _get_resolver(self, nameserver: str, timeout: Optional[int] = None) -> aiodns.DNSResolver:
+        """Get or create a cached DNS resolver for the given nameserver.
+
+        This prevents creating too many resolver instances which would exhaust
+        inotify watches on Linux systems.
+        """
+        # Initialize lock on first use
+        if self._cache_lock is None:
+            self._cache_lock = asyncio.Lock()
+
+        cache_key = f"{nameserver}:{timeout or self.timeout}"
+
+        async with self._cache_lock:
+            if cache_key not in self._resolver_cache:
+                self._resolver_cache[cache_key] = aiodns.DNSResolver(
+                    nameservers=[nameserver],
+                    timeout=timeout or self.timeout
+                )
+            return self._resolver_cache[cache_key]
+
     async def _setup_baseline_single(self, resolver_ip: str) -> bool:
         """Setup baseline from single trusted resolver."""
         self._log(f"[INFO] {resolver_ip} - Establishing baseline")
         try:
-            resolver = aiodns.DNSResolver(nameservers=[resolver_ip], timeout=self.timeout)
+            resolver = await self._get_resolver(resolver_ip)
             data = {}
 
             # Get baseline IP
@@ -192,7 +215,7 @@ def _matches_baseline(self, has_nxdomain: bool) -> bool:
     async def _measure_latency(self, server: str) -> float:
         """Measure simple DNS query latency."""
         try:
-            resolver = aiodns.DNSResolver(nameservers=[server], timeout=1)
+            resolver = await self._get_resolver(server, timeout=1)
             start = time.time()
             await resolver.query(self.baseline_domain, 'A')
             return (time.time() - start) * 1000
@@ -205,7 +228,8 @@ async def _validate_server(self, server: str) -> ValidationResult:
             return ValidationResult(server, False, -1, "Invalid IP")
 
         try:
-            resolver = aiodns.DNSResolver(nameservers=[server], timeout=FAST_TIMEOUT if self.use_fast_timeout else self.timeout)
+            timeout = FAST_TIMEOUT if self.use_fast_timeout else self.timeout
+            resolver = await self._get_resolver(server, timeout=timeout)
 
             # Run ALL checks in parallel for max speed
             poison_task = self._check_poisoning(resolver, server)