[for discussion, POC]: make loader arguments discoverable

dissect/target/loader.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import argparse
 import os
 import urllib.parse
 from pathlib import Path
@@ -82,6 +83,26 @@ def __init__(
             dict(urllib.parse.parse_qsl(parsed_path.query, keep_blank_values=True)) if parsed_path else {}
         )
 
+        self._parser = self._create_parser(self.__class__)
+
+    @classmethod
+    def print_help(cls) -> None:
+        """Prints the help message for this loader's specific arguments."""
+        cls._create_parser(cls).print_help()
+
+    @staticmethod
+    def _create_parser(cls: type[Loader]) -> argparse.ArgumentParser:
+        """Creates the argument parser for this loader."""
+        # Do like generate_argparse_for_method in cli.py
+        parser = argparse.ArgumentParser(
+            prog=f"loader:{cls.__name__.lower()}",
+            description=f"Options for the '{cls.__name__}' loader.",
+            add_help=False,
+        )
+        for args, kwargs in getattr(cls, "__args__", []):
+            parser.add_argument(*args, **kwargs)
+        return parser
+
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}({str(self.path)!r})"
 
@@ -115,6 +136,20 @@ def find_all(path: Path, parsed_path: urllib.parse.ParseResult | None = None) ->
         yield path
 
     def map(self, target: Target) -> None:
+        """Wrapper around the _map function that handles argument passing."""
+        # The loader parses its own arguments from argv
+        loader_options, _ = self._parser.parse_known_args()
+
+        # The query string can act as a default for any arguments not provided on the command line
+        for key, value in self.parsed_query.items():
+            # argparse sets missing optional arguments to None. We only want to override if it's None.
+            if getattr(loader_options, key, None) is None:
+                setattr(loader_options, key, value)
+
+        # Pass the parsed options directly to the implementation map function
+        return self._map(target, **vars(loader_options))
+
+    def _map(self, target: Target, **kwargs) -> None:
         """Maps the loaded path into a ``Target``.
 
         Args:

dissect/target/loaders/local.py

@@ -15,6 +15,7 @@
 from dissect.target.exceptions import LoaderError
 from dissect.target.filesystems.dir import DirectoryFilesystem
 from dissect.target.loader import Loader
+from dissect.target.plugin import arg
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -38,6 +39,12 @@
 WINDOWS_DRIVE_FIXED = 3
 
 
+@arg("--force-directory-fs", action="store_true", help="Force the use of DirectoryFilesystem on all drives.")
+@arg(
+    "--fallback-to-directory-fs",
+    action="store_true",
+    help="Fallback to DirectoryFilesystem if a filesystem cannot be opened.",
+)
 class LocalLoader(Loader):
     """Load local filesystem."""
 
@@ -49,21 +56,18 @@ def __init__(self, path: Path, **kwargs):
     def detect(path: Path) -> bool:
         return urllib.parse.urlparse(str(path)).path == "local"
 
-    def map(self, target: Target) -> None:
+    def _map(self, target: Target, force_directory_fs: bool = False, fallback_to_directory_fs: bool = False) -> None:
         # For the local loader we abuse the path/URI parsing a bit, so fix it up here
         target.parsed_path = urllib.parse.urlparse(str(target.path))
         target.path_query = self.parsed_query
         target.path = Path("local")
 
         os_name = _get_os_name()
 
-        force_dirfs = "force-directory-fs" in self.parsed_query
-        fallback_to_dirfs = "fallback-to-directory-fs" in self.parsed_query
-
         if os_name == "windows":
-            map_windows_mounted_drives(target, force_dirfs=force_dirfs, fallback_to_dirfs=fallback_to_dirfs)
+            map_windows_mounted_drives(target, force_dirfs=force_directory_fs, fallback_to_dirfs=fallback_to_directory_fs)
         else:
-            if fallback_to_dirfs or force_dirfs:
+            if fallback_to_directory_fs or force_directory_fs:
                 # Where Windows does some sophisticated fallback, for other
                 # operating systems we don't know anything yet about the
                 # relation between disks and mount points.

dissect/target/tools/query.py

@@ -18,6 +18,7 @@
 )
 from dissect.target.helpers import cache, record_modifier
 from dissect.target.helpers.logging import get_logger
+from dissect.target.loader import LOADERS_BY_SCHEME
 from dissect.target.plugin import (
     PLUGINS,
     FunctionDescriptor,
@@ -105,7 +106,16 @@ def main() -> int:
 
     # Show help for target-query
     if not args.function and ("-h" in rest or "--help" in rest):
-        parser.print_help()
+        if not args.loader:
+            parser.print_help()
+            return 0
+
+        if (loader_cls := LOADERS_BY_SCHEME.get(args.loader, None)) is None:
+            print(f"Error: Loader '{args.loader}' not found.")
+            return 1
+
+        # The loader now knows how to print its own help.
+        loader_cls.print_help()
         return 0
 
     process_generic_arguments(parser, args)
@@ -126,6 +136,7 @@ def main() -> int:
             )
 
     # Process plugin arguments after host and child args are checked
+    # This is for plugins, not loaders. We pass `rest` to let it find plugin args.
     different_output_types = process_plugin_arguments(parser, args, rest)
 
     if not args.targets: