Junior Year Self-Study Notes: My Journey with the Framework

Introducing Hyperlane: The Next-Gen Rust Web Framework

Hyperlane is a high-performance, lightweight, and developer-friendly Rust Web framework. It is engineered for extreme speed, zero platform dependency, and a modern development experience. Hyperlane leverages Rust's safety and concurrency, providing blazing-fast HTTP services and robust real-time communication support.

Performance Highlights: Stunning Benchmark Results

• 
  wrk test (single-core):
  
  
  
  
  • Hyperlane: QPS 120,000+
  
  
  • actix-web: QPS 90,000+
  
  
  • axum: QPS 80,000+
  
  
  
  
  
  



• 
  ab test (10,000 requests, 100 concurrency):
  
  
  
  
  • Hyperlane: QPS 110,000+
  
  
  • actix-web: QPS 85,000+
  
  
  • axum: QPS 75,000+
  
  
  
  
  
  

For more details and quick start templates, visit the Hyperlane GitHub page.

I came across the Hyperlane Rust HTTP framework while browsing GitHub, and its advertised performance metrics immediately piqued my interest. The official documentation states:

"Hyperlane is a high-performance, lightweight Rust HTTP framework. It's engineered to streamline modern web service development, striking a balance between flexibility and raw performance."

I resolved to utilize it for my distributed systems course project. My first step was to add it as a dependency in my Cargo.toml file:

[dependencies]

hyperlane = "5.25.1"

Day 3: The Elegance of Context Abstraction

Today, I delved into Hyperlane's Context abstraction. In many conventional web frameworks, retrieving the request method might involve a sequence like this:

let method = ctx.get_request().await.get_method();

Hyperlane, however, provides a more direct and concise approach:

let method = ctx.get_request_method().await;

My Observation:

This simplification of chained calls is reminiscent of Rust's ? operator—it effectively flattens nested invocations and significantly enhances code readability. Hyperlane cleverly auto-generates getter and setter methods, mapping an underlying request.method to a more accessible get_request_method().

Day 5: Routing and HTTP Method Macros

While working on implementing RESTful APIs, I discovered Hyperlane's convenient method macros:

#[methods(get, post)]

async fn user_api(ctx: Context) {

    // Logic to handle GET and POST requests

}



#[delete]

async fn delete_user(ctx: Context) {

    // Logic to handle DELETE requests

}

An Issue I Encountered:

Initially, I overlooked adding the async keyword to my route handler functions. This seemingly minor oversight resulted in a frustrating half-hour spent debugging compiler errors. Rust's asynchronous programming paradigm truly demands meticulous attention to detail.

Day 7: Exploring Response Handling Mechanisms

I dedicated the entire day to studying Hyperlane's response APIs and compiled a comparison table to solidify my understanding:

Key Discovery:

The distinction between send() and send_once() lies in whether the underlying TCP connection is maintained, which is a critical consideration for scenarios involving long-lived connections.

Day 10: Understanding the Middleware Onion Model

Through diagrams provided in the official documentation, I gained a clear understanding of Hyperlane's middleware workflow, often referred to as the "onion model":

graph LR

    A[Request] --> B[Middleware 1 (Outer Layer)]

    B --> C[Middleware 2 (Inner Layer)]

    C --> D[Controller/Route Handler]

    D --> E[Middleware 2 (Response Flow)]

    E --> F[Middleware 1 (Response Flow)]

    F --> G[Response]

My Implementation Attempt:

I implemented a simple logging middleware to illustrate the concept:

async fn log_middleware(ctx: Context, next: Next) {

    let start_time = Instant::now();

    println!(

For more information, please visit Hyperlane's GitHub page or contact the author: [email protected].