cn-tool 0.7.0__py3-none-any.whl

cn_tool/__init__.py

@@ -0,0 +1 @@
+"""cn-tool: Infoblox lookups and network checks."""

cn_tool/__main__.py

@@ -0,0 +1,5 @@
+"""``python -m cn_tool``: the same entry point as the ``cn`` command."""
+from cn_tool.main import main
+
+if __name__ == "__main__":
+    main()

cn_tool/cn_buildstamp.py

@@ -0,0 +1,104 @@
+"""Shared build-stamp reader for cn-tool and its bundled CLIs.
+
+The ``cn_tool/version`` file (next to this module) is the single CI-managed source of truth for the
+*platform* version (``MAJOR.MINOR.BUILD``) plus the short git ``BUILD_HASH``.
+It is rewritten on every release by ``.github/workflows/release-public.yml``.
+
+Each bundled tool additionally carries its own
+*component* ``__version__`` and renders a combined ``--version`` line through
+this module, so the per-tool version and the shared package build stamp stay
+consistent and the parsing logic lives in exactly one place.
+
+Hybrid ``--version`` format::
+
+    cli-tool 0.2.1 (cn-tool 0.2.88, build 1b5d97f)
+             ^^^^^           ^^^^^^        ^^^^^^^
+        component        package version   git hash
+        (per tool)       (version file)    (version file)
+
+When the ``version`` file is missing or unparseable, the platform suffix is
+omitted and the component version is shown alone (never a misleading
+``unknown``).
+"""
+
+from __future__ import annotations
+
+from functools import lru_cache
+from pathlib import Path
+from typing import NamedTuple, Optional
+
+
+class BuildStamp(NamedTuple):
+    package_version: str  # e.g. "0.2.88"
+    build_hash: str       # e.g. "1b5d97f" (may be "")
+
+
+def parse_version_text(content: str) -> Optional[BuildStamp]:
+    """Parse the ``KEY=value`` body of a ``version`` file.
+
+    Returns ``None`` when the required ``MAJOR``/``MINOR`` keys are missing
+    or non-numeric (a hand-edited file must not yield a stamp like
+    ``"abc.2.88"``), so callers can fall back to a component-only version
+    line. A non-numeric optional ``BUILD`` degrades to ``MAJOR.MINOR``.
+    """
+    parts: dict[str, str] = {}
+    for line in content.splitlines():
+        key, sep, val = line.partition("=")
+        if sep:
+            parts[key.strip()] = val.strip()
+
+    major = parts.get("MAJOR", "")
+    minor = parts.get("MINOR", "")
+    build = parts.get("BUILD", "")
+    if not (major.isdigit() and minor.isdigit()):
+        return None
+    if not build.isdigit():
+        build = ""
+    build_hash = parts.get("BUILD_HASH", "")
+
+    package_version = f"{major}.{minor}.{build}" if build else f"{major}.{minor}"
+    return BuildStamp(package_version=package_version, build_hash=build_hash)
+
+
+@lru_cache(maxsize=1)
+def build_stamp() -> Optional[BuildStamp]:
+    """Parse the ``version`` file next to this module (cn_tool/version).
+
+    Returns ``None`` when the file is absent or unparseable so callers can fall
+    back to a component-only version line. Result is cached after first call.
+    """
+    try:
+        version_file = Path(__file__).resolve().parent / "version"
+        content = version_file.read_text(encoding="utf-8")
+    except OSError:
+        return None
+    return parse_version_text(content)
+
+
+def package_version_string() -> str:
+    """Legacy combined string used by cn-tool: ``"0.2.88 hash 1b5d97f"``.
+
+    Falls back to ``"unknown"`` when no build stamp is available. This matches
+    the string the CI previously injected into ``main.py`` at build time.
+    """
+    stamp = build_stamp()
+    if stamp is None:
+        return "unknown"
+    if stamp.build_hash:
+        return f"{stamp.package_version} hash {stamp.build_hash}"
+    return stamp.package_version
+
+
+def version_line(tool_name: str, component_version: str) -> str:
+    """Render a bundled tool's ``--version`` line in the hybrid format.
+
+    Example: ``cli-tool 0.2.1 (cn-tool 0.2.88, build 1b5d97f)``.
+    Without a build stamp the platform suffix is dropped: ``cli-tool 0.2.1``.
+    """
+    stamp = build_stamp()
+    if stamp is None:
+        return f"{tool_name} {component_version}"
+    suffix = f"cn-tool {stamp.package_version}"
+    if stamp.build_hash:
+        suffix += f", build {stamp.build_hash}"
+    return f"{tool_name} {component_version} ({suffix})"

