veil-api 0.8.2__tar.gz → 0.8.3__tar.gz

{veil_api-0.8.2 → veil_api-0.8.3}/Cargo.lock

@@ -4301,7 +4301,7 @@ dependencies = [
 
 [[package]]
 name = "veil-capi"
-version = "0.8.2"
+version = "0.8.3"
 dependencies = [
  "bytes",
  "serde_json",
@@ -4319,7 +4319,7 @@ dependencies = [
 
 [[package]]
 name = "veil-proxy"
-version = "0.8.2"
+version = "0.8.3"
 dependencies = [
  "anyhow",
  "arc-swap",
@@ -4403,14 +4403,14 @@ dependencies = [
 
 [[package]]
 name = "veil-proxy-build"
-version = "0.8.2"
+version = "0.8.3"
 dependencies = [
  "prost-build",
 ]
 
 [[package]]
 name = "veil-proxy-macros"
-version = "0.8.2"
+version = "0.8.3"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4419,8 +4419,9 @@ dependencies = [
 
 [[package]]
 name = "veil-proxy-quiche"
-version = "0.24.9-veil.1"
+version = "0.24.9-veil.2"
 dependencies = [
+ "aws-lc-sys",
  "boring",
  "cdylib-link-lines",
  "cmake",
@@ -4509,7 +4510,7 @@ dependencies = [
 
 [[package]]
 name = "veil-python"
-version = "0.8.2"
+version = "0.8.3"
 dependencies = [
  "bytes",
  "itoa",

{veil_api-0.8.2 → veil_api-0.8.3}/Cargo.toml

@@ -40,7 +40,7 @@ resolver = "2"
 # （ルートから veil-macros への依存の版と、ワークスペース外の Cargo.lock も一緒に更新する）。
 # 公開の workflow（.github/workflows/release.yml）はタグとこの版が違えば何も公開しない。
 [workspace.package]
-version = "0.8.2"
+version = "0.8.3"
 edition = "2021"
 license = "Apache-2.0 OR MIT"
 authors = ["aofusa"]
@@ -677,7 +677,7 @@ regex = { version = "1", optional = true }
 serde_urlencoded = { version = "0.7", optional = true }
 # マクロで定義したルート・L4 ハンドラの静的登録（リンク時に収集）
 inventory = { version = "0.3", optional = true }
-veil-macros = { package = "veil-proxy-macros", path = "crates/veil-macros", version = "0.8.2", optional = true }
+veil-macros = { package = "veil-proxy-macros", path = "crates/veil-macros", version = "0.8.3", optional = true }
 tower-service = { version = "0.3", optional = true }
 tower-layer = { version = "0.3", optional = true }
 http = { version = "1.4", optional = true }
@@ -715,7 +715,7 @@ ring = "0.17"
 rcgen = { version = "0.14.6", optional = true, default-features = false, features = ["crypto", "pem", "ring"] }
 # OpenBSD/NetBSD の quiche(http3) は vendored BoringSSL（`boringssl-boring-crate` feature、
 # 外部 `boring` crate 経由）を無条件で使う（FreeBSD/macOS/Windows と同じ構成、F-136）。
-quiche = { package = "veil-proxy-quiche", path = "third_party/quiche", version = "=0.24.9-veil.1", default-features = false, features = ["boringssl-boring-crate"], optional = true }
+quiche = { package = "veil-proxy-quiche", path = "third_party/quiche", version = "=0.24.9-veil.2", default-features = false, features = ["boringssl-boring-crate"], optional = true }
 # quiche 0.24.9 が依存する boring のバージョンと必ず一致させること（異なると
 # `SslContextBuilder` の型が別物になりコンパイルエラーになる）。FreeBSD/macOS/Windows と
 # 同じ理由で optional にしない。
@@ -933,7 +933,10 @@ required-features = ["wasm"]
 # **Linux は無変更**（AGENTS.md「Linux 経路は不変」）: `boring` crate を Linux の依存に
 # 入れてはならない（重複シンボルでリンクが壊れる）。
 [target.'cfg(target_os = "linux")'.dependencies]
-quiche = { package = "veil-proxy-quiche", path = "third_party/quiche", version = "=0.24.9-veil.1", default-features = false, optional = true }
+# F-243: quiche の BoringSSL の FFI を aws-lc-sys の Rust のバインディング経由で呼ぶ（`aws-lc-sys` feature、
+# third_party/quiche/src/veil_ffi.rs）。aws-lc-sys の接頭辞の有無（AWS_LC_SYS_NO_PREFIX）を問わずリンクできるので、
+# veil を依存にする利用者は .cargo/config.toml に何も書かなくてよい。
+quiche = { package = "veil-proxy-quiche", path = "third_party/quiche", version = "=0.24.9-veil.2", default-features = false, features = ["aws-lc-sys"], optional = true }
 # F-238: rustls（aws-lc-rs）が引く aws-lc-sys と必ず同じ 1 つの版にする（2 つになると、プレフィックス無しの
 # シンボルが衝突し、ビルドが libcrypto を見つけられずに失敗する）。crates.io から入れた利用者の解決では
 # aws-lc-rs の最新が新しい aws-lc-sys を要求するので、範囲で受けて同じ版に寄せる。
@@ -944,7 +947,7 @@ aws-lc-sys = { version = ">=0.45, <0.48", features = ["ssl", "bindgen"] }
 # `boringssl-boring-crate` feature 経由でしか提供されないため、常時これを使う
 # （macOS/Windows と同じ構成）。
 [target.'cfg(target_os = "freebsd")'.dependencies]
-quiche = { package = "veil-proxy-quiche", path = "third_party/quiche", version = "=0.24.9-veil.1", default-features = false, features = ["boringssl-boring-crate"], optional = true }
+quiche = { package = "veil-proxy-quiche", path = "third_party/quiche", version = "=0.24.9-veil.2", default-features = false, features = ["boringssl-boring-crate"], optional = true }
 # quiche 0.24.9 が依存する boring のバージョンと必ず一致させること（異なると
 # `SslContextBuilder` の型が別物になりコンパイルエラーになる）。FreeBSD は常に
 # BoringSSL 固定のため optional にしない（http3 feature 無効時の追加コストは
@@ -953,7 +956,7 @@ boring = "4.3"
 
 # macOS/Windows: 従来どおり vendored BoringSSL（boring crate）を無条件で使う（不変）。
 [target.'cfg(any(target_os = "macos", windows))'.dependencies]
-quiche = { package = "veil-proxy-quiche", path = "third_party/quiche", version = "=0.24.9-veil.1", default-features = false, features = ["boringssl-boring-crate"], optional = true }
+quiche = { package = "veil-proxy-quiche", path = "third_party/quiche", version = "=0.24.9-veil.2", default-features = false, features = ["boringssl-boring-crate"], optional = true }
 # `src/http3_server.rs` が `boring::ssl::SslContextBuilder` 等を直接使うための直接依存
 # （quiche 内部の boring 依存とは別に、自クレートのコードから使うには直接宣言が要る）。
 # Cargo の feature はターゲット非依存（`http3 = ["dep:quiche"]` に `dep:boring` を
@@ -983,7 +986,7 @@ tonic = { version = "0.14.2", features = ["tls-ring", "channel"] }
 # ビルド時のみ複数フレームを詰める）。小さい応答を多数多重化する HTTP/3 ではリクエストごとに
 # 1 パケット（sendto + AEAD + ヘッダ保護）を払うことになり、FreeBSD aarch64 の 3B 静的配信で
 # 送信 syscall が 1.01/req（nginx 0.22/req）だった。常に詰めるよう 1 箇所だけ差し替えた
-# vendoring 版を `veil-proxy-quiche`（版 0.24.9-veil.1）として各ターゲットの依存に直接書く（上の
+# vendoring 版を `veil-proxy-quiche`（版 0.24.9-veil.2）として各ターゲットの依存に直接書く（上の
 # target 別の quiche。依存のキーは `quiche` のままなのでコードは `quiche::` のまま）。以前は
 # `[patch.crates-io]` で差し替えていたが、patch は crates.io から入れた利用者のビルドには効かない（F-238）。
 # 詳細は third_party/quiche/README.veil.md。

veil_api-0.8.3/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: veil-api
+Version: 0.8.3
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: License :: OSI Approved :: MIT License
+Requires-Dist: grpcio ; extra == 'grpc'
+Requires-Dist: pydantic>=2 ; extra == 'pydantic'
+Provides-Extra: grpc
+Provides-Extra: pydantic
+Summary: veil API server library: FastAPI-like Python bindings (io_uring / HTTP/1.1, 2, 3)
+Author: aofusa
+License: Apache-2.0 OR MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Changelog, https://github.com/aofusa/veil-proxy/releases
+Project-URL: Documentation, https://veil-api.readthedocs.io
+Project-URL: Source, https://github.com/aofusa/veil-proxy
+
+# veil-api
+
+FastAPI-like Python bindings for the [veil](https://github.com/aofusa/veil-proxy) API server.
+
+Accepting connections, TLS, HTTP/1.1, HTTP/2, HTTP/3, gRPC and OpenAPI serving are handled
+by the Rust data plane (io_uring on Linux), so Python only contains your handler functions, written with
+FastAPI-style decorators. The package is installed as `veil-api` and imported as `veil`.
+
+## Install
+
+```bash
+pip install veil-api
+pip install "veil-api[grpc]"      # adds grpcio, for veil.grpc.Server (generated grpc_tools.protoc code)
+pip install pydantic              # optional: body validation and schema generation with models
+```
+
+Pre-built wheels are published for:
+
+- Linux: manylinux and musllinux, x86_64 and aarch64
+- macOS: arm64 and x86_64
+- Windows: x86_64
+
+All wheels are abi3, so one wheel works on every Python 3.9 or newer.
+Linux uses io_uring; the other platforms use the platform's native readiness API (kqueue, WSAPoll).
+
+## Quick start
+
+```python
+import veil
+
+@veil.get("/ping", offload=False)
+def ping():
+    return "pong"
+
+@veil.get("/hello/{name}")
+def hello(name: str, greeting: str = "Hello"):   # name: path parameter, greeting: query parameter
+    return {"message": f"{greeting}, {name}"}
+
+@veil.post("/users", status_code=201,
+           body_constraints={"name": {"type": "string", "minLength": 1, "maxLength": 50, "required": True},
+                             "age": {"type": "integer", "minimum": 0, "maximum": 120, "required": True}})
+def create_user(body: dict):
+    return body
+
+veil.run(listen_cleartext="127.0.0.1:8000")      # stops gracefully on Ctrl-C / SIGTERM
+```
+
+You can also create an application object, as in FastAPI:
+
+```python
+app = veil.App(title="Demo", version="1.0")
+
+@app.get("/")
+def index():
+    return {"ok": True}
+
+app.run(listen_cleartext="127.0.0.1:8000")
+```
+
+The server also serves `/openapi.json` and Swagger UI at `/docs` (disable with `run(openapi=False)`).
+
+## Handlers at a glance
+
+- **Arguments** are bound from the signature: a parameter named `req`/`request` (or annotated `veil.Request`)
+  receives the request; a name that appears in the path is a path parameter (converted by its `int`/`float`/`bool`/`str`
+  annotation); a pydantic `BaseModel`, `dict`/`list` annotation or the name `body` receives the JSON body;
+  anything else is a query parameter. Missing or invalid values produce a FastAPI-style 422 response.
+- **Return values**: `dict`/`list`/numbers become JSON, `str` is `text/plain`, `bytes` is
+  `application/octet-stream`, `None` is 204; `veil.Response`, `veil.JSONResponse`, `(body, status)` and pydantic
+  models are also accepted. `raise veil.HTTPException(404, "not found")` produces `{"detail": "not found"}`.
+  An unhandled exception is printed to stderr and answered with 500.
+- **Streaming**: generators (sync or async), `veil.StreamingResponse`, `veil.EventSourceResponse` (Server-Sent
+  Events) and `@veil.post(..., stream_body=True)` for streamed request bodies.
+- **gRPC**: `veil.grpc.unary_unary` and friends (no dependencies), or `veil.grpc.Server` with grpcio-generated code.
+- **WebSocket**: Python handlers cannot terminate WebSocket connections; use Server-Sent Events or streaming
+  responses for server push.
+- **L4**: `@veil.l4_tcp` and `@veil.l4_udp` for raw TCP and UDP listeners.
+- **Configuration**: `veil.run(config_path=None, *, listen_cleartext=None, listen=None, tls_cert=None, tls_key=None,
+  threads=None, overrides=None, openapi=True)`. `overrides` maps config keys to Python values, for example
+  `{"server.threads": 4}`. Use `listen` with `tls_cert` and `tls_key` for TLS (HTTP/2 and HTTP/3).
+- **Access log**: one line per request is written to standard output by default (`[access_log] enabled = true`,
+  `format = "text"`). Turn it off with `overrides={"access_log.enabled": False}`.
+
+## Threads and the GIL
+
+Python handlers run while holding the GIL.
+
+- By default (`offload=True`) a handler runs on veil's handler thread pool (`[api] handler_threads`), so the
+  I/O worker threads never wait for the GIL and keep serving connections. `async def` handlers run on one event
+  loop per pool thread.
+- With `offload=False` the handler runs directly on the I/O worker thread. Use it only for trivially cheap
+  handlers: blocking I/O or long GIL holds stall every connection that worker owns.
+- Pure Python handlers are limited by the GIL; for CPU-bound work consider a multi-process deployment.
+- Streaming responses are iterated on a handler pool thread. On an `offload=False` route the whole body is built
+  before it is sent.
+
+## Documentation
+
+Full documentation (quick start, routing, requests and responses, dependency injection, long-lived connections, gRPC,
+configuration and the API reference) is on Read the Docs: <https://veil-api.readthedocs.io>.
+
+Source code, examples and issue tracker: <https://github.com/aofusa/veil-proxy>.
+
+## License
+
+Apache-2.0 OR MIT
+

{veil_api-0.8.2 → veil_api-0.8.3}/README.crates-io.md

@@ -35,18 +35,10 @@ async fn main() -> Result<(), veil::api::Error> {
 }
 ```
 
-## HTTP/3 on Linux needs one line of Cargo configuration
+## Build requirements
 
-On Linux, quiche shares rustls' `aws-lc-sys` and needs it built without symbol prefixes. Add this to
-`.cargo/config.toml` of your project (use your target triple; the build stops with this message when it is missing):
-
-```toml
-[env]
-AWS_LC_SYS_NO_PREFIX_x86_64_unknown_linux_gnu = { value = "1", force = true }
-# AWS_LC_SYS_NO_PREFIX_aarch64_unknown_linux_gnu = { value = "1", force = true }
-```
-
-Builds without the `http3` feature, and other operating systems, do not need it.
+The `Cargo.toml` entry is all you need; there is nothing to add to `.cargo/config.toml`, also for HTTP/3 on Linux.
+quiche and rustls share one `aws-lc-sys`, whose build needs a C compiler, CMake and libclang (bindgen).
 
 ## Documentation
 

veil_api-0.8.3/README.md

@@ -0,0 +1,106 @@
+# veil-api
+
+FastAPI-like Python bindings for the [veil](https://github.com/aofusa/veil-proxy) API server.
+
+Accepting connections, TLS, HTTP/1.1, HTTP/2, HTTP/3, gRPC and OpenAPI serving are handled
+by the Rust data plane (io_uring on Linux), so Python only contains your handler functions, written with
+FastAPI-style decorators. The package is installed as `veil-api` and imported as `veil`.
+
+## Install
+
+```bash
+pip install veil-api
+pip install "veil-api[grpc]"      # adds grpcio, for veil.grpc.Server (generated grpc_tools.protoc code)
+pip install pydantic              # optional: body validation and schema generation with models
+```
+
+Pre-built wheels are published for:
+
+- Linux: manylinux and musllinux, x86_64 and aarch64
+- macOS: arm64 and x86_64
+- Windows: x86_64
+
+All wheels are abi3, so one wheel works on every Python 3.9 or newer.
+Linux uses io_uring; the other platforms use the platform's native readiness API (kqueue, WSAPoll).
+
+## Quick start
+
+```python
+import veil
+
+@veil.get("/ping", offload=False)
+def ping():
+    return "pong"
+
+@veil.get("/hello/{name}")
+def hello(name: str, greeting: str = "Hello"):   # name: path parameter, greeting: query parameter
+    return {"message": f"{greeting}, {name}"}
+
+@veil.post("/users", status_code=201,
+           body_constraints={"name": {"type": "string", "minLength": 1, "maxLength": 50, "required": True},
+                             "age": {"type": "integer", "minimum": 0, "maximum": 120, "required": True}})
+def create_user(body: dict):
+    return body
+
+veil.run(listen_cleartext="127.0.0.1:8000")      # stops gracefully on Ctrl-C / SIGTERM
+```
+
+You can also create an application object, as in FastAPI:
+
+```python
+app = veil.App(title="Demo", version="1.0")
+
+@app.get("/")
+def index():
+    return {"ok": True}
+
+app.run(listen_cleartext="127.0.0.1:8000")
+```
+
+The server also serves `/openapi.json` and Swagger UI at `/docs` (disable with `run(openapi=False)`).
+
+## Handlers at a glance
+
+- **Arguments** are bound from the signature: a parameter named `req`/`request` (or annotated `veil.Request`)
+  receives the request; a name that appears in the path is a path parameter (converted by its `int`/`float`/`bool`/`str`
+  annotation); a pydantic `BaseModel`, `dict`/`list` annotation or the name `body` receives the JSON body;
+  anything else is a query parameter. Missing or invalid values produce a FastAPI-style 422 response.
+- **Return values**: `dict`/`list`/numbers become JSON, `str` is `text/plain`, `bytes` is
+  `application/octet-stream`, `None` is 204; `veil.Response`, `veil.JSONResponse`, `(body, status)` and pydantic
+  models are also accepted. `raise veil.HTTPException(404, "not found")` produces `{"detail": "not found"}`.
+  An unhandled exception is printed to stderr and answered with 500.
+- **Streaming**: generators (sync or async), `veil.StreamingResponse`, `veil.EventSourceResponse` (Server-Sent
+  Events) and `@veil.post(..., stream_body=True)` for streamed request bodies.
+- **gRPC**: `veil.grpc.unary_unary` and friends (no dependencies), or `veil.grpc.Server` with grpcio-generated code.
+- **WebSocket**: Python handlers cannot terminate WebSocket connections; use Server-Sent Events or streaming
+  responses for server push.
+- **L4**: `@veil.l4_tcp` and `@veil.l4_udp` for raw TCP and UDP listeners.
+- **Configuration**: `veil.run(config_path=None, *, listen_cleartext=None, listen=None, tls_cert=None, tls_key=None,
+  threads=None, overrides=None, openapi=True)`. `overrides` maps config keys to Python values, for example
+  `{"server.threads": 4}`. Use `listen` with `tls_cert` and `tls_key` for TLS (HTTP/2 and HTTP/3).
+- **Access log**: one line per request is written to standard output by default (`[access_log] enabled = true`,
+  `format = "text"`). Turn it off with `overrides={"access_log.enabled": False}`.
+
+## Threads and the GIL
+
+Python handlers run while holding the GIL.
+
+- By default (`offload=True`) a handler runs on veil's handler thread pool (`[api] handler_threads`), so the
+  I/O worker threads never wait for the GIL and keep serving connections. `async def` handlers run on one event
+  loop per pool thread.
+- With `offload=False` the handler runs directly on the I/O worker thread. Use it only for trivially cheap
+  handlers: blocking I/O or long GIL holds stall every connection that worker owns.
+- Pure Python handlers are limited by the GIL; for CPU-bound work consider a multi-process deployment.
+- Streaming responses are iterated on a handler pool thread. On an `offload=False` route the whole body is built
+  before it is sent.
+
+## Documentation
+
+Full documentation (quick start, routing, requests and responses, dependency injection, long-lived connections, gRPC,
+configuration and the API reference) is on Read the Docs: <https://veil-api.readthedocs.io>.
+
+Source code, examples and issue tracker: <https://github.com/aofusa/veil-proxy>.
+
+## License
+
+Apache-2.0 OR MIT

{veil_api-0.8.2 → veil_api-0.8.3}/build.rs

@@ -7,10 +7,10 @@
 //! `std::env::set_var` してもこれらへは一切伝播しない（B-47）。
 //! ターゲット別の値と理由は `.cargo/config.toml` のコメントを参照。
 //!
-//! F-238: その `.cargo/config.toml` は、veil を依存として（crates.io・git から）使う側のビルドでは
-//! 読まれない。Linux の `http3` で値が無いと、リンクの段で quiche の BoringSSL のシンボルが見つからない
-//! という分かりにくい失敗になるので、ここで値を確かめ、要る設定を示して先に止める
-//! （[`check_aws_lc_no_prefix`]）。
+//! F-243: Linux の quiche は aws-lc-sys の Rust のバインディング経由で BoringSSL の API を呼ぶ
+//! （`third_party/quiche/src/veil_ffi.rs`）ので、接頭辞の有無を問わずリンクできる。veil を依存として使う側は
+//! `[env]` を書かなくてよい（以前はここで値を確かめて止めていた。F-238）。veil のリポジトリの `[env]` は、
+//! 配布物のシンボル名を揃えるためだけに残している。
 //!
 //! F-120: クロスプラットフォーム対応（Phase 1）向けに、target_os / feature の
 //! 組み合わせから `veil_rt_uring` / `veil_rt_reactor` / `veil_poller_epoll` /
@@ -28,44 +28,6 @@ fn main() {
     emit_runtime_backend_cfg();
     emit_wasm_nosignals_cfg();
     emit_allocator_cfg();
-    check_aws_lc_no_prefix();
-}
-
-/// F-238: Linux の `http3` は、quiche が rustls と同じ aws-lc-sys を BoringSSL 互換の非プレフィックスの
-/// シンボルで使う（B-47）。そのため aws-lc-sys のビルドに `AWS_LC_SYS_NO_PREFIX_<triple>=1` が要る。
-/// 値は aws-lc-sys のビルドスクリプトが読むので、ここでは設定できない（確かめるだけ）。docs.rs は
-/// リンクしない（rustdoc）ので確かめない。
-fn check_aws_lc_no_prefix() {
-    let target = std::env::var("TARGET").unwrap_or_default();
-    let suffixed = format!("AWS_LC_SYS_NO_PREFIX_{}", target.replace('-', "_"));
-    println!("cargo:rerun-if-env-changed={suffixed}");
-    println!("cargo:rerun-if-env-changed=AWS_LC_SYS_NO_PREFIX");
-    println!("cargo:rerun-if-env-changed=DOCS_RS");
-    let linux = std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("linux");
-    if !linux || !feature_enabled("HTTP3") || std::env::var_os("DOCS_RS").is_some() {
-        return;
-    }
-    // aws-lc-sys の parse_to_bool と同じ解釈（先頭が 0/n/off/f なら偽、数字/y/on/t なら真）。
-    // 接尾辞付きの変数を優先する（aws-lc-sys と同じ順）。
-    let value = std::env::var(&suffixed)
-        .or_else(|_| std::env::var("AWS_LC_SYS_NO_PREFIX"))
-        .unwrap_or_default();
-    let v = value.trim().to_ascii_lowercase();
-    let falsy = v.is_empty()
-        || v.starts_with('0')
-        || v.starts_with('n')
-        || v.starts_with("off")
-        || v.starts_with('f');
-    if falsy {
-        panic!(
-            "veil-proxy: the `http3` feature on Linux needs aws-lc-sys built without symbol prefixes.\n\
-             Add this to `.cargo/config.toml` of your project (or workspace) and rebuild:\n\n\
-             [env]\n\
-             {suffixed} = {{ value = \"1\", force = true }}\n\n\
-             (quiche shares rustls' aws-lc-sys and needs its BoringSSL-compatible names; see\n\
-             https://docs.rs/veil-proxy and docs/guide/library.md. Building without `http3` does not need it.)"
-        );
-    }
 }
 
 /// F-183: veil 専用アロケータ（`veil-alloc` feature）を実際に使うかの cfg エイリアス。
@@ -154,10 +116,11 @@ fn emit_runtime_backend_cfg() {
             println!("cargo::rustc-cfg=veil_poller_wsapoll");
         }
         other => {
+            // F-120/F-125/F-140: 対応 OS の一覧。
             panic!(
                 "veil build.rs: unsupported target_os \"{other}\" — veil currently \
                  supports target_os = \"linux\", \"freebsd\", \"openbsd\", \"macos\", \
-                 \"netbsd\", \"windows\" only (F-120/F-125/F-140)"
+                 \"netbsd\", \"windows\" only"
             );
         }
     }

{veil_api-0.8.2 → veil_api-0.8.3}/crates/README.crates-io.md

@@ -35,18 +35,10 @@ async fn main() -> Result<(), veil::api::Error> {
 }
 ```
 
-## HTTP/3 on Linux needs one line of Cargo configuration
+## Build requirements
 
-On Linux, quiche shares rustls' `aws-lc-sys` and needs it built without symbol prefixes. Add this to
-`.cargo/config.toml` of your project (use your target triple; the build stops with this message when it is missing):
-
-```toml
-[env]
-AWS_LC_SYS_NO_PREFIX_x86_64_unknown_linux_gnu = { value = "1", force = true }
-# AWS_LC_SYS_NO_PREFIX_aarch64_unknown_linux_gnu = { value = "1", force = true }
-```
-
-Builds without the `http3` feature, and other operating systems, do not need it.
+The `Cargo.toml` entry is all you need; there is nothing to add to `.cargo/config.toml`, also for HTTP/3 on Linux.
+quiche and rustls share one `aws-lc-sys`, whose build needs a C compiler, CMake and libclang (bindgen).
 
 ## Documentation
 

veil_api-0.8.3/crates/veil-macros/src/lib.rs

@@ -0,0 +1,78 @@
+// F-188 / F-189 / F-192
+//! Procedural macros for the veil API library.
+//!
+//! Use them through the `veil` crate (`#[veil::route]`, `#[veil::main]`,
+//! `#[derive(veil::Schema)]` and `#[veil::l4_handler]`). The generated code refers to its
+//! dependencies through `::veil::api::__private`, so your crate does not need to add
+//! dependencies such as `inventory` or `serde_json`.
+// F-241: docs.rs にソースの表示を出さない（コメントは日本語のため）。
+#![doc(html_no_source)]
+use proc_macro::TokenStream;
+
+mod l4;
+mod main_attr;
+mod route;
+mod schema;
+mod util;
+
+/// Declares an HTTP route and registers the function as its handler.
+///
+/// ```ignore
+/// #[veil::route(path = "/users/{id}", method = "GET")]
+/// async fn get_user(id: u64, verbose: Option<bool>) -> Json<User> { ... }
+/// ```
+///
+/// - `path` (required): `{name}` matches one segment, and a trailing `{*name}` matches the rest.
+/// - `method = "GET"` / `methods = ["GET", "POST"]` (all methods if omitted).
+/// - `name` (defaults to the function name), `tags = ["users"]`, `summary`, `description`,
+///   `status = 201`, `offload = true` (synchronous functions are offloaded by default) and
+///   `hidden = true` (leave the route out of OpenAPI).
+///
+/// Arguments are interpreted by type and name, with the same rules as FastAPI: `&Request` /
+/// `Request`, `Json<T>` (body), `Query<T>`, `Form<T>`, `State<T>`, `Headers` and `Bytes`. An
+/// argument named like a `{name}` in the path is a path parameter, and any other simple type is
+/// a query parameter (optional if it is an `Option<T>`). If the inner type of `Json`, `Query`
+/// or `Form` derives `veil::Schema`, it is validated automatically and a failure returns 422.
+#[proc_macro_attribute]
+pub fn route(attr: TokenStream, item: TokenStream) -> TokenStream {
+    route::expand(attr.into(), item.into())
+        .unwrap_or_else(|e| e.to_compile_error())
+        .into()
+}
+
+/// Registers an L4 (TCP/UDP) handler (`l4-handler` feature).
+///
+/// ```ignore
+/// #[veil::l4_handler(name = "echo", protocol = "tcp")]
+/// async fn echo(conn: &mut L4Connection) -> Result<(), L4Error> { ... }
+///
+/// #[veil::l4_handler(name = "udp_echo", protocol = "udp")]
+/// async fn udp_echo(dgram: L4Datagram) -> Option<bytes::Bytes> { Some(dgram.data) }
+/// ```
+#[proc_macro_attribute]
+pub fn l4_handler(attr: TokenStream, item: TokenStream) -> TokenStream {
+    l4::expand(attr.into(), item.into())
+        .unwrap_or_else(|e| e.to_compile_error())
+        .into()
+}
+
+/// Lets `async fn main()` start veil (so you can write `veil::serve(config).await`).
+#[proc_macro_attribute]
+pub fn main(attr: TokenStream, item: TokenStream) -> TokenStream {
+    main_attr::expand(attr.into(), item.into())
+        .unwrap_or_else(|e| e.to_compile_error())
+        .into()
+}
+
+/// Implements JSON Schema (OpenAPI) generation and automatic validation for a struct or enum.
+///
+/// It accepts `#[validate(range(min = 1, max = 100))]`, `length(min, max, equal)`, `email`,
+/// `url`, `nested` and `custom = "path::to::fn"` (`fn(&T) -> Result<(), impl Display>`), and
+/// `#[schema(description, example, format, pattern)]`. Doc comments and the serde attributes
+/// `rename`, `rename_all`, `default` and `skip` are respected.
+#[proc_macro_derive(Schema, attributes(validate, schema))]
+pub fn derive_schema(item: TokenStream) -> TokenStream {
+    schema::expand(item.into())
+        .unwrap_or_else(|e| e.to_compile_error())
+        .into()
+}

{veil_api-0.8.2 → veil_api-0.8.3}/crates/veil-macros/src/main_attr.rs

@@ -1,4 +1,4 @@
-//! `#[veil::main]`: `async fn main()` を同期の `main` にして中身を実行する。
+//! `#[veil::main]`: turns `async fn main()` into a synchronous `main` that runs its body.
 
 use proc_macro2::TokenStream;
 use quote::quote;

{veil_api-0.8.2 → veil_api-0.8.3}/crates/veil-macros/src/route.rs

@@ -87,14 +87,14 @@ fn parse_args(attr: TokenStream) -> syn::Result<RouteArgs> {
     Ok(a)
 }
 
-/// 引数 1 個の扱い。
+/// How one argument is handled.
 enum ArgKind {
     RequestRef,
     RequestOwned,
     Json(Type),
     Query(Type),
     Form(Type),
-    /// `FromRequest` で取り出す（State・Headers・Bytes 等）
+    /// Extracted with `FromRequest` (State, Headers, Bytes and so on).
     FromRequest(Type),
     PathParam(String, Type),
     QueryParam {
@@ -144,7 +144,7 @@ fn classify(name: Option<&str>, ty: &Type, path_params: &[String]) -> ArgKind {
     }
 }
 
-/// 戻り値型から OpenAPI の応答スキーマを推測する（`Json<T>`・`Result<Json<T>, _>`・`(u16, Json<T>)`・文字列）。
+/// Infers the OpenAPI response schema from the return type (`Json<T>`, `Result<Json<T>, _>`, `(u16, Json<T>)` or a string).
 fn response_content(ret: &ReturnType) -> TokenStream {
     let ty = match ret {
         ReturnType::Default => return quote!(None),

{veil_api-0.8.2 → veil_api-0.8.3}/crates/veil-macros/src/schema.rs

@@ -1,11 +1,11 @@
-//! `#[derive(veil::Schema)]`: JSON Schema（`ApiSchema`）と自動バリデーション（`Validate`）。
+//! `#[derive(veil::Schema)]`: JSON Schema (`ApiSchema`) and automatic validation (`Validate`).
 
 use crate::util::{doc_text, lit_str, option_inner};
 use proc_macro2::TokenStream;
 use quote::quote;
 use syn::{spanned::Spanned, Attribute, Data, DeriveInput, Error, Expr, Fields, Lit, LitStr, Type};
 
-/// フィールド（またはコンテナ）の serde 属性のうち、スキーマに効くもの。
+/// The serde attributes of a field (or container) that affect the schema.
 #[derive(Default)]
 struct SerdeAttrs {
     rename: Option<String>,
@@ -73,7 +73,7 @@ fn serde_attrs(attrs: &[Attribute]) -> SerdeAttrs {
     out
 }
 
-/// serde の `rename_all` を適用する。
+/// Applies serde's `rename_all`.
 fn rename(name: &str, rule: Option<&str>) -> String {
     let words: Vec<String> = split_words(name);
     match rule {
@@ -108,7 +108,7 @@ fn capitalize(w: &str) -> String {
     }
 }
 
-/// `snake_case`・`PascalCase` の両方から単語に分ける。
+/// Splits both `snake_case` and `PascalCase` into words.
 fn split_words(name: &str) -> Vec<String> {
     let mut words = Vec::new();
     for part in name.split('_').filter(|p| !p.is_empty()) {
@@ -131,7 +131,7 @@ fn split_words(name: &str) -> Vec<String> {
     words
 }
 
-/// `#[validate(...)]` と `#[schema(...)]` の内容。
+/// The contents of `#[validate(...)]` and `#[schema(...)]`.
 #[derive(Default)]
 struct Rules {
     min: Option<f64>,
@@ -308,7 +308,7 @@ fn opt_usize(v: Option<u64>) -> TokenStream {
     }
 }
 
-/// フィールドのスキーマに付ける制約（JSON Schema のキーワード）。
+/// The constraints (JSON Schema keywords) attached to a field's schema.
 fn constraint_inserts(r: &Rules, desc: &Option<String>) -> TokenStream {
     let mut ins = Vec::new();
     let put = |k: &str, v: TokenStream| quote!(__c.insert(#k.into(), ::veil::api::__private::serde_json::json!(#v)););