Skip to content

VoxaCommunications-NetNode Architecture

Overview

VoxaCommunications-NetNode is a decentralized networking platform that provides secure, privacy-focused communication through request splitting, dynamic routing, and a built-in crypto chain. The system is designed to be highly modular, scalable, and secure.

Core Architecture

High-Level Components

┌─────────────────────────────────────────────────────────────┐
│                    FastAPI Application                      │
├─────────────────────────────────────────────────────────────┤
│                      API Layer                             │
│  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐         │
│  │  Apps   │ │  Data   │ │  Info   │ │ Status  │         │
│  │   API   │ │   API   │ │   API   │ │   API   │         │
│  └─────────┘ └─────────┘ └─────────┘ └─────────┘         │
├─────────────────────────────────────────────────────────────┤
│                  Core Services Layer                       │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐         │
│  │ App Manager │ │ Net Manager │ │Registry Mgr │         │
│  │             │ │             │ │             │         │
│  │ - Deploy    │ │ - UPnP/NPC  │ │ - Auth      │         │
│  │ - Scale     │ │ - P2P Net   │ │ - Node Reg  │         │
│  │ - Monitor   │ │ - DNS       │ │ - Discovery │         │
│  └─────────────┘ └─────────────┘ └─────────────┘         │
├─────────────────────────────────────────────────────────────┤
│                 Networking Layer                           │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐         │
│  │ Kytan Server│ │ SSU Node    │ │Load Balancer│         │
│  │             │ │             │ │             │         │
│  │ - Protocols │ │ - P2P Comm  │ │ - Traffic   │         │
│  │ - Security  │ │ - Discovery │ │ - Health    │         │
│  │ - Routing   │ │ - Relay     │ │ - Failover  │         │
│  └─────────────┘ └─────────────┘ └─────────────┘         │
├─────────────────────────────────────────────────────────────┤
│                 Infrastructure Layer                       │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐         │
│  │   Docker    │ │ File System │ │ Monitoring  │         │
│  │ Containers  │ │  Storage    │ │  & Logging  │         │
│  └─────────────┘ └─────────────┘ └─────────────┘         │
└─────────────────────────────────────────────────────────────┘

Component Details

1. Application Entry Point (src/main.py)

The main application class orchestrates the entire system:

  • Configuration Management: Loads and validates settings from multiple sources
  • Service Initialization: Sets up networking, registry, and app management
  • FastAPI Integration: Configures web API endpoints
  • Lifecycle Management: Handles startup, running, and shutdown phases

Key Features: - Environment-based configuration with validation - Modular service initialization - Error handling and recovery - Production vs development modes

2. Networking Layer

Kytan Server

  • Custom networking protocol implementation
  • Secure communication channels
  • Context management for connections
  • Error handling and recovery

SSU Node (Secure Socket Utility)

  • P2P communication foundation
  • Node discovery and relay capabilities
  • UPnP/NPC port forwarding
  • DNS management integration

Net Manager

  • Central networking coordinator
  • Port forwarding management
  • Service discovery optimization
  • HTTP to P2P bridge

3. Application Management System

App Manager (src/lib/VoxaCommunications_Router/apps/app_manager.py)

  • Full application lifecycle management
  • Docker containerization support
  • Resource allocation and limits
  • Health monitoring and auto-scaling
  • P2P app discovery and routing

Security & Sandboxing (src/lib/VoxaCommunications_Router/apps/security.py)

  • Container isolation
  • Resource limit enforcement
  • Network policy management
  • Registry validation
  • Runtime security monitoring

Load Balancer (src/lib/VoxaCommunications_Router/apps/load_balancer.py)

  • Multiple balancing algorithms
  • Health-aware routing
  • Traffic distribution
  • Automatic failover

4. Registry System

Registry Manager

  • Node authentication and registration
  • Centralized node directory (transitioning to decentralized)
  • Session management
  • Cryptographic verification

RI Manager (Registry Information)

  • Bootstrap process management
  • Node metadata handling
  • Network topology awareness

5. Data Layer

Storage Management

  • Local data persistence
  • Configuration management
  • Log aggregation
  • Resource tracking

File System Organization

data/
├── apps/          # Application data
├── dns/           # DNS records
├── local/         # Local node data
├── nri/           # Node Registry Information
└── rri/           # Relay Registry Information

