http-fs 2.0.1

HTTP File Service library
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

//!Axum adaptor
//!
//!Implements `Handler` onto `StaticFiles`
//!
//!## Usage
//!
//!```rust,ignore
//!
//!use axum::{routing, Router};
//!
//!use http_fs::config::{self, StaticFileConfig, TokioWorker};
//!use http_fs::StaticFiles;
//!
//!use std::path::Path;
//!
//!#[derive(Clone)]
//!pub struct DirectoryConfig;
//!impl StaticFileConfig for DirectoryConfig {
//!    type FileService = config::DefaultConfig;
//!    type DirService = config::DefaultConfig;
//!
//!    fn handle_directory(&self, _path: &Path) -> bool {
//!        true
//!    }
//!}

//!async fn example() {
//!    let static_files = StaticFiles::new(TokioWorker, DirectoryConfig);
//!
//!    //idk how to make this shitty Handler to infer T
//!    let app = Router::new().route("/", routing::any::<_, (), _, _>(static_files));
//!    // run it with hyper on localhost:3000
//!    axum::Server::bind(&"0.0.0.0:3000".parse().unwrap())
//!        .serve(app.into_make_service())
//!        .await
//!        .unwrap();
//!}
//!```

use axum::handler::Handler;
use axum::http::request::Request;
use axum::http::header::HeaderMap;
use axum::response::Response;

use crate::config::{StaticFileConfig, FileServeConfig, FsTaskSpawner};
use crate::{StaticFiles, Body};

use std::io;
use core::{task, future};
use core::pin::Pin;

impl<W: FsTaskSpawner, C: FileServeConfig> axum::body::HttpBody for Body<W, C> {
    type Data = bytes::Bytes;
    type Error = io::Error;

    #[inline(always)]
    fn poll_data(self: Pin<&mut Self>, ctx: &mut task::Context<'_>) -> task::Poll<Option<Result<Self::Data, Self::Error>>> {
        self.poll_next(ctx)
    }

    #[inline(always)]
    fn poll_trailers(self: Pin<&mut Self>, _: &mut task::Context<'_>) -> task::Poll<Result<Option<HeaderMap>, Self::Error>> {
        task::Poll::Ready(Ok(None))
    }

    #[inline(always)]
    fn is_end_stream(&self) -> bool {
        self.is_finished()
    }
}

impl<W: FsTaskSpawner + Send + Clone + 'static, C: StaticFileConfig + Send + Clone + 'static, T, S, B> Handler<T, S, B> for StaticFiles<W, C> where W::FileReadFut: Send + 'static {
    type Future = future::Ready<Response>;

    #[inline(always)]
    fn call(self, req: Request<B>, _: S) -> Self::Future {
        let response = self.serve_http(req.method(), req.uri(), req.headers());
        future::ready(response.map(|body| axum::body::boxed(body)))
    }
}