raijin-server 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

raijin_server/utils.py

@@ -29,9 +29,38 @@ BACKUP_COUNT = int(os.environ.get("RAIJIN_LOG_BACKUP_COUNT", 5))
 logger = logging.getLogger("raijin-server")
 logger.setLevel(logging.INFO)
 
-file_handler = RotatingFileHandler(LOG_FILE, maxBytes=MAX_LOG_BYTES, backupCount=BACKUP_COUNT)
+
+def _build_file_handler() -> RotatingFileHandler:
+    """Cria handler com fallback para $HOME quando /var/log exige root."""
+    try:
+        return RotatingFileHandler(LOG_FILE, maxBytes=MAX_LOG_BYTES, backupCount=BACKUP_COUNT)
+    except PermissionError:
+        fallback = Path.home() / ".raijin-server.log"
+        fallback.parent.mkdir(parents=True, exist_ok=True)
+        return RotatingFileHandler(fallback, maxBytes=MAX_LOG_BYTES, backupCount=BACKUP_COUNT)
+
+
+file_handler = _build_file_handler()
 stream_handler = logging.StreamHandler()
 
+
+def active_log_file() -> Path:
+    return Path(getattr(file_handler, "baseFilename", LOG_FILE))
+
+
+def available_log_files() -> list[Path]:
+    base = active_log_file()
+    pattern = base.name + "*"
+    return [p for p in sorted(base.parent.glob(pattern)) if p.is_file()]
+
+
+def page_text(content: str) -> None:
+    pager = shutil.which("less")
+    if pager:
+        subprocess.run([pager, "-R"], input=content, text=True, check=False)
+    else:
+        typer.echo(content)
+
 formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
 file_handler.setFormatter(formatter)
 stream_handler.setFormatter(formatter)
@@ -57,6 +86,13 @@ class ExecutionContext:
     timeout: int = 600  # 10 min for slow connections
     errors: list = field(default_factory=list)
     warnings: list = field(default_factory=list)
+    # Controle interativo/diagnostico
+    selected_steps: list[str] | None = None
+    confirm_each_step: bool = False
+    debug_snapshots: bool = False
+    post_diagnose: bool = False
+    color_prompts: bool = True
+    interactive_steps: bool = False
 
 
 def resolve_script_path(script_name: str) -> Path:
@@ -317,6 +353,125 @@ def _get_helm_release_status(release: str, namespace: str) -> str:
         return ""
 
 
