Fixes to ZFS command logic.

First prompt:

    Call the ZFS programs only when application start and call again only if the user presses F5.

    For `zpool iostat` call it once and let the program run in a separated thread continuosly grabbing its output. For better output use the `-H` flag to omit the header and make the parser easier as it will separate columns using tabs (\t).

Second prompt:

    The screen is not being updated with data from zpool iostat, the vdevs table and IOPS should be update with this data.

Author: sergiogarciadev

src/zfs_dashboard/ui/app.py

@@ -1,8 +1,62 @@
 from textual.app import App
 from textual.binding import Binding
 
-from ..zfs import get_system_status
+from ..zfs import get_static_data, parse_iostat_line
 from .screens import DashboardScreen
+import threading
+import subprocess
+import time
+
+class IostatWorker(threading.Thread):
+    def __init__(self, callback):
+        super().__init__(daemon=True)
+        self.callback = callback
+        self.running = True
+        
+    def run(self):
+        # Run zpool iostat -H -p -y 1
+        # -H: Scripted mode (no headers, tabs)
+        # -p: Parsable numbers
+        # -y: Omit first report (since boot) - available in newer ZFS
+        # If -y not supported, we just ignore the first line if it looks huge? 
+        # Actually -y is best. If not available, we might see a big spike at start.
+        # Let's assume -y is available or acceptable behavior.
+        # We need to run it continuously.
+        
+        cmd = ['zpool', 'iostat', '-v', '-H', '-p', '-y', '1']
+        
+        # Fallback if -y is not supported?
+        # Let's try running it.
+        try:
+            process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                bufsize=1 # Line buffered
+            )
+            
+            while self.running and process.poll() is None:
+                line = process.stdout.readline()
+                if not line:
+                    break
+                
+                stats = parse_iostat_line(line)
+                if stats:
+                    self.callback(stats)
+                    
+        except FileNotFoundError:
+            pass # zpool not found
+        except Exception as e:
+            print(f"Iostat worker error: {e}")
+        finally:
+            if process:
+                process.terminate()
+                process.wait()
+
+    def stop(self):
+        self.running = False
+
 
 class ZfsDashboardApp(App):
     CSS = """
@@ -52,10 +106,26 @@ def __init__(self, interval: int = 5, pool_filter: str = None, dataset_filter: s
 
     def on_mount(self):
         self.action_refresh_data()
-        self.set_interval(self.interval, self.action_refresh_data)
+        # Start background worker
+        self.worker = IostatWorker(self.update_iostat)
+        self.worker.start()
+
+    def on_unmount(self):
+        if hasattr(self, 'worker'):
+            self.worker.stop()
+
+    def update_iostat(self, stats):
+        # stats is tuple: (name, read_ops, write_ops, read_bytes, write_bytes)
+        # We need to update the UI.
+        # Since this is called from a thread, we must use call_from_thread
+        self.call_from_thread(self._update_iostat_ui, stats)
+
+    def _update_iostat_ui(self, stats):
+        if self.screen and isinstance(self.screen, DashboardScreen):
+            self.screen.update_iostat_data(stats)
 
     def action_refresh_data(self):
-        all_pools = get_system_status()
+        all_pools = get_static_data()
 
         # Apply pool filter
         if self.pool_filter:

src/zfs_dashboard/ui/screens.py

@@ -143,3 +143,52 @@ def on_dataset_tree_widget_selected(self, message: DatasetTreeWidget.Selected):
             pool_name = tree_id.split("-", 1)[1]
             details = self.query_one(f"#details-{pool_name}", DatasetDetails)
             details.dataset = message.dataset
+
+    def update_iostat_data(self, stats):
+        # stats: (name, read_ops, write_ops, read_bytes, write_bytes)
+        name, r_ops, w_ops, r_bytes, w_bytes = stats
+        
+        # We need to find the pool or vdev with this name.
+        # Since we don't know if it's a pool or vdev easily without context,
+        # we can try to find widgets that match.
+        # Pools have IDs like `overview-{pool_name}`
+        # Vdevs are inside `VdevList`, which we need to access.
+        
+        # 1. Check if it's a pool
+        # We can iterate over our pools to see if name matches
+        for pool in self.pools:
+            if pool.name == name:
+                # Update pool stats
+                pool.read_ops = r_ops
+                pool.write_ops = w_ops
+                pool.read_bytes = r_bytes
+                pool.write_bytes = w_bytes
+                
+                # Update UI
+                try:
+                    overview = self.query_one(f"#overview-{pool.name}", PoolOverview)
+                    overview.update_stats()
+                except Exception:
+                    pass
+                    
+                # Also update "All" tab if it exists
+                if len(self.pools) > 1:
+                    self.update_all_tab()
+                return
+
+            # 2. Check if it's a vdev in this pool
+            for vdev in pool.vdevs:
+                if vdev.name == name:
+                    vdev.read_ops = r_ops
+                    vdev.write_ops = w_ops
+                    vdev.read_bytes = r_bytes
+                    vdev.write_bytes = w_bytes
+                    
+                    # Update VdevList
+                    try:
+                        vdev_list = self.query_one(f"#vdevs-{pool.name}", VdevList)
+                        vdev_list.update_vdevs()
+                    except Exception:
+                        pass
+                    return
+

src/zfs_dashboard/ui/widgets.py

@@ -21,6 +21,11 @@ def compose(self) -> ComposeResult:
         yield Label("Write IOPS", classes="header-small")
         yield Sparkline(data=[], summary_function=max, id="write-ops-spark")
 
+    def update_stats(self):
+        """Force update of stats from self.pool"""
+        if self.pool:
+            self.watch_pool(self.pool)
+
     def watch_pool(self, pool: Pool):
         if pool:
             self.query_one("#pool-state", Label).update(f"State: {pool.state} | Health: {pool.health}")
@@ -62,6 +67,10 @@ def on_mount(self):
         table = self.query_one(DataTable)
         table.add_columns("Name", "State", "Read", "Write", "Cksum", "Type", "R IOPS", "W IOPS", "R Bytes", "W Bytes")
 
+    def update_vdevs(self):
+        """Force update of vdev table"""
+        self.watch_vdevs(self.vdevs)
+
     def watch_vdevs(self, vdevs: list[Vdev]):
         table = self.query_one(DataTable)
         table.clear()

src/zfs_dashboard/zfs.py

@@ -182,7 +182,46 @@ def build_dataset_tree(datasets: List[Dataset]) -> List[Dataset]:
 
     return roots
 
+def parse_iostat_line(line: str) -> Optional[tuple[str, str, int, int, int, int]]:
+    """
+    Parses a single line from `zpool iostat -H -p -y 1`.
+    Format: pool_name  alloc  free  read_ops  write_ops  read_bytes  write_bytes
+    Or:     vdev_name  alloc  free  read_ops  write_ops  read_bytes  write_bytes
+    
+    Returns: (name, type_hint, read_ops, write_ops, read_bytes, write_bytes)
+    type_hint is 'pool' or 'vdev' based on context (caller needs to track).
+    Actually, `zpool iostat -H` prints flat lines.
+    We need to know the structure.
+    But usually it prints:
+    pool_name ...
+      vdev ...
+    
+    With -H, indentation is preserved?
+    Let's check `zpool iostat -H` behavior.
+    Usually -H removes headers and separates with tabs.
+    It DOES NOT preserve indentation usually.
+    Wait, if indentation is lost, we can't distinguish pool from vdev easily if names are similar.
+    However, the order is always Pool -> Vdevs.
+    
+    Let's assume the caller handles the hierarchy or we just return the raw stats and name.
+    """
+    parts = line.strip().split('\t')
+    if len(parts) < 7:
+        return None
+        
+    name = parts[0]
+    try:
+        # parts[1] alloc, parts[2] free
+        read_ops = int(parts[3])
+        write_ops = int(parts[4])
+        read_bytes = int(parts[5])
+        write_bytes = int(parts[6])
+        return (name, read_ops, write_ops, read_bytes, write_bytes)
+    except (ValueError, IndexError):
+        return None
+
 def parse_zpool_iostat(output: str) -> Dict[str, Dict[str, dict]]:
+
     """
     Parses `zpool iostat -v -p` (using -p for exact numbers)
     Returns nested dict: pool -> vdev -> {read_ops, write_ops, read_bytes, write_bytes}
