hyper-fs 0.2.0

Static File Service for hyper 0.11+.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

// #[macro_use]
extern crate futures;
extern crate futures_cpupool;
extern crate hyper;
extern crate log;
extern crate mxo_env_logger;
extern crate num_cpus;
extern crate tokio_core;
extern crate url;

use mxo_env_logger::*;
use futures_cpupool::Builder;
use tokio_core::reactor::Core;
use tokio_core::net::TcpListener;
use hyper::server::Http;
use futures::{Future, Stream};
use futures_cpupool::CpuPool;
use hyper::server::{Request, Response, Service};
use hyper::Error;

extern crate hyper_fs;
use hyper_fs::{error_handler, Config, HyperFutureObject, StaticIndex};

use std::path::PathBuf;
use std::sync::Arc;
use std::rc::Rc;
use std::env;

fn main() {
    init().expect("Init Log Failed");
    let port = env::args()
        .nth(1)
        .and_then(|arg| arg.parse::<u16>().ok())
        .unwrap_or(8000);
    let addr = format!("0.0.0.0:{}", port).parse().unwrap();
    let index = env::args().nth(2).unwrap_or_else(|| ".".to_owned());

    let pool = Builder::new().pool_size(3).name_prefix("hyper-fs").create();
    let config = Config::new()
        .cache_secs(60)
        .follow_links(true)
        .show_index(true); // .chunk_size(8196)

    let mut core = Core::new().unwrap();
    let handle = core.handle();
    let listener = TcpListener::bind(&addr, &handle).unwrap();
    let index_server = Rc::new(IndexServer::new(pool, index, config));

    let http = Http::new();
    let server = listener.incoming().for_each(|(socket, addr)| {
        http.bind_connection(&handle, socket, addr, index_server.clone());
        Ok(())
    });
    println!("Listening on http://{} with 1 thread.", addr);
    core.run(server).unwrap();
}

struct IndexServer {
    path: PathBuf,
    pool: CpuPool,
    config: Arc<Config>,
}
impl IndexServer {
    fn new<P: Into<PathBuf>>(pool: CpuPool, path: P, config: Config) -> Self {
        Self {
            path: path.into(),
            pool: pool,
            config: Arc::new(config),
        }
    }
}

impl Service for IndexServer {
    type Request = Request;
    type Response = Response;
    type Error = Error;
    type Future = HyperFutureObject;
    fn call(&self, req: Request) -> Self::Future {
        Box::new(
            StaticIndex::new(req.path(), &self.path, self.config.clone())
                .call(&self.pool, req)
                .or_else(error_handler)
                .map(|res_req| res_req.0),
        )
    }
}