cn_tool/core/background.py

@@ -0,0 +1,130 @@
+import threading
+from time import time, sleep
+from cn_tool.core.base import ScriptContext
+from cn_tool.utils.cache import CacheManager
+from cn_tool.utils.cache_helpers import mt_index_configurations
+
+
+def start_background_tasks(ctx: ScriptContext) -> None:
+    """
+    Initializes and starts all non-blocking background processes for the application.
+    """
+    if ctx.cfg.get("cache_enabled", False):
+        # Initialize the CacheManager instance and attach it to the context
+        ctx.cache = CacheManager.get_instance(
+            directory=ctx.cfg["cache_directory"],
+            logger=ctx.logger,
+            cfg=ctx.cfg,
+        )
+        # Start the cache indexing in a separate thread
+        threading.Thread(target=_background_cache_init, args=[ctx], daemon=True).start()
+
+
+def _background_cache_init(ctx: ScriptContext) -> None:
+    """
+    Checks the cache state and triggers a re-index if necessary.
+    This function is designed to be run in a background thread.
+    (Original `background_cache_init` logic)
+    """
+    logger = ctx.logger
+    if not ctx.cache:
+        logger.info("Index Cache - Cache does not exist, skipping.")
+        return
+
+    cache: CacheManager = ctx.cache
+
+    if cache.dc.get("indexing"):
+        logger.info("Index Cache - Another process is already indexing; will watch and recheck later.")
+        threading.Thread(target=_wait_for_indexing_and_recheck, args=[ctx], daemon=True).start()
+        return
+
+    updated_time = cache.dc.get("updated", 0)
+    if not isinstance(updated_time, (int, float)):
+        return
+
+    # Check if the cache was updated recently and if versions match
+    if (int(time()) - int(updated_time)) <= 30 and cache.dc.get("version") == ctx.cfg.get("cache_version", None):
+        logger.info("Index Cache - State is up-to-date, skipping checks.")
+        cache.log_stats("startup-check")
+        return
+
+    if cache.dc.get("version") != ctx.cfg["cache_version"]:
+        logger.info(f"Index Cache - New cache version {ctx.cfg.get('cache_version', 'Unspecified')} in config.")
+        # Mark resetting so UI doesn't briefly show Ready/0 devices
+        try:
+            cache.dc.set("indexing", True)
+            cache.dc.set("indexing_phase", "resetting")
+            cache.dc.set("indexing_started", int(time()))
+            cache.dc.set("indexing_last_update", int(time()))
+        except Exception:
+            pass
+        cache.reset_cache()
+
+    logger.info("Index Cache - Starting cache check and potential re-indexing.")
+    try:
+        mt_index_configurations(ctx)
+    except Exception as e:
+        logger.error(f"Index Cache - Error during background initialization: {e}", exc_info=True)
+        # Ensure the indexing flag is cleared on error
+        cache.dc.pop("indexing", None)
+
+
+def _recheck_and_index_if_needed(ctx: ScriptContext) -> None:
+    """
+    Re-run the same readiness check and trigger indexing if needed.
+    Used when we started while another process was indexing.
+    """
+    logger = ctx.logger
+    cache: CacheManager = ctx.cache  # type: ignore
+
+    if cache.dc.get("version") != ctx.cfg["cache_version"]:
+        logger.info("Index Cache - Detected version change during recheck; resetting cache.")
+        cache.reset_cache()
+
+    updated_time = cache.dc.get("updated", 0)
+    if not isinstance(updated_time, (int, float)):
+        updated_time = 0
+
+    if (int(time()) - int(updated_time)) <= 30 and cache.dc.get("version") == ctx.cfg.get("cache_version", None):
+        logger.info("Index Cache - State is up-to-date on recheck, skipping.")
+        cache.log_stats("post-foreign-index-recheck")
+        return
+
+    logger.info("Index Cache - Rechecking cache; starting (re-)index if necessary.")
+    try:
+        mt_index_configurations(ctx)
+    except Exception as e:
+        logger.error(f"Index Cache - Error during recheck: {e}", exc_info=True)
+        cache.dc.pop("indexing", None)
+
+
+def _wait_for_indexing_and_recheck(ctx: ScriptContext) -> None:
+    """
+    Waits for an external indexing to complete or become stale, then rechecks and indexes if needed.
+    """
+    logger = ctx.logger
+    cache: CacheManager = ctx.cache  # type: ignore
+    STALE_SECONDS = 180
+    POLL_SECONDS = 5
+
+    while True:
+        try:
+            # If an error was recorded during indexing, stop waiting and surface it
+            if cache.dc.get("indexing_error"):
+                logger.error("Index Cache - External indexing signaled an error. Rechecking will not start automatically.")
+                cache.dc.pop("indexing", None)
+                return
+            if not cache.dc.get("indexing"):
+                logger.info("Index Cache - External indexing finished (flag cleared). Rechecking.")
+                break
+            last = int(cache.dc.get("indexing_last_update", 0) or 0)
+            if (int(time()) - last) > STALE_SECONDS:
+                logger.warning("Index Cache - External indexing appears stale; clearing flag and rechecking.")
+                cache.dc.pop("indexing", None)
+                break
+        except Exception:
+            # Conservative: break and recheck if we cannot read the flag
+            break
+        sleep(POLL_SECONDS)
+
+    _recheck_and_index_if_needed(ctx)