@@ -263,7 +302,11 @@ def parse_zpool_iostat(output: str) -> Dict[str, Dict[str, dict]]:
 
     return stats
 
-def get_system_status() -> List[Pool]:
+def get_static_data() -> List[Pool]:
+    """
+    Fetches static structure: Pools, Vdevs, Datasets.
+    Does NOT fetch realtime IO stats.
+    """
     # 1. Get Pools
     pool_list_out = run_command(['zpool', 'list', '-H', '-o', 'name,size,alloc,free,frag,cap,health,altroot'])
     pools = parse_zpool_list(pool_list_out)
@@ -280,38 +323,6 @@ def get_system_status() -> List[Pool]:
     snap_out = run_command(['zfs', 'list', '-H', '-t', 'snapshot', '-o', 'name,used'])
     snaps_map = parse_zfs_snapshots(snap_out)
 
-    # 5. Get IO Stats
-    # Use -p for parsable numbers, -v for verbose (vdevs)
-    # Note: `zpool iostat` without interval prints stats since boot.
-    # For realtime, we usually want current activity.
-    # `zpool iostat -v -p 1 2` prints 2 samples, first is since boot, second is last 1 sec.
-    # But that blocks for 1 second.
-    # If we want non-blocking, we have to accept "since boot" or manage a background process.
-    # Requirement: "Realtime Monitoring ... updated every 5 seconds".
-    # If we run `zpool iostat` every 5 seconds, we get "since boot" stats if we don't specify interval.
-    # If we specify interval, it blocks.
-    # Textual app is async, we could run it in a worker?
-    # Or we can just show "since boot" averages?
-    # Usually "Realtime" implies current load.
-    # Let's try to run `zpool iostat -v -p 1 1` which waits 1 second and gives 1 sample (actually 2 lines of headers + 2 samples).
-    # The second sample is the current load.
-    # But this adds 1s latency to the refresh.
-    # Let's use `zpool iostat -v -p -y 1 1`? -y omits first report (since boot) on recent ZFS versions.
-    # If -y is not supported, we parse the second data block.
-    
-    # Let's try `zpool iostat -v -p 1 1` and parse the last set of values.
-    # This will block for 1 second.
-    iostat_out = run_command(['zpool', 'iostat', '-v', '-p', '1', '1'])
-    # This command outputs:
-    # Header
-    # Stats since boot
-    # Header (sometimes)
-    # Stats for 1s
-    
-    # We need to parse this carefully.
-    # If we just take the last occurrence of each pool/vdev, it should be the latest sample.
-    io_stats = parse_zpool_iostat(iostat_out)
-    
     # Attach snapshots to datasets
     for ds in all_datasets:
         if ds.name in snaps_map:
