Kubernetes but better and for Illumos - mirror
Find a file
Till Wegmueller 8d9ae6ac62
Add pod controller, status subresource, node agent, and main binary
Implement the core reconciliation loop that connects Pod events to zone
lifecycle. Status subresource endpoints allow updating pod/node status
without triggering spec-level changes. The main binary now provides
`serve` (API server only) and `agent` (full node: API + scheduler +
controller + heartbeat) subcommands via clap.

- Status subresource: generic update_status in common.rs, PUT endpoints
  for /pods/{name}/status and /nodes/{name}/status
- Pod controller: polls pods assigned to this node, provisions zones via
  ZoneRuntime, updates status to Running/Failed, monitors zone health
- Node agent: registers host as a Node, sends periodic heartbeats with
  Ready condition
- API client: lightweight reqwest-based HTTP client for controller and
  node agent to talk to the API server
- Main binary: clap CLI with serve/agent commands, wires all components
  together with graceful shutdown via ctrl-c

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-08 22:53:18 +01:00
crates Add pod controller, status subresource, node agent, and main binary 2026-02-08 22:53:18 +01:00
docs/ai/research Implement first 3 phases of implementation plan 2026-01-28 22:51:26 +01:00
.gitignore Initial commit 2026-01-28 22:50:31 +01:00
Cargo.lock Add pod controller, status subresource, node agent, and main binary 2026-02-08 22:53:18 +01:00
Cargo.toml Add pod controller, status subresource, node agent, and main binary 2026-02-08 22:53:18 +01:00
DEVELOPMENT.md Implement first 3 phases of implementation plan 2026-01-28 22:51:26 +01:00
LICENSE Initial commit 2026-01-28 22:50:31 +01:00
PHASE4_SUMMARY.md Implement phase 4 2026-01-28 23:06:06 +01:00
README.md Implement phase 4 2026-01-28 23:06:06 +01:00

Reddwarf: Rust-Based Single-Binary Kubernetes Control Plane

A pure Rust implementation of a Kubernetes control plane with DAG-based resource versioning.

Project Status

Current Phase: Phase 4 Complete (API Server)

Completed Phases

Phase 1: Foundation & Core Types

  • Workspace structure created
  • Core Kubernetes types and traits (Pod, Node, Service, Namespace)
  • Error handling with miette diagnostics
  • ResourceKey and GroupVersionKind types
  • JSON/YAML serialization helpers
  • 9 tests passing

Phase 2: Storage Layer with redb

  • KVStore trait abstraction
  • redb backend implementation (100% pure Rust)
  • Key encoding for resources
  • Transaction support
  • Prefix scanning and indexing
  • 9 tests passing

Phase 3: Versioning Layer

  • VersionStore for DAG-based versioning
  • Commit operations (create, get, list)
  • Conflict detection between concurrent modifications
  • DAG traversal for history
  • Common ancestor finding
  • 7 tests passing

Phase 4: API Server

  • Axum-based REST API server
  • HTTP verb handlers (GET, POST, PUT, PATCH, DELETE)
  • Pod, Node, Service, Namespace endpoints
  • LIST operations with prefix filtering
  • Resource validation
  • Kubernetes-compatible error responses
  • Health check endpoints (/healthz, /livez, /readyz)
  • 7 tests passing

Total: 32 tests passing

Architecture

reddwarf/
├── crates/
│   ├── reddwarf-core/          # ✅ Core K8s types & traits
│   ├── reddwarf-storage/       # ✅ redb storage backend
│   ├── reddwarf-versioning/    # ✅ DAG-based versioning
│   ├── reddwarf-apiserver/     # ✅ Axum REST API server
│   ├── reddwarf-scheduler/     # 🔄 Pod scheduler (pending)
│   └── reddwarf/               # 🔄 Main binary (pending)
└── tests/                      # 🔄 Integration tests (pending)

Building

# Build all crates
cargo build --workspace

# Run all tests
cargo test --workspace

# Run clippy
cargo clippy --workspace -- -D warnings

# Build release binary
cargo build --release

Next Phases

Phase 5: Basic Scheduler (Week 6)

  • Pod scheduling to nodes
  • Resource-based filtering
  • Simple scoring algorithm

Phase 6: Main Binary Integration (Week 7)

  • Single binary combining all components
  • Configuration and CLI
  • TLS support
  • Graceful shutdown
  • Observability (logging, metrics)

Phase 7: Testing & Documentation (Week 8)

  • Integration tests
  • End-to-end tests with kubectl
  • User documentation
  • API documentation

Key Features

  • Pure Rust: 100% Rust implementation, no C++ dependencies
  • Portable: Supports x86_64, ARM64, illumos
  • redb Storage: Fast, ACID-compliant storage with MVCC
  • DAG Versioning: Advanced resource versioning with conflict detection
  • Type-Safe: Leverages Rust's type system for correctness
  • Rich Errors: miette diagnostics for user-friendly error messages

License

MIT OR Apache-2.0