Struct HttpCanServer 

pub struct HttpCanServer { /* private fields */ }

HTTPCan server builder and runner

Implementations

impl HttpCanServer

pub fn new() -> Self

Create a new HTTPCan server with default configuration

Examples found in repository

examples/basic.rs (line 14)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::init();

    // Method 1: Using default configuration
    println!("Starting HTTPCan server with default configuration...");
    
    // Create server with default settings (port 8080, all features enabled)
    let _server = HttpCanServer::new();
    
    // Method 2: Using builder pattern
    let server = HttpCanServer::new()
        .port(3000)
        .host("127.0.0.1")
        .add_current_server(true)
        .exclude_header("x-internal-header")
        .exclude_header("x-debug-*");
    
    // Method 3: Using ServerConfig
    let config = ServerConfig::new()
        .port(3000)
        .host("127.0.0.1")
        .add_current_server(true)
        .exclude_headers(vec![
            "x-internal-header".to_string(),
            "x-debug-*".to_string(),
        ]);
    
    let _server_with_config = HttpCanServer::with_config(config);
    
    // Start the server
    server.run().await?;
    
    Ok(())
}

pub fn with_config(config: ServerConfig) -> Self

Create a new HTTPCan server with custom configuration

Examples found in repository

examples/basic.rs (line 34)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::init();

    // Method 1: Using default configuration
    println!("Starting HTTPCan server with default configuration...");
    
    // Create server with default settings (port 8080, all features enabled)
    let _server = HttpCanServer::new();
    
    // Method 2: Using builder pattern
    let server = HttpCanServer::new()
        .port(3000)
        .host("127.0.0.1")
        .add_current_server(true)
        .exclude_header("x-internal-header")
        .exclude_header("x-debug-*");
    
    // Method 3: Using ServerConfig
    let config = ServerConfig::new()
        .port(3000)
        .host("127.0.0.1")
        .add_current_server(true)
        .exclude_headers(vec![
            "x-internal-header".to_string(),
            "x-debug-*".to_string(),
        ]);
    
    let _server_with_config = HttpCanServer::with_config(config);
    
    // Start the server
    server.run().await?;
    
    Ok(())
}

pub fn port(self, port: u16) -> Self

Set the port for the server

Examples found in repository

examples/basic.rs (line 18)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::init();

    // Method 1: Using default configuration
    println!("Starting HTTPCan server with default configuration...");
    
    // Create server with default settings (port 8080, all features enabled)
    let _server = HttpCanServer::new();
    
    // Method 2: Using builder pattern
    let server = HttpCanServer::new()
        .port(3000)
        .host("127.0.0.1")
        .add_current_server(true)
        .exclude_header("x-internal-header")
        .exclude_header("x-debug-*");
    
    // Method 3: Using ServerConfig
    let config = ServerConfig::new()
        .port(3000)
        .host("127.0.0.1")
        .add_current_server(true)
        .exclude_headers(vec![
            "x-internal-header".to_string(),
            "x-debug-*".to_string(),
        ]);
    
    let _server_with_config = HttpCanServer::with_config(config);
    
    // Start the server
    server.run().await?;
    
    Ok(())
}

pub fn host<S: Into<String>>(self, host: S) -> Self

Set the host address for the server

Examples found in repository

examples/basic.rs (line 19)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::init();

    // Method 1: Using default configuration
    println!("Starting HTTPCan server with default configuration...");
    
    // Create server with default settings (port 8080, all features enabled)
    let _server = HttpCanServer::new();
    
    // Method 2: Using builder pattern
    let server = HttpCanServer::new()
        .port(3000)
        .host("127.0.0.1")
        .add_current_server(true)
        .exclude_header("x-internal-header")
        .exclude_header("x-debug-*");
    
    // Method 3: Using ServerConfig
    let config = ServerConfig::new()
        .port(3000)
        .host("127.0.0.1")
        .add_current_server(true)
        .exclude_headers(vec![
            "x-internal-header".to_string(),
            "x-debug-*".to_string(),
        ]);
    
    let _server_with_config = HttpCanServer::with_config(config);
    
    // Start the server
    server.run().await?;
    
    Ok(())
}

pub fn add_current_server(self, add: bool) -> Self

Enable or disable adding current server to OpenAPI specification

Examples found in repository

examples/basic.rs (line 20)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::init();

    // Method 1: Using default configuration
    println!("Starting HTTPCan server with default configuration...");
    
    // Create server with default settings (port 8080, all features enabled)
    let _server = HttpCanServer::new();
    
    // Method 2: Using builder pattern
    let server = HttpCanServer::new()
        .port(3000)
        .host("127.0.0.1")
        .add_current_server(true)
        .exclude_header("x-internal-header")
        .exclude_header("x-debug-*");
    
    // Method 3: Using ServerConfig
    let config = ServerConfig::new()
        .port(3000)
        .host("127.0.0.1")
        .add_current_server(true)
        .exclude_headers(vec![
            "x-internal-header".to_string(),
            "x-debug-*".to_string(),
        ]);
    
    let _server_with_config = HttpCanServer::with_config(config);
    
    // Start the server
    server.run().await?;
    
    Ok(())
}

pub fn exclude_headers(self, headers: Vec<String>) -> Self

Set headers to exclude from responses

pub fn exclude_header<S: Into<String>>(self, header: S) -> Self

Add a header to exclude from responses

Examples found in repository

examples/basic.rs (line 21)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::init();

    // Method 1: Using default configuration
    println!("Starting HTTPCan server with default configuration...");
    
    // Create server with default settings (port 8080, all features enabled)
    let _server = HttpCanServer::new();
    
    // Method 2: Using builder pattern
    let server = HttpCanServer::new()
        .port(3000)
        .host("127.0.0.1")
        .add_current_server(true)
        .exclude_header("x-internal-header")
        .exclude_header("x-debug-*");
    
    // Method 3: Using ServerConfig
    let config = ServerConfig::new()
        .port(3000)
        .host("127.0.0.1")
        .add_current_server(true)
        .exclude_headers(vec![
            "x-internal-header".to_string(),
            "x-debug-*".to_string(),
        ]);
    
    let _server_with_config = HttpCanServer::with_config(config);
    
    // Start the server
    server.run().await?;
    
    Ok(())
}

pub fn static_dir<P: Into<PathBuf>>(self, dir: P) -> Self

Set custom static files directory

pub async fn run(self) -> Result<()>

Start the HTTPCan server

Examples found in repository

examples/basic.rs (line 37)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::init();

    // Method 1: Using default configuration
    println!("Starting HTTPCan server with default configuration...");
    
    // Create server with default settings (port 8080, all features enabled)
    let _server = HttpCanServer::new();
    
    // Method 2: Using builder pattern
    let server = HttpCanServer::new()
        .port(3000)
        .host("127.0.0.1")
        .add_current_server(true)
        .exclude_header("x-internal-header")
        .exclude_header("x-debug-*");
    
    // Method 3: Using ServerConfig
    let config = ServerConfig::new()
        .port(3000)
        .host("127.0.0.1")
        .add_current_server(true)
        .exclude_headers(vec![
            "x-internal-header".to_string(),
            "x-debug-*".to_string(),
        ]);
    
    let _server_with_config = HttpCanServer::with_config(config);
    
    // Start the server
    server.run().await?;
    
    Ok(())
}

pub fn config(&self) -> &ServerConfig

Get the server configuration

Trait Implementations

impl Default for HttpCanServer

fn default() -> Self

Returns the “default value” for a type.