@@ -325,23 +336,12 @@ def get_system_status() -> List[Pool]:
         if pool.name in vdevs_map:
             pool.vdevs = vdevs_map[pool.name]
 
-        # Attach IO Stats
-        if pool.name in io_stats:
-            p_stats = io_stats[pool.name].get("__pool__", {})
-            pool.read_ops = p_stats.get("read_ops", 0)
-            pool.write_ops = p_stats.get("write_ops", 0)
-            pool.read_bytes = p_stats.get("read_bytes", 0)
-            pool.write_bytes = p_stats.get("write_bytes", 0)
-            
-            for vdev in pool.vdevs:
-                if vdev.name in io_stats[pool.name]:
-                    v_stats = io_stats[pool.name][vdev.name]
-                    vdev.read_ops = v_stats.get("read_ops", 0)
-                    vdev.write_ops = v_stats.get("write_ops", 0)
-                    vdev.read_bytes = v_stats.get("read_bytes", 0)
-                    vdev.write_bytes = v_stats.get("write_bytes", 0)
-        
         # Find root dataset for this pool
         pool.datasets = [ds for ds in root_datasets if ds.name == pool.name]
 
     return pools
+
+def get_system_status() -> List[Pool]:
+    # Deprecated: Use get_static_data for structure and background thread for stats
+    return get_static_data()
+