clone from: https://github.com/miquels/webdav-handler-rs

2022-12-30 20:52:41 +08:00
parent f933400535
commit d3a950b54d
47 changed files with 10444 additions and 2 deletions
--- a/examples/actix.rs
+++ b/examples/actix.rs
@@ -0,0 +1,37 @@
+use std::io;
+
+use actix_web::{web, App, HttpServer};
+use webdav_handler::actix::*;
+use webdav_handler::{fakels::FakeLs, localfs::LocalFs, DavConfig, DavHandler};
+
+pub async fn dav_handler(req: DavRequest, davhandler: web::Data<DavHandler>) -> DavResponse {
+    if let Some(prefix) = req.prefix() {
+        let config = DavConfig::new().strip_prefix(prefix);
+        davhandler.handle_with(config, req.request).await.into()
+    } else {
+        davhandler.handle(req.request).await.into()
+    }
+}
+
+#[actix_web::main]
+async fn main() -> io::Result<()> {
+    env_logger::init();
+    let addr = "127.0.0.1:4918";
+    let dir = "/tmp";
+
+    let dav_server = DavHandler::builder()
+        .filesystem(LocalFs::new(dir, false, false, false))
+        .locksystem(FakeLs::new())
+        .build_handler();
+
+    println!("actix-web example: listening on {} serving {}", addr, dir);
+
+    HttpServer::new(move || {
+        App::new()
+            .data(dav_server.clone())
+            .service(web::resource("/{tail:.*}").to(dav_handler))
+    })
+    .bind(addr)?
+    .run()
+    .await
+}
--- a/examples/hyper.rs
+++ b/examples/hyper.rs
@@ -0,0 +1,31 @@
+use std::convert::Infallible;
+use webdav_handler::{fakels::FakeLs, localfs::LocalFs, DavHandler};
+
+#[tokio::main]
+async fn main() {
+    env_logger::init();
+    let dir = "/tmp";
+    let addr = ([127, 0, 0, 1], 4918).into();
+
+    let dav_server = DavHandler::builder()
+        .filesystem(LocalFs::new(dir, false, false, false))
+        .locksystem(FakeLs::new())
+        .build_handler();
+
+    let make_service = hyper::service::make_service_fn(move |_| {
+        let dav_server = dav_server.clone();
+        async move {
+            let func = move |req| {
+                let dav_server = dav_server.clone();
+                async move { Ok::<_, Infallible>(dav_server.handle(req).await) }
+            };
+            Ok::<_, Infallible>(hyper::service::service_fn(func))
+        }
+    });
+
+    println!("hyper example: listening on {:?} serving {}", addr, dir);
+    let _ = hyper::Server::bind(&addr)
+        .serve(make_service)
+        .await
+        .map_err(|e| eprintln!("server error: {}", e));
+}
--- a/examples/sample-litmus-server.rs
+++ b/examples/sample-litmus-server.rs
@@ -0,0 +1,125 @@
+//
+//  Sample application.
+//
+//  Listens on localhost:4918, plain http, no ssl.
+//  Connect to http://localhost:4918/
+//
+
+use std::convert::Infallible;
+use std::error::Error;
+use std::net::SocketAddr;
+use std::str::FromStr;
+
+#[macro_use]
+extern crate clap;
+
+use env_logger;
+use futures::future::TryFutureExt;
+use hyper;
+
+use headers::{authorization::Basic, Authorization, HeaderMapExt};
+
+use webdav_handler::{body::Body, fakels, localfs, memfs, memls, DavConfig, DavHandler};
+
+#[derive(Clone)]
+struct Server {
+    dh:   DavHandler,
+    auth: bool,
+}
+
+impl Server {
+    pub fn new(directory: String, memls: bool, fakels: bool, auth: bool) -> Self {
+        let mut config = DavHandler::builder();
+        if directory != "" {
+            config = config.filesystem(localfs::LocalFs::new(directory, true, true, true));
+        } else {
+            config = config.filesystem(memfs::MemFs::new());
+        };
+        if fakels {
+            config = config.locksystem(fakels::FakeLs::new());
+        }
+        if memls {
+            config = config.locksystem(memls::MemLs::new());
+        }
+
+        Server {
+            dh: config.build_handler(),
+            auth,
+        }
+    }
+
+    async fn handle(&self, req: hyper::Request<hyper::Body>) -> Result<hyper::Response<Body>, Infallible> {
+        let user = if self.auth {
+            // we want the client to authenticate.
+            match req.headers().typed_get::<Authorization<Basic>>() {
+                Some(Authorization(basic)) => Some(basic.username().to_string()),
+                None => {
+                    // return a 401 reply.
+                    let response = hyper::Response::builder()
+                        .status(401)
+                        .header("WWW-Authenticate", "Basic realm=\"foo\"")
+                        .body(Body::from("please auth".to_string()))
+                        .unwrap();
+                    return Ok(response);
+                },
+            }
+        } else {
+            None
+        };
+
+        if let Some(user) = user {
+            let config = DavConfig::new().principal(user);
+            Ok(self.dh.handle_with(config, req).await)
+        } else {
+            Ok(self.dh.handle(req).await)
+        }
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    env_logger::init();
+
+    let matches = clap_app!(webdav_lib =>
+        (version: "0.1")
+        (@arg PORT: -p --port +takes_value "port to listen on (4918)")
+        (@arg DIR: -d --dir +takes_value "local directory to serve")
+        (@arg MEMFS: -m --memfs "serve from ephemeral memory filesystem (default)")
+        (@arg MEMLS: -l --memls "use ephemeral memory locksystem (default with --memfs)")
+        (@arg FAKELS: -f --fakels "use fake memory locksystem (default with --memfs)")
+        (@arg AUTH: -a --auth "require basic authentication")
+    )
+    .get_matches();
+
+    let (dir, name) = match matches.value_of("DIR") {
+        Some(dir) => (dir, dir),
+        None => ("", "memory filesystem"),
+    };
+    let auth = matches.is_present("AUTH");
+    let memls = matches.is_present("MEMFS") || matches.is_present("MEMLS");
+    let fakels = matches.is_present("FAKELS");
+
+    let dav_server = Server::new(dir.to_string(), memls, fakels, auth);
+    let make_service = hyper::service::make_service_fn(|_| {
+        let dav_server = dav_server.clone();
+        async move {
+            let func = move |req| {
+                let dav_server = dav_server.clone();
+                async move { dav_server.clone().handle(req).await }
+            };
+            Ok::<_, hyper::Error>(hyper::service::service_fn(func))
+        }
+    });
+
+    let port = matches.value_of("PORT").unwrap_or("4918");
+    let addr = "0.0.0.0:".to_string() + port;
+    let addr = SocketAddr::from_str(&addr)?;
+
+    let server = hyper::Server::try_bind(&addr)?
+        .serve(make_service)
+        .map_err(|e| eprintln!("server error: {}", e));
+
+    println!("Serving {} on {}", name, port);
+    let _ = server.await;
+    Ok(())
+}
--- a/examples/warp.rs
+++ b/examples/warp.rs
@@ -0,0 +1,13 @@
+use std::net::SocketAddr;
+use webdav_handler::warp::dav_dir;
+
+#[tokio::main]
+async fn main() {
+    env_logger::init();
+    let dir = "/tmp";
+    let addr: SocketAddr = ([127, 0, 0, 1], 4918).into();
+
+    println!("warp example: listening on {:?} serving {}", addr, dir);
+    let warpdav = dav_dir(dir, true, true);
+    warp::serve(warpdav).run(addr).await;
+}