Subvolume.vala

/*
 * Subvolume.vala
 *
 * Copyright 2012-2018 Tony George <teejeetech@gmail.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA 02110-1301, USA.
 *
 *
 */

using TeeJee.Logging;
using TeeJee.FileSystem;
using TeeJee.JsonHelper;
using TeeJee.ProcessHelper;
using TeeJee.GtkHelper;
using TeeJee.System;
using TeeJee.Misc;

public class Subvolume : GLib.Object{

	public string device_uuid;
	public string name = "";
	public string path = "";
	public long id = -1;
	public int64 total_bytes = 0;
	public int64 unshared_bytes = 0;

	public string mount_path = "";

	//parent
	public SnapshotRepo? repo;
	
	public Subvolume(string name, string path, string parent_dev_uuid, SnapshotRepo? parent_repo){
		
		this.name = name;
		this.path = path;
		this.device_uuid = parent_dev_uuid;
		this.repo = parent_repo;

		if (repo != null){
			this.mount_path = repo.mount_paths[name];
		}
	}

	public string total_formatted{
		owned get{
			return format_file_size(total_bytes);
		}
	}

	public string unshared_formatted{
		owned get{
			return format_file_size(unshared_bytes);
		}
	}

	public Device? get_device(){
		
		return Device.get_device_by_uuid(device_uuid);
	}
	
	public bool exists_on_disk{
		get {
			return dir_exists(path);
		}
	}

	public bool is_system_subvolume{
		get {
			return (repo == null);
		}
	}
	
	public static Gee.HashMap<string, Subvolume> detect_subvolumes_for_system_by_path(
		string system_path, SnapshotRepo? repo, Gtk.Window? parent_window){

		var map = new Gee.HashMap<string, Subvolume>();
		
		log_debug("Searching subvolume for system at path: %s".printf(system_path));
		
		var fstab = FsTabEntry.read_file(path_combine(system_path, "/etc/fstab"));
		var crypttab = CryptTabEntry.read_file(path_combine(system_path, "/etc/crypttab"));
		
		foreach(var item in fstab){
			
			if (!item.is_for_system_directory()){ continue; }
			
			if (item.subvolume_name().length > 0){
				
				var dev = item.resolve_device(crypttab, parent_window);
				var dev_name = (dev == null) ? "" : dev.device;
				var dev_uuid = (dev == null) ? "" : dev.uuid;
				
				log_debug("Found subvolume: %s, on device: %s".printf(item.subvolume_name(), dev_name));
				
				var subvol = new Subvolume(item.subvolume_name(), item.mount_point, dev_uuid, repo);
				map.set(subvol.name, subvol);
			}
		}

		return map;
	}

	public void print_info(){
		
		log_debug("name=%s, uuid=%s, id=%ld, path=%s".printf(name, device_uuid, id, path));
	}

	// actions ----------------------------------
	
