Skip to content

Commit

Permalink
update hyper examples to for new http 1.0 compatible version
Browse files Browse the repository at this point in the history
  • Loading branch information
@themasch
themasch committed Jan 4, 2024
1 parent f38bc97 commit 5f4d879
Show file tree
Hide file tree
Showing 3 changed files with 114 additions and 56 deletions.
56 changes: 39 additions & 17 deletions examples/hyper.rs
View file
Original file line number Diff line number Diff line change
@@ -1,31 +1,53 @@
use std::{convert::Infallible, net::SocketAddr};

use hyper::{server::conn::http1, service::service_fn};
use hyper_util::rt::TokioIo;
use tokio::net::TcpListener;

use dav_server::{fakels::FakeLs, localfs::LocalFs, DavHandler};
use std::convert::Infallible;

#[tokio::main]
async fn main() {
env_logger::init();
let dir = "/tmp";
let addr = ([127, 0, 0, 1], 4918).into();
let addr = SocketAddr::from(([127, 0, 0, 1], 4918));

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 listener = TcpListener::bind(addr).await.unwrap();

println!("Serving on {:?}", addr);

// We start a loop to continuously accept incoming connections
loop {
let (stream, _) = listener.accept().await.unwrap();
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));

// Use an adapter to access something implementing `tokio::io` traits as if they implement
// `hyper::rt` IO traits.
let io = TokioIo::new(stream);

// Spawn a tokio task to serve multiple connections concurrently
tokio::task::spawn(async move {
// Finally, we bind the incoming connection to our `hello` service
if let Err(err) = http1::Builder::new()
// `service_fn` converts our function in a `Service`
.serve_connection(
io,
service_fn({
move |req| {
let dav_server = dav_server.clone();
async move { Ok::<_, Infallible>(dav_server.handle(req).await) }
}
}),
)
.await
{
println!("Error serving connection: {:?}", err);
}
});
}
}
57 changes: 36 additions & 21 deletions examples/sample-litmus-server.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5,14 +5,13 @@
// Connect to http://localhost:4918/
//

use std::convert::Infallible;
use std::error::Error;
use std::net::SocketAddr;
use std::str::FromStr;
use std::{convert::Infallible, error::Error, net::SocketAddr, str::FromStr};

use clap::Parser;
use futures_util::future::TryFutureExt;
use headers::{authorization::Basic, Authorization, HeaderMapExt};
use hyper::{server::conn::http1, service::service_fn};
use hyper_util::rt::TokioIo;
use tokio::net::TcpListener;

use dav_server::{body::Body, fakels, localfs, memfs, memls, DavConfig, DavHandler};

Expand Down Expand Up @@ -45,7 +44,7 @@ impl Server {

async fn handle(
&self,
req: hyper::Request<hyper::Body>,
req: hyper::Request<hyper::body::Incoming>,
) -> Result<hyper::Response<Body>, Infallible> {
let user = if self.auth {
// we want the client to authenticate.
Expand Down Expand Up @@ -112,26 +111,42 @@ async fn main() -> Result<(), Box<dyn Error>> {
let fakels = args.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 = args.port;
let addr = format!("0.0.0.0:{}", port);
let addr = SocketAddr::from_str(&addr)?;

let server = hyper::Server::try_bind(&addr)?
.serve(make_service)
.map_err(|e| eprintln!("server error: {}", e));
let listener = TcpListener::bind(addr).await?;

println!("Serving {} on {}", name, port);
let _ = server.await;
Ok(())

// We start a loop to continuously accept incoming connections
loop {
let (stream, _) = listener.accept().await?;
let dav_server = dav_server.clone();

// Use an adapter to access something implementing `tokio::io` traits as if they implement
// `hyper::rt` IO traits.
let io = TokioIo::new(stream);

// Spawn a tokio task to serve multiple connections concurrently
tokio::task::spawn(async move {
// Finally, we bind the incoming connection to our `hello` service
if let Err(err) = http1::Builder::new()
// `service_fn` converts our function in a `Service`
.serve_connection(
io,
service_fn({
move |req| {
let dav_server = dav_server.clone();
async move { dav_server.clone().handle(req).await }
}
}),
)
.await
{
println!("Error serving connection: {:?}", err);
}
});
}
}
57 changes: 39 additions & 18 deletions src/lib.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -70,36 +70,57 @@
//!
//! ```no_run
//! use std::convert::Infallible;
//! use std::net::SocketAddr;
//! use dav_server::{fakels::FakeLs, localfs::LocalFs, DavHandler};
//! use hyper::server::conn::http1;
//! use hyper::service::service_fn;
//! use hyper_util::rt::TokioIo;
//! use tokio::net::TcpListener;
//!
//! #[tokio::main]
//! async fn main() {
//! env_logger::init();
//! let dir = "/tmp";
//! let addr = ([127, 0, 0, 1], 4918).into();
//! let addr = SocketAddr::from(([127, 0, 0, 1], 4918));
//!
//! 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 listener = TcpListener::bind(addr).await.unwrap();
//!
//! println!("Serving on {:?}", addr);
//!
//! // We start a loop to continuously accept incoming connections
//! loop {
//! let (stream, _) = listener.accept().await.unwrap();
//! 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!("Serving {} on {}", dir, addr);
//! let _ = hyper::Server::bind(&addr)
//! .serve(make_service)
//! .await
//! .map_err(|e| eprintln!("server error: {}", e));
//!
//! // Use an adapter to access something implementing `tokio::io` traits as if they implement
//! // `hyper::rt` IO traits.
//! let io = TokioIo::new(stream);
//!
//! // Spawn a tokio task to serve multiple connections concurrently
//! tokio::task::spawn(async move {
//! // Finally, we bind the incoming connection to our `hello` service
//! if let Err(err) = http1::Builder::new()
//! // `service_fn` converts our function in a `Service`
//! .serve_connection(
//! io,
//! service_fn({
//! move |req| {
//! let dav_server = dav_server.clone();
//! async move { Ok::<_, Infallible>(dav_server.handle(req).await) }
//! }
//! }),
//! )
//! .await
//! {
//! println!("Error serving connection: {:?}", err);
//! }
//! });
//! }
//! }
//! ```
//! [DavHandler]: struct.DavHandler.html
Expand Down

0 comments on commit 5f4d879

Please sign in to comment.