move methods to vars, reduce size of dispatch

Author: bitplane

src/blkcache/backend.py

@@ -7,88 +7,37 @@
 """
 
 import logging
+from functools import partial
 from pathlib import Path
-from typing import Dict, Any
 
 # Import file detection
 from blkcache.file import detect
 from blkcache.file.device import DEFAULT_SECTOR_SIZE
 
 log = logging.getLogger(__name__)
 
-
-class HandleManager:
-    """Manages file handles and their lifecycle for nbdkit backend."""
-
-    def __init__(self):
-        self._handles: Dict[int, Any] = {}  # handle_id -> File instance
-        self._next_handle = 1
-        self._files = []  # Keep references to context managers
-
-    def open_file(self, path: Path, mode: str) -> int:
-        """Open a file and return a handle ID."""
-        file_cls = detect(path)
-        file_instance = file_cls(path, mode)
-
-        # Enter the context manager and keep reference
-        opened_file = file_instance.__enter__()
-        self._files.append((file_instance, opened_file))
-
-        # Assign handle and store
-        handle = self._next_handle
-        self._handles[handle] = opened_file
-        self._next_handle += 1
-
-        log.debug("Opened file %s as handle %d", path, handle)
-        return handle
-
-    def get_file(self, handle: int):
-        """Get the file instance for a handle."""
-        if handle not in self._handles:
-            raise ValueError(f"Invalid handle: {handle}")
-        return self._handles[handle]
-
-    def close_file(self, handle: int) -> None:
-        """Close a specific file handle."""
-        if handle in self._handles:
-            file_instance = self._handles[handle]
-            # Find and close the corresponding context manager
-            for i, (ctx_mgr, opened_file) in enumerate(self._files):
-                if opened_file is file_instance:
-                    try:
-                        ctx_mgr.__exit__(None, None, None)
-                    except Exception as e:
-                        log.warning("Error closing file handle %d: %s", handle, e)
-                    self._files.pop(i)
-                    break
-
-            del self._handles[handle]
-            log.debug("Closed handle %d", handle)
-
-    def close_all(self) -> None:
-        """Close all open files."""
-        for ctx_mgr, _ in self._files:
-            try:
-                ctx_mgr.__exit__(None, None, None)
-            except Exception as e:
-                log.warning("Error during cleanup: %s", e)
-
-        self._handles.clear()
-        self._files.clear()
-        log.debug("Closed all handles")
-
-
 # Global state
 DEV: Path | None = None
 CACHE: Path | None = None
 SECTOR_SIZE = DEFAULT_SECTOR_SIZE
 METADATA = {}
 
-# Handle manager instance
-HANDLE_MANAGER = HandleManager()
+# Simple dispatch table: handle -> (file_instance, context_generator)
+TABLE = {}
+
+
+def lookup(attr: str, handle: int, table=TABLE):
+    """Generic attribute lookup for dispatch."""
+    obj, _ = table[handle]
+    return getattr(obj, attr)
 
 
-# These functions are now handled by the BlockCache class
+def open_file_context(path: Path, mode: str):
+    """Generator to manage file lifecycle."""
+    file_cls = detect(path)
+    file_instance = file_cls(path, mode)
+    with file_instance as f:
+        yield f
 
 
 def config(key: str, val: str) -> None:
@@ -126,72 +75,45 @@ def config_complete() -> None:
 def open(_readonly: bool) -> int:
     """Opens device and returns handle ID."""
     mode = "rb" if _readonly else "r+b"
-    return HANDLE_MANAGER.open_file(DEV, mode)
+    handle = len(TABLE) + 1
+    ctx = open_file_context(DEV, mode)
+    obj = next(ctx)
+    TABLE[handle] = (obj, ctx)
+    log.debug("Opened file %s as handle %d", DEV, handle)
+    return handle
 
 
 def get_size(h: int) -> int:
     """Get file size."""
-    file_instance = HANDLE_MANAGER.get_file(h)
-    return file_instance.size()
+    obj, _ = TABLE[h]
+    return obj.size()
 
 
 def pread(h: int, count: int, offset: int) -> bytes:
     """Read data at offset."""
-    file_instance = HANDLE_MANAGER.get_file(h)
-    return file_instance.pread(count, offset)
+    obj, _ = TABLE[h]
+    return obj.pread(count, offset)
 
 
 def close(h: int) -> None:
     """Close file handle."""
     log.debug("Backend close() called for handle %d", h)
-    HANDLE_MANAGER.close_file(h)
+    if h in TABLE:
+        obj, ctx = TABLE[h]
+        try:
+            next(ctx)  # Advance generator to trigger cleanup
+        except StopIteration:
+            pass
+        del TABLE[h]
     log.debug("Backend close() completed")
 
 
-# Optional capability functions - use duck typing
-def can_write(h: int) -> bool:
-    """Check if file supports writing."""
-    file_instance = HANDLE_MANAGER.get_file(h)
-    return "w" in file_instance.mode or "a" in file_instance.mode or "+" in file_instance.mode
-
-
-def can_flush(h: int) -> bool:
-    """Check if file supports flushing."""
-    file_instance = HANDLE_MANAGER.get_file(h)
-    return hasattr(file_instance, "flush")
-
-
-def can_trim(h: int) -> bool:
-    """Check if file supports trim operations."""
-    file_instance = HANDLE_MANAGER.get_file(h)
-    return hasattr(file_instance, "trim")
-
-
-def can_zero(h: int) -> bool:
-    """Check if file supports zero operations."""
-    file_instance = HANDLE_MANAGER.get_file(h)
-    return hasattr(file_instance, "zero")
-
-
-def can_fast_zero(h: int) -> bool:
-    """Check if file supports fast zero operations."""
-    file_instance = HANDLE_MANAGER.get_file(h)
-    return hasattr(file_instance, "fast_zero")
-
-
-def can_extents(h: int) -> bool:
-    """Check if file supports extent operations."""
-    file_instance = HANDLE_MANAGER.get_file(h)
-    return hasattr(file_instance, "extents")
-
-
-def is_rotational(h: int) -> bool:
-    """Check if underlying storage is rotational."""
-    file_instance = HANDLE_MANAGER.get_file(h)
-    return hasattr(file_instance, "is_rotational") and file_instance.is_rotational()
-
-
-def can_multi_conn(h: int) -> bool:
-    """Check if file supports multiple connections."""
-    # For now, return False for safety
-    return False
+# Optional capability functions - use partial dispatch
+can_write = partial(lookup, "can_write")
+can_flush = partial(lookup, "can_flush")
+can_trim = partial(lookup, "can_trim")
+can_zero = partial(lookup, "can_zero")
+can_fast_zero = partial(lookup, "can_fast_zero")
+can_extents = partial(lookup, "can_extents")
+is_rotational = partial(lookup, "is_rotational")
+can_multi_conn = partial(lookup, "can_multi_conn")

src/blkcache/file/base.py

@@ -1,4 +1,5 @@
 import hashlib
+from functools import lru_cache
 from pathlib import Path
 
 
@@ -9,20 +10,42 @@ def __init__(self, path: Path | str, mode: str):
         self.path = Path(path)
         self.mode = mode
         self._f = None
+        self._dependencies = []
+
+        # nbdkit capability attributes - safe defaults
+        self.can_write = "w" in mode or "+" in mode or "a" in mode
+        self.can_flush = True
+        self.can_trim = False
+        self.can_zero = False
+        self.can_fast_zero = False
+        self.can_extents = False
+        self.is_rotational = False
+        self.can_multi_conn = False
 
     @staticmethod
     def check(path: Path) -> bool:
         """Check if this class can handle the given path."""
         return path.is_file() or (path.exists() and not path.is_dir())
 
+    def depends(self, *files):
+        """Register file dependencies for cascading cleanup."""
+        self._dependencies.extend(files)
+        return self
+
     def __enter__(self):
+        # Open dependencies first (bottom-up)
+        for dep in self._dependencies:
+            dep.__enter__()
         self._f = self.path.open(self.mode)
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         if self._f:
             self._f.close()
         self._f = None
+        # Close dependencies last (top-down)
+        for dep in reversed(self._dependencies):
+            dep.__exit__(exc_type, exc_val, exc_tb)
 
     def __getattr__(self, name):
         """Delegate unknown attributes to the underlying file object."""
@@ -63,6 +86,8 @@ def size(self) -> int:
         finally:
             self._f.seek(current)
 
+    @property
+    @lru_cache(maxsize=1)
     def sector_size(self) -> int:
         """Get sector size of the underlying storage device."""
         try:

src/blkcache/file/cache.py src/blkcache/file/cached.pysrc/blkcache/file/cache.py renamed to src/blkcache/file/cached.py

@@ -10,7 +10,7 @@
 from .base import File
 
 
-class CacheFile(File):
+class CachedFile(File):
     """Passthrough cache that wraps another File instance."""
 
     def __init__(self, backing_file: File, cache_file: File):
@@ -49,9 +49,10 @@ def size(self) -> int:
         """Get size from backing file."""
         return self.backing_file.size()
 
+    @property
     def sector_size(self) -> int:
         """Get sector size from backing file."""
-        return self.backing_file.sector_size()
+        return self.backing_file.sector_size
 
     def pread(self, count: int, offset: int) -> bytes:
         """Read with cache - try cache first, then backing file."""

src/blkcache/file/device.py

@@ -7,6 +7,7 @@
 
 import fcntl
 import struct
+from functools import lru_cache
 from pathlib import Path
 
 from .base import File
@@ -24,6 +25,8 @@ class Device(File):
 
     def __init__(self, path: Path | str, mode: str = "rb"):
         super().__init__(path, mode)
+        # Update capability based on device type
+        self.is_rotational = self._check_rotational()
 
     @staticmethod
     def check(path: Path) -> bool:
@@ -48,6 +51,8 @@ def device_size(self) -> int:
         # Fall back to file size
         return self.size()
 
+    @property
+    @lru_cache(maxsize=1)
     def sector_size(self) -> int:
         """Get device sector size using ioctl."""
         try:
@@ -56,7 +61,7 @@ def sector_size(self) -> int:
         except (OSError, IOError):
             return DEFAULT_SECTOR_SIZE
 
-    def is_rotational(self) -> bool:
+    def _check_rotational(self) -> bool:
         """Check if device uses spinning media (HDD) vs flash (SSD)."""
         try:
             # Check sys path for rotational status

src/blkcache/file/removable.py

@@ -10,6 +10,7 @@
 import struct
 import threading
 import time
+from functools import lru_cache
 from pathlib import Path
 
 from .device import Device, BLKSSZGET, DEFAULT_SECTOR_SIZE
@@ -24,6 +25,34 @@
 class Removable(Device):
     """Removable device with media change detection."""
 
+    def __init__(self, path: Path | str, mode: str = "rb"):
+        super().__init__(path, mode)
+        # Optical drives and floppy disks are rotational
+        self.is_rotational = self._is_optical() or self._is_floppy()
+
+    def _is_optical(self) -> bool:
+        """Check if this is an optical drive (CD/DVD)."""
+        device_name = self.path.name
+        return device_name.startswith(("sr", "scd")) or "cdrom" in str(self.path)
+
+    def _is_floppy(self) -> bool:
+        """Check if this is a floppy disk drive."""
+        device_name = self.path.name
+        # fd0, fd1 for traditional floppies, sd* devices need more checking
+        if device_name.startswith("fd"):
+            return True
+
+        # Check for USB floppies via sysfs
+        try:
+            model_path = Path(f"/sys/block/{device_name}/device/model")
+            if model_path.exists():
+                model = model_path.read_text().strip().lower()
+                return "floppy" in model or "fd" in model
+        except Exception:
+            pass
+
+        return False
+
     @staticmethod
     def check(path: Path) -> bool:
         """Check if this is a removable block device."""
@@ -38,9 +67,11 @@ def check(path: Path) -> bool:
             except (OSError, IOError):
                 pass
 
-        # Fallback: optical drive naming patterns
-        return "sr" in str(path) or "cd" in str(path)
+        p = str(path)
+        return p.startswith("/dev/") and ("sr" in p or "cd" in p)
 
+    @property
+    @lru_cache(maxsize=1)
     def sector_size(self) -> int:
         """Get sector size with CDROM-specific ioctl support."""
         try:
@@ -56,23 +87,6 @@ def sector_size(self) -> int:
                     return DEFAULT_CDROM_SECTOR_SIZE
                 return DEFAULT_SECTOR_SIZE
 
-    def is_rotational(self) -> bool:
-        """Removable devices are typically rotational (CD/DVD)."""
-        try:
-            # Check sys path first
-            rotational_path = Path(f"/sys/block/{self.path.name}/queue/rotational")
-            if rotational_path.exists():
-                return rotational_path.read_text().strip() == "1"
-        except Exception:
-            pass
-
-        # Heuristic: CDs and DVDs are rotational
-        if "sr" in str(self.path) or "cd" in str(self.path):
-            return True
-
-        # Default for other removable media
-        return False
-
     def watch_for_changes(self, stop_event: threading.Event, callback=None, logger=None) -> None:
         """
         Monitor device for media changes.