redundanet 2.0.0__py3-none-any.whl

redundanet/cli/node.py

@@ -0,0 +1,305 @@
+"""Node management CLI commands for RedundaNet."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from redundanet.core.config import NodeRole, NodeStatus
+from redundanet.core.manifest import Manifest
+
+app = typer.Typer(help="Node management commands")
+console = Console()
+
+
+@app.command("list")
+def list_nodes(
+    manifest_path: Annotated[
+        Optional[Path],
+        typer.Option("--manifest", "-m", help="Path to manifest file"),
+    ] = None,
+    role: Annotated[
+        Optional[str],
+        typer.Option("--role", "-r", help="Filter by role"),
+    ] = None,
+    status: Annotated[
+        Optional[str],
+        typer.Option("--status", "-s", help="Filter by status"),
+    ] = None,
+) -> None:
+    """List all nodes in the network."""
+    if manifest_path is None:
+        from redundanet.core.config import get_default_manifest_path
+
+        manifest_path = get_default_manifest_path()
+
+    if not manifest_path.exists():
+        console.print(f"[red]Error:[/red] Manifest not found: {manifest_path}")
+        raise typer.Exit(1)
+
+    manifest = Manifest.from_file(manifest_path)
+    nodes = manifest.nodes
+
+    # Apply filters
+    if role:
+        nodes = [n for n in nodes if role in [r.value for r in n.roles]]
+    if status:
+        nodes = [n for n in nodes if n.status.value == status]
+
+    # Create table
+    table = Table(title=f"RedundaNet Nodes ({len(nodes)})")
+    table.add_column("Name", style="cyan")
+    table.add_column("VPN IP", style="green")
+    table.add_column("Status")
+    table.add_column("Roles")
+    table.add_column("Region")
+
+    for node in nodes:
+        status_style = {
+            "active": "[green]active[/green]",
+            "pending": "[yellow]pending[/yellow]",
+            "inactive": "[red]inactive[/red]",
+        }.get(node.status.value, node.status.value)
+
+        roles_str = ", ".join(r.value for r in node.roles)
+
+        table.add_row(
+            node.name,
+            node.vpn_ip or node.internal_ip,
+            status_style,
+            roles_str or "[dim]none[/dim]",
+            node.region or "[dim]unknown[/dim]",
+        )
+
+    console.print(table)
+
+
+@app.command("info")
+def node_info(
+    node_name: Annotated[str, typer.Argument(help="Name of the node")],
+    manifest_path: Annotated[
+        Optional[Path],
+        typer.Option("--manifest", "-m", help="Path to manifest file"),
+    ] = None,
+) -> None:
+    """Show detailed information about a node."""
+    if manifest_path is None:
+        from redundanet.core.config import get_default_manifest_path
+
+        manifest_path = get_default_manifest_path()
+
+    if not manifest_path.exists():
+        console.print(f"[red]Error:[/red] Manifest not found: {manifest_path}")
+        raise typer.Exit(1)
+
+    manifest = Manifest.from_file(manifest_path)
+    node = manifest.get_node(node_name)
+
+    if node is None:
+        console.print(f"[red]Error:[/red] Node '{node_name}' not found")
+        raise typer.Exit(1)
+
+    # Display node info
+    table = Table(title=f"Node: {node.name}", show_header=False, box=None)
+    table.add_column("Property", style="cyan")
+    table.add_column("Value")
+
+    table.add_row("Name", node.name)
+    table.add_row("Internal IP", node.internal_ip)
+    table.add_row("VPN IP", node.vpn_ip or "[dim]same as internal[/dim]")
+    table.add_row("Public IP", node.public_ip or "[dim]not set[/dim]")
+    table.add_row("Status", node.status.value)
+    table.add_row("Region", node.region or "[dim]unknown[/dim]")
+    table.add_row("GPG Key ID", node.gpg_key_id or "[dim]not set[/dim]")
+    table.add_row("Publicly Accessible", "Yes" if node.is_publicly_accessible else "No")
+    table.add_row("Roles", ", ".join(r.value for r in node.roles) or "[dim]none[/dim]")
+    table.add_row("Storage Contribution", node.storage_contribution or "[dim]none[/dim]")
+    table.add_row("Storage Allocation", node.storage_allocation or "[dim]none[/dim]")
+
+    # Ports
+    table.add_row("", "")
+    table.add_row("[bold]Ports[/bold]", "")
+    table.add_row("  Tinc", str(node.ports.tinc))
+    table.add_row("  Tahoe Storage", str(node.ports.tahoe_storage))
+    table.add_row("  Tahoe Client", str(node.ports.tahoe_client))
+    table.add_row("  Tahoe Introducer", str(node.ports.tahoe_introducer))
+
+    console.print(table)
+
+
+@app.command("add")
+def add_node(
+    name: Annotated[str, typer.Option("--name", "-n", prompt=True, help="Node name")],
+    internal_ip: Annotated[
+        str,
+        typer.Option("--ip", "-i", prompt=True, help="Internal/VPN IP address"),
+    ],
+    public_ip: Annotated[
+        Optional[str],
+        typer.Option("--public-ip", "-p", help="Public IP address"),
+    ] = None,
+    gpg_key_id: Annotated[
+        Optional[str],
+        typer.Option("--gpg-key", "-g", help="GPG key ID"),
+    ] = None,
+    region: Annotated[
+        Optional[str],
+        typer.Option("--region", "-r", help="Geographic region"),
+    ] = None,
+    roles: Annotated[
+        Optional[list[str]],
+        typer.Option("--role", help="Node roles (can be specified multiple times)"),
+    ] = None,
+    storage: Annotated[
+        Optional[str],
+        typer.Option("--storage", "-s", help="Storage contribution"),
+    ] = None,
+    publicly_accessible: Annotated[
+        bool,
+        typer.Option("--public", help="Node is publicly accessible"),
+    ] = False,
+    manifest_path: Annotated[
+        Optional[Path],
+        typer.Option("--manifest", "-m", help="Path to manifest file"),
+    ] = None,
+) -> None:
+    """Add a new node to the manifest."""
+    from redundanet.core.config import NodeConfig, PortConfig
+
+    if manifest_path is None:
+        from redundanet.core.config import get_default_manifest_path
+
+        manifest_path = get_default_manifest_path()
+
+    if not manifest_path.exists():
+        console.print(f"[red]Error:[/red] Manifest not found: {manifest_path}")
+        console.print("Create a new manifest first or specify a valid path.")
+        raise typer.Exit(1)
+
+    manifest = Manifest.from_file(manifest_path)
+
+    # Check if node already exists
+    if manifest.get_node(name):
+        console.print(f"[red]Error:[/red] Node '{name}' already exists")
+        raise typer.Exit(1)
+
+    # Parse roles
+    node_roles = []
+    if roles:
+        for role in roles:
+            try:
+                node_roles.append(NodeRole(role))
+            except ValueError:
+                valid_roles = [r.value for r in NodeRole]
+                console.print(f"[red]Error:[/red] Invalid role '{role}'")
+                console.print(f"Valid roles: {', '.join(valid_roles)}")
+                raise typer.Exit(1) from None
+
+    # Create node config
+    node = NodeConfig(
+        name=name,
+        internal_ip=internal_ip,
+        vpn_ip=internal_ip,
+        public_ip=public_ip,
+        gpg_key_id=gpg_key_id,
+        region=region,
+        status=NodeStatus.PENDING,
+        roles=node_roles,
+        ports=PortConfig(),
+        storage_contribution=storage,
+        is_publicly_accessible=publicly_accessible,
+    )
+
+    # Add to manifest
+    manifest.add_node(node)
+    manifest.save(manifest_path)
+
+    console.print(f"[green]Added node '{name}' to manifest[/green]")
+    console.print(f"Manifest saved to: {manifest_path}")
+
+
+@app.command("remove")
+def remove_node(
+    node_name: Annotated[str, typer.Argument(help="Name of the node to remove")],
+    manifest_path: Annotated[
+        Optional[Path],
+        typer.Option("--manifest", "-m", help="Path to manifest file"),
+    ] = None,
+    force: Annotated[
+        bool,
+        typer.Option("--force", "-f", help="Skip confirmation"),
+    ] = False,
+) -> None:
+    """Remove a node from the manifest."""
+    if manifest_path is None:
+        from redundanet.core.config import get_default_manifest_path
+
+        manifest_path = get_default_manifest_path()
+
+    if not manifest_path.exists():
+        console.print(f"[red]Error:[/red] Manifest not found: {manifest_path}")
+        raise typer.Exit(1)
+
+    manifest = Manifest.from_file(manifest_path)
+
+    if not manifest.get_node(node_name):
+        console.print(f"[red]Error:[/red] Node '{node_name}' not found")
+        raise typer.Exit(1)
+
+    if not force:
+        confirm = typer.confirm(f"Are you sure you want to remove node '{node_name}'?")
+        if not confirm:
+            console.print("Aborted.")
+            raise typer.Exit(0)
+
+    manifest.remove_node(node_name)
+    manifest.save(manifest_path)
+
+    console.print(f"[green]Removed node '{node_name}' from manifest[/green]")
+
+
+@app.command("keys")
+def manage_keys(
+    action: Annotated[
+        str,
+        typer.Argument(help="Action: generate, export, import"),
+    ],
+    node_name: Annotated[
+        Optional[str],
+        typer.Option("--name", "-n", help="Node name"),
+    ] = None,
+) -> None:
+    """Manage GPG keys for node authentication."""
+    from redundanet.core.config import load_settings
+
+    settings = load_settings()
+    node_name = node_name or settings.node_name
+
+    if not node_name:
+        console.print("[red]Error:[/red] No node name specified")
+        console.print("Use --name or set REDUNDANET_NODE_NAME")
+        raise typer.Exit(1)
+
+    if action == "generate":
+        console.print(f"[bold]Generating GPG key for node: {node_name}[/bold]")
+        console.print("[yellow]Note:[/yellow] This will create a new GPG keypair.")
+        console.print("Use 'redundanet node keys export' to share your public key.")
+        # In a real implementation, we'd call the GPG module
+        console.print("[dim]GPG key generation not yet implemented[/dim]")
+
+    elif action == "export":
+        console.print(f"[bold]Exporting public key for node: {node_name}[/bold]")
+        console.print("[dim]Key export not yet implemented[/dim]")
+
+    elif action == "import":
+        console.print("[bold]Importing public key[/bold]")
+        console.print("[dim]Key import not yet implemented[/dim]")
+
+    else:
+        console.print(f"[red]Error:[/red] Unknown action '{action}'")
+        console.print("Valid actions: generate, export, import")
+        raise typer.Exit(1)

redundanet/cli/storage.py

@@ -0,0 +1,267 @@
+"""Storage management CLI commands for RedundaNet."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+
+app = typer.Typer(help="Storage management commands")
+console = Console()
+
+
+@app.command("status")
+def storage_status(
+    verbose: Annotated[
+        bool,
+        typer.Option("--verbose", "-v", help="Show detailed status"),
+    ] = False,
+) -> None:
+    """Show storage status and statistics."""
+    console.print(Panel("[bold]Storage Status[/bold]", expand=False))
+
+    # Storage overview
+    table = Table(title="Storage Overview", show_header=True)
+    table.add_column("Metric", style="cyan")
+    table.add_column("Value", style="green")
+
+    table.add_row("Contribution", "[dim]Not configured[/dim]")
+    table.add_row("Allocation", "[dim]Not configured[/dim]")
+    table.add_row("Used", "[dim]Unknown[/dim]")
+    table.add_row("Available", "[dim]Unknown[/dim]")
+
+    console.print(table)
+
+    if verbose:
+        # Tahoe-LAFS status
+        console.print("\n[bold]Tahoe-LAFS Configuration:[/bold]")
+        tahoe_table = Table(show_header=False)
+        tahoe_table.add_column("Property", style="cyan")
+        tahoe_table.add_column("Value")
+
+        tahoe_table.add_row("Shares Needed (k)", "[dim]3[/dim]")
+        tahoe_table.add_row("Shares Happy", "[dim]7[/dim]")
+        tahoe_table.add_row("Shares Total (n)", "[dim]10[/dim]")
+        tahoe_table.add_row("Introducer FURL", "[dim]Not set[/dim]")
+
+        console.print(tahoe_table)
+
+
+@app.command("start")
+def storage_start(
+    client: Annotated[
+        bool,
+        typer.Option("--client", "-c", help="Start client service"),
+    ] = True,
+    storage: Annotated[
+        bool,
+        typer.Option("--storage", "-s", help="Start storage service"),
+    ] = True,
+) -> None:
+    """Start storage services."""
+    services = []
+    if client:
+        services.append("client")
+    if storage:
+        services.append("storage")
+
+    if not services:
+        console.print("[yellow]No services specified[/yellow]")
+        return
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        for service in services:
+            task = progress.add_task(f"Starting {service}...", total=None)
+            # In a real implementation, we'd start the service
+            progress.update(task, completed=True)
+
+    console.print(f"[green]Started services: {', '.join(services)}[/green]")
+
+
+@app.command("stop")
+def storage_stop(
+    client: Annotated[
+        bool,
+        typer.Option("--client", "-c", help="Stop client service"),
+    ] = True,
+    storage: Annotated[
+        bool,
+        typer.Option("--storage", "-s", help="Stop storage service"),
+    ] = True,
+) -> None:
+    """Stop storage services."""
+    services = []
+    if client:
+        services.append("client")
+    if storage:
+        services.append("storage")
+
+    if not services:
+        console.print("[yellow]No services specified[/yellow]")
+        return
+
+    with console.status("[bold yellow]Stopping services..."):
+        pass
+
+    console.print(f"[yellow]Stopped services: {', '.join(services)}[/yellow]")
+
+
+@app.command("mount")
+def mount_storage(
+    mountpoint: Annotated[
+        Path,
+        typer.Argument(help="Directory to mount Tahoe filesystem"),
+    ] = Path("/mnt/redundanet"),
+) -> None:
+    """Mount the Tahoe-LAFS filesystem."""
+    if not mountpoint.exists():
+        console.print(f"[yellow]Creating mountpoint: {mountpoint}[/yellow]")
+        mountpoint.mkdir(parents=True, exist_ok=True)
+
+    with console.status(f"[bold green]Mounting at {mountpoint}..."):
+        # In a real implementation, we'd mount the FUSE filesystem
+        pass
+
+    console.print(f"[green]Mounted at: {mountpoint}[/green]")
+
+
+@app.command("unmount")
+def unmount_storage(
+    mountpoint: Annotated[
+        Path,
+        typer.Argument(help="Mountpoint to unmount"),
+    ] = Path("/mnt/redundanet"),
+    force: Annotated[
+        bool,
+        typer.Option("--force", "-f", help="Force unmount"),
+    ] = False,
+) -> None:
+    """Unmount the Tahoe-LAFS filesystem."""
+    with console.status(f"[bold yellow]Unmounting {mountpoint}..."):
+        # In a real implementation, we'd unmount
+        pass
+
+    console.print(f"[yellow]Unmounted: {mountpoint}[/yellow]")
+
+
+@app.command("upload")
+def upload_file(
+    source: Annotated[Path, typer.Argument(help="File or directory to upload")],
+    destination: Annotated[
+        Optional[str],
+        typer.Argument(help="Destination path in storage"),
+    ] = None,
+) -> None:
+    """Upload a file or directory to the storage grid."""
+    if not source.exists():
+        console.print(f"[red]Error:[/red] Source not found: {source}")
+        raise typer.Exit(1)
+
+    dest = destination or source.name
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task(f"Uploading {source.name}...", total=None)
+        # In a real implementation, we'd upload using Tahoe-LAFS
+        progress.update(task, completed=True)
+
+    console.print(f"[green]Uploaded:[/green] {source} -> {dest}")
+
+
+@app.command("download")
+def download_file(
+    source: Annotated[str, typer.Argument(help="Source path in storage")],
+    destination: Annotated[
+        Optional[Path],
+        typer.Argument(help="Local destination path"),
+    ] = None,
+) -> None:
+    """Download a file from the storage grid."""
+    dest = destination or Path(source).name
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task(f"Downloading {source}...", total=None)
+        # In a real implementation, we'd download using Tahoe-LAFS
+        progress.update(task, completed=True)
+
+    console.print(f"[green]Downloaded:[/green] {source} -> {dest}")
+
+
+@app.command("ls")
+def list_files(
+    path: Annotated[str, typer.Argument(help="Path to list")] = "/",
+    long: Annotated[
+        bool,
+        typer.Option("--long", "-l", help="Show detailed listing"),
+    ] = False,
+) -> None:
+    """List files in the storage grid."""
+    console.print(f"[bold]Listing: {path}[/bold]")
+
+    # In a real implementation, we'd query Tahoe-LAFS
+    table = Table(show_header=True)
+    table.add_column("Name")
+    if long:
+        table.add_column("Size")
+        table.add_column("Modified")
+        table.add_column("Cap")
+
+    console.print("[dim]No files found (storage not connected)[/dim]")
+    console.print(table)
+
+
+@app.command("info")
+def file_info(
+    path: Annotated[str, typer.Argument(help="File path to inspect")],
+) -> None:
+    """Show detailed information about a file."""
+    console.print(f"[bold]File Info: {path}[/bold]")
+
+    table = Table(show_header=False)
+    table.add_column("Property", style="cyan")
+    table.add_column("Value")
+
+    table.add_row("Path", path)
+    table.add_row("Size", "[dim]Unknown[/dim]")
+    table.add_row("Type", "[dim]Unknown[/dim]")
+    table.add_row("Shares", "[dim]Unknown[/dim]")
+    table.add_row("Health", "[dim]Unknown[/dim]")
+
+    console.print(table)
+
+
+@app.command("repair")
+def repair_file(
+    path: Annotated[str, typer.Argument(help="File path to repair")],
+    check_only: Annotated[
+        bool,
+        typer.Option("--check", "-c", help="Only check, don't repair"),
+    ] = False,
+) -> None:
+    """Check and repair file redundancy."""
+    action = "Checking" if check_only else "Repairing"
+
+    with console.status(f"[bold green]{action} {path}..."):
+        # In a real implementation, we'd run tahoe check/repair
+        pass
+
+    if check_only:
+        console.print("[green]File health: OK[/green]")
+    else:
+        console.print("[green]Repair complete[/green]")

redundanet/core/__init__.py

@@ -0,0 +1,31 @@
+"""Core business logic for RedundaNet."""
+
+from redundanet.core.config import NetworkConfig, NodeConfig, NodeRole, TahoeConfig
+from redundanet.core.exceptions import (
+    ConfigurationError,
+    ManifestError,
+    NetworkError,
+    NodeError,
+    RedundaNetError,
+    StorageError,
+    VPNError,
+)
+from redundanet.core.manifest import Manifest
+from redundanet.core.node import Node, NodeStatus
+
+__all__ = [
+    "ConfigurationError",
+    "Manifest",
+    "ManifestError",
+    "NetworkConfig",
+    "NetworkError",
+    "Node",
+    "NodeConfig",
+    "NodeError",
+    "NodeRole",
+    "NodeStatus",
+    "RedundaNetError",
+    "StorageError",
+    "TahoeConfig",
+    "VPNError",
+]