BackupPage.cpp

Go to the documentation of this file.

/*
 * BastionGuard™
 * BackupPage.cpp
 */
 
#include "BackupPage.hpp"
#include <glibmm/spawn.h>
#include <glibmm/i18n.h>
#include <glibmm/fileutils.h>
#include <glibmm/main.h>
#include <giomm.h>
#include <sys/statvfs.h>
#include <sys/wait.h>
#include <sstream>
#include <iomanip>
#include <memory>
#include <thread>
 
// ---------------------------------------------------------------------------
// Costanti
// ---------------------------------------------------------------------------
 
static const char* BG_BACKUP_LAUNCHER    = "/usr/bin/bastionguard-backup-launcher";
static const char* RECOVERY_SQUASHFS     = "/boot/bastionguard-recovery/live/filesystem.squashfs";
static const char* RECOVERY_KERNEL       = "/boot/bastionguard-recovery/vmlinuz";
static const char* RECOVERY_DIR          = "/boot/bastionguard-recovery";
static const char* GRUB_ENTRY            = "/etc/grub.d/42_bastionguard-recovery";
static const char* BUILD_SCRIPT          = "/usr/share/bastionguard-backup/scripts/build-recovery-squashfs.sh";
static const char* INSTALL_GRUB_SCRIPT   = "/usr/share/bastionguard-backup/scripts/install-grub-entry.sh";
 
static constexpr guint64 MIN_SPACE_BYTES = 2ULL * 1024 * 1024 * 1024; // 2 GB
 
// ---------------------------------------------------------------------------
// Helper: formatta bytes leggibili
// ---------------------------------------------------------------------------
 
static std::string fmtSize(guint64 bytes)
{
    std::ostringstream ss;
 
    if (bytes >= 1024ULL * 1024 * 1024) {
        ss << std::fixed << std::setprecision(1)
        << (double)bytes / (1024.0 * 1024 * 1024);
        return Glib::ustring::compose(_("%1 GB"), ss.str());
    }
 
    if (bytes >= 1024ULL * 1024) {
        ss << std::fixed << std::setprecision(0)
        << (double)bytes / (1024.0 * 1024);
        return Glib::ustring::compose(_("%1 MB"), ss.str());
    }
 
    ss << (bytes / 1024);
    return Glib::ustring::compose(_("%1 KB"), ss.str());
}
 
// ---------------------------------------------------------------------------
// Costruttore
// ---------------------------------------------------------------------------
 
BackupPage::BackupPage()
: Gtk::Box(Gtk::Orientation::VERTICAL, 0)
{
    logBuffer = Gtk::TextBuffer::create();
 
    notebook.append_page(*buildBackupTab(), _("💾 Backup"));
    notebook.append_page(*buildGrubTab(),   _("🛡 Recovery GRUB"));
 
    // Layout a due colonne: tab operative a sinistra e log a destra.
    auto* columns = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 0);
 
    auto* leftColumn = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 0);
    leftColumn->set_hexpand(true);
    notebook.set_vexpand(true);
    leftColumn->append(notebook);
 
    auto* rightColumn = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 0);
    rightColumn->set_size_request(340, -1);   // colonna laterale ~340px
    rightColumn->append(*buildLogSection());
 
    columns->append(*leftColumn);
    columns->append(*rightColumn);
 
    set_vexpand(true);
    append(*columns);
    columns->set_vexpand(true);
 
    // Aggiorna stato immagine all'avvio
    updateRecoveryStatus();
}
 
BackupPage::~BackupPage()
{
    if (alive_) alive_->store(false, std::memory_order_release);
    if (pulseTimer.connected()) pulseTimer.disconnect();
}
 
// ---------------------------------------------------------------------------
// Backup TAB
// ---------------------------------------------------------------------------
 
Gtk::Widget* BackupPage::buildBackupTab()
{
    auto box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 16);
    box->set_margin_top(20);
    box->set_margin_bottom(20);
    box->set_margin_start(20);
    box->set_margin_end(20);
 
    auto label = Gtk::make_managed<Gtk::Label>();
    label->set_markup(
        _("<b>Gestione snapshot BastionGuard</b>\n\n"
        "Per creare, eliminare e ripristinare snapshot "
        "aprire l'interfaccia grafica dedicata.\n"));
    label->set_wrap(true);
    label->set_halign(Gtk::Align::START);
    box->append(*label);
 
    auto launchButton = Gtk::make_managed<Gtk::Button>();
    launchButton->set_label(_("🛡 Apri Gestione Backup"));
    launchButton->get_style_context()->add_class("suggested-action");
    launchButton->signal_clicked().connect([this]() {
        try {
            Glib::spawn_command_line_async(BG_BACKUP_LAUNCHER);
            logSafe(Glib::ustring(_("Avvio gestore backup BastionGuard...\n")).raw());
        } catch (...) {
            logSafe(Glib::ustring(_("Errore durante l'avvio del gestore backup BastionGuard.\n")).raw());
        }
    });
    box->append(*launchButton);
 
    return box;
}
 
