nginx-lens 0.1.0__py3-none-any.whl

analyzer/base.py

@@ -0,0 +1,18 @@
+from typing import Any, List, Dict
+
+class Analyzer:
+    def __init__(self, tree):
+        self.tree = tree
+        self.directives = tree.directives
+
+    def walk(self, directives=None, parent=None):
+        """
+        Рекурсивно обходит дерево директив.
+        Возвращает генератор (директива, родитель).
+        """
+        if directives is None:
+            directives = self.directives
+        for d in directives:
+            yield d, parent
+            if 'directives' in d:
+                yield from self.walk(d['directives'], d) 

analyzer/conflicts.py

@@ -0,0 +1,33 @@
+from analyzer.base import Analyzer
+from typing import List, Dict, Any
+import re
+
+def find_location_conflicts(tree) -> List[Dict[str, Any]]:
+    """
+    Находит пересекающиеся location-ы внутри одного server-блока.
+    Возвращает список конфликтов: [{server, location1, location2}]
+    """
+    analyzer = Analyzer(tree)
+    conflicts = []
+    for d, parent in analyzer.walk():
+        if d.get('block') == 'server':
+            locations = []
+            for sub, _ in analyzer.walk(d['directives'], d):
+                if sub.get('block') == 'location':
+                    arg = sub.get('arg')
+                    if arg:
+                        locations.append(arg)
+            # Проверяем пересечения
+            for i in range(len(locations)):
+                for j in range(i+1, len(locations)):
+                    if _locations_conflict(locations[i], locations[j]):
+                        conflicts.append({
+                            'server': d,
+                            'location1': locations[i],
+                            'location2': locations[j]
+                        })
+    return conflicts
+
+def _locations_conflict(loc1, loc2):
+    # Простая эвристика: если один путь — префикс другого
+    return loc1.startswith(loc2) or loc2.startswith(loc1) 

analyzer/diff.py

@@ -0,0 +1,40 @@
+from typing import List, Dict, Any
+
+def diff_trees(tree1, tree2) -> List[Dict[str, Any]]:
+    """
+    Сравнивает два дерева директив. Возвращает список отличий.
+    Формат: [{type, path, value1, value2}]
+    type: 'added', 'removed', 'changed'
+    path: путь до директивы (например, ['http', 'server', 'location /api'])
+    """
+    diffs = []
+    _diff_blocks(tree1.directives, tree2.directives, [], diffs)
+    return diffs
+
+def _diff_blocks(d1, d2, path, diffs):
+    # Индексируем по (block,arg) или (directive,args) или (upstream)
+    def key(d):
+        if 'block' in d:
+            return ('block', d['block'], d.get('arg'))
+        if 'directive' in d:
+            return ('directive', d['directive'], d.get('args'))
+        if 'upstream' in d:
+            return ('upstream', d['upstream'])
+        return ('other', str(d))
+    map1 = {key(x): x for x in d1}
+    map2 = {key(x): x for x in d2}
+    all_keys = set(map1) | set(map2)
+    for k in all_keys:
+        v1 = map1.get(k)
+        v2 = map2.get(k)
+        p = path + [k[1] if k[0] != 'directive' else f"{k[1]} {k[2] or ''}".strip()]
+        if v1 and not v2:
+            diffs.append({'type': 'removed', 'path': p, 'value1': v1, 'value2': None})
+        elif v2 and not v1:
+            diffs.append({'type': 'added', 'path': p, 'value1': None, 'value2': v2})
+        else:
+            # Рекурсивно сравниваем блоки
+            if 'directives' in v1 and 'directives' in v2:
+                _diff_blocks(v1['directives'], v2['directives'], p, diffs)
+            elif v1 != v2:
+                diffs.append({'type': 'changed', 'path': p, 'value1': v1, 'value2': v2}) 

analyzer/duplicates.py

@@ -0,0 +1,26 @@
+from analyzer.base import Analyzer
+from typing import List, Dict, Any
+
+def find_duplicate_directives(tree) -> List[Dict[str, Any]]:
+    """
+    Находит дублирующиеся директивы внутри одного блока.
+    Возвращает список: [{block, directive, count}]
+    """
+    analyzer = Analyzer(tree)
+    duplicates = []
+    for d, parent in analyzer.walk():
+        if 'directives' in d:
+            seen = {}
+            for sub, _ in analyzer.walk(d['directives'], d):
+                if 'directive' in sub:
+                    key = (sub['directive'], str(sub.get('args')))
+                    seen[key] = seen.get(key, 0) + 1
+            for (directive, args), count in seen.items():
+                if count > 1:
+                    duplicates.append({
+                        'block': d,
+                        'directive': directive,
+                        'args': args,
+                        'count': count
+                    })
+    return duplicates 

