redundanet 2.0.0__py3-none-any.whl

redundanet/storage/furl.py

@@ -0,0 +1,196 @@
+"""FURL management for Tahoe-LAFS introducers."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from redundanet.core.exceptions import StorageError
+from redundanet.utils.files import read_file, read_yaml, write_file, write_yaml
+from redundanet.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+# FURL format: pb://<tubid>@<location>/<swissnum>
+FURL_PATTERN = re.compile(r"^pb://([a-z2-7]+)@([^/]+)/([a-z2-7]+)$")
+
+
+def parse_furl(furl: str) -> dict[str, str]:
+    """Parse a FURL into its components.
+
+    Args:
+        furl: The FURL string
+
+    Returns:
+        Dictionary with tubid, location, and swissnum
+    """
+    match = FURL_PATTERN.match(furl.strip())
+    if not match:
+        raise StorageError(f"Invalid FURL format: {furl}")
+
+    return {
+        "tubid": match.group(1),
+        "location": match.group(2),
+        "swissnum": match.group(3),
+    }
+
+
+def validate_furl(furl: str) -> bool:
+    """Validate a FURL format.
+
+    Args:
+        furl: The FURL string
+
+    Returns:
+        True if valid
+    """
+    try:
+        parse_furl(furl)
+        return True
+    except StorageError:
+        return False
+
+
+class FURLManager:
+    """Manages FURL distribution and synchronization."""
+
+    def __init__(
+        self,
+        manifest_path: Path,
+        cache_path: Path | None = None,
+    ) -> None:
+        """Initialize FURL manager.
+
+        Args:
+            manifest_path: Path to the network manifest
+            cache_path: Path to cache the FURL locally
+        """
+        self.manifest_path = manifest_path
+        self.cache_path = cache_path or Path("/var/lib/redundanet/introducer_furl.cache")
+
+    def get_cached_furl(self) -> str | None:
+        """Get the cached FURL if available.
+
+        Returns:
+            Cached FURL or None
+        """
+        if self.cache_path.exists():
+            try:
+                return read_file(self.cache_path).strip()
+            except Exception:
+                return None
+        return None
+
+    def cache_furl(self, furl: str) -> None:
+        """Cache a FURL locally.
+
+        Args:
+            furl: FURL to cache
+        """
+        if not validate_furl(furl):
+            raise StorageError(f"Cannot cache invalid FURL: {furl}")
+
+        self.cache_path.parent.mkdir(parents=True, exist_ok=True)
+        write_file(self.cache_path, furl, mode=0o600)
+        logger.debug("Cached FURL", path=str(self.cache_path))
+
+    def get_furl_from_manifest(self) -> str | None:
+        """Get the introducer FURL from the manifest.
+
+        Returns:
+            FURL from manifest or None
+        """
+        if not self.manifest_path.exists():
+            return None
+
+        try:
+            data = read_yaml(self.manifest_path)
+            furl = data.get("introducer_furl")
+            if furl and furl != "null":
+                return str(furl)
+            return None
+        except Exception as e:
+            logger.error("Failed to read FURL from manifest", error=str(e))
+            return None
+
+    def update_manifest_furl(self, furl: str) -> None:
+        """Update the FURL in the manifest.
+
+        Args:
+            furl: New FURL to set
+        """
+        if not validate_furl(furl):
+            raise StorageError(f"Cannot update manifest with invalid FURL: {furl}")
+
+        if not self.manifest_path.exists():
+            raise StorageError(f"Manifest not found: {self.manifest_path}")
+
+        data = read_yaml(self.manifest_path)
+        data["introducer_furl"] = furl
+        write_yaml(self.manifest_path, data)
+
+        logger.info("Updated manifest with FURL", furl=furl[:50] + "...")
+
+    def get_effective_furl(self) -> str | None:
+        """Get the effective FURL to use.
+
+        Checks manifest first, then cache.
+
+        Returns:
+            FURL to use or None
+        """
+        # First try manifest
+        furl = self.get_furl_from_manifest()
+        if furl:
+            # Update cache
+            self.cache_furl(furl)
+            return furl
+
+        # Fall back to cache
+        return self.get_cached_furl()
+
+    def sync_furl(self, local_furl: str | None = None) -> str | None:
+        """Synchronize FURL between local and manifest.
+
+        If local_furl is provided (this is an introducer), update the manifest.
+        Otherwise, fetch FURL from manifest and cache it.
+
+        Args:
+            local_furl: Local FURL if this is an introducer
+
+        Returns:
+            The synchronized FURL
+        """
+        if local_furl:
+            # This is an introducer - publish FURL to manifest
+            if validate_furl(local_furl):
+                self.update_manifest_furl(local_furl)
+                self.cache_furl(local_furl)
+                return local_furl
+            else:
+                raise StorageError(f"Invalid local FURL: {local_furl}")
+        else:
+            # This is a client/storage - get FURL from manifest
+            furl = self.get_effective_furl()
+            if furl:
+                self.cache_furl(furl)
+            return furl
+
+    def extract_introducer_ip(self) -> str | None:
+        """Extract the introducer IP from the FURL.
+
+        Returns:
+            IP address of the introducer or None
+        """
+        furl = self.get_effective_furl()
+        if not furl:
+            return None
+
+        try:
+            parsed = parse_furl(furl)
+            location = parsed["location"]
+            # Location format: ip:port or hostname:port
+            host = location.split(":")[0]
+            return host
+        except Exception:
+            return None

redundanet/storage/introducer.py

@@ -0,0 +1,175 @@
+"""Tahoe-LAFS introducer operations for RedundaNet."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from jinja2 import Template
+
+from redundanet.core.exceptions import StorageError
+from redundanet.utils.files import ensure_dir, read_file, write_file
+from redundanet.utils.logging import get_logger
+from redundanet.utils.process import is_command_available, run_command
+
+logger = get_logger(__name__)
+
+TAHOE_INTRODUCER_CFG_TEMPLATE = """# Tahoe-LAFS introducer configuration
+# Generated by RedundaNet
+
+[node]
+nickname = {{ nickname }}
+web.port = tcp:{{ web_port }}:interface=0.0.0.0
+tub.port = tcp:{{ tub_port }}
+tub.location = {{ tub_location }}
+
+[introducer]
+# This node is an introducer
+"""
+
+
+@dataclass
+class TahoeIntroducerConfig:
+    """Configuration for Tahoe-LAFS introducer."""
+
+    nickname: str
+    node_dir: Path
+    vpn_ip: str
+    web_port: int = 3458
+    tub_port: int = 3458
+
+    @property
+    def tub_location(self) -> str:
+        """Get the tub location for this introducer."""
+        return f"tcp:{self.vpn_ip}:{self.tub_port}"
+
+
+class TahoeIntroducer:
+    """Manages Tahoe-LAFS introducer node."""
+
+    def __init__(self, config: TahoeIntroducerConfig) -> None:
+        self.config = config
+        self._tahoe_cfg = config.node_dir / "tahoe.cfg"
+        self._furl_file = config.node_dir / "private" / "introducer.furl"
+
+    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.")
+        return True
+
+    def create_node(self) -> str:
+        """Create a new Tahoe-LAFS introducer node.
+
+        Returns:
+            The introducer FURL
+        """
+        logger.info("Creating Tahoe introducer", nickname=self.config.nickname)
+
+        self.ensure_tahoe_installed()
+        ensure_dir(self.config.node_dir, mode=0o700)
+
+        # Create the introducer (nickname is set in tahoe.cfg, not command line)
+        # Use --listen=none initially, we'll configure the proper settings in tahoe.cfg
+        result = run_command(
+            f"tahoe create-introducer --listen=none {self.config.node_dir}",
+            check=False,
+        )
+
+        if not result.success and "already exists" not in result.stderr:
+            raise StorageError(f"Failed to create introducer: {result.stderr}")
+
+        # Write custom configuration
+        self._write_config()
+
+        # Start the introducer to generate the FURL
+        self.start()
+
+        # Wait for FURL to be generated
+        import time
+
+        for _ in range(30):
+            if self._furl_file.exists():
+                break
+            time.sleep(1)
+
+        if not self._furl_file.exists():
+            raise StorageError("FURL file not generated after starting introducer")
+
+        furl = self.get_furl()
+        logger.info("Tahoe introducer created", furl=furl[:50] + "...")
+
+        return furl
+
+    def _write_config(self) -> None:
+        """Write tahoe.cfg configuration file."""
+        template = Template(TAHOE_INTRODUCER_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,
+        )
+
+        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 introducer."""
+        logger.info("Starting Tahoe introducer", 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 introducer", error=result.stderr)
+            return False
+
+        logger.info("Tahoe introducer started")
+        return True
+
+    def stop(self) -> bool:
+        """Stop the Tahoe introducer."""
+        logger.info("Stopping Tahoe introducer", 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 introducer", error=result.stderr)
+            return False
+
+        logger.info("Tahoe introducer stopped")
+        return True
+
+    def restart(self) -> bool:
+        """Restart the Tahoe introducer."""
+        result = run_command(f"tahoe restart {self.config.node_dir}", check=False)
+        return result.success
+
+    def is_running(self) -> bool:
+        """Check if the introducer is running."""
+        result = run_command(f"tahoe status {self.config.node_dir}", check=False)
+        return result.success and "RUNNING" in result.stdout
+
+    def get_furl(self) -> str:
+        """Get the introducer FURL.
+
+        Returns:
+            The introducer FURL string
+        """
+        if not self._furl_file.exists():
+            raise StorageError(f"FURL file not found: {self._furl_file}")
+
+        return read_file(self._furl_file).strip()
+
+    def get_status(self) -> dict[str, object]:
+        """Get introducer status."""
+        status: dict[str, object] = {
+            "running": self.is_running(),
+            "node_dir": str(self.config.node_dir),
+            "web_url": f"http://{self.config.vpn_ip}:{self.config.web_port}",
+        }
+
+        if self._furl_file.exists():
+            status["furl"] = self.get_furl()
+
+        return status

redundanet/storage/storage.py

@@ -0,0 +1,195 @@
+"""Tahoe-LAFS storage node operations for RedundaNet."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+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_STORAGE_CFG_TEMPLATE = """# Tahoe-LAFS storage node 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 = true
+reserved_space = {{ reserved_space }}
+{% if storage_dir %}storage_dir = {{ storage_dir }}{% endif %}
+
+[helper]
+enabled = false
+"""
+
+
+@dataclass
+class TahoeStorageConfig:
+    """Configuration for Tahoe-LAFS storage node."""
+
+    nickname: str
+    node_dir: Path
+    introducer_furl: str
+    reserved_space: str = "50G"
+    storage_dir: Path | None = None
+    web_port: int = 3457
+    tub_port: int = 34570
+    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,
+        storage_dir: Path | None = None,
+    ) -> TahoeStorageConfig:
+        """Create storage config from TahoeConfig."""
+        return cls(
+            nickname=nickname,
+            node_dir=node_dir or Path("/var/lib/tahoe-storage"),
+            introducer_furl=introducer_furl,
+            reserved_space=tahoe_config.reserved_space,
+            storage_dir=storage_dir,
+            shares_needed=tahoe_config.shares_needed,
+            shares_happy=tahoe_config.shares_happy,
+            shares_total=tahoe_config.shares_total,
+        )
+
+
+class TahoeStorage:
+    """Manages Tahoe-LAFS storage node."""
+
+    def __init__(self, config: TahoeStorageConfig) -> 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.")
+        return True
+
+    def create_node(self) -> None:
+        """Create a new Tahoe-LAFS storage node."""
+        logger.info("Creating Tahoe storage node", nickname=self.config.nickname)
+
+        self.ensure_tahoe_installed()
+        ensure_dir(self.config.node_dir, mode=0o700)
+
+        if self.config.storage_dir:
+            ensure_dir(self.config.storage_dir, mode=0o700)
+
+        # Create the node
+        result = run_command(
+            f"tahoe create-node --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 storage node: {result.stderr}")
+
+        # Write custom configuration
+        self._write_config()
+
+        logger.info("Tahoe storage node created", node_dir=str(self.config.node_dir))
+
+    def _write_config(self) -> None:
+        """Write tahoe.cfg configuration file."""
+        template = Template(TAHOE_STORAGE_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,
+            reserved_space=self.config.reserved_space,
+            storage_dir=str(self.config.storage_dir) if self.config.storage_dir else None,
+            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 storage node."""
+        logger.info("Starting Tahoe storage", 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 storage", error=result.stderr)
+            return False
+
+        logger.info("Tahoe storage started")
+        return True
+
+    def stop(self) -> bool:
+        """Stop the Tahoe storage node."""
+        logger.info("Stopping Tahoe storage", 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 storage", error=result.stderr)
+            return False
+
+        logger.info("Tahoe storage stopped")
+        return True
+
+    def restart(self) -> bool:
+        """Restart the Tahoe storage 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 storage node is running."""
+        result = run_command(f"tahoe status {self.config.node_dir}", check=False)
+        return result.success and "RUNNING" in result.stdout
+
+    def get_stats(self) -> dict[str, object]:
+        """Get storage statistics."""
+        stats: dict[str, object] = {
+            "running": self.is_running(),
+            "node_dir": str(self.config.node_dir),
+            "reserved_space": self.config.reserved_space,
+        }
+
+        # Try to get disk usage
+        storage_path = self.config.storage_dir or (self.config.node_dir / "storage" / "shares")
+        if storage_path.exists():
+            result = run_command(f"du -sh {storage_path}", check=False)
+            if result.success:
+                stats["used_space"] = result.stdout.split()[0]
+
+        return stats
+
+    def update_introducer_furl(self, furl: str) -> None:
+        """Update the introducer FURL in the configuration."""
+        self.config.introducer_furl = furl
+        self._write_config()
+        logger.info("Updated introducer FURL")

redundanet/utils/__init__.py

@@ -0,0 +1,15 @@
+"""Utility functions for RedundaNet."""
+
+from redundanet.utils.files import ensure_dir, read_yaml, write_yaml
+from redundanet.utils.logging import get_logger, setup_logging
+from redundanet.utils.process import run_command, run_command_async
+
+__all__ = [
+    "ensure_dir",
+    "get_logger",
+    "read_yaml",
+    "run_command",
+    "run_command_async",
+    "setup_logging",
+    "write_yaml",
+]