diff --git a/.github/workflows/validate.yml b/.github/workflows/validate.yml index eeca99a..6e83f87 100644 --- a/.github/workflows/validate.yml +++ b/.github/workflows/validate.yml @@ -13,44 +13,19 @@ jobs: steps: - uses: actions/checkout@v4 - - name: Install ShellCheck + - name: Install validation tools run: | sudo apt-get update - sudo apt-get install -y shellcheck + sudo apt-get install -y jq shellcheck - - name: Validate shell syntax - run: bash -n install_media.sh update_stack.sh sync_transmission_port.sh + - name: Validate shell and Compose invariants + run: bash tests/validate.sh - name: Run ShellCheck - run: shellcheck --severity=error install_media.sh update_stack.sh sync_transmission_port.sh - - - name: Extract generated Compose configuration - run: | - python3 - <<'PY' - from pathlib import Path - - source = Path("install_media.sh").read_text() - marker = 'cat > "$INSTALL_DIR/docker-compose.yml" < /tmp/media-stack.env <<'EOF' - PUID=1000 - PGID=1000 - INSTALL_DIR=/tmp/media-stack - LAN_IP=192.0.2.10 - VPN_USER=test+pmp - VPN_PASS=test - PANGOLIN_ENDPOINT=https://pangolin.example.com - NEWT_ID=test - NEWT_SECRET=test - PUBLIC_DOMAIN=example.com - TZ=Europe/Warsaw - TR_USER=admin - TR_PASS=test - EOF - - - name: Validate generated Compose configuration - run: docker compose --env-file /tmp/media-stack.env -f /tmp/docker-compose.yml config --quiet + run: >- + shellcheck --severity=warning + proxmox_lxc.sh + install_media.sh + media_stack.sh + update_stack.sh + sync_transmission_port.sh diff --git a/README.md b/README.md index 867b27d..032f423 100644 --- a/README.md +++ b/README.md @@ -1,319 +1,329 @@ -# Media Stack Installer +# Media Stack dla Proxmox LXC -Interaktywny instalator stosu multimedialnego dla Debiana lub Ubuntu, przygotowany przede wszystkim do działania w kontenerze LXC na Proxmox VE. Konfiguruje Docker, ProtonVPN, Pangolin, Tailscale, automatyczne przekazywanie portu do Transmission oraz opóźnione aktualizacje kontenerów. +Produkcyjny instalator kompletnego stacku multimedialnego. Główny skrypt jest +uruchamiany **na serwerze Proxmox VE**: tworzy osobny, nieuprzywilejowany LXC z +Debianem 13, przygotowuje urządzenia i uruchamia instalator aplikacji **wewnątrz +tego LXC**. -## Instalacja od zera na Proxmox VE +Docker ani żadna aplikacja multimedialna nie są instalowane na hoście Proxmox. -Poniższa procedura prowadzi od świeżego hosta Proxmox do działającego stosu. Zakłada, że Proxmox VE jest już zainstalowany i panel WWW działa. Polecenia oznaczone jako **host Proxmox** wykonuj w powłoce węzła Proxmox, a oznaczone jako **LXC** — w konsoli utworzonego kontenera. +## Co powstaje -### 1. Przygotuj potrzebne dane - -Przed rozpoczęciem przygotuj: - -- płatne konto ProtonVPN obsługujące port forwarding; -- **osobny login i hasło OpenVPN** z panelu ProtonVPN: `Account → OpenVPN username` — nie są to dane logowania do konta Proton; -- adres endpointu Pangolin, np. `https://pangolin.example.com`; -- identyfikator i sekret tunelu Newt utworzonego w Pangolin; -- domenę bazową używaną przez Pangolin, np. `example.com`; -- konto Tailscale, do którego zostanie dodany serwer; -- opcjonalnie zamontowany katalog NAS przeznaczony na drugi egzemplarz backupu konfiguracji. - -Nie dopisuj `+pmp` do loginu OpenVPN. Instalator robi to automatycznie. +```text +Proxmox VE host +└── nieuprzywilejowany LXC „media” + ├── Docker Engine + Compose + ├── Gluetun → ProtonVPN → Transmission + ├── Radarr, Sonarr, Prowlarr, Bazarr + ├── Jellyfin i Seerr + ├── opcjonalny FlareSolverr + ├── opcjonalny Newt → Pangolin + ├── opcjonalny Tailscale + ├── automatyczne spięcie aplikacji ARR + ├── synchronizacja portu ProtonVPN → Transmission + └── opóźnione aktualizacje z backupem i rollbackiem +``` -### 2. Pobierz szablon systemu +Provisioner może również przekazać urządzenie renderujące Intel/AMD do Jellyfin +i utworzyć osobny, zarządzany przez Proxmox wolumin na media. -W panelu Proxmox przejdź do magazynu przechowującego szablony, wybierz `CT Templates` i pobierz aktualny 64-bitowy szablon Debiana. Zalecany jest Debian 13; Debian 12 i aktualne wydania Ubuntu również są obsługiwane przez instalator. +## Najszybsza instalacja -### 3. Utwórz LXC +### 1. Przygotuj dane -Wybierz `Create CT` i ustaw: +Przed startem warto mieć: -| Ustawienie | Zalecana wartość | -| --- | --- | -| Unprivileged container | włączone | -| Hostname | `media` | -| Start at boot | włączone | -| CPU | 4 rdzenie | -| RAM | 8 GB; praktyczne minimum to 4 GB bez ciężkiego transkodowania | -| Swap | 512 MB–1 GB | -| Dysk systemowy | co najmniej 32 GB | -| Network | `vmbr0`, DHCP na czas tworzenia | -| DNS | ustawienia hosta lub własny serwer DNS | +- płatne konto ProtonVPN z port forwardingiem; +- dla zalecanego WireGuard: klucz `PrivateKey` z konfiguracji ProtonVPN + wygenerowanej z włączonym NAT-PMP; +- albo osobny login i hasło OpenVPN z panelu ProtonVPN — nie dane konta; +- opcjonalnie endpoint, ID i sekret Newt z Pangolin; +- opcjonalnie konto Tailscale; +- adresację sieci: DHCP z rezerwacją lub statyczny IPv4; +- decyzję, na którym storage Proxmox mają znajdować się system i media. -Po utworzeniu LXC ustaw w routerze rezerwację DHCP dla jego adresu MAC. Możesz zamiast tego skonfigurować statyczny IPv4 w Proxmox, ale przed instalacją adres musi być już docelowy. Instalator zapisuje go w powiązaniach portów Dockera; późniejsza zmiana IP wymaga ponownego wygenerowania konfiguracji. +OpenVPN wymaga sufiksu `+pmp`; instalator dodaje go sam i nie dubluje, jeśli już +jest obecny. -Nie uruchamiaj jeszcze instalatora. +### 2. Uruchom provisioner na hoście Proxmox -### 4. Włącz TUN, nesting i keyctl +Zaloguj się do powłoki **hosta Proxmox jako root** i pobierz skrypt do pliku: -Tailscale i Gluetun potrzebują `/dev/net/tun`, a Docker wewnątrz nieuprzywilejowanego LXC wymaga `nesting` oraz `keyctl`. +```bash +installer=$(mktemp) +curl -fsSL https://raw.githubusercontent.com/placq/media-stack/main/proxmox_lxc.sh -o "$installer" +bash "$installer" +rm -f "$installer" +``` -W aktualnym interfejsie Proxmox: +Nie uruchamiaj tego polecenia na laptopie ani stacji roboczej. Provisioner ma +twardą kontrolę środowiska i zakończy się, jeśli nie wykryje hosta Proxmox VE. -1. Otwórz LXC `media`. -2. W `Options → Features` włącz `Nesting` i `Keyctl`. -3. W `Resources` wybierz `Add → Device Passthrough`. -4. Jako `Device Path` podaj `/dev/net/tun` (w niektórych wersjach UI: `dev/net/tun`). -5. Zatrzymaj LXC poleceniem `Stop`, a następnie uruchom go ponownie. Sam restart systemu wewnątrz LXC nie wystarczy. +Nie używaj `curl | bash`. Provisioner celowo wymaga interaktywnego terminala i +przed utworzeniem LXC wyświetla kompletny plan do zatwierdzenia. -To samo można wykonać z powłoki **hosta Proxmox**. Zastąp `120` rzeczywistym numerem kontenera: +Skrypt poprosi o: -```bash -CTID=120 -pct set "$CTID" --dev0 /dev/net/tun -pct set "$CTID" --features keyctl=1,nesting=1 -pct stop "$CTID" -pct start "$CTID" -``` +1. nowy CT ID i hostname; +2. storage oraz rozmiar dysku systemowego; +3. CPU, RAM i swap; +4. bridge, DHCP/statyczny IPv4 i opcjonalny VLAN; +5. opcjonalny osobny wolumin `/opt/media-stack/data`; +6. czy ten wolumin ma wejść do backupów `vzdump`; +7. opcjonalne przekazanie iGPU; +8. ostateczne potwierdzenie utworzenia LXC. -Tailscale będzie zainstalowany **wewnątrz LXC `media`**. Nie trzeba instalować go na hoście Proxmox. +Następnie automatycznie: -### 5. Opcjonalnie dodaj osobny dysk na media +- odświeży katalog `pveam` i pobierze najnowszy szablon Debian 13; +- utworzy nowy, nieuprzywilejowany LXC; +- włączy `nesting=1` i `keyctl=1` wymagane przez Docker; +- przekaże `/dev/net/tun` wymagany przez Gluetun i Tailscale; +- uruchomi LXC i poczeka na systemd, sieć oraz TUN; +- przeniesie do LXC jeden spójny snapshot projektu; +- uruchomi wewnętrzny kreator usług. -Najprostszy wariant to zarządzany przez Proxmox punkt montowania: +Druga seria pytań widoczna w tym samym terminalu dotyczy już wyłącznie +konfiguracji wewnątrz LXC: VPN, Pangolin, Transmission, Tailscale, FlareSolverr, +backupu zewnętrznego oraz transkodowania sprzętowego. -1. Otwórz `LXC → Resources → Add → Mount Point`. -2. Wybierz magazyn i rozmiar. -3. Ustaw ścieżkę wewnątrz kontenera na `/opt/media-stack/data`. -4. Zdecyduj, czy dane multimedialne mają być objęte backupem Proxmox. Duże biblioteki zazwyczaj wyłącza się z `vzdump` i zabezpiecza osobno. +Po udanej instalacji CT otrzymuje ochronę Proxmox przed przypadkowym usunięciem. -Można też podmontować do LXC katalog z hosta lub NAS, ale w nieuprzywilejowanym LXC trzeba wtedy świadomie skonfigurować mapowanie UID/GID. Nie montuj przypadkowych katalogów systemowych hosta. Zawartość bind mountów nie jest automatycznie uwzględniana w `vzdump`. +## Ważne decyzje -Jeśli dane mają pozostać na dysku systemowym LXC, pomiń ten krok. Instalator sam utworzy `/opt/media-stack/data`. +### Sieć -### 6. Opcjonalnie przekaż Intel iGPU +Najprościej wybrać DHCP i ustawić w routerze rezerwację dla MAC nowego LXC. +Można też od razu podać statyczny IPv4. Panele Dockera są wiązane tylko z +loopbackiem i konkretnym adresem LAN, dlatego nie są przypadkowo publikowane na +każdym interfejsie. -Jeżeli Jellyfin ma używać Quick Sync, przekaż urządzenia GPU do LXC przed instalacją. Z powłoki **hosta Proxmox**: +Jeśli adres LXC później się zmieni: ```bash -CTID=120 -pct set "$CTID" --dev1 /dev/dri/renderD128 -test ! -e /dev/dri/card0 || pct set "$CTID" --dev2 /dev/dri/card0 -pct stop "$CTID" -pct start "$CTID" +pct exec CTID -- media-stack repair-ip ``` -Następnie w **LXC** sprawdź: +Polecenie wykryje nowy adres, atomowo zmieni `.env`, odtworzy bindingi i w razie +błędu przywróci poprzednią konfigurację. -```bash -ls -l /dev/dri/renderD128 -``` +### Storage -Jeżeli urządzenie istnieje, instalator zaproponuje włączenie Quick Sync. Bez iGPU stos również działa — Jellyfin będzie transkodował programowo. +Provisioner może utworzyć osobny wolumin Proxmox zamontowany jako +`/opt/media-stack/data`. Dla NAS lub istniejącego bind mountu najlepiej najpierw +utworzyć LXC provisionerem bez woluminu danych, zatrzymać go, dodać świadomie +mapowany mount i dopiero wewnątrz LXC ponownie uruchomić `install_media.sh`. -### 7. Sprawdź LXC przed instalacją +W nieuprzywilejowanym LXC UID 1000 jest mapowany na UID 101000 hosta Proxmox. +Instalator testuje realny zapis jako użytkownik mediów i zatrzymuje się z jasnym +błędem, jeśli mapowanie jest niepoprawne. Nie wykonuje rekurencyjnego `chown` na +całej istniejącej bibliotece. -Otwórz konsolę LXC i wykonaj: - -```bash -cat /etc/os-release -test -c /dev/net/tun && echo "TUN: OK" || echo "TUN: BRAK" -ip -4 address show dev eth0 -ip route -``` +Katalogi pobierania i bibliotek są częścią jednego drzewa `/data`, a instalator +sprawdza możliwość tworzenia hardlinków. -Oczekiwany wynik to Debian/Ubuntu, `TUN: OK`, docelowy adres LAN i trasa domyślna. Jeżeli TUN jest niedostępny, wróć do kroku 4. +### VPN -### 8. Pobierz i uruchom instalator +WireGuard jest domyślnym zaleceniem ze względu na mniejszy narzut. Obsługiwany +jest również OpenVPN. W obu wariantach Transmission używa bezpośrednio +przestrzeni sieciowej Gluetun (`network_mode: service:gluetun`), więc utrata VPN +odcina mu wyjście zamiast przełączać ruch na zwykły interfejs LXC. -W **LXC** zaloguj się jako `root` i wykonaj: +Losowy port przydzielony przez ProtonVPN jest co minutę odczytywany z Gluetun i +ustawiany przez uwierzytelnione API Transmission. Skrypt nie parsuje logów i nie +wymaga ręcznej zmiany portu po reconnectcie. -```bash -apt-get update -apt-get install -y ca-certificates curl +### Dostęp zdalny -installer=$(mktemp) -curl -fsSL https://raw.githubusercontent.com/placq/media-stack/main/install_media.sh -o "$installer" -bash "$installer" -rm -f "$installer" -``` +Pangolin i Tailscale są niezależne i opcjonalne: -Nie używaj `curl ... | bash`: instalator celowo wymaga interaktywnego terminala. +- Pangolin publikuje deklaratywnie tylko Jellyfin oraz Seerr; +- Newt czyta metadane kontenerów przez ograniczony Docker Socket Proxy, nie przez + bezpośrednio zamontowane gniazdo Dockera; +- panele administracyjne nie mają etykiet publicznych; +- Tailscale Serve udostępnia prywatne endpointy HTTPS dla wszystkich paneli. -### 9. Odpowiedz na pytania instalatora +## Model dostępu -1. `Installation path` — pozostaw `/opt/media-stack`, chyba że świadomie używasz innej ścieżki. -2. `External backup directory` — podaj istniejący i zapisywalny katalog NAS, np. `/mnt/nas/media-stack-backups`, albo zostaw pusty. Instalator go nie tworzy, żeby brak montowania NAS nie został przeoczony. -3. `OpenVPN username/password` — wprowadź dane OpenVPN z panelu ProtonVPN. Nie używaj hasła konta Proton i nie dopisuj `+pmp`. -4. `Pangolin endpoint` — pełny adres panelu/tunelu, np. `https://pangolin.example.com`. -5. `Newt ID` i `Newt secret` — dane wygenerowane dla tego tunelu w Pangolin. -6. `Public base domain` — domena dla `jellyfin.domena` i `seerr.domena`. -7. `Transmission username/password` — dane do prywatnego panelu Transmission; zaakceptuj wygenerowane hasło albo wpisz własne silne hasło. -8. `Intel QuickSync` — wybierz `Y`, jeśli urządzenie `/dev/dri/renderD128` zostało poprawnie przekazane. +| Usługa | LAN | Tailscale | Pangolin publiczny | +| --- | :---: | :---: | :---: | +| Jellyfin | Tak | Tak | Tak | +| Seerr | Tak | Tak | Tak, domyślnie z SSO | +| Transmission | Tak | Tak | Nie | +| Radarr | Tak | Tak | Nie | +| Sonarr | Tak | Tak | Nie | +| Prowlarr | Tak | Tak | Nie | +| Bazarr | Tak | Tak | Nie | +| FlareSolverr | Nie | Nie | Nie | -Podczas instalacji Tailscale wyświetli adres logowania. Otwórz go w przeglądarce i zatwierdź dodanie urządzenia `media` do właściwego tailnetu. Instalator będzie czekał na zakończenie tego kroku. +Nie przekierowuj tych portów na routerze. Publiczny dostęp powinien przechodzić +wyłącznie przez Pangolin, a administracja zdalna przez polityki Tailscale. -Instalacja może potrwać kilka–kilkanaście minut, ponieważ pobiera Dockera i wszystkie obrazy kontenerów. Nie przerywaj jej po pojawieniu się komunikatów `Pulling` lub podczas oczekiwania na healthcheck. +## Co jest konfigurowane automatycznie -### 10. Sprawdź rezultat +Po pierwszym starcie `media-stack configure` używa bieżących schematów API +aplikacji, zamiast polegać na sztywnym JSON-ie konkretnej wersji. Operacja jest +idempotentna i ustawia: -Po zakończeniu, nadal w **LXC**, wykonaj: +- `/data/media/movies` jako root folder Radarr; +- `/data/media/tv` jako root folder Sonarr; +- Transmission jako download client obu aplikacji; +- kategorię `movies` dla Radarr i `tv` dla Sonarr; +- pełną synchronizację Prowlarr z Radarr i Sonarr; +- wewnętrzne adresy kontenerów bez Remote Path Mappings. -```bash -cd /opt/media-stack -docker compose ps -tailscale status -tailscale serve status -systemctl --no-pager status media-stack-update.timer -systemctl --no-pager status media-stack-port-sync.timer -systemctl start media-stack-port-sync.service -journalctl -u media-stack-port-sync.service -n 20 --no-pager -``` +Ręcznie pozostają czynności wymagające decyzji użytkownika: konto i biblioteki +Jellyfin, logowanie Seerr, profile jakości, indexery oraz ewentualny proxy +FlareSolverr. -W `docker compose ps` wszystkie kontenery powinny mieć stan `running`, a Gluetun i Seerr — `healthy`. Log synchronizatora powinien po zestawieniu VPN potwierdzić ustawienie portu Transmission. Pierwsza próba może poinformować, że ProtonVPN jeszcze nie przydzielił portu; timer ponowi ją automatycznie. +Jeśli automatyczne spięcie wykonało się zanim aplikacje były gotowe, można je +bezpiecznie powtórzyć: -Sprawdź interfejsy z komputera w tej samej sieci, podstawiając adres LXC: - -```text -http://ADRES_LXC:8096 Jellyfin -http://ADRES_LXC:5055 Seerr -http://ADRES_LXC:9091 Transmission -http://ADRES_LXC:7878 Radarr -http://ADRES_LXC:8989 Sonarr -http://ADRES_LXC:9696 Prowlarr -http://ADRES_LXC:6767 Bazarr +```bash +pct exec CTID -- media-stack configure ``` -W Pangolin powinny zostać wykryte wyłącznie dwa publiczne zasoby: Jellyfin i Seerr. Pozostałe panele nie powinny być publikowane do Internetu. +## Zarządzanie z hosta Proxmox -### 11. Dokończ konfigurację aplikacji - -Po pierwszym uruchomieniu: +```bash +# stan kontenerów i adresy +pct exec CTID -- media-stack status -1. Skonfiguruj bibliotekę Jellyfin w `/data/media/movies` i `/data/media/tv`. -2. Połącz Seerr z Jellyfin, Radarr i Sonarr. -3. Dodaj Transmission do Radarr i Sonarr jako host `gluetun`, port `9091`, z danymi podanymi instalatorowi. -4. W Radarr ustaw kategorię pobierania `movies`, a w Sonarr `tv`. -5. Połącz Prowlarr z Radarr i Sonarr. -6. Jeśli potrzebujesz FlareSolverr, dodaj w Prowlarr proxy o adresie `http://flaresolverr:8191`. -7. Włącz hardlinki w Radarr i Sonarr. Wszystkie aplikacje widzą wspólne drzewo `/data`, więc nie są potrzebne Remote Path Mappings. +# pełna diagnostyka: TUN, storage, hardlinki, healthchecki, VPN i timery +pct exec CTID -- media-stack doctor -### 12. Zabezpiecz dostęp +# logi jednej usługi +pct exec CTID -- media-stack logs gluetun -- Nie przekierowuj na routerze portów `5055`, `8096`, `9091`, `7878`, `8989`, `9696` ani `6767`. -- Publicznie przez Pangolin wystawiaj tylko Jellyfin i Seerr. -- Panele administracyjne otwieraj przez LAN lub Tailscale. -- W ACL/grants Tailscale ogranicz porty administracyjne do własnego użytkownika lub grupy administratorów. -- Ustaw regularny backup samego LXC w Proxmox. Backup konfiguracji wykonywany przed aktualizacją kontenerów nie zastępuje pełnego backupu Proxmox ani kopii biblioteki multimedialnej. +# spójny backup konfiguracji przy zatrzymanym stacku +pct exec CTID -- media-stack backup -### 13. Diagnostyka +# wejście do LXC +pct enter CTID +``` -Najbardziej przydatne polecenia w **LXC**: +Przydatne polecenia już wewnątrz LXC: ```bash -cd /opt/media-stack -docker compose ps -docker compose logs --tail=100 gluetun -docker compose logs --tail=100 seerr -journalctl -u tailscaled -n 100 --no-pager +media-stack status +media-stack doctor +cd /opt/media-stack && docker compose ps +systemctl status media-stack-update.timer +systemctl status media-stack-port-sync.timer journalctl -u media-stack-update.service -n 100 --no-pager journalctl -u media-stack-port-sync.service -n 100 --no-pager ``` -Typowe problemy: +## Aktualizacje i rollback -- `Missing /dev/net/tun` — wykonaj ponownie krok 4 i użyj pełnego `Stop/Start` LXC. -- Docker nie uruchamia testowego kontenera — sprawdź `Nesting` i `Keyctl`. -- ProtonVPN odrzuca dane — użyto loginu do konta zamiast osobnych danych OpenVPN. -- Brak portu przekazanego przez ProtonVPN — konto musi obsługiwać port forwarding; poczekaj na zestawienie połączenia i sprawdź log Gluetun. -- Panele działają po IP, ale nie przez Tailscale — sprawdź `tailscale status`, `tailscale serve status` i reguły dostępu tailnetu. -- NAS nie jest dostępny — zamontuj go przed uruchomieniem instalatora lub pozostaw pole zewnętrznego backupu puste. +Timer nocny pobiera metadane nowych obrazów, ale kandydat musi pozostać +niezmieniony przez siedem dni. Grupy zależnych usług dojrzewają razem: -Materiały źródłowe: [Tailscale w nieuprzywilejowanym LXC](https://tailscale.com/kb/1130/lxc-unprivileged/), [dokumentacja `pct` i punktów montowania Proxmox](https://pve.proxmox.com/pve-docs/pct.1.html), [obsługiwane wydania Debiana w Docker Engine](https://docs.docker.com/engine/install/debian/), [dane OpenVPN i port forwarding ProtonVPN](https://protonvpn.com/support/port-forwarding-manual-setup). +- Gluetun + Transmission; +- Newt + Docker Socket Proxy; +- pozostałe aplikacje osobno. -## Model dostępu +Przed wdrożeniem stack jest zatrzymywany, a konfiguracja i sekrety trafiają do +sprawdzonego archiwum. Po aktualizacji wymagane są działające kontenery, +healthchecki, endpointy HTTP, brak pętli restartów i aktywny port ProtonVPN przez +pełne 60 sekund. Niepowodzenie przywraca poprzednie obrazy i konfigurację. -| Usługa | LAN | Tailscale | Publicznie przez Pangolin | -| --- | :---: | :---: | :---: | -| Jellyfin | Tak | Tak | Tak | -| Seerr | Tak | Tak | Tak | -| Transmission | Tak | Tak | Nie | -| Sonarr | Tak | Tak | Nie | -| Radarr | Tak | Tak | Nie | -| Prowlarr | Tak | Tak | Nie | -| Bazarr | Tak | Tak | Nie | -| FlareSolverr | Nie | Nie | Nie | +Opcjonalny backup NAS zapisuje także oczekiwane źródło i punkt montowania. +Zmiana lub zniknięcie mountu zatrzymuje backup/aktualizację zamiast zapisać dane +na lokalnym katalogu pod pustym mountpointem. -Tylko Jellyfin i Seerr są dostępne z Internetu. Aplikacje administracyjne nasłuchują na loopbacku i wykrytym adresie LAN, a prywatny dostęp zdalny zapewnia Tailscale Serve. +Lokalnie przechowywanych jest pięć backupów i dwa obrazy rollbacku na usługę; +na zewnętrznym filesystemie dziesięć backupów. -## Zawarte usługi +## Sekrety -- Jellyfin -- Seerr -- Transmission kierowany przez Gluetun i ProtonVPN -- Sonarr, Radarr, Prowlarr i Bazarr -- FlareSolverr -- Newt dla Pangolin -- ograniczony Docker Socket Proxy używany przez Newt do wykrywania etykiet +Hasła nie trafiają do `.env`, wygenerowanej instrukcji ani środowiska +kontenerów tam, gdzie upstream obsługuje pliki: -Newt nigdy nie otrzymuje bezpośredniego dostępu do gniazda Dockera hosta. Ruch związany z wykrywaniem przechodzi przez proxy tylko do odczytu, z wyłączonymi żądaniami zapisującymi. Seerr używa oficjalnego obrazu `ghcr.io/seerr-team/seerr:v3`. +```text +/opt/media-stack/secrets/ +├── proton_openvpn_user # tylko dla OpenVPN +├── proton_openvpn_password # tylko dla OpenVPN +├── proton_wireguard_private_key # tylko dla WireGuard +├── transmission_user +└── transmission_password +``` -## Automatyczne przekazywanie portu Transmission +Pliki mają tryb `0600`. Gluetun i LinuxServer Transmission korzystają z Docker +Compose secrets. Newt używa własnego pliku konfiguracyjnego `0600`. -Gluetun otrzymuje przekazany port od ProtonVPN. Timer systemd odczytuje go co minutę i aktualizuje Transmission przez uwierzytelnione API RPC. Zmiana portu po ponownym połączeniu VPN jest obsługiwana automatycznie; nie ma ręcznego helpera ani czynności w panelu. +## Instalacja w istniejącym LXC + +Jeśli LXC został już utworzony ręcznie, na hoście Proxmox ustaw co najmniej: ```bash -sudo systemctl status media-stack-port-sync.timer -sudo systemctl start media-stack-port-sync.service -sudo journalctl -u media-stack-port-sync.service +pct set CTID --features nesting=1,keyctl=1 +pct set CTID --dev0 /dev/net/tun +pct stop CTID +pct start CTID ``` -## Automatyczne aktualizacje i odzyskiwanie - -Nie ma panelu aktualizacji ani usługi powiadomień. Timer systemd sprawdza obrazy kontenerów każdej nocy. +Następnie wejdź do kontenera (`pct enter CTID`) i wykonaj: -- Kandydat na nowy obraz musi pozostać niezmieniony przez siedem dni przed instalacją. -- Kandydaci dojrzewają niezależnie w bezpiecznych grupach: Gluetun z Transmission, Newt z proxy oraz każda pozostała aplikacja osobno. -- Niedojrzała aktualizacja jednej grupy nie blokuje innych grup. -- Konfiguracja jest archiwizowana przed wdrożeniem; opcjonalna kopia trafia na zamontowany NAS. -- Aktualizator wymaga, aby kontenery, healthchecki, VPN i lokalne interfejsy HTTP działały stabilnie przez 60 sekund. -- Błąd startu, healthchecku albo pętla restartów automatycznie przywracają konfigurację i poprzednie obrazy. -- Zachowywanych jest pięć lokalnych backupów konfiguracji, dziesięć zewnętrznych backupów oraz dwa obrazy rollbacku na usługę. -- Nieudany kandydat musi ponownie odczekać przed następną automatyczną próbą. - -Opóźnienie można zmienić w `/opt/media-stack/.env`: - -```dotenv -UPDATE_DELAY_DAYS='7' +```bash +apt-get update +apt-get install -y ca-certificates curl +installer=$(mktemp) +curl -fsSL https://raw.githubusercontent.com/placq/media-stack/main/install_media.sh -o "$installer" +bash "$installer" +rm -f "$installer" ``` -Instalator włącza również automatyczne aktualizacje bezpieczeństwa Debiana/Ubuntu w samym LXC. Aktualizacje obrazów kontenerów i systemu operacyjnego są obsługiwane osobno. +`install_media.sh` jest bezpieczny do ponownego uruchomienia: zachowuje puste +sekrety z poprzedniej konfiguracji, waliduje nowy Compose przed podmianą i przy +błędzie odtwarza poprzednie pliki. -## Migracja z Jellyseerr +## Diagnostyka awarii provisionera -Jeśli zostanie znaleziony istniejący katalog `config/jellyseerr`, stary kontener jest zatrzymywany przed skopiowaniem bazy SQLite i konfiguracji. Najpierw powstaje archiwum migracyjne. Stary Jellyseerr jest usuwany dopiero wtedy, gdy nowy Seerr zgłosi stan `healthy`; błąd instalacji ponownie uruchamia stary kontener. +Provisioner nigdy nie usuwa automatycznie częściowo utworzonego LXC. Jeśli etap +wewnętrzny się nie powiedzie: -## Układ danych - -```text -/opt/media-stack/ -├── .env -├── docker-compose.yml -├── important_info.md -├── sync_transmission_port.sh -├── update_stack.sh -├── backups/ -├── config/ -└── data/ - ├── media/ - │ ├── movies/ - │ └── tv/ - └── torrents/ - ├── incomplete/ - ├── movies/ - └── tv/ +```bash +pct config CTID +pct enter CTID +bash /root/media-stack-source/install_media.sh ``` -Wszystkie ścieżki pobierania i biblioteki korzystają ze wspólnego montowania `/data`, dzięki czemu Sonarr i Radarr mogą używać hardlinków zamiast kopiować pliki. +Sprawdź przede wszystkim: -## Przydatne polecenia +```bash +test -c /dev/net/tun && echo TUN_OK +ip route +systemctl status docker --no-pager +cd /opt/media-stack && docker compose logs --tail=100 gluetun +``` + +CT ma po udanej instalacji włączoną ochronę. Przed świadomym usunięciem trzeba ją +wyłączyć: ```bash -cd /opt/media-stack -sudo docker compose ps -sudo systemctl status media-stack-update.timer -sudo systemctl start media-stack-update.service -sudo journalctl -u media-stack-update.service +pct set CTID --protection 0 ``` -Sekrety są przechowywane wyłącznie w `.env`, który otrzymuje uprawnienia `600`. Wygenerowana dokumentacja nie zawiera haseł. +## Pliki projektu + +| Plik | Rola | +| --- | --- | +| `proxmox_lxc.sh` | provisioner uruchamiany wyłącznie na hoście Proxmox | +| `install_media.sh` | instalator uruchamiany wyłącznie wewnątrz LXC | +| `templates/compose*.yaml` | testowalne profile stacku | +| `media_stack.sh` | status, doctor, konfiguracja ARR, backup i naprawa IP | +| `sync_transmission_port.sh` | synchronizacja ProtonVPN → Transmission | +| `update_stack.sh` | opóźnione aktualizacje, backup, healthcheck i rollback | + +Projekt opiera konfigurację LXC na oficjalnym `pct`, Dockera na podpisanym +repozytorium APT Docker CE, Tailscale na podpisanym repozytorium APT, a składnię +Pangolin na deklaratywnych blueprintach/etykietach Newt. + +Dokumentacja referencyjna: [Proxmox `pct`](https://pve.proxmox.com/pve-docs/pct.1.html), +[Docker Engine na Debianie](https://docs.docker.com/engine/install/debian/), +[Tailscale w nieuprzywilejowanym LXC](https://tailscale.com/kb/1130/lxc-unprivileged/), +[ProtonVPN port forwarding](https://protonvpn.com/support/port-forwarding-manual-setup), +[Gluetun dla ProtonVPN](https://github.com/qdm12/gluetun-wiki/blob/main/setup/providers/protonvpn.md), +[Pangolin Blueprints](https://docs.pangolin.net/manage/blueprints) oraz +[Docker dla Seerr](https://docs.seerr.dev/getting-started/docker/). diff --git a/install_media.sh b/install_media.sh index 26456a2..be1d2da 100644 --- a/install_media.sh +++ b/install_media.sh @@ -3,107 +3,159 @@ set -Eeuo pipefail umask 027 +readonly INSTALLER_VERSION="4.0.0" +readonly DEFAULT_INSTALL_DIR="/opt/media-stack" +readonly PROJECT_REPOSITORY="placq/media-stack" + RED='\033[0;31m' GREEN='\033[0;32m' YELLOW='\033[1;33m' BLUE='\033[0;34m' NC='\033[0m' -log_info() { echo -e "${BLUE}[INFO]${NC} $*"; } -log_success() { echo -e "${GREEN}[SUCCESS]${NC} $*"; } -log_warn() { echo -e "${YELLOW}[WARN]${NC} $*"; } -log_error() { echo -e "${RED}[ERROR]${NC} $*" >&2; exit 1; } +log_info() { printf '%b[INFO]%b %s\n' "$BLUE" "$NC" "$*"; } +log_success() { printf '%b[OK]%b %s\n' "$GREEN" "$NC" "$*"; } +log_warn() { printf '%b[WARN]%b %s\n' "$YELLOW" "$NC" "$*" >&2; } +die() { printf '%b[ERROR]%b %s\n' "$RED" "$NC" "$*" >&2; exit 1; } -JELLYSEERR_WAS_RUNNING=false -JELLYSEERR_CONTAINER_FOUND=false -cleanup_on_exit() { - local status=$1 line=$2 - if ((status != 0)); then - echo -e "${RED}[ERROR]${NC} Installation failed at line $line." >&2 - if $JELLYSEERR_WAS_RUNNING && command -v docker >/dev/null; then - docker start jellyseerr >/dev/null 2>&1 || true - log_warn "The previous Jellyseerr container was restarted." - fi - fi +usage() { + cat <<'EOF' +Media Stack installer for Debian/Ubuntu LXC + +Usage: + sudo bash install_media.sh + sudo bash install_media.sh --preflight + bash install_media.sh --help + +Options: + --preflight Check the host/LXC without changing it. + --help Show this help. + +The normal installation is interactive and safe to run again. Existing +credentials are retained when a secret prompt is left empty. +EOF } -trap 'cleanup_on_exit "$?" "$LINENO"' EXIT -[[ $EUID -eq 0 ]] || log_error "Run this installer with sudo or as root." -[[ -t 0 ]] || log_error "Interactive terminal required. Download the script first; do not pipe it directly to bash." -[[ "$(ps -p 1 -o comm=)" == systemd ]] || log_error "This installer requires systemd as PID 1." +PREFLIGHT_ONLY=false +case "${1:-}" in + "") ;; + --preflight) PREFLIGHT_ONLY=true ;; + --from-proxmox) + [[ "${MEDIA_STACK_PROXMOX_LAUNCH:-}" == 1 ]] || die "--from-proxmox is reserved for proxmox_lxc.sh." + ;; + --help|-h) usage; exit 0 ;; + *) usage >&2; die "Unknown option: $1" ;; +esac -if [[ "$(systemd-detect-virt --container 2>/dev/null || true)" == lxc ]]; then - if [[ ! -c /dev/net/tun || ! -r /dev/net/tun || ! -w /dev/net/tun ]]; then - log_error "LXC has no usable /dev/net/tun. On the Proxmox host run: pct set CTID --dev0 /dev/net/tun; pct set CTID --features keyctl=1,nesting=1; then fully restart the container." - fi +[[ $EUID -eq 0 ]] || die "Run this installer as root (or with sudo)." +if ! $PREFLIGHT_ONLY && [[ "${MEDIA_STACK_PROXMOX_LAUNCH:-}" != 1 ]]; then + [[ -t 0 ]] || die "An interactive terminal is required. Download the script first; do not pipe it to bash." fi -[[ -c /dev/net/tun ]] || log_error "/dev/net/tun is required by Gluetun and Tailscale." +[[ "$(ps -p 1 -o comm=)" == systemd ]] || die "systemd must be PID 1." # shellcheck disable=SC1091 source /etc/os-release case "${ID:-}" in - ubuntu|debian) ;; - *) log_error "Supported systems: Ubuntu and Debian." ;; + debian|ubuntu) ;; + *) die "Supported systems: Debian and Ubuntu." ;; esac -[[ -n "${VERSION_CODENAME:-}" ]] || log_error "Unable to determine the OS codename." - -REAL_USER=${SUDO_USER:-root} -PUID=$(id -u "$REAL_USER") -PGID=$(id -g "$REAL_USER") -TZ=$(cat /etc/timezone 2>/dev/null || echo "Europe/Warsaw") - -if [[ "$PUID" -eq 0 ]]; then - if getent passwd 1000 >/dev/null; then - REAL_USER=$(getent passwd 1000 | cut -d: -f1) - else - id media &>/dev/null || useradd -U -m -s /usr/sbin/nologin media - REAL_USER=media - fi - PUID=$(id -u "$REAL_USER") - PGID=$(id -g "$REAL_USER") +[[ -n "${VERSION_CODENAME:-}" ]] || die "Unable to determine the OS codename." + +VIRT=$(systemd-detect-virt --container 2>/dev/null || true) +[[ "$VIRT" == lxc ]] || + die "This installer runs only inside an LXC (detected: ${VIRT:-none}). On the Proxmox host use proxmox_lxc.sh." +[[ -c /dev/net/tun && -r /dev/net/tun && -w /dev/net/tun ]] || + die "LXC has no usable /dev/net/tun. On Proxmox enable nesting,keyctl and pass /dev/net/tun, then stop/start the CT." +[[ -c /dev/net/tun ]] || die "/dev/net/tun is required by Gluetun and Tailscale." + +AVAILABLE_MEMORY_MB=$(awk '/MemAvailable:/ {print int($2 / 1024)}' /proc/meminfo) +((AVAILABLE_MEMORY_MB >= 1800)) || log_warn "Only ${AVAILABLE_MEMORY_MB} MiB of memory is currently available; 4 GiB or more is recommended." + +ROOT_FREE_MB=$(df -Pm / | awk 'NR == 2 {print $4}') +((ROOT_FREE_MB >= 8192)) || log_warn "Less than 8 GiB is free on the root filesystem. Image pulls may fail." + +if $PREFLIGHT_ONLY; then + command -v ip >/dev/null || die "Missing iproute2 (the ip command)." + ip -4 route show default | grep -q . || die "No IPv4 default route was found." + log_success "Preflight passed: ${PRETTY_NAME:-$ID}, virtualization=${VIRT:-none}, TUN usable, ${AVAILABLE_MEMORY_MB} MiB available." + exit 0 fi -clear -echo -e "${BLUE}===========================================${NC}" -echo -e "${BLUE} MEDIA STACK INSTALLATION (v3.0) ${NC}" -echo -e "${BLUE}===========================================${NC}" +mkdir -p /run/lock +exec 8>/run/lock/media-stack-installer.lock +flock -n 8 || die "Another Media Stack installation is already running." -read -r -p "Installation path [/opt/media-stack]: " INSTALL_DIR -INSTALL_DIR=${INSTALL_DIR:-/opt/media-stack} -[[ "$INSTALL_DIR" == /* ]] || log_error "Installation path must be absolute." -[[ "$INSTALL_DIR" != *"'"* && "$INSTALL_DIR" != *$'\n'* ]] || log_error "Installation path cannot contain apostrophes or newlines." - -read -r -p "External backup directory (mounted NAS, empty to disable): " OFFSITE_BACKUP_DIR -if [[ -n "$OFFSITE_BACKUP_DIR" ]]; then - [[ "$OFFSITE_BACKUP_DIR" == /* ]] || log_error "External backup directory must be absolute." - [[ "$OFFSITE_BACKUP_DIR" != *"'"* && "$OFFSITE_BACKUP_DIR" != *$'\n'* ]] || log_error "External backup directory cannot contain apostrophes or newlines." - [[ -d "$OFFSITE_BACKUP_DIR" && -w "$OFFSITE_BACKUP_DIR" ]] || log_error "Mount the external backup directory and make it writable before continuing." -fi +TEMP_DIR=$(mktemp -d) +JELLYSEERR_WAS_RUNNING=false +JELLYSEERR_MIGRATED=false +DEPLOYMENT_STARTED=false +DEPLOYMENT_FINISHED=false +ROLLBACK_ARCHIVE="" +INSTALL_DIR="" + +cleanup() { + local status=$? + trap - EXIT + rm -rf -- "$TEMP_DIR" + if ((status != 0)); then + printf '%b[ERROR]%b Installation failed.\n' "$RED" "$NC" >&2 + if $DEPLOYMENT_STARTED && ! $DEPLOYMENT_FINISHED && [[ -n "$ROLLBACK_ARCHIVE" && -s "$ROLLBACK_ARCHIVE" ]]; then + log_warn "Restoring the previous generated configuration." + rm -f "$INSTALL_DIR/.env" "$INSTALL_DIR/compose.yaml" "$INSTALL_DIR/compose.openvpn.yaml" \ + "$INSTALL_DIR/compose.wireguard.yaml" "$INSTALL_DIR/compose.gpu.yaml" \ + "$INSTALL_DIR/update_stack.sh" "$INSTALL_DIR/sync_transmission_port.sh" \ + "$INSTALL_DIR/media_stack.sh" "$INSTALL_DIR/important_info.md" \ + "$INSTALL_DIR/config/newt/config.json" + rm -rf -- "$INSTALL_DIR/secrets" + tar -xzf "$ROLLBACK_ARCHIVE" -C "$INSTALL_DIR" || true + ( + if cd "$INSTALL_DIR"; then + docker compose up -d --remove-orphans + fi + ) || true + fi + if $JELLYSEERR_WAS_RUNNING && command -v docker >/dev/null; then + docker start jellyseerr >/dev/null 2>&1 || true + fi + fi + exit "$status" +} +trap cleanup EXIT +trap 'printf "%b[ERROR]%b Failure at line %s.\n" "$RED" "$NC" "$LINENO" >&2' ERR -log_info "Installing required host packages..." +log_info "Installing prerequisites inside the LXC..." export DEBIAN_FRONTEND=noninteractive apt-get update -apt-get install -y -q ca-certificates curl gnupg iproute2 jq openssl tar unattended-upgrades util-linux +apt-get install -y -q ca-certificates curl findutils gnupg iproute2 jq openssl tar unattended-upgrades util-linux -cat > /etc/apt/apt.conf.d/20auto-upgrades <<'AUTO_UPGRADES' +cat > /etc/apt/apt.conf.d/20auto-upgrades <<'EOF' APT::Periodic::Update-Package-Lists "1"; APT::Periodic::Unattended-Upgrade "1"; -AUTO_UPGRADES -systemctl enable --now unattended-upgrades.service +EOF +systemctl enable --now unattended-upgrades.service >/dev/null install_docker() { - log_info "Configuring the official Docker repository for ${ID} ${VERSION_CODENAME}..." + log_info "Installing Docker Engine from Docker's signed APT repository..." + conflicting_packages=() + for package in docker.io docker-compose docker-compose-v2 docker-doc podman-docker containerd runc; do + dpkg-query -W -f='${db:Status-Abbrev}' "$package" 2>/dev/null | grep -q '^ii' && conflicting_packages+=("$package") + done + if ((${#conflicting_packages[@]} > 0)); then + log_warn "Replacing conflicting distribution packages with Docker CE: ${conflicting_packages[*]}" + apt-get remove -y "${conflicting_packages[@]}" + fi install -m 0755 -d /etc/apt/keyrings - curl -fsSL "https://download.docker.com/linux/${ID}/gpg" -o /etc/apt/keyrings/docker.asc - chmod a+r /etc/apt/keyrings/docker.asc - cat > /etc/apt/sources.list.d/docker.sources < /etc/apt/sources.list.d/docker.sources </dev/null || ! docker compose version >/dev/null 2>&1; then install_docker fi -docker info >/dev/null 2>&1 || log_error "Docker daemon is not available." -log_info "Verifying nested Docker support..." -docker run --rm hello-world >/dev/null || log_error "Docker cannot start containers. For Proxmox LXC, enable nesting and keyctl, then fully restart the LXC." - -if ! command -v tailscale >/dev/null; then - log_info "Installing Tailscale in this system (inside the media LXC when used on Proxmox)..." - TAILSCALE_INSTALLER=$(mktemp) - curl -fsSL https://tailscale.com/install.sh -o "$TAILSCALE_INSTALLER" - sh "$TAILSCALE_INSTALLER" - rm -f "$TAILSCALE_INSTALLER" -fi +systemctl enable --now docker >/dev/null +docker info >/dev/null 2>&1 || die "The Docker daemon is unavailable." + +log_info "Verifying Docker support inside the container..." +docker run --rm --pull=missing hello-world >/dev/null || + die "Docker cannot start a container. In Proxmox enable nesting and keyctl, then fully stop/start the LXC." + +read_env() { + local key=$1 file=$2 line value + [[ -f "$file" ]] || return 0 + line=$(awk -v key="$key" 'index($0, key "=") == 1 {print; exit}' "$file") + [[ -n "$line" ]] || return 0 + value=${line#*=} + if [[ "$value" == "'"*"'" && ${#value} -ge 2 ]]; then + value=${value:1:${#value}-2} + elif [[ "$value" == '"'*'"' && ${#value} -ge 2 ]]; then + value=${value:1:${#value}-2} + fi + printf '%s' "$value" +} -TAILSCALE_IP=$(tailscale ip -4 2>/dev/null | head -n1 || true) -if [[ -z "$TAILSCALE_IP" ]]; then - log_info "Tailscale authentication is required. Open the URL shown below." - tailscale up - TAILSCALE_IP=$(tailscale ip -4 2>/dev/null | head -n1 || true) -fi -[[ -n "$TAILSCALE_IP" ]] || log_error "Tailscale is not connected." - -LAN_IP=$(ip -4 route get 1.1.1.1 2>/dev/null | awk '{for (i=1;i<=NF;i++) if ($i=="src") {print $(i+1); exit}}') -LAN_IP=${LAN_IP:-$(hostname -I | awk '{print $1}')} -[[ -n "$LAN_IP" ]] || log_error "Unable to determine the LAN address." - -if [[ ! -f "$INSTALL_DIR/docker-compose.yml" ]]; then - log_info "Checking local service ports..." - REQUIRED_PORTS=(8096 5055 9091 7878 8989 9696 6767) - for port in "${REQUIRED_PORTS[@]}"; do - if ss -H -tuln | awk '{print $5}' | grep -Eq "(^|:)$port$"; then - log_error "Port $port is already in use." +prompt_value() { + local variable=$1 label=$2 default=${3:-} answer + if [[ -n "$default" ]]; then + read -r -p "$label [$default]: " answer + printf -v "$variable" '%s' "${answer:-$default}" + else + read -r -p "$label: " answer + printf -v "$variable" '%s' "$answer" + fi +} + +prompt_secret() { + local variable=$1 label=$2 current=${3:-} answer + if [[ -n "$current" ]]; then + read -r -s -p "$label [Enter keeps the existing value]: " answer + else + read -r -s -p "$label: " answer + fi + printf '\n' + printf -v "$variable" '%s' "${answer:-$current}" +} + +prompt_yes_no() { + local variable=$1 label=$2 default=${3:-yes} answer suffix + if [[ "$default" == yes ]]; then suffix="Y/n"; else suffix="y/N"; fi + read -r -p "$label ($suffix): " answer + case "$answer" in + [Yy]|[Yy][Ee][Ss]) printf -v "$variable" yes ;; + [Nn]|[Nn][Oo]) printf -v "$variable" no ;; + "") printf -v "$variable" '%s' "$default" ;; + *) die "Expected yes or no." ;; + esac +} + +safe_value() { + [[ "$1" != *$'\n'* && "$1" != *$'\r'* && "$1" != *"'"* ]] +} + +detect_lan_ip() { + local detected + detected=$(ip -4 route get 1.1.1.1 2>/dev/null | awk '{for (i=1; i<=NF; i++) if ($i == "src") {print $(i+1); exit}}') + [[ -n "$detected" ]] || detected=$(hostname -I | awk '{print $1}') + printf '%s' "$detected" +} + +valid_ipv4() { + local address=$1 octet + local -a octets + IFS=. read -r -a octets <<< "$address" + ((${#octets[@]} == 4)) || return 1 + for octet in "${octets[@]}"; do + if [[ ! "$octet" =~ ^[0-9]{1,3}$ ]] || ((10#$octet > 255)); then + return 1 fi done +} + +printf '%b\n' "$BLUE============================================================$NC" +printf '%b\n' "$BLUE MEDIA STACK INSTALLER v${INSTALLER_VERSION}$NC" +printf '%b\n\n' "$BLUE============================================================$NC" + +prompt_value INSTALL_DIR "Installation path" "$DEFAULT_INSTALL_DIR" +[[ "$INSTALL_DIR" =~ ^/[A-Za-z0-9._/-]+$ ]] || + die "The installation path must be absolute and may contain only letters, digits, /, ., _ and -." +[[ "$INSTALL_DIR" != / && "$INSTALL_DIR" != /opt && "$INSTALL_DIR" != /srv && "$INSTALL_DIR" != /mnt && + "$INSTALL_DIR" != /usr && "$INSTALL_DIR" != /var ]] || die "Choose a dedicated installation directory." +case "$INSTALL_DIR" in + /etc/*|/boot/*|/run/*|/usr/*|/var/lib/docker|/var/lib/docker/*) + die "Choose a data location such as /opt/media-stack, /srv/media-stack or /mnt/media-stack." + ;; +esac + +mkdir -p "$INSTALL_DIR" +mkdir -p "$INSTALL_DIR/.update-state" +exec 9>"$INSTALL_DIR/.update-state/update.lock" +flock -n 9 || die "A Media Stack update or backup is already running in $INSTALL_DIR." +OLD_ENV="$INSTALL_DIR/.env" + +CURRENT_LAN_IP=$(read_env LAN_IP "$OLD_ENV") +DETECTED_LAN_IP=$(detect_lan_ip) +prompt_value LAN_IP "LAN IPv4 address" "${CURRENT_LAN_IP:-$DETECTED_LAN_IP}" +valid_ipv4 "$LAN_IP" || die "Invalid IPv4 address: $LAN_IP" +ip -4 addr show | grep -Fq " $LAN_IP/" || die "$LAN_IP is not currently assigned to this system." + +CURRENT_VPN_TYPE=$(read_env VPN_TYPE "$OLD_ENV") +[[ "$CURRENT_VPN_TYPE" == wireguard || "$CURRENT_VPN_TYPE" == openvpn ]] || CURRENT_VPN_TYPE=openvpn +prompt_value VPN_TYPE "ProtonVPN protocol (wireguard/openvpn)" "$CURRENT_VPN_TYPE" +[[ "$VPN_TYPE" == wireguard || "$VPN_TYPE" == openvpn ]] || die "VPN protocol must be wireguard or openvpn." + +LEGACY_VPN_USER=$(read_env VPN_USER "$OLD_ENV") +LEGACY_VPN_PASS=$(read_env VPN_PASS "$OLD_ENV") +CURRENT_OPENVPN_USER="" +CURRENT_OPENVPN_PASSWORD="" +CURRENT_WIREGUARD_KEY="" +[[ -f "$INSTALL_DIR/secrets/proton_openvpn_user" ]] && CURRENT_OPENVPN_USER=$(<"$INSTALL_DIR/secrets/proton_openvpn_user") +[[ -f "$INSTALL_DIR/secrets/proton_openvpn_password" ]] && CURRENT_OPENVPN_PASSWORD=$(<"$INSTALL_DIR/secrets/proton_openvpn_password") +[[ -f "$INSTALL_DIR/secrets/proton_wireguard_private_key" ]] && CURRENT_WIREGUARD_KEY=$(<"$INSTALL_DIR/secrets/proton_wireguard_private_key") +CURRENT_OPENVPN_USER=${CURRENT_OPENVPN_USER:-$LEGACY_VPN_USER} +CURRENT_OPENVPN_PASSWORD=${CURRENT_OPENVPN_PASSWORD:-$LEGACY_VPN_PASS} + +OPENVPN_USER="" +OPENVPN_PASSWORD="" +WIREGUARD_PRIVATE_KEY="" +if [[ "$VPN_TYPE" == openvpn ]]; then + printf '\n--- ProtonVPN / OpenVPN ---\n' + prompt_value OPENVPN_USER "OpenVPN username (the installer adds +pmp)" "${CURRENT_OPENVPN_USER%%+pmp*}" + prompt_secret OPENVPN_PASSWORD "OpenVPN password" "$CURRENT_OPENVPN_PASSWORD" + [[ -n "$OPENVPN_USER" && -n "$OPENVPN_PASSWORD" ]] || die "OpenVPN credentials are required." + [[ "$OPENVPN_USER" != *[[:space:]]* ]] || die "The OpenVPN username cannot contain whitespace." + [[ "$OPENVPN_USER" == *+pmp* ]] || OPENVPN_USER="${OPENVPN_USER}+pmp" +else + printf '\n--- ProtonVPN / WireGuard ---\n' + log_info "Use the PrivateKey from a ProtonVPN WireGuard configuration generated with NAT-PMP enabled." + prompt_secret WIREGUARD_PRIVATE_KEY "WireGuard private key" "$CURRENT_WIREGUARD_KEY" + [[ "$WIREGUARD_PRIVATE_KEY" =~ ^[A-Za-z0-9+/]{43}=$ ]] || die "The WireGuard private key is not valid base64 key material." fi -echo -e "\n--- PROTONVPN ---" -read -r -p "OpenVPN username: " VPN_USER -read -r -s -p "OpenVPN password: " VPN_PASS -echo - -echo -e "\n--- PANGOLIN / NEWT ---" -read -r -p "Pangolin endpoint (for example https://pangolin.example.com): " PANGOLIN_ENDPOINT -read -r -p "Newt ID: " NEWT_ID -read -r -s -p "Newt secret: " NEWT_SECRET -echo -[[ -n "$PANGOLIN_ENDPOINT" && -n "$NEWT_ID" && -n "$NEWT_SECRET" ]] || log_error "Pangolin endpoint and Newt credentials are required." -[[ "$PANGOLIN_ENDPOINT" =~ ^https?:// ]] || PANGOLIN_ENDPOINT="https://${PANGOLIN_ENDPOINT}" -PANGOLIN_ENDPOINT=${PANGOLIN_ENDPOINT%/} -PANGOLIN_HOST=${PANGOLIN_ENDPOINT#*://} -PANGOLIN_HOST=${PANGOLIN_HOST%%/*} -DETECTED_DOMAIN=${PANGOLIN_HOST#pangolin.} -[[ "$DETECTED_DOMAIN" != "$PANGOLIN_HOST" ]] || DETECTED_DOMAIN=${PANGOLIN_HOST#*.} -read -r -p "Public base domain [${DETECTED_DOMAIN}]: " PUBLIC_DOMAIN -PUBLIC_DOMAIN=${PUBLIC_DOMAIN:-$DETECTED_DOMAIN} - -echo -e "\n--- TRANSMISSION ---" -DEFAULT_TR_PASS=$(openssl rand -hex 12) -read -r -p "Username [admin]: " TR_USER -TR_USER=${TR_USER:-admin} -read -r -p "Password [${DEFAULT_TR_PASS}]: " TR_PASS -TR_PASS=${TR_PASS:-$DEFAULT_TR_PASS} - -for value in "$VPN_USER" "$VPN_PASS" "$PANGOLIN_ENDPOINT" "$NEWT_ID" "$NEWT_SECRET" "$TR_USER" "$TR_PASS" "$PUBLIC_DOMAIN"; do - [[ "$value" != *"'"* && "$value" != *$'\n'* ]] || log_error "Credentials and configuration values cannot contain apostrophes or newlines." -done +CURRENT_PROFILES=$(read_env COMPOSE_PROFILES "$OLD_ENV") +PANGOLIN_DEFAULT=yes +[[ -f "$OLD_ENV" && ",$CURRENT_PROFILES," != *,pangolin,* ]] && PANGOLIN_DEFAULT=no +prompt_yes_no ENABLE_PANGOLIN "Enable public Jellyfin/Seerr access through Pangolin" "$PANGOLIN_DEFAULT" + +LEGACY_PANGOLIN_ENDPOINT=$(read_env PANGOLIN_ENDPOINT "$OLD_ENV") +LEGACY_NEWT_ID=$(read_env NEWT_ID "$OLD_ENV") +LEGACY_NEWT_SECRET=$(read_env NEWT_SECRET "$OLD_ENV") +CURRENT_PUBLIC_DOMAIN=$(read_env PUBLIC_DOMAIN "$OLD_ENV") +PANGOLIN_ENDPOINT=$LEGACY_PANGOLIN_ENDPOINT +NEWT_ID=$LEGACY_NEWT_ID +NEWT_SECRET=$LEGACY_NEWT_SECRET +if [[ -f "$INSTALL_DIR/config/newt/config.json" ]]; then + JSON_PANGOLIN_ENDPOINT=$(jq -r '.endpoint // empty' "$INSTALL_DIR/config/newt/config.json" 2>/dev/null || true) + JSON_NEWT_ID=$(jq -r '.id // empty' "$INSTALL_DIR/config/newt/config.json" 2>/dev/null || true) + JSON_NEWT_SECRET=$(jq -r '.secret // empty' "$INSTALL_DIR/config/newt/config.json" 2>/dev/null || true) + PANGOLIN_ENDPOINT=${JSON_PANGOLIN_ENDPOINT:-$PANGOLIN_ENDPOINT} + NEWT_ID=${JSON_NEWT_ID:-$NEWT_ID} + NEWT_SECRET=${JSON_NEWT_SECRET:-$NEWT_SECRET} +fi + +PUBLIC_DOMAIN=${CURRENT_PUBLIC_DOMAIN:-disabled.invalid} +if [[ "$ENABLE_PANGOLIN" == yes ]]; then + printf '\n--- Pangolin / Newt ---\n' + prompt_value PANGOLIN_ENDPOINT "Pangolin endpoint" "$PANGOLIN_ENDPOINT" + prompt_value NEWT_ID "Newt ID" "$NEWT_ID" + prompt_secret NEWT_SECRET "Newt secret" "$NEWT_SECRET" + [[ "$PANGOLIN_ENDPOINT" =~ ^https?://[^/[:space:]]+/?$ ]] || die "Use a full Pangolin endpoint URL, for example https://pangolin.example.com." + PANGOLIN_ENDPOINT=${PANGOLIN_ENDPOINT%/} + [[ "$PANGOLIN_ENDPOINT" == https://* ]] || log_warn "The Pangolin endpoint is using plain HTTP. HTTPS is strongly recommended." + [[ -n "$NEWT_ID" && -n "$NEWT_SECRET" ]] || die "Newt ID and secret are required." + PANGOLIN_HOST=${PANGOLIN_ENDPOINT#*://} + DETECTED_DOMAIN=${PANGOLIN_HOST#pangolin.} + [[ "$DETECTED_DOMAIN" != "$PANGOLIN_HOST" ]] || DETECTED_DOMAIN=${PANGOLIN_HOST#*.} + prompt_value PUBLIC_DOMAIN "Public base domain" "${CURRENT_PUBLIC_DOMAIN:-$DETECTED_DOMAIN}" + [[ "$PUBLIC_DOMAIN" =~ ^([A-Za-z0-9]([A-Za-z0-9-]*[A-Za-z0-9])?\.)+[A-Za-z]{2,63}$ ]] || die "Invalid public domain: $PUBLIC_DOMAIN" +fi + +printf '\n--- Transmission ---\n' +CURRENT_TR_USER=$(read_env TR_USER "$OLD_ENV") +CURRENT_TR_PASS=$(read_env TR_PASS "$OLD_ENV") +[[ -f "$INSTALL_DIR/secrets/transmission_user" ]] && CURRENT_TR_USER=$(<"$INSTALL_DIR/secrets/transmission_user") +[[ -f "$INSTALL_DIR/secrets/transmission_password" ]] && CURRENT_TR_PASS=$(<"$INSTALL_DIR/secrets/transmission_password") +prompt_value TR_USER "Transmission username" "${CURRENT_TR_USER:-admin}" +GENERATED_TR_PASSWORD=false +if [[ -z "$CURRENT_TR_PASS" ]]; then + RANDOM_PASSWORD_MATERIAL=$(openssl rand -hex 16) + CURRENT_TR_PASS=${RANDOM_PASSWORD_MATERIAL:0:24} + GENERATED_TR_PASSWORD=true +fi +prompt_secret TR_PASS "Transmission password" "$CURRENT_TR_PASS" +[[ -n "$TR_USER" && -n "$TR_PASS" ]] || die "Transmission credentials are required." + +FLARESOLVERR_DEFAULT=yes +[[ -f "$OLD_ENV" && ",$CURRENT_PROFILES," != *,flaresolverr,* ]] && FLARESOLVERR_DEFAULT=no +prompt_yes_no ENABLE_FLARESOLVERR "Enable FlareSolverr" "$FLARESOLVERR_DEFAULT" + +TAILSCALE_DEFAULT=$(read_env ENABLE_TAILSCALE "$OLD_ENV") +[[ "$TAILSCALE_DEFAULT" == yes || "$TAILSCALE_DEFAULT" == no ]] || TAILSCALE_DEFAULT=yes +prompt_yes_no ENABLE_TAILSCALE "Enable private remote access through Tailscale" "$TAILSCALE_DEFAULT" -GPU_CONFIG="" +CURRENT_OFFSITE=$(read_env OFFSITE_BACKUP_DIR "$OLD_ENV") +prompt_value OFFSITE_BACKUP_DIR "External backup directory (empty disables it)" "$CURRENT_OFFSITE" +OFFSITE_BACKUP_SOURCE="" +OFFSITE_BACKUP_MOUNTPOINT="" +if [[ -n "$OFFSITE_BACKUP_DIR" ]]; then + [[ "$OFFSITE_BACKUP_DIR" == /* ]] || die "The external backup path must be absolute." + safe_value "$OFFSITE_BACKUP_DIR" || die "The external backup path contains unsupported characters." + [[ -d "$OFFSITE_BACKUP_DIR" && -w "$OFFSITE_BACKUP_DIR" ]] || die "Mount the external backup directory and make it writable first." + read -r OFFSITE_BACKUP_SOURCE OFFSITE_BACKUP_MOUNTPOINT < <(findmnt -T "$OFFSITE_BACKUP_DIR" -n -o SOURCE,TARGET --first) + [[ -n "$OFFSITE_BACKUP_SOURCE" && "$OFFSITE_BACKUP_MOUNTPOINT" != / ]] || + die "The external backup directory must be on a separately mounted filesystem, not the LXC root filesystem." +fi + +GPU_DEFAULT=no +[[ -n "$(read_env RENDER_GID "$OLD_ENV")" ]] && GPU_DEFAULT=yes +ENABLE_GPU=no +RENDER_GID="" if [[ -e /dev/dri/renderD128 ]]; then - read -r -p "Enable Intel QuickSync for Jellyfin? (Y/n): " ENABLE_GPU - if [[ ! "$ENABLE_GPU" =~ ^[Nn]$ ]]; then - RENDER_GID=$(stat -c '%g' /dev/dri/renderD128) - GPU_CONFIG=" devices:\n - /dev/dri:/dev/dri\n group_add:\n - \"${RENDER_GID}\"" + prompt_yes_no ENABLE_GPU "Enable Intel/AMD hardware transcoding for Jellyfin" "$GPU_DEFAULT" + [[ "$ENABLE_GPU" == no ]] || RENDER_GID=$(stat -c '%g' /dev/dri/renderD128) +fi + +for value in "$LAN_IP" "$OPENVPN_USER" "$OPENVPN_PASSWORD" "$WIREGUARD_PRIVATE_KEY" \ + "$PANGOLIN_ENDPOINT" "$NEWT_ID" "$NEWT_SECRET" "$PUBLIC_DOMAIN" "$TR_USER" "$TR_PASS"; do + safe_value "$value" || die "A value contains an unsupported apostrophe or newline." +done + +if [[ ! -f "$INSTALL_DIR/compose.yaml" && ! -f "$INSTALL_DIR/docker-compose.yml" ]]; then + log_info "Checking service ports on $LAN_IP..." + for port in 5055 6767 7878 8096 8989 9091 9696; do + if ss -H -ltn "sport = :$port" | grep -q .; then + die "TCP port $port is already in use." + fi + done +fi + +REAL_USER=${SUDO_USER:-} +if [[ -z "$REAL_USER" || "$REAL_USER" == root ]]; then + if id media >/dev/null 2>&1; then + REAL_USER=media + elif getent passwd 1000 >/dev/null; then + REAL_USER=$(getent passwd 1000 | cut -d: -f1) + else + useradd --create-home --user-group --shell /usr/sbin/nologin media + REAL_USER=media fi fi +PUID=$(id -u "$REAL_USER") +PGID=$(id -g "$REAL_USER") +TZ=$(cat /etc/timezone 2>/dev/null || printf 'Etc/UTC') -log_info "Preparing directories in $INSTALL_DIR..." +log_info "Preparing persistent directories without recursively changing existing media ownership..." DIRS=( config/gluetun config/transmission config/sonarr config/radarr config/prowlarr - config/bazarr config/jellyfin config/seerr config/flaresolverr + config/bazarr config/jellyfin config/seerr config/newt data/torrents/movies data/torrents/tv data/torrents/incomplete - data/media/movies data/media/tv backups .update-state + data/media/movies data/media/tv backups .update-state secrets ) -for dir in "${DIRS[@]}"; do mkdir -p "$INSTALL_DIR/$dir"; done +for relative_dir in "${DIRS[@]}"; do + mkdir -p "$INSTALL_DIR/$relative_dir" +done +for relative_dir in config/gluetun config/transmission config/sonarr config/radarr config/prowlarr config/bazarr config/jellyfin \ + data data/torrents data/torrents/movies data/torrents/tv data/torrents/incomplete data/media data/media/movies data/media/tv; do + chown "$PUID:$PGID" "$INSTALL_DIR/$relative_dir" 2>/dev/null || + die "Cannot assign $INSTALL_DIR/$relative_dir to UID:GID $PUID:$PGID. Fix the Proxmox bind-mount ID mapping." + chmod 0775 "$INSTALL_DIR/$relative_dir" +done +chown 1000:1000 "$INSTALL_DIR/config/seerr" 2>/dev/null || + die "Cannot assign the Seerr config directory to UID:GID 1000:1000. Fix the bind-mount ID mapping." +chmod 0750 "$INSTALL_DIR/config" "$INSTALL_DIR/secrets" "$INSTALL_DIR/.update-state" -if docker container inspect jellyseerr >/dev/null 2>&1; then - JELLYSEERR_CONTAINER_FOUND=true +PERMISSION_TEST="$INSTALL_DIR/data/.media-stack-write-test" +if ! runuser -u "$REAL_USER" -- touch "$PERMISSION_TEST"; then + die "UID $PUID cannot write to $INSTALL_DIR/data. Fix storage ownership or the LXC UID/GID mapping." +fi +rm -f "$PERMISSION_TEST" + +HARDLINK_SOURCE="$INSTALL_DIR/data/torrents/.hardlink-test" +HARDLINK_TARGET="$INSTALL_DIR/data/media/.hardlink-test" +runuser -u "$REAL_USER" -- touch "$HARDLINK_SOURCE" +if ! runuser -u "$REAL_USER" -- ln "$HARDLINK_SOURCE" "$HARDLINK_TARGET" 2>/dev/null; then + log_warn "The data filesystem does not support hardlinks across torrents and media; imports will copy instead." +fi +rm -f "$HARDLINK_SOURCE" "$HARDLINK_TARGET" + +if [[ -d "$INSTALL_DIR/config/jellyseerr" && ! -e "$INSTALL_DIR/config/seerr/settings.json" ]] && + docker container inspect jellyseerr >/dev/null 2>&1; then if [[ "$(docker inspect --format '{{.State.Running}}' jellyseerr)" == true ]]; then - log_info "Stopping the previous Jellyseerr container for a consistent migration..." + log_info "Stopping the legacy Jellyseerr container for a consistent migration..." docker stop jellyseerr >/dev/null JELLYSEERR_WAS_RUNNING=true fi fi - if [[ -d "$INSTALL_DIR/config/jellyseerr" && ! -e "$INSTALL_DIR/config/seerr/settings.json" ]]; then - log_info "Migrating the Jellyseerr configuration directory to Seerr..." tar -czf "$INSTALL_DIR/backups/jellyseerr-before-seerr-$(date +%Y%m%d-%H%M%S).tar.gz" \ -C "$INSTALL_DIR" config/jellyseerr cp -a "$INSTALL_DIR/config/jellyseerr/." "$INSTALL_DIR/config/seerr/" + chown -R 1000:1000 "$INSTALL_DIR/config/seerr" + JELLYSEERR_MIGRATED=true fi if [[ ! -f "$INSTALL_DIR/config/transmission/settings.json" ]]; then - cat > "$INSTALL_DIR/config/transmission/settings.json" <<'TRANSMISSION_SETTINGS' + cat > "$INSTALL_DIR/config/transmission/settings.json" <<'EOF' { "download-dir": "/data/torrents", "incomplete-dir": "/data/torrents/incomplete", - "incomplete-dir-enabled": true + "incomplete-dir-enabled": true, + "peer-port-random-on-start": false, + "port-forwarding-enabled": false, + "rename-partial-files": true } -TRANSMISSION_SETTINGS -fi - -if [[ -f "$INSTALL_DIR/.env" ]]; then - cp -a "$INSTALL_DIR/.env" "$INSTALL_DIR/.env.$(date +%Y%m%d-%H%M%S).bak" -fi -{ - printf "PUID='%s'\n" "$PUID" - printf "PGID='%s'\n" "$PGID" - printf "INSTALL_DIR='%s'\n" "$INSTALL_DIR" - printf "LAN_IP='%s'\n" "$LAN_IP" - printf "TAILSCALE_IP='%s'\n" "$TAILSCALE_IP" - printf "VPN_USER='%s+pmp'\n" "$VPN_USER" - printf "VPN_PASS='%s'\n" "$VPN_PASS" - printf "PANGOLIN_ENDPOINT='%s'\n" "$PANGOLIN_ENDPOINT" - printf "NEWT_ID='%s'\n" "$NEWT_ID" - printf "NEWT_SECRET='%s'\n" "$NEWT_SECRET" - printf "PUBLIC_DOMAIN='%s'\n" "$PUBLIC_DOMAIN" - printf "TZ='%s'\n" "$TZ" - printf "TR_USER='%s'\n" "$TR_USER" - printf "TR_PASS='%s'\n" "$TR_PASS" - printf "UPDATE_DELAY_DAYS='7'\n" - printf "OFFSITE_BACKUP_DIR='%s'\n" "$OFFSITE_BACKUP_DIR" -} > "$INSTALL_DIR/.env" -chmod 600 "$INSTALL_DIR/.env" - -log_info "Generating Docker Compose configuration..." -cat > "$INSTALL_DIR/docker-compose.yml" < "$INSTALL_DIR/important_info.md" <&2 + curl --fail --silent --show-error --location --retry 3 \ + "https://github.com/${PROJECT_REPOSITORY}/archive/${ref}.tar.gz" -o "$archive" + mkdir -p "$TEMP_DIR/bundle" + tar -xzf "$archive" --strip-components=1 -C "$TEMP_DIR/bundle" + printf '%s' "$TEMP_DIR/bundle" +} -- Transmission: gluetun:9091 -- Prowlarr: prowlarr:9696 -- FlareSolverr: http://flaresolverr:8191 -- Jellyfin: jellyfin:8096 -- Seerr: seerr:5055 +BUNDLE_DIR=$(acquire_bundle) +REQUIRED_FILES=( + templates/compose.yaml templates/compose.openvpn.yaml templates/compose.wireguard.yaml templates/compose.gpu.yaml + update_stack.sh sync_transmission_port.sh media_stack.sh +) +for required_file in "${REQUIRED_FILES[@]}"; do + [[ -f "$BUNDLE_DIR/$required_file" ]] || die "The project snapshot is missing $required_file." +done +bash -n "$BUNDLE_DIR/update_stack.sh" "$BUNDLE_DIR/sync_transmission_port.sh" "$BUNDLE_DIR/media_stack.sh" + +STAGE_DIR="$TEMP_DIR/stage" +mkdir -p "$STAGE_DIR/secrets" "$STAGE_DIR/config/newt" +cp "$BUNDLE_DIR/templates/"*.yaml "$STAGE_DIR/" +cp "$BUNDLE_DIR/update_stack.sh" "$BUNDLE_DIR/sync_transmission_port.sh" "$BUNDLE_DIR/media_stack.sh" "$STAGE_DIR/" + +printf '%s' "$TR_USER" > "$STAGE_DIR/secrets/transmission_user" +printf '%s' "$TR_PASS" > "$STAGE_DIR/secrets/transmission_password" +if [[ "$VPN_TYPE" == openvpn ]]; then + printf '%s' "$OPENVPN_USER" > "$STAGE_DIR/secrets/proton_openvpn_user" + printf '%s' "$OPENVPN_PASSWORD" > "$STAGE_DIR/secrets/proton_openvpn_password" +else + printf '%s' "$WIREGUARD_PRIVATE_KEY" > "$STAGE_DIR/secrets/proton_wireguard_private_key" +fi +chmod 0600 "$STAGE_DIR/secrets/"* + +if [[ "$ENABLE_PANGOLIN" == yes ]]; then + jq -n --arg id "$NEWT_ID" --arg secret "$NEWT_SECRET" --arg endpoint "$PANGOLIN_ENDPOINT" \ + '{id:$id, secret:$secret, endpoint:$endpoint, tlsClientCert:""}' > "$STAGE_DIR/config/newt/config.json" +elif [[ -s "$INSTALL_DIR/config/newt/config.json" ]]; then + cp "$INSTALL_DIR/config/newt/config.json" "$STAGE_DIR/config/newt/config.json" +else + printf '{}\n' > "$STAGE_DIR/config/newt/config.json" +fi +chmod 0600 "$STAGE_DIR/config/newt/config.json" -Use category \`movies\` in Radarr and \`tv\` in Sonarr. All download and media paths share the \`/data\` mount, so hardlinks work without remote path mappings. +COMPOSE_PROFILES=() +[[ "$ENABLE_PANGOLIN" == yes ]] && COMPOSE_PROFILES+=(pangolin) +[[ "$ENABLE_FLARESOLVERR" == yes ]] && COMPOSE_PROFILES+=(flaresolverr) +PROFILE_LIST=$(IFS=,; printf '%s' "${COMPOSE_PROFILES[*]}") +COMPOSE_FILES="compose.yaml:compose.${VPN_TYPE}.yaml" +[[ "$ENABLE_GPU" == yes ]] && COMPOSE_FILES="${COMPOSE_FILES}:compose.gpu.yaml" -## Automatic updates +write_env_line() { + printf "%s='%s'\n" "$1" "$2" +} +{ + write_env_line PUID "$PUID" + write_env_line PGID "$PGID" + write_env_line TZ "$TZ" + write_env_line LAN_IP "$LAN_IP" + write_env_line PUBLIC_DOMAIN "$PUBLIC_DOMAIN" + write_env_line VPN_TYPE "$VPN_TYPE" + write_env_line COMPOSE_FILE "$COMPOSE_FILES" + write_env_line COMPOSE_PROFILES "$PROFILE_LIST" + write_env_line ENABLE_TAILSCALE "$ENABLE_TAILSCALE" + write_env_line RENDER_GID "$RENDER_GID" + write_env_line UPDATE_DELAY_DAYS "7" + write_env_line OFFSITE_BACKUP_DIR "$OFFSITE_BACKUP_DIR" + write_env_line OFFSITE_BACKUP_SOURCE "$OFFSITE_BACKUP_SOURCE" + write_env_line OFFSITE_BACKUP_MOUNTPOINT "$OFFSITE_BACKUP_MOUNTPOINT" +} > "$STAGE_DIR/.env" +chmod 0600 "$STAGE_DIR/.env" + +log_info "Validating the exact Compose model before changing the running stack..." +( + cd "$STAGE_DIR" || exit 1 + docker compose config --quiet + mapfile -t declared_services < <(docker compose config --services) + [[ " ${declared_services[*]} " == *" gluetun "* && " ${declared_services[*]} " == *" transmission "* ]] || exit 1 +) -The stack checks for updates every night. Candidates mature independently in safe service groups and must remain unchanged for seven days before installation. Immediately before updating, the stack is stopped and its configuration is backed up${OFFSITE_BACKUP_DIR:+, including a copy in ${OFFSITE_BACKUP_DIR}}. Failed stability checks trigger an automatic rollback. +if [[ -f "$INSTALL_DIR/.env" || -f "$INSTALL_DIR/compose.yaml" || -f "$INSTALL_DIR/docker-compose.yml" ]]; then + timestamp=$(date +%Y%m%d-%H%M%S) + ROLLBACK_ARCHIVE="$INSTALL_DIR/backups/installer-before-${timestamp}.tar.gz" + old_items=() + for item in .env compose.yaml compose.openvpn.yaml compose.wireguard.yaml compose.gpu.yaml docker-compose.yml \ + update_stack.sh sync_transmission_port.sh media_stack.sh important_info.md secrets config/newt/config.json; do + [[ -e "$INSTALL_DIR/$item" ]] && old_items+=("$item") + done + if ((${#old_items[@]} > 0)); then + tar -czf "$ROLLBACK_ARCHIVE" -C "$INSTALL_DIR" "${old_items[@]}" + tar -tzf "$ROLLBACK_ARCHIVE" >/dev/null + fi +fi -## Transmission port forwarding +DEPLOYMENT_STARTED=true +install -m 0600 "$STAGE_DIR/.env" "$INSTALL_DIR/.env" +install -m 0640 "$STAGE_DIR/compose.yaml" "$STAGE_DIR/compose.openvpn.yaml" \ + "$STAGE_DIR/compose.wireguard.yaml" "$STAGE_DIR/compose.gpu.yaml" "$INSTALL_DIR/" +install -m 0750 "$STAGE_DIR/update_stack.sh" "$STAGE_DIR/sync_transmission_port.sh" "$STAGE_DIR/media_stack.sh" "$INSTALL_DIR/" +install -m 0600 "$STAGE_DIR/secrets/"* "$INSTALL_DIR/secrets/" +if [[ "$VPN_TYPE" == openvpn ]]; then + rm -f "$INSTALL_DIR/secrets/proton_wireguard_private_key" +else + rm -f "$INSTALL_DIR/secrets/proton_openvpn_user" "$INSTALL_DIR/secrets/proton_openvpn_password" +fi +install -m 0600 "$STAGE_DIR/config/newt/config.json" "$INSTALL_DIR/config/newt/config.json" +rm -f "$INSTALL_DIR/docker-compose.yml" + +if [[ "$ENABLE_TAILSCALE" == yes ]]; then + if ! command -v tailscale >/dev/null; then + log_info "Installing Tailscale from its signed APT repository..." + install -m 0755 -d /usr/share/keyrings + curl --fail --silent --show-error --location --retry 3 \ + "https://pkgs.tailscale.com/stable/${ID}/${VERSION_CODENAME}.noarmor.gpg" \ + -o /usr/share/keyrings/tailscale-archive-keyring.gpg + curl --fail --silent --show-error --location --retry 3 \ + "https://pkgs.tailscale.com/stable/${ID}/${VERSION_CODENAME}.tailscale-keyring.list" \ + -o /etc/apt/sources.list.d/tailscale.list + apt-get update + apt-get install -y -q tailscale + fi + systemctl enable --now tailscaled >/dev/null + if [[ -z "$(tailscale ip -4 2>/dev/null | head -n1)" ]]; then + log_info "Authenticate Tailscale using the URL displayed below." + tailscale up --timeout=10m + fi + [[ -n "$(tailscale ip -4 2>/dev/null | head -n1)" ]] || die "Tailscale did not connect." +fi -The ProtonVPN forwarded port is synchronized with Transmission automatically every minute. No manual port script or panel action is needed. -EOF +log_info "Pulling images and starting the stack (this can take several minutes)..." +( + cd "$INSTALL_DIR" || exit 1 + docker compose config --quiet + docker compose pull + docker compose up -d --remove-orphans --wait --wait-timeout 420 +) -chown -R "$PUID:$PGID" "$INSTALL_DIR/config" "$INSTALL_DIR/data" -chown -R 1000:1000 "$INSTALL_DIR/config/seerr" -find "$INSTALL_DIR/config" -type d -exec chmod 750 {} + -find "$INSTALL_DIR/config" -type f -exec chmod 640 {} + -find "$INSTALL_DIR/data" -type d -exec chmod 775 {} + -chmod 600 "$INSTALL_DIR/.env" -chmod 640 "$INSTALL_DIR/docker-compose.yml" "$INSTALL_DIR/important_info.md" - -log_info "Validating Docker Compose configuration..." -cd "$INSTALL_DIR" -docker compose config --quiet -docker compose up -d --wait --wait-timeout 300 - -if $JELLYSEERR_CONTAINER_FOUND; then - log_info "Seerr is healthy; removing the previous Jellyseerr container..." +if $JELLYSEERR_MIGRATED && docker container inspect jellyseerr >/dev/null 2>&1; then docker rm jellyseerr >/dev/null JELLYSEERR_WAS_RUNNING=false fi -docker compose up -d --remove-orphans -log_info "Configuring private Tailscale access..." -for port in 8096 5055 9091 7878 8989 9696 6767; do - if ! tailscale serve --bg --https="$port" "http://127.0.0.1:$port"; then - log_warn "Tailscale Serve could not configure HTTPS port $port. You can retry after installation." - fi -done +if [[ "$ENABLE_TAILSCALE" == yes ]]; then + log_info "Configuring private HTTPS endpoints with Tailscale Serve..." + for port in 5055 6767 7878 8096 8989 9091 9696; do + tailscale serve --bg --https="$port" "http://127.0.0.1:$port" >/dev/null || + log_warn "Tailscale Serve could not configure HTTPS port $port; retry with: media-stack repair-ip" + done +fi cat > /etc/systemd/system/media-stack-update.service < /etc/systemd/system/media-stack-update.timer <<'EOF' @@ -571,14 +672,20 @@ EOF cat > /etc/systemd/system/media-stack-port-sync.service < /etc/systemd/system/media-stack-port-sync.timer <<'EOF' @@ -586,17 +693,62 @@ cat > /etc/systemd/system/media-stack-port-sync.timer <<'EOF' Description=Periodic Transmission port synchronization [Timer] -OnBootSec=2m +OnBootSec=90s OnUnitActiveSec=1m RandomizedDelaySec=10s +Persistent=true [Install] WantedBy=timers.target EOF systemctl daemon-reload -systemctl enable --now media-stack-update.timer media-stack-port-sync.timer +systemctl enable --now media-stack-update.timer media-stack-port-sync.timer >/dev/null +ln -sfn "$INSTALL_DIR/media_stack.sh" /usr/local/sbin/media-stack + +cat > "$INSTALL_DIR/important_info.md" <> "$INSTALL_DIR/important_info.md" <&2; } +fail() { printf '%b[FAIL]%b %s\n' "$RED" "$NC" "$*" >&2; } +die() { fail "$*"; exit 1; } + +usage() { + cat <<'EOF' +Media Stack management tool + +Usage: media-stack COMMAND [ARGUMENT] + +Commands: + status Show containers, addresses and timers. + doctor Run end-to-end checks, including VPN leak isolation. + configure [--quiet] Idempotently wire Radarr/Sonarr/Prowlarr/Transmission. + repair-ip Detect a changed LAN IP and recreate port bindings. + backup Create a consistent stopped-stack configuration backup. + logs SERVICE Follow logs for one declared Compose service. + version Print the installed tool version. + help Show this help. +EOF +} + +# Help and version must also work from a source checkout, before installation +# has created the runtime environment file. +case "${1:-help}" in + help|-h|--help) + (($# <= 1)) || die "help takes no arguments." + usage + exit 0 + ;; + version) + (($# == 1)) || die "version takes no arguments." + printf 'media-stack %s\n' "$TOOL_VERSION" + exit 0 + ;; +esac + +[[ -f "$ENV_FILE" ]] || die "Missing $ENV_FILE. Run the installer first." + +read_env() { + local key=$1 line value + line=$(awk -v key="$key" 'index($0, key "=") == 1 {print; exit}' "$ENV_FILE") + [[ -n "$line" ]] || return 0 + value=${line#*=} + if [[ "$value" == "'"*"'" && ${#value} -ge 2 ]]; then + value=${value:1:${#value}-2} + elif [[ "$value" == '"'*'"' && ${#value} -ge 2 ]]; then + value=${value:1:${#value}-2} + fi + printf '%s' "$value" +} + +write_env() { + local key=$1 value=$2 temp line + [[ "$value" != *"'"* && "$value" != *$'\n'* ]] || die "Unsupported value for $key." + temp=$(mktemp "$STACK_DIR/.env.XXXXXX") + line="$key='$value'" + awk -v key="$key" -v replacement="$line" ' + BEGIN { done = 0 } + index($0, key "=") == 1 { + if (!done) print replacement + done = 1 + next + } + { print } + END { if (!done) print replacement } + ' "$ENV_FILE" > "$temp" + chmod 0600 "$temp" + mv -f "$temp" "$ENV_FILE" +} + +compose() { + (cd "$STACK_DIR" && docker compose "$@") +} + +detect_lan_ip() { + local detected + detected=$(ip -4 route get 1.1.1.1 2>/dev/null | awk '{for (i=1; i<=NF; i++) if ($i == "src") {print $(i+1); exit}}') + [[ -n "$detected" ]] || detected=$(hostname -I | awk '{print $1}') + printf '%s' "$detected" +} + +has_profile() { + local profiles + profiles=$(read_env COMPOSE_PROFILES) + [[ ",$profiles," == *",$1,"* ]] +} + +command_status() { + local lan_ip public_domain + lan_ip=$(read_env LAN_IP) + public_domain=$(read_env PUBLIC_DOMAIN) + compose ps + printf '\nLAN endpoints (%s):\n' "$lan_ip" + printf ' Jellyfin http://%s:8096\n' "$lan_ip" + printf ' Seerr http://%s:5055\n' "$lan_ip" + printf ' Transmission http://%s:9091\n' "$lan_ip" + printf ' Radarr http://%s:7878\n' "$lan_ip" + printf ' Sonarr http://%s:8989\n' "$lan_ip" + printf ' Prowlarr http://%s:9696\n' "$lan_ip" + printf ' Bazarr http://%s:6767\n' "$lan_ip" + if has_profile pangolin; then + printf '\nPublic through Pangolin:\n https://jellyfin.%s\n https://seerr.%s\n' "$public_domain" "$public_domain" + fi + if [[ "$(read_env ENABLE_TAILSCALE)" == yes ]] && command -v tailscale >/dev/null; then + printf '\nTailscale IP: %s\n' "$(tailscale ip -4 2>/dev/null | head -n1 || printf 'disconnected')" + fi + printf '\nTimers:\n' + systemctl list-timers --all media-stack-update.timer media-stack-port-sync.timer --no-pager 2>/dev/null || true +} + +CHECK_FAILURES=0 +CHECK_WARNINGS=0 +check_ok() { ok "$*"; } +check_fail() { fail "$*"; CHECK_FAILURES=$((CHECK_FAILURES + 1)); } +check_warn() { warn "$*"; CHECK_WARNINGS=$((CHECK_WARNINGS + 1)); } + +probe_http() { + local name=$1 url=$2 + if curl --fail --silent --show-error --max-time 8 "$url" >/dev/null 2>&1; then + check_ok "$name responds at $url" + else + check_fail "$name does not respond at $url" + fi +} + +command_doctor() { + local configured_ip detected_ip puid pgid storage_test hardlink_source hardlink_target + local service container_id status health gluetun_id transmission_id network_mode host_ip vpn_ip + local forwarded_port offsite_dir offsite_source offsite_mount current_source current_target unit tailscale_ip + CHECK_FAILURES=0 + CHECK_WARNINGS=0 + + [[ $EUID -eq 0 ]] || check_warn "Run as root for complete storage and systemd checks." + if [[ -c /dev/net/tun && -r /dev/net/tun && -w /dev/net/tun ]]; then + check_ok "/dev/net/tun is usable" + else + check_fail "/dev/net/tun is not usable" + fi + if docker info >/dev/null 2>&1; then check_ok "Docker daemon is available"; else check_fail "Docker daemon is unavailable"; fi + if compose config --quiet >/dev/null 2>&1; then check_ok "Compose configuration is valid"; else check_fail "Compose configuration is invalid"; fi + + configured_ip=$(read_env LAN_IP) + detected_ip=$(detect_lan_ip) + if [[ "$configured_ip" == "$detected_ip" ]] && ip -4 addr show | grep -Fq " $configured_ip/"; then + check_ok "LAN binding matches the current address ($configured_ip)" + else + check_fail "LAN binding is $configured_ip but the detected address is $detected_ip; run: media-stack repair-ip" + fi + + puid=$(read_env PUID) + pgid=$(read_env PGID) + storage_test="$STACK_DIR/data/.doctor-write-test" + if setpriv --reuid="$puid" --regid="$pgid" --clear-groups touch "$storage_test" 2>/dev/null; then + rm -f "$storage_test" + check_ok "Media UID:GID can write to the data directory" + else + check_fail "Media UID:GID cannot write to $STACK_DIR/data" + fi + hardlink_source="$STACK_DIR/data/torrents/.doctor-hardlink-test" + hardlink_target="$STACK_DIR/data/media/.doctor-hardlink-test" + if setpriv --reuid="$puid" --regid="$pgid" --clear-groups touch "$hardlink_source" 2>/dev/null && + setpriv --reuid="$puid" --regid="$pgid" --clear-groups ln "$hardlink_source" "$hardlink_target" 2>/dev/null; then + check_ok "Hardlinks work across download and media paths" + else + check_warn "Hardlinks do not work; ARR imports will copy data" + fi + rm -f "$hardlink_source" "$hardlink_target" + + while IFS= read -r service; do + container_id=$(compose ps -q "$service" 2>/dev/null || true) + if [[ -z "$container_id" ]]; then + check_fail "$service has no container" + continue + fi + status=$(docker inspect --format '{{.State.Status}}' "$container_id" 2>/dev/null || true) + health=$(docker inspect --format '{{if .State.Health}}{{.State.Health.Status}}{{else}}none{{end}}' "$container_id" 2>/dev/null || true) + if [[ "$status" == running && ("$health" == healthy || "$health" == none) ]]; then + check_ok "$service is running (health: $health)" + else + check_fail "$service state is $status (health: $health)" + fi + done < <(compose config --services 2>/dev/null || true) + + gluetun_id=$(compose ps -q gluetun 2>/dev/null || true) + transmission_id=$(compose ps -q transmission 2>/dev/null || true) + if [[ -n "$gluetun_id" && -n "$transmission_id" ]]; then + network_mode=$(docker inspect --format '{{.HostConfig.NetworkMode}}' "$transmission_id" 2>/dev/null || true) + if [[ "$network_mode" == "container:$gluetun_id" ]]; then + check_ok "Transmission shares Gluetun's network namespace (kill switch enforced)" + else + check_fail "Transmission is not isolated in Gluetun's network namespace" + fi + fi + + probe_http Jellyfin http://127.0.0.1:8096/System/Info/Public + probe_http Seerr http://127.0.0.1:5055/api/v1/settings/public + probe_http Radarr http://127.0.0.1:7878/ping + probe_http Sonarr http://127.0.0.1:8989/ping + probe_http Prowlarr http://127.0.0.1:9696/ping + probe_http Bazarr http://127.0.0.1:6767/ + if [[ ! -s "$STACK_DIR/secrets/transmission_user" || ! -s "$STACK_DIR/secrets/transmission_password" ]]; then + check_fail "Transmission credential files are missing" + elif curl --fail --silent --show-error --max-time 8 \ + -u "$(<"$STACK_DIR/secrets/transmission_user"):$(<"$STACK_DIR/secrets/transmission_password")" \ + http://127.0.0.1:9091/transmission/web/ >/dev/null 2>&1; then + check_ok "Transmission responds with the configured credentials" + else + check_fail "Transmission does not accept the configured credentials" + fi + + host_ip=$(curl --fail --silent --show-error --max-time 10 https://api.ipify.org 2>/dev/null || true) + vpn_ip=$(compose exec -T gluetun wget -qO- -T 10 https://api.ipify.org 2>/dev/null || true) + host_ip=${host_ip//$'\n'/} + vpn_ip=${vpn_ip//$'\n'/} + if [[ -n "$host_ip" && -n "$vpn_ip" && "$host_ip" != "$vpn_ip" ]]; then + check_ok "VPN egress is distinct from host egress ($vpn_ip vs $host_ip)" + elif [[ -n "$host_ip" && "$host_ip" == "$vpn_ip" ]]; then + check_fail "VPN and host public IP are identical ($host_ip); stop Transmission and inspect Gluetun" + else + check_warn "Could not compare public host and VPN addresses" + fi + + forwarded_port=$(compose exec -T gluetun cat /tmp/gluetun/forwarded_port 2>/dev/null || true) + forwarded_port=${forwarded_port//$'\n'/} + if [[ "$forwarded_port" =~ ^[0-9]+$ ]] && ((forwarded_port > 0 && forwarded_port < 65536)); then + check_ok "ProtonVPN assigned forwarded port $forwarded_port" + else + check_warn "ProtonVPN has not assigned a valid forwarded port" + fi + + offsite_dir=$(read_env OFFSITE_BACKUP_DIR) + if [[ -n "$offsite_dir" ]]; then + offsite_source=$(read_env OFFSITE_BACKUP_SOURCE) + offsite_mount=$(read_env OFFSITE_BACKUP_MOUNTPOINT) + current_source="" + current_target="" + read -r current_source current_target < <(findmnt -T "$offsite_dir" -n -o SOURCE,TARGET --first 2>/dev/null || true) + if [[ "$current_source" == "$offsite_source" && "$current_target" == "$offsite_mount" && -w "$offsite_dir" ]]; then + check_ok "External backup mount identity is unchanged ($offsite_source on $offsite_mount)" + else + check_fail "External backup mount is missing or changed; refusing silent fallback to local storage" + fi + fi + + for unit in media-stack-update.timer media-stack-port-sync.timer; do + if systemctl is-enabled --quiet "$unit" && systemctl is-active --quiet "$unit"; then + check_ok "$unit is enabled and active" + else + check_fail "$unit is not enabled and active" + fi + done + if [[ "$(read_env ENABLE_TAILSCALE)" == yes ]]; then + tailscale_ip=$(tailscale ip -4 2>/dev/null | awk 'NR == 1' || true) + if [[ -n "$tailscale_ip" ]]; then check_ok "Tailscale is connected"; else check_fail "Tailscale is disconnected"; fi + fi + + printf '\nDoctor result: %d failure(s), %d warning(s).\n' "$CHECK_FAILURES" "$CHECK_WARNINGS" + ((CHECK_FAILURES == 0)) +} + +api_key_from_config() { + local file=$1 + sed -n 's:.*\([^<]*\).*:\1:p' "$file" 2>/dev/null | awk 'NR == 1' || true +} + +wait_http() { + local url=$1 deadline=$((SECONDS + 120)) + until curl --fail --silent --max-time 4 "$url" >/dev/null 2>&1; do + ((SECONDS < deadline)) || return 1 + sleep 3 + done +} + +api_request() { + local method=$1 url=$2 api_key=$3 payload=${4:-} response + response=$(mktemp) + if [[ -n "$payload" ]]; then + if ! curl --fail --silent --show-error --max-time 20 -X "$method" \ + -H "X-Api-Key: $api_key" -H 'Content-Type: application/json' \ + --data "$payload" "$url" > "$response"; then + rm -f "$response" + return 1 + fi + else + if ! curl --fail --silent --show-error --max-time 20 -X "$method" \ + -H "X-Api-Key: $api_key" "$url" > "$response"; then + rm -f "$response" + return 1 + fi + fi + cat "$response" + rm -f "$response" +} + +ensure_root_folder() { + local name=$1 base_url=$2 api_key=$3 path=$4 existing payload + existing=$(api_request GET "$base_url/rootfolder" "$api_key") + if jq -e --arg path "$path" '.[] | select(.path == $path)' <<< "$existing" >/dev/null; then + $QUIET || ok "$name root folder already exists: $path" + return + fi + payload=$(jq -cn --arg path "$path" '{path:$path}') + api_request POST "$base_url/rootfolder" "$api_key" "$payload" >/dev/null + $QUIET || ok "$name root folder created: $path" +} + +ensure_transmission_client() { + local name=$1 base_url=$2 api_key=$3 category=$4 clients existing schema payload id method url + clients=$(api_request GET "$base_url/downloadclient" "$api_key") + existing=$(jq -c '[.[] | select(.name == "Media Stack Transmission")][0] // empty' <<< "$clients") + if [[ -n "$existing" ]]; then + payload=$existing + id=$(jq -r '.id' <<< "$existing") + method=PUT + url="$base_url/downloadclient/$id" + else + schema=$(api_request GET "$base_url/downloadclient/schema" "$api_key") + payload=$(jq -c '[.[] | select(.implementation == "Transmission")][0] // empty' <<< "$schema") + [[ -n "$payload" ]] || die "$name did not expose a Transmission download-client schema." + method=POST + url="$base_url/downloadclient" + fi + payload=$(jq -c \ + --arg username "$(<"$STACK_DIR/secrets/transmission_user")" \ + --arg password "$(<"$STACK_DIR/secrets/transmission_password")" \ + --arg category "$category" ' + .name = "Media Stack Transmission" | + .enable = true | + .priority = 1 | + .fields |= map( + if .name == "host" then .value = "gluetun" + elif .name == "port" then .value = 9091 + elif .name == "useSsl" then .value = false + elif .name == "urlBase" then .value = "/transmission/" + elif .name == "username" then .value = $username + elif .name == "password" then .value = $password + elif (.name == "category" or .name == "movieCategory" or .name == "tvCategory") then .value = $category + elif .name == "addPaused" then .value = false + else . end + ) + ' <<< "$payload") + api_request "$method" "$url" "$api_key" "$payload" >/dev/null + $QUIET || ok "$name is wired to Transmission with category $category" +} + +ensure_prowlarr_application() { + local implementation=$1 target_url=$2 target_key=$3 prowlarr_key=$4 base_url existing applications schema payload id method url + base_url=http://127.0.0.1:9696/api/v1 + applications=$(api_request GET "$base_url/applications" "$prowlarr_key") + existing=$(jq -c --arg impl "$implementation" '[.[] | select(.implementation == $impl)][0] // empty' <<< "$applications") + if [[ -n "$existing" ]]; then + payload=$existing + id=$(jq -r '.id' <<< "$existing") + method=PUT + url="$base_url/applications/$id" + else + schema=$(api_request GET "$base_url/applications/schema" "$prowlarr_key") + payload=$(jq -c --arg impl "$implementation" '[.[] | select(.implementation == $impl)][0] // empty' <<< "$schema") + [[ -n "$payload" ]] || die "Prowlarr did not expose the $implementation application schema." + method=POST + url="$base_url/applications" + fi + payload=$(jq -c --arg name "Media Stack $implementation" --arg target "$target_url" --arg key "$target_key" ' + .name = $name | + .enable = true | + .syncLevel = "fullSync" | + .fields |= map( + if .name == "prowlarrUrl" then .value = "http://prowlarr:9696" + elif .name == "baseUrl" then .value = $target + elif .name == "apiKey" then .value = $key + else . end + ) + ' <<< "$payload") + api_request "$method" "$url" "$prowlarr_key" "$payload" >/dev/null + $QUIET || ok "Prowlarr is wired to $implementation" +} + +command_configure() { + QUIET=false + case "${1:-}" in + "") ;; + --quiet) QUIET=true ;; + *) die "Usage: media-stack configure [--quiet]" ;; + esac + [[ -s "$STACK_DIR/secrets/transmission_user" && -s "$STACK_DIR/secrets/transmission_password" ]] || + die "Transmission credential files are missing." + wait_http http://127.0.0.1:7878/ping || die "Radarr did not become ready." + wait_http http://127.0.0.1:8989/ping || die "Sonarr did not become ready." + wait_http http://127.0.0.1:9696/ping || die "Prowlarr did not become ready." + + radarr_key=$(api_key_from_config "$STACK_DIR/config/radarr/config.xml") + sonarr_key=$(api_key_from_config "$STACK_DIR/config/sonarr/config.xml") + prowlarr_key=$(api_key_from_config "$STACK_DIR/config/prowlarr/config.xml") + [[ -n "$radarr_key" && -n "$sonarr_key" && -n "$prowlarr_key" ]] || die "Could not read one or more ARR API keys." + + ensure_root_folder Radarr http://127.0.0.1:7878/api/v3 "$radarr_key" /data/media/movies + ensure_root_folder Sonarr http://127.0.0.1:8989/api/v3 "$sonarr_key" /data/media/tv + ensure_transmission_client Radarr http://127.0.0.1:7878/api/v3 "$radarr_key" movies + ensure_transmission_client Sonarr http://127.0.0.1:8989/api/v3 "$sonarr_key" tv + ensure_prowlarr_application Radarr http://radarr:7878 "$radarr_key" "$prowlarr_key" + ensure_prowlarr_application Sonarr http://sonarr:8989 "$sonarr_key" "$prowlarr_key" + $QUIET || ok "ARR wiring is complete and idempotent." +} + +configure_tailscale_serve() { + [[ "$(read_env ENABLE_TAILSCALE)" == yes ]] || return 0 + command -v tailscale >/dev/null || return 0 + for port in 5055 6767 7878 8096 8989 9091 9696; do + tailscale serve --bg --https="$port" "http://127.0.0.1:$port" >/dev/null + done +} + +command_repair_ip() { + local old_ip new_ip escaped_old + [[ $EUID -eq 0 ]] || die "repair-ip must run as root." + old_ip=$(read_env LAN_IP) + new_ip=$(detect_lan_ip) + [[ -n "$new_ip" ]] || die "Could not detect the current LAN IPv4 address." + if [[ "$old_ip" == "$new_ip" ]] && ip -4 addr show | grep -Fq " $new_ip/"; then + ok "The configured LAN IP is already current: $new_ip" + configure_tailscale_serve + return + fi + info "Changing Docker bindings from $old_ip to $new_ip." + write_env LAN_IP "$new_ip" + if ! compose up -d --remove-orphans --force-recreate --wait --wait-timeout 420; then + write_env LAN_IP "$old_ip" + compose up -d --remove-orphans || true + die "Containers failed with $new_ip; restored $old_ip." + fi + configure_tailscale_serve + if [[ -f "$STACK_DIR/important_info.md" ]]; then + escaped_old=${old_ip//./\\.} + sed -i "s/${escaped_old}/${new_ip}/g" "$STACK_DIR/important_info.md" + fi + ok "LAN bindings were repaired for $new_ip." +} + +validate_offsite_mount() { + local directory source target current_source current_target + directory=$(read_env OFFSITE_BACKUP_DIR) + [[ -n "$directory" ]] || return 0 + source=$(read_env OFFSITE_BACKUP_SOURCE) + target=$(read_env OFFSITE_BACKUP_MOUNTPOINT) + current_source="" + current_target="" + read -r current_source current_target < <(findmnt -T "$directory" -n -o SOURCE,TARGET --first 2>/dev/null || true) + [[ "$current_source" == "$source" && "$current_target" == "$target" && -w "$directory" ]] || + die "External backup filesystem identity changed or is unavailable: $directory" +} + +command_backup() { + local state_dir backup_dir timestamp temporary backup offsite stack_stopped + local item + local -a items existing_items + [[ $EUID -eq 0 ]] || die "backup must run as root." + state_dir="$STACK_DIR/.update-state" + backup_dir="$STACK_DIR/backups" + mkdir -p "$state_dir" "$backup_dir" + exec 9>"$state_dir/update.lock" + flock -n 9 || die "An update or backup is already running." + validate_offsite_mount + timestamp=$(date +%Y%m%d-%H%M%S) + temporary="$backup_dir/.media-stack-$timestamp.tar.gz.partial" + backup="$backup_dir/media-stack-$timestamp.tar.gz" + stack_stopped=false + restart_stack_on_exit() { + local status=$? + trap - EXIT + if $stack_stopped; then + compose up -d --remove-orphans --wait --wait-timeout 420 || true + fi + exit "$status" + } + trap restart_stack_on_exit EXIT + compose stop --timeout 60 + stack_stopped=true + items=(config secrets .env compose.yaml compose.openvpn.yaml compose.wireguard.yaml compose.gpu.yaml important_info.md update_stack.sh sync_transmission_port.sh media_stack.sh) + existing_items=() + for item in "${items[@]}"; do + [[ -e "$STACK_DIR/$item" ]] && existing_items+=("$item") + done + ((${#existing_items[@]} > 0)) || die "No stack configuration files were found to back up." + tar -czf "$temporary" -C "$STACK_DIR" "${existing_items[@]}" + tar -tzf "$temporary" >/dev/null + mv "$temporary" "$backup" + offsite=$(read_env OFFSITE_BACKUP_DIR) + if [[ -n "$offsite" ]]; then + validate_offsite_mount + cp -a "$backup" "$offsite/" + fi + compose up -d --remove-orphans --wait --wait-timeout 420 + stack_stopped=false + trap - EXIT INT TERM + ok "Consistent backup created: $backup" +} + +command_logs() { + local service=${1:-} + [[ -n "$service" ]] || die "Usage: media-stack logs SERVICE" + if ! compose config --services | grep -Fxq "$service"; then + die "Unknown or disabled service: $service" + fi + compose logs --tail=200 --follow "$service" +} + +case "${1:-help}" in + status) shift; (($# == 0)) || die "status takes no arguments."; command_status ;; + doctor) shift; (($# == 0)) || die "doctor takes no arguments."; command_doctor ;; + configure) shift; (($# <= 1)) || die "Usage: media-stack configure [--quiet]"; command_configure "${1:-}" ;; + repair-ip) shift; (($# == 0)) || die "repair-ip takes no arguments."; command_repair_ip ;; + backup) shift; (($# == 0)) || die "backup takes no arguments."; command_backup ;; + logs) shift; (($# == 1)) || die "Usage: media-stack logs SERVICE"; command_logs "$1" ;; + *) usage >&2; die "Unknown command: $1" ;; +esac diff --git a/port.sh b/port.sh deleted file mode 100755 index e2fd7b2..0000000 --- a/port.sh +++ /dev/null @@ -1,35 +0,0 @@ -#!/bin/bash - -# Colors for better readability -GREEN='\033[0;32m' -BLUE='\033[0;34m' -YELLOW='\033[1;33m' -RED='\033[0;31m' -NC='\033[0m' - -echo -e "${BLUE}--- Checking VPN Port (Gluetun) ---${NC}" - -# 1. Check if gluetun container is running -if ! docker ps --format '{{.Names}}' | grep -q "^gluetun$"; then - echo -e "${RED}[ERROR] 'gluetun' container is not running.${NC}" - exit 1 -fi - -# 2. Extract port from logs (looking for the last "port forwarded is" line) -PORT=$(docker logs gluetun 2>&1 | grep "port forwarded is" | tail -n 1 | grep -oE '[0-9]+$') - -# 3. Display result -if [ -z "$PORT" ]; then - echo -e "${YELLOW}[INFO] No forwarded port found yet.${NC}" - echo -e "Ensure VPN is connected and Gluetun has requested a port from ProtonVPN." - echo -e "You can check full logs with: ${BLUE}docker logs gluetun${NC}" -else - echo -e "${GREEN}[SUCCESS] Your current port is: ${PORT}${NC}" - echo -e "" - echo -e "What to do next?" - echo -e "1. Open Transmission Web UI in your browser." - echo -e "2. Click the settings icon (wrench/screwdriver) in the bottom left corner." - echo -e "3. Go to the ${BLUE}Network${NC} tab." - echo -e "4. In the ${BLUE}Peer listening port${NC} field, enter: ${GREEN}${PORT}${NC}" - echo -e "5. Click outside the field or close the window to save." -fi diff --git a/proxmox_lxc.sh b/proxmox_lxc.sh new file mode 100644 index 0000000..9d1a609 --- /dev/null +++ b/proxmox_lxc.sh @@ -0,0 +1,315 @@ +#!/usr/bin/env bash + +# This script runs on the Proxmox VE host. It creates an unprivileged LXC, +# passes through the required devices, and launches install_media.sh inside it. + +set -Eeuo pipefail +umask 077 + +readonly PROVISIONER_VERSION="4.0.0" +readonly PROJECT_REPOSITORY="placq/media-stack" + +RED='\033[0;31m'; GREEN='\033[0;32m'; YELLOW='\033[1;33m'; BLUE='\033[0;34m'; NC='\033[0m' +info() { printf '%b[INFO]%b %s\n' "$BLUE" "$NC" "$*"; } +ok() { printf '%b[OK]%b %s\n' "$GREEN" "$NC" "$*"; } +warn() { printf '%b[WARN]%b %s\n' "$YELLOW" "$NC" "$*" >&2; } +die() { printf '%b[ERROR]%b %s\n' "$RED" "$NC" "$*" >&2; exit 1; } + +usage() { + cat <<'EOF' +Media Stack LXC provisioner (run on a Proxmox VE host) + +Usage: + bash proxmox_lxc.sh + bash proxmox_lxc.sh --help + +The script creates a new unprivileged Debian 13 LXC and then runs the media +installer inside that LXC. It never runs Docker or media services on the +Proxmox host itself. +EOF +} + +case "${1:-}" in + "") ;; + --help|-h) usage; exit 0 ;; + *) usage >&2; die "Unknown option: $1" ;; +esac + +[[ $EUID -eq 0 ]] || die "Run this script as root on the Proxmox VE host." +[[ -t 0 ]] || die "An interactive Proxmox shell is required; do not pipe this script to bash." +if ! command -v pveversion >/dev/null || ! command -v pct >/dev/null || ! command -v pveam >/dev/null; then + die "This is not a Proxmox VE host (pveversion/pct/pveam are missing)." +fi +[[ -e /dev/net/tun ]] || die "The Proxmox host has no /dev/net/tun device." + +mkdir -p /run/lock +exec 8>/run/lock/media-stack-lxc-provisioner.lock +flock -n 8 || die "Another Media Stack LXC provisioner is already running." + +TEMP_DIR=$(mktemp -d) +CT_CREATED=false +CTID="" +cleanup() { + local status=$? + trap - EXIT + rm -rf -- "$TEMP_DIR" + if ((status != 0)) && $CT_CREATED; then + warn "Provisioning stopped after CT $CTID was created. It was NOT deleted; inspect it with: pct config $CTID" + fi + exit "$status" +} +trap cleanup EXIT +trap 'printf "%b[ERROR]%b Failure at line %s.\n" "$RED" "$NC" "$LINENO" >&2' ERR + +prompt() { + local variable=$1 label=$2 default=${3:-} answer + if [[ -n "$default" ]]; then + read -r -p "$label [$default]: " answer + printf -v "$variable" '%s' "${answer:-$default}" + else + read -r -p "$label: " answer + printf -v "$variable" '%s' "$answer" + fi +} + +yes_no() { + local variable=$1 label=$2 default=${3:-yes} answer suffix + if [[ "$default" == yes ]]; then suffix=Y/n; else suffix=y/N; fi + read -r -p "$label ($suffix): " answer + case "$answer" in + [Yy]|[Yy][Ee][Ss]) printf -v "$variable" yes ;; + [Nn]|[Nn][Oo]) printf -v "$variable" no ;; + "") printf -v "$variable" '%s' "$default" ;; + *) die "Expected yes or no." ;; + esac +} + +first_storage_for() { + local content=$1 + pvesm status --content "$content" 2>/dev/null | awk 'NR > 1 && $3 == "active" {print $1; exit}' +} + +storage_supports() { + local storage=$1 content=$2 + pvesm status --content "$content" 2>/dev/null | awk 'NR > 1 && $1 == storage && $3 == "active" {found=1} END {exit !found}' storage="$storage" +} + +valid_ipv4() { + local address=$1 octet + local -a octets + IFS=. read -r -a octets <<< "$address" + ((${#octets[@]} == 4)) || return 1 + for octet in "${octets[@]}"; do + if [[ ! "$octet" =~ ^[0-9]{1,3}$ ]] || ((10#$octet > 255)); then + return 1 + fi + done +} + +PVE_VERSION=$(pveversion | head -n1) +printf '%b\n' "$BLUE============================================================$NC" +printf '%b\n' "$BLUE MEDIA STACK — PROXMOX LXC PROVISIONER v${PROVISIONER_VERSION}$NC" +printf '%b\n\n' "$BLUE============================================================$NC" +info "Detected $PVE_VERSION" +info "Docker and all media applications will be installed only inside the new LXC." + +NEXT_ID=$(pvesh get /cluster/nextid 2>/dev/null | tr -dc '0-9') +prompt CTID "New CT ID" "$NEXT_ID" +[[ "$CTID" =~ ^[1-9][0-9]{2,8}$ ]] || die "CT ID must be an integer of at least 100." +[[ ! -e "/etc/pve/lxc/${CTID}.conf" ]] || die "CT $CTID already exists; this provisioner never overwrites a guest." + +prompt HOSTNAME "LXC hostname" media +[[ "$HOSTNAME" =~ ^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$ ]] || die "Invalid hostname." + +DEFAULT_ROOT_STORAGE=$(first_storage_for rootdir) +[[ -n "$DEFAULT_ROOT_STORAGE" ]] || die "No active Proxmox storage supports LXC root directories." +prompt ROOT_STORAGE "Root filesystem storage" "$DEFAULT_ROOT_STORAGE" +storage_supports "$ROOT_STORAGE" rootdir || die "Storage $ROOT_STORAGE is not active or does not support rootdir content." +prompt ROOT_DISK_GB "Root filesystem size in GiB" 32 +if [[ ! "$ROOT_DISK_GB" =~ ^[0-9]+$ ]] || ((ROOT_DISK_GB < 16)); then + die "Root disk must be at least 16 GiB." +fi + +prompt CORES "CPU cores" 4 +prompt MEMORY_MB "Memory in MiB" 8192 +prompt SWAP_MB "Swap in MiB" 512 +if [[ ! "$CORES" =~ ^[0-9]+$ ]] || ((CORES < 2)); then die "At least 2 CPU cores are required."; fi +if [[ ! "$MEMORY_MB" =~ ^[0-9]+$ ]] || ((MEMORY_MB < 2048)); then die "At least 2048 MiB of memory is required."; fi +[[ "$SWAP_MB" =~ ^[0-9]+$ ]] || die "Swap must be a non-negative integer." + +prompt BRIDGE "Proxmox network bridge" vmbr0 +ip link show "$BRIDGE" >/dev/null 2>&1 || die "Network bridge $BRIDGE does not exist." +prompt NETWORK_MODE "IPv4 mode (dhcp/static)" dhcp +NET0="name=eth0,bridge=${BRIDGE},firewall=1,ip6=auto" +case "$NETWORK_MODE" in + dhcp) + NET0+=",ip=dhcp" + ;; + static) + prompt IPV4_CIDR "LXC IPv4 address with prefix (for example 192.168.1.50/24)" + prompt IPV4_GATEWAY "IPv4 gateway (for example 192.168.1.1)" + if [[ ! "$IPV4_CIDR" =~ ^(.+)/([0-9]|[12][0-9]|3[0-2])$ ]]; then + die "Invalid IPv4 CIDR." + fi + valid_ipv4 "${BASH_REMATCH[1]}" || die "Invalid IPv4 CIDR." + valid_ipv4 "$IPV4_GATEWAY" || die "Invalid IPv4 gateway." + NET0+=",ip=${IPV4_CIDR},gw=${IPV4_GATEWAY}" + ;; + *) die "IPv4 mode must be dhcp or static." ;; +esac + +prompt VLAN_TAG "Optional VLAN tag (empty means untagged)" "" +if [[ -n "$VLAN_TAG" ]]; then + if [[ ! "$VLAN_TAG" =~ ^[0-9]+$ ]] || ((VLAN_TAG < 1 || VLAN_TAG > 4094)); then + die "VLAN must be between 1 and 4094." + fi + NET0+=",tag=${VLAN_TAG}" +fi + +yes_no ADD_DATA_DISK "Allocate a separate Proxmox-managed media volume" no +DATA_STORAGE="" +DATA_SIZE_GB="" +DATA_BACKUP=no +if [[ "$ADD_DATA_DISK" == yes ]]; then + prompt DATA_STORAGE "Media volume storage" "$ROOT_STORAGE" + storage_supports "$DATA_STORAGE" rootdir || die "Storage $DATA_STORAGE is not active or does not support LXC volumes." + prompt DATA_SIZE_GB "Media volume size in GiB" 500 + if [[ ! "$DATA_SIZE_GB" =~ ^[0-9]+$ ]] || ((DATA_SIZE_GB < 20)); then + die "Media volume must be at least 20 GiB." + fi + yes_no DATA_BACKUP "Include the media volume in Proxmox vzdump backups" no +fi + +ENABLE_GPU=no +if [[ -e /dev/dri/renderD128 ]]; then + yes_no ENABLE_GPU "Pass Intel/AMD render device to Jellyfin" yes +fi + +TEMPLATE_STORAGE=$(first_storage_for vztmpl) +[[ -n "$TEMPLATE_STORAGE" ]] || die "No active storage supports vztmpl content." + +printf '\nProvisioning plan:\n' +printf ' Proxmox host: %s\n' "$(hostname)" +printf ' New guest: CT %s (%s), unprivileged Debian 13\n' "$CTID" "$HOSTNAME" +printf ' Resources: %s cores, %s MiB RAM, %s MiB swap\n' "$CORES" "$MEMORY_MB" "$SWAP_MB" +printf ' Root filesystem: %s:%s GiB\n' "$ROOT_STORAGE" "$ROOT_DISK_GB" +printf ' Network: %s via %s%s\n' "$NETWORK_MODE" "$BRIDGE" "${VLAN_TAG:+, VLAN $VLAN_TAG}" +printf ' Required device: /dev/net/tun\n' +[[ "$ENABLE_GPU" == yes ]] && printf ' GPU device: /dev/dri/renderD128\n' +[[ "$ADD_DATA_DISK" == yes ]] && printf ' Media volume: %s:%s GiB → /opt/media-stack/data (vzdump: %s)\n' \ + "$DATA_STORAGE" "$DATA_SIZE_GB" "$DATA_BACKUP" +printf ' Proxmox host: no Docker and no media services will be installed here\n\n' +yes_no CONFIRM "Create this LXC and launch its internal installer" no +[[ "$CONFIRM" == yes ]] || die "Cancelled before making changes." + +info "Refreshing the Proxmox appliance catalog..." +pveam update +TEMPLATE_NAME=$(pveam available --section system | awk '$2 ~ /^debian-13-standard_.*_amd64\.tar\.(zst|gz)$/ {print $2}' | sort -V | tail -n1) +[[ -n "$TEMPLATE_NAME" ]] || die "No Debian 13 amd64 standard template was found in the Proxmox appliance catalog." +TEMPLATE_REF="${TEMPLATE_STORAGE}:vztmpl/${TEMPLATE_NAME}" +if ! pveam list "$TEMPLATE_STORAGE" | awk -v ref="$TEMPLATE_REF" '$1 == ref {found=1} END {exit !found}'; then + info "Downloading $TEMPLATE_NAME to $TEMPLATE_STORAGE..." + pveam download "$TEMPLATE_STORAGE" "$TEMPLATE_NAME" +else + info "Using cached template $TEMPLATE_REF." +fi + +info "Creating unprivileged CT $CTID..." +pct create "$CTID" "$TEMPLATE_REF" \ + --arch amd64 \ + --ostype debian \ + --hostname "$HOSTNAME" \ + --unprivileged 1 \ + --features nesting=1,keyctl=1 \ + --dev0 /dev/net/tun \ + --cores "$CORES" \ + --memory "$MEMORY_MB" \ + --swap "$SWAP_MB" \ + --rootfs "${ROOT_STORAGE}:${ROOT_DISK_GB}" \ + --net0 "$NET0" \ + --onboot 1 \ + --start 0 \ + --timezone host \ + --description "Media Stack LXC managed by ${PROJECT_REPOSITORY}" +CT_CREATED=true + +if [[ "$ADD_DATA_DISK" == yes ]]; then + info "Allocating the media volume..." + if [[ "$DATA_BACKUP" == yes ]]; then + DATA_BACKUP_FLAG=1 + else + DATA_BACKUP_FLAG=0 + fi + pct set "$CTID" --mp0 "${DATA_STORAGE}:${DATA_SIZE_GB},mp=/opt/media-stack/data,backup=${DATA_BACKUP_FLAG}" +fi + +if [[ "$ENABLE_GPU" == yes ]]; then + info "Passing through the render device..." + pct set "$CTID" --dev1 "path=/dev/dri/renderD128,gid=1000,mode=0660" +fi + +info "Starting CT $CTID..." +pct start "$CTID" + +info "Waiting for systemd and IPv4 connectivity inside the LXC..." +READY=false +for ((_attempt = 1; _attempt <= 60; _attempt++)); do + if pct exec "$CTID" -- bash -c ' + state=$(systemctl is-system-running 2>/dev/null || true) + [[ "$state" == running || "$state" == degraded ]] && + ip -4 route show default | grep -q . && + test -c /dev/net/tun + ' 2>/dev/null; then + READY=true + break + fi + sleep 2 +done +$READY || die "CT $CTID did not become network-ready with a usable TUN device within 120 seconds." + +SCRIPT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) +info "Installing the minimal transfer/PTY tools inside CT $CTID..." +pct exec "$CTID" -- bash -c 'apt-get update && apt-get install -y ca-certificates curl util-linux' +if [[ -f "$SCRIPT_DIR/install_media.sh" && -f "$SCRIPT_DIR/templates/compose.yaml" ]]; then + info "Copying this checked-out project snapshot into the LXC..." + tar -czf "$TEMP_DIR/media-stack-source.tar.gz" \ + -C "$SCRIPT_DIR" \ + install_media.sh update_stack.sh sync_transmission_port.sh media_stack.sh templates + pct push "$CTID" "$TEMP_DIR/media-stack-source.tar.gz" /root/media-stack-source.tar.gz --perms 0600 + pct exec "$CTID" -- mkdir -p /root/media-stack-source + pct exec "$CTID" -- tar -xzf /root/media-stack-source.tar.gz -C /root/media-stack-source + INSTALLER_PATH=/root/media-stack-source/install_media.sh +else + info "Downloading one consistent project snapshot inside CT $CTID..." + pct exec "$CTID" -- curl --fail --silent --show-error --location --retry 3 \ + "https://github.com/${PROJECT_REPOSITORY}/archive/main.tar.gz" \ + -o /root/media-stack-source.tar.gz + pct exec "$CTID" -- mkdir -p /root/media-stack-source + pct exec "$CTID" -- tar -xzf /root/media-stack-source.tar.gz \ + --strip-components=1 -C /root/media-stack-source + INSTALLER_PATH=/root/media-stack-source/install_media.sh +fi + +printf '\n%bThe following questions configure services INSIDE CT %s.%b\n' "$GREEN" "$CTID" "$NC" +printf '%bNo Docker command will run on the Proxmox host.%b\n\n' "$GREEN" "$NC" + +set +e +pct exec "$CTID" -- env MEDIA_STACK_PROXMOX_LAUNCH=1 \ + script --quiet --return --command "bash $INSTALLER_PATH --from-proxmox" /dev/null +INSTALL_STATUS=$? +set -e +if ((INSTALL_STATUS != 0)); then + die "The internal installer exited with status $INSTALL_STATUS. CT $CTID is preserved for diagnosis: pct enter $CTID" +fi + +pct set "$CTID" --protection 1 +CT_IP=$(pct exec "$CTID" -- hostname -I 2>/dev/null | awk '{print $1}') +CT_MAC=$(pct config "$CTID" | sed -n 's/^net0:.*hwaddr=\([^,]*\).*/\1/p') +ok "Media Stack is running exclusively inside CT $CTID (${CT_IP:-IP unavailable})." +printf '\nManagement:\n' +[[ "$NETWORK_MODE" != dhcp ]] || printf ' DHCP reservation: reserve MAC %s for CT %s\n' "${CT_MAC:-unavailable}" "$CTID" +printf ' Enter LXC: pct enter %s\n' "$CTID" +printf ' Stack status: pct exec %s -- media-stack status\n' "$CTID" +printf ' Full diagnosis: pct exec %s -- media-stack doctor\n' "$CTID" +printf ' Remove protection before intentionally deleting the CT:\n' +printf ' pct set %s --protection 0\n' "$CTID" diff --git a/sync_transmission_port.sh b/sync_transmission_port.sh index 57a3c23..1aea71b 100644 --- a/sync_transmission_port.sh +++ b/sync_transmission_port.sh @@ -4,22 +4,28 @@ set -Eeuo pipefail umask 077 STACK_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) -ENV_FILE="$STACK_DIR/.env" +STATE_DIR="$STACK_DIR/.update-state" RPC_URL="http://127.0.0.1:9091/transmission/rpc" -[[ -f "$ENV_FILE" ]] || { - echo "Missing $ENV_FILE" >&2 +mkdir -p "$STATE_DIR" +exec 9>"$STATE_DIR/port-sync.lock" +flock -n 9 || exit 0 + +TR_USER_FILE="$STACK_DIR/secrets/transmission_user" +TR_PASS_FILE="$STACK_DIR/secrets/transmission_password" +[[ -s "$TR_USER_FILE" && -s "$TR_PASS_FILE" ]] || { + echo "Missing Transmission credential files in $STACK_DIR/secrets." >&2 exit 1 } -# The installer rejects apostrophes/newlines and writes shell-quoted values. -# shellcheck disable=SC1090 -source "$ENV_FILE" -: "${TR_USER:?Missing TR_USER in .env}" -: "${TR_PASS:?Missing TR_PASS in .env}" +TR_USER=$(<"$TR_USER_FILE") +TR_PASS=$(<"$TR_PASS_FILE") -forwarded_port=$(docker exec gluetun cat /tmp/gluetun/forwarded_port 2>/dev/null || true) +cd "$STACK_DIR" || exit 1 +forwarded_port=$(docker compose exec -T gluetun cat /tmp/gluetun/forwarded_port 2>/dev/null || true) +forwarded_port=${forwarded_port//$'\r'/} +forwarded_port=${forwarded_port//$'\n'/} if [[ ! "$forwarded_port" =~ ^[0-9]+$ ]] || ((forwarded_port < 1 || forwarded_port > 65535)); then - echo "ProtonVPN has not assigned a valid forwarded port yet; retrying on the next timer run." + echo "ProtonVPN has not assigned a valid forwarded port yet; the timer will retry." exit 0 fi @@ -28,11 +34,19 @@ trap 'rm -rf -- "$temp_dir"' EXIT headers="$temp_dir/headers" response="$temp_dir/response.json" -curl -sS --max-time 10 \ +# Transmission deliberately answers the first unauthenticated-session request +# with HTTP 409 and returns the session token in a response header. +http_code=$(curl --silent --show-error --max-time 10 \ -u "$TR_USER:$TR_PASS" \ -D "$headers" \ -o /dev/null \ - -X POST "$RPC_URL" + -X POST \ + -w '%{http_code}' \ + "$RPC_URL") +[[ "$http_code" == 409 || "$http_code" == 200 ]] || { + echo "Transmission RPC returned HTTP $http_code while requesting a session token." >&2 + exit 1 +} session_id=$(awk -F ':[[:space:]]*' ' tolower($1) == "x-transmission-session-id" { @@ -45,24 +59,30 @@ session_id=$(awk -F ':[[:space:]]*' ' exit 1 } +rpc() { + local payload=$1 + curl --fail --silent --show-error --max-time 10 \ + -u "$TR_USER:$TR_PASS" \ + -H "X-Transmission-Session-Id: $session_id" \ + -H "Content-Type: application/json" \ + --data "$payload" \ + "$RPC_URL" > "$response" + jq -e '.result == "success"' "$response" >/dev/null +} + +rpc '{"method":"session-get","arguments":{"fields":["peer-port"]}}' +current_port=$(jq -r '.arguments["peer-port"] // empty' "$response") +if [[ "$current_port" == "$forwarded_port" ]]; then + echo "Transmission peer port is already synchronized to $forwarded_port." + exit 0 +fi + payload=$(jq -cn --argjson port "$forwarded_port" '{ method: "session-set", arguments: {"peer-port": $port, "peer-port-random-on-start": false} }') -curl -fsS --max-time 10 \ - -u "$TR_USER:$TR_PASS" \ - -H "X-Transmission-Session-Id: $session_id" \ - -H "Content-Type: application/json" \ - --data "$payload" \ - "$RPC_URL" > "$response" -jq -e '.result == "success"' "$response" >/dev/null - -curl -fsS --max-time 10 \ - -u "$TR_USER:$TR_PASS" \ - -H "X-Transmission-Session-Id: $session_id" \ - -H "Content-Type: application/json" \ - --data '{"method":"session-get","arguments":{"fields":["peer-port"]}}' \ - "$RPC_URL" > "$response" -jq -e --argjson port "$forwarded_port" '.result == "success" and .arguments["peer-port"] == $port' "$response" >/dev/null +rpc "$payload" +rpc '{"method":"session-get","arguments":{"fields":["peer-port"]}}' +jq -e --argjson port "$forwarded_port" '.arguments["peer-port"] == $port' "$response" >/dev/null -echo "Transmission peer port synchronized to $forwarded_port." +echo "Transmission peer port synchronized from ${current_port:-unknown} to $forwarded_port." diff --git a/templates/compose.gpu.yaml b/templates/compose.gpu.yaml new file mode 100644 index 0000000..f8c0c1f --- /dev/null +++ b/templates/compose.gpu.yaml @@ -0,0 +1,6 @@ +services: + jellyfin: + devices: + - /dev/dri/renderD128:/dev/dri/renderD128 + group_add: + - ${RENDER_GID:?RENDER_GID is required when GPU support is enabled} diff --git a/templates/compose.openvpn.yaml b/templates/compose.openvpn.yaml new file mode 100644 index 0000000..bd605a6 --- /dev/null +++ b/templates/compose.openvpn.yaml @@ -0,0 +1,15 @@ +secrets: + proton_openvpn_user: + file: ./secrets/proton_openvpn_user + proton_openvpn_password: + file: ./secrets/proton_openvpn_password + +services: + gluetun: + environment: + VPN_TYPE: openvpn + OPENVPN_USER_SECRETFILE: /run/secrets/proton_openvpn_user + OPENVPN_PASSWORD_SECRETFILE: /run/secrets/proton_openvpn_password + secrets: + - proton_openvpn_user + - proton_openvpn_password diff --git a/templates/compose.wireguard.yaml b/templates/compose.wireguard.yaml new file mode 100644 index 0000000..53888e4 --- /dev/null +++ b/templates/compose.wireguard.yaml @@ -0,0 +1,11 @@ +secrets: + proton_wireguard_private_key: + file: ./secrets/proton_wireguard_private_key + +services: + gluetun: + environment: + VPN_TYPE: wireguard + WIREGUARD_PRIVATE_KEY_SECRETFILE: /run/secrets/proton_wireguard_private_key + secrets: + - proton_wireguard_private_key diff --git a/templates/compose.yaml b/templates/compose.yaml new file mode 100644 index 0000000..8660b38 --- /dev/null +++ b/templates/compose.yaml @@ -0,0 +1,342 @@ +name: media-stack + +x-logging: &default-logging + driver: json-file + options: + max-size: 10m + max-file: "3" + +x-linuxserver: &linuxserver + restart: unless-stopped + security_opt: + - no-new-privileges:true + logging: *default-logging + +networks: + media: + driver: bridge + socket-proxy: + driver: bridge + internal: true + +secrets: + transmission_user: + file: ./secrets/transmission_user + transmission_password: + file: ./secrets/transmission_password + +services: + gluetun: + image: qmcgaw/gluetun:v3 + restart: unless-stopped + cap_add: + - NET_ADMIN + devices: + - /dev/net/tun:/dev/net/tun + environment: + VPN_SERVICE_PROVIDER: protonvpn + PORT_FORWARD_ONLY: "on" + VPN_PORT_FORWARDING: "on" + VPN_PORT_FORWARDING_PROVIDER: protonvpn + VPN_PORT_FORWARDING_STATUS_FILE: /tmp/gluetun/forwarded_port + FIREWALL_INPUT_PORTS: "9091" + UPDATER_PERIOD: 480h + TZ: ${TZ:?TZ is required} + volumes: + - ./config/gluetun:/gluetun + ports: + - target: 9091 + published: "9091" + host_ip: 127.0.0.1 + protocol: tcp + - target: 9091 + published: "9091" + host_ip: ${LAN_IP:?LAN_IP is required} + protocol: tcp + networks: + - media + security_opt: + - no-new-privileges:true + logging: *default-logging + + transmission: + <<: *linuxserver + image: lscr.io/linuxserver/transmission:latest + network_mode: service:gluetun + depends_on: + gluetun: + condition: service_healthy + environment: + PUID: ${PUID:?PUID is required} + PGID: ${PGID:?PGID is required} + TZ: ${TZ:?TZ is required} + UMASK: "002" + FILE__USER: /run/secrets/transmission_user + FILE__PASS: /run/secrets/transmission_password + WHITELIST: "" + HOST_WHITELIST: "" + secrets: + - transmission_user + - transmission_password + volumes: + - ./config/transmission:/config + - ./data:/data + healthcheck: + test: + - CMD-SHELL + - >- + curl -fsS --max-time 5 + -u "$$(cat /run/secrets/transmission_user):$$(cat /run/secrets/transmission_password)" + http://127.0.0.1:9091/transmission/web/ >/dev/null + start_period: 30s + interval: 20s + timeout: 6s + retries: 5 + + flaresolverr: + image: ghcr.io/flaresolverr/flaresolverr:latest + profiles: + - flaresolverr + restart: unless-stopped + environment: + TZ: ${TZ:?TZ is required} + LOG_LEVEL: info + networks: + - media + security_opt: + - no-new-privileges:true + logging: *default-logging + + prowlarr: + <<: *linuxserver + image: lscr.io/linuxserver/prowlarr:latest + environment: + PUID: ${PUID:?PUID is required} + PGID: ${PGID:?PGID is required} + TZ: ${TZ:?TZ is required} + UMASK: "002" + volumes: + - ./config/prowlarr:/config + networks: + - media + ports: + - target: 9696 + published: "9696" + host_ip: 127.0.0.1 + - target: 9696 + published: "9696" + host_ip: ${LAN_IP:?LAN_IP is required} + healthcheck: + test: [CMD-SHELL, "curl -fsS --max-time 5 http://127.0.0.1:9696/ping >/dev/null || exit 1"] + start_period: 30s + interval: 20s + timeout: 6s + retries: 5 + + sonarr: + <<: *linuxserver + image: lscr.io/linuxserver/sonarr:latest + environment: + PUID: ${PUID:?PUID is required} + PGID: ${PGID:?PGID is required} + TZ: ${TZ:?TZ is required} + UMASK: "002" + volumes: + - ./config/sonarr:/config + - ./data:/data + networks: + - media + ports: + - target: 8989 + published: "8989" + host_ip: 127.0.0.1 + - target: 8989 + published: "8989" + host_ip: ${LAN_IP:?LAN_IP is required} + healthcheck: + test: [CMD-SHELL, "curl -fsS --max-time 5 http://127.0.0.1:8989/ping >/dev/null || exit 1"] + start_period: 30s + interval: 20s + timeout: 6s + retries: 5 + + radarr: + <<: *linuxserver + image: lscr.io/linuxserver/radarr:latest + environment: + PUID: ${PUID:?PUID is required} + PGID: ${PGID:?PGID is required} + TZ: ${TZ:?TZ is required} + UMASK: "002" + volumes: + - ./config/radarr:/config + - ./data:/data + networks: + - media + ports: + - target: 7878 + published: "7878" + host_ip: 127.0.0.1 + - target: 7878 + published: "7878" + host_ip: ${LAN_IP:?LAN_IP is required} + healthcheck: + test: [CMD-SHELL, "curl -fsS --max-time 5 http://127.0.0.1:7878/ping >/dev/null || exit 1"] + start_period: 30s + interval: 20s + timeout: 6s + retries: 5 + + bazarr: + <<: *linuxserver + image: lscr.io/linuxserver/bazarr:latest + environment: + PUID: ${PUID:?PUID is required} + PGID: ${PGID:?PGID is required} + TZ: ${TZ:?TZ is required} + UMASK: "002" + volumes: + - ./config/bazarr:/config + - ./data:/data + networks: + - media + ports: + - target: 6767 + published: "6767" + host_ip: 127.0.0.1 + - target: 6767 + published: "6767" + host_ip: ${LAN_IP:?LAN_IP is required} + healthcheck: + test: [CMD-SHELL, "curl -fsS --max-time 5 http://127.0.0.1:6767/ >/dev/null || exit 1"] + start_period: 45s + interval: 20s + timeout: 6s + retries: 5 + + jellyfin: + <<: *linuxserver + image: lscr.io/linuxserver/jellyfin:latest + environment: + PUID: ${PUID:?PUID is required} + PGID: ${PGID:?PGID is required} + TZ: ${TZ:?TZ is required} + UMASK: "002" + volumes: + - ./config/jellyfin:/config + - ./data:/data + networks: + - media + ports: + - target: 8096 + published: "8096" + host_ip: 127.0.0.1 + - target: 8096 + published: "8096" + host_ip: ${LAN_IP:?LAN_IP is required} + labels: + pangolin.public-resources.jellyfin.name: Jellyfin + pangolin.public-resources.jellyfin.full-domain: jellyfin.${PUBLIC_DOMAIN:?PUBLIC_DOMAIN is required} + pangolin.public-resources.jellyfin.mode: http + pangolin.public-resources.jellyfin.targets[0].method: http + pangolin.public-resources.jellyfin.targets[0].hostname: jellyfin + pangolin.public-resources.jellyfin.targets[0].port: "8096" + healthcheck: + test: [CMD-SHELL, "curl -fsS --max-time 5 http://127.0.0.1:8096/System/Info/Public >/dev/null || exit 1"] + start_period: 45s + interval: 20s + timeout: 6s + retries: 5 + + seerr: + image: ghcr.io/seerr-team/seerr:v3 + init: true + restart: unless-stopped + environment: + TZ: ${TZ:?TZ is required} + PORT: "5055" + volumes: + - ./config/seerr:/app/config + networks: + - media + ports: + - target: 5055 + published: "5055" + host_ip: 127.0.0.1 + - target: 5055 + published: "5055" + host_ip: ${LAN_IP:?LAN_IP is required} + labels: + pangolin.public-resources.seerr.name: Seerr + pangolin.public-resources.seerr.full-domain: seerr.${PUBLIC_DOMAIN:?PUBLIC_DOMAIN is required} + pangolin.public-resources.seerr.mode: http + pangolin.public-resources.seerr.auth.sso-enabled: "true" + pangolin.public-resources.seerr.targets[0].method: http + pangolin.public-resources.seerr.targets[0].hostname: seerr + pangolin.public-resources.seerr.targets[0].port: "5055" + healthcheck: + test: [CMD-SHELL, "wget -q --spider http://127.0.0.1:5055/api/v1/settings/public || exit 1"] + start_period: 30s + interval: 20s + timeout: 6s + retries: 5 + read_only: true + tmpfs: + - /tmp:size=128m,mode=1777 + security_opt: + - no-new-privileges:true + logging: *default-logging + + socket-proxy: + image: lscr.io/linuxserver/socket-proxy:latest + profiles: + - pangolin + restart: unless-stopped + environment: + CONTAINERS: "1" + EVENTS: "1" + INFO: "1" + NETWORKS: "1" + PING: "1" + VERSION: "1" + POST: "0" + ALLOW_RESTARTS: "0" + volumes: + - /var/run/docker.sock:/var/run/docker.sock:ro + networks: + - socket-proxy + read_only: true + tmpfs: + - /run:size=16m,mode=0755 + security_opt: + - no-new-privileges:true + logging: *default-logging + + newt: + image: fosrl/newt:latest + profiles: + - pangolin + restart: unless-stopped + depends_on: + - socket-proxy + environment: + CONFIG_FILE: /config/config.json + DOCKER_SOCKET: tcp://socket-proxy:2375 + DOCKER_ENFORCE_NETWORK_VALIDATION: "true" + HEALTH_FILE: /tmp/healthy + volumes: + - ./config/newt:/config + networks: + - media + - socket-proxy + tmpfs: + - /tmp:size=16m,mode=1777 + healthcheck: + test: [CMD-SHELL, "test -f /tmp/healthy"] + start_period: 30s + interval: 20s + timeout: 3s + retries: 3 + security_opt: + - no-new-privileges:true + logging: *default-logging diff --git a/tests/validate.sh b/tests/validate.sh new file mode 100644 index 0000000..418da18 --- /dev/null +++ b/tests/validate.sh @@ -0,0 +1,119 @@ +#!/usr/bin/env bash + +set -Eeuo pipefail + +REPOSITORY_ROOT=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd) +cd "$REPOSITORY_ROOT" || exit 1 + +SCRIPTS=( + proxmox_lxc.sh + install_media.sh + media_stack.sh + update_stack.sh + sync_transmission_port.sh +) +bash -n "${SCRIPTS[@]}" +bash media_stack.sh help >/dev/null +[[ "$(bash media_stack.sh version)" == "media-stack 4.0.0" ]] + +temp_dir=$(mktemp -d) +trap 'rm -rf -- "$temp_dir"' EXIT +cp templates/*.yaml "$temp_dir/" +mkdir -p "$temp_dir/secrets" +for secret in transmission_user transmission_password proton_openvpn_user proton_openvpn_password proton_wireguard_private_key; do + printf 'test-value' > "$temp_dir/secrets/$secret" +done + +cat > "$temp_dir/.env" <<'EOF' +PUID='1000' +PGID='1000' +TZ='Europe/Warsaw' +LAN_IP='192.0.2.10' +PUBLIC_DOMAIN='example.com' +RENDER_GID='104' +COMPOSE_PROFILES='pangolin,flaresolverr' +EOF + +validate_variant() { + local vpn gpu output + local -a files + vpn=$1 + gpu=${2:-no} + output="$temp_dir/${vpn}-${gpu}.json" + files=(-f compose.yaml -f "compose.${vpn}.yaml") + [[ "$gpu" == yes ]] && files+=(-f compose.gpu.yaml) + ( + cd "$temp_dir" || exit 1 + docker compose "${files[@]}" config --quiet + docker compose "${files[@]}" config --format json > "$output" + ) + jq -e . "$output" >/dev/null +} + +validate_variant openvpn yes +validate_variant wireguard no + +model="$temp_dir/openvpn-yes.json" +jq -e ' + .services.transmission.network_mode == "service:gluetun" and + .services.gluetun.cap_add == ["NET_ADMIN"] and + .services["socket-proxy"].environment.POST == "0" and + .services["socket-proxy"].read_only == true and + .services.newt.environment.DOCKER_ENFORCE_NETWORK_VALIDATION == "true" and + .services.jellyfin.labels["pangolin.public-resources.jellyfin.mode"] == "http" and + .services.seerr.labels["pangolin.public-resources.seerr.mode"] == "http" and + .services.newt.healthcheck.test[1] == "test -f /tmp/healthy" +' "$model" >/dev/null + +wireguard_model="$temp_dir/wireguard-no.json" +jq -e ' + .services.gluetun.environment.WIREGUARD_PRIVATE_KEY_SECRETFILE == "/run/secrets/proton_wireguard_private_key" and + (.services.gluetun.environment | has("WIREGUARD_PRIVATE_KEY") | not) +' "$wireguard_model" >/dev/null + +jq -e ' + (.services.newt.environment | has("NEWT_ID") | not) and + (.services.newt.environment | has("NEWT_SECRET") | not) +' "$model" >/dev/null + +# Administrative services must never declare a Pangolin public resource. +for service in transmission radarr sonarr prowlarr bazarr flaresolverr; do + if jq -e --arg service "$service" ' + .services[$service].labels // {} | + keys[]? | + startswith("pangolin.public-resources.") + ' "$model" >/dev/null; then + echo "$service unexpectedly declares a public Pangolin resource" >&2 + exit 1 + fi +done + +# VPN and Transmission credentials must be file-backed, not interpolated values. +jq -e ' + .services.gluetun.environment.OPENVPN_USER_SECRETFILE == "/run/secrets/proton_openvpn_user" and + .services.gluetun.environment.OPENVPN_PASSWORD_SECRETFILE == "/run/secrets/proton_openvpn_password" and + (.services.gluetun.environment | has("OPENVPN_USER") | not) and + (.services.gluetun.environment | has("OPENVPN_PASSWORD") | not) and + .services.transmission.environment.FILE__PASS == "/run/secrets/transmission_password" and + (.services.transmission.environment | has("PASS") | not) +' "$model" >/dev/null + +# The host provisioner must invoke the LXC installer through pct, never locally. +grep -Fq 'pct exec "$CTID" -- env MEDIA_STACK_PROXMOX_LAUNCH=1 \' proxmox_lxc.sh +grep -Fq 'script --quiet --return --command "bash $INSTALLER_PATH --from-proxmox" /dev/null' proxmox_lxc.sh +grep -Fq 'This installer runs only inside an LXC' install_media.sh +if grep -Eq '^[[:space:]]*(sudo[[:space:]]+)?bash[[:space:]]+"?\$INSTALLER_PATH"?[[:space:]]+--from-proxmox' proxmox_lxc.sh; then + echo "proxmox_lxc.sh contains a local installer invocation" >&2 + exit 1 +fi +if grep -Eq '^[[:space:]]*(sudo[[:space:]]+)?docker([[:space:]]|$)' proxmox_lxc.sh; then + echo "proxmox_lxc.sh contains a Docker invocation on the Proxmox host" >&2 + exit 1 +fi +if grep -Eq '^[[:space:]]*(sudo[[:space:]]+)?(apt|apt-get|systemctl)([[:space:]]|$)' proxmox_lxc.sh; then + echo "proxmox_lxc.sh contains an OS/service installation command on the Proxmox host" >&2 + exit 1 +fi + +git diff --check +echo "All static validation checks passed." diff --git a/update_stack.sh b/update_stack.sh index c6c66cd..096690c 100644 --- a/update_stack.sh +++ b/update_stack.sh @@ -8,32 +8,61 @@ STATE_DIR="$STACK_DIR/.update-state" BACKUP_DIR="$STACK_DIR/backups" ENV_FILE="$STACK_DIR/.env" STABILITY_SECONDS=60 -HEALTH_TIMEOUT_SECONDS=300 +HEALTH_TIMEOUT_SECONDS=420 mkdir -p "$STATE_DIR" "$BACKUP_DIR" exec 9>"$STATE_DIR/update.lock" flock -n 9 || exit 0 -cd "$STACK_DIR" +cd "$STACK_DIR" || exit 1 docker compose config --quiet -UPDATE_DELAY_DAYS=7 -OFFSITE_BACKUP_DIR="" -TR_USER="" -TR_PASS="" -if [[ -f "$ENV_FILE" ]]; then - # The installer rejects apostrophes/newlines and writes shell-quoted values. - # shellcheck disable=SC1090 - source "$ENV_FILE" -fi +read_env() { + local key=$1 line value + line=$(awk -v key="$key" 'index($0, key "=") == 1 {print; exit}' "$ENV_FILE") + [[ -n "$line" ]] || return 0 + value=${line#*=} + if [[ "$value" == "'"*"'" && ${#value} -ge 2 ]]; then + value=${value:1:${#value}-2} + elif [[ "$value" == '"'*'"' && ${#value} -ge 2 ]]; then + value=${value:1:${#value}-2} + fi + printf '%s' "$value" +} + +UPDATE_DELAY_DAYS=$(read_env UPDATE_DELAY_DAYS) +UPDATE_DELAY_DAYS=${UPDATE_DELAY_DAYS:-7} +OFFSITE_BACKUP_DIR=$(read_env OFFSITE_BACKUP_DIR) +OFFSITE_BACKUP_SOURCE=$(read_env OFFSITE_BACKUP_SOURCE) +OFFSITE_BACKUP_MOUNTPOINT=$(read_env OFFSITE_BACKUP_MOUNTPOINT) [[ "$UPDATE_DELAY_DAYS" =~ ^[0-9]+$ ]] || { echo "UPDATE_DELAY_DAYS must be a non-negative integer." >&2 exit 1 } -if [[ -n "$OFFSITE_BACKUP_DIR" && (! -d "$OFFSITE_BACKUP_DIR" || ! -w "$OFFSITE_BACKUP_DIR") ]]; then - echo "External backup directory is unavailable or not writable: $OFFSITE_BACKUP_DIR" >&2 + +validate_offsite_mount() { + local current_source current_target + [[ -n "$OFFSITE_BACKUP_DIR" ]] || return 0 + [[ -d "$OFFSITE_BACKUP_DIR" && -w "$OFFSITE_BACKUP_DIR" ]] || { + echo "External backup directory is unavailable or not writable: $OFFSITE_BACKUP_DIR" >&2 + return 1 + } + read -r current_source current_target < <(findmnt -T "$OFFSITE_BACKUP_DIR" -n -o SOURCE,TARGET --first) + [[ "$current_source" == "$OFFSITE_BACKUP_SOURCE" && "$current_target" == "$OFFSITE_BACKUP_MOUNTPOINT" ]] || { + echo "External backup mount identity changed: expected $OFFSITE_BACKUP_SOURCE on $OFFSITE_BACKUP_MOUNTPOINT." >&2 + return 1 + } +} +validate_offsite_mount + +TR_USER_FILE="$STACK_DIR/secrets/transmission_user" +TR_PASS_FILE="$STACK_DIR/secrets/transmission_password" +[[ -s "$TR_USER_FILE" && -s "$TR_PASS_FILE" ]] || { + echo "Transmission credential files are missing." >&2 exit 1 -fi +} +TR_USER=$(<"$TR_USER_FILE") +TR_PASS=$(<"$TR_PASS_FILE") DELAY_SECONDS=$((UPDATE_DELAY_DAYS * 86400)) NOW=$(date +%s) @@ -52,18 +81,40 @@ declare -A GROUP_SERVICES=( ) mapfile -t SERVICES < <(docker compose config --services) -declare -A RUNNING_IMAGE IMAGE_REF CANDIDATE_IMAGE CANDIDATE_MATURE SELECTED +declare -A SERVICE_EXISTS RUNNING_IMAGE IMAGE_REF CANDIDATE_IMAGE CANDIDATE_MATURE +for service in "${SERVICES[@]}"; do SERVICE_EXISTS[$service]=true; done for service in "${SERVICES[@]}"; do container_id=$(docker compose ps -q "$service") [[ -n "$container_id" ]] || { - echo "Service $service is not running; start the complete stack before updating." >&2 + echo "Service $service is not running; start the complete active stack before updating." >&2 exit 1 } RUNNING_IMAGE[$service]=$(docker inspect --format '{{.Image}}' "$container_id") IMAGE_REF[$service]=$(docker inspect --format '{{.Config.Image}}' "$container_id") done +restore_running_tags() { + local service failed=0 + for service in "${SERVICES[@]}"; do + docker image tag "${RUNNING_IMAGE[$service]}" "${IMAGE_REF[$service]}" || failed=1 + done + return "$failed" +} + +abort_before_deployment() { + local status=${1:-1} + trap - ERR INT TERM + set +e + restore_running_tags + echo "Update check was interrupted; image tags were restored to the running versions." >&2 + exit "$status" +} + +trap 'abort_before_deployment $?' ERR +trap 'abort_before_deployment 130' INT TERM + +# Pulling changes local tag pointers but does not modify running containers. docker compose pull for service in "${SERVICES[@]}"; do @@ -84,7 +135,9 @@ for service in "${SERVICES[@]}"; do fi if [[ "$previous_image" != "$local_image" || ! "$first_seen" =~ ^[0-9]+$ ]]; then first_seen=$NOW - printf '%s %s\n' "$local_image" "$first_seen" > "$state_file" + temp_state=$(mktemp "$STATE_DIR/.candidate.XXXXXX") + printf '%s %s\n' "$local_image" "$first_seen" > "$temp_state" + mv "$temp_state" "$state_file" fi if ((NOW - first_seen >= DELAY_SECONDS)); then CANDIDATE_MATURE[$service]=true @@ -93,12 +146,18 @@ for service in "${SERVICES[@]}"; do fi done +# A pulled tag must never remain pointed at an immature candidate: an unrelated +# manual `docker compose up` would otherwise bypass the maturation delay. +restore_running_tags +trap - ERR INT TERM + SELECTED_SERVICES=() for group in "${UPDATE_GROUPS[@]}"; do has_candidate=false group_mature=true read -r -a group_services <<< "${GROUP_SERVICES[$group]}" for service in "${group_services[@]}"; do + [[ "${SERVICE_EXISTS[$service]:-false}" == true ]] || continue if [[ -n "${CANDIDATE_IMAGE[$service]:-}" ]]; then has_candidate=true [[ "${CANDIDATE_MATURE[$service]}" == true ]] || group_mature=false @@ -106,7 +165,7 @@ for group in "${UPDATE_GROUPS[@]}"; do done if $has_candidate && $group_mature; then for service in "${group_services[@]}"; do - SELECTED[$service]=true + [[ "${SERVICE_EXISTS[$service]:-false}" == true ]] || continue SELECTED_SERVICES+=("$service") done fi @@ -116,6 +175,7 @@ done timestamp=$(date +%Y%m%d-%H%M%S) backup="$BACKUP_DIR/media-stack-$timestamp.tar.gz" +partial_backup="$BACKUP_DIR/.media-stack-$timestamp.tar.gz.partial" rollback_file="$STATE_DIR/rollback-$timestamp.tsv" for service in "${SERVICES[@]}"; do @@ -138,7 +198,7 @@ prune_artifacts() { rm -f -- "${backups[@]:5}" fi - if [[ -n "$OFFSITE_BACKUP_DIR" ]]; then + if [[ -n "$OFFSITE_BACKUP_DIR" ]] && validate_offsite_mount; then mapfile -t offsite_backups < <(find "$OFFSITE_BACKUP_DIR" -maxdepth 1 -type f -name 'media-stack-*.tar.gz' -printf '%T@ %p\n' | sort -nr | cut -d' ' -f2-) if ((${#offsite_backups[@]} > 10)); then rm -f -- "${offsite_backups[@]:10}" @@ -147,49 +207,60 @@ prune_artifacts() { } rollback() { - trap - ERR + local status=${1:-1} + trap - ERR INT TERM set +e - echo "Update failed; restoring $backup" >&2 - docker compose stop + echo "Update failed; restoring the previous images and configuration." >&2 + docker compose stop --timeout 60 if [[ -s "$backup" ]] && tar -tzf "$backup" >/dev/null 2>&1; then if [[ -d config ]]; then mv config "config.failed-$timestamp" fi - tar -xzf "$backup" + tar -xzf "$backup" -C "$STACK_DIR" + elif [[ -e "$partial_backup" ]]; then + rm -f "$partial_backup" + echo "The candidate was not started, so the existing configuration is being preserved." >&2 else - echo "Backup archive is incomplete; preserving the existing configuration." >&2 + echo "No valid backup archive exists; preserving the current configuration." >&2 fi while IFS=$'\t' read -r _service image_ref old_image; do docker image tag "$old_image" "$image_ref" done < "$rollback_file" - docker compose up -d --force-recreate + docker compose up -d --remove-orphans --force-recreate for service in "${SELECTED_SERVICES[@]}"; do if [[ -n "${CANDIDATE_IMAGE[$service]:-}" ]]; then printf '%s %s\n' "${CANDIDATE_IMAGE[$service]}" "$(date +%s)" > "$STATE_DIR/${service}.candidate" fi done prune_artifacts - exit 1 + exit "$status" } trap rollback ERR +trap 'rollback 130' INT TERM -docker compose stop -backup_items=(config .env docker-compose.yml important_info.md update_stack.sh) -[[ -f sync_transmission_port.sh ]] && backup_items+=(sync_transmission_port.sh) -tar -czf "$backup" "${backup_items[@]}" +docker compose stop --timeout 60 +backup_items=(config secrets .env compose.yaml compose.openvpn.yaml compose.wireguard.yaml compose.gpu.yaml important_info.md update_stack.sh sync_transmission_port.sh media_stack.sh) +existing_backup_items=() +for item in "${backup_items[@]}"; do + [[ -e "$item" ]] && existing_backup_items+=("$item") +done +tar -czf "$partial_backup" "${existing_backup_items[@]}" +tar -tzf "$partial_backup" >/dev/null +mv "$partial_backup" "$backup" if [[ -n "$OFFSITE_BACKUP_DIR" ]]; then + validate_offsite_mount cp -a "$backup" "$OFFSITE_BACKUP_DIR/" fi -# Pull updates all tags. Restore old tags for groups that are not being deployed now. -for service in "${SERVICES[@]}"; do - if [[ "${SELECTED[$service]:-false}" != true ]]; then - docker image tag "${RUNNING_IMAGE[$service]}" "${IMAGE_REF[$service]}" +# Point only mature, selected references at their captured candidate IDs. +for service in "${SELECTED_SERVICES[@]}"; do + if [[ -n "${CANDIDATE_IMAGE[$service]:-}" ]]; then + docker image tag "${CANDIDATE_IMAGE[$service]}" "${IMAGE_REF[$service]}" fi done -docker compose start docker compose up -d --force-recreate "${SELECTED_SERVICES[@]}" +docker compose start declare -A LAST_RESTARTS for service in "${SERVICES[@]}"; do @@ -199,13 +270,13 @@ done http_probe() { case "$1" in - jellyfin) curl -fsSL --max-time 5 http://127.0.0.1:8096/System/Info/Public >/dev/null ;; - seerr) curl -fsSL --max-time 5 http://127.0.0.1:5055/api/v1/settings/public >/dev/null ;; - transmission) curl -fsSL --max-time 5 -u "$TR_USER:$TR_PASS" http://127.0.0.1:9091/transmission/web/ >/dev/null ;; - radarr) curl -fsSL --max-time 5 http://127.0.0.1:7878/ >/dev/null ;; - sonarr) curl -fsSL --max-time 5 http://127.0.0.1:8989/ >/dev/null ;; - prowlarr) curl -fsSL --max-time 5 http://127.0.0.1:9696/ >/dev/null ;; - bazarr) curl -fsSL --max-time 5 http://127.0.0.1:6767/ >/dev/null ;; + jellyfin) curl -fsS --max-time 5 http://127.0.0.1:8096/System/Info/Public >/dev/null ;; + seerr) curl -fsS --max-time 5 http://127.0.0.1:5055/api/v1/settings/public >/dev/null ;; + transmission) curl -fsS --max-time 5 -u "$TR_USER:$TR_PASS" http://127.0.0.1:9091/transmission/web/ >/dev/null ;; + radarr) curl -fsS --max-time 5 http://127.0.0.1:7878/ping >/dev/null ;; + sonarr) curl -fsS --max-time 5 http://127.0.0.1:8989/ping >/dev/null ;; + prowlarr) curl -fsS --max-time 5 http://127.0.0.1:9696/ping >/dev/null ;; + bazarr) curl -fsS --max-time 5 http://127.0.0.1:6767/ >/dev/null ;; esac } @@ -234,7 +305,10 @@ while (($(date +%s) < deadline)); do healthy=false fi done - if ! docker exec gluetun wget -qO- http://127.0.0.1:8000/v1/vpn/status | jq -e '.status == "running"' >/dev/null; then + + forwarded_port=$(docker compose exec -T gluetun cat /tmp/gluetun/forwarded_port 2>/dev/null || true) + forwarded_port=${forwarded_port//$'\n'/} + if [[ ! "$forwarded_port" =~ ^[0-9]+$ ]] || ((forwarded_port < 1 || forwarded_port > 65535)); then healthy=false fi @@ -253,7 +327,7 @@ done false } -trap - ERR +trap - ERR INT TERM for service in "${SELECTED_SERVICES[@]}"; do rm -f "$STATE_DIR/${service}.candidate" done