246 lines
7.5 KiB
Python
246 lines
7.5 KiB
Python
"""Network browser — discovers NomadNet nodes and fetches pages via Reticulum.
|
|
|
|
Starts an RNS transport on FastAPI startup, listens for NomadNet node
|
|
announces, and exposes discovered nodes + remote page fetching via API.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import logging
|
|
import os
|
|
import threading
|
|
import time
|
|
from pathlib import Path
|
|
|
|
from fastapi import APIRouter, Query
|
|
|
|
router = APIRouter()
|
|
log = logging.getLogger("browse")
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Module-level state
|
|
# ---------------------------------------------------------------------------
|
|
|
|
_nodes: dict[str, dict] = {} # hash_hex -> node info
|
|
_own_hash: str | None = None
|
|
_own_name: str = os.environ.get("NOMADNET_NODE_NAME", "Micronomicon")
|
|
_lock = threading.Lock()
|
|
_started = False
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# RNS lifecycle
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def start_browser() -> None:
|
|
"""Initialize RNS and begin listening for NomadNet node announces."""
|
|
global _started, _own_hash
|
|
|
|
if _started:
|
|
return
|
|
|
|
try:
|
|
import RNS
|
|
|
|
configdir = os.environ.get("RNS_CONFIG_DIR", None)
|
|
if configdir:
|
|
Path(configdir).mkdir(parents=True, exist_ok=True)
|
|
|
|
reticulum = RNS.Reticulum(configdir=configdir)
|
|
|
|
# Register handler for NomadNet page-serving node announces
|
|
RNS.Transport.register_announce_handler(
|
|
_on_announce,
|
|
aspect_filter="nomadnetwork.node",
|
|
)
|
|
|
|
_started = True
|
|
log.info("RNS browser started (v%s)", RNS.__version__)
|
|
|
|
except Exception as exc:
|
|
log.warning("Failed to start RNS browser: %s", exc)
|
|
|
|
|
|
def _on_announce(
|
|
destination_hash: bytes,
|
|
announced_identity,
|
|
app_data: bytes | None,
|
|
) -> None:
|
|
"""Handle an incoming NomadNet node announce."""
|
|
import RNS
|
|
|
|
hash_hex = RNS.hexrep(destination_hash, delimit=False)
|
|
|
|
name = hash_hex[:12]
|
|
if app_data:
|
|
try:
|
|
name = app_data.decode("utf-8")
|
|
except Exception:
|
|
pass
|
|
|
|
is_self = name == _own_name
|
|
|
|
with _lock:
|
|
_nodes[hash_hex] = {
|
|
"hash": hash_hex,
|
|
"name": name,
|
|
"last_seen": time.time(),
|
|
"is_self": is_self,
|
|
}
|
|
if is_self:
|
|
global _own_hash
|
|
_own_hash = hash_hex
|
|
|
|
log.info("Node announce: %s (%s)%s", name, hash_hex[:8], " [self]" if is_self else "")
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# API endpoints
|
|
# ---------------------------------------------------------------------------
|
|
|
|
@router.get("/browse/nodes")
|
|
async def list_nodes():
|
|
"""Return all discovered NomadNet page-serving nodes."""
|
|
with _lock:
|
|
nodes = list(_nodes.values())
|
|
|
|
# Ensure the user's own node is always present
|
|
if not any(n["is_self"] for n in nodes):
|
|
nodes.insert(0, {
|
|
"hash": _own_hash or "self",
|
|
"name": _own_name,
|
|
"last_seen": time.time(),
|
|
"is_self": True,
|
|
})
|
|
|
|
return nodes
|
|
|
|
|
|
@router.get("/browse/page/{hash_hex}")
|
|
async def get_remote_page(hash_hex: str, path: str = Query("index.mu")):
|
|
"""Fetch a Micron page from a node.
|
|
|
|
For the user's own node reads from the local pages directory.
|
|
For remote nodes establishes an RNS link and requests the page.
|
|
"""
|
|
# Own node → read from disk
|
|
with _lock:
|
|
node = _nodes.get(hash_hex)
|
|
if (node and node.get("is_self")) or hash_hex == "self":
|
|
return _read_local_page(path)
|
|
|
|
# Remote node → RNS request
|
|
content = await _request_remote_page(hash_hex, path)
|
|
if content is None:
|
|
return {"content": None, "error": "Could not reach node"}
|
|
return {"content": content}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Local page reader
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _read_local_page(path: str) -> dict:
|
|
pages_dir = os.environ.get("PAGES_DIR", str(Path.home() / ".nomadnetwork/storage/pages"))
|
|
filepath = Path(pages_dir) / path
|
|
try:
|
|
return {"content": filepath.read_text()}
|
|
except FileNotFoundError:
|
|
return {"content": None, "error": "Page not found"}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Remote page fetcher (RNS link + request/response)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
async def _request_remote_page(hash_hex: str, path: str) -> str | None:
|
|
"""Establish an RNS link to a remote NomadNet node and request a page."""
|
|
try:
|
|
import RNS
|
|
except ImportError:
|
|
return None
|
|
|
|
loop = asyncio.get_event_loop()
|
|
future: asyncio.Future[str | None] = loop.create_future()
|
|
|
|
def _do_request():
|
|
try:
|
|
dest_hash = bytes.fromhex(hash_hex)
|
|
|
|
# Ensure path to destination is known
|
|
if not RNS.Transport.has_path(dest_hash):
|
|
RNS.Transport.request_path(dest_hash)
|
|
deadline = time.time() + 10
|
|
while time.time() < deadline:
|
|
if RNS.Transport.has_path(dest_hash):
|
|
break
|
|
time.sleep(0.1)
|
|
else:
|
|
loop.call_soon_threadsafe(future.set_result, None)
|
|
return
|
|
|
|
identity = RNS.Identity.recall(dest_hash)
|
|
if not identity:
|
|
loop.call_soon_threadsafe(future.set_result, None)
|
|
return
|
|
|
|
dest = RNS.Destination(
|
|
identity,
|
|
RNS.Destination.OUT,
|
|
RNS.Destination.SINGLE,
|
|
"nomadnetwork",
|
|
"node",
|
|
)
|
|
|
|
link = RNS.Link(dest)
|
|
|
|
# Wait for link to become active
|
|
deadline = time.time() + 15
|
|
while time.time() < deadline:
|
|
if link.status == RNS.Link.ACTIVE:
|
|
break
|
|
time.sleep(0.1)
|
|
else:
|
|
link.teardown()
|
|
loop.call_soon_threadsafe(future.set_result, None)
|
|
return
|
|
|
|
# Request the page via NomadNet's protocol
|
|
def on_response(request_receipt):
|
|
try:
|
|
resp = request_receipt.response
|
|
if resp is not None:
|
|
content = resp.decode("utf-8") if isinstance(resp, bytes) else str(resp)
|
|
loop.call_soon_threadsafe(future.set_result, content)
|
|
else:
|
|
loop.call_soon_threadsafe(future.set_result, None)
|
|
except Exception:
|
|
loop.call_soon_threadsafe(future.set_result, None)
|
|
finally:
|
|
link.teardown()
|
|
|
|
def on_failed(request_receipt):
|
|
if not future.done():
|
|
loop.call_soon_threadsafe(future.set_result, None)
|
|
link.teardown()
|
|
|
|
link.request(
|
|
"/page/" + path,
|
|
response_callback=on_response,
|
|
failed_callback=on_failed,
|
|
)
|
|
|
|
except Exception as exc:
|
|
log.warning("Remote page request failed: %s", exc)
|
|
if not future.done():
|
|
loop.call_soon_threadsafe(future.set_result, None)
|
|
|
|
# Run blocking RNS operations in a thread
|
|
threading.Thread(target=_do_request, daemon=True).start()
|
|
|
|
try:
|
|
return await asyncio.wait_for(future, timeout=30.0)
|
|
except asyncio.TimeoutError:
|
|
return None
|