analyzer/empty_blocks.py

@@ -0,0 +1,14 @@
+from analyzer.base import Analyzer
+from typing import List, Dict, Any
+
+def find_empty_blocks(tree) -> List[Dict[str, Any]]:
+    """
+    Находит пустые блоки (без вложенных директив).
+    Возвращает список: [{block, arg}]
+    """
+    analyzer = Analyzer(tree)
+    empties = []
+    for d, parent in analyzer.walk():
+        if 'block' in d and (not d.get('directives')):
+            empties.append({'block': d.get('block'), 'arg': d.get('arg')})
+    return empties 

analyzer/route.py

@@ -0,0 +1,60 @@
+from urllib.parse import urlparse
+from analyzer.base import Analyzer
+from typing import Dict, Any, Optional
+import re
+
+def find_route(tree, url: str) -> Optional[Dict[str, Any]]:
+    """
+    Находит server и location, которые обслуживают данный URL.
+    Возвращает: {'server': ..., 'location': ..., 'proxy_pass': ...}
+    """
+    parsed = urlparse(url)
+    host = parsed.hostname
+    port = str(parsed.port or (443 if parsed.scheme == 'https' else 80))
+    path = parsed.path or '/'
+    analyzer = Analyzer(tree)
+    best_server = None
+    best_server_score = -1
+    # 1. Ищем подходящий server
+    for d, _ in analyzer.walk():
+        if d.get('block') == 'server':
+            names = []
+            listens = []
+            for sub, _ in analyzer.walk(d['directives'], d):
+                if sub.get('directive') == 'server_name':
+                    names += sub.get('args', '').split()
+                if sub.get('directive') == 'listen':
+                    listens.append(sub.get('args', ''))
+            score = 0
+            if host and any(_host_match(host, n) for n in names):
+                score += 2
+            if port and any(port in l for l in listens):
+                score += 1
+            if score > best_server_score:
+                best_server = d
+                best_server_score = score
+    if not best_server:
+        return None
+    # 2. Внутри server ищем лучший location (longest prefix match)
+    best_loc = None
+    best_len = -1
+    proxy_pass = None
+    for sub, _ in analyzer.walk(best_server['directives'], best_server):
+        if sub.get('block') == 'location':
+            loc = sub.get('arg', '')
+            if path.startswith(loc) and len(loc) > best_len:
+                best_loc = sub
+                best_len = len(loc)
+    if best_loc:
+        for d, _ in analyzer.walk(best_loc.get('directives', []), best_loc):
+            if d.get('directive') == 'proxy_pass':
+                proxy_pass = d.get('args')
+    return {'server': best_server, 'location': best_loc, 'proxy_pass': proxy_pass}
+
+def _host_match(host, pattern):
+    # Примитивная поддержка wildcard
+    if pattern == '_':
+        return True
+    if pattern.startswith('*.'):
+        return host.endswith(pattern[1:])
+    return host == pattern 

analyzer/unused.py

@@ -0,0 +1,29 @@
+from analyzer.base import Analyzer
+from typing import List, Dict, Any
+import re
+
+def find_unused_variables(tree) -> List[Dict[str, Any]]:
+    """
+    Находит переменные, определённые через set/map, которые не используются.
+    Возвращает список: [{name, context}]
+    """
+    analyzer = Analyzer(tree)
+    defined = set()
+    used = set()
+    for d, parent in analyzer.walk():
+        if d.get('directive') == 'set':
+            parts = d.get('args', '').split()
+            if parts:
+                defined.add(parts[0])
+        if d.get('directive') == 'map':
+            parts = d.get('args', '').split()
+            if parts:
+                defined.add(parts[0])
+        # Ищем использование $var в любых аргументах
+        for v in re.findall(r'\$[a-zA-Z0-9_]+', str(d.get('args',''))):
+            used.add(v)
+    unused = []
+    for var in defined:
+        if var not in used:
+            unused.append({'name': var, 'context': None})
+    return unused 

