index : static-web-server.git

db51d7776907c12db9192e9543487adbe5e7a854 [patch]

88882189b1808335845d7f5bd620099343a88b0a

b16703099b3397f71be9d9412f329725ffe95b81

db51d7776907c12db9192e9543487adbe5e7a854.tar.gz

refactor: use option type for certain server arguments

Diff

 src/config.rs      | 30 +++++++++-------------------
 src/server.rs      | 58 ++++++++++++++++++++++++++++++++-----------------------
 src/staticfiles.rs |  5 ++++-
 3 files changed, 48 insertions(+), 45 deletions(-)

diff --git a/src/config.rs b/src/config.rs
index 976cadc..1b01c97 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -3,14 +3,9 @@ use structopt::StructOpt;
/// A blazing fast static files-serving web server powered by Rust Iron
#[derive(Debug, StructOpt)]
pub struct Options {
    #[structopt(
        long,
        short = "l",
        default_value = "my-static-server",
        env = "SERVER_NAME"
    )]
    #[structopt(long, short = "l", env = "SERVER_NAME")]
    /// Name for server
    pub name: String,
    pub name: Option<String>,

    #[structopt(long, short = "a", default_value = "[::]", env = "SERVER_HOST")]
    /// Host address (E.g 127.0.0.1)
@@ -51,15 +46,15 @@ pub struct Options {

    #[structopt(long, short = "t", env = "SERVER_TLS")]
    /// Enables TLS/SSL support.
    pub tls: bool,
    pub tls: Option<bool>,

    #[structopt(long, default_value = "", env = "SERVER_TLS_PKCS12")]
    #[structopt(long, env = "SERVER_TLS_PKCS12")]
    /// A cryptographic identity PKCS #12 bundle file path containing a X509 certificate along with its corresponding private key and chain of certificates to a trusted root.
    pub tls_pkcs12: String,
    pub tls_pkcs12: Option<String>,

    #[structopt(long, default_value = "", env = "SERVER_TLS_PKCS12_PASSWD")]
    #[structopt(long, env = "SERVER_TLS_PKCS12_PASSWD")]
    /// A specified password to decrypt the private key.
    pub tls_pkcs12_passwd: String,
    pub tls_pkcs12_passwd: Option<String>,

    #[structopt(long, env = "SERVER_TLS_REDIRECT_FROM")]
    /// Host port for redirecting HTTP requests to HTTPS. This option enables the HTTP redirect feature.
@@ -73,16 +68,11 @@ pub struct Options {
    /// Specify a logging level in lower case.
    pub log_level: String,

    #[structopt(
        long,
        short = "c",
        default_value = "",
        env = "SERVER_CORS_ALLOW_ORIGINS"
    )]
    #[structopt(long, short = "c", env = "SERVER_CORS_ALLOW_ORIGINS")]
    /// Specify a CORS list of allowed origin hosts separated by comas. Host ports or protocols aren't being checked. Use an asterisk (*) to allow any host.
    pub cors_allow_origins: String,
    pub cors_allow_origins: Option<String>,

    #[structopt(long, short = "i", env = "SERVER_DIRECTORY_LISTING")]
    /// Enable directory listing for all requests ending with the slash character (‘/’).
    pub directory_listing: bool,
    pub directory_listing: Option<bool>,
}
diff --git a/src/server.rs b/src/server.rs
index cd7aef1..4b47dd6 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -13,25 +13,6 @@ struct RunningServer {
    server_type: String,
}

fn on_server_running(server_name: &str, running_servers: &[RunningServer]) {
    // Notify when server is running
    running_servers.iter().for_each(|server| {
        logger::log_server(&format!(
            "{} Server ({}) is listening on {}",
            server.server_type, server_name, server.listening.socket
        ))
    });

    // Wait for incoming signals (E.g Ctrl+C (SIGINT), SIGTERM, etc
    signal_manager::wait_for_signal(|sig: signal::Signal| {
        let code = signal_manager::signal_to_int(sig);

        println!();
        warn!("Signal {} caught. Server execution exited.", code);
        std::process::exit(code)
    })
}

/// Run HTTP/HTTPS web server
pub fn run(opts: Options) {
    logger::init(&opts.log_level);
@@ -44,14 +25,18 @@ pub fn run(opts: Options) {
        assets_dir: opts.assets,
        page_50x_path: opts.page50x,
        page_404_path: opts.page404,
        cors_allow_origins: opts.cors_allow_origins,
        directory_listing: opts.directory_listing,
        cors_allow_origins: opts.cors_allow_origins.unwrap_or_default(),
        directory_listing: opts.directory_listing.unwrap_or_default(),
    });

    let mut running_servers = Vec::new();
    if opts.tls {
    if opts.tls.unwrap_or_default() {
        // Launch static HTTPS server
        let ssl = NativeTlsServer::new(opts.tls_pkcs12, &opts.tls_pkcs12_passwd).unwrap();
        let ssl = NativeTlsServer::new(
            opts.tls_pkcs12.unwrap_or_default(),
            &opts.tls_pkcs12_passwd.unwrap_or_default(),
        )
        .unwrap();

        match Iron::new(files.handle()).https(addr, ssl) {
            Ok(listening) => running_servers.push(RunningServer {
@@ -88,5 +73,30 @@ pub fn run(opts: Options) {
            Err(err) => panic!("{:?}", err),
        }
    }
    on_server_running(&opts.name, &running_servers);

    on_server_running(&opts.name.unwrap_or_default(), &running_servers);
}

fn on_server_running(server_name: &str, running_servers: &[RunningServer]) {
    // Notify when server is running
    running_servers.iter().for_each(|server| {
        let mut servername = String::new();
        if !server_name.is_empty() {
            servername = format!(" ({})", servername);
        }

        logger::log_server(&format!(
            "{} Server{} is listening on {}",
            server.server_type, servername, server.listening.socket
        ))
    });

    // Wait for incoming signals (E.g Ctrl+C (SIGINT), SIGTERM, etc
    signal_manager::wait_for_signal(|sig: signal::Signal| {
        let code = signal_manager::signal_to_int(sig);

        println!();
        warn!("Signal {} caught. Server execution exited.", code);
        std::process::exit(code)
    })
}
diff --git a/src/staticfiles.rs b/src/staticfiles.rs
index 4904725..1794385 100644
--- a/src/staticfiles.rs
+++ b/src/staticfiles.rs
@@ -59,6 +59,10 @@ impl StaticFiles {
            Ok(v) => v,
        };

        if self.opts.directory_listing {
            log_server("Directory listing enabled");
        }

        // Define middleware chain
        let mut chain = Chain::new(
            Staticfile::new(root_dir, assets_dir, self.opts.directory_listing)
@@ -72,7 +76,6 @@ impl StaticFiles {

        // CORS support
        let allowed_hosts = &self.opts.cors_allow_origins;

        if !allowed_hosts.is_empty() {
            log_server("CORS enabled");
            log_server(&format!("Access-Control-Allow-Origin: {}", allowed_hosts));