RestoreDeviceBox.vala

Go to the documentation of this file.

/*
 * RestoreDeviceBox.vala
 */
 
using Gtk;
using Gee;
 
using TeeJee.Logging;
using TeeJee.FileSystem;
using TeeJee.JsonHelper;
using TeeJee.ProcessHelper;
using TeeJee.GtkHelper;
using TeeJee.System;
using TeeJee.Misc;
 
class RestoreDeviceBox : Gtk.Box{
 
    private Gtk.Box infobar_location;
    private Gtk.Label lbl_infobar_location;
    private Gtk.Box option_box;
    private Gtk.Label lbl_header_subvol;
    private bool show_volume_name = false;
    
    private Gtk.SizeGroup sg_mount_point = new Gtk.SizeGroup(SizeGroupMode.HORIZONTAL);
    private Gtk.SizeGroup sg_device = new Gtk.SizeGroup(SizeGroupMode.HORIZONTAL);
    private Gtk.SizeGroup sg_mount_options = new Gtk.SizeGroup(SizeGroupMode.HORIZONTAL);
    private Gtk.Window parent_window;
 
    public RestoreDeviceBox (Gtk.Window _parent_window) {
        log_debug("RestoreDeviceBox: RestoreDeviceBox()");
        GLib.Object(orientation: Gtk.Orientation.VERTICAL, spacing: 6);
        parent_window = _parent_window;
        margin_top = 12;
        margin_bottom = 12;
        margin_start = 12;
        margin_end = 12;
 
        var hbox = new Gtk.Box(Gtk.Orientation.HORIZONTAL, 6);
        append(hbox);
        add_label_header(hbox, _("Select Target Device"), true);
 
        var label = add_label(hbox, "");
        label.hexpand = true;
 
        Gtk.SizeGroup size_group = new Gtk.SizeGroup(SizeGroupMode.HORIZONTAL);
        var btn_refresh = add_button(hbox, _("Refresh"), "", size_group, null);
        btn_refresh.clicked.connect(()=>{
            App.update_partitions();
            refresh();
        });
 
        if (App.mirror_system){
            add_label(this, _("Select the target devices where system will be cloned."));
        }
        else{
            add_label(this,
                _("Select the devices where files will be restored.") + "\n" +
                _("Devices from which snapshot was created are pre-selected."));
        }
 
        hbox = new Gtk.Box(Gtk.Orientation.HORIZONTAL, 6);
        hbox.margin_top = 12;
        append(hbox);
 
        label = add_label(hbox, _("Path") + "  ", true, true);
        label.xalign = 0.0f;
        sg_mount_point.add_widget(label);
        
        label = add_label(hbox, _("Device") + "  ", true, true);
        label.xalign = 0.0f;
        sg_device.add_widget(label);
 
        label = add_label(hbox, _("Subvolume"), true, true);
        label.xalign = 0.5f;
        label.visible = false;
        lbl_header_subvol = label;
 
        option_box = new Gtk.Box(Gtk.Orientation.VERTICAL, 6);
        append(option_box);
 
        add_boot_options();
        create_infobar_location();
        log_debug("RestoreDeviceBox: RestoreDeviceBox(): exit");
    }
 
    public void refresh(bool reset_device_selections = true){
        log_debug("RestoreDeviceBox: refresh()");
        App.update_partitions();
        create_device_selection_options(reset_device_selections);
        App.init_boot_options();
        log_debug("RestoreDeviceBox: refresh(): exit");
    }
 
    private void create_device_selection_options(bool reset_device_selections){
        if (reset_device_selections){
            App.init_mount_list();
        }
 
        show_volume_name = false;
        foreach(var entry in App.mount_list){
            if ((entry.device != null) && ((entry.subvolume_name().length > 0) || (entry.lvm_name().length > 0))){
                show_volume_name = true;
                break;
            }
        }
 
        lbl_header_subvol.visible = show_volume_name;
 
        while (option_box.get_first_child() != null){
            option_box.remove(option_box.get_first_child());
        }
 
        foreach(MountEntry entry in App.mount_list){
            add_device_selection_option(entry);
        }
 
        show();
    }
 
    private void add_device_selection_option(MountEntry entry){
        var box = new Gtk.Box(Gtk.Orientation.HORIZONTAL, 6);
        option_box.append(box);
 
        var label = add_label(box, entry.mount_point, true);
        sg_mount_point.add_widget(label);
        
        var combo = add_device_combo(box, entry);
        sg_device.add_widget(combo);
 
        if (show_volume_name){
            string txt = "";
            if (entry.subvolume_name().length > 0){
                txt = "%s".printf(entry.subvolume_name());
            }
            else {
                txt = "%s".printf(entry.lvm_name());
            }
            label = add_label(box, txt, false);
            sg_mount_options.add_widget(label);
        }
    }
 
