dwipe 1.0.1__tar.gz → 1.0.2__tar.gz

{dwipe-1.0.1/src/dwipe.egg-info → dwipe-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dwipe
-Version: 1.0.1
+Version: 1.0.2
 Summary: A tool to wipe disks and partitions for Linux
 Author-email: Joe Defen <joedef@google.com>
 License: MIT
@@ -63,6 +63,8 @@ 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-1.0.1 → dwipe-1.0.2}/README.md

@@ -45,6 +45,8 @@ 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-1.0.1 → dwipe-1.0.2}/pyproject.toml

@@ -47,7 +47,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dwipe"
-version = "1.0.1"
+version = "1.0.2"
 description = "A tool to wipe disks and partitions for Linux"
 authors = [
     { name = "Joe Defen", email = "joedef@google.com" }

{dwipe-1.0.1 → dwipe-1.0.2}/src/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.1 → dwipe-1.0.2/src/dwipe.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dwipe
-Version: 1.0.1
+Version: 1.0.2
 Summary: A tool to wipe disks and partitions for Linux
 Author-email: Joe Defen <joedef@google.com>
 License: MIT
@@ -63,6 +63,8 @@ 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: