emion 0.2.0__tar.gz

emion-0.2.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE
+recursive-include emion/dashboard/static *

emion-0.2.0/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: emion
+Version: 0.2.0
+Summary: Professional ION-DTN Mission Control & BPv7 Simulation Framework
+Author: EmION Team
+Author-email: EmION Team <dev@info-gallary.com>
+License: MIT
+Project-URL: Homepage, https://github.com/info-gallary/emion
+Project-URL: Repository, https://github.com/info-gallary/emion.git
+Keywords: dtn,ion,bpv7,simulation,space,networking
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: dashboard
+Requires-Dist: fastapi>=0.100.0; extra == "dashboard"
+Requires-Dist: uvicorn>=0.20.0; extra == "dashboard"
+Requires-Dist: websockets>=11.0; extra == "dashboard"
+Dynamic: author
+
+# ⚛️ EmION — Professional ION-DTN Simulation
+
+EmION is an authentic, production-ready Delay-Tolerant Networking (DTN) simulation framework. Unlike other simulators, EmION uses the **real ION-DTN C-engine** and **Contact Graph Routing (CGR)** for 100% protocol authenticity.
+
+---
+
+## 🚀 1. Installation
+
+EmION requires **ION-DTN** (C-engine) and **pyion** to be installed on your Linux system.
+
+### One-Click Setup
+We provide a unified installer that checks dependencies and installs the package:
+```bash
+chmod +x install.sh
+./install.sh
+```
+
+### Manual Installation
+```bash
+pip install -e ".[dashboard]"
+```
+
+---
+
+## 🧪 2. Verification
+
+Ensure your environment is correctly configured by running the professional test suite. This verifies real-time bundle transit and CGR routing:
+```bash
+python3 tests/test_emion.py
+```
+
+---
+
+## 🛰️ 3. Usage
+
+### Launching Mission Control
+Start the visual dashboard to manage multi-node topologies and view live telemetry:
+```bash
+emion dashboard
+```
+- **URL**: `http://localhost:8420`
+- **Telemetry**: Real-time SDR memory and bundle tracking.
+- **Visuals**: Canvas-based topology with bundle animation.
+
+### Command Line Interface
+```bash
+emion info      # Check ION system status
+emion dashboard # Start visual UI
+```
+
+---
+
+## 🔌 4. Connecting Third-Party Modules (API)
+
+EmION supports selective attachment of Anomaly Detection or Security modules via a **FastAPI-based Plugin System**.
+
+### Step A: Implement your Plugin
+Your module must be a web service (FastAPI) with these endpoints:
+1. `GET /health` -> `{"status": "ok"}`
+2. `POST /analyze` -> Receives bundle `payload` and `metadata`, returns:
+   ```json
+   {
+     "is_anomaly": true,
+     "score": 0.95,
+     "label": "attack",
+     "details": {"reason": "Payload too large"}
+   }
+   ```
+
+### Step B: Connect to EmION
+In the Dashboard UI (or via API), connect your module:
+- **Module URL**: `http://localhost:8421`
+- **Target Nodes**: Selectively monitor specific nodes (e.g., `1,3`) or `all`.
+
+### Demo Reference
+See `anomaly_detector.py` for a functional sample implementation.
+
+---
+
+## 🐳 5. Docker (Self-Contained BPv7)
+
+Run the entire EmION environment (ION-DTN + pyion + Dashboard) without local installation.
+
+### Build and Run
+```bash
+docker build -t emion .
+docker run -p 8420:8420 emion
+```
+Access Mission Control at `http://localhost:8420`.
+
+---
+
+## 📦 6. Publishing to PyPI
+
+### Build the Package
+```bash
+pip install build twine
+python3 -m build
+```
+
+### Upload to PyPI
+```bash
+twine upload dist/*
+```
+
+---
+
+## 🏗️ Project Structure
+- `emion/` — Core BPv7 orchestration.
+- `docs/` — [Coding Guide](docs/coding_guide.md) & [Usage Notebook](docs/usage_demo.ipynb).
+- `ION-DTN/` — Authentic NASA-JPL C-Engine.
+- `Dockerfile` — Professional self-contained environment.
+- `README.md` — This guide.
+
+---
+
+**Authentic. Professional. Space-Ready.** ⚛️
+- ION-DTN (compiled, with ionadmin/bpadmin in PATH)
+- pyion (built against your ION installation)
+- FastAPI + uvicorn + websockets (for dashboard)