analyzer/warnings.py

@@ -0,0 +1,23 @@
+from analyzer.base import Analyzer
+from typing import List, Dict, Any
+import re
+
+def find_warnings(tree) -> List[Dict[str, Any]]:
+    """
+    Находит потенциально опасные или неочевидные директивы.
+    Возвращает список: [{type, directive, context, value}]
+    """
+    analyzer = Analyzer(tree)
+    warnings = []
+    for d, parent in analyzer.walk():
+        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})
+        if d.get('directive') == 'autoindex' and d.get('args', '').strip() == 'on':
+            warnings.append({'type': 'autoindex_on', 'directive': 'autoindex', 'context': parent, 'value': 'on'})
+        if d.get('block') == 'if':
+            warnings.append({'type': 'if_block', 'directive': 'if', 'context': parent, 'value': ''})
+        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'})
+    return warnings 

commands/analyze.py

@@ -0,0 +1,70 @@
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.tree import Tree
+from analyzer.conflicts import find_location_conflicts
+from analyzer.duplicates import find_duplicate_directives
+from analyzer.empty_blocks import find_empty_blocks
+from parser.nginx_parser import parse_nginx_config
+from analyzer.warnings import find_warnings
+from analyzer.unused import find_unused_variables
+
+app = typer.Typer()
+console = Console()
+
+def analyze(config_path: str = typer.Argument(..., help="Путь к nginx.conf")):
+    """
+    Анализирует конфигурацию Nginx на типовые проблемы.
+    """
+    tree = parse_nginx_config(config_path)
+    conflicts = find_location_conflicts(tree)
+    dups = find_duplicate_directives(tree)
+    empties = find_empty_blocks(tree)
+    warnings = find_warnings(tree)
+    unused_vars = find_unused_variables(tree)
+
+    root = Tree("[bold blue]Анализ конфигурации Nginx[/bold blue]")
+
+    if conflicts:
+        node = root.add("[red]Конфликты location-ов[/red]")
+        for c in conflicts:
+            node.add(f"[yellow]server[/yellow]: {c['server'].get('arg', '')} [magenta]location[/magenta]: [bold]{c['location1']}[/bold] ↔ [bold]{c['location2']}[/bold]")
+    else:
+        root.add("[green]Нет конфликтов location-ов[/green]")
+
+    if dups:
+        node = root.add("[red]Дублирующиеся директивы[/red]")
+        for d in dups:
+            node.add(f"[yellow]{d['directive']}[/yellow] ([italic]{d['args']}[/italic]) — {d['count']} раз в блоке [cyan]{d['block'].get('block', d['block'])}[/cyan]")
+    else:
+        root.add("[green]Нет дублирующихся директив[/green]")
+
+    if empties:
+        node = root.add("[red]Пустые блоки[/red]")
+        for e in empties:
+            node.add(f"[yellow]{e['block']}[/yellow] [italic]{e['arg'] or ''}[/italic]")
+    else:
+        root.add("[green]Нет пустых блоков[/green]")
+
+    if warnings:
+        node = root.add("[bold yellow]Потенциальные проблемы[/bold yellow]")
+        for w in warnings:
+            if w['type'] == 'proxy_pass_no_scheme':
+                node.add(f"[yellow]proxy_pass[/yellow] без схемы: [italic]{w['value']}[/italic]")
+            elif w['type'] == 'autoindex_on':
+                node.add(f"[yellow]autoindex on[/yellow] в блоке [cyan]{w['context'].get('block','')}[/cyan]")
+            elif w['type'] == 'if_block':
+                node.add(f"[yellow]Директива if[/yellow] внутри блока [cyan]{w['context'].get('block','')}[/cyan]")
+            elif w['type'] == 'server_tokens_on':
+                node.add(f"[yellow]server_tokens on[/yellow] в блоке [cyan]{w['context'].get('block','')}[/cyan]")
+    else:
+        root.add("[green]Нет потенциальных проблем[/green]")
+
+    if unused_vars:
+        node = root.add("[bold magenta]Неиспользуемые переменные[/bold magenta]")
+        for v in unused_vars:
+            node.add(f"[magenta]{v['name']}[/magenta]")
+    else:
+        root.add("[green]Нет неиспользуемых переменных[/green]")
+
+    console.print(root) 

commands/cli.py

