TimeshiftImport.vala

Go to the documentation of this file.

/*
 * BastionGuard Backup — fork di linuxmint/bastionguard-backup
 * Copyright (C) 2025–2026 Calogero Scarnà
 * GPL-2.0-or-later
 *
 * BastionGuard BackupImport.vala
 *
 * Rilevamento e importazione snapshot BastionGuard Backup esistenti.
 *
 * Logica:
 *   1. Controlla se BastionGuard Backup è/era installato leggendo
 *      /etc/bastionguard-backup/bastionguard-backup.json  (path canonico)
 *      /etc/bastionguard-backup.json            (path legacy)
 *   2. Legge backup_device_uuid → monta la partizione
 *   3. Scansiona <mount>/bastionguard-backup/snapshots/  (rsync)
 *      oppure  <mount>/bastionguard-backup-btrfs/snapshots/  (btrfs)
 *   4. Per ogni snapshot legge info.json e lo espone come
 *      BastionGuardSnapshot così il resto del codice lo tratta
 *      come uno snapshot nativo.
 *   5. Offre un metodo migrate() che:
 *      - Rinomina <mount>/bastionguard-backup/  → <mount>/bastionguard-backup/
 *      - Aggiorna tutti gli info.json con app-version BastionGuard
 *      - Aggiorna /etc/bastionguard-backup/bastionguard-backup.json
 *        con il device UUID trovato in BastionGuard Backup
 *      - Rimuove (opzionalmente) la config BastionGuard Backup
 */
 
using GLib;
using Json;
using TeeJee.Logging;
using TeeJee.FileSystem;
using TeeJee.JsonHelper;
 
namespace BastionGuardImport {
 
//
// Snapshot importato da BastionGuard Backup
//
public class ImportedSnapshot : GLib.Object {
    public string name        = "";   // es. "2025-06-01_12-00-00"
    public string path        = "";   // path completo sul device montato
    public string date        = "";   // stringa leggibile
    public int64  date_unix   = 0;
    public string sys_uuid    = "";
    public string sys_distro  = "";
    public string tags        = "";   // "O", "D", "W", "M", "B"
    public string description = "";
    public bool   is_btrfs    = false;
    public bool   valid       = false;
}
 
//
// Risultato del rilevamento BastionGuard Backup
//
public class TimeshiftDetectResult : GLib.Object {
    public bool   found            = false;
    public string config_path      = "";   // percorso del .json trovato
    public string backup_uuid      = "";   // UUID partizione backup
    public string backup_device    = "";   // es. /dev/sda2
    public string mount_path       = "";   // dove è montata la partizione
    public bool   is_btrfs         = false;
    public string snapshots_path   = "";   // path della dir snapshots
    public Gee.ArrayList<ImportedSnapshot> snapshots;
 
    public TimeshiftDetectResult() {
        snapshots = new Gee.ArrayList<ImportedSnapshot>();
    }
}
 
//
// TimeshiftImporter — classe principale
//
public class TimeshiftImporter : GLib.Object {
 
    // Path config BastionGuard Backup (originale e legacy)
    private const string TIMESHIFT_CONF         = "/etc/bastionguard-backup/bastionguard-backup.json";
    private const string TIMESHIFT_CONF_LEGACY  = "/etc/bastionguard-backup.json";
 
    // Path config BastionGuard Backup
    private const string BGBACKUP_CONF          = "/etc/bastionguard-backup/bastionguard-backup.json";
    private const string BGBACKUP_CONF_DIR      = "/etc/bastionguard-backup";
 
    // Mount point temporaneo per la scansione
    private const string SCAN_MOUNT_POINT       = "/run/bastionguard-backup/import-scan";
 