emion-0.2.0/README.md

@@ -0,0 +1,120 @@
+# ⚛️ EmION — Professional ION-DTN Simulation
+
+EmION is an authentic, production-ready Delay-Tolerant Networking (DTN) simulation framework. Unlike other simulators, EmION uses the **real ION-DTN C-engine** and **Contact Graph Routing (CGR)** for 100% protocol authenticity.
+
+---
+
+## 🚀 1. Installation
+
+EmION requires **ION-DTN** (C-engine) and **pyion** to be installed on your Linux system.
+
+### One-Click Setup
+We provide a unified installer that checks dependencies and installs the package:
+```bash
+chmod +x install.sh
+./install.sh
+```
+
+### Manual Installation
+```bash
+pip install -e ".[dashboard]"
+```
+
+---
+
+## 🧪 2. Verification
+
+Ensure your environment is correctly configured by running the professional test suite. This verifies real-time bundle transit and CGR routing:
+```bash
+python3 tests/test_emion.py
+```
+
+---
+
+## 🛰️ 3. Usage
+
+### Launching Mission Control
+Start the visual dashboard to manage multi-node topologies and view live telemetry:
+```bash
+emion dashboard
+```
+- **URL**: `http://localhost:8420`
+- **Telemetry**: Real-time SDR memory and bundle tracking.
+- **Visuals**: Canvas-based topology with bundle animation.
+
+### Command Line Interface
+```bash
+emion info      # Check ION system status
+emion dashboard # Start visual UI
+```
+
+---
+
+## 🔌 4. Connecting Third-Party Modules (API)
+
+EmION supports selective attachment of Anomaly Detection or Security modules via a **FastAPI-based Plugin System**.
+
+### Step A: Implement your Plugin
+Your module must be a web service (FastAPI) with these endpoints:
+1. `GET /health` -> `{"status": "ok"}`
+2. `POST /analyze` -> Receives bundle `payload` and `metadata`, returns:
+   ```json
+   {
+     "is_anomaly": true,
+     "score": 0.95,
+     "label": "attack",
+     "details": {"reason": "Payload too large"}
+   }
+   ```
+
+### Step B: Connect to EmION
+In the Dashboard UI (or via API), connect your module:
+- **Module URL**: `http://localhost:8421`
+- **Target Nodes**: Selectively monitor specific nodes (e.g., `1,3`) or `all`.
+
+### Demo Reference
+See `anomaly_detector.py` for a functional sample implementation.
+
+---
+
+## 🐳 5. Docker (Self-Contained BPv7)
+
+Run the entire EmION environment (ION-DTN + pyion + Dashboard) without local installation.
+
+### Build and Run
+```bash
+docker build -t emion .
+docker run -p 8420:8420 emion
+```
+Access Mission Control at `http://localhost:8420`.
+
+---
+
+## 📦 6. Publishing to PyPI
+
+### Build the Package
+```bash
+pip install build twine
+python3 -m build
+```
+
+### Upload to PyPI
+```bash
+twine upload dist/*
+```
+
+---
+
+## 🏗️ Project Structure
+- `emion/` — Core BPv7 orchestration.
+- `docs/` — [Coding Guide](docs/coding_guide.md) & [Usage Notebook](docs/usage_demo.ipynb).
+- `ION-DTN/` — Authentic NASA-JPL C-Engine.
+- `Dockerfile` — Professional self-contained environment.
+- `README.md` — This guide.
+
+---
+
+**Authentic. Professional. Space-Ready.** ⚛️
+- ION-DTN (compiled, with ionadmin/bpadmin in PATH)
+- pyion (built against your ION installation)
+- FastAPI + uvicorn + websockets (for dashboard)

emion-0.2.0/emion/__init__.py

@@ -0,0 +1,19 @@
+"""
+EmION — Authentic ION-DTN Framework.
+All operations use real ION C-engine + pyion. No dummies.
+"""
+
+__version__ = "0.1.0"
+__author__ = "EmION Team"
+
+from .core.node import EmionNode
+from .core.engine import EmionEngine
+from .plugins.base import APIPlugin
+
+ION_AVAILABLE = True
+
+
+def dashboard(host="0.0.0.0", port=8420):
+    """Launch the EmION web dashboard."""
+    from .dashboard.server import run
+    run(host=host, port=port)

