dwipe 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

dwipe/main.py

@@ -15,13 +15,13 @@ import re
 import json
 import subprocess
 import time
+import datetime
 import threading
 import random
 import shutil
 import traceback
 import curses as cs
 from types import SimpleNamespace
-from typing import Tuple, List
 from dwipe.PowerWindow import Window, OptionSpinner
 
 def human(number):
@@ -30,9 +30,9 @@ def human(number):
     number = float(number)
     while suffixes:
         suffix = suffixes.pop(0)
-        number /= 1024
-        if number < 99.95 or not suffixes:
-            return f'{number:.1f}{suffix}'
+        number /= 1000 # decimal
+        if number < 999.95 or not suffixes:
+            return f'{number:.1f}{suffix}B' # decimal
     return None
 ##############################################################################
 def ago_str(delta_secs, signed=False):
@@ -62,6 +62,7 @@ class WipeJob:
     # Generate a 1MB buffer of random data
     BUFFER_SIZE = 1 * 1024 * 1024  # 1MB
     WRITE_SIZE = 16 * 1024  # 16KB
+    STATE_OFFSET = 15 * 1024 # where json is written
     buffer = bytearray(os.urandom(BUFFER_SIZE))
     zero_buffer = bytes(WRITE_SIZE)
 
@@ -123,6 +124,62 @@ class WipeJob:
 
         return ago_str(int(round(elapsed_time))), pct_str, rate_str, when_str
 
+    def prep_marker_buffer(self, is_random):
+        """  Get the 1st 16KB to write:
+             - 15K zeros
+             - JSON status + zero fill to 1KB
+        """
+        data = { "unixtime": int(time.time()),
+                    "scrubbed_bytes": self.total_written,
+                    "size_bytes": self.total_size,
+                    "mode": 'Rand' if is_random else 'Zero'
+                    }
+        json_data = json.dumps(data).encode('utf-8')
+        buffer = bytearray(self.BUFFER_SIZE)
+        buffer[:self.STATE_OFFSET] = b'\x00' * self.STATE_OFFSET
+        buffer[self.STATE_OFFSET:self.STATE_OFFSET+len(json_data)] = json_data
+        remaining_size = self.BUFFER_SIZE - (self.STATE_OFFSET+len(json_data))
+        buffer[self.STATE_OFFSET+len(json_data):] = b'\x00' * remaining_size
+        return buffer
+
+    @staticmethod
+    def read_marker_buffer(device_name):
+        """ Open the device and read the first 16 KB """
+        try:
+            with open(f'/dev/{device_name}', 'rb') as device:
+                device.seek(0)
+                buffer = device.read(WipeJob.BUFFER_SIZE)
+        except Exception:
+            return None # cannot find info
+
+        if buffer[:WipeJob.STATE_OFFSET] != b'\x00' * (WipeJob.STATE_OFFSET):
+            return None # First 15 KB are not zeros
+
+        # Extract JSON data from the next 1 KB Strip trailing zeros
+        json_data_bytes = buffer[WipeJob.STATE_OFFSET:WipeJob.BUFFER_SIZE].rstrip(b'\x00')
+
+        if not json_data_bytes:
+            return None # No JSON data found
+
+        # Deserialize the JSON data
+        try:
+            data = json.loads(json_data_bytes.decode('utf-8'))
+        except (json.JSONDecodeError, Exception):
+            return None # Invalid JSON data!
+
+        rv = {}
+        for key, value in data.items():
+            if key in ('unixtime', 'scrubbed_bytes', 'size_bytes') and isinstance(value, int):
+                rv[key] = value
+            elif key in ('mode', ) and isinstance(value, str):
+                rv[key] = value
+            else:
+                return None # bogus data
+        if len(rv) != 4:
+            return None # bogus data
+        return SimpleNamespace(**rv)
+
+
     def write_partition(self):
         """Writes random chunks to a device and updates the progress status."""
         self.total_written = 0  # Track total bytes written
@@ -155,11 +212,11 @@ class WipeJob:
                 if self.opts.dry_run and self.total_written >= self.total_size:
                     break
             # clear the beginning of device whether aborted or not
-            # if we have started writing
+            # if we have started writing + status in JSON
             if not self.opts.dry_run and self.total_written > 0 and is_random:
                 device.seek(0)
