redundanet 2.0.0__py3-none-any.whl

redundanet/utils/files.py

@@ -0,0 +1,165 @@
+"""File utility functions for RedundaNet."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from redundanet.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+def ensure_dir(path: Path | str, mode: int = 0o755) -> Path:
+    """Ensure a directory exists, creating it if necessary.
+
+    Args:
+        path: Directory path
+        mode: Permission mode for the directory
+
+    Returns:
+        The Path object for the directory
+    """
+    path = Path(path)
+    if not path.exists():
+        path.mkdir(parents=True, mode=mode)
+        logger.debug("Created directory", path=str(path))
+    return path
+
+
+def read_yaml(path: Path | str) -> dict[str, Any]:
+    """Read and parse a YAML file.
+
+    Args:
+        path: Path to the YAML file
+
+    Returns:
+        Parsed YAML content as dictionary
+
+    Raises:
+        FileNotFoundError: If file doesn't exist
+        yaml.YAMLError: If YAML parsing fails
+    """
+    path = Path(path)
+    if not path.exists():
+        raise FileNotFoundError(f"YAML file not found: {path}")
+
+    with path.open() as f:
+        data = yaml.safe_load(f)
+
+    return data if isinstance(data, dict) else {}
+
+
+def write_yaml(path: Path | str, data: dict[str, Any], mode: int = 0o644) -> None:
+    """Write data to a YAML file.
+
+    Args:
+        path: Path to write to
+        data: Dictionary to serialize as YAML
+        mode: File permission mode
+    """
+    path = Path(path)
+    ensure_dir(path.parent)
+
+    with path.open("w") as f:
+        yaml.dump(data, f, default_flow_style=False, sort_keys=False)
+
+    path.chmod(mode)
+    logger.debug("Wrote YAML file", path=str(path))
+
+
+def safe_copy(src: Path | str, dst: Path | str, mode: int | None = None) -> Path:
+    """Safely copy a file, preserving permissions.
+
+    Args:
+        src: Source file path
+        dst: Destination file path
+        mode: Optional permission mode to set on destination
+
+    Returns:
+        Path to the destination file
+    """
+    src = Path(src)
+    dst = Path(dst)
+
+    ensure_dir(dst.parent)
+    shutil.copy2(src, dst)
+
+    if mode is not None:
+        dst.chmod(mode)
+
+    logger.debug("Copied file", src=str(src), dst=str(dst))
+    return dst
+
+
+def read_file(path: Path | str) -> str:
+    """Read a text file.
+
+    Args:
+        path: Path to the file
+
+    Returns:
+        File contents as string
+    """
+    path = Path(path)
+    return path.read_text()
+
+
+def write_file(
+    path: Path | str,
+    content: str,
+    mode: int = 0o644,
+    executable: bool = False,
+) -> Path:
+    """Write content to a text file.
+
+    Args:
+        path: Path to write to
+        content: Content to write
+        mode: File permission mode
+        executable: If True, make the file executable
+
+    Returns:
+        Path to the written file
+    """
+    path = Path(path)
+    ensure_dir(path.parent)
+
+    path.write_text(content)
+
+    if executable:
+        mode = mode | 0o111
+
+    path.chmod(mode)
+    logger.debug("Wrote file", path=str(path))
+    return path
+
+
+def remove_path(path: Path | str, ignore_errors: bool = False) -> bool:
+    """Remove a file or directory.
+
+    Args:
+        path: Path to remove
+        ignore_errors: If True, don't raise errors
+
+    Returns:
+        True if removal succeeded, False otherwise
+    """
+    path = Path(path)
+    try:
+        if path.is_file():
+            path.unlink()
+        elif path.is_dir():
+            shutil.rmtree(path)
+        else:
+            return False
+        logger.debug("Removed path", path=str(path))
+        return True
+    except (OSError, PermissionError) as e:
+        if ignore_errors:
+            logger.warning("Failed to remove path", path=str(path), error=str(e))
+            return False
+        raise

redundanet/utils/logging.py

@@ -0,0 +1,93 @@
+"""Structured logging configuration for RedundaNet."""
+
+from __future__ import annotations
+
+import contextlib
+import logging
+import sys
+from typing import Any
+
+import structlog
+from structlog.typing import Processor
+
+
+def setup_logging(
+    level: str = "INFO",
+    json_output: bool = False,
+    log_file: str | None = None,
+) -> None:
+    """Configure structured logging for the application.
+
+    Args:
+        level: Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        json_output: If True, output logs as JSON (useful for production)
+        log_file: Optional file path to write logs to
+    """
+    # Configure standard library logging
+    logging.basicConfig(
+        format="%(message)s",
+        stream=sys.stderr,
+        level=getattr(logging, level.upper()),
+    )
+
+    # Set up processors
+    shared_processors: list[Processor] = [
+        structlog.contextvars.merge_contextvars,
+        structlog.stdlib.add_log_level,
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.PositionalArgumentsFormatter(),
+        structlog.processors.TimeStamper(fmt="iso"),
+        structlog.processors.StackInfoRenderer(),
+        structlog.processors.UnicodeDecoder(),
+    ]
+
+    if json_output:
+        # JSON output for production
+        processors: list[Processor] = [
+            *shared_processors,
+            structlog.processors.format_exc_info,
+            structlog.processors.JSONRenderer(),
+        ]
+    else:
+        # Console output for development
+        processors = [
+            *shared_processors,
+            structlog.dev.ConsoleRenderer(colors=True),
+        ]
+
+    structlog.configure(
+        processors=processors,
+        wrapper_class=structlog.stdlib.BoundLogger,
+        context_class=dict,
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        cache_logger_on_first_use=True,
+    )
+
+    # Configure file handler if specified
+    if log_file:
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setLevel(getattr(logging, level.upper()))
+        logging.getLogger().addHandler(file_handler)
+
+
+def get_logger(name: str | None = None) -> structlog.stdlib.BoundLogger:
+    """Get a structured logger instance.
+
+    Args:
+        name: Logger name (typically __name__)
+
+    Returns:
+        A configured structlog logger
+    """
+    return structlog.get_logger(name)  # type: ignore[no-any-return]
+
+
+def log_context(**kwargs: Any) -> contextlib.AbstractContextManager[None]:
+    """Context manager to add context to all logs within the block.
+
+    Example:
+        with log_context(node_name="node1", operation="sync"):
+            logger.info("Starting operation")
+            # All logs here will include node_name and operation
+    """
+    return structlog.contextvars.bound_contextvars(**kwargs)

redundanet/utils/process.py

@@ -0,0 +1,226 @@
+"""Process management utilities for RedundaNet."""
+
+from __future__ import annotations
+
+import asyncio
+import shlex
+import subprocess
+from collections.abc import Sequence
+from dataclasses import dataclass
+from pathlib import Path
+
+from redundanet.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class CommandResult:
+    """Result of a command execution."""
+
+    returncode: int
+    stdout: str
+    stderr: str
+    command: str
+
+    @property
+    def success(self) -> bool:
+        """Check if the command succeeded."""
+        return self.returncode == 0
+
+    def check(self) -> None:
+        """Raise exception if command failed."""
+        if not self.success:
+            raise subprocess.CalledProcessError(
+                self.returncode,
+                self.command,
+                self.stdout,
+                self.stderr,
+            )
+
+
+def run_command(
+    command: str | Sequence[str],
+    *,
+    cwd: Path | str | None = None,
+    env: dict[str, str] | None = None,
+    timeout: float | None = None,
+    capture_output: bool = True,
+    check: bool = False,
+    input_text: str | None = None,
+) -> CommandResult:
+    """Run a shell command and return the result.
+
+    Args:
+        command: Command to run (string or list of arguments)
+        cwd: Working directory
+        env: Environment variables
+        timeout: Timeout in seconds
+        capture_output: Whether to capture stdout/stderr
+        check: If True, raise exception on non-zero exit
+        input_text: Text to send to stdin
+
+    Returns:
+        CommandResult with return code, stdout, stderr
+    """
+    if isinstance(command, str):
+        cmd_str = command
+        args = shlex.split(command)
+    else:
+        cmd_str = " ".join(command)
+        args = list(command)
+
+    logger.debug("Running command", command=cmd_str, cwd=str(cwd) if cwd else None)
+
+    try:
+        result = subprocess.run(
+            args,
+            cwd=cwd,
+            env=env,
+            timeout=timeout,
+            capture_output=capture_output,
+            text=True,
+            input=input_text,
+        )
+
+        cmd_result = CommandResult(
+            returncode=result.returncode,
+            stdout=result.stdout if capture_output else "",
+            stderr=result.stderr if capture_output else "",
+            command=cmd_str,
+        )
+
+        if check:
+            cmd_result.check()
+
+        return cmd_result
+
+    except subprocess.TimeoutExpired:
+        logger.error("Command timed out", command=cmd_str, timeout=timeout)
+        return CommandResult(
+            returncode=-1,
+            stdout="",
+            stderr=f"Command timed out after {timeout}s",
+            command=cmd_str,
+        )
+    except FileNotFoundError:
+        logger.error("Command not found", command=args[0])
+        return CommandResult(
+            returncode=-1,
+            stdout="",
+            stderr=f"Command not found: {args[0]}",
+            command=cmd_str,
+        )
+
+
+async def run_command_async(
+    command: str | Sequence[str],
+    *,
+    cwd: Path | str | None = None,
+    env: dict[str, str] | None = None,
+    timeout: float | None = None,
+    input_text: str | None = None,
+) -> CommandResult:
+    """Run a shell command asynchronously.
+
+    Args:
+        command: Command to run (string or list of arguments)
+        cwd: Working directory
+        env: Environment variables
+        timeout: Timeout in seconds
+        input_text: Text to send to stdin
+
+    Returns:
+        CommandResult with return code, stdout, stderr
+    """
+    if isinstance(command, str):
+        cmd_str = command
+        # Use shell=True for string commands
+        process = await asyncio.create_subprocess_shell(
+            command,
+            cwd=cwd,
+            env=env,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            stdin=asyncio.subprocess.PIPE if input_text else None,
+        )
+    else:
+        cmd_str = " ".join(command)
+        process = await asyncio.create_subprocess_exec(
+            *command,
+            cwd=cwd,
+            env=env,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            stdin=asyncio.subprocess.PIPE if input_text else None,
+        )
+
+    logger.debug("Running async command", command=cmd_str)
+
+    try:
+        stdin_bytes = input_text.encode() if input_text else None
+        stdout, stderr = await asyncio.wait_for(
+            process.communicate(input=stdin_bytes),
+            timeout=timeout,
+        )
+
+        return CommandResult(
+            returncode=process.returncode or 0,
+            stdout=stdout.decode() if stdout else "",
+            stderr=stderr.decode() if stderr else "",
+            command=cmd_str,
+        )
+
+    except asyncio.TimeoutError:
+        process.kill()
+        await process.wait()
+        logger.error("Async command timed out", command=cmd_str, timeout=timeout)
+        return CommandResult(
+            returncode=-1,
+            stdout="",
+            stderr=f"Command timed out after {timeout}s",
+            command=cmd_str,
+        )
+
+
+def is_command_available(command: str) -> bool:
+    """Check if a command is available in PATH.
+
+    Args:
+        command: Command name to check
+
+    Returns:
+        True if command is available
+    """
+    result = run_command(f"which {command}", check=False)
+    return result.success
+
+
+def get_pid_of(process_name: str) -> list[int]:
+    """Get PIDs of processes matching a name.
+
+    Args:
+        process_name: Process name to search for
+
+    Returns:
+        List of PIDs
+    """
+    result = run_command(f"pgrep -f {process_name}", check=False)
+    if result.success and result.stdout.strip():
+        return [int(pid) for pid in result.stdout.strip().split("\n")]
+    return []
+
+
+def kill_process(pid: int, force: bool = False) -> bool:
+    """Kill a process by PID.
+
+    Args:
+        pid: Process ID
+        force: If True, use SIGKILL instead of SIGTERM
+
+    Returns:
+        True if successful
+    """
+    signal = "-9" if force else "-15"
+    result = run_command(f"kill {signal} {pid}", check=False)
+    return result.success

redundanet/vpn/__init__.py

@@ -0,0 +1,12 @@
+"""VPN management module for RedundaNet."""
+
+from redundanet.vpn.keys import VPNKeyManager
+from redundanet.vpn.mesh import MeshNetwork
+from redundanet.vpn.tinc import TincConfig, TincManager
+
+__all__ = [
+    "TincManager",
+    "TincConfig",
+    "VPNKeyManager",
+    "MeshNetwork",
+]

redundanet/vpn/keys.py

@@ -0,0 +1,173 @@
+"""VPN key management for RedundaNet."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from redundanet.core.exceptions import VPNError
+from redundanet.utils.files import ensure_dir, read_file, write_file
+from redundanet.utils.logging import get_logger
+
+if TYPE_CHECKING:
+    from redundanet.vpn.tinc import TincConfig
+
+logger = get_logger(__name__)
+
+
+class VPNKeyManager:
+    """Manages VPN keys for node authentication."""
+
+    def __init__(self, config: TincConfig) -> None:
+        self.config = config
+        self._keys_dir = config.network_dir / "keys"
+
+    def ensure_keys_directory(self) -> Path:
+        """Ensure the keys directory exists."""
+        return ensure_dir(self._keys_dir, mode=0o700)
+
+    def import_public_key(self, node_name: str, public_key: str) -> Path:
+        """Import a public key for a remote node.
+
+        Args:
+            node_name: Name of the remote node
+            public_key: The public key content
+
+        Returns:
+            Path to the saved key file
+        """
+        if not public_key.strip():
+            raise VPNError(f"Empty public key for node {node_name}")
+
+        # Validate it looks like an RSA public key
+        if "BEGIN RSA PUBLIC KEY" not in public_key:
+            raise VPNError(f"Invalid public key format for node {node_name}")
+
+        host_file = self.config.hosts_dir / node_name
+
+        # Read existing host file or create new one
+        if host_file.exists():
+            content = read_file(host_file)
+            # Remove old key if present
+            lines = content.split("\n")
+            new_lines = []
+            in_key = False
+            for line in lines:
+                if "BEGIN RSA PUBLIC KEY" in line:
+                    in_key = True
+                if not in_key:
+                    new_lines.append(line)
+                if "END RSA PUBLIC KEY" in line:
+                    in_key = False
+
+            content = "\n".join(new_lines)
+        else:
+            content = f"# Host file for {node_name}\n"
+
+        # Append the new key
+        content = content.rstrip() + "\n\n" + public_key.strip() + "\n"
+
+        write_file(host_file, content, mode=0o644)
+        logger.info("Imported public key", node=node_name)
+
+        return host_file
+
+    def export_public_key(self) -> str:
+        """Export this node's public key.
+
+        Returns:
+            The public key as a string
+        """
+        host_file = self.config.hosts_dir / self.config.node_name
+
+        if not host_file.exists():
+            raise VPNError(f"No public key found for {self.config.node_name}")
+
+        content = read_file(host_file)
+
+        # Extract just the key portion
+        lines = content.split("\n")
+        key_lines = []
+        in_key = False
+
+        for line in lines:
+            if "BEGIN RSA PUBLIC KEY" in line:
+                in_key = True
+            if in_key:
+                key_lines.append(line)
+            if "END RSA PUBLIC KEY" in line:
+                break
+
+        if not key_lines:
+            raise VPNError(f"No public key found in host file for {self.config.node_name}")
+
+        return "\n".join(key_lines)
+
+    def export_host_file(self) -> str:
+        """Export the complete host file for this node.
+
+        Returns:
+            The complete host file content
+        """
+        host_file = self.config.hosts_dir / self.config.node_name
+
+        if not host_file.exists():
+            raise VPNError(f"No host file found for {self.config.node_name}")
+
+        return read_file(host_file)
+
+    def list_imported_keys(self) -> list[str]:
+        """List all imported node keys.
+
+        Returns:
+            List of node names with imported keys
+        """
+        nodes = []
+        if self.config.hosts_dir.exists():
+            for host_file in self.config.hosts_dir.iterdir():
+                if host_file.is_file() and host_file.name != self.config.node_name:
+                    content = read_file(host_file)
+                    if "BEGIN RSA PUBLIC KEY" in content:
+                        nodes.append(host_file.name)
+        return sorted(nodes)
+
+    def remove_key(self, node_name: str) -> bool:
+        """Remove a node's key.
+
+        Args:
+            node_name: Name of the node to remove
+
+        Returns:
+            True if removed, False if not found
+        """
+        if node_name == self.config.node_name:
+            raise VPNError("Cannot remove own node's key")
+
+        host_file = self.config.hosts_dir / node_name
+        if host_file.exists():
+            host_file.unlink()
+            logger.info("Removed key", node=node_name)
+            return True
+        return False
+
+    def verify_key(self, node_name: str) -> bool:
+        """Verify that a node's key is properly formatted.
+
+        Args:
+            node_name: Name of the node to verify
+
+        Returns:
+            True if key is valid
+        """
+        host_file = self.config.hosts_dir / node_name
+        if not host_file.exists():
+            return False
+
+        content = read_file(host_file)
+
+        # Check for required components
+        has_subnet = "Subnet = " in content
+        has_key_start = "BEGIN RSA PUBLIC KEY" in content
+        has_key_end = "END RSA PUBLIC KEY" in content
+
+        return has_subnet and has_key_start and has_key_end