emion-0.2.0/emion/cli.py

@@ -0,0 +1,67 @@
+"""
+EmION CLI — all operations use real ION-DTN.
+
+    emion dashboard     Launch the web dashboard
+    emion info          Show ION-DTN status
+    emion test          Run the 2-node communication test
+"""
+
+import sys
+import argparse
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="emion",
+        description="EmION — Authentic ION-DTN Framework"
+    )
+    sub = parser.add_subparsers(dest="cmd")
+
+    d = sub.add_parser("dashboard", help="Launch the web dashboard")
+    d.add_argument("--host", default="0.0.0.0")
+    d.add_argument("--port", type=int, default=8420)
+
+    sub.add_parser("info", help="Show ION-DTN status")
+    sub.add_parser("test", help="Run 2-node comm test")
+
+    args = parser.parse_args()
+
+    if args.cmd == "dashboard":
+        from emion.dashboard.server import run
+        run(host=args.host, port=args.port)
+    elif args.cmd == "info":
+        _info()
+    elif args.cmd == "test":
+        _test()
+    else:
+        parser.print_help()
+
+
+def _info():
+    import shutil
+    import emion
+    print(f"\n  ⚛ EmION v{emion.__version__}")
+    for cmd in ["ionadmin", "bpadmin", "ionsecadmin", "bprecvfile", "bpsendfile"]:
+        path = shutil.which(cmd)
+        print(f"  {cmd}: {'✅ ' + path if path else '❌ not found'}")
+    try:
+        import pyion
+        print(f"  pyion: ✅")
+    except ImportError:
+        print(f"  pyion: ❌ not found")
+    try:
+        import fastapi
+        print(f"  fastapi: v{fastapi.__version__}")
+    except ImportError:
+        print(f"  fastapi: ❌  (pip install fastapi uvicorn websockets)")
+    print()
+
+
+def _test():
+    from tests.test_emion import test_two_node_communication
+    ok = test_two_node_communication()
+    sys.exit(0 if ok else 1)
+
+
+if __name__ == "__main__":
+    main()

emion-0.2.0/emion/core/__init__.py

@@ -0,0 +1,3 @@
+from .node import EmionNode
+from .engine import EmionEngine
+from . import network

emion-0.2.0/emion/core/engine.py

@@ -0,0 +1,74 @@
+"""
+EmionEngine — Python interface to ION-DTN via pyion C-bindings.
+Handles memory attachment, bundle send/receive.
+No dummies — requires a running ION node.
+"""
+
+import os
+import time
+import pyion
+
+
+class EmionEngine:
+    """
+    High-level Python wrapper over pyion C-bindings for a single ION node.
+    Must be used after EmionNode.start() has booted the C daemons.
+    """
+
+    def __init__(self, node_id: int, base_dir: str = "/tmp/emion_nodes"):
+        self.node_id = node_id
+        self.node_dir = os.path.join(base_dir, str(node_id))
+        self.proxy = None
+
+    def attach(self, retries=5, delay=2):
+        """Attach to the ION shared-memory region via pyion."""
+        print(f"[EmION] Attaching engine to Node {self.node_id}...")
+
+        # Ensure ION_NODE_LIST_DIR is unset — we use cwd instead
+        os.environ.pop("ION_NODE_LIST_DIR", None)
+        pyion.ION_NODE_LIST_DIR = None
+        os.environ["ION_NODE_NUMBER"] = str(self.node_id)
+
+        saved_dir = os.getcwd()
+        os.chdir(self.node_dir)
+
+        try:
+            for attempt in range(1, retries + 1):
+                try:
+                    self.proxy = pyion.get_bp_proxy(self.node_id)
+                    print(f"      ✅ Attached (attempt {attempt})")
+                    return True
+                except Exception as e:
+                    print(f"      [!] Attempt {attempt}/{retries}: {e}")
+                    time.sleep(delay)
+        finally:
+            os.chdir(saved_dir)
+
+        raise RuntimeError(
+            f"Cannot attach to ION Node {self.node_id}. "
+            f"Is the node running? Check {self.node_dir}/node_boot.log"
+        )
+
+    def send(self, src_eid: str, dst_eid: str, payload: bytes):
+        """Send a bundle via the real ION Bundle Protocol engine."""
+        if not self.proxy:
+            self.attach()
+        with self.proxy.bp_open(src_eid) as ep:
+            result = ep.bp_send(dst_eid, payload)
+            print(f"      📡 Sent {len(payload)}B  {src_eid} → {dst_eid}")
+            return result
+
+    def receive(self, eid: str, timeout: int = 10):
+        """Receive a bundle from the ION BP engine."""
+        if not self.proxy:
+            self.attach()
+        with self.proxy.bp_open(eid) as ep:
+            data = ep.bp_receive(timeout=timeout)
+            if data:
+                print(f"      📥 Received {len(data)}B on {eid}")
+            return data
+
+    def detach(self):
+        """Detach from the ION proxy."""
+        if self.proxy:
+            self.proxy = None

