Emi/kochab
Emi
/
kochab
1
1
Fork 0
Code Issues Pull Requests Releases Activity

Merge remote-tracking branch 'upstream/master' into timeout-override

This commit is contained in:
Emi Tatsuo 2020-11-19 12:36:42 -05:00
parent df362d1bc3 381bccf36f
commit b50a5e3244
Signed by: Emi
GPG Key ID: 68FAB2E2E6DFC98B
9 changed files with 127 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CHANGELOG.md
View File

@ -12,6 +12,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
- `redirect_temporary_lossy` for `Response` and `ResponseHeader`
- `bad_request_lossy` for `Response` and `ResponseHeader`
- support for a lot more mime-types in `guess_mime_from_path`, backed by the `mime_guess` crate
- customizable TLS cert & key paths by [@Alch-Emi](https://github.com/Alch-Emi)
- `server_dir` default feature for serve_dir utils [@Alch-Emi](https://github.com/Alch-Emi)
### Improved
- build time and size by [@Alch-Emi](https://github.com/Alch-Emi)
## [0.3.0] - 2020-11-14
### Added

13
Cargo.toml
View File

@ -8,20 +8,25 @@ description = "Gemini server implementation"
repository = "https://github.com/panicbit/northstar"
documentation = "https://docs.rs/northstar"
[features]
default = ["serve_dir"]
serve_dir = ["mime_guess", "tokio/fs"]
[dependencies]
anyhow = "1.0.33"
rustls = { version = "0.18.1", features = ["dangerous_configuration"] }
tokio-rustls = "0.20.0"
tokio = { version = "0.3.1", features = ["full"] }
tokio = { version = "0.3.1", features = ["io-util","net","time", "rt"] }
mime = "0.3.16"
uriparse = "0.6.3"
percent-encoding = "2.1.0"
futures = "0.3.7"
itertools = "0.9.0"
futures-core = "0.3.7"
log = "0.4.11"
webpki = "0.21.0"
lazy_static = "1.4.0"
mime_guess = "2.0.3"
mime_guess = { version = "2.0.3", optional = true }
[dev-dependencies]
env_logger = "0.8.1"
futures-util = "0.3.7"
tokio = { version = "0.3.1", features = ["macros", "rt-multi-thread", "sync"] }

3
examples/certificates.rs
View File

@ -1,5 +1,6 @@
use anyhow::*;
use futures::{future::BoxFuture, FutureExt};
use futures_core::future::BoxFuture;
use futures_util::FutureExt;
use log::LevelFilter;
use tokio::sync::RwLock;
use northstar::{Certificate, GEMINI_MIME, GEMINI_PORT, Request, Response, Server};

3
examples/document.rs
View File

@ -1,5 +1,6 @@
use anyhow::*;
use futures::{future::BoxFuture, FutureExt};
use futures_core::future::BoxFuture;
use futures_util::FutureExt;
use log::LevelFilter;
use northstar::{Server, Request, Response, GEMINI_PORT, Document};
use northstar::document::HeadingLevel::*;

3
examples/serve_dir.rs
View File

@ -1,5 +1,6 @@
use anyhow::*;
use futures::{future::BoxFuture, FutureExt};
use futures_core::future::BoxFuture;
use futures_util::FutureExt;
use log::LevelFilter;
use northstar::{Server, Request, Response, GEMINI_PORT};

73
src/lib.rs
View File

@ -5,9 +5,10 @@ use std::{
convert::TryFrom,
io::BufReader,
sync::Arc,
path::PathBuf,
time::Duration,
};
use futures::{future::BoxFuture, FutureExt};
use futures_core::future::BoxFuture;
use tokio::{
prelude::*,
io::{self, BufStream},
@ -32,7 +33,7 @@ pub const REQUEST_URI_MAX_LEN: usize = 1024;
pub const GEMINI_PORT: u16 = 1965;
type Handler = Arc<dyn Fn(Request) -> HandlerResponse + Send + Sync>;
type HandlerResponse = BoxFuture<'static, Result<Response>>;
pub (crate) type HandlerResponse = BoxFuture<'static, Result<Response>>;
#[derive(Clone)]
pub struct Server {
@ -94,7 +95,7 @@ impl Server {
let handler = (self.handler)(request);
let handler = AssertUnwindSafe(handler);
let response = handler.catch_unwind().await
let response = util::HandlerCatchUnwind::new(handler).await
.unwrap_or_else(|_| Response::server_error(""))
.or_else(|err| {
error!("Handler failed: {:?}", err);
@ -202,6 +203,8 @@ impl Server {
pub struct Builder<A> {
addr: A,
cert_path: PathBuf,
key_path: PathBuf,
timeout: Duration,
complex_body_timeout_override: Option<Duration>,
}
@ -212,9 +215,51 @@ impl<A: ToSocketAddrs> Builder<A> {
addr,
timeout: Duration::from_secs(1),
complex_body_timeout_override: Some(Duration::from_secs(30)),
cert_path: PathBuf::from("cert/cert.pem"),
key_path: PathBuf::from("cert/key.pem"),
}
}
/// Sets the directory that northstar should look for TLS certs and keys into
///
/// Northstar will look for files called `cert.pem` and `key.pem` in the provided
/// directory.
///
/// This does not need to be set if both [`set_cert()`](Self::set_cert()) and
/// [`set_key()`](Self::set_key()) have been called.
///
/// If not set, the default is `cert/`
pub fn set_tls_dir(self, dir: impl Into<PathBuf>) -> Self {
let dir = dir.into();
self.set_cert(dir.join("cert.pem"))
.set_key(dir.join("key.pem"))
}
/// Set the path to the TLS certificate northstar will use
///
/// This defaults to `cert/cert.pem`.
///
/// This does not need to be called it [`set_tls_dir()`](Self::set_tls_dir()) has been
/// called.
pub fn set_cert(mut self, cert_path: impl Into<PathBuf>) -> Self {
self.cert_path = cert_path.into();
self
}
/// Set the path to the ertificate key northstar will use
///
/// This defaults to `cert/key.pem`.
///
/// This does not need to be called it [`set_tls_dir()`](Self::set_tls_dir()) has been
/// called.
///
/// This should of course correspond to the key set in
/// [`set_cert()`](Self::set_cert())
pub fn set_key(mut self, key_path: impl Into<PathBuf>) -> Self {
self.key_path = key_path.into();
self
}
/// Set the timeout on incoming requests
///
/// Note that this timeout is applied twice, once for the delivery of the request, and
@ -278,7 +323,7 @@ impl<A: ToSocketAddrs> Builder<A> {
where
F: Fn(Request) -> HandlerResponse + Send + Sync + 'static,
{
let config = tls_config()
let config = tls_config(&self.cert_path, &self.key_path)
.context("Failed to create TLS config")?;
let listener = TcpListener::bind(self.addr).await
@ -345,12 +390,12 @@ async fn send_response_body(body: Body, stream: &mut (impl AsyncWrite + Unpin))
Ok(())
}
fn tls_config() -> Result<Arc<ServerConfig>> {
fn tls_config(cert_path: &PathBuf, key_path: &PathBuf) -> Result<Arc<ServerConfig>> {
let mut config = ServerConfig::new(AllowAnonOrSelfsignedClient::new());
let cert_chain = load_cert_chain()
let cert_chain = load_cert_chain(cert_path)
.context("Failed to load TLS certificate")?;
let key = load_key()
let key = load_key(key_path)
.context("Failed to load TLS key")?;
config.set_single_cert(cert_chain, key)
.context("Failed to use loaded TLS certificate")?;
@ -358,24 +403,22 @@ fn tls_config() -> Result<Arc<ServerConfig>> {
Ok(config.into())
}
fn load_cert_chain() -> Result<Vec<Certificate>> {
let cert_path = "cert/cert.pem";
fn load_cert_chain(cert_path: &PathBuf) -> Result<Vec<Certificate>> {
let certs = std::fs::File::open(cert_path)
.with_context(|| format!("Failed to open `{}`", cert_path))?;
.with_context(|| format!("Failed to open `{:?}`", cert_path))?;
let mut certs = BufReader::new(certs);
let certs = rustls::internal::pemfile::certs(&mut certs)
.map_err(|_| anyhow!("failed to load certs `{}`", cert_path))?;
.map_err(|_| anyhow!("failed to load certs `{:?}`", cert_path))?;
Ok(certs)
}
fn load_key() -> Result<PrivateKey> {
let key_path = "cert/key.pem";
fn load_key(key_path: &PathBuf) -> Result<PrivateKey> {
let keys = std::fs::File::open(key_path)
.with_context(|| format!("Failed to open `{}`", key_path))?;
.with_context(|| format!("Failed to open `{:?}`", key_path))?;
let mut keys = BufReader::new(keys);
let mut keys = rustls::internal::pemfile::pkcs8_private_keys(&mut keys)
.map_err(|_| anyhow!("failed to load key `{}`", key_path))?;
.map_err(|_| anyhow!("failed to load key `{:?}`", key_path))?;
ensure!(!keys.is_empty(), "no key found");

5
src/types/body.rs
View File

@ -1,4 +1,6 @@
use tokio::{io::AsyncRead, fs::File};
use tokio::io::AsyncRead;
#[cfg(feature="serve_dir")]
use tokio::fs::File;
use crate::types::Document;
@ -37,6 +39,7 @@ impl<'a> From<&'a str> for Body {
}
}
#[cfg(feature="serve_dir")]
impl From<File> for Body {
fn from(file: File) -> Self {
Self::Reader(Box::new(file))

2
src/types/document.rs
View File

@ -39,7 +39,6 @@
use std::convert::TryInto;
use std::fmt;
use itertools::Itertools;
use crate::types::URIReference;
use crate::util::Cowy;
@ -550,5 +549,6 @@ fn strip_newlines(text: impl Cowy<str>) -> String {
text.as_ref()
.lines()
.filter(|part| !part.is_empty())
.collect::<Vec<_>>()
.join(" ")
}

50
src/util.rs
View File

@ -1,13 +1,21 @@
use std::path::Path;
#[cfg(feature="serve_dir")]
use std::path::{Path, PathBuf};
#[cfg(feature="serve_dir")]
use mime::Mime;
use anyhow::*;
#[cfg(feature="serve_dir")]
use tokio::{
fs::{self, File},
io,
};
use crate::types::{Response, Document, document::HeadingLevel::*};
use itertools::Itertools;
#[cfg(feature="serve_dir")]
use crate::types::{Document, document::HeadingLevel::*};
use crate::types::Response;
use std::panic::{catch_unwind, AssertUnwindSafe};
use std::task::Poll;
use futures_core::future::Future;
#[cfg(feature="serve_dir")]
pub async fn serve_file<P: AsRef<Path>>(path: P, mime: &Mime) -> Result<Response> {
let path = path.as_ref();
@ -22,6 +30,7 @@ pub async fn serve_file<P: AsRef<Path>>(path: P, mime: &Mime) -> Result<Response
Ok(Response::success_with_body(mime, file))
}
#[cfg(feature="serve_dir")]
pub async fn serve_dir<D: AsRef<Path>, P: AsRef<Path>>(dir: D, virtual_path: &[P]) -> Result<Response> {
debug!("Dir: {}", dir.as_ref().display());
let dir = dir.as_ref().canonicalize()
@ -47,6 +56,7 @@ pub async fn serve_dir<D: AsRef<Path>, P: AsRef<Path>>(dir: D, virtual_path: &[P
serve_dir_listing(path, virtual_path).await
}
#[cfg(feature="serve_dir")]
async fn serve_dir_listing<P: AsRef<Path>, B: AsRef<Path>>(path: P, virtual_path: &[B]) -> Result<Response> {
let mut dir = match fs::read_dir(path).await {
Ok(dir) => dir,
@ -56,10 +66,10 @@ async fn serve_dir_listing<P: AsRef<Path>, B: AsRef<Path>>(path: P, virtual_path
}
};
let breadcrumbs = virtual_path.iter().map(|segment| segment.as_ref().display()).join("/");
let breadcrumbs: PathBuf = virtual_path.iter().collect();
let mut document = Document::new();
document.add_heading(H1, format!("Index of /{}", breadcrumbs));
document.add_heading(H1, format!("Index of /{}", breadcrumbs.display()));
document.add_blank_line();
if virtual_path.get(0).map(<_>::as_ref) != Some(Path::new("")) {
@ -85,6 +95,7 @@ async fn serve_dir_listing<P: AsRef<Path>, B: AsRef<Path>>(path: P, virtual_path
Ok(Response::document(document))
}
#[cfg(feature="serve_dir")]
pub fn guess_mime_from_path<P: AsRef<Path>>(path: P) -> Mime {
let path = path.as_ref();
let extension = path.extension().and_then(|s| s.to_str());
@ -115,3 +126,32 @@ where
C: AsRef<T> + Into<T::Owned>,
T: ToOwned + ?Sized,
{}
/// A utility for catching unwinds on Futures.
///
/// This is adapted from the futures-rs CatchUnwind, in an effort to reduce the large
/// amount of dependencies tied into the feature that provides this simple struct.
#[must_use = "futures do nothing unless polled"]
pub (crate) struct HandlerCatchUnwind {
future: AssertUnwindSafe<crate::HandlerResponse>,
}
impl HandlerCatchUnwind {
pub(super) fn new(future: AssertUnwindSafe<crate::HandlerResponse>) -> Self {
Self { future }
}
}
impl Future for HandlerCatchUnwind {
type Output = Result<Result<Response>, Box<dyn std::any::Any + Send>>;
fn poll(
mut self: std::pin::Pin<&mut Self>,
cx: &mut std::task::Context
) -> Poll<Self::Output> {
match catch_unwind(AssertUnwindSafe(|| self.future.as_mut().poll(cx))) {
Ok(res) => res.map(Ok),
Err(e) => Poll::Ready(Err(e))
}
}
}