    private Gtk.ComboBoxText add_device_combo(Gtk.Box box, MountEntry entry){
        var combo = new Gtk.ComboBoxText();
        combo.hexpand = true;
        box.append(combo);
 
        Gee.ArrayList<Device?> device_map = new Gee.ArrayList<Device?>();
        var active = -1;
        var index = -1;
 
        if (entry.mount_point != "/"){
            index++;
            device_map.add(null);
            combo.append_text(_("Keep on Root Device"));
        }
        
        foreach(var dev in App.partitions){
            if ((dev.type == "loop") || (dev.fstype == "iso9660")){
                continue;
            }
 
            if (dev.type != "disk"){
                if ((entry.mount_point == "/") || (entry.mount_point == "/home")){
                    if (!dev.has_linux_filesystem()){
                        continue;
                    }
                }
 
                if (dev.has_children()){
                    continue;
                }
            }
            
            index++;
            device_map.add(dev);
            combo.append_text(dev.description());
        
            if (entry.device != null){
                if (dev.uuid == entry.device.uuid){
                    active = index;
                }
                else if (dev.has_parent() && (dev.parent.uuid == entry.device.uuid)){
                    active = index;
                }
                else if (dev.has_children() && (dev.children[0].uuid == entry.device.uuid)){
                    active = index;
                }
            }
        }
 
        if ((active == -1) && (entry.mount_point != "/")){
            active = 0;
        }
 
        combo.active = active;
        combo.changed.connect(() => {
            int current_index = combo.get_active();
            if ((current_index < 0) || (current_index >= device_map.size)){
                log_debug("device combo: active is -1");
                return;
            }
 
            Device? current_dev = device_map[current_index];
 
            if ((current_dev != null) && current_dev.is_encrypted_partition()){
                log_debug("add_device_combo().changed: unlocking encrypted device..");
                string msg_out, msg_err;
                var luks_unlocked = Device.luks_unlock(
                    current_dev, "", "", parent_window, out msg_out, out msg_err);
 
                if (luks_unlocked == null){
                    log_debug("add_device_combo().changed: failed to unlock");
                    if (entry.mount_point == "/"){
                        int fallback_index = -1;
                        for (int i = 0; i < device_map.size; i++){
                            Device? dev_iter = device_map[i];
                            if ((dev_iter != null) && (entry.device != null) && (dev_iter.device == entry.device.device)){
                                fallback_index = i;
                                break;
                            }
                        }
                        combo.active = fallback_index;
                    }
                    else{
                        combo.active = 0;
                    }
                    return;
                }
                else{
                    log_debug("add_device_combo().changed: unlocked");
                    if (entry.mount_point == "/"){
                        App.dst_root = luks_unlocked;
                        App.init_boot_options();
                    }
                    entry.device = luks_unlocked;
                    refresh(false);
                    return;
                }
            }
 
            entry.device = current_dev;
            if (entry.mount_point == "/"){
                App.dst_root = current_dev;
                App.init_boot_options();
            }
        });
 
        return combo;
    }
 
    private void add_boot_options(){
        var hbox = new Gtk.Box(Gtk.Orientation.HORIZONTAL, 6);
        append(hbox);
        string tt = _("[For Experienced Users] Change these settings if the restored system fails to boot.");
        var button = add_button(hbox, _("Bootloader Options (Advanced)"), tt, null, null);
        button.margin_start = 10;
        button.margin_end = 10;
        button.margin_top = 10;
        button.margin_bottom = 10;
 
        button.clicked.connect(()=>{
            if (parent_window is MainWindow){
                ((MainWindow) parent_window).show_settings();
            }
            else{
                var win = new BootOptionsWindow();
                win.set_transient_for(parent_window);
            }
        });
    }
 
    private void create_infobar_location(){
        var infobar = new Gtk.Box(Gtk.Orientation.VERTICAL, 0);
        infobar.visible = false;
        append(infobar);
        infobar_location = infobar;
        
        var content = infobar;
        var label = add_label(content, "");
        lbl_infobar_location = label;
    }
 
    public bool check_and_mount_devices(){
        if (App.dst_root == App.sys_root){
            return true;
        }
        
        foreach(var entry in App.mount_list){
            if ((entry.mount_point == "/") && (entry.device == null)){
                gtk_messagebox(_("Root device not selected"), _("Select the device for root file system (/)"), parent_window, true);
                return false;
            }
        }
 
        if (App.mirror_system){
            foreach(var entry in App.mount_list){
                if (entry.mount_point != "/"){ continue; }
                bool same = false;
                if (entry.device.uuid == App.sys_root.uuid){
                    same = true;
                }
                else if (entry.device.has_parent() && App.sys_root.has_parent()){
                    if (entry.device.uuid == App.sys_root.parent.uuid){
                        same = true;
                    }
                }
                if (same){
                    gtk_messagebox(_("Target device is same as system device"), _("Select another device for root file system (/)"), parent_window, true);
                    return false;
                }
                break;
            }
        }
 
        foreach(var entry in App.mount_list){
            if ((entry.mount_point == "/boot") && (entry.device == null)){
                if ((App.dst_root != null) && (App.dst_root.is_on_encrypted_partition())){
                    gtk_messagebox(
                        _("Boot device not selected"),
                        _("An encrypted device is selected for root file system (/). The boot directory (/boot) must be mounted on a non-encrypted device for the system to boot successfully.\n\nEither select a non-encrypted device for boot directory or select a non-encrypted device for root filesystem."),
                        parent_window, true);
                    return false;
                }
            }
        }
 
        if (App.reinstall_grub2 && (App.grub_device.length == 0)){
            gtk_messagebox(_("GRUB device not selected"), _("Please select the GRUB device"), parent_window, true);
            return false;
        }
 
        bool supported = App.check_btrfs_layout(App.dst_root, App.dst_home, false);
        if (!supported){
            var title = _("Unsupported Subvolume Layout") + " (%s)".printf(App.dst_root.device);
            var msg = _("Partition has an unsupported subvolume layout.") + " ";
            msg += _("Only ubuntu-type layouts with @ and @home subvolumes are currently supported.") + "\n\n";
            gtk_messagebox(title, msg, parent_window, true);
            return false;
        }
 
        bool status = App.mount_target_devices(parent_window);
        if (status == false){
            gtk_messagebox(_("Error"), _("Failed to mount devices"), parent_window, true);
            return false;
        }
 
        return true;
    }
}