nginx-lens 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

{nginx_lens-0.4.0.dist-info → nginx_lens-0.5.1.dist-info}/RECORD

@@ -12,29 +12,37 @@ 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=UUZpPOpEnPglo94AFklX-cMt6HoHPCafmqfW76CIZVg,8667
-commands/cli.py,sha256=brzp6xDDWIrm7ibaoT4x94hgAdBB2DVWniXoK8dRylE,782
+commands/cli.py,sha256=_vpXlQr0Rf5bUN2t_fV2x40eAHU6nyOjAVRr8tC0eNo,1081
+commands/completion.py,sha256=I7g70tM9JDc8PddIOS-tAGiqc3HkmQhFuAzMCMe_Jck,6223
 commands/diff.py,sha256=mf6xkf_8IKa3R-AiTsWmJDUrxqjGT5gaSAX0u5D0jjY,2097
 commands/graph.py,sha256=lBh2wCPrhsywxcEbz5UABtNdEepTMLmiIzWJt_Uu1mE,5968
-commands/health.py,sha256=e6569IAITNf9Mji_E0GbA18S9neA0yfkSsTAZcnwFoM,5343
+commands/health.py,sha256=Q2qGB02dcMFbp247qg5uxkJFWw84rmCEzZozXcy2wtQ,7606
 commands/include.py,sha256=hsheLfoQ3eUx3irAibhC2ndq3ko0VrLda-WGL9JgIlw,2245
-commands/logs.py,sha256=D6vI9YNPgStZ4weM3bSrUIzK0ncpd9Ku7V7jRBDwtPY,15415
-commands/resolve.py,sha256=eeln1_5QAR4FvsrPz1ff9cd_i_9yGlPcF_W1omkTNms,4032
+commands/logs.py,sha256=scs5_AD4w4z1LXyYZvB4IBLd3T-LSV_45hD8KtHrdhc,15763
+commands/metrics.py,sha256=MawshQaCOkdeLxlopuOzDAE-Gyjlbs_u1bIP4EsB10Q,18955
+commands/resolve.py,sha256=hxGiavoESKj_RPfezelh7vsxGSccUFMQI0K4-izdrRk,5868
 commands/route.py,sha256=4bW4sCY2cVORk-hblnE-BJH3oRL6T9cZuigL-2KCRT4,3174
 commands/syntax.py,sha256=9sjJXheQ9PRZoFm0sO73pEomzbkeYvbBV265XLU6Krk,3423
 commands/tree.py,sha256=cxq0vL6V3ah5X4ozPOmWgIH4NJbr2J48TTLNxsjzOL8,2182
+commands/validate.py,sha256=LB_a4RHsaIZxXrm9jUZ1McgLefcP1aZ_bJ_i6z5huNM,22682
+config/__init__.py,sha256=vsP76D53exH8CkpWttJLTgXlW52LFgP_zBnxPKkWAtQ,107
+config/config_loader.py,sha256=fqJEnHojkEMEpAez9ymAHUR1TbD0D_RSFGZsdI7zObQ,6927
 exporter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 exporter/csv.py,sha256=_hTIs9CihxP9ewB9FcoN-ERmzUKEQs8hf7U8_heHTO0,2815
 exporter/graph.py,sha256=WYUrqUgCaK6KihgxAcRHaQn4oMo6b7ybC8yb_36ZIsA,3995
 exporter/html.py,sha256=uquEM-WvBt2aV9GshgaI3UVhYd8sD0QQ-OmuNtvYUdU,798
 exporter/json_yaml.py,sha256=XqLOBtrh5Xd7RMeofODU8jaTkaeBEpHMNjz4UF39WrQ,11794
 exporter/markdown.py,sha256=_0mXQIhurGEZ0dO-eq9DbsuKNrgEDIblgtL3DAgYNo8,724
-nginx_lens-0.4.0.dist-info/licenses/LICENSE,sha256=g8QXKdvZZC56rU8E12vIeYF6R4jeTWOsblOnYAda3K4,1073
+nginx_lens-0.5.1.dist-info/licenses/LICENSE,sha256=g8QXKdvZZC56rU8E12vIeYF6R4jeTWOsblOnYAda3K4,1073
 parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 parser/nginx_parser.py,sha256=Sa9FtGAkvTqNzoehBvgLUWPJHLLIZYWH9ugSHW50X8s,3699
 upstream_checker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-upstream_checker/checker.py,sha256=i3L6XqUHUH5hcyLq5PXx6wOyjzEL_Z7xYCA3FffFOrU,11257
