Add device exclusion and installer drive picker (Issue #28)

Agent: exclude_devices config field with symlink-aware matching, runtime
filter in Refresh(), and [excluded by config] annotation in --discover.

Installer: drive picker auto-detects transport type via lsblk, color-codes
green (sata/nvme/usb/sas) vs yellow (iscsi/fc/unknown), pre-excludes
remote storage. Skipped on macOS (no lsblk). Warns when all drives
excluded. Summary shows red 'all excluded' state.

Docs: README agent config section, Proxmox guide iSCSI troubleshooting.
Response draft for Issue #28 (hessel-a).

Author: DAB-LABS

README.md

@@ -155,6 +155,8 @@ token: "your-secret-token"    # optional -- omit to disable auth
 scan_interval: 60s
 standby_mode: standby          # optional -- never, standby, sleep, or idle
 advertise_interface: eth0      # optional -- restrict mDNS to this interface
+exclude_devices:               # optional -- set by installer's drive picker
+  - /dev/sdb
 filesystems:                   # optional -- set by installer's disk usage picker
   - path: /
     uuid: a1b2c3d4-5678-90ab-cdef-1234567890ab
@@ -164,6 +166,8 @@ filesystems:                   # optional -- set by installer's disk usage picke
 
 All options can also be set via CLI flags: `--port`, `--token`, `--scan-interval`, `--interface`, `--config`.
 
+**Exclude devices:** Device paths listed in `exclude_devices` are skipped during every scan. The agent resolves symlinks at startup, so `/dev/disk/by-id/...` paths and their `/dev/sdX` equivalents both match. The installer's drive picker sets this automatically when it detects iSCSI, Fibre Channel, or other remote-storage transports that don't support SMART passthrough. You can also add paths manually and restart the service. If a device appears in both `exclude_devices` and `device_overrides`, the exclusion wins and a warning is logged.
+
 **Scan interval:** Uses Go duration syntax -- `30s`, `5m`, `1h`, `24h` are all valid. When `standby_mode` is set, the agent skips sleeping drives and serves cached data, so the interval does not cause unnecessary wake-ups. When `standby_mode` is `never` (the default), each poll wakes any drive that is spun down. This is the *agent-side* read cadence and is separate from the HA Poll Interval entity, which reflects how often Home Assistant pulls fresh data from the agent itself.
 
 **Standby mode:** Controls whether the agent avoids waking sleeping drives during polling. Set to `standby`, `sleep`, or `idle` to match your drives' power management (these correspond to `smartctl -n` modes). When set, the agent passes `-n <mode>` to smartctl on each poll -- if a drive is in that power state, smartctl exits without waking it and the agent serves the last cached SMART data with an `in_standby` flag. The default is `never`, which wakes drives on every poll. On the very first poll after startup, the agent always wakes all drives regardless of this setting to collect a SMART baseline (serial number, model, attributes). This one-time wake ensures every drive is registered with a stable identity from the start. Subsequent polls honor the standby setting normally.

agent/config.go

@@ -3,8 +3,10 @@ package main
 import (
 	"flag"
 	"fmt"
+	"log"
 	"net"
 	"os"
+	"path/filepath"
 	"strings"
 	"time"
 
@@ -39,9 +41,11 @@ type Config struct {
 	Filesystems        []FilesystemConfig `yaml:"filesystems"`         // empty = disk usage monitoring disabled
 	StandbyMode        string             `yaml:"standby_mode"`        // never, standby, sleep, idle (default: never)
 	DeviceOverrides    []DeviceOverride   `yaml:"device_overrides"`    // manual protocol overrides per device path
+	ExcludeDevices     []string           `yaml:"exclude_devices"`     // device paths to skip during scan
 	Discover           bool               `yaml:"-"`                   // set by --discover flag; not read from config file
 	NoWrite            bool               `yaml:"-"`                   // set by --no-write flag; skips config write in discover mode
 	SmartctlPath       string             `yaml:"-"`                   // resolved path to smartctl binary; set by resolveSmartctlPath()
+	excludeSet         map[string]bool    // normalized set built once at load time (unexported, not serialized)
 }
 
 // defaultConfig returns sane defaults.
@@ -238,9 +242,58 @@ func LoadConfig() (*Config, error) {
 		}
 	}
 
+	// Validate and normalize exclude_devices.
+	// Build a resolved set once so Refresh() does a simple map lookup per poll.
+	cfg.excludeSet = make(map[string]bool, len(cfg.ExcludeDevices))
+	seen := make(map[string]bool, len(cfg.ExcludeDevices))
+	for i, raw := range cfg.ExcludeDevices {
+		if !strings.HasPrefix(raw, "/dev/") && !strings.HasPrefix(raw, `\\.\`) {
+			return nil, fmt.Errorf("exclude_devices[%d]: %q is not a valid device path", i, raw)
+		}
+		if seen[raw] {
+			log.Printf("WARNING: duplicate entry in exclude_devices: %s", raw)
+		}
+		seen[raw] = true
+
+		// Resolve symlinks so /dev/disk/by-id/... and /dev/sdX both match.
+		resolved, err := filepath.EvalSymlinks(raw)
+		if err != nil {
+			log.Printf("WARNING: excluded device %s not found: %v (will still exclude if it appears later)", raw, err)
+			cfg.excludeSet[raw] = true
+			continue
+		}
+		cfg.excludeSet[resolved] = true
+		if resolved != raw {
+			cfg.excludeSet[raw] = true // match on either form
+		}
+	}
+
+	// Warn on exclude + override conflicts.
+	for _, ov := range cfg.DeviceOverrides {
+		if cfg.excludeSet[ov.Device] {
+			log.Printf("WARNING: %s is in both exclude_devices and device_overrides; excluding", ov.Device)
+		}
+	}
+
 	return &cfg, nil
 }
 
+// IsDeviceExcluded returns true if the given device path (or its symlink
+// target) is in the exclude_devices set. Safe to call with a nil Config.
+func (c *Config) IsDeviceExcluded(devPath string) bool {
+	if c == nil || len(c.excludeSet) == 0 {
+		return false
+	}
+	if c.excludeSet[devPath] {
+		return true
+	}
+	// Resolve the scanned path in case it's a symlink not in the raw set.
+	if resolved, err := filepath.EvalSymlinks(devPath); err == nil && resolved != devPath {
+		return c.excludeSet[resolved]
+	}
+	return false
+}
+
 // MDNSEnabled returns true if mDNS advertisement is enabled (default: true).
 func (c *Config) MDNSEnabled() bool {
 	if c.MDNS == nil {

agent/discover.go

@@ -58,7 +58,7 @@ func RunDiscover(cfg *Config, noWrite bool) error {
 		for _, dev := range scanResult.Devices {
 			r := probeOneDrive(cfg.SmartctlPath, dev.Name, dev.Protocol)
 			results = append(results, r)
-			printDriveResult(r)
+			printDriveResult(r, cfg)
 		}
 	}
 
@@ -92,7 +92,7 @@ func RunDiscover(cfg *Config, noWrite bool) error {
 
 			r := probeOneDrive(cfg.SmartctlPath, path, "sat")
 			results = append(results, r)
-			printDriveResult(r)
+			printDriveResult(r, cfg)
 		}
 	} else if platform == "qnap" {
 		fmt.Println()
@@ -230,8 +230,13 @@ func probeOneDrive(smartctlPath, path, protocol string) discoverDriveResult {
 }
 
 // printDriveResult prints a single drive's discover result to stdout.
-func printDriveResult(r discoverDriveResult) {
-	fmt.Printf("\n  %s\n", r.path)
+// If the drive is in the config's exclude list, an annotation is appended.
+func printDriveResult(r discoverDriveResult, cfg *Config) {
+	excludeTag := ""
+	if cfg.IsDeviceExcluded(r.path) {
+		excludeTag = "  [excluded by config]"
+	}
+	fmt.Printf("\n  %s%s\n", r.path, excludeTag)
 
 	if r.satRetried {
 		fmt.Printf("    Scan protocol: %s\n", r.scanProto)

agent/main.go

@@ -103,6 +103,9 @@ func RunAgent(ctx context.Context, ready chan<- struct{}) error {
 	if cfg.StandbyMode != "never" {
 		log.Printf("Standby mode: %s", cfg.StandbyMode)
 	}
+	if len(cfg.ExcludeDevices) > 0 {
+		log.Printf("Excluding %d device(s): %s", len(cfg.ExcludeDevices), strings.Join(cfg.ExcludeDevices, ", "))
+	}
 
 	// --- Cache / background scanner ---
 	cache := NewDriveCache(cfg)
@@ -673,6 +676,18 @@ func (dc *DriveCache) Refresh() {
 		}
 	}
 
+	// Filter excluded devices before any smartctl -a calls.
+	if dc.cfg != nil && len(dc.cfg.excludeSet) > 0 {
+		var filtered []scanDevice
+		for _, dev := range scanResult.Devices {
+			if dc.cfg.IsDeviceExcluded(dev.Name) {
+				continue
+			}
+			filtered = append(filtered, dev)
+		}
+		scanResult.Devices = filtered
+	}
+
 	newDrives := make(map[string]DriveInfo, len(scanResult.Devices))
 	var order []string
 

docs/guides/proxmox.md

@@ -145,6 +145,19 @@ That's expected. The App (SMART Sniffer App from the HA add-on store) runs smart
 
 Yes. If you pass the physical SATA or NVMe controller through to the VM via Proxmox's PCI passthrough (IOMMU), the VM gets direct hardware access. SMART data will work, and you could run the agent inside the VM. But this ties the physical controller to one VM and is more complex to set up. The agent-on-host approach is simpler and is how most Proxmox users run SMART Sniffer.
 
+### iSCSI or network-attached storage shows warnings in the log
+
+If your Proxmox host mounts iSCSI LUNs, Ceph RBDs, or NFS datastores, smartctl will attempt to read SMART data from those block devices and fail -- iSCSI targets don't support SMART passthrough (the SCSI commands hit the target daemon, not a physical drive). This causes repeated log warnings and exit code 4 errors.
+
+The fix is to exclude those devices. If you're running the installer fresh, the drive picker detects iSCSI and other remote transports automatically and pre-excludes them. For existing installs, add the device paths to your config:
+
+```yaml
+exclude_devices:
+  - /dev/sdb    # iSCSI LUN
+```
+
+Then restart: `sudo systemctl restart smartha-agent`. Run `smartha-agent --discover` to confirm which drives are local and which are remote.
+
 ## Example config
 
 A typical Proxmox host `config.yaml` at `/etc/smartha-agent/config.yaml`:
@@ -153,6 +166,8 @@ A typical Proxmox host `config.yaml` at `/etc/smartha-agent/config.yaml`:
 port: 9099
 scan_interval: 120
 advertise_interface: vmbr0
+exclude_devices:
+  - /dev/sdb    # iSCSI LUN -- no SMART passthrough
 ```
 
 No `device_overrides` needed unless you have a hardware RAID controller. Standard SATA and NVMe drives are detected automatically.