nginx-lens 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

analyzer/conflicts.py

@@ -30,4 +30,36 @@ def find_location_conflicts(tree) -> List[Dict[str, Any]]:
 
 def _locations_conflict(loc1, loc2):
     # Простая эвристика: если один путь — префикс другого
-    return loc1.startswith(loc2) or loc2.startswith(loc1) 
+    return loc1.startswith(loc2) or loc2.startswith(loc1)
+
+
+def find_listen_servername_conflicts(tree) -> List[Dict[str, Any]]:
+    """
+    Находит конфликтующие listen/server_name между server-блоками.
+    Возвращает список: [{server1, server2, listen, server_name}]
+    """
+    analyzer = Analyzer(tree)
+    servers = []
+    for d, parent in analyzer.walk():
+        if d.get('block') == 'server':
+            listens = set()
+            names = set()
+            for sub, _ in analyzer.walk(d['directives'], d):
+                if sub.get('directive') == 'listen':
+                    listens.add(sub.get('args', '').strip())
+                if sub.get('directive') == 'server_name':
+                    names.update(sub.get('args', '').split())
+            servers.append({'block': d, 'listen': listens, 'server_name': names})
+    conflicts = []
+    for i in range(len(servers)):
+        for j in range(i+1, len(servers)):
+            common_listen = servers[i]['listen'] & servers[j]['listen']
+            common_name = servers[i]['server_name'] & servers[j]['server_name']
+            if common_listen and common_name:
+                conflicts.append({
+                    'server1': servers[i]['block'],
+                    'server2': servers[j]['block'],
+                    'listen': list(common_listen),
+                    'server_name': list(common_name)
+                })
+    return conflicts 

analyzer/dead_locations.py

@@ -0,0 +1,34 @@
+from analyzer.base import Analyzer
+from typing import List, Dict, Any, Set
+import re
+
+def find_dead_locations(tree) -> List[Dict[str, Any]]:
+    """
+    Находит location-ы, которые не используются ни в одном proxy_pass, rewrite, try_files и т.д.
+    Возвращает список: [{server, location}]
+    """
+    analyzer = Analyzer(tree)
+    locations = []
+    used = set()
+    # Собираем все location
+    for d, parent in analyzer.walk():
+        if d.get('block') == 'server':
+            for sub, _ in analyzer.walk(d.get('directives', []), d):
+                if sub.get('block') == 'location':
+                    locations.append({'server': d, 'location': sub})
+    # Собираем все использования location (proxy_pass, rewrite, try_files)
+    for d, parent in analyzer.walk():
+        for key in ('proxy_pass', 'rewrite', 'try_files'):
+            if d.get('directive') == key:
+                args = d.get('args', '')
+                for l in locations:
+                    loc = l['location'].get('arg', '')
+                    if loc and loc in args:
+                        used.add((l['server'].get('arg',''), loc))
+    # Те, что не используются
+    dead = []
+    for l in locations:
+        key = (l['server'].get('arg',''), l['location'].get('arg',''))
+        if key not in used:
+            dead.append(l)
+    return dead 

analyzer/include.py

@@ -0,0 +1,67 @@
+import os
+import glob
+from typing import List, Dict, Any, Set
+
+def build_include_tree(path: str, visited: Set[str]=None) -> Dict[str, Any]:
+    """
+    Строит дерево include-ов начиная с path. Возвращает dict: {file: [subincludes]}
+    """
+    if visited is None:
+        visited = set()
+    path = os.path.abspath(path)
+    if path in visited:
+        return {path: 'cycle'}
+    visited.add(path)
+    includes = []
+    try:
+        with open(path) as f:
+            lines = f.readlines()
+    except Exception:
+        return {path: 'not_found'}
+    for line in lines:
+        line = line.split('#', 1)[0].strip()
+        if line.startswith('include '):
+            pattern = line[len('include '):].rstrip(';').strip()
+            pattern = os.path.join(os.path.dirname(path), pattern) if not os.path.isabs(pattern) else pattern
+            for inc_path in glob.glob(pattern):
+                includes.append(build_include_tree(inc_path, visited.copy()))
+    return {path: includes}
+
+def find_include_cycles(tree: Dict[str, Any], stack=None) -> List[List[str]]:
+    """
+    Находит циклы include-ов в дереве. Возвращает список путей.
+    """
+    if stack is None:
+        stack = []
+    cycles = []
+    for k, v in tree.items():
+        if v == 'cycle':
+            cycles.append(stack + [k])
+        elif isinstance(v, list):
+            for sub in v:
+                if isinstance(sub, dict):
+                    cycles.extend(find_include_cycles(sub, stack + [k]))
+    return cycles
+
+def find_include_shadowing(tree: Dict[str, Any], directive: str) -> List[Dict[str, Any]]:
+    """
+    Находит переопределения директивы в разных include-ах.
+    Возвращает список: [{file, directive, value}]
+    """
+    found = []
+    def _walk(t):
+        for k, v in t.items():
+            if isinstance(v, list):
+                # Проверяем сам файл
+                try:
+                    with open(k) as f:
+                        for line in f:
+                            if line.strip().startswith(directive + ' '):
+                                found.append({'file': k, 'directive': directive, 'value': line.strip()})
+                except Exception:
+                    pass
+                for sub in v:
+                    if isinstance(sub, dict):
+                        _walk(sub)
+    _walk(tree)
+    return found 