// ---------------------------------------------------------------------------
// Recovery GRUB TAB
// ---------------------------------------------------------------------------
 
Gtk::Widget* BackupPage::buildGrubTab()
{
    auto box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 14);
    box->set_margin_top(16);
    box->set_margin_bottom(16);
    box->set_margin_start(16);
    box->set_margin_end(16);
 
    // ── Descrizione ────────────────────────────────────────────────────
    auto desc = Gtk::make_managed<Gtk::Label>();
    desc->set_markup(
        _("<b>BastionGuard Recovery Environment</b>\n\n"
        "Installa una voce GRUB per avviare un sistema Linux "
        "minimale isolato e ripristinare snapshot in sicurezza.\n\n"
        "<b>⚠ Requisiti:</b>\n"
        "  • Almeno <b>2 GB</b> di spazio libero sulla partizione <tt>/boot</tt>\n"
        "  • Connessione internet per il download dei pacchetti Debian\n"
        "  • La build può richiedere 10–20 minuti"));
    desc->set_wrap(true);
    desc->set_halign(Gtk::Align::START);
    box->append(*desc);
 
    // ── Card stato immagine ─────────────────────────────────────────────
    auto card = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 6);
    card->get_style_context()->add_class("card");
    card->set_margin_top(4);
 
    recoveryStatusLabel.set_halign(Gtk::Align::START);
    recoveryStatusLabel.set_use_markup(true);
    card->append(recoveryStatusLabel);
 
    recoverySpaceLabel.set_halign(Gtk::Align::START);
    recoverySpaceLabel.set_use_markup(true);
    card->append(recoverySpaceLabel);
 
    box->append(*card);
 
    // ── Risultato ultimo comando ────────────────────────────────────────
    recoveryResultLabel.set_halign(Gtk::Align::START);
    recoveryResultLabel.set_use_markup(true);
    recoveryResultLabel.hide();
    box->append(recoveryResultLabel);
 
    // ── Progress bar ────────────────────────────────────────────────────
    recoveryProgress.set_show_text(true);
    recoveryProgress.set_text(_("In attesa..."));
    recoveryProgress.hide();
    box->append(recoveryProgress);
 
    // ── Pulsanti ────────────────────────────────────────────────────────
    auto btnBox = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 8);
 
    buildRecoveryButton.set_label(_("🔨 Build filesystem squashfs"));
    buildRecoveryButton.signal_clicked().connect(
        sigc::mem_fun(*this, &BackupPage::onBuildRecovery));
    btnBox->append(buildRecoveryButton);
 
    installGrubButton.set_label(_("⬆ Installa voce GRUB"));
    installGrubButton.get_style_context()->add_class("suggested-action");
    installGrubButton.signal_clicked().connect(
        sigc::mem_fun(*this, &BackupPage::onInstallGrub));
    btnBox->append(installGrubButton);
 
    removeGrubButton.set_label(_("🗑 Rimuovi voce GRUB"));
    removeGrubButton.get_style_context()->add_class("destructive-action");
    removeGrubButton.signal_clicked().connect(
        sigc::mem_fun(*this, &BackupPage::onRemoveGrub));
    btnBox->append(removeGrubButton);
 
    box->append(*btnBox);
 
    return box;
}
 
// ---------------------------------------------------------------------------
// Log section
// ---------------------------------------------------------------------------
 
