dargslan-dns-resolver 1.0.0__tar.gz

dargslan_dns_resolver-1.0.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: dargslan-dns-resolver
+Version: 1.0.0
+Summary: DNS resolver tester — measure resolution time, test DNSSEC, compare resolvers, and detect DNS issues
+Author-email: Dargslan <info@dargslan.com>
+License: MIT
+Project-URL: Homepage, https://dargslan.com
+Project-URL: Documentation, https://dargslan.com/blog
+Project-URL: Repository, https://github.com/Dargslan
+Project-URL: Free Cheat Sheets, https://dargslan.com/cheat-sheets
+Project-URL: Linux & DevOps Books, https://dargslan.com/books
+Keywords: dns,resolver,dnssec,nameserver,linux,sysadmin,devops,network
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# dargslan-dns-resolver
+
+**DNS Resolver Tester** — Measure resolution time, compare resolvers, test DNSSEC, and detect DNS configuration issues. Zero external dependencies.
+
+[![PyPI version](https://img.shields.io/pypi/v/dargslan-dns-resolver)](https://pypi.org/project/dargslan-dns-resolver/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Installation
+
+```bash
+pip install dargslan-dns-resolver
+```
+
+## CLI Usage
+
+```bash
+dargslan-dns report                     # Full DNS report
+dargslan-dns resolve google.com         # Quick resolution test
+dargslan-dns dig google.com MX          # Dig-style query
+dargslan-dns compare 8.8.8.8 1.1.1.1   # Compare resolvers
+dargslan-dns dnssec google.com          # DNSSEC validation test
+dargslan-dns reverse 8.8.8.8            # Reverse lookup
+dargslan-dns config                     # Show resolver config
+dargslan-dns json                       # JSON output
+```
+
+## Python API
+
+```python
+from dargslan_dns_resolver import DNSResolver
+dr = DNSResolver()
+result = dr.resolve("dargslan.com")
+comparison = dr.compare_resolvers(["8.8.8.8", "1.1.1.1", "9.9.9.9"])
+dr.print_report()
+```
+
+## More from Dargslan
+
+- [Dargslan.com](https://dargslan.com) — Linux & DevOps eBook Store
+- [Free Cheat Sheets](https://dargslan.com/cheat-sheets)
+- [Blog & Tutorials](https://dargslan.com/blog)
+
+## License
+
+MIT — see [LICENSE](LICENSE)

dargslan_dns_resolver-1.0.0/README.md

@@ -0,0 +1,45 @@
+# dargslan-dns-resolver
+
+**DNS Resolver Tester** — Measure resolution time, compare resolvers, test DNSSEC, and detect DNS configuration issues. Zero external dependencies.
+
+[![PyPI version](https://img.shields.io/pypi/v/dargslan-dns-resolver)](https://pypi.org/project/dargslan-dns-resolver/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Installation
+
+```bash
+pip install dargslan-dns-resolver
+```
+
+## CLI Usage
+
+```bash
+dargslan-dns report                     # Full DNS report
+dargslan-dns resolve google.com         # Quick resolution test
+dargslan-dns dig google.com MX          # Dig-style query
+dargslan-dns compare 8.8.8.8 1.1.1.1   # Compare resolvers
+dargslan-dns dnssec google.com          # DNSSEC validation test
+dargslan-dns reverse 8.8.8.8            # Reverse lookup
+dargslan-dns config                     # Show resolver config
+dargslan-dns json                       # JSON output
+```
+
+## Python API
+
+```python
+from dargslan_dns_resolver import DNSResolver
+dr = DNSResolver()
+result = dr.resolve("dargslan.com")
+comparison = dr.compare_resolvers(["8.8.8.8", "1.1.1.1", "9.9.9.9"])
+dr.print_report()
+```
+
+## More from Dargslan
+
+- [Dargslan.com](https://dargslan.com) — Linux & DevOps eBook Store
+- [Free Cheat Sheets](https://dargslan.com/cheat-sheets)
+- [Blog & Tutorials](https://dargslan.com/blog)
+
+## License
+
+MIT — see [LICENSE](LICENSE)

dargslan_dns_resolver-1.0.0/dargslan_dns_resolver/__init__.py

@@ -0,0 +1,269 @@
+"""
+dargslan-dns-resolver — DNS Resolver Tester
+
+Measure resolution time, test DNSSEC, compare resolvers, and detect DNS issues.
+Zero external dependencies — uses socket and subprocess.
+
+Homepage: https://dargslan.com
+Books: https://dargslan.com/books
+Blog: https://dargslan.com/blog
+"""
+
+__version__ = "1.0.0"
+__author__ = "Dargslan"
+__url__ = "https://dargslan.com"
+
+import socket
+import subprocess
+import time
+import json
+import re
+import os
+
+
+WELL_KNOWN_RESOLVERS = {
+    '8.8.8.8': 'Google DNS',
+    '8.8.4.4': 'Google DNS (secondary)',
+    '1.1.1.1': 'Cloudflare DNS',
+    '1.0.0.1': 'Cloudflare DNS (secondary)',
+    '9.9.9.9': 'Quad9 DNS',
+    '208.67.222.222': 'OpenDNS',
+    '208.67.220.220': 'OpenDNS (secondary)',
+}
+
+
+class DNSResolver:
+    """Test DNS resolver performance and configuration."""
+
+    def __init__(self):
+        pass
+
+    def _run(self, args, timeout=10):
+        try:
+            result = subprocess.run(args, capture_output=True, text=True, timeout=timeout)
+            return result.stdout.strip(), result.returncode
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            return '', 1
+
+    def get_system_resolvers(self):
+        resolvers = []
+        try:
+            with open('/etc/resolv.conf', 'r') as f:
+                for line in f:
+                    line = line.strip()
+                    if line.startswith('nameserver'):
+                        parts = line.split()
+                        if len(parts) >= 2:
+                            ip = parts[1]
+                            name = WELL_KNOWN_RESOLVERS.get(ip, '')
+                            resolvers.append({'ip': ip, 'name': name})
+        except (FileNotFoundError, PermissionError):
+            pass
+        return resolvers
+
+    def resolve(self, hostname, record_type='A'):
+        start = time.time()
+        try:
+            if record_type == 'A':
+                results = socket.getaddrinfo(hostname, None, socket.AF_INET)
+                ips = list(set(r[4][0] for r in results))
+            elif record_type == 'AAAA':
+                results = socket.getaddrinfo(hostname, None, socket.AF_INET6)
+                ips = list(set(r[4][0] for r in results))
+            else:
+                ips = []
+
+            elapsed = (time.time() - start) * 1000
+            return {
+                'hostname': hostname,
+                'type': record_type,
+                'results': ips,
+                'time_ms': round(elapsed, 2),
+                'success': True,
+            }
+        except socket.gaierror as e:
+            elapsed = (time.time() - start) * 1000
+            return {
+                'hostname': hostname,
+                'type': record_type,
+                'error': str(e),
+                'time_ms': round(elapsed, 2),
+                'success': False,
+            }
+
+    def dig(self, hostname, record_type='A', server=None):
+        args = ['dig', '+noall', '+answer', '+stats', hostname, record_type]
+        if server:
+            args.insert(1, f'@{server}')
+
+        start = time.time()
+        output, rc = self._run(args)
+        elapsed = (time.time() - start) * 1000
+
+        records = []
+        query_time = None
+        for line in output.split('\n'):
+            if line.startswith(';; Query time:'):
+                match = re.search(r'(\d+)\s+msec', line)
+                if match:
+                    query_time = int(match.group(1))
+            elif line.strip() and not line.startswith(';'):
+                records.append(line.strip())
+
+        return {
+            'hostname': hostname,
+            'type': record_type,
+            'server': server,
+            'records': records,
+            'query_time_ms': query_time,
+            'total_time_ms': round(elapsed, 2),
+            'success': rc == 0,
+        }
+
+    def benchmark_resolver(self, server, domains=None, rounds=3):
+        if domains is None:
+            domains = ['google.com', 'github.com', 'amazon.com', 'cloudflare.com', 'wikipedia.org']
+
+        times = []
+        for domain in domains:
+            for _ in range(rounds):
+                result = self.dig(domain, server=server)
+                if result.get('query_time_ms') is not None:
+                    times.append(result['query_time_ms'])
+                elif result.get('total_time_ms'):
+                    times.append(result['total_time_ms'])
+
+        if not times:
+            return {'server': server, 'error': 'No successful queries'}
+
+        times.sort()
+        return {
+            'server': server,
+            'name': WELL_KNOWN_RESOLVERS.get(server, ''),
+            'queries': len(times),
+            'avg_ms': round(sum(times) / len(times), 2),
+            'min_ms': round(times[0], 2),
+            'max_ms': round(times[-1], 2),
+            'p50_ms': round(times[len(times) // 2], 2),
+        }
+
+    def compare_resolvers(self, servers=None):
+        if servers is None:
+            servers = ['8.8.8.8', '1.1.1.1', '9.9.9.9']
+        results = []
+        for server in servers:
+            results.append(self.benchmark_resolver(server, rounds=2))
+        results.sort(key=lambda x: x.get('avg_ms', 9999))
+        return results
+
+    def check_dnssec(self, hostname):
+        output, rc = self._run(['dig', '+dnssec', '+short', hostname, 'A'])
+        has_rrsig = 'RRSIG' in output or bool(re.search(r'\bRRSIG\b', output))
+
+        output2, _ = self._run(['dig', '+noall', '+comments', hostname, 'A'])
+        ad_flag = 'flags:' in output2 and ' ad' in output2
+
+        return {
+            'hostname': hostname,
+            'dnssec_signed': has_rrsig,
+            'ad_flag': ad_flag,
+            'validated': ad_flag,
+        }
+
+    def reverse_lookup(self, ip):
+        try:
+            hostname = socket.gethostbyaddr(ip)
+            return {'ip': ip, 'hostname': hostname[0], 'aliases': hostname[1]}
+        except (socket.herror, socket.gaierror) as e:
+            return {'ip': ip, 'error': str(e)}
+
+    def check_resolv_conf(self):
+        info = {'resolvers': self.get_system_resolvers()}
+        content = ''
+        try:
+            with open('/etc/resolv.conf', 'r') as f:
+                content = f.read()
+        except (FileNotFoundError, PermissionError):
+            pass
+
+        for line in content.split('\n'):
+            line = line.strip()
+            if line.startswith('search ') or line.startswith('domain '):
+                info['search_domains'] = line.split()[1:]
+            if line.startswith('options '):
+                info['options'] = line.split()[1:]
+
+        is_symlink = os.path.islink('/etc/resolv.conf')
+        info['is_symlink'] = is_symlink
+        if is_symlink:
+            info['symlink_target'] = os.readlink('/etc/resolv.conf')
+
+        return info
+
+    def audit(self):
+        issues = []
+        resolvers = self.get_system_resolvers()
+
+        if not resolvers:
+            issues.append({'severity': 'critical', 'message': 'No DNS resolvers configured'})
+        elif len(resolvers) < 2:
+            issues.append({'severity': 'warning', 'message': 'Only one DNS resolver configured — no redundancy'})
+
+        for r in resolvers:
+            result = self.resolve('google.com')
+            if not result['success']:
+                issues.append({'severity': 'critical', 'message': f"Resolver {r['ip']} failed to resolve google.com"})
+            elif result['time_ms'] > 500:
+                issues.append({'severity': 'warning', 'message': f"DNS resolution slow ({result['time_ms']}ms)"})
+
+        return issues
+
+    def print_report(self, domains=None):
+        resolvers = self.get_system_resolvers()
+        resolv_info = self.check_resolv_conf()
+        issues = self.audit()
+
+        print(f"\n{'='*60}")
+        print(f"  DNS Resolver Report")
+        print(f"{'='*60}")
+
+        print(f"\n  System Resolvers ({len(resolvers)}):")
+        for r in resolvers:
+            name = f" ({r['name']})" if r['name'] else ''
+            print(f"    {r['ip']}{name}")
+
+        if resolv_info.get('search_domains'):
+            print(f"  Search Domains: {' '.join(resolv_info['search_domains'])}")
+        if resolv_info.get('is_symlink'):
+            print(f"  resolv.conf -> {resolv_info.get('symlink_target', '?')}")
+
+        test_domains = domains or ['google.com', 'github.com', 'dargslan.com']
+        print(f"\n  Resolution Tests:")
+        for d in test_domains:
+            r = self.resolve(d)
+            if r['success']:
+                print(f"    {d}: {', '.join(r['results'][:3])} ({r['time_ms']}ms)")
+            else:
+                print(f"    {d}: FAILED — {r.get('error','')}")
+
+        print(f"\n  Resolver Comparison:")
+        comparison = self.compare_resolvers(rounds=1)
+        for c in comparison:
+            if c.get('error'):
+                print(f"    {c['server']:>15s}: FAILED")
+            else:
+                name = f" ({c['name']})" if c.get('name') else ''
+                print(f"    {c['server']:>15s}{name}: avg={c['avg_ms']}ms min={c['min_ms']}ms max={c['max_ms']}ms")
+
+        if issues:
+            print(f"\n  Issues ({len(issues)}):")
+            for i in issues:
+                print(f"    [{i['severity'].upper():8s}] {i['message']}")
+
+        print(f"\n{'='*60}")
+        print(f"  More tools: https://dargslan.com")
+        print(f"  eBooks: https://dargslan.com/books")
+        print(f"{'='*60}\n")
+
+
+__all__ = ["DNSResolver"]

dargslan_dns_resolver-1.0.0/dargslan_dns_resolver/cli.py

@@ -0,0 +1,55 @@
+"""CLI for dargslan-dns-resolver — https://dargslan.com"""
+import argparse
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Dargslan DNS Resolver — DNS resolver tester",
+        epilog="More tools at https://dargslan.com | eBooks: https://dargslan.com/books",
+    )
+    parser.add_argument("command", nargs="?", default="report",
+                       choices=["report", "resolve", "dig", "compare", "dnssec", "reverse", "config", "issues", "json"],
+                       help="Command (default: report)")
+    parser.add_argument("targets", nargs="*", help="Hostnames or IPs")
+    parser.add_argument("-s", "--server", help="DNS server to use")
+    parser.add_argument("-t", "--type", default="A", help="Record type (A, AAAA, MX, etc.)")
+    args = parser.parse_args()
+
+    from dargslan_dns_resolver import DNSResolver
+    dr = DNSResolver()
+    import json
+
+    targets = [t for t in args.targets if t not in ('report','resolve','dig','compare','dnssec','reverse','config','issues','json')]
+
+    if args.command == 'report': dr.print_report(targets or None)
+    elif args.command == 'resolve':
+        for t in targets or ['google.com']:
+            r = dr.resolve(t, args.type)
+            if r['success']:
+                print(f"  {t}: {', '.join(r['results'])} ({r['time_ms']}ms)")
+            else:
+                print(f"  {t}: FAILED — {r.get('error','')}")
+    elif args.command == 'dig':
+        for t in targets or ['google.com']:
+            r = dr.dig(t, args.type, server=args.server)
+            for rec in r['records']: print(f"  {rec}")
+            if r.get('query_time_ms'): print(f"  Query time: {r['query_time_ms']}ms")
+    elif args.command == 'compare':
+        for c in dr.compare_resolvers(targets or None):
+            if c.get('error'): print(f"  {c['server']}: FAILED")
+            else: print(f"  {c['server']:>15s}: avg={c['avg_ms']}ms")
+    elif args.command == 'dnssec':
+        for t in targets or ['google.com']:
+            r = dr.check_dnssec(t)
+            print(f"  {t}: signed={r['dnssec_signed']} validated={r['validated']}")
+    elif args.command == 'reverse':
+        for t in targets:
+            r = dr.reverse_lookup(t)
+            print(f"  {t}: {r.get('hostname', r.get('error',''))}")
+    elif args.command == 'config':
+        c = dr.check_resolv_conf()
+        for r in c['resolvers']: print(f"  Resolver: {r['ip']} {r.get('name','')}")
+    elif args.command == 'issues':
+        for i in dr.audit(): print(f"  [{i['severity'].upper()}] {i['message']}")
+    elif args.command == 'json': print(json.dumps(dr.audit(), indent=2))
+
+if __name__ == "__main__": main()

dargslan_dns_resolver-1.0.0/dargslan_dns_resolver.egg-info/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: dargslan-dns-resolver
+Version: 1.0.0
+Summary: DNS resolver tester — measure resolution time, test DNSSEC, compare resolvers, and detect DNS issues
+Author-email: Dargslan <info@dargslan.com>
+License: MIT
+Project-URL: Homepage, https://dargslan.com
+Project-URL: Documentation, https://dargslan.com/blog
+Project-URL: Repository, https://github.com/Dargslan
+Project-URL: Free Cheat Sheets, https://dargslan.com/cheat-sheets
+Project-URL: Linux & DevOps Books, https://dargslan.com/books
+Keywords: dns,resolver,dnssec,nameserver,linux,sysadmin,devops,network
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# dargslan-dns-resolver
+
+**DNS Resolver Tester** — Measure resolution time, compare resolvers, test DNSSEC, and detect DNS configuration issues. Zero external dependencies.
+
+[![PyPI version](https://img.shields.io/pypi/v/dargslan-dns-resolver)](https://pypi.org/project/dargslan-dns-resolver/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Installation
+
+```bash
+pip install dargslan-dns-resolver
+```
+
+## CLI Usage
+
+```bash
+dargslan-dns report                     # Full DNS report
+dargslan-dns resolve google.com         # Quick resolution test
+dargslan-dns dig google.com MX          # Dig-style query
+dargslan-dns compare 8.8.8.8 1.1.1.1   # Compare resolvers
+dargslan-dns dnssec google.com          # DNSSEC validation test
+dargslan-dns reverse 8.8.8.8            # Reverse lookup
+dargslan-dns config                     # Show resolver config
+dargslan-dns json                       # JSON output
+```
+
+## Python API
+
+```python
+from dargslan_dns_resolver import DNSResolver
+dr = DNSResolver()
+result = dr.resolve("dargslan.com")
+comparison = dr.compare_resolvers(["8.8.8.8", "1.1.1.1", "9.9.9.9"])
+dr.print_report()
+```
+
+## More from Dargslan
+
+- [Dargslan.com](https://dargslan.com) — Linux & DevOps eBook Store
+- [Free Cheat Sheets](https://dargslan.com/cheat-sheets)
+- [Blog & Tutorials](https://dargslan.com/blog)
+
+## License
+
+MIT — see [LICENSE](LICENSE)

dargslan_dns_resolver-1.0.0/dargslan_dns_resolver.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+dargslan_dns_resolver/__init__.py
+dargslan_dns_resolver/cli.py
+dargslan_dns_resolver.egg-info/PKG-INFO
+dargslan_dns_resolver.egg-info/SOURCES.txt
+dargslan_dns_resolver.egg-info/dependency_links.txt
+dargslan_dns_resolver.egg-info/entry_points.txt
+dargslan_dns_resolver.egg-info/top_level.txt

dargslan_dns_resolver-1.0.0/dargslan_dns_resolver.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dargslan_dns_resolver-1.0.0/dargslan_dns_resolver.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dargslan-dns = dargslan_dns_resolver.cli:main

dargslan_dns_resolver-1.0.0/dargslan_dns_resolver.egg-info/top_level.txt

@@ -0,0 +1 @@
+dargslan_dns_resolver

dargslan_dns_resolver-1.0.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dargslan-dns-resolver"
+version = "1.0.0"
+description = "DNS resolver tester — measure resolution time, test DNSSEC, compare resolvers, and detect DNS issues"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.7"
+authors = [{name = "Dargslan", email = "info@dargslan.com"}]
+keywords = ["dns", "resolver", "dnssec", "nameserver", "linux", "sysadmin", "devops", "network"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: System Administrators",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Topic :: System :: Networking",
+]
+
+[project.urls]
+Homepage = "https://dargslan.com"
+Documentation = "https://dargslan.com/blog"
+Repository = "https://github.com/Dargslan"
+"Free Cheat Sheets" = "https://dargslan.com/cheat-sheets"
+"Linux & DevOps Books" = "https://dargslan.com/books"
+
+[project.scripts]
+dargslan-dns = "dargslan_dns_resolver.cli:main"

dargslan_dns_resolver-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+