flux-config-shared 0.1.0__tar.gz

flux_config_shared-0.1.0/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.3
+Name: flux-config-shared
+Version: 0.1.0
+Summary: Shared protocol and configuration definitions for Flux Config packages
+Author: David White
+Author-email: David White <david@runonflux.io>
+License: GPL-3.0-or-later
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: System :: Monitoring
+Requires-Dist: pyyaml>=6.0.2,<7
+Requires-Dist: aiofiles>=25.1.0,<26
+Requires-Dist: textual>=6.11.0,<7
+Requires-Dist: pydantic>=2.10.6,<3
+Requires-Dist: sshpubkeys>=3.3.1,<4
+Requires-Dist: email-validator>=2.2.0,<2.3
+Requires-Dist: pyrage>=1.3.0
+Requires-Dist: flux-delegate-starter>=0.1.0
+Requires-Python: >=3.13, <4
+Description-Content-Type: text/markdown
+
+# flux-config-shared
+
+Shared protocol and configuration definitions for Flux Config packages.
+
+This package contains:
+- JSON-RPC protocol definitions
+- Daemon state models
+- User configuration models
+- Application configuration (AppConfig)
+- Delegate configuration
+- Pydantic validation models
+
+Used by:
+- flux-configd (daemon)
+- flux-config-tui (TUI client)

flux_config_shared-0.1.0/README.md

@@ -0,0 +1,15 @@
+# flux-config-shared
+
+Shared protocol and configuration definitions for Flux Config packages.
+
+This package contains:
+- JSON-RPC protocol definitions
+- Daemon state models
+- User configuration models
+- Application configuration (AppConfig)
+- Delegate configuration
+- Pydantic validation models
+
+Used by:
+- flux-configd (daemon)
+- flux-config-tui (TUI client)

flux_config_shared-0.1.0/pyproject.toml

