Struct Server 

pub struct Server {
    pub max_connections: usize,
    pub keep_alive: Duration,
    /* private fields */
}

The main application struct that represents your web server.

Example

use axeon::{ok_json, Server};


fn main() {
    let mut app = Server::new();

    // Add a route
    app.get("/", |_req| async {
    ok_json!({ "message": "Hello" })
    });

    // Start the server
    app.listen("127.0.0.1:3000").unwrap();
}

Fields

max_connections: usize

keep_alive: Duration

Implementations

impl Server

pub fn new() -> Self

Creates a new Application instance

Examples found in repository

examples/hello_world.rs (line 9)

fn main() {
    let mut app = Server::new();

    // Add a route that handles GET requests to "/"
    app.get("/", |_req| async { Response::text("Hello, World!") });

    app.listen("127.0.0.1:3000")
        .expect("Server failed to start");
}

examples/middleware.rs (line 58)

fn main() {
    let mut app = Server::new();

    // Apply logger middleware globally
    app.middleware(Logger);

    // Public route - no auth required
    app.get("/public", |_req| async  {
        Response::text("This is a public endpoint")
    });

    // Protected routes with auth middleware
    let mut protected = Router::new();
    protected.middleware(AuthMiddleware);

    protected.get("/profile", |_req| async  {
        ok_json!({
            "name": "User",
            "email": "user@example.com"
        })
    });

    app.mount("/api", protected);

    app.listen("127.0.0.1:3000")
        .expect("Server failed to start");
}

examples/routing.rs (line 19)

fn main() {
    let mut app = Server::new();

    // Basic GET route
    app.get("/", |_req| async {
        Response::text("Welcome to Axeon API server!")
    });

    // Route with path parameter
    app.get("/users/:id", |req| async move {
        let user_id = req.params.get("id").unwrap();
        Response::text(format!("User ID: {}", user_id))
    });

    // POST request with JSON body
    app.post("/users", |req| async move {
        match req.body.json::<User>() {
            Some(user) => Response::ok(&user),
            None => Err(ServerError::BadRequest("Invalid JSON body".to_string())),
        }
    });

    // Group routes under /api prefix
    let mut api = Router::new();
    api.get("/status", |_req| async {
        Response::ok(&serde_json::json!({
            "status": "operational",
            "version": "1.0.0"
        }))
    });

    // Mount the API router to the main server
    app.mount("/api", api);

    app.listen("127.0.0.1:3000")
        .expect("Server failed to start")
}

pub fn max_connections(&mut self, max_connections: usize) -> &mut Self

pub fn keep_alive(&mut self, keep_alive: Duration) -> &mut Self

pub fn plugins<T>(&mut self, plugin: T) -> &mut Self

where T: Send + Sync + 'static,

pub fn on_error<F>(&mut self, handler: F) -> &mut Self

where F: Fn(ServerError) -> Response + Send + Sync + 'static,

pub fn get<F, R>(&mut self, path: &str, handler: F)

where F: Fn(Request) -> R + Send + Clone + Sync + 'static, R: IntoResponse + 'static,

Registers a GET route handler

Arguments

• path - The URL path to match
• handler - The async handler function

Examples found in repository

examples/hello_world.rs (line 12)

fn main() {
    let mut app = Server::new();

    // Add a route that handles GET requests to "/"
    app.get("/", |_req| async { Response::text("Hello, World!") });

    app.listen("127.0.0.1:3000")
        .expect("Server failed to start");
}

examples/middleware.rs (lines 64-66)

fn main() {
    let mut app = Server::new();

    // Apply logger middleware globally
    app.middleware(Logger);

    // Public route - no auth required
    app.get("/public", |_req| async  {
        Response::text("This is a public endpoint")
    });

    // Protected routes with auth middleware
    let mut protected = Router::new();
    protected.middleware(AuthMiddleware);

    protected.get("/profile", |_req| async  {
        ok_json!({
            "name": "User",
            "email": "user@example.com"
        })
    });

    app.mount("/api", protected);

    app.listen("127.0.0.1:3000")
        .expect("Server failed to start");
}

examples/routing.rs (lines 22-24)

