release

Author: vryptt

.github/workflows/ci.yml

@@ -0,0 +1,39 @@
+name: CI
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+jobs:
+  build:
+    name: Build & Test
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Cache Cargo registry
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Build
+        run: cargo build --release --verbose
+
+      - name: Run tests
+        run: cargo test --verbose
+
+      - name: Clippy (Lint)
+        run: cargo clippy -- -D warnings
+
+      - name: Rustfmt (Format check)
+        run: cargo fmt -- --check

.github/workflows/release.yml

@@ -0,0 +1,20 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+
+jobs:
+  build-release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - name: Build release
+        run: cargo build --release
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: hp-http-rs
+          path: target/release/hp-http-rs

Makefile

@@ -0,0 +1,28 @@
+# Makefile for hp-http-rs
+
+BINARY=hp-http-rs
+
+all: build
+
+build:
+	cargo build --release
+
+run:
+	cargo run --release
+
+clean:
+	cargo clean
+
+test:
+	cargo test
+
+fmt:
+	cargo fmt --all
+
+check:
+	cargo clippy -- -D warnings
+
+install:
+	cargo install --path .
+
+.PHONY: all build run clean test fmt check install

README.md

@@ -0,0 +1,107 @@
+# High-Performance HTTP Server in Rust
+
+This project is a lightweight and high-performance HTTP server written in **Rust**.  
+It is designed with modular structure, concurrency, and real-time statistics tracking.
+
+---
+
+## Features
+
+- Lightweight and minimal dependencies
+- Fast response for core endpoints:
+  - `GET /` → returns `"OK"`
+  - `GET /stats` → returns JSON with real-time statistics:
+    - `total_connections`: number of requests since server start
+    - `rps`: requests per second
+- Modular code structure:
+  - `server.rs` → manages server lifecycle
+  - `routes.rs` → defines HTTP routes
+  - `stats.rs` → tracks server statistics
+- Built on **Tokio** and **Hyper** for asynchronous performance
+
+---
+
+## Project Structure
+
+```
+src/
+├─ main.rs       # Entry point
+├─ server.rs     # HTTP server logic
+├─ routes.rs     # Routing and responses
+└─ stats.rs      # Real-time statistics
+Cargo.toml       # Project configuration
+Makefile         # Build and utility commands
+```
+
+---
+
+## Requirements
+
+- Rust (latest stable version recommended)
+- Cargo build system
+- Linux, macOS, or Windows
+
+---
+
+## Build and Run
+
+### Build
+```bash
+make build
+```
+
+### Run
+```bash
+make run
+```
+
+The server will start by default at: `http://127.0.0.1:8080`
+
+---
+
+## Usage
+
+- Root endpoint:
+  ```bash
+  curl http://127.0.0.1:8080/
+  ```
+  Response:
+  ```
+  OK
+  ```
+
+- Statistics endpoint:
+  ```bash
+  curl http://127.0.0.1:8080/stats
+  ```
+  Example response:
+  ```json
+  {
+    "total_connections": 42,
+    "rps": 7
+  }
+  ```
+
+---
+
+## Development
+
+- Format code:
+  ```bash
+  make fmt
+  ```
+- Run linter:
+  ```bash
+  make check
+  ```
+- Run tests:
+  ```bash
+  make test
+  ```
+
+---
+
+## License
+
+This project is licensed under the **MIT License**.  
+You are free to use, modify, and distribute it under the terms of the license.

src/main.rs

@@ -0,0 +1,12 @@
+mod server;
+mod stats;
+mod routes;
+
+use server::HttpServer;
+
+#[tokio::main]
+async fn main() {
+    let server = HttpServer::new("127.0.0.1:8080");
+    println!("🚀 Server running on http://127.0.0.1:8080");
+    server.run().await;
+}

src/routes.rs

@@ -0,0 +1,26 @@
+use crate::stats::ServerStats;
+use hyper::{Body, Request, Response};
+use serde_json::json;
+use std::sync::Arc;
+
+pub async fn router(
+    req: Request<Body>,
+    stats: Arc<ServerStats>,
+) -> Result<Response<Body>, hyper::Error> {
+    stats.increment();
+
+    match req.uri().path() {
+        "/" => Ok(Response::new(Body::from("OK"))),
+        "/stats" => {
+            let data = json!({
+                "total_connections": stats.total(),
+                "rps": stats.rps(),
+            });
+            Ok(Response::new(Body::from(data.to_string())))
+        }
+        _ => Ok(Response::builder()
+            .status(404)
+            .body(Body::from("Not Found"))
+            .unwrap()),
+    }
+}

src/server.rs

@@ -0,0 +1,38 @@
+use crate::routes::router;
+use crate::stats::ServerStats;
+use hyper::service::{make_service_fn, service_fn};
+use hyper::{Server, Request, Response, Body};
+use std::sync::Arc;
+
+pub struct HttpServer {
+    addr: String,
+    stats: Arc<ServerStats>,
+}
+
+impl HttpServer {
+    pub fn new(addr: &str) -> Self {
+        Self {
+            addr: addr.to_string(),
+            stats: Arc::new(ServerStats::new()),
+        }
+    }
+
+    pub async fn run(self) {
+        let stats = self.stats.clone();
+
+        let make_svc = make_service_fn(move |_conn| {
+            let stats = stats.clone();
+            async move {
+                Ok::<_, hyper::Error>(service_fn(move |req: Request<Body>| {
+                    router(req, stats.clone())
+                }))
+            }
+        });
+
+        let server = Server::bind(&self.addr.parse().unwrap()).serve(make_svc);
+
+        if let Err(e) = server.await {
+            eprintln!("server error: {}", e);
+        }
+    }
+}

src/stats.rs

@@ -0,0 +1,40 @@
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::time::{Instant, Duration};
+use std::sync::Mutex;
+
+pub struct ServerStats {
+    total: AtomicUsize,
+    last_count: Mutex<(usize, Instant, usize)>, // (last_total, last_time, rps)
+}
+
+impl ServerStats {
+    pub fn new() -> Self {
+        Self {
+            total: AtomicUsize::new(0),
+            last_count: Mutex::new((0, Instant::now(), 0)),
+        }
+    }
+
+    pub fn increment(&self) {
+        self.total.fetch_add(1, Ordering::Relaxed);
+    }
+
+    pub fn total(&self) -> usize {
+        self.total.load(Ordering::Relaxed)
+    }
+
+    pub fn rps(&self) -> usize {
+        let mut last = self.last_count.lock().unwrap();
+        let now = Instant::now();
+        let elapsed = now.duration_since(last.1);
+
+        if elapsed >= Duration::from_secs(1) {
+            let current_total = self.total();
+            let diff = current_total - last.0;
+            last.0 = current_total;
+            last.1 = now;
+            last.2 = diff;
+        }
+        last.2
+    }
+}