+def _get_helm_release_history(release: str, namespace: str) -> list:
+    """Retorna histórico do release Helm."""
+    try:
+        import json
+        result = subprocess.run(
+            ["helm", "history", release, "-n", namespace, "-o", "json"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        if result.returncode != 0 or not result.stdout:
+            return []
+        return json.loads(result.stdout)
+    except Exception:
+        return []
+
+
+def _diagnose_helm_release(release: str, namespace: str) -> None:
+    """Mostra diagnóstico detalhado de um release Helm."""
+    typer.secho(f"\n🔍 Diagnóstico do release '{release}':", fg=typer.colors.YELLOW)
+    
+    # Status atual
+    status = _get_helm_release_status(release, namespace)
+    typer.echo(f"  Status atual: {status or '(não encontrado)'}")
+    
+    # Histórico
+    history = _get_helm_release_history(release, namespace)
+    if history:
+        typer.echo(f"  Histórico ({len(history)} revisões):")
+        for rev in history[-5:]:  # Últimas 5 revisões
+            typer.echo(f"    Rev {rev.get('revision')}: {rev.get('status')} - {rev.get('description', '')[:50]}")
+    
+    # Secrets do Helm (onde guarda estado)
+    try:
+        result = subprocess.run(
+            ["kubectl", "get", "secrets", "-n", namespace, "-l", f"name={release},owner=helm", "-o", "name"],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+        if result.stdout.strip():
+            secrets = result.stdout.strip().split("\n")
+            typer.echo(f"  Secrets do Helm: {len(secrets)}")
+            for s in secrets[-5:]:
+                typer.echo(f"    {s}")
+    except Exception:
+        pass
+    
+    # Pods relacionados
+    try:
+        result = subprocess.run(
+            ["kubectl", "get", "pods", "-n", namespace, "-o", "wide", "--no-headers"],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+        if result.stdout.strip():
+            typer.echo("  Pods:")
+            for line in result.stdout.strip().split("\n")[:5]:
+                typer.echo(f"    {line}")
+    except Exception:
+        pass
+
+
+def _force_cleanup_helm_release(release: str, namespace: str) -> bool:
+    """Limpeza forçada de release Helm travado - remove secrets diretamente."""
+    typer.secho(f"  Limpeza forçada do release '{release}'...", fg=typer.colors.YELLOW)
+    logger.warning(f"Executando limpeza forçada do release {release} em {namespace}")
+    
+    try:
+        # 1. Primeiro tenta uninstall normal com --no-hooks (pula hooks que podem estar travando)
+        result = subprocess.run(
+            ["helm", "uninstall", release, "-n", namespace, "--no-hooks", "--wait", "--timeout", "2m"],
+            capture_output=True,
+            text=True,
+            timeout=150,
+        )
+        
+        if result.returncode == 0:
+            typer.secho(f"  ✓ Release removido via helm uninstall", fg=typer.colors.GREEN)
+            time.sleep(3)
+            return True
+        
+        # 2. Se falhou, remove os secrets do Helm diretamente
+        typer.echo("  Helm uninstall falhou, removendo secrets diretamente...")
+        logger.warning("Removendo secrets do Helm diretamente")
+        
+        # Lista secrets do Helm para este release
+        result = subprocess.run(
+            ["kubectl", "get", "secrets", "-n", namespace, "-l", f"name={release},owner=helm", "-o", "name"],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+        
+        if result.stdout.strip():
+            secrets = result.stdout.strip().split("\n")
+            for secret in secrets:
+                secret_name = secret.replace("secret/", "")
+                subprocess.run(
+                    ["kubectl", "delete", "secret", secret_name, "-n", namespace],
+                    capture_output=True,
+                    timeout=30,
+                )
+                typer.echo(f"    Removido: {secret_name}")
+            
+            time.sleep(3)
+            typer.secho(f"  ✓ Secrets do Helm removidos", fg=typer.colors.GREEN)
+            return True
+        else:
+            typer.echo("  Nenhum secret do Helm encontrado")
+            return True
+            
+    except Exception as e:
+        logger.error(f"Erro na limpeza forçada: {e}")
+        typer.secho(f"  ✗ Erro na limpeza: {e}", fg=typer.colors.RED)
+        return False
+
+
 def _cleanup_pending_helm_release(release: str, namespace: str, ctx: ExecutionContext) -> None:
     """Remove release Helm em estado pendente que bloqueia novas operacoes."""
     if ctx.dry_run:
@@ -327,32 +482,61 @@ def _cleanup_pending_helm_release(release: str, namespace: str, ctx: ExecutionCo
         return
 
     # Estados que bloqueiam: pending-install, pending-upgrade, pending-rollback
-    if status.startswith("pending"):
-        typer.secho(
-            f"⚠ Release '{release}' em estado '{status}'. Limpando antes de prosseguir...",
-            fg=typer.colors.YELLOW,
-        )
-        # Tenta rollback primeiro (funciona para pending-upgrade)
-        subprocess.run(
+    if not status.startswith("pending"):
+        return
+    
+    typer.secho(
+        f"\n⚠ Release '{release}' em estado '{status}' - bloqueando novas operações",
+        fg=typer.colors.YELLOW,
+    )
+    
+    # Mostra diagnóstico
+    _diagnose_helm_release(release, namespace)
+    
+    typer.echo("\n  Tentando recuperar...")
+    
+    # 1. Tenta rollback primeiro (funciona para pending-upgrade)
+    if status == "pending-upgrade":
+        typer.echo("  Tentando rollback para versão anterior...")
+        result = subprocess.run(
             ["helm", "rollback", release, "-n", namespace, "--wait", "--timeout", "2m"],
             capture_output=True,
+            text=True,
             timeout=150,
         )
-        # Verifica se resolveu
-        new_status = _get_helm_release_status(release, namespace)
-        if new_status.startswith("pending"):
-            # Se ainda pendente, desinstala
-            typer.secho(
-                f"  Rollback nao resolveu. Desinstalando release '{release}'...",
-                fg=typer.colors.YELLOW,
-            )
-            subprocess.run(
-                ["helm", "uninstall", release, "-n", namespace, "--wait", "--timeout", "3m"],
-                capture_output=True,
-                timeout=200,
-            )
-            time.sleep(5)
-        typer.secho(f"✓ Release '{release}' limpo.", fg=typer.colors.GREEN)
+        
+        if result.returncode == 0:
+            new_status = _get_helm_release_status(release, namespace)
+            if not new_status.startswith("pending"):
+                typer.secho(f"  ✓ Rollback bem-sucedido (status: {new_status})", fg=typer.colors.GREEN)
+                return
+        
+        typer.echo("  Rollback não resolveu...")
+    
+    # 2. Tenta uninstall normal
+    typer.echo("  Tentando helm uninstall...")
+    result = subprocess.run(
+        ["helm", "uninstall", release, "-n", namespace, "--wait", "--timeout", "3m"],
+        capture_output=True,
+        text=True,
+        timeout=200,
+    )
+    
+    if result.returncode == 0:
+        typer.secho(f"  ✓ Release removido com sucesso", fg=typer.colors.GREEN)
+        time.sleep(3)
+        return
+    
+    # 3. Se ainda falhou, força limpeza
+    typer.echo("  Uninstall normal falhou, tentando limpeza forçada...")
+    _force_cleanup_helm_release(release, namespace)
+    
+    # Verifica resultado final
+    final_status = _get_helm_release_status(release, namespace)
+    if final_status:
+        typer.secho(f"  ⚠ Release ainda existe com status: {final_status}", fg=typer.colors.YELLOW)
+    else:
+        typer.secho(f"  ✓ Release '{release}' limpo com sucesso", fg=typer.colors.GREEN)
 
 
 def helm_upgrade_install(

{raijin_server-0.2.5.dist-info → raijin_server-0.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: raijin-server
-Version: 0.2.5
+Version: 0.2.7
 Summary: CLI para automacao de setup e hardening de servidores Ubuntu Server.
 Home-page: https://example.com/raijin-server
 Author: Equipe Raijin
@@ -61,52 +61,29 @@ CLI em Python (Typer) para automatizar setup e hardening de servidores Ubuntu Se
 
 ## Requisitos
 
-- Python >= 3.9
-- Ubuntu Server 20.04+ (testado em 24.04)
-- Permissões root/sudo
-- Conectividade com internet
-- Mínimo 4GB RAM, 20GB disco livre
-- Ferramentas: `curl`, `apt-get`, `systemctl`
+## Instalação (sempre em venv midgard)
 
-Ferramentas adicionais (instaladas pelos módulos quando necessário):
-- `helm` (>=3.8 para OCI)
-- `kubectl`, `kubeadm`
-- `velero`, `istioctl`
-
-## Instalacao
-
-Sem venv (global):
+Use apenas o venv `~/.venvs/midgard` para padronizar ambiente e logs.
 
 ```bash
-python -m pip install .
-```
-
-Com venv (recomendado para desenvolvimento):
-
-```bash
-python -m venv .venv
-source .venv/bin/activate
-python -m pip install -e .
-```
+# 1) Criar/reativar venv midgard
+python3 -m venv ~/.venvs/midgard
+source ~/.venvs/midgard/bin/activate
+pip install -U pip setuptools
 
-### Instalação em Produção (Recomendado)
+# 2) Instalar a partir do source (dev)
+pip install -U raijin-server
 
-Para servidores em produção, use um venv isolado e execute com sudo preservando o ambiente:
+# 3) Uso com sudo preservando o venv
+sudo -E ~/.venvs/midgard/bin/raijin-server --version
+sudo -E ~/.venvs/midgard/bin/raijin-server validate
+sudo -E ~/.venvs/midgard/bin/raijin-server full-install
 
-```bash
-# 1. Sair do venv atual (se estiver ativo)
+# 4) Quando terminar
 deactivate
+```
 
-# 2. (Opcional) Remover venv antigo
-rm -rf ~/.venvs/raijin
-
-# 3. Criar venv novo
-python3 -m venv ~/.venvs/raijin
-source ~/.venvs/raijin/bin/activate
-pip install -U pip setuptools
-
-# 4. Instalar a versão mais recente
-pip install -U raijin-server
+> Dica: se precisar reinstalar, remova o venv (`rm -rf ~/.venvs/midgard`), recrie e repita o passo 2. O `-E` no sudo mantém o venv ativo para o Python.
 
 # 5. Rodar usando root preservando o venv
 sudo -E ~/.venvs/raijin/bin/raijin-server --version
@@ -124,30 +101,70 @@ deactivate
 ### Validar Sistema
 ```bash
 # Verifica se o sistema atende pré-requisitos
-sudo raijin-server validate
+sudo -E ~/.venvs/midgard/bin/raijin-server validate
 ```
 
 ### Menu Interativo
 ```bash
-# Menu visual com stautils.py`: Funções utilitárias com retry, timeout e logging.
-- `src/raijin_server/validators.py`: Validações de pré-requisitos e dependências.
-- `src/raijin_server/healthchecks.py`: Health checks pós-instalação.
-- `src/raijin_server/config.py`: Gerenciamento de configuração via arquivo.
-- `src/raijin_server/modules/`: Automações por tópico (hardening, network, essentials, firewall, kubernetes, calico, istio, traefik, kong, minio, prometheus, grafana, loki, harness, velero, kafka).
-- `src/raijin_server/scripts/`: Shells empacotados usados pelos módulos e scripts auxiliares.
-- `ARCHITECTURE.md`: Visão do desenho técnico.
-- `AUDIT.md`: Relatório completo de auditoria e melhorias.
-- `SECURITY.md`: Como reportar vulnerabilidades
+# Menu visual com atalho para módulos
+sudo -E ~/.venvs/midgard/bin/raijin-server menu
+```
+
 ### Execução Direta de Módulos
 ```bash
 # Executar módulo específico
-sudo raijin-server kubernetes
+sudo -E ~/.venvs/midgard/bin/raijin-server kubernetes
 
 # Dry-run (simula sem aplicar)
-sudo raijin-server --dry-run kubernetes
+sudo -E ~/.venvs/midgard/bin/raijin-server --dry-run kubernetes
 
 # Pular validações (não recomendado)
-sudo raijin-server --skip-validation kubernetes
+sudo -E ~/.venvs/midgard/bin/raijin-server --skip-validation kubernetes
+```
+
+### Instalação Completa com seleção de passos
+```bash
+# Rodar tudo (padrão)
+sudo -E ~/.venvs/midgard/bin/raijin-server full-install
+
+# Escolher passos antes de rodar
+sudo -E ~/.venvs/midgard/bin/raijin-server full-install --select-steps
+
+# Definir lista fixa (ordem original preservada)
+sudo -E ~/.venvs/midgard/bin/raijin-server full-install --steps "kubernetes,calico,cert_manager,traefik"
+
+# Pedir confirmação a cada módulo
+sudo -E ~/.venvs/midgard/bin/raijin-server full-install --confirm-each
+
+# Modo debug: snapshots + diagnose pós-módulo
+sudo -E ~/.venvs/midgard/bin/raijin-server full-install --debug-mode
+
+# Apenas snapshots após cada módulo (pós-kubernetes)
+sudo -E ~/.venvs/midgard/bin/raijin-server full-install --snapshots
+
+# Apenas diagnose pós-módulo (ex.: cert-manager)
+sudo -E ~/.venvs/midgard/bin/raijin-server full-install --post-diagnose
+```
+
+### Depuração e Logs (pós-Kubernetes)
+```bash
+# Ver todos os logs do CLI com pager (less)
+sudo -E ~/.venvs/midgard/bin/raijin-server debug logs --lines 400
+
+# Seguir logs em tempo real
+sudo -E ~/.venvs/midgard/bin/raijin-server debug logs --follow
+
+# Snapshot do cluster: nodes, pods e eventos (últimos 200)
+sudo -E ~/.venvs/midgard/bin/raijin-server debug kube --events 200
+
+# Focar em um namespace (ex.: cert-manager)
+sudo -E ~/.venvs/midgard/bin/raijin-server debug kube --namespace cert-manager --events 150
+
+# Consultar logs do kubelet via journalctl
+sudo -E ~/.venvs/midgard/bin/raijin-server debug journal --service kubelet --lines 300
+
+# Consultar outro serviço systemd (ex.: containerd)
+sudo -E ~/.venvs/midgard/bin/raijin-server debug journal --service containerd --lines 200
 ```
 
 ### Automação via Arquivo de Configuração
@@ -161,41 +178,41 @@ sudo raijin-server --skip-validation kubernetes
 
 ```bash
 # 1. Validar sistema
-sudo raijin-server validate
+sudo -E ~/.venvs/midgard/bin/raijin-server validate
 
 # 2. Base do sistema
-sudo raijin-server essentials
-sudo raijin-server hardening
-sudo raijin-server network   # OPCIONAL: pule se IP já configurado via provedor ISP
-sudo raijin-server firewall
+sudo -E ~/.venvs/midgard/bin/raijin-server essentials
+sudo -E ~/.venvs/midgard/bin/raijin-server hardening
+sudo -E ~/.venvs/midgard/bin/raijin-server network   # OPCIONAL: pule se IP já configurado via provedor ISP
+sudo -E ~/.venvs/midgard/bin/raijin-server firewall
 
 # 3. Kubernetes
-sudo raijin-server kubernetes
-sudo raijin-server calico
-sudo raijin-server secrets
-sudo raijin-server cert-manager
+sudo -E ~/.venvs/midgard/bin/raijin-server kubernetes
+sudo -E ~/.venvs/midgard/bin/raijin-server calico
+sudo -E ~/.venvs/midgard/bin/raijin-server secrets
+sudo -E ~/.venvs/midgard/bin/raijin-server cert-manager
 
 # 4. Ingress (escolha um)
-sudo raijin-server traefik
+sudo -E ~/.venvs/midgard/bin/raijin-server traefik
 # OU
-sudo raijin-server kong
+sudo -E ~/.venvs/midgard/bin/raijin-server kong
 
 # 5. Observabilidade
-sudo raijin-server prometheus
-sudo raijin-server grafana
-sudo raijin-server observability-ingress
-sudo raijin-server observability-dashboards
-sudo raijin-server loki
+sudo -E ~/.venvs/midgard/bin/raijin-server prometheus
+sudo -E ~/.venvs/midgard/bin/raijin-server grafana
+sudo -E ~/.venvs/midgard/bin/raijin-server observability-ingress
+sudo -E ~/.venvs/midgard/bin/raijin-server observability-dashboards
+sudo -E ~/.venvs/midgard/bin/raijin-server loki
 
 # 6. Storage e Mensageria (opcional)
-sudo raijin-server minio
-sudo raijin-server kafka
+sudo -E ~/.venvs/midgard/bin/raijin-server minio
+sudo -E ~/.venvs/midgard/bin/raijin-server kafka
 
 # 7. Backup
-sudo raijin-server velero
+sudo -E ~/.venvs/midgard/bin/raijin-server velero
 
 # 8. Service Mesh (opcional)
-sudo raijin-server istio
+sudo -E ~/.venvs/midgard/bin/raijin-server istio
 ```
 
 ### IP Estático (pular se já configurado)
@@ -208,7 +225,7 @@ O módulo `network` é **opcional** quando:
 Para pular automaticamente em automações:
 ```bash
 export RAIJIN_SKIP_NETWORK=1
-sudo raijin-server full-install
+sudo -E ~/.venvs/midgard/bin/raijin-server full-install
 ```
 
 O módulo detecta automaticamente se já existe um Netplan com IP estático e pergunta
@@ -222,12 +239,12 @@ se deseja pular. Se executar manualmente, basta responder "não" quando pergunta
 ### Comandos Úteis
 ```bash
 # Versão (flag ou comando)
-raijin-server --version
-raijin-server -V
-raijin-server version
+~/.venvs/midgard/bin/raijin-server --version
+~/.venvs/midgard/bin/raijin-server -V
+~/.venvs/midgard/bin/raijin-server version
 
 # Monitorar logs
-tail -f /var/log/raijin-server/raijin-server.log
+sudo -E ~/.venvs/midgard/bin/raijin-server debug logs --follow
 
 # Rotacao de logs (default: 20MB, 5 backups)
 # Ajuste via env:
@@ -317,7 +334,7 @@ O helper garante o caminho absoluto correto independentemente de onde o pacote f
 O módulo [src/raijin_server/modules/apokolips_demo.py](src/raijin_server/modules/apokolips_demo.py) cria um namespace dedicado, ConfigMap com HTML, Deployment NGINX, Service e Ingress Traefik com uma landing page "Apokolips" para validar o tráfego externo.
 
 ```bash
-sudo raijin-server apokolips-demo
+sudo -E ~/.venvs/midgard/bin/raijin-server apokolips-demo
 ```
 
 Personalização rápida:
@@ -364,7 +381,7 @@ Isso permite manter o isolamento padrão enquanto libera acesso seletivo para in
 Execute o modulo `secrets` para instalar os controladores:
 
 ```bash
-sudo raijin-server secrets
+sudo -E ~/.venvs/midgard/bin/raijin-server secrets
 ```
 
 Passos realizados:

{raijin_server-0.2.5.dist-info → raijin_server-0.2.7.dist-info}/RECORD

@@ -1,17 +1,17 @@
-raijin_server/__init__.py,sha256=7-69Vj-HYrv98hWrKmwDqDQ-ehtTqJebx1JeP4St6Q4,94
-raijin_server/cli.py,sha256=PfuIXc-pw1yZtJzCrxDVSWSsPAVBt9wqZBF-dWh6mwo,19274
+raijin_server/__init__.py,sha256=30PUXP9hr-N0U9chGsPaORRkJKEeGnKMrcXhWTwR054,94
+raijin_server/cli.py,sha256=aQxew8FCN-mZoN-ghBasm97gLk5WkOaIcpeucTpXpXY,24821
 raijin_server/config.py,sha256=Dta2CS1d6RgNiQ84P6dTXk98boFrjzuvhs_fCdlm0I4,4810
 raijin_server/healthchecks.py,sha256=BJyWyUDtEswEblvGwWMejtMnsUb8kJcULVdS9iycrcc,14565
-raijin_server/utils.py,sha256=MNIevCttKq5fVS-I4ZwlY7f7JZtEiwwY_kj69WV4AsQ,14330
+raijin_server/utils.py,sha256=9RnGnPoUTYOpMVRLNa4P4lIQrJNQLkSkPUxycZRGv78,20827
 raijin_server/validators.py,sha256=qOZMHgwjHogVf17UPlxfUCpQd9qAGQW7tycd8mUvnEs,9404
 raijin_server/modules/__init__.py,sha256=e_IbkhLGPcF8to9QUmIESP6fpcTOYcIhaXLKIvqRJMY,920
 raijin_server/modules/apokolips_demo.py,sha256=8ltsXRbVDwlDwLMIvh02NG-FeAfBWw_v6lh7IGOyNqs,13725
 raijin_server/modules/bootstrap.py,sha256=oVIGNRW_JbgY8zXNHGAIP0vGbbHNHyQexthxo5zhbcw,9762
-raijin_server/modules/calico.py,sha256=a8N7YYv7NoaspPKdhRtwHy3V2mM4cP5xA1H8BwslB18,4139
-raijin_server/modules/cert_manager.py,sha256=dse7AIUVOM2h7d2i3DWsvHLsA9NtcazebTPgOEUWB-8,34473
+raijin_server/modules/calico.py,sha256=TTPF1bLFdAKb3IVOqFqRxNblULkRmMMRylsIBp4w8I8,6700
+raijin_server/modules/cert_manager.py,sha256=YvqInfnI06VLFEgau4H0koyBxarFh6vwxvhv7HuQ4Z0,46961
 raijin_server/modules/essentials.py,sha256=2xUXCyCQtFGd2DnCKV81N1R6bEJqH8zaet8mLovtQ1I,689
 raijin_server/modules/firewall.py,sha256=h6AISqiZeTinVT7BjmQIS872qRAFZJLg7meqlth3cfw,757
-raijin_server/modules/full_install.py,sha256=aR3yOuD7y0KLI20eMrxuFBNrWWn7JMpI4HFKNizEF3o,7464
+raijin_server/modules/full_install.py,sha256=xiKe2GLuZ97c4YdTmhP-kwDVuJJ9Xq3dlgcLlqSPeYM,15518
 raijin_server/modules/grafana.py,sha256=zxYpWBM-fD8vTgoJ2Hmb9P66wz_JuiidO6_cGK3jG30,1809
 raijin_server/modules/hardening.py,sha256=4hz3ifkMhPlXa2n7gPxN0gitQgzALZ-073vuU3LM4RI,1616
 raijin_server/modules/harness.py,sha256=dhZ89YIhlkuxiRU1deN6wXVWnXm0xeI03PwYf_qgfak,1527
@@ -24,7 +24,7 @@ raijin_server/modules/minio.py,sha256=BVvsEaJlJUV92_ep7pKsBhSYPjWZrDOB3J6XAWYAHY
 raijin_server/modules/network.py,sha256=bwVljaVvTc6FbbD-XtDpqqNL-fXMB9-iWVWsXToBvt4,4804
 raijin_server/modules/observability_dashboards.py,sha256=fVz0WEOQrUTF5rJ__Nu_onyBuwL_exFmysWMmg8AE9w,7319
 raijin_server/modules/observability_ingress.py,sha256=Fh1rlFWueBNHnOkHuoHYyhILmpO-iQXINybSUYbYsHQ,5738
-raijin_server/modules/prometheus.py,sha256=Et-Tj6LrM7WDyoYRSY464E67TrEHbRe2G8T8obagC48,1066
+raijin_server/modules/prometheus.py,sha256=Rs9BREmaoKlyteNdAQZnSIeJfsRO0RQKyyL2gTnXyCw,3716
 raijin_server/modules/sanitize.py,sha256=eytL_mCYF57qnjf6g752VRC4Yl27dDJ0OQP2rjxaR70,4523
 raijin_server/modules/secrets.py,sha256=xpV3gIMnwQdAI2j69Ck5daIK4wlYJA_1rkWTtSfVNk0,3715
 raijin_server/modules/ssh_hardening.py,sha256=oQdk-EVnEHNMKIWvoFuZzI4jK0nNO8IAY4hkB4pj8zw,4025
@@ -33,12 +33,12 @@ raijin_server/modules/velero.py,sha256=_CV0QQnWr5L-CWXDOiD9Ef4J7GaQT-s9yNBwqp_FL
 raijin_server/modules/vpn.py,sha256=hF-0vA17VKTxhQLDBSEeqI5aPQpiaaj4IpUf9l6lr64,8297
 raijin_server/scripts/__init__.py,sha256=deduGfHf8BMVWred4ux5LfBDT2NJ5XYeJAt2sDEU4qs,53
 raijin_server/scripts/checklist.sh,sha256=j6E0Kmk1EfjLvKK1VpCqzXJAXI_7Bm67LK4ndyCxWh0,1842
-raijin_server/scripts/install.sh,sha256=IZOTujOSGmKpznwgL59picsQNVzYkai6FtfFS3Klf34,3908
-raijin_server/scripts/log_size_metric.sh,sha256=rC2Ck4xnYVJV4Qymu24-indC8bkzfZs4FBqqxGPRl1I,1143
-raijin_server/scripts/pre-deploy-check.sh,sha256=naPUgKjnKgsh-eGDH2623C7zcr9VjDEw1H0lfYaXW8c,4853
-raijin_server-0.2.5.dist-info/licenses/LICENSE,sha256=kJsMCjOiRZE0AQNtxWqBa32z9kMAaF4EUxyHj3hKaJo,1105
-raijin_server-0.2.5.dist-info/METADATA,sha256=TVzTE_0qlyVoyy3lsoWfFn97hJylE_oKyXDFv32BMkg,18925
-raijin_server-0.2.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-raijin_server-0.2.5.dist-info/entry_points.txt,sha256=3ZvxDX4pvcjkIRsXAJ69wIfVmKa78LKo-C3QhqN2KVM,56
-raijin_server-0.2.5.dist-info/top_level.txt,sha256=Yz1xneCRtsZOzbPIcTAcrSxd-1p80pohMXYAZ74dpok,14
-raijin_server-0.2.5.dist-info/RECORD,,
+raijin_server/scripts/install.sh,sha256=Y1ickbQ4siQ0NIPs6UgrqUr8WWy7U0LHmaTQbEgavoI,3949
+raijin_server/scripts/log_size_metric.sh,sha256=Iv4SsX8AuCYRou-klYn32mX41xB6j0xJGLBO6riw4rU,1208
+raijin_server/scripts/pre-deploy-check.sh,sha256=XqMo7IMIpwUHF17YEmU0-cVmTDMoCGMBFnmS39FidI4,4912
+raijin_server-0.2.7.dist-info/licenses/LICENSE,sha256=kJsMCjOiRZE0AQNtxWqBa32z9kMAaF4EUxyHj3hKaJo,1105
+raijin_server-0.2.7.dist-info/METADATA,sha256=YpgpUhp0TYGWYwEkKd8nDpCLY0MfyWsCWPq7D0zTrJQ,20362
+raijin_server-0.2.7.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+raijin_server-0.2.7.dist-info/entry_points.txt,sha256=3ZvxDX4pvcjkIRsXAJ69wIfVmKa78LKo-C3QhqN2KVM,56
+raijin_server-0.2.7.dist-info/top_level.txt,sha256=Yz1xneCRtsZOzbPIcTAcrSxd-1p80pohMXYAZ74dpok,14
+raijin_server-0.2.7.dist-info/RECORD,,