    //
    // detect() — punto di ingresso principale
    // Restituisce TimeshiftDetectResult con tutto ciò che ha trovato.
    // Non monta nulla di permanente, usa mount temporaneo e smonta dopo.
    //
    public TimeshiftDetectResult detect() {
        var result = new TimeshiftDetectResult();
 
        // 1. Cerca config BastionGuard Backup
        string conf_path = "";
        if (FileUtils.test(TIMESHIFT_CONF, FileTest.EXISTS))
            conf_path = TIMESHIFT_CONF;
        else if (FileUtils.test(TIMESHIFT_CONF_LEGACY, FileTest.EXISTS))
            conf_path = TIMESHIFT_CONF_LEGACY;
        else {
            log_debug("BastionGuard BackupImport: nessuna config trovata");
            return result;
        }
 
        result.found       = true;
        result.config_path = conf_path;
        log_msg("BastionGuard BackupImport: config trovata in %s".printf(conf_path));
 
        // 2. Leggi il JSON di config BastionGuard Backup
        if (!load_timeshift_config(conf_path, result))
            return result;
 
        // 3. Trova il device dal UUID
        result.backup_device = find_device_by_uuid(result.backup_uuid);
        if (result.backup_device.length == 0) {
            log_error("BastionGuard BackupImport: device con UUID %s non trovato".printf(result.backup_uuid));
            return result;
        }
        log_msg("BastionGuard BackupImport: device backup = %s".printf(result.backup_device));
 
        // 4. Monta la partizione (sola lettura)
        if (!mount_backup_device(result))
            return result;
 
        // 5. Determina il path snapshot
        if (result.is_btrfs)
            result.snapshots_path = result.mount_path + "/bastionguard-backup-btrfs/snapshots";
        else
            result.snapshots_path = result.mount_path + "/bastionguard-backup/snapshots";
 
        // 6. Scansiona gli snapshot
        if (FileUtils.test(result.snapshots_path, FileTest.IS_DIR))
            scan_snapshots(result);
        else
            log_msg("BastionGuard BackupImport: dir snapshot non trovata in %s".printf(result.snapshots_path));
 
        log_msg("BastionGuard BackupImport: trovati %d snapshot".printf(result.snapshots.size));
        return result;
    }
 
    //
    // migrate() — migrazione effettiva
    // Rinomina la directory bastionguard-backup → bastionguard-backup sul device,
    // aggiorna tutti gli info.json, aggiorna la config BastionGuard.
    // Il chiamante deve passare un TimeshiftDetectResult già popolato da detect().
    //
    public bool migrate(TimeshiftDetectResult detected,
                        bool remove_timeshift_config = false,
                        Gtk.Window? parent_window = null) {
 
        if (!detected.found || detected.snapshots.size == 0) {
            log_error("BastionGuard BackupImport: nulla da migrare");
            return false;
        }
 
        log_msg("==> BastionGuard BackupImport: avvio migrazione...");
 
        // Rimonta in lettura/scrittura per la migrazione
        string out_str, err_str;
        int status;
        try {
        try { GLib.Process.spawn_command_line_sync(
            "mount -o remount,rw %s %s".printf(
                detected.backup_device, detected.mount_path),
            out out_str, out err_str, out status);
        } catch (GLib.SpawnError e) { log_error(e.message); }
        } catch (GLib.SpawnError e) { log_error("mount remount: " + e.message); return false; }
        if (status != 0) {
            log_error("BastionGuard BackupImport: impossibile rimontare in rw: " + err_str);
            return false;
        }
 
        bool ok = true;
 
        //  Passo 1: rinomina directory sul device
        string old_base, new_base;
        if (detected.is_btrfs) {
            old_base = detected.mount_path + "/bastionguard-backup-btrfs";
            new_base = detected.mount_path + "/bastionguard-backup-btrfs";
        } else {
            old_base = detected.mount_path + "/bastionguard-backup";
            new_base = detected.mount_path + "/bastionguard-backup";
        }
 
        if (FileUtils.test(old_base, FileTest.IS_DIR)) {
            if (FileUtils.rename(old_base, new_base) != 0) {
                log_error("BastionGuard BackupImport: impossibile rinominare %s → %s".printf(
                    old_base, new_base));
                ok = false;
            } else {
                log_msg("BastionGuard BackupImport: rinominato %s → %s".printf(old_base, new_base));
                // Aggiorna il path snapshot nel result
                if (detected.is_btrfs)
                    detected.snapshots_path = new_base + "/snapshots";
                else
                    detected.snapshots_path = new_base + "/snapshots";
            }
        }
 
        //  Passo 2: aggiorna info.json di ogni snapshot
        foreach (var snap in detected.snapshots) {
            // Aggiorna il path con il nuovo nome directory
            snap.path = snap.path.replace(old_base, new_base);
            string info_path = snap.path + "/info.json";
 
            if (!FileUtils.test(info_path, FileTest.EXISTS)) continue;
 
            string raw;
            try {
                FileUtils.get_contents(info_path, out raw);
            } catch { continue; }
 
            try {
                var parser = new Json.Parser();
                parser.load_from_data(raw);
                var config = parser.get_root().get_object();
 
                // Aggiorna il campo app-version con BastionGuard
                config.set_string_member("app-version",
                    "bastionguard-backup-%s".printf(Constants.VERSION));
                // Mantieni il campo originale per tracciabilità
                config.set_string_member("imported-from", "bastionguard-backup");
 
                // Serializza e riscrivi
                var gen = new Json.Generator();
                gen.set_root(new Json.Node.alloc().init_object(config));
                gen.set_pretty(true);
                string new_json = gen.to_data(null);
                FileUtils.set_contents(info_path, new_json);
 
            } catch (Error e) {
                log_error("BastionGuard BackupImport: errore aggiornamento %s: %s".printf(
                    info_path, e.message));
            }
        }
 
        //  Passo 3: aggiorna/crea config BastionGuard Backup
        update_bgbackup_config(detected);
 
        //  Passo 4: rimuovi config BastionGuard Backup (opzionale) ─
        if (remove_timeshift_config) {
            try {
                if (FileUtils.test(TIMESHIFT_CONF, FileTest.EXISTS))
                    FileUtils.remove(TIMESHIFT_CONF);
                if (FileUtils.test(TIMESHIFT_CONF_LEGACY, FileTest.EXISTS))
                    FileUtils.remove(TIMESHIFT_CONF_LEGACY);
                log_msg("BastionGuard BackupImport: config BastionGuard Backup rimossa");
            } catch (Error e) {
                log_error("BastionGuard BackupImport: impossibile rimuovere config: " + e.message);
            }
        }
 
        //  Passo 5: smonta
        unmount_backup_device(detected.mount_path);
 
        log_msg("==> BastionGuard BackupImport: migrazione completata. " +
                "%d snapshot importati.".printf(detected.snapshots.size));
        return ok;
    }
 
