Merge pull request 'Merge dev in testing: Fix: Paketinstallation blockiert nicht mehr synchron auf smart-mount-mount.service' (#7) from dev into testing

Reviewed-on: #7

Cargo.lock

@@ -2052,7 +2052,7 @@ checksum = "ba467056f1b547ed52077911161fc86985becbc60e8e1857c8a144dab0def891"
 
 [[package]]
 name = "smart-mount"
-version = "2.0.1"
+version = "2.0.4"
 dependencies = [
  "aes-gcm 0.11.1",
  "anyhow",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "smart-mount"
-version = "2.0.1"
+version = "2.0.4"
 edition = "2024"
 authors = ['DragonSlayer_14']
 readme = "README.md"
@@ -110,7 +110,13 @@ suggests = { "davfs2" = "*", "cifs-utils" = "*", "nfs-utils" = "*" }
 post_install_script = """
 if command -v systemctl >/dev/null 2>&1; then
     systemctl daemon-reload || true
-    systemctl enable --now smart-mount-mount.service smart-mount-watch.timer || true
+    # smart-mount-mount.service mountet echte Netzlaufwerke (kann bei nicht erreichbaren
+    # Servern pro Paar mehrere zehn Sekunden dauern) - "enable --now" wuerde synchron darauf
+    # warten und damit die Paketinstallation blockieren, daher aktivieren + nur als
+    # asynchroner Job starten ("--no-block", kehrt sofort zurueck).
+    systemctl enable smart-mount-mount.service || true
+    systemctl start --no-block smart-mount-mount.service || true
+    systemctl enable --now smart-mount-watch.timer || true
 fi
 /usr/lib/smart-mount/setup-cron || true
 """

README.md

@@ -145,13 +145,19 @@ System-systemd-Dienst ein - kein manueller Schritt nötig. Die dafür paketierte
   `smart-mount watch` aufruft (Standardintervall: 120s).
 
 Die postinst/postrm-Skripte des Pakets (bzw. das `.INSTALL`-Skriptlet bei Arch) aktivieren und
-starten beide Units beim Installieren/Upgraden (`systemctl enable --now ...`) und deaktivieren
+deaktivieren beide Units beim Installieren/Deinstallieren - siehe `packaging/deb/postinst` +
-sie wieder beim Deinstallieren (`systemctl disable --now ...`) - siehe `packaging/deb/postinst`
+`packaging/deb/postrm` bzw. `[package.metadata.generate-rpm]`/`scripts/package-arch.py` in
-+ `packaging/deb/postrm` bzw. `[package.metadata.generate-rpm]`/`scripts/package-arch.py` in
 `Cargo.toml`. Welche Laufwerkspaare dabei gemountet werden (und für welchen Nutzer, siehe
 `owner_user` unten) steuert ausschließlich `/etc/smart-mount/config.toml` - nicht die
 Unit-Dateien selbst.
 
+`smart-mount-mount.service` mountet dabei echte Netzlaufwerke, was bei einem gerade nicht
+erreichbaren Server pro Paar mehrere zehn Sekunden dauern kann (begrenzt auf max. 10 Minuten
+insgesamt, siehe `TimeoutStartSec` in der Unit) - das Paket-Setup wird dadurch **nicht**
+blockiert: `systemctl start --no-block` stößt den ersten Mount-Versuch beim Installieren nur an,
+statt synchron auf ihn zu warten. `smart-mount-watch.timer` wird dagegen sofort synchron
+gestartet (das Timer-"Armen" selbst ist immer augenblicklich fertig).
+
 **Anderes Watch-Intervall als der Standard (120s):** `settings.watch_interval_secs` in
 `config.toml` steuert nur den Cron-Fallback (s. u.) - der paketierte Timer hat ein fest
 eingebautes Intervall. Zum Anpassen:
@@ -162,6 +168,15 @@ sudo systemctl edit smart-mount-watch.timer
 # OnUnitActiveSec=60s
 ```
 
+**Logs:** beide Units schreiben mit festem `SyslogIdentifier=smart-mount` ins systemd-Journal -
+`journalctl -u smart-mount-mount` / `-u smart-mount-watch` (oder gebündelt `journalctl -t
+smart-mount`) zeigt sie an. Zusätzlich schreibt smart-mount dieselben Meldungen dauerhaft nach
+`/var/log/smart-mount/log-<Datum>.log` (siehe `settings.log_level` für die Ausführlichkeit,
+Standard `info`) - unabhängig von der Journal-Rotation. `smart-mount-mount.service` bleibt nach
+einem erfolgreichen Lauf als "active (exited)" sichtbar (`RemainAfterExit=yes`), und ein
+Fehlschlag beim Mounten mindestens eines konfigurierten Laufwerkspaars lässt den Dienst jetzt
+auch tatsächlich als "failed" erscheinen, statt es stillschweigend zu ignorieren.
+
 ### Cron-Fallback (Systeme ohne systemd)
 
 Ist beim Installieren/Upgraden des Pakets kein `systemctl` gefunden, aber `/etc/cron.d`

packaging/deb/postinst

@@ -9,7 +9,15 @@ set -e
 if [ "$1" = "configure" ]; then
     if command -v systemctl >/dev/null 2>&1; then
         systemctl daemon-reload || true
-        systemctl enable --now smart-mount-mount.service smart-mount-watch.timer || true
+        # smart-mount-mount.service mountet echte Netzlaufwerke (kann pro konfiguriertem Paar
+        # mehrere zehn Sekunden dauern, wenn ein Server gerade nicht erreichbar ist) - "enable
+        # --now" wuerde synchron darauf warten und damit "apt"/"dpkg" fuer die gesamte Dauer
+        # blockieren. Daher: aktivieren (fuer den naechsten Boot) und der eigentliche Mount-Lauf
+        # nur als asynchroner Job ("--no-block", kehrt sofort zurueck) - das Paket-Setup selbst
+        # wartet also nie auf Netzwerk-Timeouts.
+        systemctl enable smart-mount-mount.service || true
+        systemctl start --no-block smart-mount-mount.service || true
+        systemctl enable --now smart-mount-watch.timer || true
     fi
     /usr/lib/smart-mount/setup-cron || true
 fi

packaging/systemd/smart-mount-mount.service

@@ -5,7 +5,26 @@ Wants=network-online.target
 
 [Service]
 Type=oneshot
+# Bleibt nach einem erfolgreichen Lauf als "active (exited)" sichtbar (statt sofort wieder
+# "inactive") - macht in 'systemctl status' auf einen Blick erkennbar, dass der letzte Boot-Lauf
+# tatsächlich durchlief, statt nur "inactive" zu zeigen (das genauso gut "nie gelaufen" heißen
+# könnte).
+RemainAfterExit=yes
 ExecStart=/usr/bin/smart-mount mount --all
+# Harte Obergrenze statt des systemd-Standards (üblicherweise 90s): pro konfiguriertem Paar
+# werden Erreichbarkeit UND Mount-Versuch sequenziell geprüft (bis zu ~20s Erreichbarkeits-
+# check + 30s Mount-Timeout, siehe crate::mount::MOUNT_TIMEOUT_SECS), bei mehreren Paaren
+# summiert sich das - 90s würde bei zwei oder mehr gerade nicht erreichbaren Servern schon
+# reichen, um mitten im Mount-Versuch abgebrochen zu werden. 10 Minuten sind großzügig genug für
+# eine typische Anzahl Paare, ohne bei einem echten Hänger (z. B. einer verwaisten Dateisperre)
+# unbegrenzt zu warten.
+TimeoutStartSec=600
+# Explizit (statt sich auf den systemd-Standard zu verlassen): stdout/stderr gehen ins Journal,
+# unter einem festen, von der jeweiligen Unit unabhängigen Tag - 'journalctl -t smart-mount'
+# zeigt damit die Ausgaben aller smart-mount-Units gebündelt.
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=smart-mount
 
 [Install]
 WantedBy=multi-user.target

packaging/systemd/smart-mount-watch.service

@@ -4,3 +4,6 @@ Description=smart-mount: check reachability and switch local/cloud if needed
 [Service]
 Type=oneshot
 ExecStart=/usr/bin/smart-mount watch
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=smart-mount

scripts/package-arch.py

@@ -105,16 +105,26 @@ def build_install_scriptlet(name, installable, all_units, has_cron_helper):
     Cron-Fallback-Hilfsprogramm ('usr/lib/<name>/setup-cron', siehe src/bin/setup-cron.rs) beim
     Installieren/Upgraden auf bzw. entfernt dessen Cron-Datei beim Entfernen wieder. Rein anhand
     der tatsächlich gefundenen Unit-Dateien/Hilfsprogramme zusammengesetzt, ohne den
-    Anwendungsnamen selbst hart zu codieren (der als `name`-Parameter hereinkommt)."""
+    Anwendungsnamen selbst hart zu codieren (der als `name`-Parameter hereinkommt).
-    installable_str = " ".join(installable)
+
+    '.service'-Units werden bewusst NICHT über 'enable --now' gestartet: Bei einem oneshot-
+    Service (typischer Fall für ein Boot-Setup-Skript) würde das den ExecStart-Befehl synchron
+    ausführen und damit 'pacman' für die gesamte Laufzeit des Skripts blockieren (siehe
+    packaging/deb/postinst für den konkreten Fall, der das erst sichtbar gemacht hat: ein
+    Mount-Versuch gegen ein gerade nicht erreichbares Netzlaufwerk). '.timer'-Units sind davon
+    nicht betroffen - sie nur zu "armen" ist immer sofort fertig - und starten daher weiterhin
+    synchron mit 'enable --now'."""
+    timers = [u for u in installable if u.endswith(".timer")]
+    services = [u for u in installable if not u.endswith(".timer")]
     all_units_str = " ".join(all_units)
 
-    systemd_enable = (
+    systemd_enable = "    systemctl daemon-reload >/dev/null 2>&1 || true\n" if installable else ""
-        "    systemctl daemon-reload >/dev/null 2>&1 || true\n"
+    if timers:
-        f"    systemctl enable --now {installable_str} >/dev/null 2>&1 || true\n"
+        systemd_enable += f"    systemctl enable --now {' '.join(timers)} >/dev/null 2>&1 || true\n"
-        if installable
+    for service in services:
-        else ""
+        systemd_enable += f"    systemctl enable {service} >/dev/null 2>&1 || true\n"
-    )
+        systemd_enable += f"    systemctl start --no-block {service} >/dev/null 2>&1 || true\n"
+
     systemd_reload = "    systemctl daemon-reload >/dev/null 2>&1 || true\n" if all_units else ""
     systemd_disable = (
         f"    systemctl disable --now {all_units_str} >/dev/null 2>&1 || true\n" if all_units else ""

src/cli/mount_cmd.rs

@@ -2,7 +2,7 @@
 
 use crate::config::{self, DrivePair};
 use crate::db::credentials::CredentialStore;
-use crate::reconcile;
+use crate::reconcile::{self, Action};
 
 fn select_pairs(
     cfg: &crate::config::AppConfig,
@@ -32,9 +32,21 @@ pub async fn run_mount(name: Option<String>, all: bool) -> anyhow::Result<()> {
     );
 
     let creds = CredentialStore::open().await?;
+    let mut had_failure = false;
     for pair in &pairs {
         let outcome = reconcile::reconcile_pair(pair, &cfg.settings, &creds).await;
         print_outcome(&outcome);
+        if matches!(outcome.action, Action::Failed(_)) {
+            had_failure = true;
+        }
+    }
+
+    // Ohne dies wäre `smart-mount-mount.service` (siehe packaging/systemd/) beim Booten selbst
+    // dann "erfolgreich" (Exit-Code 0), wenn tatsächlich kein einziges Laufwerkspaar gemountet
+    // werden konnte - `systemctl status` würde den Fehlschlag also nie sichtbar machen. Analog
+    // zu `watch::run` unten.
+    if had_failure {
+        anyhow::bail!("at least one drive pair could not be mounted");
     }
     Ok(())
 }
@@ -52,17 +64,24 @@ pub async fn run_unmount(name: Option<String>, all: bool) -> anyhow::Result<()>
         &format!("unmount: processing {} drive pair(s)", pairs.len()),
     );
 
+    let mut had_failure = false;
     for pair in &pairs {
         match reconcile::unmount_pair(pair, &cfg.settings).await {
             Ok(_) => println!("{} ({}): unmounted", pair.name, pair.id),
-            Err(e) => println!("{} ({}): ERROR: {e}", pair.name, pair.id),
+            Err(e) => {
+                println!("{} ({}): ERROR: {e}", pair.name, pair.id);
+                had_failure = true;
             }
         }
+    }
+
+    if had_failure {
+        anyhow::bail!("at least one drive pair could not be unmounted");
+    }
     Ok(())
 }
 
 pub(crate) fn print_outcome(outcome: &reconcile::ReconcileOutcome) {
-    use reconcile::Action;
     let action_str = match &outcome.action {
         Action::NoOp => "no change".to_string(),
         Action::MountedLocal => "mounted local".to_string(),

src/main.rs

@@ -7,6 +7,12 @@ use smart_mount::cli;
 async fn main() -> ExitCode {
     smart_mount::config::init();
 
+    // Persistentes, gut auffindbares Log-Verzeichnis statt logger-ctdras Standard-Fallback
+    // (ein Ordner im System-Temp-Verzeichnis, siehe logger-ctdra-Doku) - smart-mount läuft
+    // ausschließlich als root/System-Dienst (siehe crate::systemd), daher immer derselbe,
+    // feste Pfad. Muss vor dem ersten Log-Aufruf stehen (siehe logger_ctdra::set_log_dir).
+    logger_ctdra::set_log_dir("/var/log/smart-mount");
+
     let log_level = match smart_mount::config::pairs::load() {
         Ok(cfg) => cfg.settings.log_level,
         Err(_) => "info".to_string(),