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

raijin_server/modules/cert_manager.py

@@ -432,39 +432,347 @@ def _wait_for_webhook_ready(ctx: ExecutionContext, timeout: int = WEBHOOK_READY_
 # Instalação e Configuração
 # =============================================================================
 
-def _install_cert_manager_helm(ctx: ExecutionContext) -> bool:
-    """Instala cert-manager via Helm."""
-    typer.secho("\n📦 Instalando cert-manager via Helm...", fg=typer.colors.CYAN, bold=True)
+def _test_helm_repo_connectivity(ctx: ExecutionContext) -> bool:
+    """Testa conectividade com o repositório Helm antes de instalar."""
+    if ctx.dry_run:
+        return True
+    
+    logger.info("Testando conectividade com charts.jetstack.io")
+    typer.echo("  [1/5] Testando conectividade com charts.jetstack.io...")
     
     try:
-        # O helm_upgrade_install agora limpa releases pendentes automaticamente
-        helm_upgrade_install(
-            release="cert-manager",
-            chart=CHART_NAME,
-            namespace=NAMESPACE,
-            ctx=ctx,
-            repo="jetstack",
-            repo_url=CHART_REPO,
-            create_namespace=True,
-            extra_args=[
-                "--set", "installCRDs=true",
-                "--set", "webhook.timeoutSeconds=30",
-                "--set", "startupapicheck.timeout=5m",
-                "--set", "startupapicheck.enabled=true",
-                # Aumenta recursos para ambientes mais lentos
-                "--set", "webhook.replicaCount=1",
-                "--set", "cainjector.replicaCount=1",
-                "--wait",  # Espera o Helm considerar o release deployed
-                "--timeout", "10m",
-            ],
+        start = time.time()
+        result = subprocess.run(
+            ["curl", "-sI", "--connect-timeout", "15", f"{CHART_REPO}/index.yaml"],
+            capture_output=True,
+            text=True,
+            timeout=20,
         )
+        elapsed = time.time() - start
+        
+        if result.returncode == 0 and "200" in result.stdout:
+            logger.info(f"Repositório Helm acessível em {elapsed:.2f}s")
+            typer.secho(f"  ✓ Repositório Helm acessível ({elapsed:.2f}s)", fg=typer.colors.GREEN)
+            return True
+        else:
+            logger.error(f"Repositório retornou erro: {result.stdout[:200]}")
+            typer.secho(f"  ✗ Repositório retornou erro: {result.stdout[:100]}", fg=typer.colors.RED)
+            return False
+    except subprocess.TimeoutExpired:
+        logger.error("Timeout ao conectar com charts.jetstack.io")
+        typer.secho("  ✗ Timeout ao conectar com charts.jetstack.io (>15s)", fg=typer.colors.RED)
+        return False
+    except Exception as e:
+        logger.error(f"Erro de conectividade: {e}")
+        typer.secho(f"  ✗ Erro de conectividade: {e}", fg=typer.colors.RED)
+        return False
+
+
+def _test_image_registry_connectivity(ctx: ExecutionContext) -> bool:
+    """Testa conectividade com o registry de imagens."""
+    if ctx.dry_run:
         return True
+    
+    logger.info("Testando conectividade com quay.io (registry de imagens)")
+    typer.echo("  [2/5] Testando conectividade com quay.io (registry de imagens)...")
+    
+    try:
+        start = time.time()
+        result = subprocess.run(
+            ["curl", "-sI", "--connect-timeout", "15", "https://quay.io/v2/"],
+            capture_output=True,
+            text=True,
+            timeout=20,
+        )
+        elapsed = time.time() - start
+        
+        # quay.io retorna 401 para /v2/ sem auth, mas isso significa que está acessível
+        if result.returncode == 0 and ("200" in result.stdout or "401" in result.stdout):
+            logger.info(f"Registry quay.io acessível em {elapsed:.2f}s")
+            typer.secho(f"  ✓ Registry quay.io acessível ({elapsed:.2f}s)", fg=typer.colors.GREEN)
+            return True
+        else:
+            logger.warning(f"Registry pode estar inacessível: {result.stdout[:100]}")
+            typer.secho(f"  ⚠ Registry pode estar inacessível", fg=typer.colors.YELLOW)
+            return True  # Não bloqueia, apenas avisa
     except Exception as e:
-        typer.secho(f"✗ Erro na instalação do Helm: {e}", fg=typer.colors.RED)
-        ctx.errors.append(f"cert-manager: falha na instalação Helm - {e}")
+        logger.warning(f"Não foi possível testar registry: {e}")
+        typer.secho(f"  ⚠ Não foi possível testar registry: {e}", fg=typer.colors.YELLOW)
+        return True  # Não bloqueia
+
+
+def _add_helm_repo(ctx: ExecutionContext) -> bool:
+    """Adiciona e atualiza o repositório Helm."""
+    if ctx.dry_run:
+        typer.echo("  [3/5] [dry-run] Adicionando repositório Helm jetstack...")
+        return True
+    
+    logger.info("Adicionando repositório Helm jetstack")
+    typer.echo("  [3/5] Adicionando repositório Helm jetstack...")
+    
+    try:
+        start = time.time()
+        
+        # Adiciona repo
+        result = subprocess.run(
+            ["helm", "repo", "add", "jetstack", CHART_REPO, "--force-update"],
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+        
+        if result.returncode != 0:
+            logger.error(f"Falha ao adicionar repo: {result.stderr}")
+            typer.secho(f"  ✗ Falha ao adicionar repo: {result.stderr[:100]}", fg=typer.colors.RED)
+            return False
+        
+        elapsed_add = time.time() - start
+        logger.info(f"Repo adicionado em {elapsed_add:.2f}s")
+        typer.echo(f"      Repo adicionado ({elapsed_add:.2f}s)")
+        
+        # Atualiza repo
+        typer.echo("      Atualizando índice do repositório...")
+        start = time.time()
+        
+        result = subprocess.run(
+            ["helm", "repo", "update", "jetstack"],
+            capture_output=True,
+            text=True,
+            timeout=120,
+        )
+        
+        elapsed_update = time.time() - start
+        
+        if result.returncode != 0:
+            logger.error(f"Falha ao atualizar repo: {result.stderr}")
+            typer.secho(f"  ✗ Falha ao atualizar repo: {result.stderr[:100]}", fg=typer.colors.RED)
+            return False
+        
+        logger.info(f"Repo atualizado em {elapsed_update:.2f}s")
+        typer.secho(f"  ✓ Repositório configurado ({elapsed_add + elapsed_update:.2f}s total)", fg=typer.colors.GREEN)
+        return True
+        
+    except subprocess.TimeoutExpired:
+        logger.error("Timeout ao configurar repositório Helm")
+        typer.secho("  ✗ Timeout ao configurar repositório (>60s)", fg=typer.colors.RED)
+        return False
+    except Exception as e:
+        logger.error(f"Erro ao configurar repo: {e}")
+        typer.secho(f"  ✗ Erro: {e}", fg=typer.colors.RED)
         return False
 
 
+def _run_helm_install(ctx: ExecutionContext) -> bool:
+    """Executa o helm upgrade --install."""
+    if ctx.dry_run:
+        typer.echo("  [4/5] [dry-run] Executando helm upgrade --install...")
+        return True
+    
+    logger.info("Executando helm upgrade --install cert-manager")
+    typer.echo("  [4/5] Executando helm upgrade --install cert-manager...")
+    typer.echo("        (isso pode levar vários minutos)")
+    
+    cmd = [
+        "helm", "upgrade", "--install", "cert-manager", "jetstack/cert-manager",
+        "-n", NAMESPACE,
+        "--create-namespace",
+        "--set", "installCRDs=true",
+        "--set", "webhook.timeoutSeconds=30",
+        "--set", "startupapicheck.timeout=5m",
+        "--set", "startupapicheck.enabled=true",
+        "--set", "webhook.replicaCount=1",
+        "--set", "cainjector.replicaCount=1",
+        "--wait",
+        "--timeout", "15m",
+        "--debug",  # Mais logs
+    ]
+    
+    logger.info(f"Comando: {' '.join(cmd)}")
+    
+    try:
+        start = time.time()
+        
+        # Executa com output em tempo real para ver progresso
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+        )
+        
+        output_lines = []
+        last_log_time = time.time()
+        
+        while True:
+            line = process.stdout.readline()
+            if not line and process.poll() is not None:
+                break
+            if line:
+                output_lines.append(line)
+                logger.debug(line.strip())
+                
+                # Mostra progresso a cada 30s
+                if time.time() - last_log_time > 30:
+                    elapsed = int(time.time() - start)
+                    typer.echo(f"        ... ainda instalando ({elapsed}s)")
+                    last_log_time = time.time()
+        
+        elapsed = time.time() - start
+        return_code = process.poll()
+        
+        if return_code == 0:
+            logger.info(f"Helm install concluído em {elapsed:.2f}s")
+            typer.secho(f"  ✓ Helm install concluído ({elapsed:.2f}s)", fg=typer.colors.GREEN)
+            return True
+        else:
+            output = "".join(output_lines[-20:])  # Últimas 20 linhas
+            logger.error(f"Helm install falhou (código {return_code}): {output}")
+            typer.secho(f"  ✗ Helm install falhou (código {return_code})", fg=typer.colors.RED)
+            
+            # Mostra as últimas linhas do erro
+            typer.echo("\n  Últimas linhas do log:")
+            for line in output_lines[-10:]:
+                typer.echo(f"    {line.strip()}")
+            
+            return False
+            
+    except Exception as e:
+        logger.error(f"Erro durante helm install: {e}")
+        typer.secho(f"  ✗ Erro: {e}", fg=typer.colors.RED)
+        return False
+
+
+def _verify_installation(ctx: ExecutionContext) -> bool:
+    """Verifica se os pods estão rodando."""
+    if ctx.dry_run:
+        typer.echo("  [5/5] [dry-run] Verificando instalação...")
+        return True
+    
+    logger.info("Verificando pods do cert-manager")
+    typer.echo("  [5/5] Verificando pods do cert-manager...")
+    
+    try:
+        result = subprocess.run(
+            ["kubectl", "get", "pods", "-n", NAMESPACE, "-o", "wide"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        
+        if result.returncode == 0:
+            typer.echo(f"\n{result.stdout}")
+            
+            # Verifica se todos estão Running
+            if "Running" in result.stdout and "0/1" not in result.stdout:
+                logger.info("Todos os pods estão Running")
+                typer.secho("  ✓ Todos os pods estão Running", fg=typer.colors.GREEN)
+                return True
+            else:
+                logger.warning("Alguns pods podem não estar prontos")
+                typer.secho("  ⚠ Alguns pods podem não estar prontos", fg=typer.colors.YELLOW)
+                return True  # Não falha, o wait_for_webhook vai verificar
+        else:
+            logger.error(f"Erro ao verificar pods: {result.stderr}")
+            return False
+            
+    except Exception as e:
+        logger.error(f"Erro ao verificar pods: {e}")
+        return False
+
+
+def _install_cert_manager_helm(ctx: ExecutionContext) -> bool:
+    """Instala cert-manager via Helm com logs detalhados."""
+    typer.secho("\n📦 Instalando cert-manager via Helm...", fg=typer.colors.CYAN, bold=True)
+    logger.info("Iniciando instalação do cert-manager")
+    
+    start_total = time.time()
+    
+    # Etapa 1: Testa conectividade com repo Helm
+    if not _test_helm_repo_connectivity(ctx):
+        typer.secho(
+            "\n⚠ Problema de conectividade com o repositório Helm.",
+            fg=typer.colors.YELLOW,
+        )
+        typer.echo("  Teste manual: curl -sI https://charts.jetstack.io/index.yaml")
+        if not typer.confirm("Tentar instalar mesmo assim?", default=False):
+            return False
+    
+    # Etapa 2: Testa conectividade com registry de imagens
+    _test_image_registry_connectivity(ctx)
+    
+    # Etapa 3: Adiciona e atualiza repo Helm
+    if not _add_helm_repo(ctx):
+        return False
+    
+    # Etapa 4: Executa helm install
+    if not _run_helm_install(ctx):
+        _show_diagnostic_info(ctx)
+        return False
+    
+    # Etapa 5: Verifica instalação
+    _verify_installation(ctx)
+    
+    elapsed_total = time.time() - start_total
+    logger.info(f"Instalação do cert-manager concluída em {elapsed_total:.2f}s")
+    typer.secho(f"\n✓ Instalação concluída em {elapsed_total:.2f}s", fg=typer.colors.GREEN)
+    
+    return True
+
+
+def _show_diagnostic_info(ctx: ExecutionContext) -> None:
+    """Mostra informações de diagnóstico quando falha."""
+    if ctx.dry_run:
+        return
+    
+    typer.secho("\n🔍 Informações de diagnóstico:", fg=typer.colors.YELLOW, bold=True)
+    
+    # Pods
+    typer.echo("\n  Pods:")
+    try:
+        result = subprocess.run(
+            ["kubectl", "get", "pods", "-n", NAMESPACE, "-o", "wide"],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+        if result.stdout:
+            for line in result.stdout.strip().split("\n"):
+                typer.echo(f"    {line}")
+    except Exception:
+        typer.echo("    (não foi possível obter pods)")
+    
+    # Eventos recentes
+    typer.echo("\n  Eventos recentes:")
+    try:
+        result = subprocess.run(
+            ["kubectl", "get", "events", "-n", NAMESPACE, "--sort-by=.lastTimestamp"],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+        if result.stdout:
+            lines = result.stdout.strip().split("\n")
+            for line in lines[-10:]:  # Últimos 10 eventos
+                typer.echo(f"    {line[:120]}")
+    except Exception:
+        typer.echo("    (não foi possível obter eventos)")
+    
+    # Helm status
+    typer.echo("\n  Helm release status:")
+    try:
+        result = subprocess.run(
+            ["helm", "status", "cert-manager", "-n", NAMESPACE],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+        if result.stdout:
+            for line in result.stdout.strip().split("\n")[:15]:
+                typer.echo(f"    {line}")
+    except Exception:
+        typer.echo("    (não foi possível obter status do Helm)")
+
+
 def _apply_manifest_with_retry(
     manifest: str,
     ctx: ExecutionContext,

raijin_server/utils.py

@@ -317,6 +317,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 +446,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.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: raijin-server
-Version: 0.2.5
+Version: 0.2.6
 Summary: CLI para automacao de setup e hardening de servidores Ubuntu Server.
 Home-page: https://example.com/raijin-server
 Author: Equipe Raijin

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

@@ -2,13 +2,13 @@ raijin_server/__init__.py,sha256=7-69Vj-HYrv98hWrKmwDqDQ-ehtTqJebx1JeP4St6Q4,94
 raijin_server/cli.py,sha256=PfuIXc-pw1yZtJzCrxDVSWSsPAVBt9wqZBF-dWh6mwo,19274
 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=Gs182mcLVM3ClCADFIK9Qi1fQA7BfunaTu0ie-8pAvo,19692
 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/cert_manager.py,sha256=Kb8N60j3BDjkNS8t8aTsdsKy5syRWobccP3PBpv-Q8E,45887
 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
@@ -36,9 +36,9 @@ raijin_server/scripts/checklist.sh,sha256=j6E0Kmk1EfjLvKK1VpCqzXJAXI_7Bm67LK4ndy
 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-0.2.6.dist-info/licenses/LICENSE,sha256=kJsMCjOiRZE0AQNtxWqBa32z9kMAaF4EUxyHj3hKaJo,1105
+raijin_server-0.2.6.dist-info/METADATA,sha256=KXv3RV6GSO2qQJ85n_SFJP6h10rbph0WbTJ611fG-M4,18925
+raijin_server-0.2.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+raijin_server-0.2.6.dist-info/entry_points.txt,sha256=3ZvxDX4pvcjkIRsXAJ69wIfVmKa78LKo-C3QhqN2KVM,56
+raijin_server-0.2.6.dist-info/top_level.txt,sha256=Yz1xneCRtsZOzbPIcTAcrSxd-1p80pohMXYAZ74dpok,14
+raijin_server-0.2.6.dist-info/RECORD,,