nginx-lens 0.3.0__tar.gz → 0.3.2__tar.gz

{nginx_lens-0.3.0/nginx_lens.egg-info → nginx_lens-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nginx-lens
-Version: 0.3.0
+Version: 0.3.2
 Summary: CLI-инструмент для анализа, визуализации и диагностики конфигураций Nginx
 Author: Daniil Astrouski
 Author-email: shelovesuastra@gmail.com
@@ -9,6 +9,7 @@ License-File: LICENSE
 Requires-Dist: typer[all]>=0.9.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: requests>=2.25.0
+Requires-Dist: dnspython>=2.0.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: license-file

{nginx_lens-0.3.0 → nginx_lens-0.3.2}/commands/health.py

@@ -51,15 +51,21 @@ def health(
             color = "green" if srv["healthy"] else "red"
             
             if resolve:
-                resolved = None
+                resolved_list = []
                 if name in resolved_info:
                     for resolved_srv in resolved_info[name]:
                         if resolved_srv["address"] == srv["address"]:
-                            resolved = resolved_srv["resolved"]
+                            resolved_list = resolved_srv["resolved"]
                             break
                 
-                if resolved:
-                    table.add_row(srv["address"], f"[{color}]{status}[/{color}]", resolved)
+                if resolved_list:
+                    # Показываем все IP-адреса через запятую
+                    resolved_str = ", ".join(resolved_list)
+                    # Если есть "invalid resolve", показываем красным, иначе зеленым
+                    if any("invalid resolve" in r for r in resolved_list):
+                        table.add_row(srv["address"], f"[{color}]{status}[/{color}]", f"[red]{resolved_str}[/red]")
+                    else:
+                        table.add_row(srv["address"], f"[{color}]{status}[/{color}]", f"[green]{resolved_str}[/green]")
                 else:
                     table.add_row(srv["address"], f"[{color}]{status}[/{color}]", "[yellow]Failed to resolve[/yellow]")
             else:

{nginx_lens-0.3.0 → nginx_lens-0.3.2}/commands/resolve.py

@@ -40,8 +40,15 @@ def resolve(
     for name, servers in results.items():
         for idx, srv in enumerate(servers):
             upstream_name = name if idx == 0 else ""
-            if srv["resolved"]:
-                table.add_row(upstream_name, srv["address"], f"[green]{srv['resolved']}[/green]")
+            resolved_list = srv["resolved"]
+            if resolved_list:
+                # Показываем все IP-адреса через запятую
+                resolved_str = ", ".join(resolved_list)
+                # Если есть "invalid resolve", показываем красным, иначе зеленым
+                if any("invalid resolve" in r for r in resolved_list):
+                    table.add_row(upstream_name, srv["address"], f"[red]{resolved_str}[/red]")
+                else:
+                    table.add_row(upstream_name, srv["address"], f"[green]{resolved_str}[/green]")
             else:
                 table.add_row(upstream_name, srv["address"], "[red]Failed to resolve[/red]")
 

{nginx_lens-0.3.0 → nginx_lens-0.3.2/nginx_lens.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nginx-lens
-Version: 0.3.0
+Version: 0.3.2
 Summary: CLI-инструмент для анализа, визуализации и диагностики конфигураций Nginx
 Author: Daniil Astrouski
 Author-email: shelovesuastra@gmail.com
@@ -9,6 +9,7 @@ License-File: LICENSE
 Requires-Dist: typer[all]>=0.9.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: requests>=2.25.0
+Requires-Dist: dnspython>=2.0.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: license-file

{nginx_lens-0.3.0 → nginx_lens-0.3.2}/nginx_lens.egg-info/requires.txt

@@ -1,3 +1,4 @@
 typer[all]>=0.9.0
 rich>=13.0.0
 requests>=2.25.0
+dnspython>=2.0.0

{nginx_lens-0.3.0 → nginx_lens-0.3.2}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="nginx-lens",
-    version="0.3.0",
+    version="0.3.2",
     description="CLI-инструмент для анализа, визуализации и диагностики конфигураций Nginx",
     author="Daniil Astrouski",
     author_email="shelovesuastra@gmail.com",
@@ -12,6 +12,7 @@ setup(
         "typer[all]>=0.9.0",
         "rich>=13.0.0",
         "requests>=2.25.0",
+        "dnspython>=2.0.0",
     ],
     entry_points={
         "console_scripts": [

nginx_lens-0.3.2/upstream_checker/checker.py

@@ -0,0 +1,255 @@
+# upstream_checker/checker.py
+
+import socket
+import time
+import http.client
+from typing import Dict, List
+try:
+    import dns.resolver
+    import dns.exception
+    DNS_AVAILABLE = True
+except ImportError:
+    DNS_AVAILABLE = False
+
+
+def check_tcp(address: str, timeout: float, retries: int) -> bool:
+    """
+    Проверка доступности сервера по TCP.
+    Ignores extra upstream options like 'max_fails' or 'fail_timeout'.
+    """
+    # Берем только host:port, игнорируем параметры
+    host_port = address.split()[0]
+    host, port = host_port.split(":")
+    port = int(port)
+    
+    for _ in range(retries):
+        try:
+            with socket.create_connection((host, port), timeout=timeout):
+                return True
+        except (socket.timeout, ConnectionRefusedError, OSError):
+            time.sleep(0.2)
+    return False
+
+
+def check_http(address: str, timeout: float, retries: int) -> bool:
+    """
+    Проверка доступности сервера по HTTP (GET /).
+    Ignores extra upstream options like 'max_fails' or 'fail_timeout'.
+    """
+    host_port = address.split()[0]
+    host, port = host_port.split(":")
+    port = int(port)
+    
+    for _ in range(retries):
+        try:
+            conn = http.client.HTTPConnection(host, port, timeout=timeout)
+            conn.request("GET", "/")
+            resp = conn.getresponse()
+            healthy = resp.status < 500
+            conn.close()
+            if healthy:
+                return True
+        except Exception:
+            time.sleep(0.2)
+            continue
+    return False
+
+
+def resolve_address(address: str) -> List[str]:
+    """
+    Резолвит адрес upstream сервера в IP-адреса с информацией о CNAME.
+    
+    Args:
+        address: Адрес в формате "host:port" или "host:port параметры"
+        
+    Returns:
+        Список строк в формате:
+        - "ip:port" - если резолвинг успешен без CNAME
+        - "ip:port (via cname.example.com)" - если есть CNAME и все ок
+        - "invalid resolve (via cname.example.com -> TXT)" - если CNAME ведет на невалидную запись
+        Пустой список, если резолвинг не удался
+    """
+    try:
+        host_port = address.split()[0]
+        
+        if ":" not in host_port:
+            return []
+            
+        parts = host_port.rsplit(":", 1)
+        if len(parts) != 2:
+            return []
+        host, port = parts
+        
+        # Если это уже IPv4 адрес, возвращаем как есть
+        try:
+            socket.inet_aton(host)
+            return [host_port]
+        except socket.error:
+            pass
+        
+        # Проверяем IPv6 (в квадратных скобках)
+        if host.startswith("[") and host.endswith("]"):
+            ipv6_host = host[1:-1]
+            try:
+                socket.inet_pton(socket.AF_INET6, ipv6_host)
+                return [host_port]
+            except (socket.error, OSError):
+                pass
+        
+        # Используем dnspython для детального DNS резолвинга
+        if DNS_AVAILABLE:
+            return _resolve_with_dns(host, port)
+        else:
+            # Fallback на стандартный socket, если dnspython недоступен
+            return _resolve_with_socket(host, port)
+    except (ValueError, IndexError, AttributeError):
+        return []
+
+
+def _resolve_with_dns(host: str, port: str) -> List[str]:
+    """Резолвит DNS с использованием dnspython для получения информации о CNAME."""
+    try:
+        cname_info = None
+        invalid_type = None
+        
+        # Сначала проверяем CNAME для исходного хоста
+        try:
+            cname_answer = dns.resolver.resolve(host, 'CNAME', raise_on_no_answer=False)
+            if cname_answer:
+                cname_target = str(cname_answer[0].target).rstrip('.')
+                cname_info = cname_target
+                
+                # Если есть CNAME, проверяем A записи для CNAME цели (не для исходного хоста)
+                try:
+                    a_answer = dns.resolver.resolve(cname_target, 'A', raise_on_no_answer=False)
+                    if a_answer:
+                        # CNAME ведет на валидные A записи
+                        resolved_ips = []
+                        for rdata in a_answer:
+                            ip = str(rdata.address)
+                            resolved_ips.append(f"{ip}:{port} (via {cname_info})")
+                        return resolved_ips
+                    else:
+                        # Нет A записей для CNAME цели, проверяем другие типы
+                        try:
+                            txt_answer = dns.resolver.resolve(cname_target, 'TXT', raise_on_no_answer=False)
+                            if txt_answer:
+                                invalid_type = 'TXT'
+                        except:
+                            pass
+                        if not invalid_type:
+                            try:
+                                mx_answer = dns.resolver.resolve(cname_target, 'MX', raise_on_no_answer=False)
+                                if mx_answer:
+                                    invalid_type = 'MX'
+                            except:
+                                pass
+                        if not invalid_type:
+                            # Проверяем другие невалидные типы
+                            try:
+                                ns_answer = dns.resolver.resolve(cname_target, 'NS', raise_on_no_answer=False)
+                                if ns_answer:
+                                    invalid_type = 'NS'
+                            except:
+                                pass
+                        if invalid_type:
+                            return [f"invalid resolve (via {cname_info} -> {invalid_type})"]
+                        else:
+                            return [f"invalid resolve (via {cname_info})"]
+                except Exception:
+                    return [f"invalid resolve (via {cname_info})"]
+        except Exception:
+            pass
+        
+        # Если нет CNAME, получаем A записи для исходного хоста
+        try:
+            a_answer = dns.resolver.resolve(host, 'A', raise_on_no_answer=False)
+            if a_answer:
+                resolved_ips = []
+                for rdata in a_answer:
+                    ip = str(rdata.address)
+                    resolved_ips.append(f"{ip}:{port}")
+                return resolved_ips if resolved_ips else []
+        except Exception:
+            pass
+        
+        return []
+    except Exception:
+        return []
+
+
+def _resolve_with_socket(host: str, port: str) -> List[str]:
+    """Fallback резолвинг через socket (без информации о CNAME)."""
+    try:
+        # gethostbyname_ex возвращает (hostname, aliaslist, ipaddrlist)
+        _, _, ipaddrlist = socket.gethostbyname_ex(host)
+        # Фильтруем только IPv4 адреса (IPv6 обрабатываются отдельно)
+        resolved_ips = []
+        for ip in ipaddrlist:
+            try:
+                # Проверяем, что это IPv4
+                socket.inet_aton(ip)
+                resolved_ips.append(f"{ip}:{port}")
+            except socket.error:
+                pass
+        return resolved_ips if resolved_ips else []
+    except (socket.gaierror, OSError):
+        return []
+
+
+def resolve_upstreams(
+    upstreams: Dict[str, List[str]]
+) -> Dict[str, List[dict]]:
+    """
+    Резолвит DNS имена upstream-серверов в IP-адреса.
+    
+    Возвращает:
+    {
+        "backend": [
+            {"address": "example.com:8080", "resolved": ["192.168.1.1:8080", "192.168.1.2:8080"]},
+            {"address": "127.0.0.1:8080", "resolved": ["127.0.0.1:8080"]},
+            {"address": "badhost:80", "resolved": []},
+            ...
+        ]
+    }
+    """
+    results = {}
+    for name, servers in upstreams.items():
+        results[name] = []
+        for srv in servers:
+            resolved = resolve_address(srv)
+            results[name].append({
+                "address": srv,
+                "resolved": resolved
+            })
+    return results
+
+
+def check_upstreams(
+    upstreams: Dict[str, List[str]],
+    timeout: float = 2.0,
+    retries: int = 1,
+    mode: str = "tcp"
+) -> Dict[str, List[dict]]:
+    """
+    Проверяет доступность upstream-серверов.
+    mode: "tcp" (по умолчанию) или "http"
+    
+    Возвращает:
+    {
+        "backend": [
+            {"address": "127.0.0.1:8080", "healthy": True},
+            ...
+        ]
+    }
+    """
+    results = {}
+    for name, servers in upstreams.items():
+        results[name] = []
+        for srv in servers:
+            if mode.lower() == "http":
+                healthy = check_http(srv, timeout, retries)
+            else:
+                healthy = check_tcp(srv, timeout, retries)
+            results[name].append({"address": srv, "healthy": healthy})
+    return results

nginx_lens-0.3.0/upstream_checker/checker.py

@@ -1,151 +0,0 @@
-# upstream_checker/checker.py
-
-import socket
-import time
-import http.client
-from typing import Dict, List, Optional
-
-
-def check_tcp(address: str, timeout: float, retries: int) -> bool:
-    """
-    Проверка доступности сервера по TCP.
-    Ignores extra upstream options like 'max_fails' or 'fail_timeout'.
-    """
-    # Берем только host:port, игнорируем параметры
-    host_port = address.split()[0]
-    host, port = host_port.split(":")
-    port = int(port)
-    
-    for _ in range(retries):
-        try:
-            with socket.create_connection((host, port), timeout=timeout):
-                return True
-        except (socket.timeout, ConnectionRefusedError, OSError):
-            time.sleep(0.2)
-    return False
-
-
-def check_http(address: str, timeout: float, retries: int) -> bool:
-    """
-    Проверка доступности сервера по HTTP (GET /).
-    Ignores extra upstream options like 'max_fails' or 'fail_timeout'.
-    """
-    host_port = address.split()[0]
-    host, port = host_port.split(":")
-    port = int(port)
-    
-    for _ in range(retries):
-        try:
-            conn = http.client.HTTPConnection(host, port, timeout=timeout)
-            conn.request("GET", "/")
-            resp = conn.getresponse()
-            healthy = resp.status < 500
-            conn.close()
-            if healthy:
-                return True
-        except Exception:
-            time.sleep(0.2)
-            continue
-    return False
-
-
-def resolve_address(address: str) -> Optional[str]:
-    """
-    Резолвит адрес upstream сервера в IP-адрес.
-    
-    Args:
-        address: Адрес в формате "host:port" или "host:port параметры"
-        
-    Returns:
-        IP-адрес в формате "ip:port" или None, если резолвинг не удался
-    """
-    try:
-        host_port = address.split()[0]
-        
-        if ":" not in host_port:
-            return None
-            
-        parts = host_port.rsplit(":", 1)
-        if len(parts) != 2:
-            return None
-        host, port = parts
-        
-        try:
-            socket.inet_aton(host)
-            return host_port
-        except socket.error:
-            pass
-        
-        if host.startswith("[") and host.endswith("]"):
-            ipv6_host = host[1:-1]
-            try:
-                socket.inet_pton(socket.AF_INET6, ipv6_host)
-                return host_port
-            except (socket.error, OSError):
-                pass
-        
-        try:
-            ip = socket.gethostbyname(host)
-            return f"{ip}:{port}"
-        except (socket.gaierror, OSError):
-            return None
-    except (ValueError, IndexError, AttributeError):
-        return None
-
-
-def resolve_upstreams(
-    upstreams: Dict[str, List[str]]
-) -> Dict[str, List[dict]]:
-    """
-    Резолвит DNS имена upstream-серверов в IP-адреса.
-    
-    Возвращает:
-    {
-        "backend": [
-            {"address": "example.com:8080", "resolved": "192.168.1.1:8080"},
-            {"address": "127.0.0.1:8080", "resolved": "127.0.0.1:8080"},
-            {"address": "badhost:80", "resolved": None},
-            ...
-        ]
-    }
-    """
-    results = {}
-    for name, servers in upstreams.items():
-        results[name] = []
-        for srv in servers:
-            resolved = resolve_address(srv)
-            results[name].append({
-                "address": srv,
-                "resolved": resolved
-            })
-    return results
-
-
-def check_upstreams(
-    upstreams: Dict[str, List[str]],
-    timeout: float = 2.0,
-    retries: int = 1,
-    mode: str = "tcp"
-) -> Dict[str, List[dict]]:
-    """
-    Проверяет доступность upstream-серверов.
-    mode: "tcp" (по умолчанию) или "http"
-    
-    Возвращает:
-    {
-        "backend": [
-            {"address": "127.0.0.1:8080", "healthy": True},
-            ...
-        ]
-    }
-    """
-    results = {}
-    for name, servers in upstreams.items():
-        results[name] = []
-        for srv in servers:
-            if mode.lower() == "http":
-                healthy = check_http(srv, timeout, retries)
-            else:
-                healthy = check_tcp(srv, timeout, retries)
-            results[name].append({"address": srv, "healthy": healthy})
-    return results