@@ -0,0 +1,19 @@
+import typer
+from rich.console import Console
+from commands.health import health
+from commands.analyze import analyze
+from commands.tree import tree
+from commands.diff import diff
+from commands.route import route
+
+app = typer.Typer(help="nginx-lens — анализ и диагностика конфигураций Nginx")
+console = Console()
+
+app.command()(health)
+app.command()(analyze)
+app.command()(tree)
+app.command()(diff)
+app.command()(route)
+
+if __name__ == "__main__":
+    app() 

commands/diff.py

@@ -0,0 +1,35 @@
+import typer
+from rich.console import Console
+from rich.tree import Tree
+from rich.text import Text
+from analyzer.diff import diff_trees
+from parser.nginx_parser import parse_nginx_config
+
+app = typer.Typer()
+console = Console()
+
+def diff(
+    config1: str = typer.Argument(..., help="Первый nginx.conf"),
+    config2: str = typer.Argument(..., help="Второй nginx.conf")
+):
+    """
+    Сравнивает две конфигурации Nginx и выводит отличия.
+    """
+    tree1 = parse_nginx_config(config1)
+    tree2 = parse_nginx_config(config2)
+    diffs = diff_trees(tree1, tree2)
+    if not diffs:
+        console.print("[green]Конфигурации идентичны[/green]")
+        return
+    root = Tree("[bold blue]Diff nginx.conf[/bold blue]")
+    for d in diffs:
+        path = "/".join(d['path'])
+        if d['type'] == 'added':
+            root.add(f"[green]+ {path}[/green]")
+        elif d['type'] == 'removed':
+            root.add(f"[red]- {path}[/red]")
+        elif d['type'] == 'changed':
+            node = root.add(f"[yellow]! {path}[/yellow]")
+            node.add(f"[red]- {d['value1']}[/red]")
+            node.add(f"[green]+ {d['value2']}[/green]")
+    console.print(root) 

commands/health.py

@@ -0,0 +1,24 @@
+import typer
+from rich.console import Console
+from upstream_checker.checker import check_upstreams
+from parser.nginx_parser import parse_nginx_config
+
+app = typer.Typer()
+console = Console()
+
+def health(
+    config_path: str = typer.Argument(..., help="Путь к nginx.conf"),
+    timeout: float = typer.Option(2.0, help="Таймаут проверки (сек)"),
+    retries: int = typer.Option(1, help="Количество попыток")
+):
+    """
+    Проверяет доступность upstream-серверов, определённых в nginx.conf.
+    """
+    tree = parse_nginx_config(config_path)
+    upstreams = tree.get_upstreams()
+    results = check_upstreams(upstreams, timeout=timeout, retries=retries)
+    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}") 

commands/route.py