    //
    // PRIVATI
    //
 
    private bool load_timeshift_config(string path, TimeshiftDetectResult result) {
        string raw;
        try {
            FileUtils.get_contents(path, out raw);
        } catch (Error e) {
            log_error("BastionGuard BackupImport: impossibile leggere %s: %s".printf(path, e.message));
            return false;
        }
        try {
            var parser = new Json.Parser();
            parser.load_from_data(raw);
            var config = parser.get_root().get_object();
 
            result.backup_uuid = json_get_string(config, "backup_device_uuid", "");
            result.is_btrfs    = json_get_bool(config,   "btrfs_mode",         false);
 
            if (result.backup_uuid.length == 0) {
                log_error("BastionGuard BackupImport: backup_device_uuid non trovato nella config");
                return false;
            }
        } catch (Error e) {
            log_error("BastionGuard BackupImport: errore parsing config: " + e.message);
            return false;
        }
        return true;
    }
 
    private string find_device_by_uuid(string uuid) {
        if (uuid.length == 0) return "";
        string path = "/dev/disk/by-uuid/" + uuid;
        if (FileUtils.test(path, FileTest.EXISTS)) {
            // Risolvi il symlink
            string out_str, err_str;
            int status;
            try {
            GLib.Process.spawn_command_line_sync(
                "readlink -f " + path,
                out out_str, out err_str, out status);
            } catch (GLib.SpawnError e) { log_error(e.message); }
            if (status == 0)
                return out_str.strip();
        }
        // Fallback: cerca con blkid
        string out_str, err_str;
        int status;
        try {
        GLib.Process.spawn_command_line_sync(
            "blkid -U " + uuid,
            out out_str, out err_str, out status);
        } catch (GLib.SpawnError e) { log_error(e.message); }
        if (status == 0 && out_str.strip().length > 0)
            return out_str.strip();
 
        return "";
    }
 
    private bool mount_backup_device(TimeshiftDetectResult result) {
        dir_create(SCAN_MOUNT_POINT);
        result.mount_path = SCAN_MOUNT_POINT;
 
        string out_str, err_str;
        int status;
        try {
        try { GLib.Process.spawn_command_line_sync(
            "mount -o ro %s %s".printf(result.backup_device, SCAN_MOUNT_POINT),
            out out_str, out err_str, out status);
        } catch (GLib.SpawnError e) { log_error(e.message); }
        } catch (GLib.SpawnError e) { log_error("mount: " + e.message); return false; }
 
        if (status != 0) {
            log_error("BastionGuard BackupImport: mount fallito: " + err_str);
            return false;
        }
        return true;
    }
 
