redundanet 2.0.0__py3-none-any.whl

redundanet/core/node.py

@@ -0,0 +1,135 @@
+"""Node representation and management for RedundaNet."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from redundanet.core.config import NodeRole
+
+if TYPE_CHECKING:
+    from redundanet.core.config import NodeConfig
+
+
+class NodeStatus(str, Enum):
+    """Runtime status of a node."""
+
+    ONLINE = "online"
+    OFFLINE = "offline"
+    CONNECTING = "connecting"
+    ERROR = "error"
+    UNKNOWN = "unknown"
+
+
+@dataclass
+class NodeHealth:
+    """Health information for a node."""
+
+    vpn_connected: bool = False
+    storage_available: bool = False
+    introducer_reachable: bool = False
+    last_seen: datetime | None = None
+    uptime_seconds: int = 0
+    errors: list[str] = field(default_factory=list)
+
+    @property
+    def is_healthy(self) -> bool:
+        """Check if the node is in a healthy state."""
+        return self.vpn_connected and len(self.errors) == 0
+
+
+@dataclass
+class Node:
+    """Represents a node in the RedundaNet network."""
+
+    name: str
+    internal_ip: str
+    vpn_ip: str
+    roles: list[NodeRole] = field(default_factory=list)
+    public_ip: str | None = None
+    gpg_key_id: str | None = None
+    region: str | None = None
+    is_publicly_accessible: bool = False
+    storage_contribution: str | None = None
+    storage_allocation: str | None = None
+
+    # Runtime state
+    status: NodeStatus = NodeStatus.UNKNOWN
+    health: NodeHealth = field(default_factory=NodeHealth)
+
+    @classmethod
+    def from_config(cls, config: NodeConfig) -> Node:
+        """Create a Node instance from NodeConfig."""
+        return cls(
+            name=config.name,
+            internal_ip=config.internal_ip,
+            vpn_ip=config.vpn_ip or config.internal_ip,
+            roles=[NodeRole(r.value) for r in config.roles],
+            public_ip=config.public_ip,
+            gpg_key_id=config.gpg_key_id,
+            region=config.region,
+            is_publicly_accessible=config.is_publicly_accessible,
+            storage_contribution=config.storage_contribution,
+            storage_allocation=config.storage_allocation,
+        )
+
+    def has_role(self, role: NodeRole) -> bool:
+        """Check if this node has a specific role."""
+        return role in self.roles
+
+    @property
+    def is_introducer(self) -> bool:
+        """Check if this node is a Tahoe-LAFS introducer."""
+        return self.has_role(NodeRole.TAHOE_INTRODUCER)
+
+    @property
+    def is_storage(self) -> bool:
+        """Check if this node provides storage."""
+        return self.has_role(NodeRole.TAHOE_STORAGE)
+
+    @property
+    def is_client(self) -> bool:
+        """Check if this node is a Tahoe-LAFS client."""
+        return self.has_role(NodeRole.TAHOE_CLIENT)
+
+    @property
+    def is_vpn_node(self) -> bool:
+        """Check if this node participates in the VPN mesh."""
+        return self.has_role(NodeRole.TINC_VPN)
+
+    @property
+    def fqdn(self) -> str:
+        """Get the fully qualified domain name for this node."""
+        return f"{self.name}.redundanet.local"
+
+    def to_dict(self) -> dict[str, object]:
+        """Convert node to dictionary representation."""
+        return {
+            "name": self.name,
+            "internal_ip": self.internal_ip,
+            "vpn_ip": self.vpn_ip,
+            "public_ip": self.public_ip,
+            "gpg_key_id": self.gpg_key_id,
+            "region": self.region,
+            "roles": [r.value for r in self.roles],
+            "is_publicly_accessible": self.is_publicly_accessible,
+            "storage_contribution": self.storage_contribution,
+            "storage_allocation": self.storage_allocation,
+            "status": self.status.value,
+        }
+
+
+@dataclass
+class LocalNode(Node):
+    """Represents the local node with additional local-only information."""
+
+    config_path: str | None = None
+    data_path: str | None = None
+    private_key_path: str | None = None
+
+    @property
+    def is_configured(self) -> bool:
+        """Check if the local node is properly configured."""
+        return bool(self.config_path and self.private_key_path)

redundanet/network/__init__.py

@@ -0,0 +1,11 @@
+"""Network utilities module for RedundaNet."""
+
+from redundanet.network.discovery import NodeDiscovery
+from redundanet.network.dns import DNSManager
+from redundanet.network.validation import NetworkValidator
+
+__all__ = [
+    "NodeDiscovery",
+    "NetworkValidator",
+    "DNSManager",
+]

redundanet/network/discovery.py

@@ -0,0 +1,218 @@
+"""Node discovery for RedundaNet."""
+
+from __future__ import annotations
+
+import contextlib
+from dataclasses import dataclass, field
+from datetime import datetime
+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.config import NodeConfig
+    from redundanet.core.manifest import Manifest
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class DiscoveredNode:
+    """Information about a discovered node."""
+
+    name: str
+    vpn_ip: str
+    reachable: bool = False
+    latency_ms: float | None = None
+    last_seen: datetime | None = None
+    services: list[str] = field(default_factory=list)
+
+
+class NodeDiscovery:
+    """Discovers and monitors nodes in the network."""
+
+    def __init__(
+        self,
+        manifest: Manifest,
+        local_node_name: str,
+    ) -> None:
+        """Initialize node discovery.
+
+        Args:
+            manifest: Network manifest
+            local_node_name: Name of the local node
+        """
+        self.manifest = manifest
+        self.local_node_name = local_node_name
+        self._discovered: dict[str, DiscoveredNode] = {}
+
+    def discover_all(self) -> dict[str, DiscoveredNode]:
+        """Discover all nodes defined in the manifest.
+
+        Returns:
+            Dictionary mapping node name to DiscoveredNode
+        """
+        logger.info("Discovering nodes", count=len(self.manifest.nodes))
+
+        for node in self.manifest.nodes:
+            if node.name == self.local_node_name:
+                continue
+
+            discovered = self._probe_node(node)
+            self._discovered[node.name] = discovered
+
+            if discovered.reachable:
+                logger.debug(
+                    "Node reachable",
+                    node=node.name,
+                    latency_ms=discovered.latency_ms,
+                )
+            else:
+                logger.debug("Node unreachable", node=node.name)
+
+        return self._discovered
+
+    def _probe_node(self, node: NodeConfig) -> DiscoveredNode:
+        """Probe a single node for reachability.
+
+        Args:
+            node: Node configuration
+
+        Returns:
+            DiscoveredNode with probe results
+        """
+        vpn_ip = node.vpn_ip or node.internal_ip
+
+        discovered = DiscoveredNode(
+            name=node.name,
+            vpn_ip=vpn_ip,
+        )
+
+        # Ping the node
+        result = run_command(f"ping -c 2 -W 2 -q {vpn_ip}", check=False)
+
+        if result.success:
+            discovered.reachable = True
+            discovered.last_seen = datetime.now()
+
+            # Parse latency from ping output
+            for line in result.stdout.split("\n"):
+                if "rtt" in line or "round-trip" in line:
+                    parts = line.split("=")
+                    if len(parts) >= 2:
+                        times = parts[1].strip().split("/")
+                        if len(times) >= 2:
+                            with contextlib.suppress(ValueError):
+                                discovered.latency_ms = float(times[1])
+                    break
+
+            # Probe services
+            discovered.services = self._probe_services(vpn_ip, node)
+
+        return discovered
+
+    def _probe_services(self, ip: str, node: NodeConfig) -> list[str]:
+        """Probe which services are available on a node.
+
+        Args:
+            ip: Node IP address
+            node: Node configuration
+
+        Returns:
+            List of available service names
+        """
+        services = []
+
+        # Check Tahoe-LAFS ports based on roles
+        role_ports = {
+            "tahoe_introducer": node.ports.tahoe_introducer,
+            "tahoe_storage": node.ports.tahoe_storage,
+            "tahoe_client": node.ports.tahoe_client,
+        }
+
+        for role in node.roles:
+            role_str = role.value
+            if role_str in role_ports:
+                port = role_ports[role_str]
+                if self._port_open(ip, port):
+                    services.append(role_str)
+
+        return services
+
+    def _port_open(self, ip: str, port: int, timeout: float = 2.0) -> bool:
+        """Check if a TCP port is open.
+
+        Args:
+            ip: IP address
+            port: Port number
+            timeout: Timeout in seconds
+
+        Returns:
+            True if port is open
+        """
+        result = run_command(
+            f"nc -z -w {int(timeout)} {ip} {port}",
+            check=False,
+            timeout=timeout + 1,
+        )
+        return result.success
+
+    def get_reachable_nodes(self) -> list[DiscoveredNode]:
+        """Get all reachable nodes.
+
+        Returns:
+            List of reachable nodes
+        """
+        return [n for n in self._discovered.values() if n.reachable]
+
+    def get_unreachable_nodes(self) -> list[DiscoveredNode]:
+        """Get all unreachable nodes.
+
+        Returns:
+            List of unreachable nodes
+        """
+        return [n for n in self._discovered.values() if not n.reachable]
+
+    def get_nodes_with_service(self, service: str) -> list[DiscoveredNode]:
+        """Get nodes that have a specific service running.
+
+        Args:
+            service: Service name (e.g., 'tahoe_storage')
+
+        Returns:
+            List of nodes with the service
+        """
+        return [n for n in self._discovered.values() if service in n.services]
+
+    def refresh_node(self, node_name: str) -> DiscoveredNode | None:
+        """Refresh the status of a single node.
+
+        Args:
+            node_name: Name of the node to refresh
+
+        Returns:
+            Updated DiscoveredNode or None if not found
+        """
+        node = self.manifest.get_node(node_name)
+        if not node:
+            return None
+
+        discovered = self._probe_node(node)
+        self._discovered[node_name] = discovered
+        return discovered
+
+    def get_discovery_stats(self) -> dict[str, int]:
+        """Get discovery statistics.
+
+        Returns:
+            Dictionary with stats
+        """
+        total = len(self._discovered)
+        reachable = len(self.get_reachable_nodes())
+
+        return {
+            "total_nodes": total,
+            "reachable": reachable,
+            "unreachable": total - reachable,
+        }

redundanet/network/dns.py

@@ -0,0 +1,180 @@
+"""DNS and hosts file management for RedundaNet."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from redundanet.utils.files import read_file, write_file
+from redundanet.utils.logging import get_logger
+
+if TYPE_CHECKING:
+    from redundanet.core.manifest import Manifest
+
+logger = get_logger(__name__)
+
+HOSTS_MARKER_START = "# BEGIN REDUNDANET NODES"
+HOSTS_MARKER_END = "# END REDUNDANET NODES"
+
+
+class DNSManager:
+    """Manages local DNS resolution for network nodes."""
+
+    def __init__(
+        self,
+        manifest: Manifest,
+        hosts_file: Path = Path("/etc/hosts"),
+        domain: str = "redundanet.local",
+    ) -> None:
+        """Initialize DNS manager.
+
+        Args:
+            manifest: Network manifest
+            hosts_file: Path to hosts file
+            domain: Domain name for nodes
+        """
+        self.manifest = manifest
+        self.hosts_file = hosts_file
+        self.domain = domain
+        self._resolution_cache: dict[str, str] = {}
+
+    def update_hosts_file(self) -> None:
+        """Update /etc/hosts with node entries."""
+        logger.info("Updating hosts file", path=str(self.hosts_file))
+
+        # Read current hosts file
+        content = read_file(self.hosts_file) if self.hosts_file.exists() else ""
+
+        # Remove existing RedundaNet entries
+        lines = content.split("\n")
+        new_lines = []
+        in_redundanet_section = False
+
+        for line in lines:
+            if HOSTS_MARKER_START in line:
+                in_redundanet_section = True
+                continue
+            if HOSTS_MARKER_END in line:
+                in_redundanet_section = False
+                continue
+            if not in_redundanet_section:
+                new_lines.append(line)
+
+        # Add new RedundaNet entries
+        new_lines.append("")
+        new_lines.append(HOSTS_MARKER_START)
+
+        for node in self.manifest.nodes:
+            ip = node.vpn_ip or node.internal_ip
+            fqdn = f"{node.name}.{self.domain}"
+            new_lines.append(f"{ip} {node.name} {fqdn}")
+            self._resolution_cache[node.name] = ip
+            self._resolution_cache[fqdn] = ip
+
+        new_lines.append(HOSTS_MARKER_END)
+        new_lines.append("")
+
+        # Write updated hosts file
+        content = "\n".join(new_lines)
+        write_file(self.hosts_file, content, mode=0o644)
+
+        logger.info("Hosts file updated", entries=len(self.manifest.nodes))
+
+    def resolve_node(self, name: str) -> str | None:
+        """Resolve a node name to IP address.
+
+        Args:
+            name: Node name or FQDN
+
+        Returns:
+            IP address or None
+        """
+        # Check cache first
+        if name in self._resolution_cache:
+            return self._resolution_cache[name]
+
+        # Check FQDN
+        fqdn = f"{name}.{self.domain}"
+        if fqdn in self._resolution_cache:
+            return self._resolution_cache[fqdn]
+
+        # Look up in manifest
+        node = self.manifest.get_node(name)
+        if node:
+            ip = node.vpn_ip or node.internal_ip
+            self._resolution_cache[name] = ip
+            return ip
+
+        return None
+
+    def get_all_resolutions(self) -> dict[str, str]:
+        """Get all node name to IP resolutions.
+
+        Returns:
+            Dictionary mapping names to IPs
+        """
+        resolutions = {}
+
+        for node in self.manifest.nodes:
+            ip = node.vpn_ip or node.internal_ip
+            resolutions[node.name] = ip
+            resolutions[f"{node.name}.{self.domain}"] = ip
+
+        return resolutions
+
+    def remove_hosts_entries(self) -> None:
+        """Remove RedundaNet entries from hosts file."""
+        if not self.hosts_file.exists():
+            return
+
+        content = read_file(self.hosts_file)
+
+        # Remove RedundaNet section
+        lines = content.split("\n")
+        new_lines = []
+        in_redundanet_section = False
+
+        for line in lines:
+            if HOSTS_MARKER_START in line:
+                in_redundanet_section = True
+                continue
+            if HOSTS_MARKER_END in line:
+                in_redundanet_section = False
+                continue
+            if not in_redundanet_section:
+                new_lines.append(line)
+
+        content = "\n".join(new_lines)
+        write_file(self.hosts_file, content, mode=0o644)
+
+        self._resolution_cache.clear()
+        logger.info("Removed RedundaNet entries from hosts file")
+
+    def write_resolution_file(self, path: Path) -> None:
+        """Write a separate resolution file for other scripts.
+
+        Args:
+            path: Path to write resolution file
+        """
+        lines = []
+
+        for node in self.manifest.nodes:
+            ip = node.vpn_ip or node.internal_ip
+            fqdn = f"{node.name}.{self.domain}"
+            lines.append(f"{ip} {node.name} {fqdn}")
+
+        content = "\n".join(lines) + "\n"
+        write_file(path, content, mode=0o644)
+
+        logger.debug("Wrote resolution file", path=str(path))
+
+    def validate_resolution(self, name: str) -> bool:
+        """Validate that a name can be resolved.
+
+        Args:
+            name: Name to validate
+
+        Returns:
+            True if resolvable
+        """
+        return self.resolve_node(name) is not None