blazingly-native 0.1.1

Native Compio HTTP/1 adapter for Blazingly, with optional rustls TLS and an experimental HTTP/2 path
Documentation 
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

# blazingly-native

Native Compio-based HTTP/1 server adapter for the
[Blazingly](https://github.com/sergii-ziborov/blazingly) framework, with
optional rustls TLS (`tls` feature) and an experimental HTTP/2 path (`http2`
feature).

The adapter deliberately owns every socket-runtime and wire-protocol
dependency, so the operation graph, router, DI, and documentation crates stay
runtime-neutral; Tokio, Hyper, and Axum are not in this crate's tree. Parsing
and framing come from `blazingly-wire`, sockets and completion I/O from
Compio. `Server` serves one compiled app; `MulticoreServer` runs
thread-per-core with one non-`Send` app per worker; `ServerLimits` enforces
header, body, chunk, pipeline, and socket-deadline limits before an operation
is dispatched; `shutdown_channel` and `termination_channel` drive graceful
drain. The crate is usable without the `blazingly` facade: anything that
produces an `ExecutableApp` — the facade's macros, or explicit construction
as below — can be served. The facade gates this adapter behind its
non-default `native` feature and exposes it as `blazingly::native`.

```toml
[dependencies]
blazingly-core = "0.1"
blazingly-executor = "0.1"
blazingly-native = "0.1"
```

```rust
use blazingly_core::{HttpMethod, OperationDescriptor, ResponseDescriptor, TypeDescriptor};
use blazingly_executor::{ExecutableApp, ExecutableOperation, ExecutionOutcome, OperationFuture};
use blazingly_native::Server;

fn health() -> ExecutableOperation {
    let descriptor = OperationDescriptor::new(
        HttpMethod::Get,
        "/health",
        "app.health",
        "Reports liveness",
        None,
        vec![ResponseDescriptor::success(
            200,
            Some(TypeDescriptor::new("Health")),
        )],
    )
    .expect("operation id is valid");
    ExecutableOperation::typed(descriptor, |_input| {
        Ok(Box::pin(async {
            ExecutionOutcome::Success {
                status: 200,
                headers: Vec::new(),
                body: Some(b"\"ok\"".to_vec()),
                background: Vec::new(),
            }
        }) as OperationFuture)
    })
}

fn main() -> std::io::Result<()> {
    let app = ExecutableApp::new([health()]).expect("operation graph compiles");
    Server::new(app).serve("127.0.0.1:3000")
}
```

## Links

- [API documentation](https://docs.rs/blazingly-native)
- [Getting started](https://github.com/sergii-ziborov/blazingly/blob/main/docs/getting-started.md) — the framework picture
- [Repository](https://github.com/sergii-ziborov/blazingly)