CerebraLake

A groundbreaking multi-language control-plane and data orchestration system that unifies Rust's performance, Java's reliability, and React's interactivity into one cohesive architecture.

---

📋 Table of Contents

• Overview
• Architecture
• Key Features
• Tech Stack
• Getting Started
  • Prerequisites
  • Installation
  • Running the Services
• Project Structure
• Usage
• Deployment
• Roadmap
• Contributing
• License
• Contact

---

🌍 Overview

CerebraLake is a modular, real-time monitoring and control system designed for high-performance distributed environments. By integrating three powerful technologies, it delivers a seamless experience for data ingestion, orchestration, and visualization.

Why CerebraLake?

• 🦀 Rust Core: Lightning-fast data processing and low-level system control
• ☕ Java Control Plane: Enterprise-grade orchestration and coordination
• ⚛️ React Dashboard: Beautiful, real-time system monitoring

Each layer operates independently while maintaining seamless integration through REST APIs and file-based discovery.

---

🏛️ Architecture

┌──────────────────────────────────────────────────────────────┐
│                     React Dashboard                           │
│              (Real-time Monitoring Interface)                 │
└────────────────────────┬─────────────────────────────────────┘
                         │ REST API / WebSocket
                         ▼
┌──────────────────────────────────────────────────────────────┐
│              Java Control Plane (Spring Boot)                 │
│  • Orchestration Logic        • State Management             │
│  • Service Discovery          • Health Monitoring            │
└────────────────────────┬─────────────────────────────────────┘
                         │ HTTP / File I/O
                         ▼
┌──────────────────────────────────────────────────────────────┐
│                   Rust Core (Axum Server)                     │
│  • High-throughput Data Ingestion  • Metrics Collection      │
│  • Dynamic Port Allocation         • Health Endpoints        │
└──────────────────────────────────────────────────────────────┘

Communication Flow

Layer	Technology	Primary Responsibility
🦀 Data Plane	Rust (Axum, Tokio)	Low-level data ingestion, processing, and real-time metric emission
☕ Control Plane	Spring Boot	Service coordination, orchestration, and state management
⚛️ Presentation	React + Vite	Real-time visualization and system monitoring

---

✨ Key Features

🔄 Auto-Discovery System

• Dynamic port allocation with automatic service discovery
• Zero-configuration inter-service communication
• File-based port registry (active_port.txt, java_active_port.txt)

⚡ Real-Time Monitoring

• Live metrics dashboard with auto-refresh
• Health status indicators for all services
• Connection visualization and uptime tracking

🔗 Cross-Language Integration

• Seamless Rust ↔ Java communication via REST
• React consumes metrics from both backend services
• Standard HTTP/REST patterns for universal compatibility

🚀 Stateless Architecture

• Each component runs independently
• Automatic reconnection and service recovery
• No complex configuration required

📊 Clean Observability

• Structured logging across all layers
• Prometheus-compatible metrics endpoints
• Centralized health monitoring

---

🛠️ Tech Stack

Component	Technologies	Purpose
Backend - Rust	Axum, Tokio, Serde, Hyper	High-performance async data plane
Backend - Java	Spring Boot, WebFlux, Maven	Reactive orchestration layer
Frontend	React 18, TypeScript, Vite, TailwindCSS	Modern, responsive UI
Integration	REST APIs, File I/O	Cross-language communication

---

🚀 Getting Started

Prerequisites

Ensure you have the following installed:

• Rust (1.70+) → Install Rust
• Java JDK (17+) → Adoptium JDK
• Maven (3.8+) → Install Maven
• Node.js (18+) → Download Node.js

Installation

Clone the repository:

git clone https://github.com/Jitterx69/CerebraLake.git
cd CerebraLake

Running the Services

Option 1: Manual Startup

1. Start the Rust Core

cd rust-core
cargo run

The Rust service will:

• Automatically select a free port
• Write the port to active_port.txt
• Expose endpoints at /metrics and /health

2. Start the Java Control Plane

cd java-controlplane
mvn spring-boot:run

The Java service will:

• Read Rust's port from active_port.txt
• Write its own port to java_active_port.txt
• Start the orchestration layer

3. Launch the React Dashboard

cd react-dashboard
npm install
npm run dev

Open your browser at http://localhost:3000 to view the dashboard.

Option 2: One-Command Startup (Recommended)

Use the provided startup script:

chmod +x run_all.sh
./run_all.sh

This will start all three services in the correct order.

---

📁 Project Structure

CerebraLake/
├── rust-core/                 # 🦀 Rust data plane
│   ├── src/
│   │   └── main.rs
│   ├── Cargo.toml
│   └── active_port.txt       # Auto-generated port file
│
├── java-controlplane/         # ☕ Spring Boot orchestration
│   ├── src/
│   │   └── main/
│   ├── pom.xml
│   └── java_active_port.txt  # Auto-generated port file
│
├── react-dashboard/           # ⚛️ React monitoring UI
│   ├── src/
│   │   ├── components/
│   │   ├── App.tsx
│   │   └── main.tsx
│   ├── package.json
│   └── vite.config.ts
│
├── docker-compose.yml         # Container orchestration
├── run_all.sh                 # Startup script
├── .gitignore
├── LICENSE
└── README.md

---

💻 Usage

Accessing the Dashboard

Once all services are running, navigate to:

http://localhost:3000

The dashboard displays:

• ✅ Service health status
• 🔌 Active ports for Rust and Java services
• 📊 Real-time system metrics
• 🕒 Last update timestamp

API Endpoints

Rust Core (Dynamic Port - check active_port.txt)

GET /health          # Health check
GET /metrics         # Prometheus metrics
GET /active_port     # Current port info

Java Control Plane (Dynamic Port - check java_active_port.txt)

GET /api/health      # Health check
GET /api/state       # Current system state
POST /api/control    # Control operations

---

🐳 Deployment

Docker Compose

Deploy the entire stack with Docker:

version: '3.8'
services:
  rust-core:
    build: ./rust-core
    ports:
      - "8000:8000"
    networks:
      - cerebralake-net

  java-controlplane:
    build: ./java-controlplane
    ports:
      - "8080:8080"
    depends_on:
      - rust-core
    networks:
      - cerebralake-net

  react-dashboard:
    build: ./react-dashboard
    ports:
      - "3000:3000"
    depends_on:
      - java-controlplane
    networks:
      - cerebralake-net

networks:
  cerebralake-net:
    driver: bridge

Run with:

docker-compose up --build

---

🗺️ Roadmap

✅ Current Features

• Dynamic port allocation and discovery
• Real-time health monitoring
• Cross-language REST communication
• React-based visualization dashboard

🚧 Upcoming Features

• WebSocket support for real-time updates
• PostgreSQL integration for persistent storage
• Kafka-based message queue for telemetry
• Prometheus metrics exporter
• Grafana dashboard templates
• Kubernetes deployment manifests
• Authentication and authorization layer
• Circuit breaker patterns
• Distributed tracing with OpenTelemetry

---

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

---

📧 Contact

Mohit (Jitterx69)

• GitHub: @Jitterx69
• Email: [email protected]
• Project Link: https://github.com/Jitterx69/CerebraLake

---

Built by JitterX

A cross-language symphony of Rust 🦀 + Java ☕ + React ⚛️