fn main() {
    let mut app = Server::new();

    // Basic GET route
    app.get("/", |_req| async {
        Response::text("Welcome to Axeon API server!")
    });

    // Route with path parameter
    app.get("/users/:id", |req| async move {
        let user_id = req.params.get("id").unwrap();
        Response::text(format!("User ID: {}", user_id))
    });

    // POST request with JSON body
    app.post("/users", |req| async move {
        match req.body.json::<User>() {
            Some(user) => Response::ok(&user),
            None => Err(ServerError::BadRequest("Invalid JSON body".to_string())),
        }
    });

    // Group routes under /api prefix
    let mut api = Router::new();
    api.get("/status", |_req| async {
        Response::ok(&serde_json::json!({
            "status": "operational",
            "version": "1.0.0"
        }))
    });

    // Mount the API router to the main server
    app.mount("/api", api);

    app.listen("127.0.0.1:3000")
        .expect("Server failed to start")
}

pub fn post<F, R>(&mut self, path: &str, handler: F)

where F: Fn(Request) -> R + Send + Clone + Sync + 'static, R: IntoResponse + 'static,

Registers a POST route handler

Arguments

• path - The URL path to match
• handler - The async handler function

Examples found in repository

examples/routing.rs (lines 33-38)

fn main() {
    let mut app = Server::new();

    // Basic GET route
    app.get("/", |_req| async {
        Response::text("Welcome to Axeon API server!")
    });

    // Route with path parameter
    app.get("/users/:id", |req| async move {
        let user_id = req.params.get("id").unwrap();
        Response::text(format!("User ID: {}", user_id))
    });

    // POST request with JSON body
    app.post("/users", |req| async move {
        match req.body.json::<User>() {
            Some(user) => Response::ok(&user),
            None => Err(ServerError::BadRequest("Invalid JSON body".to_string())),
        }
    });

    // Group routes under /api prefix
    let mut api = Router::new();
    api.get("/status", |_req| async {
        Response::ok(&serde_json::json!({
            "status": "operational",
            "version": "1.0.0"
        }))
    });

    // Mount the API router to the main server
    app.mount("/api", api);

    app.listen("127.0.0.1:3000")
        .expect("Server failed to start")
}

pub fn put<F, R>(&mut self, path: &str, handler: F)

where F: Fn(Request) -> R + Send + Clone + Sync + 'static, R: IntoResponse + 'static,

Registers a PUT route handler

Arguments

• path - The URL path to match
• handler - The async handler function

pub fn patch<F, R>(&mut self, path: &str, handler: F)

where F: Fn(Request) -> R + Send + Clone + Sync + 'static, R: IntoResponse + 'static,

Registers a PATCH route handler

Arguments

• path - The URL path to match
• handler - The async handler function

pub fn delete<F, R>(&mut self, path: &str, handler: F)

where F: Fn(Request) -> R + Send + Clone + Sync + 'static, R: IntoResponse + 'static,

Registers a DELETE route handler

Arguments

• path - The URL path to match
• handler - The async handler function

pub fn head<F, R>(&mut self, path: &str, handler: F)

where F: Fn(Request) -> R + Send + Clone + Sync + 'static, R: IntoResponse + 'static,

Registers a HEAD route handler

Arguments

• path - The URL path to match
• handler - The async handler function

pub fn connect<F, R>(&mut self, path: &str, handler: F)

where F: Fn(Request) -> R + Send + Clone + Sync + 'static, R: IntoResponse + 'static,

Registers a CONNECT route handler

Arguments

• path - The URL path to match
• handler - The async handler function

pub fn options<F, R>(&mut self, path: &str, handler: F)

where F: Fn(Request) -> R + Send + Clone + Sync + 'static, R: IntoResponse + 'static,

Registers an OPTIONS route handler

Arguments

• path - The URL path to match
• handler - The async handler function

pub fn trace<F, R>(&mut self, path: &str, handler: F)

where F: Fn(Request) -> R + Send + Clone + Sync + 'static, R: IntoResponse + 'static,

Registers a TRACE route handler

Arguments

• path - The URL path to match
• handler - The async handler function

