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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

#![deny(
    clippy::dbg_macro,
    missing_copy_implementations,
    rustdoc::missing_crate_level_docs,
    missing_debug_implementations,
    missing_docs,
    nonstandard_style,
    unused_qualifications
)]

/*!
# Trillium adapter using smol and async-global-executor

## Default / 12-factor applications

```rust,no_run
trillium_smol::run(|conn: trillium::Conn| async move {
    conn.ok("hello smol")
});
```

## Server configuration

For more details, see [trillium_smol::config](crate::config).

```rust
let stopper = trillium_smol::Stopper::new();
# stopper.stop(); // stoppping the server immediately for the test
trillium_smol::config()
    .with_port(0)
    .with_host("127.0.0.1")
    .without_signals()
    .with_nodelay()
    .with_acceptor(()) // see [`trillium_rustls`] and [`trillium_native_tls`]
    .with_stopper(stopper)
    .run(|conn: trillium::Conn| async move {
        conn.ok("hello smol")
    });
```

## Client

```rust
# #[cfg(feature = "smol")]
trillium_testing::with_server("ok", |url| async move {
    use trillium_smol::TcpConnector;
    use trillium_client::{Conn, Client};
    let mut conn = Conn::<TcpConnector>::get(url.clone()).execute().await?;
    assert_eq!(conn.response_body().read_string().await?, "ok");

    let client = Client::<TcpConnector>::new().with_default_pool();
    let mut conn = client.get(url);
    conn.send().await?;
    assert_eq!(conn.response_body().read_string().await?, "ok");
    Ok(())
});
```


*/

use trillium::Handler;
pub use trillium_server_common::{Binding, CloneCounterObserver, Stopper};

mod client;
pub use client::ClientConfig;

mod server;
use server::Config;

mod transport;
pub use transport::SmolTransport;

pub use async_global_executor;
pub use async_io;
pub use async_net;

/**
# Runs a trillium handler in a sync context with default config

Runs a trillium handler on the async-global-executor runtime with
default configuration. See [`crate::config`] for what the defaults are
and how to override them


This function will block the current thread until the server shuts
down
*/
pub fn run(handler: impl Handler) {
    config().run(handler)
}

/**
# Runs a trillium handler in an async context with default config

Run the provided trillium handler on an already-running async-executor
with default settings. The defaults are the same as [`crate::run`]. To
customize these settings, see [`crate::config`].

This function will poll pending until the server shuts down.

*/
pub async fn run_async(handler: impl Handler) {
    config().run_async(handler).await
}

/**
# Configures a server before running it

## Defaults

The default configuration is as follows:

* port: the contents of the `PORT` env var or else 8080
* host: the contents of the `HOST` env var or else "localhost"
* signals handling and graceful shutdown: enabled on cfg(unix) systems
* tcp nodelay: disabled
* tls acceptor: none

## Usage

```rust
let stopper = trillium_smol::Stopper::new();
# stopper.stop(); // stoppping the server immediately for the test
trillium_smol::config()
    .with_port(0)
    .with_host("127.0.0.1")
    .without_signals()
    .with_nodelay()
    .with_acceptor(()) // see [`trillium_rustls`] and [`trillium_native_tls`]
    .with_stopper(stopper)
    .run(|conn: trillium::Conn| async move {
        conn.ok("hello smol")
    });
```

See [`trillium_server_common::Config`] for more details

*/
pub fn config() -> Config<()> {
    Config::new()
}

/// spawn and detach a Future that returns ()
pub fn spawn<Fut: std::future::Future<Output = ()> + Send + 'static>(future: Fut) {
    async_global_executor::spawn(future).detach();
}