@@ -0,0 +1,30 @@
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from analyzer.route import find_route
+from parser.nginx_parser import parse_nginx_config
+
+app = typer.Typer()
+console = Console()
+
+def route(
+    config_path: str = typer.Argument(..., help="Путь к nginx.conf"),
+    url: str = typer.Argument(..., help="URL для маршрутизации (например, http://host/path)")
+):
+    """
+    Показывает, какой server/location обслуживает указанный URL.
+    """
+    tree = parse_nginx_config(config_path)
+    res = find_route(tree, url)
+    if not res:
+        console.print(Panel(f"Не найден подходящий server для {url}", style="red"))
+        return
+    server = res['server']
+    location = res['location']
+    proxy_pass = res['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:
+        text += f"[bold]proxy_pass:[/bold] {proxy_pass}\n"
+    console.print(Panel(text, title="Route", style="green")) 

commands/tree.py

@@ -0,0 +1,44 @@
+import typer
+from rich.console import Console
+from rich.tree import Tree as RichTree
+from parser.nginx_parser import parse_nginx_config
+
+app = typer.Typer()
+console = Console()
+
+def _build_tree(directives, parent):
+    for d in directives:
+        if 'block' in d:
+            label = f"[bold]{d['block']}[/bold] {d.get('arg') or ''}".strip()
+            node = parent.add(label)
+            if d.get('directives'):
+                _build_tree(d['directives'], node)
+        elif 'upstream' in d:
+            label = f"[bold magenta]upstream[/bold magenta] {d['upstream']}"
+            node = parent.add(label)
+            for srv in d.get('servers', []):
+                node.add(f"[green]server[/green] {srv}")
+        elif 'directive' in d:
+            parent.add(f"[cyan]{d['directive']}[/cyan] {d.get('args','')}")
+
+def tree(
+    config_path: str = typer.Argument(..., help="Путь к nginx.conf"),
+    markdown: bool = typer.Option(False, help="Экспортировать в Markdown"),
+    html: bool = typer.Option(False, help="Экспортировать в HTML")
+):
+    """
+    Визуализирует структуру nginx.conf в виде дерева.
+    """
+    tree_obj = parse_nginx_config(config_path)
+    root = RichTree(f"[bold blue]nginx.conf[/bold blue]")
+    _build_tree(tree_obj.directives, root)
+    if markdown:
+        from exporter.markdown import tree_to_markdown
+        md = tree_to_markdown(tree_obj.directives)
+        console.print(md)
+    elif html:
+        from exporter.html import tree_to_html
+        html_code = tree_to_html(tree_obj.directives)
+        console.print(html_code)
+    else:
+        console.print(root) 

exporter/html.py

@@ -0,0 +1,20 @@
+def tree_to_html(directives, level=0):
+    html = []
+    html.append('<ul>')
+    for d in directives:
+        if 'block' in d:
+            label = f"{d['block']} {d.get('arg') or ''}".strip()
+            html.append(f"<li><b>{label}</b>")
+            if d.get('directives'):
+                html.append(tree_to_html(d['directives'], level+1))
+            html.append("</li>")
+        elif 'upstream' in d:
+            label = f"upstream {d['upstream']}"
+            html.append(f"<li><b>{label}</b><ul>")
+            for srv in d.get('servers', []):
+                html.append(f"<li>server {srv}</li>")
+            html.append("</ul></li>")
+        elif 'directive' in d:
+            html.append(f"<li>{d['directive']} {d.get('args','')}</li>")
+    html.append('</ul>')
+    return '\n'.join(html) 

exporter/markdown.py

@@ -0,0 +1,17 @@
+def tree_to_markdown(directives, level=0):
+    lines = []
+    prefix = '  ' * level + '- '
+    for d in directives:
+        if 'block' in d:
+            label = f"{d['block']} {d.get('arg') or ''}".strip()
+            lines.append(f"{prefix}{label}")
+            if d.get('directives'):
+                lines.append(tree_to_markdown(d['directives'], level+1))
+        elif 'upstream' in d:
+            label = f"upstream {d['upstream']}"
+            lines.append(f"{prefix}{label}")
+            for srv in d.get('servers', []):
+                lines.append(f"{'  '*(level+1)}- server {srv}")
+        elif 'directive' in d:
+            lines.append(f"{prefix}{d['directive']} {d.get('args','')}")
+    return '\n'.join(lines) 

nginx_lens-0.1.0.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: nginx-lens
+Version: 0.1.0
+Summary: CLI-инструмент для анализа, визуализации и диагностики конфигураций Nginx
+Author: Daniil Astrouski
+Author-email: shelovesuastra@gmail.com
+Requires-Python: >=3.8
+Requires-Dist: typer[all]>=0.9.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: requests>=2.25.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

nginx_lens-0.1.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+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=pRL3-ZkI2nwXMdvXsBrh__MWTd9u0NFNRaiM5x8SSX0,3280
+commands/cli.py,sha256=A47d3vdTDPHRZlRKs02PtxOFdPHjecpXTZyGhQ34r_w,490
+commands/diff.py,sha256=yA_znERefmtcWuusdX7XUqCqRftA6hFWsYRVedc97ig,1237
+commands/health.py,sha256=2QdjIVattoaksW7BrjM2_vqqB18_t7ILeBvKVjaxTdM,1008
+commands/route.py,sha256=jqGKRcocjNhGAN6LQ1PvqcNaNKG_Nn437l9ZeHaD-FA,1132
+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.0.dist-info/METADATA,sha256=YaK62hPH-fHD66tS3qvGVHJsc7HkAEbz5xxnvWQVAVA,476
+nginx_lens-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nginx_lens-0.1.0.dist-info/entry_points.txt,sha256=qEcecjSyLqcJjbIVlNlTpqAhPqDyaujUV5ZcBTAr3po,48
+nginx_lens-0.1.0.dist-info/top_level.txt,sha256=mxLJO4rZg0rbixVGhplF3fUNFs8vxDIL25ronZNvRy4,51
+nginx_lens-0.1.0.dist-info/RECORD,,

nginx_lens-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nginx_lens-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+nginx-lens = commands.cli:app

nginx_lens-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,5 @@
+analyzer
+commands
+exporter
+parser
+upstream_checker

parser/nginx_parser.py

@@ -0,0 +1,95 @@
+import os
+import glob
+from typing import Dict, List, Any
+import re
+
+class NginxConfigTree:
+    def __init__(self, directives=None, upstreams=None):
+        self.directives = directives or []
+        self._upstreams = upstreams or {}
+    def get_upstreams(self) -> Dict[str, List[str]]:
+        return self._upstreams
+
+# --- Вспомогательные функции ---
+def _strip_comments(line: str) -> str:
+    return line.split('#', 1)[0].strip()
+
+def _parse_block(lines, base_dir) -> (List[Any], Dict[str, List[str]]):
+    directives = []
+    upstreams = {}
+    i = 0
+    while i < len(lines):
+        line = _strip_comments(lines[i])
+        if not line:
+            i += 1
+            continue
+        if line.startswith('include '):
+            pattern = line[len('include '):].rstrip(';').strip()
+            pattern = os.path.join(base_dir, pattern) if not os.path.isabs(pattern) else pattern
+            for inc_path in glob.glob(pattern):
+                with open(inc_path) as f:
+                    inc_lines = f.readlines()
+                inc_directives, inc_upstreams = _parse_block(inc_lines, os.path.dirname(inc_path))
+                directives.extend(inc_directives)
+                for k, v in inc_upstreams.items():
+                    upstreams.setdefault(k, []).extend(v)
+            i += 1
+            continue
+        m = re.match(r'upstream\s+(\S+)\s*{', line)
+        if m:
+            name = m.group(1)
+            block_lines = []
+            depth = 1
+            i += 1
+            while i < len(lines) and depth > 0:
+                l = _strip_comments(lines[i])
+                if '{' in l:
+                    depth += l.count('{')
+                if '}' in l:
+                    depth -= l.count('}')
+                if depth > 0:
+                    block_lines.append(l)
+                i += 1
+            servers = []
+            for bl in block_lines:
+                m_srv = re.match(r'server\s+([^;]+);', bl)
+                if m_srv:
+                    servers.append(m_srv.group(1).strip())
+            upstreams[name] = servers
+            directives.append({'upstream': name, 'servers': servers})
+            continue
+        # Блоки (например, server, http, location)
+        m = re.match(r'(\S+)\s*(\S+)?\s*{', line)
+        if m:
+            block_name = m.group(1)
+            block_arg = m.group(2)
+            block_lines = []
+            depth = 1
+            i += 1
+            while i < len(lines) and depth > 0:
+                l = _strip_comments(lines[i])
+                if '{' in l:
+                    depth += l.count('{')
+                if '}' in l:
+                    depth -= l.count('}')
+                if depth > 0:
+                    block_lines.append(l)
+                i += 1
+            sub_directives, sub_upstreams = _parse_block(block_lines, base_dir)
+            directives.append({'block': block_name, 'arg': block_arg, 'directives': sub_directives})
+            for k, v in sub_upstreams.items():
+                upstreams.setdefault(k, []).extend(v)
+            continue
+        # Обычная директива
+        m = re.match(r'(\S+)\s+([^;]+);', line)
+        if m:
+            directives.append({'directive': m.group(1), 'args': m.group(2)})
+        i += 1
+    return directives, upstreams
+
+def parse_nginx_config(path: str) -> NginxConfigTree:
+    base_dir = os.path.dirname(os.path.abspath(path))
+    with open(path) as f:
+        lines = f.readlines()
+    directives, upstreams = _parse_block(lines, base_dir)
+    return NginxConfigTree(directives, upstreams) 

upstream_checker/checker.py

@@ -0,0 +1,12 @@
+import socket
+from typing import Dict, List
+
+def check_upstreams(upstreams: Dict[str, List[str]], timeout=2.0, retries=1):
+    # TODO: Реализовать реальную проверку TCP/HTTP
+    # Сейчас возвращает все healthy
+    result = {}
+    for name, servers in upstreams.items():
+        result[name] = []
+        for srv in servers:
+            result[name].append({"address": srv, "healthy": True})
+    return result