emion-0.2.0/emion/core/network.py

@@ -0,0 +1,101 @@
+"""
+Emion Network - High-level orchestration API for ION-DTN.
+Provides simple functional interface for notebooks and scripts.
+"""
+
+import time
+import subprocess
+from typing import List, Dict, Optional
+from emion.core.node import EmionNode
+from emion.core.engine import EmionEngine
+from emion.plugins.base import APIPlugin
+
+_nodes: Dict[int, EmionNode] = {}
+_engines: Dict[int, EmionEngine] = {}
+_plugins: Dict[str, APIPlugin] = {}
+
+
+def register_node(node_id: int):
+    """Register an authentic ION-DTN node."""
+    if node_id in _nodes:
+        return _nodes[node_id]
+    
+    n = EmionNode(node_id)
+    # auto-connect routing
+    for existing_id, existing_node in _nodes.items():
+        n.connect_to(existing_id)
+        existing_node.connect_to(node_id)
+    
+    _nodes[node_id] = n
+    return n
+
+
+def start_core(cleanup: bool = True):
+    """
+    Boot all registered ION nodes. 
+    Minimum 2 nodes recommended for routing verification.
+    """
+    if cleanup:
+        print("[EmION] Cleaning up existing ION processes (killm)...")
+        subprocess.run(["killm"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        time.sleep(2)
+
+    print(f"[EmION] Initializing {len(_nodes)} nodes...")
+    for nid, node in _nodes.items():
+        node.start(cleanup=False)
+    
+    # Wait for shared memory regions to stabilize
+    time.sleep(6)
+    
+    print("[EmION] Attaching bundle engines...")
+    for nid in _nodes:
+        eng = EmionEngine(nid)
+        eng.attach()
+        _engines[nid] = eng
+
+
+def stop_core():
+    """Shut down all ION nodes and engines."""
+    for nid, node in _nodes.items():
+        try:
+            node.stop()
+        except:
+            pass
+    _engines.clear()
+    subprocess.run(["killm"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+
+def send_bundle(src: int, dst: int, payload: str):
+    """Send a real BPv7 bundle via IPN."""
+    if src not in _engines:
+        raise RuntimeError(f"Engine for Node {src} not initialized. Call start_core() first.")
+    
+    src_eid = f"ipn:{src}.1"
+    dst_eid = f"ipn:{dst}.1"
+    data = payload.encode()
+    
+    res = _engines[src].send(src_eid, dst_eid, data)
+    
+    # Analyze with plugins
+    module_results = {}
+    for name, plugin in _plugins.items():
+        module_results[name] = plugin.analyze(data, {"src": src_eid, "dst": dst_eid})
+        
+    return {
+        "status": "sent",
+        "bundle_id": res, 
+        "src": src_eid, 
+        "dst": dst_eid, 
+        "size": len(data),
+        "analyzer_results": module_results
+    }
+
+
+def attach_plugin(url: str, target_nodes: str = "all"):
+    """Attach an external anomaly/security module."""
+    plugin = APIPlugin(base_url=url, name=url)
+    if plugin.health_check():
+        _plugins[url] = plugin
+        return {"status": "ok", "url": url}
+    else:
+        raise ConnectionError(f"Could not reach plugin at {url}/health")