nginx-lens 0.2.3__tar.gz → 0.3.1__tar.gz

{nginx_lens-0.2.3/nginx_lens.egg-info → nginx_lens-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nginx-lens
-Version: 0.2.3
+Version: 0.3.1
 Summary: CLI-инструмент для анализа, визуализации и диагностики конфигураций Nginx
 Author: Daniil Astrouski
 Author-email: shelovesuastra@gmail.com

{nginx_lens-0.2.3 → nginx_lens-0.3.1}/commands/cli.py

@@ -9,6 +9,7 @@ from commands.include import include_tree
 from commands.graph import graph
 from commands.logs import logs
 from commands.syntax import syntax
+from commands.resolve import resolve
 
 app = typer.Typer(help="nginx-lens — анализ и диагностика конфигураций Nginx")
 console = Console()
@@ -22,6 +23,7 @@ app.command()(include_tree)
 app.command()(graph)
 app.command()(logs)
 app.command()(syntax)
+app.command()(resolve)
 
 if __name__ == "__main__":
     app() 

{nginx_lens-0.2.3 → nginx_lens-0.3.1}/commands/health.py

@@ -1,7 +1,7 @@
 import typer
 from rich.console import Console
 from rich.table import Table
-from upstream_checker.checker import check_upstreams
+from upstream_checker.checker import check_upstreams, resolve_upstreams
 from parser.nginx_parser import parse_nginx_config
 
 app = typer.Typer()
@@ -12,6 +12,7 @@ def health(
     timeout: float = typer.Option(2.0, help="Таймаут проверки (сек)"),
     retries: int = typer.Option(1, help="Количество попыток"),
     mode: str = typer.Option("tcp", help="Режим проверки: tcp или http", case_sensitive=False),
+    resolve: bool = typer.Option(False, "--resolve", "-r", help="Показать резолвленные IP-адреса"),
 ):
     """
     Проверяет доступность upstream-серверов, определённых в nginx.conf. Выводит таблицу.
@@ -19,6 +20,7 @@ def health(
     Пример:
         nginx-lens health /etc/nginx/nginx.conf
         nginx-lens health /etc/nginx/nginx.conf --timeout 5 --retries 3 --mode http
+        nginx-lens health /etc/nginx/nginx.conf --resolve
     """
     try:
         tree = parse_nginx_config(config_path)
@@ -31,15 +33,38 @@ def health(
 
     upstreams = tree.get_upstreams()
     results = check_upstreams(upstreams, timeout=timeout, retries=retries, mode=mode.lower())
+    
+    # Если нужно показать резолвленные IP-адреса
+    resolved_info = {}
+    if resolve:
+        resolved_info = resolve_upstreams(upstreams)
 
     table = Table(show_header=True, header_style="bold blue")
-    table.add_column("upstream_name")
-    table.add_column("upstream_status")
+    table.add_column("Address")
+    table.add_column("Status")
+    if resolve:
+        table.add_column("Resolved IP")
 
     for name, servers in results.items():
         for srv in servers:
             status = "Healthy" if srv["healthy"] else "Unhealthy"
             color = "green" if srv["healthy"] else "red"
-            table.add_row(srv["address"], f"[{color}]{status}[/{color}]")
+            
+            if resolve:
+                resolved_list = []
+                if name in resolved_info:
+                    for resolved_srv in resolved_info[name]:
+                        if resolved_srv["address"] == srv["address"]:
+                            resolved_list = resolved_srv["resolved"]
+                            break
+                
+                if resolved_list:
+                    # Показываем все IP-адреса через запятую
+                    resolved_str = ", ".join(resolved_list)
+                    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:
+                table.add_row(srv["address"], f"[{color}]{status}[/{color}]")
 
     console.print(table)

nginx_lens-0.3.1/commands/resolve.py

@@ -0,0 +1,52 @@
+import typer
+from rich.console import Console
+from rich.table import Table
+from upstream_checker.checker import resolve_upstreams
+from parser.nginx_parser import parse_nginx_config
+
+app = typer.Typer()
+console = Console()
+
+def resolve(
+    config_path: str = typer.Argument(..., help="Путь к nginx.conf"),
+):
+    """
+    Резолвит DNS имена upstream-серверов в IP-адреса.
+
+    Пример:
+        nginx-lens resolve /etc/nginx/nginx.conf
+    """
+    try:
+        tree = parse_nginx_config(config_path)
+    except FileNotFoundError:
+        console.print(f"[red]Файл {config_path} не найден. Проверьте путь к конфигу.[/red]")
+        return
+    except Exception as e:
+        console.print(f"[red]Ошибка при разборе {config_path}: {e}[/red]")
+        return
+
+    upstreams = tree.get_upstreams()
+    if not upstreams:
+        console.print("[yellow]Не найдено ни одного upstream в конфигурации.[/yellow]")
+        return
+    
+    results = resolve_upstreams(upstreams)
+
+    table = Table(show_header=True, header_style="bold blue")
+    table.add_column("Upstream Name")
+    table.add_column("Address")
+    table.add_column("Resolved IP")
+
+    for name, servers in results.items():
+        for idx, srv in enumerate(servers):
+            upstream_name = name if idx == 0 else ""
+            resolved_list = srv["resolved"]
+            if resolved_list:
+                # Показываем все IP-адреса через запятую
+                resolved_str = ", ".join(resolved_list)
+                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]")
+
+    console.print(table)
+

{nginx_lens-0.2.3 → nginx_lens-0.3.1/nginx_lens.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nginx-lens
-Version: 0.2.3
+Version: 0.3.1
 Summary: CLI-инструмент для анализа, визуализации и диагностики конфигураций Nginx
 Author: Daniil Astrouski
 Author-email: shelovesuastra@gmail.com

{nginx_lens-0.2.3 → nginx_lens-0.3.1}/nginx_lens.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ commands/graph.py
 commands/health.py
 commands/include.py
 commands/logs.py
+commands/resolve.py
 commands/route.py
 commands/syntax.py
 commands/tree.py

{nginx_lens-0.2.3 → nginx_lens-0.3.1}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="nginx-lens",
-    version="0.2.3",
+    version="0.3.1",
     description="CLI-инструмент для анализа, визуализации и диагностики конфигураций Nginx",
     author="Daniil Astrouski",
     author_email="shelovesuastra@gmail.com",

nginx_lens-0.3.1/upstream_checker/checker.py

@@ -0,0 +1,164 @@
+# upstream_checker/checker.py
+
+import socket
+import time
+import http.client
+from typing import Dict, List
+
+
+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-адреса.
+    
+    Args:
+        address: Адрес в формате "host:port" или "host:port параметры"
+        
+    Returns:
+        Список IP-адресов в формате "ip:port" или пустой список, если резолвинг не удался
+    """
+    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
+        
+        # Пытаемся резолвить DNS имя - получаем все IP-адреса
+        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 []
+    except (ValueError, IndexError, AttributeError):
+        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.2.3/upstream_checker/checker.py

@@ -1,79 +0,0 @@
-# upstream_checker/checker.py
-
-import socket
-import time
-import http.client
-from typing import Dict, List
-
-
-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 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