	public bool remove(){

		if (is_system_subvolume){
			if (name == App.root_subvolume_name){
				path = path_combine(App.mount_point_app + "/backup", App.root_subvolume_name);
			}
			else if (name == App.home_subvolume_name){
				path = path_combine(App.mount_point_app + "/backup-home", App.home_subvolume_name);
			}
		}
		
		string cmd = "";
		string std_out, std_err, subpath;
		int ret_val;

		if (!dir_exists(path)){ return true; } // ok, item does not exist

		log_msg("%s: %s (Id:%ld)".printf(_("Deleting subvolume"), name, id));

		// always remove subvolumes recursively, this does not affect performance
		string options = App.use_option_raw ? "--commit-after" : "";

        if (Main.btrfs_version__can_recursive_delete) {
            options += " --recursive";
        }

		subpath = path_combine(path, name);
		if (dir_exists(subpath)) { // possible nested subvolume present, verify before deleting
			int rc_show = exec_sync("btrfs subvolume show '%s'".printf(subpath), out std_out, out std_err);
			if (rc_show == 0) {
				// confirmed nested btrfs subvolume, delete it first
				cmd = "btrfs subvolume delete %s '%s'".printf(options, subpath);
				log_debug("Deleting nested subvolume in snapshot");
				log_debug(cmd);
				ret_val = exec_sync(cmd, out std_out, out std_err);
				if (ret_val != 0){
					log_error(std_err);
					log_error(_("Failed to delete snapshot nested subvolume") + ": '%s'".printf(subpath));
					return false;
				}
			} else {
				// path exists but is not a btrfs subvolume, skip nested removal
				log_debug("Nested path exists but is not a btrfs subvolume, skipping: %s".printf(subpath));
			}
		}
		
		cmd = "btrfs subvolume delete %s '%s'".printf(options, path);
		log_debug(cmd);
		ret_val = exec_sync(cmd, out std_out, out std_err);
		if (ret_val != 0){
			log_error(std_err);
			log_error(_("Failed to delete snapshot subvolume") + ": '%s'".printf(path));
			return false;
		}

		log_msg("%s: %s (Id:%ld)\n".printf(_("Deleted subvolume"), name, id));

		if (App.btrfs_qgroups_enabled) {
			if ((id > 0) && (repo != null)){

				log_debug("Waiting on btrfs to finish deleting...");
				while (exec_sync("btrfs subvolume sync %s".printf(mount_path), out std_out, out std_err) != 0) {
					log_debug("Still waiting for btrfs to finish deleting... %s".printf(std_err));
					sleep(1000);
				}

                log_debug("Rescanning quotas...");
                while (exec_sync("btrfs quota rescan %s".printf(mount_path), out std_out, out std_err) != 0) {
                    log_debug("Still rescanning quotas... %s".printf(std_err));
                    sleep(1000);
                }

				// Check if qgroup still exists before trying to destroy it.
				// The qgroup may have been auto-destroyed when the subvolume was deleted.
				string qgroup_id = "0/%ld".printf(id);
				cmd = "btrfs qgroup show -f '%s'".printf(repo.mount_paths[name]);
				log_debug(cmd);
				ret_val = exec_sync(cmd, out std_out, out std_err);

				bool qgroup_exists = (ret_val == 0) && (std_out.contains(qgroup_id));

				if (!qgroup_exists) {
					log_debug("Qgroup %s already removed (auto-destroyed with subvolume)".printf(qgroup_id));
				} else {
					log_msg("%s: %s".printf(_("Destroying qgroup"), qgroup_id));

					cmd = "btrfs qgroup destroy %s '%s'".printf(qgroup_id, repo.mount_paths[name]);
					log_debug(cmd);
					ret_val = exec_sync(cmd, out std_out, out std_err);
					if (ret_val != 0){
						// Qgroup may have been destroyed between our check and destroy attempt
						log_debug("Qgroup %s could not be destroyed (likely already removed): %s".printf(qgroup_id, std_err));
					} else {
						log_msg("%s: %s\n".printf(_("Destroyed qgroup"), qgroup_id));
					}
				}

                log_debug("Rescanning quotas (post)...");
                while (exec_sync("btrfs quota rescan %s".printf(mount_path), out std_out, out std_err) != 0) {
                    log_debug("Still rescanning quotas (post)... %s".printf(std_err));
                    sleep(1000);
                }

                log_debug("Final sync (post)...");
                while (exec_sync("btrfs subvolume sync %s".printf(mount_path), out std_out, out std_err) != 0) {
                    log_debug("Still syncing (post)... %s".printf(std_err));
                    sleep(1000);
                }

			}
		}

		return true;
	}

	public bool restore(){

		if (is_system_subvolume) { return false; }

		// restore snapshot subvolume by creating new subvolume snapshots ----------------------
		
		string src_path = path;
		string dst_path = path_combine(mount_path, name);

		if (!dir_exists(src_path)){
			log_error("%s: %s".printf(_("Not Found"), src_path));
			return false;
		}

		if (dir_exists(dst_path)){
			log_error("%s: %s".printf(_("Subvolume exists at destination"), dst_path));
			return false;
		}
		
		string cmd = "btrfs subvolume snapshot '%s' '%s'".printf(src_path, dst_path);
		log_debug(cmd);

		string std_out, std_err;
		int status = exec_sync(cmd, out std_out, out std_err);
		
		if (status != 0){
			log_error(std_err);
			log_error(_("btrfs returned an error") + ": %d".printf(status));
			log_error(_("Failed to restore system subvolume") + ": %s".printf(name));
			return false;
		}

		log_msg(_("Restored system subvolume") + ": %s".printf(name));
		
		return true;
	}
}