dwipe 1.0.7__py3-none-any.whl → 2.0.0__py3-none-any.whl

dwipe/PersistentState.py

@@ -0,0 +1,195 @@
+"""
+PersistentState class for saving user preferences and device states
+"""
+# pylint: disable=invalid-name,broad-exception-caught,line-too-long
+import json
+import time
+from pathlib import Path
+from .Utils import Utils
+
+
+class PersistentState:
+    """Manages persistent state for dwipe preferences and device locks"""
+
+    def __init__(self, config_path=None):
+        """Initialize persistent state
+
+        Args:
+            config_path: Path to config file (default: ~/.config/dwipe/state.json)
+        """
+        if config_path is None:
+            config_dir = Utils.get_config_dir()
+            config_path = config_dir / 'state.json'
+
+        self.config_path = Path(config_path)
+        self.state = {
+            'theme': 'default',
+            'wipe_mode': 'Zero',  # 'Rand' or 'Zero' or +V
+            'passes': 1,  # 1, 2, or 4 wipe passes
+            'confirmation': 'YES',  # 'Y', 'y', 'YES', 'yes', 'device'
+            'verify_pct': 2,  # 0, 2, 5, 10, 25, 50, 100
+            'dense': False,  # True = compact view, False = blank lines between disks
+            'slowdown_stop': 16,
+            'stall_timeout': 60,
+            'devices': {}  # device_id -> {locked, last_seen, last_name, size_bytes}
+        }
+        self.dirty = False
+        self.max_devices = 400
+
+        self.load()
+
+    def save_updated_opts(self, opts):
+        """Save updated option variables from opts to state"""
+        for key in self.state:
+            if key == 'devices':
+                continue  # Skip devices dict
+            if hasattr(opts, key):
+                value = getattr(opts, key)
+                if self.state[key] != value:
+                    self.state[key] = value
+                    self.dirty = True
+
+    def restore_updated_opts(self, opts):
+        """Restore option variables from state to opts"""
+        for key in self.state:
+            if hasattr(opts, key):
+                setattr(opts, key, self.state[key])
+
+    def load(self):
+        """Load state from disk"""
+        if self.config_path.exists():
+            try:
+                with open(self.config_path, 'r', encoding='utf-8') as f:
+                    loaded = json.load(f)
+                    # Migrate old mode values to new format
+#                   if 'mode' in loaded:
+#                       old_mode = loaded['mode']
+#                       if old_mode in ('random', 'Random', 'RANDOM'):
+#                           loaded['mode'] = 'Rand'
+#                           self.dirty = True  # Save migrated value
+#                       elif old_mode in ('zero', 'zeros', 'Zero', 'ZERO'):
+#                           loaded['mode'] = 'Zero'
+#                           self.dirty = True  # Save migrated value
+                    self.state.update(loaded)
+            except (json.JSONDecodeError, IOError) as e:
+                print(f'Warning: Could not load state from {self.config_path}: {e}')
+
+    def save(self):
+        """Save state to disk if dirty"""
+        if not self.dirty:
+            return
+
+        try:
+            # Clean up old devices before saving
+            self._cleanup_old_devices()
+
+            with open(self.config_path, 'w', encoding='utf-8') as f:
+                json.dump(self.state, f, indent=2)
+            # Fix ownership if running with sudo
+            Utils.fix_file_ownership(self.config_path)
+            self.dirty = False
+        except IOError as e:
+            print(f'Warning: Could not save state to {self.config_path}: {e}')
+
+    def _cleanup_old_devices(self):
+        """Keep only the most recent max_devices entries"""
+        devices = self.state['devices']
+        if len(devices) <= self.max_devices:
+            return
+
+        # Sort by last_seen timestamp, keep most recent
+        sorted_devices = sorted(
+            devices.items(),
+            key=lambda x: x[1].get('last_seen', 0),
+            reverse=True
+        )
+
+        # Keep only max_devices most recent
+        self.state['devices'] = dict(sorted_devices[:self.max_devices])
+
+    @staticmethod
+    def make_device_id(partition):
+        """Create a stable device identifier
+
+        Priority:
+        1. partition.uuid (PARTUUID for partitions, UUID for filesystems)
+        2. partition.serial (for whole disks)
+        3. Fallback: hash of name+size+label+fstype
+
+        Args:
+            partition: SimpleNamespace with device info
+
+        Returns:
+            str: Stable device identifier
+        """
+        # Try UUID first (PARTUUID or filesystem UUID)
+        if hasattr(partition, 'uuid') and partition.uuid:
+            return f'uuid:{partition.uuid}'
+
+        # Try serial number (for whole disks)
+        if hasattr(partition, 'serial') and partition.serial:
+            return f'serial:{partition.serial}'
+
+        # Fallback: create stable ID from device characteristics
+        # This will break if device is repartitioned/reformatted, but that's acceptable
+        parts = [
+            partition.name,
+            str(partition.size_bytes),
+            partition.label if hasattr(partition, 'label') else '',
+            partition.fstype if hasattr(partition, 'fstype') else ''
+        ]
+        fallback_id = ':'.join(parts)
+        return f'fallback:{fallback_id}'
+
+    def get_device_locked(self, partition):
+        """Check if a device is locked
+
+        Args:
+            partition: SimpleNamespace with device info
+
+        Returns:
+            bool: True if device is locked
+        """
+        device_id = self.make_device_id(partition)
+        device_state = self.state['devices'].get(device_id, {})
+        return device_state.get('locked', False)
+
+    def set_device_locked(self, partition, locked):
+        """Set device lock state
+
+        Args:
+            partition: SimpleNamespace with device info
+            locked: bool, True to lock device
+        """
+        device_id = self.make_device_id(partition)
+        now = int(time.time())
+
+        if device_id not in self.state['devices']:
+            self.state['devices'][device_id] = {}
+
+        device_state = self.state['devices'][device_id]
+        device_state['locked'] = locked
+        device_state['last_seen'] = now
+        device_state['last_name'] = partition.name
+        device_state['size_bytes'] = partition.size_bytes
+
+        self.dirty = True
+
+    def update_device_seen(self, partition):
+        """Update last_seen timestamp for a device
+
+        Args:
+            partition: SimpleNamespace with device info
+        """
+        device_id = self.make_device_id(partition)
+        now = int(time.time())
+
+        if device_id in self.state['devices']:
+            self.state['devices'][device_id]['last_seen'] = now
+            self.state['devices'][device_id]['last_name'] = partition.name
+            self.dirty = True
+
+
+    def sync(self):
+        """Save state if dirty (called each loop)"""
+        self.save()