pub fn middleware(&mut self, middleware: impl Middleware + 'static)

Adds a middleware to the application

Arguments

• middleware - The middleware to add

Examples found in repository

examples/middleware.rs (line 61)

fn main() {
    let mut app = Server::new();

    // Apply logger middleware globally
    app.middleware(Logger);

    // Public route - no auth required
    app.get("/public", |_req| async  {
        Response::text("This is a public endpoint")
    });

    // Protected routes with auth middleware
    let mut protected = Router::new();
    protected.middleware(AuthMiddleware);

    protected.get("/profile", |_req| async  {
        ok_json!({
            "name": "User",
            "email": "user@example.com"
        })
    });

    app.mount("/api", protected);

    app.listen("127.0.0.1:3000")
        .expect("Server failed to start");
}

pub fn mount(&mut self, path: &str, router: Router)

Mounts a router at a specific path

Arguments

• path - The URL path to mount the router
• router - The router to mount

Examples found in repository

examples/middleware.rs (line 79)

fn main() {
    let mut app = Server::new();

    // Apply logger middleware globally
    app.middleware(Logger);

    // Public route - no auth required
    app.get("/public", |_req| async  {
        Response::text("This is a public endpoint")
    });

    // Protected routes with auth middleware
    let mut protected = Router::new();
    protected.middleware(AuthMiddleware);

    protected.get("/profile", |_req| async  {
        ok_json!({
            "name": "User",
            "email": "user@example.com"
        })
    });

    app.mount("/api", protected);

    app.listen("127.0.0.1:3000")
        .expect("Server failed to start");
}

examples/routing.rs (line 50)

fn main() {
    let mut app = Server::new();

    // Basic GET route
    app.get("/", |_req| async {
        Response::text("Welcome to Axeon API server!")
    });

    // Route with path parameter
    app.get("/users/:id", |req| async move {
        let user_id = req.params.get("id").unwrap();
        Response::text(format!("User ID: {}", user_id))
    });

    // POST request with JSON body
    app.post("/users", |req| async move {
        match req.body.json::<User>() {
            Some(user) => Response::ok(&user),
            None => Err(ServerError::BadRequest("Invalid JSON body".to_string())),
        }
    });

    // Group routes under /api prefix
    let mut api = Router::new();
    api.get("/status", |_req| async {
        Response::ok(&serde_json::json!({
            "status": "operational",
            "version": "1.0.0"
        }))
    });

    // Mount the API router to the main server
    app.mount("/api", api);

    app.listen("127.0.0.1:3000")
        .expect("Server failed to start")
}

pub fn with_tls<P: AsRef<Path>>( &mut self, cert_file: P, key_file: P, ) -> &mut Self

Configure TLS for HTTPS support

pub fn listen(self, addr: &str) -> Result<(), Box<dyn Error>>

Starts the HTTP server

Arguments

• addr - Address to listen on (e.g. “127.0.0.1:3000”)

Examples found in repository

examples/hello_world.rs (line 14)

fn main() {
    let mut app = Server::new();

    // Add a route that handles GET requests to "/"
    app.get("/", |_req| async { Response::text("Hello, World!") });

    app.listen("127.0.0.1:3000")
        .expect("Server failed to start");
}

examples/middleware.rs (line 81)

fn main() {
    let mut app = Server::new();

    // Apply logger middleware globally
    app.middleware(Logger);

    // Public route - no auth required
    app.get("/public", |_req| async  {
        Response::text("This is a public endpoint")
    });

    // Protected routes with auth middleware
    let mut protected = Router::new();
    protected.middleware(AuthMiddleware);

    protected.get("/profile", |_req| async  {
        ok_json!({
            "name": "User",
            "email": "user@example.com"
        })
    });

    app.mount("/api", protected);

    app.listen("127.0.0.1:3000")
        .expect("Server failed to start");
}

examples/routing.rs (line 52)

fn main() {
    let mut app = Server::new();

    // Basic GET route
    app.get("/", |_req| async {
        Response::text("Welcome to Axeon API server!")
    });

    // Route with path parameter
    app.get("/users/:id", |req| async move {
        let user_id = req.params.get("id").unwrap();
        Response::text(format!("User ID: {}", user_id))
    });

    // POST request with JSON body
    app.post("/users", |req| async move {
        match req.body.json::<User>() {
            Some(user) => Response::ok(&user),
            None => Err(ServerError::BadRequest("Invalid JSON body".to_string())),
        }
    });

    // Group routes under /api prefix
    let mut api = Router::new();
    api.get("/status", |_req| async {
        Response::ok(&serde_json::json!({
            "status": "operational",
            "version": "1.0.0"
        }))
    });

    // Mount the API router to the main server
    app.mount("/api", api);

    app.listen("127.0.0.1:3000")
        .expect("Server failed to start")
}

pub fn static_dir(&mut self, dir: &str) -> &mut Self

Sets the directory for serving static files

Arguments

• dir - Path to the static files directory

Example

use axeon::Server;

let mut app = Server::new();
app.static_dir("public");

Trait Implementations

impl Clone for Server

fn clone(&self) -> Server

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.