    private void unmount_backup_device(string mount_path) {
        string out_str, err_str;
        int status;
        try {
        try { GLib.Process.spawn_command_line_sync(
            "umount %s".printf(mount_path),
            out out_str, out err_str, out status);
        } catch (GLib.SpawnError e) { log_error(e.message); }
        } catch (GLib.SpawnError e) { log_error("umount: " + e.message); }
        if (status != 0)
            log_error("BastionGuard BackupImport: umount fallito: " + err_str);
    }
 
    private void scan_snapshots(TimeshiftDetectResult result) {
        try {
            var dir = Dir.open(result.snapshots_path);
            string? name;
            while ((name = dir.read_name()) != null) {
                string snap_path = result.snapshots_path + "/" + name;
                if (!FileUtils.test(snap_path, FileTest.IS_DIR)) continue;
 
                var snap = parse_snapshot(snap_path, name, result.is_btrfs);
                if (snap.valid)
                    result.snapshots.add(snap);
            }
            // Ordina per data (più recente prima)
            result.snapshots.sort((a, b) => {
                return (int)(b.date_unix - a.date_unix);
            });
        } catch (Error e) {
            log_error("BastionGuard BackupImport: errore scansione snapshot: " + e.message);
        }
    }
 
    private ImportedSnapshot parse_snapshot(string path, string name, bool is_btrfs) {
        var snap     = new ImportedSnapshot();
        snap.name    = name;
        snap.path    = path;
        snap.is_btrfs = is_btrfs;
 
        string info_path = path + "/info.json";
        if (!FileUtils.test(info_path, FileTest.EXISTS)) {
            log_debug("BastionGuard BackupImport: info.json non trovato in " + path);
            return snap;
        }
 
        string raw;
        try {
            FileUtils.get_contents(info_path, out raw);
        } catch { return snap; }
 
        try {
            var parser = new Json.Parser();
            parser.load_from_data(raw);
            var config = parser.get_root().get_object();
 
            snap.sys_uuid    = json_get_string(config, "sys-uuid",   "");
            snap.sys_distro  = json_get_string(config, "sys-distro", "");
            snap.tags        = json_get_string(config, "tags",       "");
            snap.description = json_get_string(config, "comments",   "");
 
            string created_str = json_get_string(config, "created", "0");
            snap.date_unix = int64.parse(created_str);
            var dt = new DateTime.from_unix_utc(snap.date_unix).to_local();
            snap.date = dt.format("%Y-%m-%d %H:%M:%S");
 
            snap.valid = true;
        } catch (Error e) {
            log_error("BastionGuard BackupImport: errore parsing info.json in %s: %s".printf(
                path, e.message));
        }
        return snap;
    }
 
    private void update_bgbackup_config(TimeshiftDetectResult detected) {
        // Crea dir config se non esiste
        dir_create(BGBACKUP_CONF_DIR);
 
        // Leggi config esistente o crea vuota
        var config = new Json.Object();
        if (FileUtils.test(BGBACKUP_CONF, FileTest.EXISTS)) {
            string raw;
            try {
                FileUtils.get_contents(BGBACKUP_CONF, out raw);
                var parser = new Json.Parser();
                parser.load_from_data(raw);
                config = parser.get_root().get_object();
            } catch {}
        }
 
        // Aggiorna con i dati importati da BastionGuard Backup
        config.set_string_member("backup_device_uuid", detected.backup_uuid);
        config.set_string_member("btrfs_mode",         detected.is_btrfs.to_string());
        config.set_string_member("imported_from_timeshift", "true");
 
        // Scrivi
        try {
            var gen = new Json.Generator();
            gen.set_root(new Json.Node.alloc().init_object(config));
            gen.set_pretty(true);
            string json_str = gen.to_data(null);
            FileUtils.set_contents(BGBACKUP_CONF, json_str);
            log_msg("BastionGuard BackupImport: config BastionGuard aggiornata in " + BGBACKUP_CONF);
        } catch (Error e) {
            log_error("BastionGuard BackupImport: impossibile scrivere config: " + e.message);
        }
    }
 
} // class TimeshiftImporter
 
} // namespace BastionGuardImport