-                chunk = memoryview(WipeJob.zero_buffer)
-                bytes_written = device.write(chunk)
+                # chunk = memoryview(WipeJob.zero_buffer)
+                bytes_written = device.write(self.prep_marker_buffer(is_random))
         self.done = True
 
 class DeviceInfo:
@@ -183,13 +240,37 @@ class DeviceInfo:
             dflt=dflt,         # default run-time state
             label='',       # blkid
             fstype='',      # blkid
+            model='',       # /sys/class/block/{name}/device/vendor|model
             # fsuse='-',
             size_bytes=size_bytes,  # /sys/block/{name}/...
+            marker='',      #  persistent status
             mounts=[],        # /proc/mounts
             minors=[],
             job=None,         # if zap running
             )
 
+
+    @staticmethod
+    def get_device_vendor_model(device_name):
+        """ Gets the vendor and model for a given device from the /sys/class/block directory.
+        - Args: - device_name: The device name, such as 'sda', 'sdb', etc.
+-       - Returns: A string containing the vendor and model information.
+        """
+        def get_str(device_name, suffix):
+            try:
+                rv = ''
+                fullpath = f'/sys/class/block/{device_name}/device/{suffix}'
+                with open(fullpath, 'r', encoding='utf-8') as f: # Read information
+                    rv = f.read().strip()
+            except (FileNotFoundError, Exception):
+                # print(f"Error reading {info} for {device_name} : {e}")
+                pass
+            return rv
+
+        # rv = f'{get_str(device_name, "vendor")}' #vendor seems useless/confusing
+        rv = f'{get_str(device_name, "model")}'
+        return rv.strip()
+
     def parse_lsblk(self, dflt):
         """ Parse ls_blk for all the goodies we need """
         def eat_one(device):
@@ -216,6 +297,17 @@ class DeviceInfo:
             while len(mounts) >= 1 and mounts[0] is None:
                 del mounts[0]
             entry.mounts = mounts
+            if not mounts:
+                marker = WipeJob.read_marker_buffer(entry.name)
+                now = int(round(time.time()))
+                if (marker and marker.size_bytes == entry.size_bytes
+                        and 0 <= marker.scrubbed_bytes <= entry.size_bytes
+                        and marker.unixtime < now):
+                    pct = int(round((marker.scrubbed_bytes/marker.size_bytes)*100))
+                    state = 'W' if pct >= 100 else 's'
+                    dt = datetime.datetime.fromtimestamp(marker.unixtime)
+                    entry.marker = f'{state} {pct}% {marker.mode} {dt.strftime('%Y/%m/%d %H:%M')}'
+
             return entry
 
                # Run the `lsblk` command and get its output in JSON format with additional columns
@@ -228,6 +320,7 @@ class DeviceInfo:
         # Parse each block device and its properties
         for device in parsed_data['blockdevices']:
             parent = eat_one(device)
+            parent.fstype = self.get_device_vendor_model(parent.name)
             entries[parent.name] = parent
             for child in device.get('children', []):
                 entry = eat_one(child)
@@ -240,6 +333,8 @@ class DeviceInfo:
                 if entry.mounts:
                     entry.state = 'Mnt'
                     parent.state = 'Mnt'
+                elif entry.marker:
+                    entry.state = entry.marker[0]
 
         if self.DB:
             print('\n\nDB: --->>> after parse_lsblk:')
@@ -359,7 +454,7 @@ class DeviceInfo:
     def compute_field_widths(self, nss):
         """ TBD """
 
-        wids = self.wids = SimpleNamespace(state=5, name=4, human=6, fstype=4, label=5)
+        wids = self.wids = SimpleNamespace(state=5, name=4, human=7, fstype=4, label=5)
         for ns in nss.values():
             wids.state = max(wids.state, len(ns.state))
         #   wids.fsuse = max(wids.fsuse, len(ns.fsuse))
@@ -383,18 +478,23 @@ class DeviceInfo:
         emit += f'{sep}{"SIZE":_^{wids.human}}'
         emit += f'{sep}{"TYPE":_^{wids.fstype}}'
         emit += f'{sep}{"LABEL":_^{wids.label}}'
-        emit += f'{sep}MOUNTS'
+        emit += f'{sep}MOUNTS/STATUS'
         return emit
 
     def part_str(self, partition):
         """ Convert partition to human value. """
