redundanet 2.0.0__py3-none-any.whl

redundanet/network/validation.py

@@ -0,0 +1,279 @@
+"""Network validation for RedundaNet."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from redundanet.utils.logging import get_logger
+from redundanet.utils.process import run_command
+
+if TYPE_CHECKING:
+    from redundanet.core.manifest import Manifest
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class ValidationResult:
+    """Result of a validation check."""
+
+    name: str
+    passed: bool
+    message: str
+    details: dict[str, object] = field(default_factory=dict)
+
+
+@dataclass
+class NetworkValidationReport:
+    """Complete network validation report."""
+
+    checks: list[ValidationResult] = field(default_factory=list)
+
+    @property
+    def passed(self) -> bool:
+        """Check if all validations passed."""
+        return all(c.passed for c in self.checks)
+
+    @property
+    def failed_checks(self) -> list[ValidationResult]:
+        """Get all failed checks."""
+        return [c for c in self.checks if not c.passed]
+
+    def add_check(self, result: ValidationResult) -> None:
+        """Add a validation result."""
+        self.checks.append(result)
+
+
+class NetworkValidator:
+    """Validates network configuration and connectivity."""
+
+    def __init__(
+        self,
+        manifest: Manifest,
+        local_node_name: str,
+        vpn_interface: str = "tinc0",
+    ) -> None:
+        """Initialize network validator.
+
+        Args:
+            manifest: Network manifest
+            local_node_name: Name of the local node
+            vpn_interface: VPN interface name
+        """
+        self.manifest = manifest
+        self.local_node_name = local_node_name
+        self.vpn_interface = vpn_interface
+
+    def validate_all(self) -> NetworkValidationReport:
+        """Run all validation checks.
+
+        Returns:
+            Complete validation report
+        """
+        report = NetworkValidationReport()
+
+        # Run all checks
+        report.add_check(self.check_vpn_interface())
+        report.add_check(self.check_local_node_config())
+        report.add_check(self.check_manifest_validity())
+        report.add_check(self.check_peer_connectivity())
+        report.add_check(self.check_introducer_reachability())
+
+        return report
+
+    def check_vpn_interface(self) -> ValidationResult:
+        """Check if the VPN interface is up and configured."""
+        result = run_command(f"ip link show {self.vpn_interface}", check=False)
+
+        if not result.success:
+            return ValidationResult(
+                name="vpn_interface",
+                passed=False,
+                message=f"VPN interface {self.vpn_interface} does not exist",
+            )
+
+        if "UP" not in result.stdout:
+            return ValidationResult(
+                name="vpn_interface",
+                passed=False,
+                message=f"VPN interface {self.vpn_interface} is not up",
+            )
+
+        # Get IP address
+        result = run_command(f"ip addr show {self.vpn_interface}", check=False)
+        ip_configured = "inet " in result.stdout
+
+        return ValidationResult(
+            name="vpn_interface",
+            passed=ip_configured,
+            message="VPN interface is up and configured"
+            if ip_configured
+            else "VPN interface has no IP",
+            details={"interface": self.vpn_interface},
+        )
+
+    def check_local_node_config(self) -> ValidationResult:
+        """Check if the local node is properly configured in the manifest."""
+        node = self.manifest.get_node(self.local_node_name)
+
+        if not node:
+            return ValidationResult(
+                name="local_node_config",
+                passed=False,
+                message=f"Local node {self.local_node_name} not found in manifest",
+            )
+
+        issues = []
+
+        if not node.vpn_ip and not node.internal_ip:
+            issues.append("No VPN IP configured")
+
+        if not node.roles:
+            issues.append("No roles assigned")
+
+        if issues:
+            return ValidationResult(
+                name="local_node_config",
+                passed=False,
+                message=f"Local node configuration issues: {', '.join(issues)}",
+                details={"node_name": self.local_node_name, "issues": issues},
+            )
+
+        return ValidationResult(
+            name="local_node_config",
+            passed=True,
+            message="Local node properly configured",
+            details={"node_name": self.local_node_name, "roles": [r.value for r in node.roles]},
+        )
+
+    def check_manifest_validity(self) -> ValidationResult:
+        """Check if the manifest is valid."""
+        errors = self.manifest.validate()
+
+        if errors:
+            return ValidationResult(
+                name="manifest_validity",
+                passed=False,
+                message=f"Manifest has {len(errors)} validation error(s)",
+                details={"errors": errors},
+            )
+
+        return ValidationResult(
+            name="manifest_validity",
+            passed=True,
+            message="Manifest is valid",
+            details={"node_count": len(self.manifest.nodes)},
+        )
+
+    def check_peer_connectivity(self) -> ValidationResult:
+        """Check connectivity to peer nodes."""
+        peers = [n for n in self.manifest.nodes if n.name != self.local_node_name]
+
+        if not peers:
+            return ValidationResult(
+                name="peer_connectivity",
+                passed=True,
+                message="No peers to check",
+            )
+
+        reachable = 0
+        unreachable = []
+
+        for peer in peers:
+            ip = peer.vpn_ip or peer.internal_ip
+            result = run_command(f"ping -c 1 -W 2 {ip}", check=False)
+            if result.success:
+                reachable += 1
+            else:
+                unreachable.append(peer.name)
+
+        if len(unreachable) == len(peers):
+            return ValidationResult(
+                name="peer_connectivity",
+                passed=False,
+                message="Cannot reach any peers",
+                details={"unreachable": unreachable},
+            )
+
+        if unreachable:
+            return ValidationResult(
+                name="peer_connectivity",
+                passed=True,  # Some peers reachable is OK
+                message=f"Reached {reachable}/{len(peers)} peers",
+                details={"reachable": reachable, "unreachable": unreachable},
+            )
+
+        return ValidationResult(
+            name="peer_connectivity",
+            passed=True,
+            message=f"All {reachable} peers reachable",
+            details={"reachable": reachable},
+        )
+
+    def check_introducer_reachability(self) -> ValidationResult:
+        """Check if the introducer is reachable."""
+        introducers = self.manifest.get_introducers()
+
+        if not introducers:
+            return ValidationResult(
+                name="introducer_reachability",
+                passed=False,
+                message="No introducer configured in manifest",
+            )
+
+        # Try to reach the first introducer
+        introducer = introducers[0]
+        ip = introducer.vpn_ip or introducer.internal_ip
+        port = introducer.ports.tahoe_introducer
+
+        # Check if port is open
+        result = run_command(f"nc -z -w 5 {ip} {port}", check=False)
+
+        if result.success:
+            return ValidationResult(
+                name="introducer_reachability",
+                passed=True,
+                message=f"Introducer {introducer.name} is reachable",
+                details={"introducer": introducer.name, "address": f"{ip}:{port}"},
+            )
+
+        # Port not open, but maybe node is reachable
+        ping_result = run_command(f"ping -c 1 -W 2 {ip}", check=False)
+
+        if ping_result.success:
+            return ValidationResult(
+                name="introducer_reachability",
+                passed=False,
+                message=f"Introducer {introducer.name} reachable but port {port} closed",
+                details={"introducer": introducer.name, "address": f"{ip}:{port}"},
+            )
+
+        return ValidationResult(
+            name="introducer_reachability",
+            passed=False,
+            message=f"Introducer {introducer.name} is not reachable",
+            details={"introducer": introducer.name, "address": f"{ip}:{port}"},
+        )
+
+    def wait_for_vpn(self, timeout: float = 60.0, interval: float = 5.0) -> bool:
+        """Wait for the VPN interface to come up.
+
+        Args:
+            timeout: Maximum wait time in seconds
+            interval: Check interval in seconds
+
+        Returns:
+            True if VPN came up within timeout
+        """
+        import time
+
+        start = time.time()
+
+        while time.time() - start < timeout:
+            result = self.check_vpn_interface()
+            if result.passed:
+                return True
+            time.sleep(interval)
+
+        return False

redundanet/storage/__init__.py

@@ -0,0 +1,13 @@
+"""Tahoe-LAFS storage module for RedundaNet."""
+
+from redundanet.storage.client import TahoeClient
+from redundanet.storage.furl import FURLManager
+from redundanet.storage.introducer import TahoeIntroducer
+from redundanet.storage.storage import TahoeStorage
+
+__all__ = [
+    "TahoeClient",
+    "TahoeStorage",
+    "TahoeIntroducer",
+    "FURLManager",
+]

redundanet/storage/client.py

@@ -0,0 +1,306 @@
+"""Tahoe-LAFS client operations for RedundaNet."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from jinja2 import Template
+
+from redundanet.core.config import TahoeConfig
+from redundanet.core.exceptions import StorageError
+from redundanet.utils.files import ensure_dir, write_file
+from redundanet.utils.logging import get_logger
+from redundanet.utils.process import is_command_available, run_command
+
+logger = get_logger(__name__)
+
+TAHOE_CLIENT_CFG_TEMPLATE = """# Tahoe-LAFS client configuration
+# Generated by RedundaNet
+
+[node]
+nickname = {{ nickname }}
+web.port = tcp:{{ web_port }}:interface=127.0.0.1
+tub.port = tcp:{{ tub_port }}
+tub.location = {{ tub_location }}
+
+[client]
+introducer.furl = {{ introducer_furl }}
+shares.needed = {{ shares_needed }}
+shares.happy = {{ shares_happy }}
+shares.total = {{ shares_total }}
+
+[storage]
+enabled = false
+
+[helper]
+enabled = false
+"""
+
+
+@dataclass
+class TahoeClientConfig:
+    """Configuration for Tahoe-LAFS client."""
+
+    nickname: str
+    node_dir: Path
+    introducer_furl: str
+    web_port: int = 3456
+    tub_port: int = 34560
+    tub_location: str = "AUTO"
+    shares_needed: int = 3
+    shares_happy: int = 7
+    shares_total: int = 10
+
+    @classmethod
+    def from_tahoe_config(
+        cls,
+        nickname: str,
+        introducer_furl: str,
+        tahoe_config: TahoeConfig,
+        node_dir: Path | None = None,
+    ) -> TahoeClientConfig:
+        """Create client config from TahoeConfig."""
+        return cls(
+            nickname=nickname,
+            node_dir=node_dir or Path("/var/lib/tahoe-client"),
+            introducer_furl=introducer_furl,
+            shares_needed=tahoe_config.shares_needed,
+            shares_happy=tahoe_config.shares_happy,
+            shares_total=tahoe_config.shares_total,
+        )
+
+
+class TahoeClient:
+    """Manages Tahoe-LAFS client node."""
+
+    def __init__(self, config: TahoeClientConfig) -> None:
+        self.config = config
+        self._tahoe_cfg = config.node_dir / "tahoe.cfg"
+
+    def ensure_tahoe_installed(self) -> bool:
+        """Check if Tahoe-LAFS is installed."""
+        if not is_command_available("tahoe"):
+            raise StorageError("Tahoe-LAFS is not installed. Please install tahoe-lafs first.")
+        return True
+
+    def create_node(self) -> None:
+        """Create a new Tahoe-LAFS client node."""
+        logger.info("Creating Tahoe client node", nickname=self.config.nickname)
+
+        self.ensure_tahoe_installed()
+        ensure_dir(self.config.node_dir, mode=0o700)
+
+        # Create the node using tahoe command
+        result = run_command(
+            f"tahoe create-client --basedir={self.config.node_dir} "
+            f"--nickname={self.config.nickname}",
+            check=False,
+        )
+
+        if not result.success and "already exists" not in result.stderr:
+            raise StorageError(f"Failed to create client node: {result.stderr}")
+
+        # Write custom configuration
+        self._write_config()
+
+        logger.info("Tahoe client node created", node_dir=str(self.config.node_dir))
+
+    def _write_config(self) -> None:
+        """Write tahoe.cfg configuration file."""
+        template = Template(TAHOE_CLIENT_CFG_TEMPLATE)
+        content = template.render(
+            nickname=self.config.nickname,
+            web_port=self.config.web_port,
+            tub_port=self.config.tub_port,
+            tub_location=self.config.tub_location,
+            introducer_furl=self.config.introducer_furl,
+            shares_needed=self.config.shares_needed,
+            shares_happy=self.config.shares_happy,
+            shares_total=self.config.shares_total,
+        )
+
+        write_file(self._tahoe_cfg, content, mode=0o600)
+        logger.debug("Wrote tahoe.cfg", path=str(self._tahoe_cfg))
+
+    def start(self) -> bool:
+        """Start the Tahoe client node."""
+        logger.info("Starting Tahoe client", nickname=self.config.nickname)
+
+        result = run_command(f"tahoe start {self.config.node_dir}", check=False)
+
+        if not result.success:
+            logger.error("Failed to start Tahoe client", error=result.stderr)
+            return False
+
+        logger.info("Tahoe client started")
+        return True
+
+    def stop(self) -> bool:
+        """Stop the Tahoe client node."""
+        logger.info("Stopping Tahoe client", nickname=self.config.nickname)
+
+        result = run_command(f"tahoe stop {self.config.node_dir}", check=False)
+
+        if not result.success:
+            logger.error("Failed to stop Tahoe client", error=result.stderr)
+            return False
+
+        logger.info("Tahoe client stopped")
+        return True
+
+    def restart(self) -> bool:
+        """Restart the Tahoe client node."""
+        result = run_command(f"tahoe restart {self.config.node_dir}", check=False)
+        return result.success
+
+    def is_running(self) -> bool:
+        """Check if the Tahoe client is running."""
+        result = run_command(f"tahoe status {self.config.node_dir}", check=False)
+        return result.success and "RUNNING" in result.stdout
+
+    def get_node_url(self) -> str:
+        """Get the web UI URL for this node."""
+        return f"http://127.0.0.1:{self.config.web_port}"
+
+    def upload_file(self, local_path: Path, format_: str = "CHK") -> str:
+        """Upload a file to the grid.
+
+        Args:
+            local_path: Path to the file to upload
+            format_: Upload format (CHK, SDMF, MDMF)
+
+        Returns:
+            The capability string for the uploaded file
+        """
+        if not local_path.exists():
+            raise StorageError(f"File not found: {local_path}")
+
+        result = run_command(
+            f"tahoe put --format={format_} {local_path}",
+            cwd=self.config.node_dir,
+            check=False,
+        )
+
+        if not result.success:
+            raise StorageError(f"Upload failed: {result.stderr}")
+
+        # The capability is the last line of output
+        return result.stdout.strip().split("\n")[-1]
+
+    def download_file(self, cap: str, local_path: Path) -> Path:
+        """Download a file from the grid.
+
+        Args:
+            cap: The capability string
+            local_path: Where to save the file
+
+        Returns:
+            Path to the downloaded file
+        """
+        ensure_dir(local_path.parent)
+
+        result = run_command(
+            f"tahoe get {cap} {local_path}",
+            cwd=self.config.node_dir,
+            check=False,
+        )
+
+        if not result.success:
+            raise StorageError(f"Download failed: {result.stderr}")
+
+        return local_path
+
+    def list_directory(self, cap: str) -> list[dict[str, Any]]:
+        """List contents of a directory capability.
+
+        Args:
+            cap: Directory capability
+
+        Returns:
+            List of entries with name, type, and size
+        """
+        result = run_command(
+            f"tahoe ls --json {cap}",
+            cwd=self.config.node_dir,
+            check=False,
+        )
+
+        if not result.success:
+            raise StorageError(f"List failed: {result.stderr}")
+
+        import json
+
+        try:
+            data = json.loads(result.stdout)
+            entries = []
+            for name, info in data.get("children", {}).items():
+                entry_type, metadata = info
+                entries.append(
+                    {
+                        "name": name,
+                        "type": entry_type,
+                        "size": metadata.get("size", 0),
+                        "mutable": metadata.get("mutable", False),
+                    }
+                )
+            return entries
+        except json.JSONDecodeError:
+            return []
+
+    def check_file(self, cap: str, repair: bool = False) -> dict[str, Any]:
+        """Check the health of a file.
+
+        Args:
+            cap: Capability to check
+            repair: Whether to repair if unhealthy
+
+        Returns:
+            Health check results
+        """
+        cmd = "tahoe check"
+        if repair:
+            cmd += " --repair"
+        cmd += f" {cap}"
+
+        result = run_command(cmd, cwd=self.config.node_dir, check=False)
+
+        return {
+            "healthy": result.success,
+            "output": result.stdout,
+        }
+
+    def mount_filesystem(self, mountpoint: Path, cap: str | None = None) -> bool:
+        """Mount the Tahoe filesystem using FUSE.
+
+        Args:
+            mountpoint: Where to mount
+            cap: Optional root capability (uses alias if not provided)
+
+        Returns:
+            True if mount succeeded
+        """
+        ensure_dir(mountpoint)
+
+        cmd = f"tahoe start {self.config.node_dir}"
+        if cap:
+            cmd += f" --mountpoint={mountpoint} --cap={cap}"
+        else:
+            cmd += f" --mountpoint={mountpoint}"
+
+        # Note: tahoe-lafs FUSE mounting is complex, this is simplified
+        result = run_command(cmd, check=False)
+        return result.success
+
+    def unmount_filesystem(self, mountpoint: Path) -> bool:
+        """Unmount the Tahoe filesystem.
+
+        Args:
+            mountpoint: Mountpoint to unmount
+
+        Returns:
+            True if unmount succeeded
+        """
+        result = run_command(f"fusermount -u {mountpoint}", check=False)
+        return result.success