Server: require State to be Clone

Cargo.toml

@@ -44,6 +44,7 @@ route-recognizer = "0.2.0"
 logtest = "2.0.0"
 async-trait = "0.1.36"
 futures-util = "0.3.5"
+pin-project-lite = "0.1.7"
 
 [dev-dependencies]
 async-std = { version = "1.6.0", features = ["unstable", "attributes"] }

examples/graphql.rs

@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use async_std::task;
 use juniper::{http::graphiql, http::GraphQLRequest, RootNode};
 use std::sync::RwLock;
@@ -37,8 +39,9 @@ impl NewUser {
  }
 }
 
+#[derive(Clone)]
 pub struct State {
- users: RwLock<Vec<User>>,
+ users: Arc<RwLock<Vec<User>>>,
 }
 impl juniper::Context for State {}
 
@@ -96,7 +99,7 @@ async fn handle_graphiql(_: Request<State>) -> tide::Result<impl Into<Response>>
 fn main() -> std::io::Result<()> {
  task::block_on(async {
  let mut app = Server::with_state(State {
- users: RwLock::new(Vec::new()),
+ users: Arc::new(RwLock::new(Vec::new())),
  });
  app.at("/").get(Redirect::permanent("/graphiql"));
  app.at("/graphql").post(handle_graphql);

examples/middleware.rs

@@ -11,7 +11,7 @@ struct User {
  name: String,
 }
 
-#[derive(Default, Debug)]
+#[derive(Clone, Default, Debug)]
 struct UserDatabase;
 impl UserDatabase {
  async fn find_user(&self) -> Option<User> {
@@ -62,7 +62,7 @@ impl RequestCounterMiddleware {
 struct RequestCount(usize);
 
 #[tide::utils::async_trait]
-impl<State: Send + Sync + 'static> Middleware<State> for RequestCounterMiddleware {
+impl<State: Clone + Send + Sync + 'static> Middleware<State> for RequestCounterMiddleware {
  async fn handle(&self, mut req: Request<State>, next: Next<'_, State>) -> Result {
  let count = self.requests_counted.fetch_add(1, Ordering::Relaxed);
  tide::log::trace!("request counter", { count: count });

examples/upload.rs

@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use async_std::{fs::OpenOptions, io};
 use tempfile::TempDir;
 use tide::prelude::*;
@@ -6,15 +8,15 @@ use tide::{Body, Request, Response, StatusCode};
 #[async_std::main]
 async fn main() -> Result<(), std::io::Error> {
  tide::log::start();
- let mut app = tide::with_state(tempfile::tempdir()?);
+ let mut app = tide::with_state(Arc::new(tempfile::tempdir()?));
 
  // To test this example:
  // $ cargo run --example upload
  // $ curl -T ./README.md locahost:8080 # this writes the file to a temp directory
  // $ curl localhost:8080/README.md # this reads the file from the same temp directory
 
  app.at(":file")
- .put(|req: Request<TempDir>| async move {
+ .put(|req: Request<Arc<TempDir>>| async move {
  let path: String = req.param("file")?;
  let fs_path = req.state().path().join(path);
 
@@ -33,7 +35,7 @@ async fn main() -> Result<(), std::io::Error> {
 
  Ok(json!({ "bytes": bytes_written }))
  })
- .get(|req: Request<TempDir>| async move {
+ .get(|req: Request<Arc<TempDir>>| async move {
  let path: String = req.param("file")?;
  let fs_path = req.state().path().join(path);
 

src/cookies/middleware.rs

@@ -35,7 +35,7 @@ impl CookiesMiddleware {
 }
 
 #[async_trait]
-impl<State: Send + Sync + 'static> Middleware<State> for CookiesMiddleware {
+impl<State: Clone + Send + Sync + 'static> Middleware<State> for CookiesMiddleware {
  async fn handle(&self, mut ctx: Request<State>, next: Next<'_, State>) -> crate::Result {
  let cookie_jar = if let Some(cookie_data) = ctx.ext::<CookieData>() {
  cookie_data.content.clone()

src/endpoint.rs

@@ -45,7 +45,7 @@ use crate::{Middleware, Request, Response};
 ///
 /// Tide routes will also accept endpoints with `Fn` signatures of this form, but using the `async` keyword has better ergonomics.
 #[async_trait]
-pub trait Endpoint<State: Send + Sync + 'static>: Send + Sync + 'static {
+pub trait Endpoint<State: Clone + Send + Sync + 'static>: Send + Sync + 'static {
  /// Invoke the endpoint within the given context
  async fn call(&self, req: Request<State>) -> crate::Result;
 }
@@ -55,7 +55,7 @@ pub(crate) type DynEndpoint<State> = dyn Endpoint<State>;
 #[async_trait]
 impl<State, F, Fut, Res> Endpoint<State> for F
 where
- State: Send + Sync + 'static,
+ State: Clone + Send + Sync + 'static,
  F: Send + Sync + 'static + Fn(Request<State>) -> Fut,
  Fut: Future<Output = Result<Res>> + Send + 'static,
  Res: Into<Response> + 'static,
@@ -93,7 +93,7 @@ impl<E, State> std::fmt::Debug for MiddlewareEndpoint<E, State> {
 
 impl<E, State> MiddlewareEndpoint<E, State>
 where
- State: Send + Sync + 'static,
+ State: Clone + Send + Sync + 'static,
  E: Endpoint<State>,
 {
  pub fn wrap_with_middleware(ep: E, middleware: &[Arc<dyn Middleware<State>>]) -> Self {
@@ -107,7 +107,7 @@ where
 #[async_trait]
 impl<E, State> Endpoint<State> for MiddlewareEndpoint<E, State>
 where
- State: Send + Sync + 'static,
+ State: Clone + Send + Sync + 'static,
  E: Endpoint<State>,
 {
  async fn call(&self, req: Request<State>) -> crate::Result {

src/fs/serve_dir.rs

@@ -21,7 +21,7 @@ impl ServeDir {
 #[async_trait::async_trait]
 impl<State> Endpoint<State> for ServeDir
 where
- State: Send + Sync + 'static,
+ State: Clone + Send + Sync + 'static,
 {
  async fn call(&self, req: Request<State>) -> Result {
  let path = req.url().path();
@@ -60,8 +60,6 @@ where
 mod test {
  use super::*;
 
- use async_std::sync::Arc;
-
  use std::fs::{self, File};
  use std::io::Write;
 
@@ -83,7 +81,7 @@ mod test {
  let request = crate::http::Request::get(
  crate::http::Url::parse(&format!("http://localhost/{}", path)).unwrap(),
  );
- crate::Request::new(Arc::new(()), request, vec![])
+ crate::Request::new((), request, vec![])
  }
 
  #[async_std::test]

src/lib.rs

@@ -259,6 +259,7 @@ pub fn new() -> server::Server<()> {
 /// use tide::Request;
 ///
 /// /// The shared application state.
+/// #[derive(Clone)]
 /// struct State {
 /// name: String,
 /// }
@@ -279,7 +280,7 @@ pub fn new() -> server::Server<()> {
 /// ```
 pub fn with_state<State>(state: State) -> server::Server<State>
 where
- State: Send + Sync + 'static,
+ State: Clone + Send + Sync + 'static,
 {
  Server::with_state(state)
 }

src/listener/concurrent_listener.rs

@@ -35,7 +35,7 @@ use futures_util::stream::{futures_unordered::FuturesUnordered, StreamExt};
 #[derive(Default)]
 pub struct ConcurrentListener<State>(Vec<Box<dyn Listener<State>>>);
 
-impl<State: Send + Sync + 'static> ConcurrentListener<State> {
+impl<State: Clone + Send + Sync + 'static> ConcurrentListener<State> {
  /// creates a new ConcurrentListener
  pub fn new() -> Self {
  Self(vec![])
@@ -78,7 +78,7 @@ impl<State: Send + Sync + 'static> ConcurrentListener<State> {
 }
 
 #[async_trait::async_trait]
-impl<State: Send + Sync + 'static> Listener<State> for ConcurrentListener<State> {
+impl<State: Clone + Send + Sync + 'static> Listener<State> for ConcurrentListener<State> {
  async fn listen(&mut self, app: Server<State>) -> io::Result<()> {
  let mut futures_unordered = FuturesUnordered::new();
 

src/listener/failover_listener.rs

@@ -35,7 +35,7 @@ use async_std::io;
 #[derive(Default)]
 pub struct FailoverListener<State>(Vec<Box<dyn Listener<State>>>);
 
-impl<State: Send + Sync + 'static> FailoverListener<State> {
+impl<State: Clone + Send + Sync + 'static> FailoverListener<State> {
  /// creates a new FailoverListener
  pub fn new() -> Self {
  Self(vec![])
@@ -80,7 +80,7 @@ impl<State: Send + Sync + 'static> FailoverListener<State> {
 }
 
 #[async_trait::async_trait]
-impl<State: Send + Sync + 'static> Listener<State> for FailoverListener<State> {
+impl<State: Clone + Send + Sync + 'static> Listener<State> for FailoverListener<State> {
  async fn listen(&mut self, app: Server<State>) -> io::Result<()> {
  for listener in self.0.iter_mut() {
  let app = app.clone();

src/listener/parsed_listener.rs

@@ -31,7 +31,7 @@ impl Display for ParsedListener {
 }
 
 #[async_trait::async_trait]
-impl<State: Send + Sync + 'static> Listener<State> for ParsedListener {
+impl<State: Clone + Send + Sync + 'static> Listener<State> for ParsedListener {
  async fn listen(&mut self, app: Server<State>) -> io::Result<()> {
  match self {
  #[cfg(unix)]

src/listener/tcp_listener.rs

@@ -51,7 +51,7 @@ impl TcpListener {
  }
 }
 
-fn handle_tcp<State: Send + Sync + 'static>(app: Server<State>, stream: TcpStream) {
+fn handle_tcp<State: Clone + Send + Sync + 'static>(app: Server<State>, stream: TcpStream) {
  task::spawn(async move {
  let local_addr = stream.local_addr().ok();
  let peer_addr = stream.peer_addr().ok();
@@ -69,7 +69,7 @@ fn handle_tcp<State: Send + Sync + 'static>(app: Server<State>, stream: TcpStrea
 }
 
 #[async_trait::async_trait]
-impl<State: Send + Sync + 'static> Listener<State> for TcpListener {
+impl<State: Clone + Send + Sync + 'static> Listener<State> for TcpListener {
  async fn listen(&mut self, app: Server<State>) -> io::Result<()> {
  self.connect().await?;
  let listener = self.listener()?;

src/listener/to_listener.rs

@@ -52,7 +52,7 @@ use std::net::ToSocketAddrs;
 /// # Other implementations
 /// See below for additional provided implementations of ToListener.
 
-pub trait ToListener<State: Send + Sync + 'static> {
+pub trait ToListener<State: Clone + Send + Sync + 'static> {
  type Listener: Listener<State>;
  /// Transform self into a
  /// [`Listener`](crate::listener::Listener). Unless self is
@@ -63,7 +63,7 @@ pub trait ToListener<State: Send + Sync + 'static> {
  fn to_listener(self) -> io::Result<Self::Listener>;
 }
 
-impl<State: Send + Sync + 'static> ToListener<State> for Url {
+impl<State: Clone + Send + Sync + 'static> ToListener<State> for Url {
  type Listener = ParsedListener;
 
  fn to_listener(self) -> io::Result<Self::Listener> {
@@ -106,14 +106,14 @@ impl<State: Send + Sync + 'static> ToListener<State> for Url {
  }
 }
 
-impl<State: Send + Sync + 'static> ToListener<State> for String {
+impl<State: Clone + Send + Sync + 'static> ToListener<State> for String {
  type Listener = ParsedListener;
  fn to_listener(self) -> io::Result<Self::Listener> {
  ToListener::<State>::to_listener(self.as_str())
  }
 }
 
-impl<State: Send + Sync + 'static> ToListener<State> for &str {
+impl<State: Clone + Send + Sync + 'static> ToListener<State> for &str {
  type Listener = ParsedListener;
 
  fn to_listener(self) -> io::Result<Self::Listener> {
@@ -133,36 +133,36 @@ impl<State: Send + Sync + 'static> ToListener<State> for &str {
 }
 
 #[cfg(unix)]
-impl<State: Send + Sync + 'static> ToListener<State> for async_std::path::PathBuf {
+impl<State: Clone + Send + Sync + 'static> ToListener<State> for async_std::path::PathBuf {
  type Listener = UnixListener;
  fn to_listener(self) -> io::Result<Self::Listener> {
  Ok(UnixListener::from_path(self))
  }
 }
 
 #[cfg(unix)]
-impl<State: Send + Sync + 'static> ToListener<State> for std::path::PathBuf {
+impl<State: Clone + Send + Sync + 'static> ToListener<State> for std::path::PathBuf {
  type Listener = UnixListener;
  fn to_listener(self) -> io::Result<Self::Listener> {
  Ok(UnixListener::from_path(self))
  }
 }
 
-impl<State: Send + Sync + 'static> ToListener<State> for async_std::net::TcpListener {
+impl<State: Clone + Send + Sync + 'static> ToListener<State> for async_std::net::TcpListener {
  type Listener = TcpListener;
  fn to_listener(self) -> io::Result<Self::Listener> {
  Ok(TcpListener::from_listener(self))
  }
 }
 
-impl<State: Send + Sync + 'static> ToListener<State> for std::net::TcpListener {
+impl<State: Clone + Send + Sync + 'static> ToListener<State> for std::net::TcpListener {
  type Listener = TcpListener;
  fn to_listener(self) -> io::Result<Self::Listener> {
  Ok(TcpListener::from_listener(self))
  }
 }
 
-impl<State: Send + Sync + 'static> ToListener<State> for (&str, u16) {
+impl<State: Clone + Send + Sync + 'static> ToListener<State> for (&str, u16) {
  type Listener = TcpListener;
 
  fn to_listener(self) -> io::Result<Self::Listener> {
@@ -171,65 +171,67 @@ impl<State: Send + Sync + 'static> ToListener<State> for (&str, u16) {
 }
 
 #[cfg(unix)]
-impl<State: Send + Sync + 'static> ToListener<State> for async_std::os::unix::net::UnixListener {
+impl<State: Clone + Send + Sync + 'static> ToListener<State>
+ for async_std::os::unix::net::UnixListener
+{
  type Listener = UnixListener;
  fn to_listener(self) -> io::Result<Self::Listener> {
  Ok(UnixListener::from_listener(self))
  }
 }
 
 #[cfg(unix)]
-impl<State: Send + Sync + 'static> ToListener<State> for std::os::unix::net::UnixListener {
+impl<State: Clone + Send + Sync + 'static> ToListener<State> for std::os::unix::net::UnixListener {
  type Listener = UnixListener;
  fn to_listener(self) -> io::Result<Self::Listener> {
  Ok(UnixListener::from_listener(self))
  }
 }
 
-impl<State: Send + Sync + 'static> ToListener<State> for TcpListener {
+impl<State: Clone + Send + Sync + 'static> ToListener<State> for TcpListener {
  type Listener = Self;
  fn to_listener(self) -> io::Result<Self::Listener> {
  Ok(self)
  }
 }
 
 #[cfg(unix)]
-impl<State: Send + Sync + 'static> ToListener<State> for UnixListener {
+impl<State: Clone + Send + Sync + 'static> ToListener<State> for UnixListener {
  type Listener = Self;
  fn to_listener(self) -> io::Result<Self::Listener> {
  Ok(self)
  }
 }
 
-impl<State: Send + Sync + 'static> ToListener<State> for ConcurrentListener<State> {
+impl<State: Clone + Send + Sync + 'static> ToListener<State> for ConcurrentListener<State> {
  type Listener = Self;
  fn to_listener(self) -> io::Result<Self::Listener> {
  Ok(self)
  }
 }
 
-impl<State: Send + Sync + 'static> ToListener<State> for ParsedListener {
+impl<State: Clone + Send + Sync + 'static> ToListener<State> for ParsedListener {
  type Listener = Self;
  fn to_listener(self) -> io::Result<Self::Listener> {
  Ok(self)
  }
 }
 
-impl<State: Send + Sync + 'static> ToListener<State> for FailoverListener<State> {
+impl<State: Clone + Send + Sync + 'static> ToListener<State> for FailoverListener<State> {
  type Listener = Self;
  fn to_listener(self) -> io::Result<Self::Listener> {
  Ok(self)
  }
 }
 
-impl<State: Send + Sync + 'static> ToListener<State> for std::net::SocketAddr {
+impl<State: Clone + Send + Sync + 'static> ToListener<State> for std::net::SocketAddr {
  type Listener = TcpListener;
  fn to_listener(self) -> io::Result<Self::Listener> {
  Ok(TcpListener::from_addrs(vec![self]))
  }
 }
 
-impl<TL: ToListener<State>, State: Send + Sync + 'static> ToListener<State> for Vec<TL> {
+impl<TL: ToListener<State>, State: Clone + Send + Sync + 'static> ToListener<State> for Vec<TL> {
  type Listener = ConcurrentListener<State>;
  fn to_listener(self) -> io::Result<Self::Listener> {
  let mut concurrent_listener = ConcurrentListener::new();