@@ -0,0 +1,57 @@
+[project]
+name = "flux-config-shared"
+version = "0.1.0"
+description = "Shared protocol and configuration definitions for Flux Config packages"
+authors = [{ name = "David White", email = "david@runonflux.io" }]
+requires-python = ">=3.13, <4"
+readme = "README.md"
+license = { text = "GPL-3.0-or-later" }
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: System Administrators",
+    "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: System :: Systems Administration",
+    "Topic :: System :: Monitoring",
+]
+
+dependencies = [
+    "pyyaml>=6.0.2,<7",
+    "aiofiles>=25.1.0,<26",
+    "textual>=6.11.0,<7",
+    "pydantic>=2.10.6,<3",
+    "sshpubkeys>=3.3.1,<4",
+    "email_validator>=2.2.0,<2.3",
+    "pyrage>=1.3.0",
+    "flux-delegate-starter>=0.1.0",
+]
+
+[build-system]
+requires = ["uv_build>=0.9.18,<0.10.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = ["flux_config_shared"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py313"
+
+[tool.ruff.lint]
+select = [
+    "E",      # pycodestyle errors
+    "F",      # pyflakes
+    "I",      # isort (import sorting)
+    "N",      # pep8-naming
+    "UP",     # pyupgrade
+    "ANN",    # flake8-annotations
+    "ASYNC",  # flake8-async
+    "S",      # flake8-bandit (security)
+    "B",      # flake8-bugbear
+    "C4",     # flake8-comprehensions
+    "DTZ",    # flake8-datetimez
+]
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["F401"]  # Unused imports OK in __init__

flux_config_shared-0.1.0/src/flux_config_shared/__init__.py

@@ -0,0 +1,23 @@
+"""Shared protocol definitions for flux_config."""
+
+from flux_config_shared.app_config import AppConfig
+from flux_config_shared.protocol import (
+    Event,
+    EventType,
+    JsonRpcError,
+    JsonRpcRequest,
+    JsonRpcResponse,
+    MethodName,
+    RPCErrorCode,
+)
+
+__all__ = [
+    "AppConfig",
+    "Event",
+    "EventType",
+    "JsonRpcError",
+    "JsonRpcRequest",
+    "JsonRpcResponse",
+    "MethodName",
+    "RPCErrorCode",
+]

flux_config_shared-0.1.0/src/flux_config_shared/app_config.py

@@ -0,0 +1,102 @@
+"""Application configuration for TUI and other clients."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field, fields
+from typing import ClassVar
+
+import aiofiles
+import yaml
+from textual.theme import BUILTIN_THEMES
+
+
+@dataclass
+class AppConfig:
+    config_path: ClassVar[str] = "/mnt/root/config/app_config.yaml"
+    theme: str = "flexoki"
+    poweroff_screen: int = 0
+    screen_resolutions: list[str] = field(default_factory=list)
+    selected_resolution: str | None = None
+
+    asdict = asdict
+
+    @classmethod
+    def from_file(cls) -> AppConfig:
+        try:
+            with open(cls.config_path) as f:
+                data = f.read()
+        except FileNotFoundError:
+            instance = cls()
+            instance.persist_sync()
+            return instance
+
+        conf: dict = yaml.safe_load(data)
+
+        filtered = {field.name: conf.get(field.name) for field in fields(cls) if field.name in conf}
+
+        return cls(**filtered)
+
+    async def update(
+        self,
+        *,
+        theme: str | None = None,
+        poweroff_screen: int | None = None,
+        resolutions: list[str] | None = None,
+        selected_resolution: str | None = None,
+    ) -> None:
+        needs_persist = False
+
+        if theme and theme in BUILTIN_THEMES and self.theme != theme:
+            self.theme = theme
+            needs_persist = True
+
+        if poweroff_screen is not None and self.poweroff_screen != poweroff_screen:
+            self.poweroff_screen = poweroff_screen
+            needs_persist = True
+
+        if resolutions:
+            self.screen_resolutions = resolutions
+            needs_persist = True
+
+        if selected_resolution and self.selected_resolution != selected_resolution:
+            self.selected_resolution = selected_resolution
+            needs_persist = True
+
+        if needs_persist:
+            await self.persist()
+
+    def update_sync(
+        self,
+        *,
+        theme: str | None = None,
+        poweroff_screen: int | None = None,
+        resolutions: list[str] | None = None,
+    ) -> None:
+        needs_persist = False
+
+        if theme and theme in BUILTIN_THEMES and self.theme != theme:
+            self.theme = theme
+            needs_persist = True
+
+        if poweroff_screen is not None and self.poweroff_screen != poweroff_screen:
+            self.poweroff_screen = poweroff_screen
+            needs_persist = True
+
+        if resolutions:
+            self.screen_resolutions = resolutions
+            needs_persist = True
+
+        if needs_persist:
+            self.persist_sync()
+
+    async def persist(self) -> None:
+        conf = yaml.dump(self.asdict())
+
+        async with aiofiles.open(AppConfig.config_path, "w") as f:
+            await f.write(conf)
+
+    def persist_sync(self) -> None:
+        conf = yaml.dump(self.asdict())
+
+        with open(AppConfig.config_path, "w") as f:
+            f.write(conf)

flux_config_shared-0.1.0/src/flux_config_shared/config_locations.py

@@ -0,0 +1,46 @@
+"""Configuration file locations for Flux services."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class ConfigLocations:
+    """Standard configuration file locations for Flux services.
+
+    This matches the original ConfigLocations class from config_builder.py
+    """
+
+    # Daemon configs
+    fluxd: Path = Path("/dat/var/lib/fluxd/flux.conf")
+    fluxd_seed_nodes: Path = Path("/mnt/root/config/seed_nodes.yaml")
+    fluxbenchd: Path = Path("/dat/usr/lib/fluxbenchd/fluxbench.conf")
+    fluxos: Path = Path("/dat/usr/lib/fluxos/config/userconfig.js")
+    flux_watchdog: Path = Path("/dat/usr/lib/fluxwatchdog/config.js")
+    syncthing: Path = Path("/dat/usr/lib/syncthing/config.xml")
+
+    # SSH configs
+    ssh_auth_flux: Path = Path("/mnt/root/config/ssh/authorized_keys")
+    ssh_auth_fs: Path = Path("/home/operator/.ssh/authorized_keys")
+
+    # Systemd configs
+    fluxadm_ssh_socket: Path = Path("/etc/systemd/system/fluxadm-ssh.socket.d/override.conf")
+
+    # Firewall configs
+    fluxadm_ufw: Path = Path("/etc/ufw/applications.d/fluxadm-ssh")
+    fail2ban: Path = Path("/etc/fail2ban/jail.d/defaults-debian.conf")
+
+    # X11/Display configs
+    xorg_serverflags: Path = Path("/etc/X11/xorg.conf.d/10-serverflags.conf")
+    xorg_serverflags_persistent: Path = Path(
+        "/mnt/root/config/etc/X11/xorg.conf.d/10-serverflags.conf"
+    )
+
+    # Application configs
+    config_dir: Path = Path("/mnt/root/config")
+    logs_dir: Path = Path("/var/log/flux_config")
+    user_config: Path = Path("/mnt/root/config/flux_user_config.yaml")
+    installer_config: Path = Path("/mnt/root/config/flux_config.yaml")
+    shaping_policy: Path = Path("/mnt/root/config/shaping_policy.json")

flux_config_shared-0.1.0/src/flux_config_shared/daemon_state.py

@@ -0,0 +1,163 @@
+"""Unified daemon state model for synchronization between daemon and TUI."""
+
+from __future__ import annotations
+
+import time
+from dataclasses import asdict, dataclass, field
+from enum import Enum
+
+
+class DaemonPhase(str, Enum):
+    """Daemon lifecycle phases (simplified state machine).
+
+    Phases represent daemon's overall state, NOT UI loading states.
+    Use SystemStatus enums to determine specific loading messages.
+    """
+
+    INITIALIZING = "initializing"
+    RUNNING = "running"
+    ERROR = "error"
+
+
+class DatMountStatus(str, Enum):
+    """Data crypt mount status (replaces ad-hoc status_message)."""
+
+    PENDING = "pending"
+    MOUNTING = "mounting"
+    DELAYED = "delayed"
+    FAILED = "failed"
+    COMPLETE = "complete"
+
+
+class ConnectivityStatus(str, Enum):
+    """Network connectivity status."""
+
+    UNKNOWN = "unknown"
+    CHECKING = "checking"
+    VALIDATED = "validated"
+    FAILED = "failed"
+
+
+@dataclass
+class InitializationStatus:
+    """Tracks initialization progress without ad-hoc strings."""
+
+    completed_milestones: set[str] = field(default_factory=set)
+    current_operation: str | None = None
+    current_operation_started_at: float | None = None
+    blocked_on: list[str] = field(default_factory=list)
+
+    def is_complete(self) -> bool:
+        """Check if all key milestones are complete."""
+        key_milestones = {"dat_mounted", "db_state_populated", "connectivity_validated"}
+        return key_milestones.issubset(self.completed_milestones)
+
+
+@dataclass
+class SystemStatus:
+    """System readiness status using enums (replaces status_message + fatal_error)."""
+
+    dat_mount_status: DatMountStatus = DatMountStatus.PENDING
+    dat_mount_error: str | None = None
+
+    connectivity_status: ConnectivityStatus = ConnectivityStatus.UNKNOWN
+    connectivity_error: str | None = None
+    connectivity_checked_at: float | None = None
+
+    db_populated: bool = False
+    db_error: str | None = None
+
+    fatal_error: dict[str, str] | None = None
+
+
+@dataclass
+class ServiceStates:
+    """Service running states."""
+
+    fluxd_started: bool = False
+    fluxbenchd_started: bool = False
+    fluxos_started: bool = False
+    syncthing_started: bool = False
+    flux_watchdog_started: bool = False
+
+
+@dataclass
+class NetworkInfo:
+    """Network information."""
+
+    public_ip: str | None = None
+    local_ip: str | None = None
+    connected: bool = False
+
+
+@dataclass
+class BlockchainInfo:
+    """Blockchain information."""
+
+    height: int | None = None
+
+
+@dataclass
+class SystemInfo:
+    """System information."""
+
+    secureboot_enforced: bool = False
+
+
+@dataclass
+class WebserverInfo:
+    """Webserver state."""
+
+    host: str | None = None
+    port: int | None = None
+    token: str | None = None
+
+
+@dataclass
+class ConfigInfo:
+    """Configuration state."""
+
+    installer_config: dict | None = None
+    user_config: dict | None = None
+
+
+@dataclass
+class DaemonState:
+    """Complete daemon state - single source of truth."""
+
+    phase: DaemonPhase = DaemonPhase.INITIALIZING
+
+    install_state: str = "UNKNOWN"
+    reconfigure_mode: str | None = None
+
+    initialization: InitializationStatus = field(default_factory=InitializationStatus)
+
+    system_status: SystemStatus = field(default_factory=SystemStatus)
+
+    services: ServiceStates = field(default_factory=ServiceStates)
+
+    network: NetworkInfo = field(default_factory=NetworkInfo)
+
+    blockchain: BlockchainInfo = field(default_factory=BlockchainInfo)
+
+    system: SystemInfo = field(default_factory=SystemInfo)
+
+    webserver: WebserverInfo = field(default_factory=WebserverInfo)
+
+    tunnel: dict = field(default_factory=dict)
+
+    config: ConfigInfo = field(default_factory=ConfigInfo)
+
+    active_tasks: list[dict] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization."""
+        result = asdict(self)
+        result["phase"] = self.phase.value
+        result["system_status"]["dat_mount_status"] = (
+            self.system_status.dat_mount_status.value
+        )
+        result["system_status"]["connectivity_status"] = (
+            self.system_status.connectivity_status.value
+        )
+        return result

flux_config_shared-0.1.0/src/flux_config_shared/delegate_config.py

@@ -0,0 +1,112 @@
+"""Delegate node starting configuration."""
+
+from __future__ import annotations
+
+import base64
+import re
+from dataclasses import asdict
+
+import pyrage
+from pydantic import ConfigDict, Field, field_validator
+from pydantic.dataclasses import dataclass as py_dataclass
+from pydantic_core import to_jsonable_python
+
+
+WIF_PATTERN = r"^[5KLc9][1-9A-HJ-NP-Za-km-z]{50,51}$"
+COMPRESSED_PUBKEY_PATTERN = r"^(02|03)[0-9a-fA-F]{64}$"
+
+
+def validate_wif_format(wif: str) -> bool:
+    """Validate WIF private key format.
+
+    Args:
+        wif: WIF format private key string
+
+    Returns:
+        True if valid WIF format, False otherwise
+    """
+    return bool(re.match(WIF_PATTERN, wif))
+
+
+def encrypt_delegate_key(wif_key: str, passphrase: str) -> str:
+    """Encrypt a WIF private key with age passphrase encryption.
+
+    Args:
+        wif_key: WIF format private key
+        passphrase: Encryption passphrase
+
+    Returns:
+        Base64-encoded age-encrypted ciphertext
+    """
+    encrypted_bytes = pyrage.passphrase.encrypt(wif_key.encode("utf-8"), passphrase)
+    return base64.b64encode(encrypted_bytes).decode("utf-8")
+
+
+def decrypt_delegate_key(encrypted: str, passphrase: str) -> str:
+    """Decrypt an age-encrypted WIF private key.
+
+    Args:
+        encrypted: Base64-encoded age-encrypted ciphertext
+        passphrase: Decryption passphrase
+
+    Returns:
+        Decrypted WIF private key
+
+    Raises:
+        binascii.Error: If encrypted data is not valid base64
+        pyrage.DecryptError: If passphrase is incorrect
+    """
+    encrypted_bytes = base64.b64decode(encrypted)
+    decrypted = pyrage.passphrase.decrypt(encrypted_bytes, passphrase)
+    return decrypted.decode("utf-8")
+
+
+@py_dataclass(config=ConfigDict(populate_by_name=True))
+class Delegate:
+    """Delegate node starting configuration."""
+
+    delegate_private_key_encrypted: str | None = Field(
+        default=None, alias="delegatePrivateKeyEncrypted"
+    )
+    collateral_pubkey: str | None = Field(default=None, alias="collateralPubkey")
+
+    asdict = asdict
+
+    @field_validator("collateral_pubkey", mode="after")
+    @classmethod
+    def validate_collateral_pubkey(cls, value: str | None) -> str | None:
+        """Validate compressed public key format.
+
+        Args:
+            value: Compressed public key (66 hex chars, 02/03 prefix)
+
+        Returns:
+            Validated pubkey in lowercase
+
+        Raises:
+            ValueError: If pubkey format is invalid
+        """
+        if not value:
+            return value
+
+        if not re.match(COMPRESSED_PUBKEY_PATTERN, value):
+            raise ValueError("Collateral pubkey must be 66 hex chars with 02/03 prefix")
+
+        return value.lower()
+
+    @property
+    def is_configured(self) -> bool:
+        """Check if delegate is fully configured.
+
+        Returns:
+            True if both encrypted key and collateral pubkey are set
+        """
+        return bool(self.delegate_private_key_encrypted and self.collateral_pubkey)
+
+    def to_ui_dict(self) -> dict:
+        """Convert to UI dictionary format with camelCase keys.
+
+        Returns:
+            Dictionary with camelCase keys for UI
+        """
+        return to_jsonable_python(self, by_alias=True)

flux_config_shared-0.1.0/src/flux_config_shared/log.py

@@ -0,0 +1,124 @@
+"""Shared logging configuration for flux_config packages.
+
+This module provides a centralized logging configuration function.
+Each application (daemon, TUI, CLI) should call configure_logging() at startup.
+
+Best practice: Libraries should NOT configure handlers, only applications should.
+See: https://docs.python-guide.org/writing/logging/
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import sys
+from logging.config import dictConfig
+from pathlib import Path
+
+# Track if logging has been configured to avoid duplicate setup
+_configured = False
+
+
+def configure_logging(
+    app_name: str,
+    *,
+    use_textual: bool = False,
+    log_level: int = logging.INFO,
+) -> None:
+    """Configure logging for an application.
+
+    This should be called once at application startup. Each app gets its own
+    log directory and file: /var/log/{app_name}/{app_name}.log
+
+    Args:
+        app_name: Application name for log file (e.g., "flux-configd", "flux-config-tui")
+        use_textual: Use TextualHandler for console output (for TUI apps)
+        log_level: Logging level (default: INFO)
+    """
+    global _configured  # noqa: PLW0603
+
+    if _configured:
+        logging.getLogger(__name__).warning(
+            f"Logging already configured, ignoring configure_logging({app_name})"
+        )
+        return
+
+    # Determine if we can write to log directory
+    log_file = None
+    try:
+        log_dir = Path(f"/var/log/{app_name}")
+        if not log_dir.exists():
+            log_dir.mkdir(parents=True, exist_ok=True)
+        if os.access(log_dir, os.W_OK):
+            log_file = log_dir / f"{app_name}.log"
+    except (PermissionError, OSError):
+        pass
+
+    # Build handlers
+    handlers: dict = {}
+
+    # Console handler - TextualHandler for TUI, StreamHandler for others
+    if use_textual:
+        handlers["console"] = {
+            "level": "INFO",
+            "formatter": "standard",
+            "class": "textual.logging.TextualHandler",
+        }
+    elif sys.stdout.isatty():
+        # Only add console handler if running interactively
+        handlers["console"] = {
+            "level": "INFO",
+            "formatter": "standard",
+            "class": "logging.StreamHandler",
+            "stream": "ext://sys.stdout",
+        }
+
+    # File handler (if we can write)
+    if log_file:
+        handlers["file"] = {
+            "level": "DEBUG",  # File gets all logs
+            "formatter": "detailed",
+            "class": "logging.handlers.RotatingFileHandler",
+            "filename": str(log_file),
+            "mode": "a",
+            "maxBytes": 50 * 1024 * 1024,  # 50MB
+            "backupCount": 5,
+            "encoding": "utf-8",
+        }
+
+    # Determine which handlers to use for loggers
+    logger_handlers = list(handlers.keys())
+
+    # Build the config
+    config = {
+        "version": 1,
+        "disable_existing_loggers": False,  # Important: don't break existing loggers
+        "formatters": {
+            "standard": {
+                "format": "{asctime} [{levelname}] {name}: {message}",
+                "datefmt": "%H:%M:%S",
+                "style": "{",
+            },
+            "detailed": {
+                "format": "{asctime} [{levelname}] {name}:{lineno} - {message}",
+                "datefmt": "%Y-%m-%d %H:%M:%S",
+                "style": "{",
+            },
+        },
+        "handlers": handlers,
+        "root": {
+            "handlers": logger_handlers,
+            "level": log_level,
+        },
+    }
+
+    # Apply configuration
+    dictConfig(config)
+
+    # Suppress noisy library logs
+    logging.getLogger("websockets").setLevel(logging.WARNING)
+    logging.getLogger("websockets.server").setLevel(logging.WARNING)
+    logging.getLogger("urllib3.connectionpool").setLevel(logging.WARNING)
+    logging.getLogger("asyncio").setLevel(logging.WARNING)
+
+    _configured = True