analyzer/rewrite.py

@@ -0,0 +1,37 @@
+from analyzer.base import Analyzer
+from typing import List, Dict, Any
+import re
+
+def find_rewrite_issues(tree) -> List[Dict[str, Any]]:
+    """
+    Находит потенциальные проблемы с rewrite: циклы, конфликты, неэффективные правила.
+    Возвращает список: [{type, context, value}]
+    """
+    analyzer = Analyzer(tree)
+    issues = []
+    rewrites = []
+    for d, parent in analyzer.walk():
+        if d.get('directive') == 'rewrite':
+            args = d.get('args', '')
+            parts = args.split()
+            if len(parts) >= 2:
+                pattern, target = parts[0], parts[1]
+                rewrites.append({'pattern': pattern, 'target': target, 'context': parent, 'raw': args})
+    # Проверка на циклы (rewrite на себя)
+    for r in rewrites:
+        if r['pattern'] == r['target']:
+            issues.append({'type': 'rewrite_cycle', 'context': r['context'], 'value': r['raw']})
+    # Проверка на потенциальные конфликты (два одинаковых паттерна с разными target)
+    seen = {}
+    for r in rewrites:
+        key = r['pattern']
+        if key in seen and seen[key] != r['target']:
+            issues.append({'type': 'rewrite_conflict', 'context': r['context'], 'value': f"{key} -> {seen[key]} и {key} -> {r['target']}"})
+        seen[key] = r['target']
+    # Неэффективные rewrite (например, без break/last/redirect/permanent)
+    for d, parent in analyzer.walk():
+        if d.get('directive') == 'rewrite':
+            args = d.get('args', '')
+            if not re.search(r'\b(last|break|redirect|permanent)\b', args):
+                issues.append({'type': 'rewrite_no_flag', 'context': parent, 'value': args})
+    return issues 

analyzer/warnings.py

@@ -2,22 +2,112 @@ from analyzer.base import Analyzer
 from typing import List, Dict, Any
 import re
 
+# Список устаревших директив (пример)
+DEPRECATED_DIRECTIVES = {
+    'ssl': 'ssl директива устарела, используйте listen ... ssl',
+    'spdy': 'spdy устарел, используйте http2',
+    'ssl_session_cache': 'ssl_session_cache устарел в новых версиях',
+}
+
+# Список security-заголовков
+SECURITY_HEADERS = [
+    'X-Frame-Options',
+    'Strict-Transport-Security',
+    'X-Content-Type-Options',
+    'Referrer-Policy',
+    'Content-Security-Policy',
+]
+
+LIMITS = {
+    'client_max_body_size': {'min': 1024*1024, 'max': 1024*1024*100},  # 1M - 100M
+    'proxy_buffer_size': {'min': 4096, 'max': 1024*1024},             # 4K - 1M
+    'proxy_buffers': {'min': 2, 'max': 32},                           # 2-32
+    'proxy_busy_buffers_size': {'min': 4096, 'max': 1024*1024},       # 4K - 1M
+}
+
+def _parse_size(val):
+    # Преобразует строку типа 1m, 512k, 4096 в байты
+    val = val.strip().lower()
+    if val.endswith('k'):
+        return int(float(val[:-1]) * 1024)
+    if val.endswith('m'):
+        return int(float(val[:-1]) * 1024 * 1024)
+    try:
+        return int(val)
+    except Exception:
+        return None
+
 def find_warnings(tree) -> List[Dict[str, Any]]:
     """
-    Находит потенциально опасные или неочевидные директивы.
+    Находит потенциально опасные или неочевидные директивы и нарушения best practices.
     Возвращает список: [{type, directive, context, value}]
     """
     analyzer = Analyzer(tree)
     warnings = []
+    found_headers = set()
     for d, parent in analyzer.walk():
+        # proxy_pass без схемы
         if d.get('directive') == 'proxy_pass':
             val = d.get('args', '')
             if not re.match(r'^(http|https)://', val):
                 warnings.append({'type': 'proxy_pass_no_scheme', 'directive': 'proxy_pass', 'context': parent, 'value': val})
+        # autoindex on
         if d.get('directive') == 'autoindex' and d.get('args', '').strip() == 'on':
             warnings.append({'type': 'autoindex_on', 'directive': 'autoindex', 'context': parent, 'value': 'on'})
+        # if внутри блока
         if d.get('block') == 'if':
             warnings.append({'type': 'if_block', 'directive': 'if', 'context': parent, 'value': ''})
+        # server_tokens on
         if d.get('directive') == 'server_tokens' and d.get('args', '').strip() == 'on':
             warnings.append({'type': 'server_tokens_on', 'directive': 'server_tokens', 'context': parent, 'value': 'on'})
