From 50f9aeeb18a15c6c27c9320f29023170cfa71104 Mon Sep 17 00:00:00 2001 From: t00ls-dev <14156701+t00ls-dev@users.noreply.github.com> Date: Wed, 29 Jul 2026 00:44:45 +0000 Subject: [PATCH] plexden: adiciona uninstall e doctor MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit uninstall — para os serviços, revoga o Cloudflare Tunnel de verdade na conta (cloudflared tunnel delete, não só apaga local), desinstala Plex/qBittorrent/cloudflared e limpa os stubs/config que o provision.sh criou. $PLEXDEN_HOME (mídia, banco do Plex) fica intacto por padrão; --purge apaga isso também, mas exige digitar "APAGAR" num terminal interativo mesmo com --yes passado — não tem volta. O usuário do sistema nunca é removido automaticamente, por segurança. doctor — diagnóstico só-leitura (dispensa root): usuário da stack, /etc/plexden.conf, pacotes instalados, os três serviços respondendo, credentials.env, espaço em disco. Resume tudo como OK/AVISO/ERRO. --- README.md | 19 +++ plexden | 297 ++++++++++++++++++++++++++++++++++++++++ tests/test_uninstall.py | 92 +++++++++++++ 3 files changed, 408 insertions(+) create mode 100644 tests/test_uninstall.py diff --git a/README.md b/README.md index d1798fc..3509c3a 100644 --- a/README.md +++ b/README.md @@ -282,6 +282,8 @@ plexden postprocess "" "" # o AutoRun do qBittorrent chama is plexden links [--apply] # download apagado? tira o link da biblioteca plexden links --scan [--apply] # redescobre pares por inode (nunca remove) sudo plexden update # atualiza o Plex pelo pacote oficial (.deb/.rpm) +sudo plexden uninstall [--purge] [--yes] # desinstala a stack (--purge apaga a mídia também) +plexden doctor # diagnóstico rápido, só leitura ``` O que cada comando faz: @@ -370,6 +372,23 @@ O que cada comando faz: respeita o canal da sua conta. Se a instalação do pacote falhar, ele sai com erro apontando o backup — em vez de deixar você com o Plex parado e um "Pronto" na tela. +- **`uninstall`** — para os serviços, desinstala Plex/qBittorrent/cloudflared + e limpa tudo que o `provision.sh` criou no sistema (stubs, `/etc/plexden.conf` + etc.). Se houver um Cloudflare Tunnel configurado, ele também é **revogado + de verdade na Cloudflare** (`cloudflared tunnel delete`), não só apagado + localmente — o registro DNS que aponta pra ele, porém, não some sozinho; + isso precisa ser removido à mão pelo painel da Cloudflare. Por padrão + `$PLEXDEN_HOME` (mídia, banco do Plex, torrents) **fica intacto**; use + `--purge` se quiser apagar isso também — que pede uma segunda confirmação + específica (digitar `APAGAR`), inclusive quando `--yes` já foi passado, já + que essa parte não tem volta. Sem terminal interativo, `--purge` se recusa + a rodar; a desinstalação normal aceita `--yes` para automação. +- **`doctor`** — só leitura, dispensa root: roda uma bateria de checagens + (usuário da stack, `/etc/plexden.conf`, pacotes do Plex/qBittorrent + instalados, os três serviços respondendo, `credentials.env`, espaço em + disco) e resume tudo como `[OK]`, `[AVISO]` ou `[ERRO]`. Não muda nada no + sistema — é o primeiro comando pra rodar quando algo parece errado, antes + de ir atrás de log. ## Problemas comuns diff --git a/plexden b/plexden index cd0d549..89da79e 100755 --- a/plexden +++ b/plexden @@ -14,6 +14,8 @@ pacote via pip). plexden postprocess "" "" (AutoRun do qB) plexden links [--scan] [--apply] (limpa a biblioteca) plexden update (root) + plexden uninstall [--purge] [--yes] (root) + plexden doctor (dispensa root) plexden plex-exec (entrypoint do Plex) plexden _init {start|stop|status|restart} (stub SysV) @@ -1260,6 +1262,297 @@ def cmd_update(args): return 0 +# ============================================================ UNINSTALL ======= +CF_ETC = "/etc/cloudflared" +CF_BIN = "/usr/local/bin/cloudflared" +STACK_STUB = "/usr/local/bin/plex-stack-start" + + +def _du_sh(path): + r = sh(["du", "-sh", path]) + return r.stdout.split()[0] if r.returncode == 0 and r.stdout else "?" + + +def _confirmar(pergunta): + """False sem terminal interativo — nunca trava esperando um input que + nao vai chegar (ex.: rodado de um script sem --yes por engano).""" + if not sys.stdin.isatty(): + return False + try: + resposta = input(pergunta) + except (EOFError, KeyboardInterrupt): + return False + return resposta.strip().lower() in ("s", "sim", "y", "yes") + + +def _cf_tunnel_uuid(): + """UUID e cert.pem do tunnel configurado, procurando primeiro no volume + persistente (fonte da verdade) e so depois em /etc (pode ter sido + restaurado so ali numa instalacao antiga).""" + for base in (os.path.join(PERSIST, "cloudflared"), CF_ETC): + cert = os.path.join(base, "cert.pem") + if not os.path.isfile(cert): + continue + try: + nomes = os.listdir(base) + except OSError: + continue + for nome in nomes: + if nome.endswith(".json"): + return nome[:-5], cert + return None, None + + +def _uninstall_tunnel(): + uuid, cert = _cf_tunnel_uuid() + if not uuid: + print(" sem credenciais de tunnel — nada a revogar") + return + if not shutil.which("cloudflared"): + print(" cloudflared nao esta mais instalado — pulei a revogacao do tunnel") + return + print(f" revogando o tunnel {uuid} na Cloudflare...") + # --origincert explicito: nao da pra confiar que ~/.cloudflared/cert.pem + # (onde o 'tunnel login' original deixou o certificado) ainda exista — + # o cert que sobrevive de verdade e o copiado para o volume persistente. + base = ["timeout", "60", "cloudflared", "tunnel", "--origincert", cert] + sh(base + ["cleanup", uuid]) + r = sh(base + ["delete", uuid]) + if r.returncode == 0: + print(" tunnel revogado na Cloudflare") + else: + detalhe = (r.stderr or r.stdout or "").strip() + print(f" AVISO: nao consegui revogar o tunnel automaticamente ({detalhe})") + print(f" revogue na mao depois: cloudflared tunnel --origincert {cert} delete {uuid}") + print(" lembrete: se algum dominio foi apontado pro tunnel (route dns), o") + print(" registro DNS continua la — remova pelo painel da Cloudflare.") + + +def _uninstall_pacotes(): + mgr = _detect_pkg() + if not mgr: + print(" gerenciador de pacotes nao reconhecido — remova") + print(" plexmediaserver e qbittorrent-nox manualmente") + return + pkgs = ["plexmediaserver", "qbittorrent-nox"] + if mgr == "apt-get": + sh(["apt-get", "remove", "-y", "-qq"] + pkgs) + _rm("/etc/apt/sources.list.d/plexmediaserver.list") + _rm("/etc/apt/keyrings/plex.gpg") + else: + sh([mgr, "remove", "-y", "-q"] + pkgs) + _rm("/etc/yum.repos.d/plex.repo") + print(" pacotes removidos (config e midia continuam intactos)") + + +def _uninstall_arquivos(): + # 'service uninstall' remove a unit do systemd ou o script SysV — o que + # o 'service install' do provision.sh tiver criado — sem a gente ter que + # adivinhar qual dos dois caminhos foi usado. + if shutil.which("cloudflared"): + sh(["cloudflared", "service", "uninstall"]) + _rm(CF_BIN) + shutil.rmtree(CF_ETC, ignore_errors=True) + _rm(INIT_PLEX) + _rm(STACK_STUB) + _rm("/etc/plexden.conf") + try: + import pwd + home = pwd.getpwnam(PLEX_USER).pw_dir + _rm(os.path.join(home, "bin", "plex-start")) + except (KeyError, OSError): + pass + print(" stubs, binarios e config do sistema removidos") + + +def cmd_uninstall(args): + require_root("uninstall") + purge = "--purge" in args + pula_confirmacao = "--yes" in args or "-y" in args + + print("== O que sera removido ==") + print(" Servicos, os pacotes Plex/qBittorrent, o cloudflared, o tunnel na") + print(" Cloudflare (se houver) e os arquivos que o provision.sh criou.") + if purge: + tam = _du_sh(PERSIST) if os.path.isdir(PERSIST) else "?" + print(f"\n --purge: TAMBEM apaga {PERSIST} inteiro — midia, banco do Plex,") + print(f" torrents ({tam}). ISSO NAO TEM VOLTA.") + + if not pula_confirmacao and not _confirmar("\nContinuar? [s/N] "): + print("cancelado") + return 1 + + if purge: + # O purge apaga dado do usuario, entao confirma sempre de novo, com + # uma resposta que nao sai sem querer de um '--yes' apertado na pressa + # — nem sequer o '--yes' da base dispensa esta segunda confirmacao. + tam = _du_sh(PERSIST) if os.path.isdir(PERSIST) else "?" + if not sys.stdin.isatty(): + print("ERRO: --purge exige confirmacao num terminal interativo") + return 1 + try: + resp = input(f"\nDigite APAGAR para apagar {PERSIST} ({tam}) de vez: ") + except (EOFError, KeyboardInterrupt): + resp = "" + if resp.strip() != "APAGAR": + print("purge cancelado (o resto da desinstalacao continua)") + purge = False + + do_stop() + + print("\n== Cloudflare Tunnel ==") + _uninstall_tunnel() + + print("\n== Pacotes ==") + _uninstall_pacotes() + + print("\n== Arquivos e stubs ==") + _uninstall_arquivos() + + if purge: + print("\n== Purge ==") + if os.path.isdir(PERSIST): + shutil.rmtree(PERSIST, ignore_errors=True) + print(f" {PERSIST} removido") + try: + import pwd + pwd.getpwnam(PLEX_USER) + print(f" usuario '{PLEX_USER}' NAO foi removido automaticamente") + print(f" (se quiser: userdel -r {PLEX_USER})") + except KeyError: + pass + else: + print(f"\n {PERSIST} preservado — midia e banco do Plex intactos") + + print("\n== Pronto ==") + _rm(os.path.abspath(sys.argv[0])) + return 0 + + +# ============================================================ DOCTOR ========== +# Diagnostico somente-leitura: nao muda nada no sistema, so relata. Dispensa +# root pelo mesmo motivo que 'services status' dispensa — cada checagem aqui +# ja e leitura (HTTP, statvfs, dpkg/rpm -q, pwd). +def _doc(nivel, msg): + return (nivel, msg) + + +def _check_usuario(): + try: + import pwd + pwd.getpwnam(PLEX_USER) + return _doc("OK", f"usuario da stack '{PLEX_USER}' existe") + except KeyError: + return _doc("ERRO", f"usuario '{PLEX_USER}' nao existe") + + +def _check_conf(): + if os.path.isfile("/etc/plexden.conf"): + return _doc("OK", "/etc/plexden.conf presente") + return _doc("AVISO", "/etc/plexden.conf ausente — rode o provision.sh") + + +def _check_pacote_plex(): + mgr = _detect_pkg() + fam = _pkg_family(mgr) if mgr else None + if not fam: + return _doc("AVISO", "gerenciador de pacotes nao reconhecido — nao da pra checar o pacote do Plex") + ver = _plex_version_installed(fam) + if ver: + return _doc("OK", f"pacote do Plex instalado (v{ver})") + return _doc("ERRO", "pacote do Plex (plexmediaserver) nao instalado") + + +def _check_pacote_qbit(): + if shutil.which("qbittorrent-nox"): + return _doc("OK", "qbittorrent-nox instalado") + return _doc("ERRO", "qbittorrent-nox nao encontrado") + + +def _check_plex(): + if plex_ok(): + ident = http_get(f"{PLEX_URL}/identity", timeout=5) + cm = re.search(r'claimed="([01])"', ident) + claimed = cm.group(1) if cm else "?" + if claimed == "0": + return _doc("AVISO", "Plex no ar, mas nao reivindicado (veja plex.tv/claim)") + return _doc("OK", f"Plex respondendo (claimed={claimed})") + if _plex_running_pid(): + return _doc("ERRO", "Plex: processo vivo mas HTTP nao responde (travado)") + return _doc("AVISO", "Plex parado") + + +def _check_qbit(): + if qbit_ok(): + return _doc("OK", "qBittorrent respondendo") + if pgrep_x("qbittorrent-nox"): + return _doc("ERRO", "qBittorrent: processo vivo mas HTTP nao responde") + return _doc("AVISO", "qBittorrent parado") + + +def _check_cloudflared(): + if not cf_configured(): + return _doc("OK", "cloudflared nao configurado (opcional)") + if cf_ok(): + return _doc("OK", "cloudflared rodando") + return _doc("AVISO", "cloudflared configurado mas parado") + + +def _check_credenciais_qb(): + caminho = os.path.join(PERSIST, "credentials.env") + if os.path.isfile(caminho): + return _doc("OK", "credentials.env presente") + return _doc("AVISO", "credentials.env ausente — 'plexden qb' vai pedir ~/.qbcreds") + + +def _check_disco(): + try: + st = os.statvfs(PERSIST) + total = st.f_blocks * st.f_frsize + free = st.f_bavail * st.f_frsize + if not total: + return _doc("AVISO", f"{PERSIST}: nao foi possivel medir o espaco") + pct_livre = free * 100 / total + gb = lambda b: f"{b / (1024**3):.0f}G" + msg = f"{PERSIST}: {gb(free)} livres de {gb(total)} ({pct_livre:.0f}% livre)" + if pct_livre < 5: + return _doc("ERRO", msg + " — espaco critico") + if pct_livre < 15: + return _doc("AVISO", msg + " — espaco baixo") + return _doc("OK", msg) + except OSError: + return _doc("ERRO", f"{PERSIST} inacessivel — rode o provision.sh") + + +def cmd_doctor(args): + checks = [ + _check_usuario(), + _check_conf(), + _check_pacote_plex(), + _check_pacote_qbit(), + _check_plex(), + _check_qbit(), + _check_cloudflared(), + _check_credenciais_qb(), + _check_disco(), + ] + print("== plexden doctor ==\n") + for nivel, msg in checks: + print(f"[{nivel:<5}] {msg}") + + erros = sum(1 for n, _ in checks if n == "ERRO") + avisos = sum(1 for n, _ in checks if n == "AVISO") + print() + if erros: + print(f"{erros} erro(s), {avisos} aviso(s) — veja acima") + return 1 + if avisos: + print(f"tudo certo, {avisos} aviso(s) — veja acima") + return 0 + print("tudo certo") + return 0 + + # ============================================================ DISPATCH ======== USAGE = """plexden — stack Plex + qBittorrent + Cloudflare @@ -1270,6 +1563,8 @@ USAGE = """plexden — stack Plex + qBittorrent + Cloudflare plexden links [--apply] fonte do torrent apagada -> remove o hardlink plexden links --scan [--apply] redescobre pares por inode (nunca remove) plexden update (root) + plexden uninstall [--purge] [--yes] (root) + plexden doctor (dispensa root) plexden plex-exec plexden _init {start|stop|restart|status} """ @@ -1286,6 +1581,8 @@ def main(argv): "postprocess": cmd_postprocess, "links": cmd_links, "update": cmd_update, + "uninstall": cmd_uninstall, + "doctor": cmd_doctor, "plex-exec": cmd_plex_exec, "_init": cmd_init, } diff --git a/tests/test_uninstall.py b/tests/test_uninstall.py new file mode 100644 index 0000000..26ee10b --- /dev/null +++ b/tests/test_uninstall.py @@ -0,0 +1,92 @@ +#!/usr/bin/env python3 +"""'plexden uninstall': deteccao das credenciais do Cloudflare Tunnel. + +So cobre a parte pura (sem tocar em pacotes, servicos ou no sistema de +arquivos fora de um diretorio temporario): _cf_tunnel_uuid() precisa achar o +par UUID/cert.pem certo, preferindo o volume persistente sobre /etc (que pode +estar desatualizado numa reinstalacao), e nao explodir quando nada esta +configurado. O resto do comando (parar servicos, remover pacotes, revogar o +tunnel na Cloudflare) e destrutivo por natureza e foi validado manualmente +com binarios falsos, nao aqui. +""" +import importlib.machinery +import importlib.util +import os +import tempfile +import unittest + +RAIZ = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + + +def _carrega_plexden(home): + os.environ["PLEXDEN_HOME"] = home + loader = importlib.machinery.SourceFileLoader( + "plexden_uninstall", os.path.join(RAIZ, "plexden")) + spec = importlib.util.spec_from_loader(loader.name, loader) + mod = importlib.util.module_from_spec(spec) + loader.exec_module(mod) + return mod + + +class TestCfTunnelUuid(unittest.TestCase): + def setUp(self): + self._tmp = tempfile.TemporaryDirectory() + self.persist = self._tmp.name + self.addCleanup(self._tmp.cleanup) + self.mod = _carrega_plexden(self.persist) + # /etc/cloudflared de verdade nao deve vazar para o teste. + self._etc_tmp = tempfile.TemporaryDirectory() + self.addCleanup(self._etc_tmp.cleanup) + self.mod.CF_ETC = os.path.join(self._etc_tmp.name, "cloudflared") + + def test_sem_credenciais_devolve_none(self): + self.assertEqual(self.mod._cf_tunnel_uuid(), (None, None)) + + def test_acha_uuid_e_cert_no_volume_persistente(self): + cfdir = os.path.join(self.persist, "cloudflared") + os.makedirs(cfdir) + open(os.path.join(cfdir, "cert.pem"), "w").close() + uuid = "12345678-1234-1234-1234-123456789012" + open(os.path.join(cfdir, f"{uuid}.json"), "w").close() + + achado_uuid, achado_cert = self.mod._cf_tunnel_uuid() + self.assertEqual(achado_uuid, uuid) + self.assertEqual(achado_cert, os.path.join(cfdir, "cert.pem")) + + def test_prefere_volume_persistente_sobre_etc(self): + """/etc pode ter sobrado de uma instalacao antiga — o volume manda.""" + cfdir = os.path.join(self.persist, "cloudflared") + os.makedirs(cfdir) + open(os.path.join(cfdir, "cert.pem"), "w").close() + uuid_bom = "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa" + open(os.path.join(cfdir, f"{uuid_bom}.json"), "w").close() + + os.makedirs(self.mod.CF_ETC) + open(os.path.join(self.mod.CF_ETC, "cert.pem"), "w").close() + uuid_velho = "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb" + open(os.path.join(self.mod.CF_ETC, f"{uuid_velho}.json"), "w").close() + + achado_uuid, _ = self.mod._cf_tunnel_uuid() + self.assertEqual(achado_uuid, uuid_bom) + + def test_cai_para_etc_se_persist_nao_tem_cert(self): + os.makedirs(self.mod.CF_ETC) + open(os.path.join(self.mod.CF_ETC, "cert.pem"), "w").close() + uuid = "cccccccc-cccc-cccc-cccc-cccccccccccc" + open(os.path.join(self.mod.CF_ETC, f"{uuid}.json"), "w").close() + + achado_uuid, achado_cert = self.mod._cf_tunnel_uuid() + self.assertEqual(achado_uuid, uuid) + self.assertEqual(achado_cert, os.path.join(self.mod.CF_ETC, "cert.pem")) + + def test_cert_sem_json_nao_conta(self): + """cert.pem sozinho, sem nenhum .json, e' credencial incompleta.""" + cfdir = os.path.join(self.persist, "cloudflared") + os.makedirs(cfdir) + open(os.path.join(cfdir, "cert.pem"), "w").close() + + self.assertEqual(self.mod._cf_tunnel_uuid(), (None, None)) + + +if __name__ == "__main__": + unittest.main(verbosity=2)