dwipe/Utils.py

@@ -0,0 +1,199 @@
+"""
+Utils class - Utility functions for dwipe
+"""
+import os
+import sys
+import datetime
+from pathlib import Path
+
+
+class Utils:
+    """Utility functions encapsulated as a family"""
+
+    @staticmethod
+    def human(number):
+        """Return a concise number description."""
+        suffixes = ['K', 'M', 'G', 'T']
+        number = float(number)
+        while suffixes:
+            suffix = suffixes.pop(0)
+            number /= 1000  # decimal
+            if number < 999.95 or not suffixes:
+                return f'{number:.1f}{suffix}B'  # decimal
+        return None
+
+    @staticmethod
+    def ago_str(delta_secs, signed=False):
+        """Turn time differences in seconds to a compact representation;
+        e.g., '18h·39m' or '450ms' for sub-second times
+        """
+        abs_delta = delta_secs if delta_secs >= 0 else -delta_secs
+
+        # For sub-second times, show milliseconds
+        if 0.00051 <= abs_delta < 0.99949:
+            ms = int(abs_delta * 1000)
+            rv = '-' if signed and delta_secs < 0 else ''
+            return rv + f'{ms}ms'
+
+        ago = int(max(0, round(abs_delta)))
+        divs = (60, 60, 24, 7, 52, 9999999)
+        units = ('s', 'm', 'h', 'd', 'w', 'y')
+        vals = (ago % 60, int(ago / 60))  # seed with secs, mins (step til 2nd fits)
+        uidx = 1  # best units
+        for div in divs[1:]:
+            if vals[1] < div:
+                break
+            vals = (vals[1] % div, int(vals[1] / div))
+            uidx += 1
+        rv = '-' if signed and delta_secs < 0 else ''
+        rv += f'{vals[1]}{units[uidx]}' if vals[1] else ''
+        rv += f'{vals[0]:d}{units[uidx - 1]}'
+        return rv
+
+    @staticmethod
+    def rerun_module_as_root(module_name):
+        """Rerun using the module name"""
+        if os.geteuid() != 0:  # Re-run the script with sudo
+            os.chdir(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+            vp = ['sudo', sys.executable, '-m', module_name] + sys.argv[1:]
+            os.execvp('sudo', vp)
+
+    @staticmethod
+    def get_config_dir():
+        """Get the dwipe config directory, handling sudo correctly
+
+        Returns the real user's ~/.config/dwipe directory, even when running with sudo
+        """
+        real_user = os.environ.get('SUDO_USER')
+        if real_user:
+            # Running with sudo - get the real user's home directory
+            import pwd
+            real_home = pwd.getpwnam(real_user).pw_dir
+            config_dir = Path(real_home) / '.config' / 'dwipe'
+        else:
+            # Not running with sudo - use normal home
+            config_dir = Path.home() / '.config' / 'dwipe'
+
+        config_dir.mkdir(parents=True, exist_ok=True)
+
+        # Fix ownership if running with sudo
+        if real_user:
+            try:
+                import pwd
+                pw_record = pwd.getpwnam(real_user)
+                uid, gid = pw_record.pw_uid, pw_record.pw_gid
+                os.chown(config_dir, uid, gid)
+                # Also fix parent .config directory if we created it
+                parent = config_dir.parent
+                if parent.exists():
+                    os.chown(parent, uid, gid)
+            except (OSError, KeyError):
+                pass  # Ignore permission errors and missing users
+
+        return config_dir
+
+    @staticmethod
+    def fix_file_ownership(file_path):
+        """Fix file ownership to the real user when running with sudo"""
+        real_user = os.environ.get('SUDO_USER')
+        if real_user:
+            try:
+                import pwd
+                pw_record = pwd.getpwnam(real_user)
+                uid, gid = pw_record.pw_uid, pw_record.pw_gid
+                os.chown(file_path, uid, gid)
+            except (OSError, KeyError):
+                pass  # Ignore permission errors and missing users
+
+    @staticmethod
+    def get_log_path():
+        """Get the path to the log file, creating directory if needed"""
+        log_dir = Utils.get_config_dir()
+        return log_dir / 'log.txt'
+
+    @staticmethod
+    def trim_log_if_needed(log_path, max_lines=1000):
+        """Trim log file by removing oldest 1/3 if it exceeds max_lines"""
+        try:
+            if not log_path.exists():
+                return
+
+            with open(log_path, 'r', encoding='utf-8') as f:
+                lines = f.readlines()
+
+            if len(lines) > max_lines:
+                # Keep the newest 2/3 of the log
+                keep_count = len(lines) * 2 // 3
+                with open(log_path, 'w', encoding='utf-8') as f:
+                    f.writelines(lines[-keep_count:])
+        except Exception:
+            pass  # Don't fail if log trimming fails
+
+    @staticmethod
+    def log_wipe(device_name, size_bytes, mode, result, elapsed_time=None, uuid=None, label=None, fstype=None, pct=None, verify_result=None):
+        """Log a wipe or verify operation to ~/.config/dwipe/log.txt
+
+        Args:
+            device_name: Device name (e.g., 'sdb1')
+            size_bytes: Size of device in bytes
+            mode: 'Rand', 'Zero', or 'Vrfy' (for verify operations)
+            result: 'completed' or 'stopped'
+            elapsed_time: Optional elapsed time in seconds
+            uuid: Optional UUID of the partition
+            label: Optional label of the partition (only for non-wiped)
+            fstype: Optional filesystem type (only for non-wiped)
+            pct: Optional percentage (for stopped wipes)
+            verify_result: Optional verify result (chi-squared value for Rand verifies)
+        """
+        log_path = Utils.get_log_path()
+
+        # Trim log if needed before appending
+        Utils.trim_log_if_needed(log_path)
+
+        timestamp = datetime.datetime.now().strftime('%Y-%m-%d %H:%M')
+        size_str = Utils.human(size_bytes)
+        time_str = f' in {Utils.ago_str(int(elapsed_time))}' if elapsed_time else ''
+
+        # Show percentage if available, otherwise 100% for completed or result status
+        if result == 'completed':
+            status_str = '100%'
+        elif result in ('OK', 'FAIL', 'skip'):
+            # For verify operations: show 100% and the result
+            status_str = f'100%'
+        elif pct is not None:
+            status_str = f'{pct:3d}%'
+        else:
+            status_str = f'{result:>4s}'
+
+        # Build UUID field (last 8 chars or full if shorter)
+        uuid_str = uuid[-8:] if uuid and len(uuid) >= 8 else (uuid if uuid else '-')
+
+        # For wiped/verified disks, don't show label/fstype (they shouldn't have any)
+        # Only show for non-completed operations
+        if (result in ('completed', 'OK', 'FAIL', 'skip')) and mode in ('Rand', 'Zero', 'Vrfy'):
+            info_str = ''
+        else:
+            # Show fstype and label for non-wiped disks
+            fstype_str = fstype if fstype and fstype.strip() else '-'
+            label_str = f"'{label}'" if label and label.strip() else "'-'"
+            info_str = f' | {fstype_str} {label_str}'
+
+        # Add result status for verify operations (OK/FAIL)
+        result_str = ''
+        if result in ('OK', 'FAIL', 'skip'):
+            result_str = f' | {result}'
+
+        # Add verify result details if available (failure reason or stats)
+        stats_str = ''
+        if verify_result:
+            stats_str = f' | {verify_result}'
+
+        log_line = f'{timestamp} | {mode:4s} | {status_str} {size_str:>8s}{time_str:>12s} | {device_name:8s} | {uuid_str:8s}{info_str}{result_str}{stats_str}\n'
+
+        try:
+            with open(log_path, 'a', encoding='utf-8') as f:
+                f.write(log_line)
+            # Fix ownership if running with sudo
+            Utils.fix_file_ownership(log_path)
+        except Exception:
+            pass  # Don't fail if logging fails