-nginx_lens-0.4.0.dist-info/METADATA,sha256=W4PE6mOQdDbsW0S4RTokPg3h2m9f39Fol0RWV3zxuJo,717
-nginx_lens-0.4.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-nginx_lens-0.4.0.dist-info/entry_points.txt,sha256=qEcecjSyLqcJjbIVlNlTpqAhPqDyaujUV5ZcBTAr3po,48
-nginx_lens-0.4.0.dist-info/top_level.txt,sha256=mxLJO4rZg0rbixVGhplF3fUNFs8vxDIL25ronZNvRy4,51
-nginx_lens-0.4.0.dist-info/RECORD,,
+upstream_checker/checker.py,sha256=b3E7P9f_7JRWqXa_mSei6LKchD9yQoLNuwindnvfWYI,13258
+upstream_checker/dns_cache.py,sha256=RiGgDFKaIvVQz8Rrm8lBorct8WzbyXHLKZy6W7WhYg4,6903
+utils/__init__.py,sha256=tl98tkuTjz9Q5TKD8cxAxBh6n1Yk65TgKCdIbPFsnz4,43
+utils/progress.py,sha256=Aqb1EW7yGJUSSzw5hTJYiKQ3XjU7ABEqAByfQo9t9P0,4797
+nginx_lens-0.5.1.dist-info/METADATA,sha256=qmc0BzifHWigs76BS7E5g9flKjFGiw5hZ9HAn_9bkuQ,717
+nginx_lens-0.5.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+nginx_lens-0.5.1.dist-info/entry_points.txt,sha256=qEcecjSyLqcJjbIVlNlTpqAhPqDyaujUV5ZcBTAr3po,48
+nginx_lens-0.5.1.dist-info/top_level.txt,sha256=W4rp9juDAaGS642PMW3zfoHyFMj0yTtXKAwlVz87bao,64
+nginx_lens-0.5.1.dist-info/RECORD,,

{nginx_lens-0.4.0.dist-info → nginx_lens-0.5.1.dist-info}/top_level.txt

@@ -1,5 +1,7 @@
 analyzer
 commands
+config
 exporter
 parser
 upstream_checker
+utils

upstream_checker/checker.py

@@ -3,8 +3,9 @@
 import socket
 import time
 import http.client
-from typing import Dict, List, Tuple
+from typing import Dict, List, Tuple, Optional
 from concurrent.futures import ThreadPoolExecutor, as_completed
+from utils.progress import ProgressManager
 try:
     import dns.resolver
     import dns.exception
@@ -12,6 +13,8 @@ try:
 except ImportError:
     DNS_AVAILABLE = False
 
+from upstream_checker.dns_cache import get_cache, is_cache_enabled, disable_cache, enable_cache
+
 
 def check_tcp(address: str, timeout: float, retries: int) -> bool:
     """
@@ -56,12 +59,15 @@ def check_http(address: str, timeout: float, retries: int) -> bool:
     return False
 
 
-def resolve_address(address: str) -> List[str]:
+def resolve_address(address: str, use_cache: bool = True, cache_ttl: int = 300, cache_dir: Optional[str] = None) -> List[str]:
     """
     Резолвит адрес upstream сервера в IP-адреса с информацией о CNAME.
     
     Args:
         address: Адрес в формате "host:port" или "host:port параметры"
+        use_cache: Использовать ли кэш (по умолчанию True)
+        cache_ttl: Время жизни кэша в секундах (по умолчанию 300)
+        cache_dir: Директория для кэша (опционально)
         
     Returns:
         Список строк в формате:
@@ -81,6 +87,7 @@ def resolve_address(address: str) -> List[str]:
             return []
         host, port = parts
         
+        # Проверка на IP адрес (не кэшируем IP адреса)
         try:
             socket.inet_aton(host)
             return [host_port]
@@ -95,10 +102,25 @@ def resolve_address(address: str) -> List[str]:
             except (socket.error, OSError):
                 pass
         
+        # Проверяем кэш перед резолвингом
+        if use_cache and is_cache_enabled():
+            cache = get_cache(ttl=cache_ttl, cache_dir=cache_dir)
+            cached_result = cache.get(host, port)
+            if cached_result is not None:
+                return cached_result
+        
+        # Выполняем резолвинг
         if DNS_AVAILABLE:
-            return _resolve_with_dns(host, port)
+            result = _resolve_with_dns(host, port)
         else:
-            return _resolve_with_socket(host, port)
+            result = _resolve_with_socket(host, port)
+        
+        # Сохраняем в кэш
+        if use_cache and is_cache_enabled():
+            cache = get_cache(ttl=cache_ttl, cache_dir=cache_dir)
+            cache.set(host, port, result)
+        
+        return result
     except (ValueError, IndexError, AttributeError):
         return []
 
@@ -187,7 +209,11 @@ def _resolve_with_socket(host: str, port: str) -> List[str]:
 
 def resolve_upstreams(
     upstreams: Dict[str, List[str]],
-    max_workers: int = 10
+    max_workers: int = 10,
+    use_cache: bool = True,
+    cache_ttl: int = 300,
+    cache_dir: Optional[str] = None,
+    progress_manager: Optional[ProgressManager] = None
 ) -> Dict[str, List[dict]]:
     """
     Резолвит DNS имена upstream-серверов в IP-адреса.
@@ -195,6 +221,9 @@ def resolve_upstreams(
     Args:
         upstreams: Словарь upstream серверов
         max_workers: Максимальное количество потоков для параллельной обработки
+        use_cache: Использовать ли кэш (по умолчанию True)
+        cache_ttl: Время жизни кэша в секундах (по умолчанию 300)
+        cache_dir: Директория для кэша (опционально)
     
     Возвращает:
     {
@@ -226,7 +255,10 @@ def resolve_upstreams(
     
     # Параллельная обработка резолвинга
     with ThreadPoolExecutor(max_workers=max_workers) as executor:
-        future_to_key = {executor.submit(resolve_address, srv): key for key, srv in tasks}
+        future_to_key = {
+            executor.submit(resolve_address, srv, use_cache, cache_ttl, cache_dir): key 
+            for key, srv in tasks
+        }
         
         for future in as_completed(future_to_key):
             key = future_to_key[future]
@@ -260,7 +292,8 @@ def check_upstreams(
     timeout: float = 2.0,
     retries: int = 1,
     mode: str = "tcp",
-    max_workers: int = 10
+    max_workers: int = 10,
+    progress_manager: Optional[ProgressManager] = None
 ) -> Dict[str, List[dict]]:
     """
     Проверяет доступность upstream-серверов.
@@ -305,6 +338,9 @@ def check_upstreams(
             for key, srv in tasks
         }
         
+        completed = 0
+        total = len(tasks)
+        
         for future in as_completed(future_to_key):
             key = future_to_key[future]
             name, idx = task_to_key[key]