cn_tool/core/base.py

@@ -0,0 +1,210 @@
+# core/base.py
+from abc import ABC, abstractmethod
+import argparse
+from dataclasses import dataclass, field
+import logging
+import sys
+from time import perf_counter
+from typing import Any, Callable, Dict, List, NamedTuple, Optional, TYPE_CHECKING
+
+from .event_bus import EventBus
+
+
+if TYPE_CHECKING:
+    from cn_tool.utils.display import ThemedConsole
+    from cn_tool.utils.cache import CacheManager
+    from cn_tool.utils.stats import StatsManager
+
+
+@dataclass(frozen=True)
+class Credentials:
+    """One account: a user name, its password, and where the password came from (``source``).
+
+    The password is not part of ``repr``, so a log line that formats the object never shows it.
+    """
+    username: str
+    password: str = field(repr=False)
+    source: str = ""  # "INFOBLOX_PW", "GPG file /home/alice/infoblox.gpg" or "prompt"
+
+
+@dataclass
+class ScriptContext:
+    """A container for shared objects used throughout the script."""
+    cfg: Dict[str, Any] = field(repr=False)  # .cn as typed: it can hold an [email] password, or one pasted into [auth]
+    logger: logging.Logger
+    console: "ThemedConsole"  # Use quotes for forward reference
+    cache: Optional["CacheManager"]  # Use quotes for forward reference
+    event_bus: EventBus
+    username: str
+    password: str = field(repr=False)  # the TACACS password: repr(ctx) never shows it
+    plugins: List["BasePlugin"]
+    stats: Optional["StatsManager"] = None
+    # Infoblox's own account once resolved; None while unknown, and always None when Infoblox uses the
+    # shared login (username/password above).
+    infoblox_credentials: Optional[Credentials] = None
+
+
+class CliResult(NamedTuple):
+    """What ``BaseModule.run_cli`` hands back: the process exit code and the sections to render."""
+    exit_code: int
+    data: Dict[str, List[Dict[str, Any]]]
+
+
+def cli_exit_code(found: bool, invalid: bool, failed: bool) -> int:
+    """Exit status of a command-line run: 3 incomplete, 2 usage error, 0 data, 1 no record.
+
+    Precedence is 3 > 2 > 0 > 1, so an Infoblox failure or unsaved report is never hidden
+    behind "found", and a usage error is never hidden behind data from the valid objects.
+    """
+    if failed:
+        return 3
+    if invalid:
+        return 2
+    return 0 if found else 1
+
+
+class BaseModule(ABC):
+    """Abstract Base Class for all main menu modules."""
+
+    #: Command under which ``cn <name>`` dispatches to ``run_cli``; None keeps the module menu-only.
+    cli_name: Optional[str] = None
+
+    def __init__(self):
+        # Hooks are points where plugins can inject logic.
+        # The key is the hook name, the value is a list of callback functions.
+        self.hooks: Dict[str, List[Callable]] = {
+            'pre_run': [],  # Called at the absolute beginning of a module's run method.
+            'process_data': [],  # Called after initial data processing.
+            'pre_render': [],   # Called just before creating tables for display.
+            'pre_save': [],     # Called just before queueing data for saving.
+            'post_run': [],     # Called at the very end of a module's run method, for cleanup.
+        }
+
+    @property
+    def visibility_config_key(self) -> Optional[str]:
+        """
+        If a string is returned, this module will only be visible in the menu
+        if the corresponding key in the configuration is True.
+        e.g., return 'email_enabled'
+        """
+        return None
+
+    @property
+    def track_in_stats(self) -> bool:
+        """Whether this module should contribute to shared usage statistics."""
+        return True
+
+    @property
+    @abstractmethod
+    def menu_key(self) -> str:
+        """The character key to trigger this module from the menu (e.g., '1', 'b')."""
+        pass
+
+    @property
+    @abstractmethod
+    def menu_title(self) -> str:
+        """The title of the module to display in the menu."""
+        pass
+
+    def register_hook(self, hook_name: str, callback: Callable):
+        """Allows plugins to register a callback for a specific hook."""
+        if hook_name in self.hooks:
+            self.hooks[hook_name].append(callback)
+        else:
+            print(f"Warning: Attempted to register for unknown hook '{hook_name}' in {self.menu_title}", file=sys.stderr)
+
+    def execute_hook(self, hook_name: str, ctx: ScriptContext, data: Any) -> Any:
+        """Executes all registered callbacks for a hook, passing data through them."""
+        modified_data = data
+        for callback in self.hooks.get(hook_name, []):
+            try:
+                # Get the plugin's name from the bound method for clear logging
+                plugin_name = callback.__self__.name
+            except AttributeError:
+                plugin_name = "Unknown Plugin"
+
+            hook_start_time = perf_counter()
+            # Each callback receives the context and the data, and must return the (potentially modified) data.
+            modified_data = callback(ctx, modified_data)
+
+            hook_end_time = perf_counter()
+            duration = round(hook_end_time - hook_start_time, 3)
+
+            ctx.logger.info(f"Plugin '{plugin_name}' hook '{hook_name}' took {duration} seconds.")
+
+        return modified_data
+
+    @abstractmethod
+    def run(self, ctx: ScriptContext) -> None:
+        """The main entry point for the module's execution."""
+        pass
+
+    def run_cli(self, ctx: ScriptContext, args: argparse.Namespace) -> CliResult:
+        """Run once from ``cn <command>`` with the parsed options; the result is rendered by main."""
+        ctx.console.print(f"{self.menu_title} is not available from the command line.")
+        return CliResult(2, {})
+
+
+class BasePlugin(ABC):
+    """Abstract Base Class for all plugins."""
+
+    @property
+    def user_configurable_settings(self) -> List[Dict[str, str]]:
+        """
+        A list of settings this plugin exposes to the user via the setup module.
+        Each dict should contain:
+        - 'key': The key in the config context (e.g., 'ad_user')
+        - 'prompt': The user-friendly prompt (e.g., 'Active Directory Username')
+        """
+        return []
+    
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """A descriptive name for the plugin."""
+        pass
+
+    @property
+    @abstractmethod
+    def target_module_name(self) -> str:
+        """The filename of the module this plugin targets (e.g., 'ip_request')."""
+        pass
+
+    @property
+    def config_schema(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Defines the configuration schema required by this plugin.
+        Each plugin can specify its own section, keys, types, and fallbacks.
+        Example:
+            return {
+                'my_plugin_key': {'section': 'myplugin', 'ini_key': 'api_key', 'type': 'str', 'fallback': ''}
+            }
+        """
+        return {}
+
+    @property
+    def manages_global_connection(self) -> bool:
+        """
+        If True, this plugin manages a persistent, application-wide connection.
+        The main application will call connect() on startup and disconnect() on exit.
+        """
+        return False
+
+    def connect(self, ctx: ScriptContext) -> None:
+        """
+        Called once on application startup if manages_global_connection is True.
+        Used to initialize persistent resources like API connections.
+        """
+        pass
+
+    def disconnect(self, ctx: ScriptContext) -> None:
+        """
+        Called once on application exit if manages_global_connection is True.
+        Used to clean up persistent resources.
+        """
+        pass
+
+    @abstractmethod
+    def register(self, module: BaseModule) -> None:
+        """Called by the loader to register the plugin's hooks with its target module."""
+        pass

cn_tool/core/event_bus.py

@@ -0,0 +1,57 @@
+"""Simple publish/subscribe event bus used for cross-module notifications."""
+from __future__ import annotations
+
+from collections import defaultdict
+import itertools
+import logging
+import threading
+from typing import Any, Callable, DefaultDict, List, Optional, Tuple
+
+EventCallback = Callable[[Any], None]
+
+
+class EventBus:
+    """Thread-safe in-process event dispatcher."""
+
+    def __init__(self, logger: Optional[logging.Logger] = None) -> None:
+        self._logger = logger
+        self._lock = threading.Lock()
+        self._subscribers: DefaultDict[str, List[Tuple[int, EventCallback]]] = defaultdict(list)
+        self._token_source = itertools.count(1)
+
+    def subscribe(self, event_name: str, callback: EventCallback) -> int:
+        """Register *callback* to be invoked when *event_name* is published."""
+        if not callable(callback):  # pragma: no cover - defensive guard
+            raise TypeError("callback must be callable")
+        token = next(self._token_source)
+        with self._lock:
+            self._subscribers[event_name].append((token, callback))
+        return token
+
+    def unsubscribe(self, token: int) -> bool:
+        """Remove a previously registered callback using its subscription *token*."""
+        with self._lock:
+            for event_name, callbacks in list(self._subscribers.items()):
+                for index, (stored_token, _) in enumerate(callbacks):
+                    if stored_token == token:
+                        callbacks.pop(index)
+                        if not callbacks:
+                            self._subscribers.pop(event_name, None)
+                        return True
+        return False
+
+    def publish(self, event_name: str, payload: Any | None = None) -> None:
+        """Invoke all listeners subscribed to *event_name* with *payload*."""
+        with self._lock:
+            callbacks = list(self._subscribers.get(event_name, ()))
+        for _, callback in callbacks:
+            try:
+                callback(payload)
+            except Exception:  # pragma: no cover - logging guard
+                if self._logger:
+                    self._logger.exception("Event handler failure for '%s'", event_name)
+
+    def clear(self) -> None:
+        """Remove every subscriber from the bus."""
+        with self._lock:
+            self._subscribers.clear()

cn_tool/core/loader.py

@@ -0,0 +1,164 @@
+# core/loader.py
+import os
+import importlib
+import inspect
+import logging
+from typing import Dict, Any
+from cn_tool.core.base import BaseModule, BasePlugin
+
+
+logger = logging.getLogger(__name__)
+
+
+def _merge_plugin_schema(schema: Dict[str, Any], plugin_schema: Dict[str, Any]) -> Dict[str, Any]:
+    """Merge plugin schema entries without discarding required base metadata."""
+    merged = schema.copy()
+    for key, plugin_spec in plugin_schema.items():
+        current_spec = merged.get(key)
+        if isinstance(current_spec, dict) and isinstance(plugin_spec, dict):
+            merged[key] = {**current_spec, **plugin_spec}
+        else:
+            merged[key] = plugin_spec
+    return merged
+
+
+def collect_plugin_schemas(master_schema: Dict[str, Any]) -> Dict[str, Any]:
+    """Harvest config_schema from every plugin without registering hooks.
+
+    Returns ``master_schema`` extended with each plugin's contributed keys.
+    Used by the standalone CLIs bundled with cn-tool so they see the same schema surface as
+    cn-tool's main entry point without pulling in module loading or hook
+    registration. Plugin files are walked in ``sorted(os.listdir(...))`` order
+    -- the same order ``_load_and_register_plugins`` uses -- so merge precedence
+    matches between the two callers.
+
+    NOTE: this instantiates each ``BasePlugin`` subclass to read its
+    ``config_schema`` property. Plugin authors must keep ``__init__`` free of
+    I/O or thread/process creation, otherwise those CLIs' runtime builds incur
+    those side effects on every invocation.
+    """
+    plugins_path = os.path.join(os.path.dirname(__file__), "..", "plugins")
+    schema = master_schema.copy()
+    if not os.path.isdir(plugins_path):
+        return schema
+    for filename in sorted(os.listdir(plugins_path)):
+        if not filename.endswith(".py") or filename.startswith("__"):
+            continue
+        module_path = f"cn_tool.plugins.{filename[:-3]}"
+        try:
+            mod = importlib.import_module(module_path)
+        except Exception as exc:
+            logger.debug("collect_plugin_schemas: import failed %s: %s", module_path, exc)
+            continue
+        for _, obj in inspect.getmembers(mod):
+            if not inspect.isclass(obj) or obj is BasePlugin:
+                continue
+            try:
+                if not issubclass(obj, BasePlugin):
+                    continue
+            except TypeError:
+                continue
+            try:
+                plugin_schema = obj().config_schema or {}
+            except Exception as exc:
+                logger.warning(
+                    "collect_plugin_schemas: could not read schema from %s: %s",
+                    obj.__name__,
+                    exc,
+                )
+                continue
+            schema = _merge_plugin_schema(schema, plugin_schema)
+    return schema
+
+
+def load_modules_and_plugins(master_schema: Dict[str, Any]) -> tuple[Dict[str, BaseModule], list[BasePlugin], Dict[str, Any]]:
+    """
+    Discovers, loads, and registers all modules and plugins.
+    It also collects configuration schemas from plugins and merges them.
+
+    Args:
+        master_schema: The base configuration schema of the application.
+
+    Returns:
+        A tuple containing:
+        - A dictionary of loaded and configured module instances.
+        - The updated master schema including plugin configurations.
+    """
+    # Start with a copy of the base schema
+    updated_schema = master_schema.copy()
+    all_plugins: list[BasePlugin] = []
+
+    modules_path = os.path.join(os.path.dirname(__file__), '..', 'modules')
+    plugins_path = os.path.join(os.path.dirname(__file__), '..', 'plugins')
+
+    modules = _load_modules(modules_path)
+    # The plugin loader now returns the updated schema
+    updated_schema = _load_and_register_plugins(plugins_path, modules, updated_schema, all_plugins)
+
+    # Return a dictionary keyed by menu_key for easy access in the main loop
+    modules_by_key = {mod.menu_key: mod for mod in modules.values()}
+
+    return modules_by_key, all_plugins, updated_schema
+
+
+def _load_modules(path: str) -> Dict[str, BaseModule]:
+    """Loads all BaseModule subclasses from a given directory."""
+    loaded_modules: Dict[str, BaseModule] = {}
+    for filename in sorted(os.listdir(path)):
+        if filename.endswith('.py') and not filename.startswith('__'):
+            module_name = filename[:-3]
+            module_path = f"cn_tool.modules.{module_name}"
+            try:
+                module = importlib.import_module(module_path)
+                for name, obj in inspect.getmembers(module):
+                    try:
+                        if inspect.isclass(obj) and issubclass(obj, BaseModule) and obj is not BaseModule:
+                            instance = obj()
+                            logger.info(f"  -> Loaded module: {instance.menu_title} ({module_name})")
+                            loaded_modules[module_name] = instance  # Instantiate the module
+                    except TypeError:
+                        continue
+            except ImportError as e:
+                logger.error("Error loading module %s: %s", module_path, e)
+    return loaded_modules
+
+
+def _load_and_register_plugins(path: str, modules: Dict[str, BaseModule], schema: Dict[str, Any], plugin_list: list[BasePlugin]) -> Dict[str, Any]:
+    """
+    Loads plugins, registers their hooks, and merges their config schemas.
+    """
+    for filename in sorted(os.listdir(path)):
+        if filename.endswith('.py') and not filename.startswith('__'):
+            module_name = filename[:-3]
+            module_path = f"cn_tool.plugins.{module_name}"
+            try:
+                module = importlib.import_module(module_path)
+                for name, obj in inspect.getmembers(module):
+                    if inspect.isclass(obj):
+                        try:
+                            if issubclass(obj, BasePlugin) and obj is not BasePlugin:
+                                plugin = obj()
+                                logger.info(f"  -> Loaded plugin: {plugin.name}")
+                                plugin_list.append(plugin)
+
+                                plugin_schema = plugin.config_schema
+                                if plugin_schema:
+                                    logger.info("Loading config schema from plugin '%s'", plugin.name)
+                                    schema = _merge_plugin_schema(schema, plugin_schema)
+
+                                target_name = plugin.target_module_name
+                                # Only attempt to register if the plugin specifies a target.
+                                if target_name:
+                                    target_module = modules.get(target_name)
+                                    if target_module:
+                                        plugin.register(target_module)
+                                    else:
+                                        # This warning will now only show for plugins that
+                                        # SPECIFY a target that does not exist.
+                                        logger.warning("Plugin '%s' targets non-existent module '%s'", plugin.name, target_name)
+                                # If target_name is empty, we do nothing. This is expected for lifecycle plugins.
+                        except TypeError:
+                            continue
+            except ImportError as e:
+                logger.error("Error loading plugin %s: %s", module_path, e)
+    return schema