Security Architecture

Multi-Layer Security

  1. Network Level - Encrypted P2P communications - Request splitting and routing - Dynamic path selection - Anonymous routing capabilities

  2. Application Level - Container sandboxing - Resource isolation - Registry validation - Runtime monitoring

  3. Protocol Level - Cryptographic signatures - Session authentication - Message integrity - Replay protection

Request Splitting Technology

VoxaCommunications implements advanced request splitting:

  • Hash-based Verification: Each request part includes cryptographic hashes
  • Dynamic Routing: Parts take different paths through the network
  • Secure Reassembly: Destination nodes verify and reconstruct requests
  • Privacy Protection: No single relay sees complete requests

Configuration System

Configuration Hierarchy

  1. Environment Variables: Runtime configuration
  2. JSON Config Files: Structured settings
  3. Remote Structures: External configuration sources
  4. Validation Layer: Type checking and constraint enforcement

Key Configuration Files

  • config/settings.json: Main application settings
  • config/dev.json: Development-specific overrides
  • config/p2p.json: Networking configuration
  • config/apps.json: Application deployment settings
  • config/discovery.json: Network discovery parameters

API Architecture

RESTful API Design

The system exposes a comprehensive REST API through FastAPI:

App Management APIs (/apps/)

  • POST /apps/add_app/: Deploy applications
  • GET /apps/list_apps/: List deployed applications
  • GET /apps/get_app_status/: Application status
  • POST /apps/add_stop_app/: Stop applications
  • POST /apps/add_scale_app/: Scale applications

Data APIs (/data/)

  • Network discovery endpoints
  • Data storage and retrieval
  • Node information access

Status APIs (/status/)

  • Health monitoring
  • System status checks
  • Performance metrics

Info APIs (/info/)

  • System information
  • Version details
  • Capability discovery

Development and Testing

Development Tools

  • CLI Interface: src/cli.py provides command-line access
  • Testing Scripts: Automated deployment and API testing
  • Dev Environment: Multi-node development setup
  • Monitoring: Comprehensive logging and metrics

Container Support

  • Docker Integration: Full containerization support
  • Dev Containers: VS Code development environment
  • Multi-stage Builds: Optimized production images
  • Resource Management: CPU and memory limits

Scalability Design

Horizontal Scaling

  • Node Distribution: Applications deployed across multiple nodes
  • Load Distribution: Traffic balanced across instances
  • Geographic Distribution: Nodes can be globally distributed
  • Auto-scaling: Dynamic replica management

Performance Optimization

  • Connection Pooling: Efficient resource utilization
  • Caching Layers: Reduced latency for common operations
  • Async Processing: Non-blocking I/O operations
  • Resource Monitoring: Proactive resource management

Future Architecture

Decentralization Roadmap

  1. Registry Decentralization: Move from centralized to distributed registry
  2. Blockchain Integration: Enhanced crypto chain for trust and incentives
  3. Advanced Routing: ML-based optimal path selection
  4. Edge Computing: Computational task distribution

Planned Enhancements

  • WebAssembly Support: Run WASM applications
  • Advanced Cryptography: Post-quantum crypto integration
  • Mobile Clients: Lightweight mobile node implementations
  • IoT Integration: Support for IoT device networks

Monitoring and Observability

Logging Strategy

  • Structured Logging: JSON-formatted log entries
  • Log Aggregation: Centralized log collection
  • Error Tracking: Comprehensive error reporting
  • Performance Logging: Request timing and metrics

Metrics and Monitoring

  • Health Checks: Automated system health monitoring
  • Performance Metrics: CPU, memory, network utilization
  • Application Metrics: App-specific performance data
  • Alert System: Proactive issue notification

Deployment Architecture

Production Deployment

  • Container Orchestration: Docker-based deployment
  • Service Discovery: Automatic service registration
  • Load Balancing: Traffic distribution and failover
  • Rolling Updates: Zero-downtime deployments

Development Environment

  • Multi-node Setup: run_dev_nodes.sh for local testing
  • Hot Reload: Development mode with auto-restart
  • Debug Support: Comprehensive debugging tools
  • Test Automation: Automated testing pipelines

This architecture provides a solid foundation for a decentralized, secure, and scalable communication network while maintaining flexibility for future enhancements and community contributions.

Our Sponsors

Loading sponsors...