+        # ssl_certificate/ssl_certificate_key
+        if d.get('directive') == 'ssl_certificate' or d.get('directive') == 'ssl_certificate_key':
+            if not d.get('args', '').strip():
+                warnings.append({'type': 'ssl_missing', 'directive': d['directive'], 'context': parent, 'value': ''})
+        # ssl_protocols
+        if d.get('directive') == 'ssl_protocols':
+            val = d.get('args', '')
+            if 'TLSv1' in val or 'TLSv1.1' in val:
+                warnings.append({'type': 'ssl_protocols_weak', 'directive': 'ssl_protocols', 'context': parent, 'value': val})
+        # ssl_ciphers
+        if d.get('directive') == 'ssl_ciphers':
+            val = d.get('args', '')
+            if any(x in val for x in ['RC4', 'MD5', 'DES']):
+                warnings.append({'type': 'ssl_ciphers_weak', 'directive': 'ssl_ciphers', 'context': parent, 'value': val})
+        # listen 443 ssl
+        if d.get('directive') == 'listen' and '443' in d.get('args', '') and 'ssl' not in d.get('args', ''):
+            warnings.append({'type': 'listen_443_no_ssl', 'directive': 'listen', 'context': parent, 'value': d.get('args', '')})
+        # http2
+        if d.get('directive') == 'listen' and '443' in d.get('args', '') and 'http2' not in d.get('args', ''):
+            warnings.append({'type': 'listen_443_no_http2', 'directive': 'listen', 'context': parent, 'value': d.get('args', '')})
+        # limit_req/limit_conn
+        if d.get('block') == 'server':
+            has_limit = False
+            for sub, _ in analyzer.walk(d.get('directives', []), d):
+                if sub.get('directive') in ('limit_req', 'limit_conn'):
+                    has_limit = True
+            if not has_limit:
+                warnings.append({'type': 'no_limit_req_conn', 'directive': 'server', 'context': d, 'value': ''})
+        # Security headers
+        if d.get('directive') == 'add_header':
+            for h in SECURITY_HEADERS:
+                if h in d.get('args', ''):
+                    found_headers.add(h)
+        # Deprecated directives
+        if d.get('directive') in DEPRECATED_DIRECTIVES:
+            warnings.append({'type': 'deprecated', 'directive': d['directive'], 'context': parent, 'value': DEPRECATED_DIRECTIVES[d['directive']]})
+        # Проверка лимитов и буферов
+        for lim, rng in LIMITS.items():
+            if d.get('directive') == lim:
+                val = d.get('args', '').split()[0]
+                size = _parse_size(val)
+                if size is not None:
+                    if size < rng['min']:
+                        warnings.append({'type': 'limit_too_small', 'directive': lim, 'context': parent, 'value': val})
+                    if size > rng['max']:
+                        warnings.append({'type': 'limit_too_large', 'directive': lim, 'context': parent, 'value': val})
+    # Проверка отсутствующих security headers
+    for h in SECURITY_HEADERS:
+        if h not in found_headers:
+            warnings.append({'type': 'missing_security_header', 'directive': 'add_header', 'context': None, 'value': h})
     return warnings 

commands/analyze.py

@@ -1,12 +1,14 @@
 import typer
 from rich.console import Console
 from rich.table import Table
-from analyzer.conflicts import find_location_conflicts
+from analyzer.conflicts import find_location_conflicts, find_listen_servername_conflicts
 from analyzer.duplicates import find_duplicate_directives
 from analyzer.empty_blocks import find_empty_blocks
 from analyzer.warnings import find_warnings
 from analyzer.unused import find_unused_variables
 from parser.nginx_parser import parse_nginx_config
+from analyzer.rewrite import find_rewrite_issues
+from analyzer.dead_locations import find_dead_locations
 
 app = typer.Typer()
 console = Console()