@@ -313,5 +349,9 @@ def check_upstreams(
                 results[name][idx] = {"address": srv, "healthy": healthy}
             except Exception:
                 results[name][idx] = {"address": key[2], "healthy": False}
+            
+            completed += 1
+            if progress_manager:
+                progress_manager.update(completed, total=total, description=f"Проверка upstream серверов ({completed}/{total})")
     
     return results

upstream_checker/dns_cache.py

@@ -0,0 +1,216 @@
+"""
+Модуль для кэширования результатов DNS резолвинга.
+"""
+import os
+import json
+import time
+import hashlib
+from typing import Optional, List, Dict
+from pathlib import Path
+
+
+class DNSCache:
+    """
+    Кэш для результатов DNS резолвинга.
+    """
+    
+    def __init__(self, cache_dir: Optional[str] = None, ttl: int = 300):
+        """
+        Инициализация кэша.
+        
+        Args:
+            cache_dir: Директория для хранения кэша (по умолчанию ~/.cache/nginx-lens/)
+            ttl: Время жизни кэша в секундах (по умолчанию 5 минут)
+        """
+        self.ttl = ttl
+        
+        if cache_dir:
+            self.cache_dir = Path(cache_dir)
+        else:
+            # Используем ~/.cache/nginx-lens/ или /tmp/nginx-lens-cache/
+            home_cache = Path.home() / ".cache" / "nginx-lens"
+            tmp_cache = Path("/tmp") / "nginx-lens-cache"
+            
+            # Пробуем использовать домашнюю директорию, если доступна
+            try:
+                home_cache.mkdir(parents=True, exist_ok=True)
+                self.cache_dir = home_cache
+            except (OSError, PermissionError):
+                # Fallback на /tmp
+                try:
+                    tmp_cache.mkdir(parents=True, exist_ok=True)
+                    self.cache_dir = tmp_cache
+                except (OSError, PermissionError):
+                    # Последний fallback - текущая директория
+                    self.cache_dir = Path.cwd() / ".nginx-lens-cache"
+                    self.cache_dir.mkdir(parents=True, exist_ok=True)
+        
+        self.cache_file = self.cache_dir / "dns_cache.json"
+        self._cache: Dict[str, Dict] = {}
+        self._load_cache()
+    
+    def _get_cache_key(self, host: str, port: str) -> str:
+        """
+        Генерирует ключ кэша для host:port.
+        
+        Args:
+            host: Имя хоста
+            port: Порт
+            
+        Returns:
+            Хеш ключ для кэша
+        """
+        key = f"{host}:{port}"
+        return hashlib.md5(key.encode()).hexdigest()
+    
+    def _load_cache(self):
+        """Загружает кэш из файла."""
+        if self.cache_file.exists():
+            try:
+                with open(self.cache_file, 'r') as f:
+                    self._cache = json.load(f)
+            except (json.JSONDecodeError, IOError):
+                self._cache = {}
+    
+    def _save_cache(self):
+        """Сохраняет кэш в файл."""
+        try:
+            with open(self.cache_file, 'w') as f:
+                json.dump(self._cache, f)
+        except IOError:
+            # Игнорируем ошибки записи
+            pass
+    
+    def get(self, host: str, port: str) -> Optional[List[str]]:
+        """
+        Получает результат из кэша.
+        
+        Args:
+            host: Имя хоста
+            port: Порт
+            
+        Returns:
+            Список резолвленных IP-адресов или None, если нет в кэше или истек TTL
+        """
+        key = self._get_cache_key(host, port)
+        
+        if key not in self._cache:
+            return None
+        
+        cached_data = self._cache[key]
+        cached_time = cached_data.get('timestamp', 0)
+        current_time = time.time()
+        
+        # Проверяем TTL
+        if current_time - cached_time > self.ttl:
+            # Удаляем устаревшую запись
+            del self._cache[key]
+            self._save_cache()
+            return None
+        
+        return cached_data.get('result')
+    
+    def set(self, host: str, port: str, result: List[str]):
+        """
+        Сохраняет результат в кэш.
+        
+        Args:
+            host: Имя хоста
+            port: Порт
+            result: Список резолвленных IP-адресов
+        """
+        key = self._get_cache_key(host, port)
+        
+        self._cache[key] = {
+            'timestamp': time.time(),
+            'result': result,
+            'host': host,
+            'port': port
+        }
+        
+        self._save_cache()
+    
+    def clear(self):
+        """Очищает весь кэш."""
+        self._cache = {}
+        if self.cache_file.exists():
+            try:
+                self.cache_file.unlink()
+            except IOError:
+                pass
+    
+    def get_cache_info(self) -> Dict[str, any]:
+        """
+        Возвращает информацию о кэше.
+        
+        Returns:
+            Словарь с информацией о кэше
+        """
+        current_time = time.time()
+        valid_entries = 0
+        expired_entries = 0
+        
+        for key, data in self._cache.items():
+            cached_time = data.get('timestamp', 0)
+            if current_time - cached_time <= self.ttl:
+                valid_entries += 1
+            else:
+                expired_entries += 1
+        
+        return {
+            'total_entries': len(self._cache),
+            'valid_entries': valid_entries,
+            'expired_entries': expired_entries,
+            'cache_dir': str(self.cache_dir),
+            'ttl': self.ttl
+        }
+
+
+# Глобальный экземпляр кэша (будет инициализирован при первом использовании)
+_cache_instance: Optional[DNSCache] = None
+_cache_enabled = True
+
+
+def get_cache(ttl: int = 300, cache_dir: Optional[str] = None) -> DNSCache:
+    """
+    Получает глобальный экземпляр кэша.
+    
+    Args:
+        ttl: Время жизни кэша в секундах
+        cache_dir: Директория для кэша
+        
+    Returns:
+        Экземпляр DNSCache
+    """
+    global _cache_instance
+    if _cache_instance is None:
+        _cache_instance = DNSCache(cache_dir=cache_dir, ttl=ttl)
+    elif ttl != _cache_instance.ttl:
+        # Обновляем TTL если изменился
+        _cache_instance.ttl = ttl
+    return _cache_instance
+
+
+def clear_cache():
+    """Очищает глобальный кэш."""
+    global _cache_instance
+    if _cache_instance:
+        _cache_instance.clear()
+
+
+def disable_cache():
+    """Отключает кэширование."""
+    global _cache_enabled
+    _cache_enabled = False
+
+
+def enable_cache():
+    """Включает кэширование."""
+    global _cache_enabled
+    _cache_enabled = True
+
+
+def is_cache_enabled() -> bool:
+    """Проверяет, включено ли кэширование."""
+    return _cache_enabled
+

utils/__init__.py

@@ -0,0 +1,4 @@
+"""
+Утилиты для nginx-lens.
+"""
+

utils/progress.py

@@ -0,0 +1,120 @@
+"""
+Утилиты для отображения прогресса операций.
+"""
+from typing import Optional, Callable, Any
+from rich.progress import Progress, SpinnerColumn, BarColumn, TextColumn, TimeElapsedColumn, TimeRemainingColumn, TaskID
+from rich.console import Console
+import signal
+import sys
+
+console = Console()
+
+
+class ProgressManager:
+    """
+    Менеджер для отображения прогресса операций с поддержкой отмены.
+    """
+    
+    def __init__(self, description: str = "Обработка", show_progress: bool = True):
+        """
+        Инициализация менеджера прогресса.
+        
+        Args:
+            description: Описание операции
+            show_progress: Показывать ли прогресс-бар
+        """
+        self.description = description
+        self.show_progress = show_progress
+        self.progress: Optional[Progress] = None
+        self.task_id: Optional[TaskID] = None
+        self.cancelled = False
+        
+        # Обработка сигнала прерывания
+        self._original_sigint = signal.signal(signal.SIGINT, self._handle_interrupt)
+    
+    def _handle_interrupt(self, signum, frame):
+        """Обработка прерывания (Ctrl+C)."""
+        self.cancelled = True
+        if self.progress:
+            self.progress.stop()
+        console.print("\n[yellow]Операция отменена пользователем[/yellow]")
+        sys.exit(130)  # Стандартный exit code для SIGINT
+    
+    def __enter__(self):
+        """Вход в контекстный менеджер."""
+        if self.show_progress:
+            self.progress = Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                BarColumn(),
+                TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+                TimeElapsedColumn(),
+                TimeRemainingColumn(),
+                console=console,
+                transient=False,
+            )
+            self.progress.start()
+            self.task_id = self.progress.add_task(self.description, total=None)
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Выход из контекстного менеджера."""
+        if self.progress:
+            self.progress.stop()
+        # Восстанавливаем оригинальный обработчик сигнала
+        signal.signal(signal.SIGINT, self._original_sigint)
+        return False
+    
+    def update(self, completed: int, total: Optional[int] = None, description: Optional[str] = None):
+        """
+        Обновляет прогресс.
+        
+        Args:
+            completed: Количество завершенных задач
+            total: Общее количество задач (если None, используется спиннер)
+            description: Описание текущей операции
+        """
+        if self.progress and self.task_id is not None:
+            if total is not None:
+                self.progress.update(self.task_id, total=total, completed=completed)
+            if description:
+                self.progress.update(self.task_id, description=description)
+    
+    def advance(self, advance: int = 1):
+        """
+        Увеличивает прогресс на указанное значение.
+        
+        Args:
+            advance: На сколько увеличить прогресс
+        """
+        if self.progress and self.task_id is not None:
+            self.progress.advance(self.task_id, advance)
+
+
+def with_progress(
+    description: str,
+    total: Optional[int] = None,
+    show_progress: bool = True
+) -> Callable:
+    """
+    Декоратор для добавления прогресс-бара к функции.
+    
+    Args:
+        description: Описание операции
+        total: Общее количество итераций (если известно)
+        show_progress: Показывать ли прогресс-бар
+        
+    Returns:
+        Декорированная функция
+    """
+    def decorator(func: Callable) -> Callable:
+        def wrapper(*args, **kwargs):
+            with ProgressManager(description=description, show_progress=show_progress) as pm:
+                # Передаем менеджер прогресса в функцию
+                kwargs['progress_manager'] = pm
+                if total is not None:
+                    pm.update(0, total=total)
+                return func(*args, **kwargs)
+        return wrapper
+    return decorator
+