|
|
@@ -0,0 +1,1375 @@
|
|
|
+# Fix incorrect adopt implementation with dry-run support
|
|
|
+def adopt(config, snapshot, dry_run=False, simulate=False):
|
|
|
+ try:
|
|
|
+ current_root_path = os.path.join(config['snapshot']['btrfs_mount_point'], config['snapshot']['root_subvolume'])
|
|
|
+ snapshot_path = os.path.join(config['snapshot']['snapshot_dir'], snapshot)
|
|
|
+
|
|
|
+ if not os.path.exists(snapshot_path) and not (dry_run or simulate):
|
|
|
+ logger.error(f"Snapshot '{snapshot}' not found at {snapshot_path}")
|
|
|
+ print(f"Error: Snapshot '{snapshot}' not found.")
|
|
|
+ return False
|
|
|
+
|
|
|
+ # Check if we're on a live system (not booted into the snapshot)
|
|
|
+ if not (dry_run or simulate):
|
|
|
+ with open("/proc/cmdline", "r") as f:
|
|
|
+ cmdline = f.read()
|
|
|
+ if snapshot in cmdline:
|
|
|
+ logger.warning(f"You are already booted into snapshot {snapshot}.")
|
|
|
+ print(f"Warning: You are already booted into snapshot {snapshot}. No changes needed.")
|
|
|
+ return False
|
|
|
+
|
|
|
+ # Create a backup of current root first before making changes
|
|
|
+ backup_name = f"@_backup_{datetime.now().strftime('%Y%m%d-%H%M%S')}"
|
|
|
+ backup_path = os.path.join(config['snapshot']['btrfs_mount_point'], backup_name)
|
|
|
+
|
|
|
+ print(f"{'[SIMULATE] ' if simulate else ''}{'[DRY-RUN] ' if dry_run else ''}Creating backup of current root subvolume as {backup_name}")
|
|
|
+ logger.info(f"Creating backup of current root at {backup_path}")
|
|
|
+
|
|
|
+ # Create a snapshot of the current root
|
|
|
+ cmd_backup = ["btrfs", "subvolume", "snapshot", current_root_path, backup_path]
|
|
|
+ returncode, stdout, stderr = safe_execute(
|
|
|
+ cmd_backup,
|
|
|
+ dry_run=dry_run,
|
|
|
+ simulate=simulate,
|
|
|
+ description="Creating backup of current root"
|
|
|
+ )
|
|
|
+
|
|
|
+ if returncode != 0 and not (dry_run or simulate):
|
|
|
+ logger.error(f"Failed to create backup: {stderr}")
|
|
|
+ print(f"Error: Failed to create backup: {stderr}")
|
|
|
+ return False
|
|
|
+
|
|
|
+ # Delete current root subvolume
|
|
|
+ print(f"{'[SIMULATE] ' if simulate else ''}{'[DRY-RUN] ' if dry_run else ''}Deleting current root subvolume")
|
|
|
+ logger.info(f"Deleting current root subvolume at {current_root_path}")
|
|
|
+ cmd_delete = ["btrfs", "subvolume", "delete", current_root_path]
|
|
|
+ returncode, stdout, stderr = safe_execute(
|
|
|
+ cmd_delete,
|
|
|
+ dry_run=dry_run,
|
|
|
+ simulate=simulate,
|
|
|
+ description="Deleting current root subvolume"
|
|
|
+ )
|
|
|
+
|
|
|
+ if returncode != 0 and not (dry_run or simulate):
|
|
|
+ logger.error(f"Failed to delete current root: {stderr}")
|
|
|
+ print(f"Error: Failed to delete current root: {stderr}")
|
|
|
+ return False
|
|
|
+
|
|
|
+ # Create a new snapshot of the selected snapshot as the new root subvolume
|
|
|
+ print(f"{'[SIMULATE] ' if simulate else ''}{'[DRY-RUN] ' if dry_run else ''}Creating new root subvolume from snapshot '{snapshot}'")
|
|
|
+ logger.info(f"Creating new root from {snapshot_path} to {current_root_path}")
|
|
|
+ cmd_new_root = ["btrfs", "subvolume", "snapshot", snapshot_path, current_root_path]
|
|
|
+ returncode, stdout, stderr = safe_execute(
|
|
|
+ cmd_new_root,
|
|
|
+ dry_run=dry_run,
|
|
|
+ simulate=simulate,
|
|
|
+ description=f"Creating new root subvolume from snapshot '{snapshot# Safe command execution with dry-run support
|
|
|
+def safe_execute(cmd, dry_run=False, simulate=False, description=None):
|
|
|
+ """
|
|
|
+ Execute a command safely with dry-run and simulation support.
|
|
|
+
|
|
|
+ Args:
|
|
|
+ cmd: Command list to execute
|
|
|
+ dry_run: If True, just print the command without executing
|
|
|
+ simulate: If True, log as if executed but don't actually execute
|
|
|
+ description: Optional description of what the command does
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ A tuple of (return_code, stdout, stderr) or (0, '', '') if dry_run/simulate
|
|
|
+ """
|
|
|
+ cmd_str = ' '.join(cmd)
|
|
|
+
|
|
|
+ if description:
|
|
|
+ logger.info(f"{description}: {cmd_str}")
|
|
|
+ if dry_run or simulate:
|
|
|
+ print(f"WOULD EXECUTE: {description}")
|
|
|
+ print(f" $ {cmd_str}")
|
|
|
+ else:
|
|
|
+ logger.info(f"Would execute: {cmd_str}")
|
|
|
+ if dry_run or simulate:
|
|
|
+ print(f"WOULD EXECUTE: {cmd_str}")
|
|
|
+
|
|
|
+ if dry_run or simulate:
|
|
|
+ # Return success for dry run or simulate
|
|
|
+ return 0, '', ''
|
|
|
+ else:
|
|
|
+ # Actually execute the command
|
|
|
+ result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
|
+ return result.returncode, result.stdout.decode(), result.stderr.decode()
|
|
|
+
|
|
|
+# Safe file operations with dry-run support
|
|
|
+def safe_write_file(file_path, content, dry_run=False, simulate=False, description=None):
|
|
|
+ """
|
|
|
+ Write to a file with dry-run and simulation support.
|
|
|
+
|
|
|
+ Args:
|
|
|
+ file_path: Path to the file
|
|
|
+ content: Content to write
|
|
|
+ dry_run: If True, just print what would be written
|
|
|
+ simulate: If True, log as if written but don't actually write
|
|
|
+ description: Optional description of the write operation
|
|
|
+ """
|
|
|
+ if description:
|
|
|
+ logger.info(f"{description}: {file_path}")
|
|
|
+ if dry_run or simulate:
|
|
|
+ print(f"WOULD WRITE: {description}")
|
|
|
+ print(f" To file: {file_path}")
|
|
|
+ print(f" Content length: {len(content)} bytes")
|
|
|
+ if len(content) < 1000:
|
|
|
+ print(f" Content preview:\n{'-'*40}\n{content[:500]}\n{'-'*40}")
|
|
|
+ else:
|
|
|
+ print(f" Content preview (first 500 bytes):\n{'-'*40}\n{content[:500]}...\n{'-'*40}")
|
|
|
+ else:
|
|
|
+ logger.info(f"Would write to: {file_path}")
|
|
|
+ if dry_run or simulate:
|
|
|
+ print(f"WOULD WRITE TO: {file_path}")
|
|
|
+
|
|
|
+ if not (dry_run or simulate):
|
|
|
+ # Create directory if it doesn't exist
|
|
|
+ os.makedirs(os.path.dirname(file_path), exist_ok=True)
|
|
|
+ # Actually write the file
|
|
|
+ with open(file_path, 'w') as f:
|
|
|
+ f.write(content)
|
|
|
+
|
|
|
+# Apply test directory to paths if specified
|
|
|
+def adjust_path(config, path, test_dir=None):
|
|
|
+ """
|
|
|
+ Adjust a path with a test directory if specified.
|
|
|
+
|
|
|
+ Args:
|
|
|
+ config: Configuration dictionary
|
|
|
+ path: Original path
|
|
|
+ test_dir: Test directory to prepend (if not None)
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ Adjusted path
|
|
|
+ """
|
|
|
+ if test_dir is None:
|
|
|
+ return path
|
|
|
+
|
|
|
+ # For absolute paths, replace with test directory
|
|
|
+ if path.startswith('/'):
|
|
|
+ return os.path.join(test_dir, path[1:])
|
|
|
+ return path#!/usr/bin/env python3
|
|
|
+
|
|
|
+import os
|
|
|
+import sys
|
|
|
+import subprocess
|
|
|
+import toml
|
|
|
+import argparse
|
|
|
+import logging
|
|
|
+from datetime import datetime
|
|
|
+import shutil
|
|
|
+
|
|
|
+# Path to the configuration file
|
|
|
+CONFIG_PATH = "/etc/snap-slack/config.toml"
|
|
|
+LOG_PATH = "/var/log/snap-slack.log"
|
|
|
+
|
|
|
+# Set up logging
|
|
|
+logging.basicConfig(
|
|
|
+ level=logging.INFO,
|
|
|
+ format='%(asctime)s - %(levelname)s - %(message)s',
|
|
|
+ handlers=[
|
|
|
+ logging.FileHandler(LOG_PATH),
|
|
|
+ logging.StreamHandler()
|
|
|
+ ]
|
|
|
+)
|
|
|
+logger = logging.getLogger('snap-slack')
|
|
|
+
|
|
|
+# Read configuration from a TOML file with test dir support
|
|
|
+def read_config(file_path=CONFIG_PATH, test_dir=None):
|
|
|
+ if not os.path.exists(file_path):
|
|
|
+ logger.error(f"Configuration file not found: {file_path}")
|
|
|
+ raise FileNotFoundError(f"Configuration file not found: {file_path}")
|
|
|
+
|
|
|
+ try:
|
|
|
+ with open(file_path, 'r') as f:
|
|
|
+ config = toml.load(f)
|
|
|
+
|
|
|
+ # Validate essential config entries
|
|
|
+ required_fields = {
|
|
|
+ 'snapshot': ['snapshot_dir', 'snapshot_prefix', 'btrfs_mount_point', 'root_subvolume', 'retention_days'],
|
|
|
+ }
|
|
|
+
|
|
|
+ if config.get('bootloader', {}).get('type', 'elilo').lower() == 'elilo':
|
|
|
+ required_fields['elilo'] = ['elilo_conf', 'root_partition']
|
|
|
+ else:
|
|
|
+ required_fields['grub'] = ['config_file', 'root_partition']
|
|
|
+
|
|
|
+ for section, fields in required_fields.items():
|
|
|
+ if section not in config:
|
|
|
+ raise ValueError(f"Missing required section '{section}' in config file")
|
|
|
+
|
|
|
+ for field in fields:
|
|
|
+ if field not in config[section]:
|
|
|
+ raise ValueError(f"Missing required field '{field}' in section '{section}'")
|
|
|
+
|
|
|
+ # If test_dir is specified, adjust paths in the config
|
|
|
+ if test_dir:
|
|
|
+ logger.info(f"Using test directory: {test_dir}")
|
|
|
+ print(f"Using test directory: {test_dir}")
|
|
|
+
|
|
|
+ # Adjust snapshot paths
|
|
|
+ config['snapshot']['snapshot_dir'] = adjust_path(config, config['snapshot']['snapshot_dir'], test_dir)
|
|
|
+ config['snapshot']['btrfs_mount_point'] = adjust_path(config, config['snapshot']['btrfs_mount_point'], test_dir)
|
|
|
+
|
|
|
+ # Adjust bootloader paths
|
|
|
+ if 'elilo' in config:
|
|
|
+ config['elilo']['elilo_conf'] = adjust_path(config, config['elilo']['elilo_conf'], test_dir)
|
|
|
+
|
|
|
+ if 'grub' in config:
|
|
|
+ if 'config_file' in config['grub']:
|
|
|
+ config['grub']['config_file'] = adjust_path(config, config['grub']['config_file'], test_dir)
|
|
|
+ if 'custom_entries_file' in config['grub']:
|
|
|
+ config['grub']['custom_entries_file'] = adjust_path(config, config['grub']['custom_entries_file'], test_dir)
|
|
|
+
|
|
|
+ # Adjust boot paths
|
|
|
+ if 'boot' in config and 'boot_dir' in config['boot']:
|
|
|
+ config['boot']['boot_dir'] = adjust_path(config, config['boot']['boot_dir'], test_dir)
|
|
|
+
|
|
|
+ # Add test_dir to config for reference
|
|
|
+ config['_test_dir'] = test_dir
|
|
|
+
|
|
|
+ return config
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Error reading config: {str(e)}")
|
|
|
+ raise
|
|
|
+
|
|
|
+# Create a new snapshot with the current date and time
|
|
|
+def create_snapshot(config, dry_run=False, simulate=False, description=None):
|
|
|
+ try:
|
|
|
+ date_str = datetime.now().strftime("%Y%m%d-%H%M%S")
|
|
|
+
|
|
|
+ # Add description to snapshot name if provided
|
|
|
+ if description:
|
|
|
+ # Clean up description for use in filename
|
|
|
+ clean_desc = description.replace(" ", "-")
|
|
|
+ clean_desc = re.sub(r'[^a-zA-Z0-9\-_]', '', clean_desc)
|
|
|
+ snapshot_name = f"{config['snapshot']['snapshot_prefix']}{date_str}-{clean_desc}"
|
|
|
+ else:
|
|
|
+ snapshot_name = f"{config['snapshot']['snapshot_prefix']}{date_str}"
|
|
|
+
|
|
|
+ snapshot_path = os.path.join(config['snapshot']['snapshot_dir'], snapshot_name)
|
|
|
+
|
|
|
+ # Ensure snapshot directory exists
|
|
|
+ if not (dry_run or simulate):
|
|
|
+ os.makedirs(config['snapshot']['snapshot_dir'], exist_ok=True)
|
|
|
+
|
|
|
+ # Run the Btrfs snapshot command
|
|
|
+ root_path = os.path.join(config['snapshot']['btrfs_mount_point'], config['snapshot']['root_subvolume'])
|
|
|
+ if not os.path.exists(root_path) and not (dry_run or simulate):
|
|
|
+ logger.error(f"Root subvolume path does not exist: {root_path}")
|
|
|
+ return None
|
|
|
+
|
|
|
+ # Check if encryption is enabled
|
|
|
+ is_encrypted = config.get('encryption', {}).get('enabled', False)
|
|
|
+
|
|
|
+ # If hibernation is enabled, we need a read-write snapshot
|
|
|
+ # otherwise, create a read-only snapshot
|
|
|
+ hibernation_enabled = config.get('hibernation', {}).get('enabled', False)
|
|
|
+ snapshot_readonly = not hibernation_enabled
|
|
|
+
|
|
|
+ # Command for creating snapshot
|
|
|
+ cmd = ["btrfs", "subvolume", "snapshot"]
|
|
|
+ if snapshot_readonly:
|
|
|
+ cmd.append("-r") # read-only flag
|
|
|
+ cmd.extend([root_path, snapshot_path])
|
|
|
+
|
|
|
+ # Execute the command with safety measures
|
|
|
+ returncode, stdout, stderr = safe_execute(
|
|
|
+ cmd,
|
|
|
+ dry_run=dry_run,
|
|
|
+ simulate=simulate,
|
|
|
+ description=f"Creating {'read-only' if snapshot_readonly else 'read-write'} snapshot{' with description: ' + description if description else ''}"
|
|
|
+ )
|
|
|
+
|
|
|
+ if returncode == 0:
|
|
|
+ logger.info(f"Created snapshot: {snapshot_name}")
|
|
|
+ print(f"{'[SIMULATE] ' if simulate else ''}{'[DRY-RUN] ' if dry_run else ''}Created snapshot: {snapshot_name}")
|
|
|
+
|
|
|
+ # For encrypted systems with hibernation, update the initramfs
|
|
|
+ if is_encrypted and hibernation_enabled:
|
|
|
+ update_initramfs_for_encryption(config, snapshot_name, snapshot_path, dry_run=dry_run, simulate=simulate)
|
|
|
+
|
|
|
+ add_boot_entry(config, snapshot_name, dry_run=dry_run, simulate=simulate)
|
|
|
+ return snapshot_name
|
|
|
+ else:
|
|
|
+ error_msg = stderr
|
|
|
+ logger.error(f"Failed to create snapshot: {error_msg}")
|
|
|
+ print(f"Failed to create snapshot: {error_msg}")
|
|
|
+ return None
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Error creating snapshot: {str(e)}")
|
|
|
+ print(f"Error creating snapshot: {str(e)}")
|
|
|
+ return None
|
|
|
+
|
|
|
+# Update initramfs for encrypted volume with hibernation
|
|
|
+def update_initramfs_for_encryption(config, snapshot_name, snapshot_path):
|
|
|
+ try:
|
|
|
+ logger.info(f"Updating initramfs for encrypted system with hibernation support")
|
|
|
+ print(f"Updating initramfs for encrypted system with hibernation support...")
|
|
|
+
|
|
|
+ # Get initramfs generation tool from config
|
|
|
+ initramfs_tool = config.get('encryption', {}).get('initramfs_tool', 'mkinitrd')
|
|
|
+
|
|
|
+ # Get location to put the new initramfs file
|
|
|
+ initramfs_dir = config.get('encryption', {}).get('initramfs_dir', '/boot')
|
|
|
+
|
|
|
+ # New initramfs filename with snapshot identifier
|
|
|
+ initramfs_file = f"initrd-{snapshot_name}.gz"
|
|
|
+ initramfs_path = os.path.join(initramfs_dir, initramfs_file)
|
|
|
+
|
|
|
+ # Get kernel version
|
|
|
+ kernel_version = get_current_kernel_version(config)
|
|
|
+ if not kernel_version:
|
|
|
+ logger.error("Failed to determine kernel version")
|
|
|
+ raise Exception("Failed to determine kernel version")
|
|
|
+
|
|
|
+ # Get LUKS UUID for the root device
|
|
|
+ luks_uuid = get_luks_uuid(config)
|
|
|
+ if not luks_uuid:
|
|
|
+ logger.error("Failed to determine LUKS UUID")
|
|
|
+ raise Exception("Failed to determine LUKS UUID")
|
|
|
+
|
|
|
+ # Generate initramfs command based on tool
|
|
|
+ if initramfs_tool == "mkinitrd":
|
|
|
+ # For mkinitrd (Slackware's default)
|
|
|
+ resume_device = config.get('hibernation', {}).get('resume_device', '')
|
|
|
+ luks_name = config.get('encryption', {}).get('luks_name', 'cryptroot')
|
|
|
+
|
|
|
+ # Create mkinitrd config file for this snapshot
|
|
|
+ mkinitrd_conf = f"/etc/mkinitrd.conf.{snapshot_name}"
|
|
|
+
|
|
|
+ with open("/etc/mkinitrd.conf", "r") as f:
|
|
|
+ mkinitrd_content = f.read()
|
|
|
+
|
|
|
+ # Update paths for the snapshot
|
|
|
+ mkinitrd_content = mkinitrd_content.replace(
|
|
|
+ f"ROOT_DEVICE=",
|
|
|
+ f"ROOT_DEVICE=/dev/mapper/{luks_name}\n# Original: ")
|
|
|
+
|
|
|
+ # Add the LUKS options if not present
|
|
|
+ if "LUKSDEV=" not in mkinitrd_content:
|
|
|
+ mkinitrd_content += f"\n# Added by snap-slack\nLUKSDEV=UUID={luks_uuid}\n"
|
|
|
+
|
|
|
+ # Add the resume device if not present and hibernation is enabled
|
|
|
+ if resume_device and "RESUMEDEV=" not in mkinitrd_content:
|
|
|
+ mkinitrd_content += f"RESUMEDEV={resume_device}\n"
|
|
|
+
|
|
|
+ # Add rootflags for the snapshot
|
|
|
+ if "ROOTFLAGS=" not in mkinitrd_content:
|
|
|
+ mkinitrd_content += f"ROOTFLAGS=subvol={config['snapshot']['snapshot_dir']}/{snapshot_name}\n"
|
|
|
+ else:
|
|
|
+ # Replace existing rootflags
|
|
|
+ mkinitrd_content = re.sub(
|
|
|
+ r'ROOTFLAGS=.*',
|
|
|
+ f'ROOTFLAGS=subvol={config["snapshot"]["snapshot_dir"]}/{snapshot_name}',
|
|
|
+ mkinitrd_content)
|
|
|
+
|
|
|
+ # Write the custom config
|
|
|
+ with open(mkinitrd_conf, "w") as f:
|
|
|
+ f.write(mkinitrd_content)
|
|
|
+
|
|
|
+ # Build the mkinitrd command
|
|
|
+ cmd = [
|
|
|
+ "mkinitrd",
|
|
|
+ "-F", # force
|
|
|
+ "-c", mkinitrd_conf, # use custom config
|
|
|
+ "-o", initramfs_path,
|
|
|
+ "-k", kernel_version
|
|
|
+ ]
|
|
|
+
|
|
|
+ elif initramfs_tool == "dracut":
|
|
|
+ # For dracut
|
|
|
+ resume_device = config.get('hibernation', {}).get('resume_device', '')
|
|
|
+
|
|
|
+ cmd = [
|
|
|
+ "dracut",
|
|
|
+ "--force", # force
|
|
|
+ "--kver", kernel_version, # kernel version
|
|
|
+ "-f", initramfs_path, # output file
|
|
|
+ ]
|
|
|
+
|
|
|
+ # Add LUKS and resume parameters
|
|
|
+ dracut_modules = "crypt"
|
|
|
+ if resume_device:
|
|
|
+ dracut_modules += " resume"
|
|
|
+
|
|
|
+ cmd.extend([
|
|
|
+ "--add", dracut_modules,
|
|
|
+ "--persistent-policy", "by-uuid"
|
|
|
+ ])
|
|
|
+
|
|
|
+ # Add kernel command line parameters
|
|
|
+ kernel_cmdline = f"rd.luks.uuid={luks_uuid} root=/dev/mapper/cryptroot rootflags=subvol={config['snapshot']['snapshot_dir']}/{snapshot_name}"
|
|
|
+ if resume_device:
|
|
|
+ kernel_cmdline += f" resume={resume_device}"
|
|
|
+
|
|
|
+ cmd.extend(["--kernel-cmdline", kernel_cmdline])
|
|
|
+
|
|
|
+ else:
|
|
|
+ logger.error(f"Unsupported initramfs generation tool: {initramfs_tool}")
|
|
|
+ raise Exception(f"Unsupported initramfs generation tool: {initramfs_tool}")
|
|
|
+
|
|
|
+ # Execute the command
|
|
|
+ logger.info(f"Running command: {' '.join(cmd)}")
|
|
|
+ print(f"Generating custom initramfs for encrypted system...")
|
|
|
+
|
|
|
+ result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
|
+
|
|
|
+ if result.returncode == 0:
|
|
|
+ logger.info(f"Successfully created custom initramfs at {initramfs_path}")
|
|
|
+ print(f"Successfully created custom initramfs at {initramfs_path}")
|
|
|
+
|
|
|
+ # Update the config with the custom initramfs location
|
|
|
+ config['encryption']['custom_initramfs'] = initramfs_file
|
|
|
+ return True
|
|
|
+ else:
|
|
|
+ error_msg = result.stderr.decode()
|
|
|
+ logger.error(f"Failed to create custom initramfs: {error_msg}")
|
|
|
+ print(f"Failed to create custom initramfs: {error_msg}")
|
|
|
+ return False
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Error updating initramfs: {str(e)}")
|
|
|
+ print(f"Error updating initramfs: {str(e)}")
|
|
|
+ return False
|
|
|
+
|
|
|
+# Get LUKS UUID for encrypted device
|
|
|
+def get_luks_uuid(config):
|
|
|
+ try:
|
|
|
+ # Try to get UUID from config first
|
|
|
+ uuid = config.get('encryption', {}).get('luks_uuid', '')
|
|
|
+ if uuid:
|
|
|
+ return uuid
|
|
|
+
|
|
|
+ # If not in config, try to determine it
|
|
|
+ luks_device = config.get('encryption', {}).get('luks_device', '')
|
|
|
+ if not luks_device:
|
|
|
+ # Try to find it automatically
|
|
|
+ cmd = ["blkid", "-t", "TYPE=crypto_LUKS", "-o", "device"]
|
|
|
+ result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
|
+
|
|
|
+ if result.returncode == 0:
|
|
|
+ devices = result.stdout.decode().strip().split('\n')
|
|
|
+ if devices and devices[0]:
|
|
|
+ luks_device = devices[0]
|
|
|
+
|
|
|
+ if luks_device:
|
|
|
+ # Get UUID of the LUKS device
|
|
|
+ cmd = ["blkid", "-s", "UUID", "-o", "value", luks_device]
|
|
|
+ result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
|
+
|
|
|
+ if result.returncode == 0:
|
|
|
+ uuid = result.stdout.decode().strip()
|
|
|
+ return uuid
|
|
|
+
|
|
|
+ return None
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Error getting LUKS UUID: {str(e)}")
|
|
|
+ return None
|
|
|
+
|
|
|
+# Get current kernel version
|
|
|
+def get_current_kernel_version(config):
|
|
|
+ try:
|
|
|
+ # Try to get from config first
|
|
|
+ kernel_version = config.get('boot', {}).get('kernel_version', '')
|
|
|
+ if kernel_version:
|
|
|
+ return kernel_version
|
|
|
+
|
|
|
+ # Try to determine from running system
|
|
|
+ if os.path.exists("/proc/version"):
|
|
|
+ with open("/proc/version", "r") as f:
|
|
|
+ version_info = f.read()
|
|
|
+ match = re.search(r'Linux version ([0-9.-]+\S+)', version_info)
|
|
|
+ if match:
|
|
|
+ return match.group(1)
|
|
|
+
|
|
|
+ # Fallback to uname
|
|
|
+ result = subprocess.run(["uname", "-r"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
|
+ if result.returncode == 0:
|
|
|
+ return result.stdout.decode().strip()
|
|
|
+
|
|
|
+ return None
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Error determining kernel version: {str(e)}")
|
|
|
+ return None
|
|
|
+
|
|
|
+# Add a boot entry for a snapshot
|
|
|
+def add_boot_entry(config, snapshot, dry_run=False, simulate=False):
|
|
|
+ try:
|
|
|
+ # Determine the bootloader type from config
|
|
|
+ bootloader = config.get('bootloader', {}).get('type', 'elilo').lower()
|
|
|
+
|
|
|
+ if bootloader == 'grub':
|
|
|
+ return add_grub_entry(config, snapshot, dry_run=dry_run, simulate=simulate)
|
|
|
+ else:
|
|
|
+ return add_elilo_entry(config, snapshot, dry_run=dry_run, simulate=simulate)
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Error adding boot entry: {str(e)}")
|
|
|
+ print(f"Error adding boot entry: {str(e)}")
|
|
|
+ return False
|
|
|
+
|
|
|
+# Add an entry for the snapshot in elilo.conf
|
|
|
+def add_elilo_entry(config, snapshot, dry_run=False, simulate=False):
|
|
|
+ try:
|
|
|
+ # Get the extra boot options from the config, if any
|
|
|
+ extra_boot_options = config.get('elilo', {}).get('extra_boot_options', '')
|
|
|
+
|
|
|
+ # Check if encryption is enabled
|
|
|
+ is_encrypted = config.get('encryption', {}).get('enabled', False)
|
|
|
+ hibernation_enabled = config.get('hibernation', {}).get('enabled', False)
|
|
|
+
|
|
|
+ # Determine initrd file to use
|
|
|
+ initrd_file = "initrd.gz" # Default
|
|
|
+
|
|
|
+ if is_encrypted and hibernation_enabled:
|
|
|
+ # Use the custom initramfs for encrypted systems with hibernation
|
|
|
+ custom_initramfs = config.get('encryption', {}).get('custom_initramfs', '')
|
|
|
+ if custom_initramfs:
|
|
|
+ initrd_file = custom_initramfs
|
|
|
+
|
|
|
+ # Construct the boot entry with optional extra boot options
|
|
|
+ entry = f"""
|
|
|
+image=vmlinuz
|
|
|
+ label={snapshot}
|
|
|
+ root={config['elilo']['root_partition']}
|
|
|
+"""
|
|
|
+
|
|
|
+ # Add proper boot parameters based on encryption status
|
|
|
+ if is_encrypted:
|
|
|
+ luks_uuid = get_luks_uuid(config)
|
|
|
+ luks_name = config.get('encryption', {}).get('luks_name', 'cryptroot')
|
|
|
+
|
|
|
+ # For encrypted systems
|
|
|
+ entry += f" append=\"rd.luks.uuid={luks_uuid} root=/dev/mapper/{luks_name} rootflags=subvol={config['snapshot']['snapshot_dir']}/{snapshot} ro"
|
|
|
+
|
|
|
+ # Add resume device for hibernation if enabled
|
|
|
+ if hibernation_enabled:
|
|
|
+ resume_device = config.get('hibernation', {}).get('resume_device', '')
|
|
|
+ if resume_device:
|
|
|
+ entry += f" resume={resume_device}"
|
|
|
+
|
|
|
+ # Add any extra boot options
|
|
|
+ if extra_boot_options:
|
|
|
+ entry += f" {extra_boot_options}"
|
|
|
+
|
|
|
+ entry += "\"\n"
|
|
|
+ else:
|
|
|
+ # For non-encrypted systems
|
|
|
+ entry += f" append=\"rootflags=subvol={config['snapshot']['snapshot_dir']}/{snapshot} ro {extra_boot_options}\"\n"
|
|
|
+
|
|
|
+ entry += " read-only\n"
|
|
|
+ entry += f" initrd={initrd_file}\n"
|
|
|
+
|
|
|
+ # Append to elilo.conf if the entry doesn't already exist
|
|
|
+ elilo_conf = config['elilo']['elilo_conf']
|
|
|
+
|
|
|
+ # Create the file if it doesn't exist
|
|
|
+ if not os.path.exists(elilo_conf) and not (dry_run or simulate):
|
|
|
+ # Ensure elilo.conf directory exists
|
|
|
+ os.makedirs(os.path.dirname(elilo_conf), exist_ok=True)
|
|
|
+ with open(elilo_conf, 'w') as f:
|
|
|
+ f.write("# ELILO Configuration File\n")
|
|
|
+
|
|
|
+ # Check if the entry already exists (in simulation or dry-run mode, assume it doesn't)
|
|
|
+ entry_exists = False
|
|
|
+ if not (dry_run or simulate) and os.path.exists(elilo_conf):
|
|
|
+ with open(elilo_conf, 'r') as f:
|
|
|
+ content = f.read()
|
|
|
+ if snapshot in content:
|
|
|
+ entry_exists = True
|
|
|
+ logger.info(f"Entry for snapshot {snapshot} already exists in elilo.conf")
|
|
|
+ print(f"Entry for snapshot {snapshot} already exists in elilo.conf")
|
|
|
+ return False
|
|
|
+
|
|
|
+ if not entry_exists:
|
|
|
+ # Add the entry using safe file operations
|
|
|
+ description = f"Adding entry for snapshot {snapshot} to elilo.conf"
|
|
|
+
|
|
|
+ if not (dry_run or simulate):
|
|
|
+ with open(elilo_conf, 'a+') as f:
|
|
|
+ f.write(entry)
|
|
|
+
|
|
|
+ logger.info(description)
|
|
|
+ if dry_run or simulate:
|
|
|
+ print(f"{'[SIMULATE] ' if simulate else ''}{'[DRY-RUN] ' if dry_run else ''}{description}")
|
|
|
+ print(f"WOULD APPEND TO {elilo_conf}:")
|
|
|
+ print(f"{'-'*40}\n{entry}\n{'-'*40}")
|
|
|
+ else:
|
|
|
+ print(f"Added entry for snapshot: {snapshot}")
|
|
|
+
|
|
|
+ return True
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Error adding elilo entry: {str(e)}")
|
|
|
+ print(f"Error adding elilo entry: {str(e)}")
|
|
|
+ return False
|
|
|
+
|
|
|
+# Add an entry for the snapshot in grub.cfg or custom config
|
|
|
+def add_grub_entry(config, snapshot):
|
|
|
+ try:
|
|
|
+ # Get boot options
|
|
|
+ extra_boot_options = config.get('grub', {}).get('extra_boot_options', '')
|
|
|
+
|
|
|
+ # Get GRUB configuration details
|
|
|
+ grub_custom_file = config.get('grub', {}).get('custom_entries_file', '/etc/grub.d/60_snap-slack')
|
|
|
+ kernel_path = config.get('grub', {}).get('kernel_path', '/boot/vmlinuz')
|
|
|
+ initrd_path = config.get('grub', {}).get('initrd_path', '/boot/initrd.gz')
|
|
|
+ root_partition = config.get('grub', {}).get('root_partition', '/dev/sdaX')
|
|
|
+
|
|
|
+ # Create the GRUB menu entry
|
|
|
+ grub_entry = f"""
|
|
|
+# Entry for snapshot {snapshot}
|
|
|
+menuentry "Slackware - {snapshot}" {{
|
|
|
+ linux {kernel_path} root={root_partition} rootflags=subvol={config['snapshot']['snapshot_dir']}/{snapshot} ro {extra_boot_options}
|
|
|
+ initrd {initrd_path}
|
|
|
+}}
|
|
|
+"""
|
|
|
+
|
|
|
+ # Determine if we're using a custom file or directly modifying grub.cfg
|
|
|
+ if config.get('grub', {}).get('use_custom_file', True):
|
|
|
+ # Using a custom file in /etc/grub.d/
|
|
|
+ # Check if directory exists
|
|
|
+ os.makedirs(os.path.dirname(grub_custom_file), exist_ok=True)
|
|
|
+
|
|
|
+ # Create or update the custom file
|
|
|
+ snapshot_entries = {}
|
|
|
+ if os.path.exists(grub_custom_file):
|
|
|
+ with open(grub_custom_file, 'r') as f:
|
|
|
+ content = f.read()
|
|
|
+
|
|
|
+ # Parse existing entries
|
|
|
+ import re
|
|
|
+ entries = re.findall(r'menuentry "Slackware - (snapshot-[^"]+)"', content)
|
|
|
+ for entry in entries:
|
|
|
+ snapshot_entries[entry] = True
|
|
|
+
|
|
|
+ # If the snapshot is not already in the file
|
|
|
+ if snapshot not in snapshot_entries:
|
|
|
+ with open(grub_custom_file, 'a+') as f:
|
|
|
+ if os.path.getsize(grub_custom_file) == 0:
|
|
|
+ f.write("#!/bin/sh\n")
|
|
|
+ f.write("exec tail -n +3 $0\n\n")
|
|
|
+ f.write("# This file was generated by snap-slack\n\n")
|
|
|
+ f.write("cat << EOF\n")
|
|
|
+ f.write(grub_entry)
|
|
|
+ if not content.endswith("EOF\n"):
|
|
|
+ f.write("EOF\n")
|
|
|
+
|
|
|
+ # Make the file executable
|
|
|
+ os.chmod(grub_custom_file, 0o755)
|
|
|
+
|
|
|
+ # Update GRUB configuration
|
|
|
+ logger.info(f"Updating GRUB configuration")
|
|
|
+ if os.path.exists("/usr/sbin/update-grub"):
|
|
|
+ cmd = ["update-grub"]
|
|
|
+ else:
|
|
|
+ cmd = ["grub-mkconfig", "-o", config.get('grub', {}).get('config_file', '/boot/grub/grub.cfg')]
|
|
|
+
|
|
|
+ result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
|
+ if result.returncode != 0:
|
|
|
+ logger.warning(f"GRUB update command failed: {result.stderr.decode()}")
|
|
|
+ logger.warning("You may need to manually update your GRUB configuration.")
|
|
|
+ print("Warning: GRUB configuration update failed. You may need to run 'update-grub' or 'grub-mkconfig' manually.")
|
|
|
+
|
|
|
+ logger.info(f"Added GRUB entry for snapshot: {snapshot}")
|
|
|
+ return True
|
|
|
+ else:
|
|
|
+ logger.info(f"GRUB entry for snapshot {snapshot} already exists")
|
|
|
+ return False
|
|
|
+ else:
|
|
|
+ # Directly modify grub.cfg (not recommended but supported)
|
|
|
+ grub_cfg = config.get('grub', {}).get('config_file', '/boot/grub/grub.cfg')
|
|
|
+
|
|
|
+ if not os.path.exists(grub_cfg):
|
|
|
+ logger.warning(f"GRUB config file not found at {grub_cfg}")
|
|
|
+ return False
|
|
|
+
|
|
|
+ with open(grub_cfg, 'r') as f:
|
|
|
+ content = f.read()
|
|
|
+
|
|
|
+ if f"Slackware - {snapshot}" not in content:
|
|
|
+ # Find the last menuentry
|
|
|
+ last_entry_pos = content.rfind("menuentry ")
|
|
|
+ if last_entry_pos == -1:
|
|
|
+ # No menuentry found, append to end
|
|
|
+ with open(grub_cfg, 'a') as f:
|
|
|
+ f.write(grub_entry)
|
|
|
+ else:
|
|
|
+ # Find the end of the last menuentry
|
|
|
+ bracket_count = 0
|
|
|
+ for i in range(last_entry_pos, len(content)):
|
|
|
+ if content[i] == '{':
|
|
|
+ bracket_count += 1
|
|
|
+ elif content[i] == '}':
|
|
|
+ bracket_count -= 1
|
|
|
+ if bracket_count == 0:
|
|
|
+ # Insert after the last menuentry
|
|
|
+ new_content = content[:i+1] + grub_entry + content[i+1:]
|
|
|
+ with open(grub_cfg, 'w') as f:
|
|
|
+ f.write(new_content)
|
|
|
+ break
|
|
|
+
|
|
|
+ logger.info(f"Added GRUB entry for snapshot: {snapshot}")
|
|
|
+ return True
|
|
|
+ else:
|
|
|
+ logger.info(f"GRUB entry for snapshot {snapshot} already exists")
|
|
|
+ return False
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Error adding GRUB entry: {str(e)}")
|
|
|
+ raise
|
|
|
+
|
|
|
+# Remove a boot entry for a deleted snapshot
|
|
|
+def remove_boot_entry(config, snapshot):
|
|
|
+ try:
|
|
|
+ # Determine the bootloader type from config
|
|
|
+ bootloader = config.get('bootloader', {}).get('type', 'elilo').lower()
|
|
|
+
|
|
|
+ if bootloader == 'grub':
|
|
|
+ return remove_grub_entry(config, snapshot)
|
|
|
+ else:
|
|
|
+ return remove_elilo_entry(config, snapshot)
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Error removing boot entry: {str(e)}")
|
|
|
+ raise
|
|
|
+
|
|
|
+# Remove an entry for a deleted snapshot from elilo.conf
|
|
|
+def remove_elilo_entry(config, snapshot):
|
|
|
+ try:
|
|
|
+ elilo_conf = config['elilo']['elilo_conf']
|
|
|
+ if not os.path.exists(elilo_conf):
|
|
|
+ logger.warning(f"elilo.conf not found at {elilo_conf}")
|
|
|
+ return
|
|
|
+
|
|
|
+ with open(elilo_conf, 'r') as f:
|
|
|
+ lines = f.readlines()
|
|
|
+
|
|
|
+ found = False
|
|
|
+ with open(elilo_conf, 'w') as f:
|
|
|
+ for line in lines:
|
|
|
+ if f"label={snapshot}" in line:
|
|
|
+ found = True
|
|
|
+ continue
|
|
|
+ if found and (line.strip() == "" or line.startswith("image=")):
|
|
|
+ found = False
|
|
|
+ if not found:
|
|
|
+ f.write(line)
|
|
|
+
|
|
|
+ logger.info(f"Removed entry for snapshot: {snapshot}")
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Error removing elilo entry: {str(e)}")
|
|
|
+ raise
|
|
|
+
|
|
|
+# Remove an entry for a deleted snapshot from grub configuration
|
|
|
+def remove_grub_entry(config, snapshot):
|
|
|
+ try:
|
|
|
+ # If using custom file
|
|
|
+ if config.get('grub', {}).get('use_custom_file', True):
|
|
|
+ grub_custom_file = config.get('grub', {}).get('custom_entries_file', '/etc/grub.d/60_snap-slack')
|
|
|
+
|
|
|
+ if not os.path.exists(grub_custom_file):
|
|
|
+ logger.warning(f"GRUB custom file not found at {grub_custom_file}")
|
|
|
+ return
|
|
|
+
|
|
|
+ with open(grub_custom_file, 'r') as f:
|
|
|
+ lines = f.readlines()
|
|
|
+
|
|
|
+ # Find and remove the menuentry block
|
|
|
+ new_lines = []
|
|
|
+ skip_mode = False
|
|
|
+ bracket_count = 0
|
|
|
+
|
|
|
+ for line in lines:
|
|
|
+ if f'menuentry "Slackware - {snapshot}"' in line:
|
|
|
+ skip_mode = True
|
|
|
+ bracket_count = 0
|
|
|
+
|
|
|
+ if skip_mode:
|
|
|
+ if '{' in line:
|
|
|
+ bracket_count += line.count('{')
|
|
|
+ if '}' in line:
|
|
|
+ bracket_count -= line.count('}')
|
|
|
+ if bracket_count <= 0:
|
|
|
+ skip_mode = False
|
|
|
+ continue
|
|
|
+
|
|
|
+ new_lines.append(line)
|
|
|
+
|
|
|
+ # Write the modified content back
|
|
|
+ with open(grub_custom_file, 'w') as f:
|
|
|
+ f.writelines(new_lines)
|
|
|
+
|
|
|
+ # Update GRUB configuration
|
|
|
+ logger.info(f"Updating GRUB configuration")
|
|
|
+ if os.path.exists("/usr/sbin/update-grub"):
|
|
|
+ cmd = ["update-grub"]
|
|
|
+ else:
|
|
|
+ cmd = ["grub-mkconfig", "-o", config.get('grub', {}).get('config_file', '/boot/grub/grub.cfg')]
|
|
|
+
|
|
|
+ result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
|
+ if result.returncode != 0:
|
|
|
+ logger.warning(f"GRUB update command failed: {result.stderr.decode()}")
|
|
|
+ logger.warning("You may need to manually update your GRUB configuration.")
|
|
|
+ print("Warning: GRUB configuration update failed. You may need to run 'update-grub' or 'grub-mkconfig' manually.")
|
|
|
+ else:
|
|
|
+ # Direct modification of grub.cfg (not recommended)
|
|
|
+ grub_cfg = config.get('grub', {}).get('config_file', '/boot/grub/grub.cfg')
|
|
|
+
|
|
|
+ if not os.path.exists(grub_cfg):
|
|
|
+ logger.warning(f"GRUB config file not found at {grub_cfg}")
|
|
|
+ return
|
|
|
+
|
|
|
+ with open(grub_cfg, 'r') as f:
|
|
|
+ content = f.read()
|
|
|
+
|
|
|
+ # Find and remove the menuentry block
|
|
|
+ import re
|
|
|
+ pattern = re.compile(f'menuentry\s+"Slackware - {snapshot}"\s+{{.*?}}', re.DOTALL)
|
|
|
+ new_content = pattern.sub('', content)
|
|
|
+
|
|
|
+ with open(grub_cfg, 'w') as f:
|
|
|
+ f.write(new_content)
|
|
|
+
|
|
|
+ logger.info(f"Removed GRUB entry for snapshot: {snapshot}")
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Error removing GRUB entry: {str(e)}")
|
|
|
+ raise
|
|
|
+
|
|
|
+# List all current snapshots
|
|
|
+def list_snapshots(config):
|
|
|
+ try:
|
|
|
+ snapshots = []
|
|
|
+ snapshot_dir = config['snapshot']['snapshot_dir']
|
|
|
+
|
|
|
+ if not os.path.exists(snapshot_dir):
|
|
|
+ logger.warning(f"Snapshot directory does not exist: {snapshot_dir}")
|
|
|
+ return snapshots
|
|
|
+
|
|
|
+ for entry in os.listdir(snapshot_dir):
|
|
|
+ entry_path = os.path.join(snapshot_dir, entry)
|
|
|
+ if os.path.isdir(entry_path) and entry.startswith(config['snapshot']['snapshot_prefix']):
|
|
|
+ snapshots.append(entry)
|
|
|
+ return sorted(snapshots)
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Error listing snapshots: {str(e)}")
|
|
|
+ raise
|
|
|
+
|
|
|
+# Display snapshots with details
|
|
|
+def display_snapshots(config):
|
|
|
+ try:
|
|
|
+ snapshots = list_snapshots(config)
|
|
|
+
|
|
|
+ if not snapshots:
|
|
|
+ print("No snapshots found.")
|
|
|
+ return
|
|
|
+
|
|
|
+ print("\nAvailable snapshots:")
|
|
|
+ print("-" * 80)
|
|
|
+ print("{:<30} {:<20} {:<10}".format("Snapshot Name", "Created Date", "Age (days)"))
|
|
|
+ print("-" * 80)
|
|
|
+
|
|
|
+ now = datetime.now()
|
|
|
+
|
|
|
+ for snapshot in snapshots:
|
|
|
+ snapshot_path = os.path.join(config['snapshot']['snapshot_dir'], snapshot)
|
|
|
+ created_time = datetime.fromtimestamp(os.path.getctime(snapshot_path))
|
|
|
+ age_days = (now - created_time).days
|
|
|
+
|
|
|
+ created_date = created_time.strftime("%Y-%m-%d %H:%M:%S")
|
|
|
+ print("{:<30} {:<20} {:<10}".format(snapshot, created_date, age_days))
|
|
|
+
|
|
|
+ print("-" * 80)
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Error displaying snapshots: {str(e)}")
|
|
|
+ print(f"Error: {str(e)}")
|
|
|
+
|
|
|
+# Remove snapshots older than the retention period
|
|
|
+def remove_old_snapshots(config):
|
|
|
+ try:
|
|
|
+ retention_days = config['snapshot']['retention_days']
|
|
|
+ now = datetime.now()
|
|
|
+ removed_count = 0
|
|
|
+
|
|
|
+ for snapshot in list_snapshots(config):
|
|
|
+ snapshot_path = os.path.join(config['snapshot']['snapshot_dir'], snapshot)
|
|
|
+ created_time = datetime.fromtimestamp(os.path.getctime(snapshot_path))
|
|
|
+ if (now - created_time).days > retention_days:
|
|
|
+ # Remove snapshot
|
|
|
+ cmd = ["btrfs", "subvolume", "delete", snapshot_path]
|
|
|
+ logger.info(f"Running command: {' '.join(cmd)}")
|
|
|
+ result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
|
+
|
|
|
+ if result.returncode == 0:
|
|
|
+ remove_boot_entry(config, snapshot)
|
|
|
+ logger.info(f"Removed snapshot: {snapshot}")
|
|
|
+ removed_count += 1
|
|
|
+ else:
|
|
|
+ logger.error(f"Failed to remove snapshot {snapshot}: {result.stderr.decode()}")
|
|
|
+
|
|
|
+ return removed_count
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Error removing old snapshots: {str(e)}")
|
|
|
+ raise
|
|
|
+
|
|
|
+# Fix incorrect adopt implementation
|
|
|
+def adopt(config, snapshot):
|
|
|
+ try:
|
|
|
+ current_root_path = os.path.join(config['snapshot']['btrfs_mount_point'], config['snapshot']['root_subvolume'])
|
|
|
+ snapshot_path = os.path.join(config['snapshot']['snapshot_dir'], snapshot)
|
|
|
+
|
|
|
+ if not os.path.exists(snapshot_path):
|
|
|
+ logger.error(f"Snapshot '{snapshot}' not found at {snapshot_path}")
|
|
|
+ raise Exception(f"Snapshot '{snapshot}' not found.")
|
|
|
+
|
|
|
+ # Check if we're on a live system (not booted into the snapshot)
|
|
|
+ with open("/proc/cmdline", "r") as f:
|
|
|
+ cmdline = f.read()
|
|
|
+ if snapshot in cmdline:
|
|
|
+ logger.warning(f"You are already booted into snapshot {snapshot}.")
|
|
|
+ print(f"Warning: You are already booted into snapshot {snapshot}. No changes needed.")
|
|
|
+ return
|
|
|
+
|
|
|
+ # Create a backup of current root first before making changes
|
|
|
+ backup_name = f"@_backup_{datetime.now().strftime('%Y%m%d-%H%M%S')}"
|
|
|
+ backup_path = os.path.join(config['snapshot']['btrfs_mount_point'], backup_name)
|
|
|
+
|
|
|
+ print(f"Creating backup of current root subvolume as {backup_name}")
|
|
|
+ logger.info(f"Creating backup of current root at {backup_path}")
|
|
|
+
|
|
|
+ # Create a snapshot of the current root
|
|
|
+ cmd_backup = ["btrfs", "subvolume", "snapshot", current_root_path, backup_path]
|
|
|
+ logger.info(f"Running command: {' '.join(cmd_backup)}")
|
|
|
+ result = subprocess.run(cmd_backup, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
|
+
|
|
|
+ if result.returncode != 0:
|
|
|
+ logger.error(f"Failed to create backup: {result.stderr.decode()}")
|
|
|
+ raise Exception(f"Failed to create backup: {result.stderr.decode()}")
|
|
|
+
|
|
|
+ # Delete current root subvolume
|
|
|
+ print(f"Deleting current root subvolume")
|
|
|
+ logger.info(f"Deleting current root subvolume at {current_root_path}")
|
|
|
+ cmd_delete = ["btrfs", "subvolume", "delete", current_root_path]
|
|
|
+ logger.info(f"Running command: {' '.join(cmd_delete)}")
|
|
|
+ result = subprocess.run(cmd_delete, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
|
+
|
|
|
+ if result.returncode != 0:
|
|
|
+ logger.error(f"Failed to delete current root: {result.stderr.decode()}")
|
|
|
+ raise Exception(f"Failed to delete current root: {result.stderr.decode()}")
|
|
|
+
|
|
|
+ # Create a new snapshot of the selected snapshot as the new root subvolume
|
|
|
+ print(f"Creating new root subvolume from snapshot '{snapshot}'")
|
|
|
+ logger.info(f"Creating new root from {snapshot_path} to {current_root_path}")
|
|
|
+ cmd_new_root = ["btrfs", "subvolume", "snapshot", snapshot_path, current_root_path]
|
|
|
+ logger.info(f"Running command: {' '.join(cmd_new_root)}")
|
|
|
+ result = subprocess.run(cmd_new_root, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
|
+
|
|
|
+ if result.returncode != 0:
|
|
|
+ logger.error(f"Failed to create new root: {result.stderr.decode()}")
|
|
|
+ # Try to recover from backup
|
|
|
+ print("Error occurred. Attempting to recover from backup...")
|
|
|
+ try:
|
|
|
+ if os.path.exists(backup_path):
|
|
|
+ recovery_cmd = ["btrfs", "subvolume", "snapshot", backup_path, current_root_path]
|
|
|
+ subprocess.run(recovery_cmd, check=True)
|
|
|
+ print("Recovery successful.")
|
|
|
+ logger.info("Recovered from backup after failed adopt operation")
|
|
|
+ except Exception as recovery_error:
|
|
|
+ logger.critical(f"Failed to recover from backup: {str(recovery_error)}")
|
|
|
+ raise Exception(f"Failed to create new root: {result.stderr.decode()}")
|
|
|
+
|
|
|
+ print("\n" + "=" * 80)
|
|
|
+ print(f"SUCCESS: Snapshot '{snapshot}' has been adopted as the new root subvolume.")
|
|
|
+ print("=" * 80)
|
|
|
+ print("\nTo use this snapshot, you need to:")
|
|
|
+ print("1. Reboot your system")
|
|
|
+ print("2. In the bootloader menu, select your regular Slackware entry (not the snapshot entry)")
|
|
|
+ print("3. The system will now boot with the adopted snapshot as the root filesystem")
|
|
|
+ print("\nIf you encounter issues, you can:")
|
|
|
+ print(f"- Boot into the backup snapshot '{backup_name}' (emergency only)")
|
|
|
+ print(f"- Or boot into any other available snapshot from the bootloader menu")
|
|
|
+ print("=" * 80)
|
|
|
+
|
|
|
+ logger.info(f"Successfully adopted snapshot '{snapshot}' as new root subvolume")
|
|
|
+
|
|
|
+ # Note: We don't need to update elilo.conf for the adopted snapshot since it's now the root
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Error adopting snapshot: {str(e)}")
|
|
|
+ print(f"Error: {str(e)}")
|
|
|
+ print("\nYour system may be in an inconsistent state. Please verify the root subvolume.")
|
|
|
+ sys.exit(1)
|
|
|
+
|
|
|
+# Create a live bootable image from a snapshot
|
|
|
+def create_boot_image(config, snapshot):
|
|
|
+ try:
|
|
|
+ snapshot_path = os.path.join(config['snapshot']['snapshot_dir'], snapshot)
|
|
|
+ if not os.path.exists(snapshot_path):
|
|
|
+ logger.error(f"Snapshot '{snapshot}' not found.")
|
|
|
+ raise Exception(f"Snapshot '{snapshot}' not found.")
|
|
|
+
|
|
|
+ bootdir = config.get('boot', {}).get('boot_dir', '/boot')
|
|
|
+ if not os.path.exists(bootdir):
|
|
|
+ logger.error(f"Boot directory not found: {bootdir}")
|
|
|
+ raise Exception(f"Boot directory not found: {bootdir}")
|
|
|
+
|
|
|
+ # Create a custom initrd that boots directly into the snapshot
|
|
|
+ # This is a simplified example - actual implementation would depend on
|
|
|
+ # how Slackware builds initrd images
|
|
|
+
|
|
|
+ print(f"Creating bootable image for snapshot '{snapshot}'...")
|
|
|
+ logger.info(f"Creating bootable image for snapshot '{snapshot}'")
|
|
|
+
|
|
|
+ # Ensure the snapshot entry exists in elilo.conf
|
|
|
+ add_elilo_entry(config, snapshot)
|
|
|
+
|
|
|
+ print("\n" + "=" * 80)
|
|
|
+ print(f"SUCCESS: Boot entry for snapshot '{snapshot}' is configured.")
|
|
|
+ print("=" * 80)
|
|
|
+ print("\nTo boot into this snapshot:")
|
|
|
+ print("1. Reboot your system")
|
|
|
+ print("2. In the ELILO boot menu, select the entry labeled:")
|
|
|
+ print(f" {snapshot}")
|
|
|
+ print("\nNOTE: This will boot into the snapshot in read-only mode.")
|
|
|
+ print(" To make it permanent, use 'snap-slack adopt --snapshot' after testing.")
|
|
|
+ print("=" * 80)
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Error creating boot image: {str(e)}")
|
|
|
+ print(f"Error: {str(e)}")
|
|
|
+
|
|
|
+# Main logic for managing snapshots
|
|
|
+def manage(config):
|
|
|
+ try:
|
|
|
+ # Step 1: Create snapshot directory if it doesn't exist
|
|
|
+ os.makedirs(config['snapshot']['snapshot_dir'], exist_ok=True)
|
|
|
+
|
|
|
+ # Step 2: Get list of current snapshots and add them to elilo.conf if needed
|
|
|
+ print("Checking existing snapshots...")
|
|
|
+ snapshots = list_snapshots(config)
|
|
|
+ for snapshot in snapshots:
|
|
|
+ add_elilo_entry(config, snapshot)
|
|
|
+
|
|
|
+ # Step 3: Remove snapshots older than retention period
|
|
|
+ print("Checking for old snapshots to remove...")
|
|
|
+ removed = remove_old_snapshots(config)
|
|
|
+ if removed > 0:
|
|
|
+ print(f"Removed {removed} old snapshots.")
|
|
|
+ else:
|
|
|
+ print("No old snapshots to remove.")
|
|
|
+
|
|
|
+ print("\nSnapshot management completed successfully.")
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Error managing snapshots: {str(e)}")
|
|
|
+ print(f"Error: {str(e)}")
|
|
|
+
|
|
|
+# Verify system configuration
|
|
|
+def verify_system(config):
|
|
|
+ try:
|
|
|
+ issues = []
|
|
|
+
|
|
|
+ # Check if btrfs is installed
|
|
|
+ result = subprocess.run(["which", "btrfs"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
|
+ if result.returncode != 0:
|
|
|
+ issues.append("BTRFS tools not found. Please install btrfs-progs package.")
|
|
|
+
|
|
|
+ # Check if root filesystem is btrfs
|
|
|
+ result = subprocess.run(["findmnt", "-no", "FSTYPE", "/"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
|
+ if "btrfs" not in result.stdout.decode().strip():
|
|
|
+ issues.append("Root filesystem is not BTRFS. snap-slack requires a BTRFS root filesystem.")
|
|
|
+
|
|
|
+ # Check if elilo.conf exists or can be created
|
|
|
+ elilo_conf = config['elilo']['elilo_conf']
|
|
|
+ if not os.path.exists(elilo_conf):
|
|
|
+ if not os.path.exists(os.path.dirname(elilo_conf)):
|
|
|
+ issues.append(f"ELILO config directory not found: {os.path.dirname(elilo_conf)}")
|
|
|
+
|
|
|
+ # Check if snapshot directory exists or can be created
|
|
|
+ snapshot_dir = config['snapshot']['snapshot_dir']
|
|
|
+ if not os.path.exists(snapshot_dir):
|
|
|
+ try:
|
|
|
+ os.makedirs(snapshot_dir, exist_ok=True)
|
|
|
+ except Exception:
|
|
|
+ issues.append(f"Cannot create snapshot directory: {snapshot_dir}")
|
|
|
+
|
|
|
+ # Check if root subvolume exists
|
|
|
+ root_path = os.path.join(config['snapshot']['btrfs_mount_point'], config['snapshot']['root_subvolume'])
|
|
|
+ if not os.path.exists(root_path):
|
|
|
+ issues.append(f"Root subvolume not found: {root_path}")
|
|
|
+
|
|
|
+ if issues:
|
|
|
+ print("\nSystem verification found issues:")
|
|
|
+ for i, issue in enumerate(issues, 1):
|
|
|
+ print(f"{i}. {issue}")
|
|
|
+ return False
|
|
|
+ else:
|
|
|
+ print("System verification passed. Your system is properly configured for snap-slack.")
|
|
|
+ return True
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Error verifying system: {str(e)}")
|
|
|
+ print(f"Error verifying system: {str(e)}")
|
|
|
+ return False
|
|
|
+
|
|
|
+# Parse command-line arguments
|
|
|
+def parse_arguments():
|
|
|
+ parser = argparse.ArgumentParser(
|
|
|
+ description='Manage BTRFS snapshots and bootloader entries.',
|
|
|
+ formatter_class=argparse.RawDescriptionHelpFormatter,
|
|
|
+ epilog="""
|
|
|
+Examples:
|
|
|
+ snap-slack create Create a new snapshot
|
|
|
+ snap-slack create --description "pre-update" Create snapshot with description
|
|
|
+ snap-slack list List all available snapshots
|
|
|
+ snap-slack manage Manage existing snapshots
|
|
|
+ snap-slack boot --snapshot X Set up specific snapshot for booting
|
|
|
+ snap-slack adopt --snapshot X Adopt a snapshot as the new root filesystem
|
|
|
+ snap-slack verify Verify system configuration
|
|
|
+ """
|
|
|
+ )
|
|
|
+
|
|
|
+ # Global options
|
|
|
+ parser.add_argument('--dry-run', action='store_true', help='Show what would be done without actually doing it')
|
|
|
+ parser.add_argument('--test-dir', help='Use a test directory instead of the real root')
|
|
|
+ parser.add_argument('--config', help=f'Path to config file (default: {CONFIG_PATH})')
|
|
|
+ parser.add_argument('--verbose', '-v', action='store_true', help='Enable verbose output')
|
|
|
+ parser.add_argument('--simulate', action='store_true', help='Simulate operations (for safe testing)')
|
|
|
+
|
|
|
+ subparsers = parser.add_subparsers(dest='action', help='Action to perform')
|
|
|
+
|
|
|
+ # Create command
|
|
|
+ create_parser = subparsers.add_parser('create', help='Create a new snapshot')
|
|
|
+ create_parser.add_argument('--description', help='Optional description for the snapshot')
|
|
|
+
|
|
|
+ # List command
|
|
|
+ list_parser = subparsers.add_parser('list', help='List all snapshots')
|
|
|
+
|
|
|
+ # Manage command
|
|
|
+ manage_parser = subparsers.add_parser('manage', help='Manage snapshots (clean up old ones, update bootloader config)')
|
|
|
+
|
|
|
+ # Boot command
|
|
|
+ boot_parser = subparsers.add_parser('boot', help='Configure a snapshot for booting')
|
|
|
+ boot_parser.add_argument('--snapshot', required=True, help='The snapshot to configure for booting')
|
|
|
+
|
|
|
+ # Adopt command
|
|
|
+ adopt_parser = subparsers.add_parser('adopt', help='Adopt a snapshot as the new root subvolume')
|
|
|
+ adopt_parser.add_argument('--snapshot', required=True, help='The snapshot to adopt as the new root subvolume')
|
|
|
+
|
|
|
+ # Verify command
|
|
|
+ verify_parser = subparsers.add_parser('verify', help='Verify system configuration')
|
|
|
+
|
|
|
+ return parser.parse_args()
|
|
|
+
|
|
|
+def main():
|
|
|
+ try:
|
|
|
+ # Parse command-line arguments
|
|
|
+ args = parse_arguments()
|
|
|
+
|
|
|
+ if not args.action:
|
|
|
+ print("Error: No action specified. Use --help for usage information.")
|
|
|
+ sys.exit(1)
|
|
|
+
|
|
|
+ # Set logging level based on verbosity
|
|
|
+ if args.verbose:
|
|
|
+ logger.setLevel(logging.DEBUG)
|
|
|
+
|
|
|
+ # Load configuration
|
|
|
+ config_path = args.config if args.config else CONFIG_PATH
|
|
|
+ config = read_config(config_path, args.test_dir)
|
|
|
+
|
|
|
+ # Execute based on action
|
|
|
+ if args.action == 'create':
|
|
|
+ snapshot = create_snapshot(
|
|
|
+ config,
|
|
|
+ dry_run=args.dry_run,
|
|
|
+ simulate=args.simulate,
|
|
|
+ description=args.description if hasattr(args, 'description') else None
|
|
|
+ )
|
|
|
+ if snapshot:
|
|
|
+ print(f"{'[SIMULATE] ' if args.simulate else ''}{'[DRY-RUN] ' if args.dry_run else ''}Created snapshot: {snapshot}")
|
|
|
+ print(f"To boot from this snapshot, use: snap-slack boot --snapshot {snapshot}")
|
|
|
+ elif args.action == 'list':
|
|
|
+ display_snapshots(config)
|
|
|
+ elif args.action == 'manage':
|
|
|
+ manage(config, dry_run=args.dry_run, simulate=args.simulate)
|
|
|
+ elif args.action == 'boot':
|
|
|
+ create_boot_image(config, args.snapshot, dry_run=args.dry_run, simulate=args.simulate)
|
|
|
+ elif args.action == 'adopt':
|
|
|
+ adopt(config, args.snapshot, dry_run=args.dry_run, simulate=args.simulate)
|
|
|
+ elif args.action == 'verify':
|
|
|
+ verify_system(config)
|
|
|
+ elif args.action == 'install-hooks':
|
|
|
+ install_slackpkg_hooks(config, dry_run=args.dry_run, simulate=args.simulate)
|
|
|
+ else:
|
|
|
+ print(f"Invalid action: {args.action}")
|
|
|
+ sys.exit(1)
|
|
|
+
|
|
|
+ except KeyboardInterrupt:
|
|
|
+ print("\nOperation cancelled by user.")
|
|
|
+ sys.exit(130)
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Unhandled exception: {str(e)}")
|
|
|
+ print(f"Error: {str(e)}")
|
|
|
+ sys.exit(1)
|
|
|
+
|
|
|
+# Install SlackPkg hooks
|
|
|
+def install_slackpkg_hooks(config, dry_run=False, simulate=False):
|
|
|
+ hooks_script = os.path.join(os.path.dirname(os.path.abspath(__file__)), "install-hooks.sh")
|
|
|
+
|
|
|
+ if os.path.exists(hooks_script):
|
|
|
+ # Execute the hook installation script
|
|
|
+ cmd = ["bash", hooks_script]
|
|
|
+ returncode, stdout, stderr = safe_execute(
|
|
|
+ cmd,
|
|
|
+ dry_run=dry_run,
|
|
|
+ simulate=simulate,
|
|
|
+ description="Installing SlackPkg hooks"
|
|
|
+ )
|
|
|
+
|
|
|
+ if returncode != 0 and not (dry_run or simulate):
|
|
|
+ print(f"Error installing hooks: {stderr}")
|
|
|
+ return False
|
|
|
+
|
|
|
+ return True
|
|
|
+ else:
|
|
|
+ # Generate the hooks in-place
|
|
|
+ hooks_dir = "/etc/slackpkg/hooks"
|
|
|
+ pre_hook = os.path.join(hooks_dir, "pre-install.sh")
|
|
|
+ post_hook = os.path.join(hooks_dir, "post-install.sh")
|
|
|
+
|
|
|
+ # Create hooks directory
|
|
|
+ if not os.path.exists(hooks_dir) and not (dry_run or simulate):
|
|
|
+ try:
|
|
|
+ os.makedirs(hooks_dir, exist_ok=True)
|
|
|
+ except Exception as e:
|
|
|
+ print(f"Error creating hooks directory: {str(e)}")
|
|
|
+ return False
|
|
|
+
|
|
|
+ # Pre-install hook content
|
|
|
+ pre_hook_content = """#!/bin/bash
|
|
|
+# SlackPkg Pre-install Hook for snap-slack
|
|
|
+# This file was automatically installed by snap-slack
|
|
|
+
|
|
|
+# Configuration
|
|
|
+SNAP_SLACK=/usr/bin/snap-slack
|
|
|
+ENABLE_AUTO_SNAPSHOTS=1 # Set to 0 to disable automatic snapshots
|
|
|
+MAX_PACKAGE_COUNT=100 # Maximum number of packages to include in snapshot name
|
|
|
+
|
|
|
+# Check if snap-slack is installed
|
|
|
+if [ ! -x "$SNAP_SLACK" ]; then
|
|
|
+ echo "WARNING: snap-slack not found at $SNAP_SLACK, skipping pre-install snapshot"
|
|
|
+ exit 0
|
|
|
+fi
|
|
|
+
|
|
|
+# Check if auto snapshots are enabled
|
|
|
+if [ "$ENABLE_AUTO_SNAPSHOTS" != "1" ]; then
|
|
|
+ echo "INFO: Automatic snapshots are disabled in slackpkg hook"
|
|
|
+ exit 0
|
|
|
+fi
|
|
|
+
|
|
|
+# Function to create a snapshot
|
|
|
+create_snapshot() {
|
|
|
+ local desc="$1"
|
|
|
+ echo "Creating snapshot before package operations: $desc"
|
|
|
+ $SNAP_SLACK create --description "$desc"
|
|
|
+}
|
|
|
+
|
|
|
+# Get the operation being performed
|
|
|
+OPERATION="$1"
|
|
|
+shift
|
|
|
+PACKAGES="$@"
|
|
|
+
|
|
|
+# Create appropriate snapshot based on operation
|
|
|
+case "$OPERATION" in
|
|
|
+ upgrade-all)
|
|
|
+ create_snapshot "pre-upgrade-all"
|
|
|
+ ;;
|
|
|
+ install|upgrade)
|
|
|
+ # Limit the number of packages in the snapshot name for readability
|
|
|
+ if [ "$(echo $PACKAGES | wc -w)" -gt $MAX_PACKAGE_COUNT ]; then
|
|
|
+ PKG_COUNT=$(echo $PACKAGES | wc -w)
|
|
|
+ create_snapshot "pre-$OPERATION-$PKG_COUNT-packages"
|
|
|
+ else
|
|
|
+ create_snapshot "pre-$OPERATION-$(echo $PACKAGES | tr ' ' '-')"
|
|
|
+ fi
|
|
|
+ ;;
|
|
|
+ remove)
|
|
|
+ if [ "$(echo $PACKAGES | wc -w)" -gt $MAX_PACKAGE_COUNT ]; then
|
|
|
+ PKG_COUNT=$(echo $PACKAGES | wc -w)
|
|
|
+ create_snapshot "pre-remove-$PKG_COUNT-packages"
|
|
|
+ else
|
|
|
+ create_snapshot "pre-remove-$(echo $PACKAGES | tr ' ' '-')"
|
|
|
+ fi
|
|
|
+ ;;
|
|
|
+ *)
|
|
|
+ # For other operations, create a generic snapshot
|
|
|
+ create_snapshot "pre-slackpkg-operation"
|
|
|
+ ;;
|
|
|
+esac
|
|
|
+
|
|
|
+exit 0
|
|
|
+"""
|
|
|
+ # Post-install hook content
|
|
|
+ post_hook_content = """#!/bin/bash
|
|
|
+# SlackPkg Post-install Hook for snap-slack
|
|
|
+# This file was automatically installed by snap-slack
|
|
|
+
|
|
|
+# Configuration
|
|
|
+SNAP_SLACK=/usr/bin/snap-slack
|
|
|
+AUTO_CLEANUP=1 # Set to 0 to disable automatic snapshot cleanup
|
|
|
+
|
|
|
+# Check if snap-slack is installed
|
|
|
+if [ ! -x "$SNAP_SLACK" ]; then
|
|
|
+ echo "WARNING: snap-slack not found at $SNAP_SLACK, skipping post-install operations"
|
|
|
+ exit 0
|
|
|
+fi
|
|
|
+
|
|
|
+# Check if auto cleanup is enabled
|
|
|
+if [ "$AUTO_CLEANUP" = "1" ]; then
|
|
|
+ echo "Running snapshot management to clean up old snapshots"
|
|
|
+ $SNAP_SLACK manage
|
|
|
+fi
|
|
|
+
|
|
|
+# Log the successful completion
|
|
|
+echo "Package operation completed successfully."
|
|
|
+echo "If you encounter issues, you can rollback using:"
|
|
|
+echo " snap-slack list # to see available snapshots"
|
|
|
+echo " snap-slack adopt --snapshot <snapshot-name> # to rollback"
|
|
|
+
|
|
|
+exit 0
|
|
|
+"""
|
|
|
+ # Write the pre-install hook
|
|
|
+ safe_write_file(
|
|
|
+ pre_hook,
|
|
|
+ pre_hook_content,
|
|
|
+ dry_run=dry_run,
|
|
|
+ simulate=simulate,
|
|
|
+ description="Creating pre-install hook"
|
|
|
+ )
|
|
|
+
|
|
|
+ # Write the post-install hook
|
|
|
+ safe_write_file(
|
|
|
+ post_hook,
|
|
|
+ post_hook_content,
|
|
|
+ dry_run=dry_run,
|
|
|
+ simulate=simulate,
|
|
|
+ description="Creating post-install hook"
|
|
|
+ )
|
|
|
+
|
|
|
+ # Make hooks executable
|
|
|
+ if not (dry_run or simulate):
|
|
|
+ try:
|
|
|
+ os.chmod(pre_hook, 0o755)
|
|
|
+ os.chmod(post_hook, 0o755)
|
|
|
+ except Exception as e:
|
|
|
+ print(f"Error setting permissions on hooks: {str(e)}")
|
|
|
+ return False
|
|
|
+
|
|
|
+ print("SlackPkg hooks installed successfully.")
|
|
|
+ print("The hooks will create snapshots before package operations and clean up old snapshots afterward.")
|
|
|
+ print("To disable automatic snapshots, edit /etc/slackpkg/hooks/pre-install.sh and set ENABLE_AUTO_SNAPSHOTS=0")
|
|
|
+ print("To disable automatic cleanup, edit /etc/slackpkg/hooks/post-install.sh and set AUTO_CLEANUP=0")
|
|
|
+
|
|
|
+ return True
|
|
|
+
|
|
|
+if __name__ == "__main__":
|
|
|
+ main()
|
Bernardo Magri