-        def print_str_or_dashes(name, width, chrs=' -'):
-            if not name.strip(): # Create a string of '─' characters of the specified width
-                result = f'{chrs}' * (width//2)
-                result += ' ' * (width%2)
-            else: # Format the name to be right-aligned within the specified width
-                result = f'{name:>{width}}'
-            return result
+#       def print_str_or_dashes(name, width, chrs=' -'):
+#           if not name.strip(): # Create a string of '─' characters of the specified width
+#               result = f'{chrs}' * (width//2)
+#               result += ' ' * (width%2)
+#           else: # Format the name to be right-aligned within the specified width
+#               result = f'{name:>{width}}'
+#           return result
+
+        def print_str_or_dash(name, width, empty='-'):
+            if not name.strip(): # return
+                name = empty
+            return f'{name:^{width}}'
 
         sep = '  '
         ns = partition # shorthand
@@ -409,14 +509,17 @@ class DeviceInfo:
         emit += f'{sep}{name_str:<{wids.name}}'
     #   emit += f'{sep}{ns.fsuse:^{wids.fsuse}}'
         emit += f'{sep}{human(ns.size_bytes):>{wids.human}}'
-        emit += sep + print_str_or_dashes(ns.fstype, wids.fstype)
+        emit += sep + print_str_or_dash(ns.fstype, wids.fstype)
         # emit += f'{sep}{ns.fstype:>{wids.fstype}}'
         if ns.parent is None:
-            emit += sep + '■' + '─'*(wids.label-2) + '■' 
+            emit += sep + '■' + '─'*(wids.label-2) + '■'
         else:
-            emit += sep + print_str_or_dashes(ns.label, wids.label, chrs=' -')
+            emit += sep + print_str_or_dash(ns.label, wids.label)
         # emit += f' {ns.label:>{wids.label}}'
-        emit += f'{sep}{",".join(ns.mounts)}'
+        if ns.mounts:
+            emit += f'{sep}{",".join(ns.mounts)}'
+        else:
+            emit += f'{sep}{ns.marker}'
         return emit
 
     def merge_dev_infos(self, nss, prev_nss=None):
@@ -605,7 +708,7 @@ class DiskWipe:
             for part in self.partitions.values():
                 stop_if_idle(part)
             return None
-        
+
         if key == ord('l'):
             part = self.partitions[self.pick_name]
             self.set_state(part, 'Unlk' if part.state == 'Lock' else 'Lock')
@@ -739,7 +842,7 @@ class DiskWipe:
 
                     if partition.parent and self.partitions[partition.parent].state == 'Lock':
                         continue
-                    
+
                     if wanted(name) or partition.job:
                         partition.line = self.dev_info.part_str(partition)
                         self.win.add_body(partition.line)

{dwipe-1.0.0.dist-info → dwipe-1.0.2.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: dwipe
-Version: 1.0.0
+Version: 1.0.2
 Summary: A tool to wipe disks and partitions for Linux
 Author-email: Joe Defen <joedef@google.com>
 License: MIT
 Project-URL: Homepage, https://github.com/joedefen/dwipe
 Project-URL: Bug Tracker, https://github.com/joedefen/dwipe/issues
-Keywords: disk,partition,wipe,clean
+Keywords: disk,partition,wipe,clean,scrub
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: POSIX :: Linux
@@ -17,27 +17,30 @@ Requires-Dist: psutil>=5.9
 Requires-Dist: importlib-metadata; python_version < "3.8"
 
 # dwipe
-`dwipe` to wipe disks and partitions for Linux for your security.
+`dwipe` is tool to wipe disks and partitions for Linux helps secure you data. `dwipes` aims to reduce mistakes by providing ample information about your devices during selection.
 
-* Install `dwipe` using `pipx install dwipe`, or however you python scripts from PyPi.org.
+> **Quick Start:**
+> * Install `dwipe` using `pipx install dwipe`, or however you install python scripts from PyPi.org.
+> * Run `dwipe` from a terminal and observe the context sensitive help on the 1st line.
 
+To help with your disk scrubbing, `dwipe`:
+* shows disks and partitions that can be wiped along with selected information to help choose them (i.e.,; labels, sizes, and types); disallowed are mounted devices and overlapping wipes and manually "locked" disks.
+* updates the device list when it changes;  newly added devices are marked differently to make it easier to see them.
+* supports starting multiple wipes, shows their progress, and shows completion states.
+* supports either zeroing devices or filling with random data.
+* supports filtering for devices by name/pattern in case of too many for one screen, etc.
+* supports stopping wipes in progress.
 
-`dwipe` features include:
-* shows the disks and partitions that could be wiped along with useful information to help choose them (i.e., labels, sizes, and types)
-* allows starting multiple wipes and shows their progress.
-* allows filtering for devices by name in case of too many for one screen.
-* allows stopping wipes in progress.
-* not offering to wipe disks that are mounted or would have conflicting/overlapping wipes in progress.
-* allowing to "lock" a disk to prevent mistaken wipes on that disk.
+`dwipe` shows file system labels, and if not the partition label.  It is best practice to label partitions and file systems well to make selection easier.
   
 ## Usage
-* Run `dwipe` from the command line.
+> Simply run `dwipe` from the command line w/o arguments normally. Its command line arguments mostly for debugging including "--dry-run" which lets you test/practice the interface w/o risk.
 
 Here is a typical screen:
 
 ![dwipe-help](https://raw.githubusercontent.com/joedefen/dwipe/master/resources/dwipe-main-screen.png?raw=true)
 
-The possible state values and meaning are:
+The possible state values and meanings are:
 * **-** : indicates the device is ready for wiping if desired.
 * **^** : similar to **-**, but also indicates the device was added after `dwipe` started
 * **Mnt** :  the partition is mounted or the disk has partitions that are mounted.  You cannot wipe the device in this state.
@@ -60,8 +63,12 @@ The top line shows the "Mode" which is Random or Zeros. For some disks, zeroing
 
 The write rate and estimating remaining times are shown when wiping a device.  Due to write queueing, the initial rates may be inflated, final rates are deflated, and the times are optimistic.
 
+The 'W' (Wiped) and 's' (partly wiped) states are disk persistent.  For those states, more information is provided about the wipe including when and percent complete.
+
 
 ### The Help Screen
 When **?** is typed, the help screen looks like:
 
 ![dwipe-help](https://raw.githubusercontent.com/joedefen/dwipe/master/resources/dwipe-help-screen.png?raw=true)
+
+You can navigate the list of devices with arrow keys and vi-like keys.

dwipe-1.0.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+dwipe/PowerWindow.py,sha256=pQGXsAMeuiHn-vtEiVG0rgW1eCslh3ukC-VrPhH_j3k,28587
+dwipe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dwipe/main.py,sha256=SyM9S69LkyLvhop3JbnlylGvCHzfv-Vgx8Qh2vhh2Ts,34200
+dwipe-1.0.2.dist-info/LICENSE,sha256=qB9OdnyyF6WYHiEIXVm0rOSdcf8e2ctorrtWs6CC5lU,1062
+dwipe-1.0.2.dist-info/METADATA,sha256=1vDa6BrAtgnmLjMO0qxx-K9mbtWKC4rjgvaHG8hcVbc,4538
+dwipe-1.0.2.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
+dwipe-1.0.2.dist-info/entry_points.txt,sha256=s-gAs_OhS9lr-oVMKii2ZjsLfCSO4-oHV7Wa9oJe-2g,42
+dwipe-1.0.2.dist-info/top_level.txt,sha256=nJT1SUDcOmULgmF9JmYwIIQLmXAIn6qAWW8EdWuxsAg,6
+dwipe-1.0.2.dist-info/RECORD,,

dwipe-1.0.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-dwipe/PowerWindow.py,sha256=pQGXsAMeuiHn-vtEiVG0rgW1eCslh3ukC-VrPhH_j3k,28587
-dwipe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dwipe/main.py,sha256=lXu-xsx1oQnDLBroKUyMnaYmnAujBP7IfXFpyX2T8Gc,29837
-dwipe-1.0.0.dist-info/LICENSE,sha256=qB9OdnyyF6WYHiEIXVm0rOSdcf8e2ctorrtWs6CC5lU,1062
-dwipe-1.0.0.dist-info/METADATA,sha256=rWG2JeZ-TIF6NZnt-9Slt0IyYKh8S93Bxso21tSp5u4,3601
-dwipe-1.0.0.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
-dwipe-1.0.0.dist-info/entry_points.txt,sha256=s-gAs_OhS9lr-oVMKii2ZjsLfCSO4-oHV7Wa9oJe-2g,42
-dwipe-1.0.0.dist-info/top_level.txt,sha256=nJT1SUDcOmULgmF9JmYwIIQLmXAIn6qAWW8EdWuxsAg,6
-dwipe-1.0.0.dist-info/RECORD,,