@@ -21,6 +23,9 @@ def analyze(config_path: str = typer.Argument(..., help="Путь к nginx.conf"
     empties = find_empty_blocks(tree)
     warnings = find_warnings(tree)
     unused_vars = find_unused_variables(tree)
+    listen_conflicts = find_listen_servername_conflicts(tree)
+    rewrite_issues = find_rewrite_issues(tree)
+    dead_locations = find_dead_locations(tree)
 
     table = Table(show_header=True, header_style="bold blue")
     table.add_column("issue_type")
@@ -43,6 +48,12 @@ def analyze(config_path: str = typer.Argument(..., help="Путь к nginx.conf"
             table.add_row("server_tokens_on", f"server_tokens on в блоке {w['context'].get('block','')}")
     for v in unused_vars:
         table.add_row("unused_variable", v['name'])
+    for c in listen_conflicts:
+        table.add_row("listen_servername_conflict", f"server1: {c['server1'].get('arg','')} server2: {c['server2'].get('arg','')} listen: {','.join(c['listen'])} server_name: {','.join(c['server_name'])}")
+    for r in rewrite_issues:
+        table.add_row(r['type'], r['value'])
+    for l in dead_locations:
+        table.add_row("dead_location", f"server: {l['server'].get('arg','')} location: {l['location'].get('arg','')}")
 
     if table.row_count == 0:
         console.print("[green]Проблем не найдено[/green]")

commands/cli.py

@@ -5,6 +5,10 @@ from commands.analyze import analyze
 from commands.tree import tree
 from commands.diff import diff
 from commands.route import route
+from commands.include import include_tree
+from commands.graph import graph
+from commands.logs import app as logs_app
+from commands.syntax import app as syntax_app
 
 app = typer.Typer(help="nginx-lens — анализ и диагностика конфигураций Nginx")
 console = Console()
@@ -14,6 +18,10 @@ app.command()(analyze)
 app.command()(tree)
 app.command()(diff)
 app.command()(route)
+app.command()(include_tree)
+app.command()(graph)
+app.add_typer(logs_app, name="logs")
+app.add_typer(syntax_app, name="syntax")
 
 if __name__ == "__main__":
     app() 

commands/graph.py

@@ -0,0 +1,22 @@
+import typer
+from rich.console import Console
+from parser.nginx_parser import parse_nginx_config
+from exporter.graph import tree_to_dot, tree_to_mermaid
+
+app = typer.Typer()
+console = Console()
+
+def graph(
+    config_path: str = typer.Argument(..., help="Путь к nginx.conf"),
+    format: str = typer.Option("dot", help="Формат: dot или mermaid")
+):
+    """
+    Генерирует схему маршрутизации nginx (dot/mermaid).
+    """
+    tree = parse_nginx_config(config_path)
+    if format == "dot":
+        console.print(tree_to_dot(tree.directives))
+    elif format == "mermaid":
+        console.print(tree_to_mermaid(tree.directives))
+    else:
+        console.print("[red]Неизвестный формат: выберите dot или mermaid[/red]") 

commands/health.py

@@ -1,5 +1,6 @@
 import typer
 from rich.console import Console
+from rich.table import Table
 from upstream_checker.checker import check_upstreams
 from parser.nginx_parser import parse_nginx_config
 
@@ -12,13 +13,17 @@ def health(
     retries: int = typer.Option(1, help="Количество попыток")
 ):
     """
-    Проверяет доступность upstream-серверов, определённых в nginx.conf.
+    Проверяет доступность upstream-серверов, определённых в nginx.conf. Выводит таблицу.
     """
     tree = parse_nginx_config(config_path)
     upstreams = tree.get_upstreams()
     results = check_upstreams(upstreams, timeout=timeout, retries=retries)
+    table = Table(show_header=True, header_style="bold blue")
+    table.add_column("upstream_name")
+    table.add_column("upstream_status")
     for name, servers in results.items():
-        console.print(f"[bold]{name}[/bold]")
         for srv in servers:
-            status = "[green]Healthy ✅[/green]" if srv["healthy"] else "[red]Unhealthy ❌[/red]"
-            console.print(f"  {srv['address']} {status}") 
+            status = "Healthy" if srv["healthy"] else "Unhealthy"
+            color = "green" if srv["healthy"] else "red"
+            table.add_row(srv["address"], f"[{color}]{status}[/{color}]")
+    console.print(table) 

commands/include.py

@@ -0,0 +1,47 @@
+import typer
+from rich.console import Console
+from rich.tree import Tree
+from rich.table import Table
+from analyzer.include import build_include_tree, find_include_cycles, find_include_shadowing
+
+app = typer.Typer()
+console = Console()
+
+def include_tree(
+    config_path: str = typer.Argument(..., help="Путь к nginx.conf"),
+    directive: str = typer.Option(None, help="Показать shadowing для директивы (например, server_name)")
+):
+    """
+    Показывает дерево include-ов, циклы и shadowing директив.
+    """
+    tree = build_include_tree(config_path)
+    rich_tree = Tree(f"[bold blue]{config_path}[/bold blue]")
+    def _add(node, t):
+        for k, v in t.items():
+            if v == 'cycle':
+                node.add(f"[red]{k} (cycle)[/red]")
+            elif v == 'not_found':
+                node.add(f"[yellow]{k} (not found)[/yellow]")
+            elif isinstance(v, list):
+                sub = node.add(f"{k}")
+                for sub_t in v:
+                    if isinstance(sub_t, dict):
+                        _add(sub, sub_t)
+    _add(rich_tree, tree)
+    console.print(rich_tree)
+    # Циклы
+    cycles = find_include_cycles(tree)
+    if cycles:
+        console.print("[red]Обнаружены циклы include-ов:[/red]")
+        for c in cycles:
+            console.print(" -> ".join(c))
+    # Shadowing
+    if directive:
+        shadow = find_include_shadowing(tree, directive)
+        if shadow:
+            table = Table(show_header=True, header_style="bold blue")
+            table.add_column("file")
+            table.add_column("value")
+            for s in shadow:
+                table.add_row(s['file'], s['value'])
+            console.print(table) 

commands/logs.py

@@ -0,0 +1,80 @@
+import typer
+from rich.console import Console
+from rich.table import Table
+import re
+from collections import Counter, defaultdict
+
+app = typer.Typer()
+console = Console()
+
+log_line_re = re.compile(r'(?P<ip>\S+) \S+ \S+ \[(?P<time>[^\]]+)\] "(?P<method>\S+) (?P<path>\S+) [^\"]+" (?P<status>\d{3})')
+
+@app.command()
+def logs(
+    log_path: str = typer.Argument(..., help="Путь к access.log или error.log"),
+    top: int = typer.Option(10, help="Сколько топ-значений выводить")
+):
+    """
+    Анализирует access.log/error.log: топ-404, топ-500, частые запросы, подозрительные user-agent, IP.
+    """
+    status_counter = Counter()
+    path_counter = Counter()
+    ip_counter = Counter()
+    user_agent_counter = Counter()
+    errors = defaultdict(list)
+    with open(log_path) as f:
+        for line in f:
+            m = log_line_re.search(line)
+            if m:
+                ip = m.group('ip')
+                path = m.group('path')
+                status = m.group('status')
+                status_counter[status] += 1
+                path_counter[path] += 1
+                ip_counter[ip] += 1
+                if status.startswith('4') or status.startswith('5'):
+                    errors[status].append(path)
+            # user-agent (если есть)
+            if '" "' in line:
+                ua = line.rsplit('" "', 1)[-1].strip().strip('"')
+                if ua:
+                    user_agent_counter[ua] += 1
+    # Топ статусов
+    table = Table(title="Top HTTP Status Codes", show_header=True, header_style="bold blue")
+    table.add_column("Status")
+    table.add_column("Count")
+    for status, count in status_counter.most_common(top):
+        table.add_row(status, str(count))
+    console.print(table)
+    # Топ путей
+    table = Table(title="Top Paths", show_header=True, header_style="bold blue")
+    table.add_column("Path")
+    table.add_column("Count")
+    for path, count in path_counter.most_common(top):
+        table.add_row(path, str(count))
+    console.print(table)
+    # Топ IP
+    table = Table(title="Top IPs", show_header=True, header_style="bold blue")
+    table.add_column("IP")
+    table.add_column("Count")
+    for ip, count in ip_counter.most_common(top):
+        table.add_row(ip, str(count))
+    console.print(table)
+    # Топ User-Agent
+    if user_agent_counter:
+        table = Table(title="Top User-Agents", show_header=True, header_style="bold blue")
+        table.add_column("User-Agent")
+        table.add_column("Count")
+        for ua, count in user_agent_counter.most_common(top):
+            table.add_row(ua, str(count))
+        console.print(table)
+    # Топ 404/500
+    for err in ('404', '500'):
+        if errors[err]:
+            table = Table(title=f"Top {err} Paths", show_header=True, header_style="bold blue")
+            table.add_column("Path")
+            table.add_column("Count")
+            c = Counter(errors[err])
+            for path, count in c.most_common(top):
+                table.add_row(path, str(count))
+            console.print(table) 

commands/route.py

@@ -1,43 +1,30 @@
 import typer
 from rich.console import Console
-from rich.table import Table
+from rich.panel import Panel
 from analyzer.route import find_route
 from parser.nginx_parser import parse_nginx_config
-from upstream_checker.checker import check_upstreams
 
 app = typer.Typer()
 console = Console()
 
 def route(
     config_path: str = typer.Argument(..., help="Путь к nginx.conf"),
-    url: str = typer.Argument(..., help="URL для маршрутизации (например, http://host/path)"),
-    timeout: float = typer.Option(2.0, help="Таймаут проверки (сек)"),
-    retries: int = typer.Option(1, help="Количество попыток")
+    url: str = typer.Argument(..., help="URL для маршрутизации (например, http://host/path)")
 ):
     """
-    Показывает, какой server/location обслуживает указанный URL и статус upstream-ов (таблица).
+    Показывает, какой server/location обслуживает указанный URL.
     """
     tree = parse_nginx_config(config_path)
     res = find_route(tree, url)
     if not res:
-        console.print("[red]Не найден подходящий server для {url}[/red]")
+        console.print(Panel(f"Не найден подходящий server для {url}", style="red"))
         return
     server = res['server']
     location = res['location']
     proxy_pass = res['proxy_pass']
-    table = Table(show_header=True, header_style="bold blue")
-    table.add_column("upstream_name")
-    table.add_column("upstream_status")
-    # Проверяем upstream если есть proxy_pass
+    text = f"[bold]Server:[/bold] {server.get('arg','') or '[no arg]'}\n"
+    if location:
+        text += f"[bold]Location:[/bold] {location.get('arg','')}\n"
     if proxy_pass:
-        upstreams = tree.get_upstreams()
-        for name, servers in upstreams.items():
-            if name in proxy_pass:
-                results = check_upstreams({name: servers}, timeout=timeout, retries=retries)
-                for srv in results[name]:
-                    status = "Healthy" if srv["healthy"] else "Unhealthy"
-                    color = "green" if srv["healthy"] else "red"
-                    table.add_row(srv["address"], f"[{color}]{status}[/{color}]")
-    else:
-        table.add_row("-", "-")
-    console.print(table) 
+        text += f"[bold]proxy_pass:[/bold] {proxy_pass}\n"
+    console.print(Panel(text, title="Route", style="green")) 

commands/syntax.py

@@ -0,0 +1,57 @@
+import typer
+from rich.console import Console
+from rich.table import Table
+import subprocess
+import os
+import re
+
+app = typer.Typer()
+console = Console()
+
+ERROR_RE = re.compile(r'in (.+?):(\d+)')
+
+@app.command()
+def syntax(
+    config_path: str = typer.Argument(..., help="Путь к nginx.conf"),
+    nginx_path: str = typer.Option("nginx", help="Путь к бинарю nginx (по умолчанию 'nginx')")
+):
+    """
+    Проверяет синтаксис nginx-конфига через nginx -t. В случае ошибки показывает место в виде таблицы.
+    """
+    cmd = [nginx_path, "-t", "-c", os.path.abspath(config_path)]
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=False)
+        if result.returncode == 0:
+            console.print("[green]Синтаксис nginx-конфига корректен[/green]")
+        else:
+            console.print("[red]Ошибка синтаксиса![/red]")
+        console.print(result.stdout)
+        console.print(result.stderr)
+        # Парсим ошибку
+        err = result.stderr or result.stdout
+        m = ERROR_RE.search(err)
+        if m:
+            file, line = m.group(1), int(m.group(2))
+            msg = err.strip().split('\n')[-1]
+            # Читаем контекст
+            context = []
+            try:
+                with open(file) as f:
+                    lines = f.readlines()
+                start = max(0, line-3)
+                end = min(len(lines), line+2)
+                for i in range(start, end):
+                    mark = "->" if i+1 == line else "  "
+                    context.append((str(i+1), mark, lines[i].rstrip()))
+            except Exception:
+                context = []
+            table = Table(title="Ошибка синтаксиса", show_header=True, header_style="bold red")
+            table.add_column("File")
+            table.add_column("Line")
+            table.add_column("Message")
+            table.add_column("Context")
+            for ln, mark, code in context:
+                table.add_row(file, ln, msg if mark == "->" else "", f"{mark} {code}")
+            console.print(table)
+    except FileNotFoundError:
+        console.print(f"[red]Не найден бинарь nginx: {nginx_path}[/red]") 

exporter/graph.py

@@ -0,0 +1,84 @@
+from typing import List
+
+def tree_to_dot(directives) -> str:
+    lines = ["digraph nginx {", "  rankdir=LR;"]
+    node_id = 0
+    def node(label):
+        nonlocal node_id
+        node_id += 1
+        return f"n{node_id}", label
+    def walk(dirs, parent_id=None):
+        for d in dirs:
+            if 'block' in d and d['block'] == 'server':
+                nid, label = node(f"server {d.get('arg','')}")
+                lines.append(f'  {nid} [label="{label}", shape=box, style=filled, fillcolor=lightblue];')
+                if parent_id:
+                    lines.append(f'  {parent_id} -> {nid};')
+                walk(d.get('directives', []), nid)
+            elif 'block' in d and d['block'] == 'location':
+                nid, label = node(f"location {d.get('arg','')}")
+                lines.append(f'  {nid} [label="{label}", shape=ellipse, style=filled, fillcolor=lightyellow];')
+                if parent_id:
+                    lines.append(f'  {parent_id} -> {nid};')
+                walk(d.get('directives', []), nid)
+            elif 'upstream' in d:
+                nid, label = node(f"upstream {d['upstream']}")
+                lines.append(f'  {nid} [label="{label}", shape=diamond, style=filled, fillcolor=lightgreen];')
+                if parent_id:
+                    lines.append(f'  {parent_id} -> {nid};')
+                for srv in d.get('servers', []):
+                    sid, slabel = node(f"server {srv}")
+                    lines.append(f'  {sid} [label="{slabel}", shape=note];')
+                    lines.append(f'  {nid} -> {sid};')
+            elif 'directive' in d and d['directive'] == 'proxy_pass':
+                nid, label = node(f"proxy_pass {d.get('args','')}")
+                lines.append(f'  {nid} [label="{label}", shape=parallelogram, style=filled, fillcolor=orange];')
+                if parent_id:
+                    lines.append(f'  {parent_id} -> {nid};')
+    walk(directives)
+    lines.append("}")
+    return '\n'.join(lines)
+
+def tree_to_mermaid(directives) -> str:
+    lines = ["graph LR"]
+    node_id = 0
+    def node(label):
+        nonlocal node_id
+        node_id += 1
+        return f"n{node_id}", label
+    def walk(dirs, parent_id=None):
+        for d in dirs:
+            if 'block' in d and d['block'] == 'server':
+                nid, label = node(f"server {d.get('arg','')}")
+                lines.append(f'{nid}["{label}"]:::server')
+                if parent_id:
+                    lines.append(f'{parent_id} --> {nid}')
+                walk(d.get('directives', []), nid)
+            elif 'block' in d and d['block'] == 'location':
+                nid, label = node(f"location {d.get('arg','')}")
+                lines.append(f'{nid}["{label}"]:::location')
+                if parent_id:
+                    lines.append(f'{parent_id} --> {nid}')
+                walk(d.get('directives', []), nid)
+            elif 'upstream' in d:
+                nid, label = node(f"upstream {d['upstream']}")
+                lines.append(f'{nid}["{label}"]:::upstream')
+                if parent_id:
+                    lines.append(f'{parent_id} --> {nid}')
+                for srv in d.get('servers', []):
+                    sid, slabel = node(f"server {srv}")
+                    lines.append(f'{sid}["{slabel}"]:::srv')
+                    lines.append(f'{nid} --> {sid}')
+            elif 'directive' in d and d['directive'] == 'proxy_pass':
+                nid, label = node(f"proxy_pass {d.get('args','')}")
+                lines.append(f'{nid}["{label}"]:::proxy')
+                if parent_id:
+                    lines.append(f'{parent_id} --> {nid}')
+    walk(directives)
+    # Стили
+    lines.append("classDef server fill:#b3e0ff,stroke:#333;")
+    lines.append("classDef location fill:#fff2b3,stroke:#333;")
+    lines.append("classDef upstream fill:#b3ffb3,stroke:#333;")
+    lines.append("classDef proxy fill:#ffd699,stroke:#333;")
+    lines.append("classDef srv fill:#eee,stroke:#333;")
+    return '\n'.join(lines) 

{nginx_lens-0.1.1.dist-info → nginx_lens-0.1.2.dist-info}/METADATA

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

nginx_lens-0.1.2.dist-info/RECORD

@@ -0,0 +1,36 @@
+analyzer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+analyzer/base.py,sha256=oGKg78BfMVmuzYafc08oq9p31-jEgYolGjLkUcIdkN8,607
+analyzer/conflicts.py,sha256=NSNZc8e2x51K41dflSUvuwlDq-rzBXU5ITi6WfxFbfU,2796
+analyzer/dead_locations.py,sha256=uvMu5qBGTVi0Nn960x3WpRvTljGbQuVFivU4nfe36oY,1435
+analyzer/diff.py,sha256=idvXnoLzBVUYgKi_s3uDu0v2GNMV3B8aDqTROXcdQdo,1749
+analyzer/duplicates.py,sha256=VUjbM19Y_Wwty8GEOu_7nNzOH6mr071p_z1MAkp1kBA,1012
+analyzer/empty_blocks.py,sha256=7Zu4-5I5PS3bjhH0Ppq1CvM7rMTeRIc4fHx5n5vkMIw,517
+analyzer/include.py,sha256=FhKR4VsogLknykjLD2N8jX9OtwxZcWik5oPpvp-_luE,2465
+analyzer/rewrite.py,sha256=-jSLLG1jqmGU-dXWvU6NHCW6muB8Lfro6fXX1tDCHCQ,1834
+analyzer/route.py,sha256=2xxQooQEsfn10tzGCZUoP32T0OnTMnPB6qRgBR6not8,2345
+analyzer/unused.py,sha256=Ixzv0bPsw9IafblVwLiAOgugdg2dGu1MJDtuoqzPZiY,1066
+analyzer/warnings.py,sha256=zC36QMvegA2eQPvZ-P1eysrX_kXHx5A1MUKHKKNvG5c,5784
+commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+commands/analyze.py,sha256=adkc0K2VSFp4jLZQFuj_WwuBZdJkEGi0uvZyVf00EMg,3104
+commands/cli.py,sha256=0uzz71nMXTGlY1odZkEGwtVOjf7uq7762qRLXQaQURo,780
+commands/diff.py,sha256=BqrBzZJcD7XJWU0HdNos31yANvbwEWR1ZHaVowCoeV0,1282
+commands/graph.py,sha256=0_Iastpx7X8ygVsN4KUwiSIm2UCPLgm1yOq75furYJk,787
+commands/health.py,sha256=gmqeno-tADqIjO-y-LUlWhy2Nsm-K77GK5xaPV98V9w,1226
+commands/include.py,sha256=30bPFwZusvsCNjp7U2fgS9h9wWbSQlZFB6eCwzvWwok,1756
+commands/logs.py,sha256=chfwgO4KaClor_ySs_QkJ7M7q3V-5ahKFhyd5K8GOik,3128
+commands/route.py,sha256=jqGKRcocjNhGAN6LQ1PvqcNaNKG_Nn437l9ZeHaD-FA,1132
+commands/syntax.py,sha256=rABFjTHhJIumdTXSEzNlJNypZxfbXpmPlwSHkiAP7S0,2322
+commands/tree.py,sha256=H8kFYueo6mcN82MSgIzAH6Usq9u7sYo2WlY0p8rlN_A,1669
+exporter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+exporter/graph.py,sha256=WYUrqUgCaK6KihgxAcRHaQn4oMo6b7ybC8yb_36ZIsA,3995
+exporter/html.py,sha256=uquEM-WvBt2aV9GshgaI3UVhYd8sD0QQ-OmuNtvYUdU,798
+exporter/markdown.py,sha256=_0mXQIhurGEZ0dO-eq9DbsuKNrgEDIblgtL3DAgYNo8,724
+parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+parser/nginx_parser.py,sha256=JqZ3clNy4Nf-bmbsx_rJUL7EgRoB79b87eEu_isMeqg,3577
+upstream_checker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+upstream_checker/checker.py,sha256=9-6CMUTN7gXUACP8EwX722QogfujZyV-WWWUeM3a79k,455
+nginx_lens-0.1.2.dist-info/METADATA,sha256=pRmzXAm457F0Ed7-4KY8TH9JkOWue0Zm_PdOcvyHxOE,476
+nginx_lens-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nginx_lens-0.1.2.dist-info/entry_points.txt,sha256=qEcecjSyLqcJjbIVlNlTpqAhPqDyaujUV5ZcBTAr3po,48
+nginx_lens-0.1.2.dist-info/top_level.txt,sha256=mxLJO4rZg0rbixVGhplF3fUNFs8vxDIL25ronZNvRy4,51
+nginx_lens-0.1.2.dist-info/RECORD,,

nginx_lens-0.1.1.dist-info/RECORD

@@ -1,28 +0,0 @@
-analyzer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-analyzer/base.py,sha256=oGKg78BfMVmuzYafc08oq9p31-jEgYolGjLkUcIdkN8,607
-analyzer/conflicts.py,sha256=2h8CyipWo5-81C_RYAiL2XaNZ2HYO8LHDIt5KEcser0,1398
-analyzer/diff.py,sha256=idvXnoLzBVUYgKi_s3uDu0v2GNMV3B8aDqTROXcdQdo,1749
-analyzer/duplicates.py,sha256=VUjbM19Y_Wwty8GEOu_7nNzOH6mr071p_z1MAkp1kBA,1012
-analyzer/empty_blocks.py,sha256=7Zu4-5I5PS3bjhH0Ppq1CvM7rMTeRIc4fHx5n5vkMIw,517
-analyzer/route.py,sha256=2xxQooQEsfn10tzGCZUoP32T0OnTMnPB6qRgBR6not8,2345
-analyzer/unused.py,sha256=Ixzv0bPsw9IafblVwLiAOgugdg2dGu1MJDtuoqzPZiY,1066
-analyzer/warnings.py,sha256=eg50TfbE1pJBR6fGUEByqKm5Km1AQBiIy284DOidacI,1244
-commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-commands/analyze.py,sha256=rEOM2h8Ds3S4kcrT5ZPxj6pki912xkihycybJGcERbg,2350
-commands/cli.py,sha256=A47d3vdTDPHRZlRKs02PtxOFdPHjecpXTZyGhQ34r_w,490
-commands/diff.py,sha256=BqrBzZJcD7XJWU0HdNos31yANvbwEWR1ZHaVowCoeV0,1282
-commands/health.py,sha256=2QdjIVattoaksW7BrjM2_vqqB18_t7ILeBvKVjaxTdM,1008
-commands/route.py,sha256=wiNkovPBPnpMau6sWQryOPaP5D8TFOT3s4Ua3XwplLg,1861
-commands/tree.py,sha256=H8kFYueo6mcN82MSgIzAH6Usq9u7sYo2WlY0p8rlN_A,1669
-exporter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-exporter/html.py,sha256=uquEM-WvBt2aV9GshgaI3UVhYd8sD0QQ-OmuNtvYUdU,798
-exporter/markdown.py,sha256=_0mXQIhurGEZ0dO-eq9DbsuKNrgEDIblgtL3DAgYNo8,724
-parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-parser/nginx_parser.py,sha256=JqZ3clNy4Nf-bmbsx_rJUL7EgRoB79b87eEu_isMeqg,3577
-upstream_checker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-upstream_checker/checker.py,sha256=9-6CMUTN7gXUACP8EwX722QogfujZyV-WWWUeM3a79k,455
-nginx_lens-0.1.1.dist-info/METADATA,sha256=kyCiTNE9IVC5AO9ZVrBQN5xRmCbkOndGz3ofO0R3zlE,476
-nginx_lens-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nginx_lens-0.1.1.dist-info/entry_points.txt,sha256=qEcecjSyLqcJjbIVlNlTpqAhPqDyaujUV5ZcBTAr3po,48
-nginx_lens-0.1.1.dist-info/top_level.txt,sha256=mxLJO4rZg0rbixVGhplF3fUNFs8vxDIL25ronZNvRy4,51
-nginx_lens-0.1.1.dist-info/RECORD,,