Gtk::Widget* BackupPage::buildLogSection()
{
    auto frame = Gtk::make_managed<Gtk::Frame>(_("Log operazioni"));
 
    logView.set_buffer(logBuffer);
    logView.set_editable(false);
    logView.set_monospace(true);
    logView.set_wrap_mode(Gtk::WrapMode::WORD_CHAR);
 
    auto scroll = Gtk::make_managed<Gtk::ScrolledWindow>();
    scroll->set_child(logView);
    // Pannello laterale: si espande in ALTEZZA per riempire lo spazio delle
    // tab, e ha una larghezza contenuta così non ruba spazio al contenuto.
    scroll->set_policy(Gtk::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
    scroll->set_vexpand(true);
 
    frame->set_child(*scroll);
    frame->set_vexpand(true);
    frame->set_size_request(340, -1);   // larghezza ~340px, altezza flessibile
    frame->set_margin_top(10);
    frame->set_margin_bottom(10);
    frame->set_margin_end(12);
    frame->set_margin_start(6);
    return frame;
}
 
// ---------------------------------------------------------------------------
// Aggiorna stato immagine recovery
// ---------------------------------------------------------------------------
 
void BackupPage::updateRecoveryStatus()
{
    bool squashfs_ok = Glib::file_test(RECOVERY_SQUASHFS, Glib::FileTest::EXISTS);
    bool kernel_ok   = Glib::file_test(RECOVERY_KERNEL,   Glib::FileTest::EXISTS);
    bool grub_ok     = Glib::file_test(GRUB_ENTRY,        Glib::FileTest::EXISTS);
 
    std::string status_markup;
 
    if (squashfs_ok && kernel_ok) {
        std::string size_str = "?";
        try {
            auto info = Gio::File::create_for_path(RECOVERY_SQUASHFS)
            ->query_info("standard::size");
            size_str = fmtSize((guint64)info->get_size());
        } catch (...) {}
 
        status_markup = Glib::ustring::compose(
            _("<span foreground='#22c55e'>✅ <b>Immagine recovery presente</b></span>\n"
            "<small><tt>%1</tt>\n"
            "filesystem.squashfs: %2\n"
            "Voce GRUB: %3</small>"),
            RECOVERY_DIR,
            size_str,
            grub_ok ? _("✅ installata") : _("⚠ non installata")
        );
    } else {
        status_markup =
        _("<span foreground='#f59e0b'>⚠ <b>Immagine recovery non trovata</b></span>\n"
        "<small>Usare \"Build filesystem squashfs\" per crearla.</small>");
    }
 
    recoveryStatusLabel.set_markup(status_markup);
 
    // Spazio disponibile su /boot
    struct statvfs vfs;
    std::string space_markup;
 
    const char* check_path = Glib::file_test("/boot", Glib::FileTest::IS_DIR)
    ? "/boot" : "/";
 
    if (statvfs(check_path, &vfs) == 0) {
        guint64 free_bytes = (guint64)vfs.f_bavail * vfs.f_frsize;
        std::string free_str = fmtSize(free_bytes);
        bool enough = free_bytes >= MIN_SPACE_BYTES;
 
        space_markup = Glib::ustring::compose(
            _("Spazio libero su <tt>%1</tt>: <b>%2</b> %3"),
                                              check_path,
                                              free_str,
                                              enough
                                              ? _("<span foreground='#22c55e'>✅ sufficiente</span>")
                                              : _("<span foreground='#ef4444'>❌ insufficiente (minimo 2 GB)</span>")
        );
    } else {
        space_markup = _("Spazio disponibile: <i>non rilevato</i>");
    }
 
    recoverySpaceLabel.set_markup(space_markup);
}
 
// ---------------------------------------------------------------------------
// setResult — mostra alert success/error
// ---------------------------------------------------------------------------
 
void BackupPage::setResult(bool success, const std::string& msg)
{
    if (success) {
        recoveryResultLabel.set_markup(
            Glib::ustring::compose(
                "<span foreground='#ffffff' background='#22c55e'> ✅  %1 </span>",
                msg
            )
        );
        recoveryResultLabel.get_style_context()->add_class("alert-success");
        recoveryResultLabel.get_style_context()->remove_class("alert-danger");
    } else {
        recoveryResultLabel.set_markup(
            Glib::ustring::compose(
                "<span foreground='#ffffff' background='#c0392b'> ❌  %1 </span>",
                msg
            )
        );
        recoveryResultLabel.get_style_context()->add_class("alert-danger");
        recoveryResultLabel.get_style_context()->remove_class("alert-success");
    }
 
    recoveryResultLabel.show();
    updateRecoveryStatus();
}
 
 
 
// ---------------------------------------------------------------------------
// Handlers
// ---------------------------------------------------------------------------
 
void BackupPage::onBuildRecovery()
{
 
    std::string cmd = std::string("pkexec bash \"") + BUILD_SCRIPT + "\"";
    logSafe(Glib::ustring(_("==> Avvio build Recovery environment...\n")).raw());
    logSafe(Glib::ustring(_("    (può richiedere 10-20 minuti)\n")).raw());
    runAsyncStreaming(cmd, true);
}
 
void BackupPage::onInstallGrub()
{
 
    std::string cmd = std::string("pkexec bash \"") + INSTALL_GRUB_SCRIPT + "\"";
    logSafe(Glib::ustring(_("==> Installazione voce GRUB...\n")).raw());
    runAsyncStreaming(cmd, true);
}
 
void BackupPage::onRemoveGrub()
{
 
    std::string cmd =
    "pkexec bash -c 'rm -f /etc/grub.d/42_bastionguard-recovery && update-grub'";
    logSafe(Glib::ustring(_("==> Rimozione voce GRUB...\n")).raw());
    runAsyncStreaming(cmd, false);
}
 
// ---------------------------------------------------------------------------
// runAsyncStreaming — esegue comando con output live nel log
// ---------------------------------------------------------------------------
 
void BackupPage::runAsyncStreaming(const std::string& cmd, bool show_success)
{
    if (buildRunning) {
        logSafe(Glib::ustring(_("⚠ Operazione già in corso.\n")).raw());
        return;
    }
 
    buildRunning = true;
    buildRecoveryButton.set_sensitive(false);
    installGrubButton.set_sensitive(false);
    removeGrubButton.set_sensitive(false);
 
    recoveryProgress.set_text(_("Operazione in corso..."));
    recoveryProgress.show();
    recoveryResultLabel.hide();
 
    pulseTimer = Glib::signal_timeout().connect([this]() -> bool {
        if (!buildRunning)
            return false;
        recoveryProgress.pulse();
        return true;
    }, 200);
 
    std::vector<std::string> argv = { "/bin/bash", "-c", cmd };
    int stdout_fd = -1;
    int stderr_fd = -1;
    Glib::Pid pid = 0;
 
    try {
        Glib::spawn_async_with_pipes(
            "",
            argv,
            Glib::SpawnFlags::SEARCH_PATH | Glib::SpawnFlags::DO_NOT_REAP_CHILD,
            sigc::slot<void()>(),
                                     &pid,
                                     nullptr,
                                     &stdout_fd,
                                     &stderr_fd
        );
    } catch (const Glib::Error& e) {
        logSafe(
            Glib::ustring::compose(_("Errore avvio processo: %1\n"), e.what()).raw()
        );
        buildRunning = false;
        pulseTimer.disconnect();
        recoveryProgress.hide();
        buildRecoveryButton.set_sensitive(true);
        installGrubButton.set_sensitive(true);
        removeGrubButton.set_sensitive(true);
        setResult(false, _("Errore avvio processo"));
        return;
    }
 
    auto stdout_ch = Glib::IOChannel::create_from_fd(stdout_fd);
    auto stderr_ch = Glib::IOChannel::create_from_fd(stderr_fd);
    stdout_ch->set_encoding("");
    stderr_ch->set_encoding("");
    stdout_ch->set_flags(Glib::IOFlags::NONBLOCK);
    stderr_ch->set_flags(Glib::IOFlags::NONBLOCK);
 
    // ANTI-BOOTLOOP: condividiamo le sigc::connection per le due signal_io
    // dentro shared_ptr, così sia le callback I/O (in caso di HUP/ERR) sia
    // il child_watch possono disconnetterle. Senza questa disconnessione
    // esplicita, quando il processo termina i fd vanno in IO_HUP e GLib
    // continua a richiamare la callback all'infinito (busy loop sul main
    // loop → BackupPage va in "bootloop" e la UI si blocca, specie durante
    // build pesanti come `build-recovery-squashfs.sh` che dura 10-20 min).
    auto stdout_conn = std::make_shared<sigc::connection>();
    auto stderr_conn = std::make_shared<sigc::connection>();
    auto alive = alive_;
 
    // Helper che drena ciò che resta sul channel in modo non bloccante,
    // ignorando errori. Chiamato sia su HUP sia alla terminazione del child.
    auto drain_channel = [this, alive](Glib::RefPtr<Glib::IOChannel> ch, bool is_stderr) {
        if (!ch) return;
        try {
            for (;;) {
                Glib::ustring line;
                auto st = ch->read_line(line);
                if (st != Glib::IOStatus::NORMAL || line.empty()) break;
                BastionGuard::if_alive(alive, [this, &line, is_stderr]() {
                    if (is_stderr) {
                        logSafe(Glib::ustring::compose(_("⚠ %1"), line.raw()).raw());
                    } else {
                        logSafe(line.raw());
                    }
                });
            }
        } catch (...) {}
    };
 
    // Leggi stdout
    *stdout_conn = Glib::signal_io().connect(
        [this, alive, stdout_ch, stdout_conn, drain_channel](Glib::IOCondition cond) -> bool {
            // Drena tutto ciò che è disponibile.
            if ((cond & Glib::IOCondition::IO_IN) != Glib::IOCondition()) {
                try {
                    Glib::ustring line;
                    auto status = stdout_ch->read_line(line);
                    if (status == Glib::IOStatus::NORMAL && !line.empty()) {
                        BastionGuard::if_alive(alive, [this, &line]() {
                            logSafe(line.raw());
                        });
                    }
                } catch (...) {}
            }
            // FIX BOOTLOOP: HUP/ERR → drena residuo, poi stacca la sorgente
            // ritornando false. Senza questo, GLib richiama la callback
            // all'infinito perché HUP è level-triggered.
            if ((cond & (Glib::IOCondition::IO_HUP | Glib::IOCondition::IO_ERR))
                != Glib::IOCondition()) {
                drain_channel(stdout_ch, false);
                return false;
            }
            return true;
        },
        stdout_fd, Glib::IOCondition::IO_IN | Glib::IOCondition::IO_HUP | Glib::IOCondition::IO_ERR
    );
 
    // Leggi stderr
    *stderr_conn = Glib::signal_io().connect(
        [this, alive, stderr_ch, stderr_conn, drain_channel](Glib::IOCondition cond) -> bool {
            if ((cond & Glib::IOCondition::IO_IN) != Glib::IOCondition()) {
                try {
                    Glib::ustring line;
                    auto status = stderr_ch->read_line(line);
                    if (status == Glib::IOStatus::NORMAL && !line.empty()) {
                        BastionGuard::if_alive(alive, [this, &line]() {
                            logSafe(Glib::ustring::compose(_("⚠ %1"), line.raw()).raw());
                        });
                    }
                } catch (...) {}
            }
            if ((cond & (Glib::IOCondition::IO_HUP | Glib::IOCondition::IO_ERR))
                != Glib::IOCondition()) {
                drain_channel(stderr_ch, true);
                return false;
            }
            return true;
        },
        stderr_fd, Glib::IOCondition::IO_IN | Glib::IOCondition::IO_HUP | Glib::IOCondition::IO_ERR
    );
 
    // Attendi completamento processo
    Glib::signal_child_watch().connect(
        [this, alive, show_success, stdout_ch, stderr_ch, stdout_conn, stderr_conn, drain_channel]
        (Glib::Pid p, int status) {
            // FIX BOOTLOOP: stacca esplicitamente le due signal_io PRIMA
            // di chiudere i channel, altrimenti se il fd viene riciclato
            // dal kernel le callback si riarmano su un altro fd.
            if (stdout_conn && stdout_conn->connected()) stdout_conn->disconnect();
            if (stderr_conn && stderr_conn->connected()) stderr_conn->disconnect();
 
            // Drena eventuale residuo prima di chiudere.
            drain_channel(stdout_ch, false);
            drain_channel(stderr_ch, true);
 
            try { stdout_ch->close(); } catch (...) {}
            try { stderr_ch->close(); } catch (...) {}
            Glib::spawn_close_pid(p);
 
            BastionGuard::if_alive(alive, [this, show_success, status]() {
                pulseTimer.disconnect();
                buildRunning = false;
                recoveryProgress.hide();
                buildRecoveryButton.set_sensitive(true);
                installGrubButton.set_sensitive(true);
                removeGrubButton.set_sensitive(true);
 
                bool ok = (WIFEXITED(status) && WEXITSTATUS(status) == 0);
 
                if (ok) {
                    logSafe(Glib::ustring(_("==> Operazione completata con successo.\n")).raw());
                    if (show_success)
                        setResult(true, _("Completato — disponibile al prossimo avvio"));
                } else {
                    int code = WIFEXITED(status) ? WEXITSTATUS(status) : -1;
                    logSafe(
                        Glib::ustring::compose(
                            _("==> Operazione terminata con errore (codice: %1)\n"),
                                               code
                        ).raw()
                    );
                    setResult(
                        false,
                        Glib::ustring::compose(
                            _("Operazione fallita (codice %1)"),
                                               code
                        ).raw()
                    );
                }
            });
        },
        pid
    );
}
 
// ---------------------------------------------------------------------------
// logSafe — aggiunge testo al log sul thread principale
// ---------------------------------------------------------------------------
 
void BackupPage::logSafe(const std::string& msg)
{
    auto alive = alive_;
    Glib::signal_idle().connect_once([this, alive, msg]() {
        BastionGuard::if_alive(alive, [this, &msg]() {
            logBuffer->insert(logBuffer->end(), msg);
            auto mark = logBuffer->get_insert();
            logView.move_mark_onscreen(mark);
        });
    });
}