RsyncLogBox.vala

Go to the documentation of this file.

/*
 * RsyncLogBox.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;
 
public class RsyncLogBox : Gtk.Box {
    private Gtk.Box vbox_progress;
    private Gtk.Box vbox_list;
    private Gtk.ComboBoxText cmb_filter;
    private Gtk.Box hbox_filter;
    private Gtk.Entry txt_pattern;
    private Gtk.ListBox listbox;
 
    private string name_filter = "";
    private string status_filter = "";
 
    public Gtk.Label lbl_header;
    public Gtk.Label lbl_header_progress;
    private Gtk.Spinner spinner;
    public Gtk.Label lbl_msg;
    public Gtk.Label lbl_status;
    public Gtk.Label lbl_remaining;
    public Gtk.ProgressBar progressbar;
 
    private uint tmr_init = 0;
    private bool thread_is_running = false;
 
    private string rsync_log_file;
    private Gee.ArrayList<FileItem> loglist;
    private Gtk.Window window;
 
    public RsyncLogBox(Gtk.Window _window) {
        GLib.Object(orientation: Gtk.Orientation.VERTICAL, spacing: 6);
        this.margin_start = 6;
        this.margin_end = 6;
        this.margin_top = 6;
        this.margin_bottom = 6;
        window = _window;
        log_debug("RsyncLogBox: RsyncLogBox()");
    }
 
    public void open_log(string _rsync_log_file){
        rsync_log_file = _rsync_log_file;
        if (App.dry_run){
            lbl_header = add_label_header(this, _("Confirm Actions"), true);
            lbl_header.visible = false;
        }
        create_progressbar();
        create_filters();
        create_listview();
 
        cmb_filter.changed.connect(() => {
            status_filter = cmb_filter.get_active_id() ?? "";
            apply_filters();
        });
 
        show();
        tmr_init = Timeout.add(100, init_delayed);
        log_debug("RsyncLogWindow: open_log(): exit");
    }
 
    private bool is_restore_log {
        get {
            return file_basename(rsync_log_file).contains("restore");
        }
    }
 
    public bool init_delayed(){
        if (tmr_init > 0){
            Source.remove(tmr_init);
            tmr_init = 0;
        }
        parse_log_file();
        if (App.dry_run && (lbl_header != null)){
            lbl_header.visible = true;
        }
        return false;
    }
 
    private void parse_log_file(){
        try {
            thread_is_running = true;
            new Thread<void>.try ("log-file-parser", () => {parse_log_file_thread();});
        }
        catch (Error e) {
            log_error (e.message);
        }
 
        while (thread_is_running){
            double fraction = (App.task.prg_count_total > 0) ? ((App.task.prg_count * 1.0) / App.task.prg_count_total) : 0.0;
            if (fraction < 0.99){
                progressbar.fraction = fraction;
            }
            lbl_msg.label = _("Read %'d of %'d lines...").printf(App.task.prg_count, App.task.prg_count_total);
            sleep(500);
            gtk_do_events();
        }
 
        lbl_msg.label = _("Populating list...");
        gtk_do_events();
        refresh_rows();
        vbox_progress.visible = false;
        vbox_list.visible = true;
        hbox_filter.visible = true;
    }
 
    private void parse_log_file_thread(){
        App.task = new RsyncTask();
        loglist = App.task.parse_log(rsync_log_file);
        thread_is_running = false;
    }
 
    public bool is_running{
        get { return thread_is_running; }
    }
 
    private void create_progressbar(){
        vbox_progress = new Gtk.Box(Orientation.VERTICAL, 6);
        append(vbox_progress);
        lbl_header_progress = add_label_header(vbox_progress, _("Parsing log file..."), true);
        var hbox_status = new Gtk.Box(Orientation.HORIZONTAL, 6);
        vbox_progress.append(hbox_status);
        spinner = new Gtk.Spinner();
        spinner.spinning = true;
        hbox_status.append(spinner);
        lbl_msg = add_label(hbox_status, _("Preparing..."));
        lbl_msg.hexpand = true;
        lbl_msg.ellipsize = Pango.EllipsizeMode.END;
        lbl_msg.max_width_chars = 50;
        progressbar = new Gtk.ProgressBar();
        vbox_progress.append(progressbar);
    }
 
    private void create_filters(){
        var hbox = new Gtk.Box(Gtk.Orientation.HORIZONTAL, 6);
        hbox.visible = false;
        append(hbox);
        hbox_filter = hbox;
        add_search_entry(hbox);
        add_combo(hbox);
 
        if (!App.dry_run){
            var label = add_label(hbox, "");
            label.hexpand = true;
            var button = new Gtk.Button.with_label(_("Close"));
        button.get_style_context().add_class("btn-cancel");
            hbox.append(button);
            button.clicked.connect(()=>{ window.destroy(); });
        }
    }
 
    private void add_search_entry(Gtk.Box hbox){
        var txt = new Gtk.Entry();
        txt.hexpand = true;
        txt.placeholder_text = _("Filter by name or path");
        hbox.append(txt);
        txt_pattern = txt;
        txt.changed.connect(()=>{ name_filter = txt.text.down(); apply_filters(); });
    }
 
    private void add_combo(Gtk.Box hbox){
        cmb_filter = new Gtk.ComboBoxText();
        hbox.append(cmb_filter);
        cmb_filter.append("", _("All Files"));
        cmb_filter.append("created", "%s".printf(App.dry_run ? _("Create") : _("Created")));
        if (is_restore_log){
            cmb_filter.append("deleted", "%s".printf(App.dry_run ? _("Delete") : _("Deleted")));
        }
        cmb_filter.append("changed", "%s".printf(App.dry_run ? _("Restore") : _("Changed")));
        if (!App.dry_run){
            cmb_filter.append("checksum", " └ %s".printf(_("Checksum")));
            cmb_filter.append("size", " └ %s".printf(_("Size")));
            cmb_filter.append("timestamp", " └ %s".printf(_("Timestamp")));
            cmb_filter.append("permissions", " └ %s".printf(_("Permissions")));
            cmb_filter.append("owner", " └ %s".printf(_("Owner")));
            cmb_filter.append("group", " └ %s".printf(_("Group")));
        }
        cmb_filter.set_active_id("");
    }
 
    private void create_listview() {
        vbox_list = new Gtk.Box(Orientation.VERTICAL, 6);
        vbox_list.visible = false;
        append(vbox_list);
        listbox = new Gtk.ListBox();
        listbox.selection_mode = Gtk.SelectionMode.NONE;
        listbox.add_css_class("boxed-list");
        var scrolled = new Gtk.ScrolledWindow();
        scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC);
        scrolled.vexpand = true;
        scrolled.set_child(listbox);
        vbox_list.append(scrolled);
    }
 
    private string display_status(FileItem item){
        if (is_restore_log){
            switch(item.file_status){
            case "checksum":
            case "size":
            case "timestamp":
            case "permissions":
            case "owner":
            case "group":
                return App.dry_run ? _("Restore") : _("Changed");
            case "created":
                return App.dry_run ? _("Create") : _("Created");
            case "deleted":
                return App.dry_run ? _("Delete") : _("Deleted");
            default:
                return item.file_status;
            }
        }
        switch(item.file_status){
        case "checksum":
        case "size":
        case "timestamp":
        case "permissions":
        case "owner":
        case "group":
            return _("Changed");
        case "created":
            return _("Created");
        case "deleted":
            return _("Deleted");
        default:
            return item.file_status;
        }
    }
 
    private string relpath_for(FileItem item){
        var spath = "%s/localhost".printf(file_parent(rsync_log_file));
        var relpath = item.file_path[spath.length:item.file_path.length];
        if (!is_restore_log){
            relpath = relpath[1:relpath.length];
        }
        return relpath;
    }
 
    private bool item_matches(FileItem item){
        string relpath = relpath_for(item).down();
        if ((name_filter.length > 0) && !relpath.contains(name_filter)){
            return false;
        }
        if (status_filter.length == 0){
            return true;
        }
        if (status_filter == "changed"){
            switch(item.file_status){
            case "checksum":
            case "size":
            case "timestamp":
            case "permissions":
            case "owner":
            case "group":
                return true;
            default:
                return false;
            }
        }
        return item.file_status == status_filter;
    }
 
    private Gtk.Widget create_log_row(FileItem item){
        var row = new Gtk.ListBoxRow();
        var outer = new Gtk.Box(Gtk.Orientation.VERTICAL, 4);
        outer.margin_start = 8;
        outer.margin_end = 8;
        outer.margin_top = 8;
        outer.margin_bottom = 8;
        row.set_child(outer);
 
        var top = new Gtk.Box(Gtk.Orientation.HORIZONTAL, 8);
        outer.append(top);
 
        var image = new Gtk.Image.from_pixbuf(item.get_icon(16, false, false));
        top.append(image);
 
        var status = new Gtk.Label(display_status(item));
        status.xalign = 0.0f;
        status.add_css_class("accent");
        status.width_chars = 12;
        top.append(status);
 
        var path = new Gtk.Label(relpath_for(item));
        path.xalign = 0.0f;
        path.hexpand = true;
        path.wrap = true;
        top.append(path);
 
        return row;
    }
 
    private void clear_rows(){
        Gtk.Widget? child = listbox.get_first_child();
        while (child != null){
            Gtk.Widget? next = child.get_next_sibling();
            listbox.remove(child);
            child = next;
        }
    }
 
    private void refresh_rows() {
        clear_rows();
        if (loglist == null){ return; }
        foreach(var item in loglist) {
            if (App.dry_run && (item.file_type == FileType.DIRECTORY)){
                continue;
            }
            if (!item_matches(item)){
                continue;
            }
            listbox.append(create_log_row(item));
        }
    }
 
    private void apply_filters(){
        status_filter = cmb_filter.get_active_id() ?? "";
        name_filter = txt_pattern.text.down();
        refresh_rows();
    }
}