From 8cdfa445d6629ffef4cb84967ff7017654045bc2 Mon Sep 17 00:00:00 2001 From: mo khan Date: Wed, 2 Jul 2025 18:36:06 -0600 Subject: chore: add vendor directory --- vendor/tower-layer/src/identity.rs | 37 +++++ vendor/tower-layer/src/layer_fn.rs | 114 +++++++++++++ vendor/tower-layer/src/lib.rs | 112 +++++++++++++ vendor/tower-layer/src/stack.rs | 62 +++++++ vendor/tower-layer/src/tuple.rs | 330 +++++++++++++++++++++++++++++++++++++ 5 files changed, 655 insertions(+) create mode 100644 vendor/tower-layer/src/identity.rs create mode 100644 vendor/tower-layer/src/layer_fn.rs create mode 100644 vendor/tower-layer/src/lib.rs create mode 100644 vendor/tower-layer/src/stack.rs create mode 100644 vendor/tower-layer/src/tuple.rs (limited to 'vendor/tower-layer/src') diff --git a/vendor/tower-layer/src/identity.rs b/vendor/tower-layer/src/identity.rs new file mode 100644 index 00000000..5233a1d8 --- /dev/null +++ b/vendor/tower-layer/src/identity.rs @@ -0,0 +1,37 @@ +use super::Layer; +use std::fmt; + +/// A no-op middleware. +/// +/// When wrapping a [`Service`], the [`Identity`] layer returns the provided +/// service without modifying it. +/// +/// [`Service`]: https://docs.rs/tower-service/latest/tower_service/trait.Service.html +#[derive(Default, Clone)] +pub struct Identity { + _p: (), +} + +impl Identity { + /// Create a new [`Identity`] value + pub const fn new() -> Identity { + Identity { _p: () } + } +} + +/// Decorates a [`Service`], transforming either the request or the response. +/// +/// [`Service`]: https://docs.rs/tower-service/latest/tower_service/trait.Service.html +impl Layer for Identity { + type Service = S; + + fn layer(&self, inner: S) -> Self::Service { + inner + } +} + +impl fmt::Debug for Identity { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("Identity").finish() + } +} diff --git a/vendor/tower-layer/src/layer_fn.rs b/vendor/tower-layer/src/layer_fn.rs new file mode 100644 index 00000000..06f6e0e3 --- /dev/null +++ b/vendor/tower-layer/src/layer_fn.rs @@ -0,0 +1,114 @@ +use super::Layer; +use std::fmt; + +/// Returns a new [`LayerFn`] that implements [`Layer`] by calling the +/// given function. +/// +/// The [`Layer::layer`] method takes a type implementing [`Service`] and +/// returns a different type implementing [`Service`]. In many cases, this can +/// be implemented by a function or a closure. The [`LayerFn`] helper allows +/// writing simple [`Layer`] implementations without needing the boilerplate of +/// a new struct implementing [`Layer`]. +/// +/// # Example +/// ```rust +/// # use tower::Service; +/// # use std::task::{Poll, Context}; +/// # use tower_layer::{Layer, layer_fn}; +/// # use std::fmt; +/// # use std::convert::Infallible; +/// # +/// // A middleware that logs requests before forwarding them to another service +/// pub struct LogService { +/// target: &'static str, +/// service: S, +/// } +/// +/// impl Service for LogService +/// where +/// S: Service, +/// Request: fmt::Debug, +/// { +/// type Response = S::Response; +/// type Error = S::Error; +/// type Future = S::Future; +/// +/// fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll> { +/// self.service.poll_ready(cx) +/// } +/// +/// fn call(&mut self, request: Request) -> Self::Future { +/// // Log the request +/// println!("request = {:?}, target = {:?}", request, self.target); +/// +/// self.service.call(request) +/// } +/// } +/// +/// // A `Layer` that wraps services in `LogService` +/// let log_layer = layer_fn(|service| { +/// LogService { +/// service, +/// target: "tower-docs", +/// } +/// }); +/// +/// // An example service. This one uppercases strings +/// let uppercase_service = tower::service_fn(|request: String| async move { +/// Ok::<_, Infallible>(request.to_uppercase()) +/// }); +/// +/// // Wrap our service in a `LogService` so requests are logged. +/// let wrapped_service = log_layer.layer(uppercase_service); +/// ``` +/// +/// [`Service`]: https://docs.rs/tower-service/latest/tower_service/trait.Service.html +/// [`Layer::layer`]: crate::Layer::layer +pub fn layer_fn(f: T) -> LayerFn { + LayerFn { f } +} + +/// A `Layer` implemented by a closure. See the docs for [`layer_fn`] for more details. +#[derive(Clone, Copy)] +pub struct LayerFn { + f: F, +} + +impl Layer for LayerFn +where + F: Fn(S) -> Out, +{ + type Service = Out; + + fn layer(&self, inner: S) -> Self::Service { + (self.f)(inner) + } +} + +impl fmt::Debug for LayerFn { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("LayerFn") + .field("f", &format_args!("{}", std::any::type_name::())) + .finish() + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[allow(dead_code)] + #[test] + fn layer_fn_has_useful_debug_impl() { + struct WrappedService { + inner: S, + } + let layer = layer_fn(|svc| WrappedService { inner: svc }); + let _svc = layer.layer("foo"); + + assert_eq!( + "LayerFn { f: tower_layer::layer_fn::tests::layer_fn_has_useful_debug_impl::{{closure}} }".to_string(), + format!("{:?}", layer), + ); + } +} diff --git a/vendor/tower-layer/src/lib.rs b/vendor/tower-layer/src/lib.rs new file mode 100644 index 00000000..4823fcc1 --- /dev/null +++ b/vendor/tower-layer/src/lib.rs @@ -0,0 +1,112 @@ +#![warn( + missing_debug_implementations, + missing_docs, + rust_2018_idioms, + unreachable_pub +)] +#![forbid(unsafe_code)] +// `rustdoc::broken_intra_doc_links` is checked on CI + +//! Layer traits and extensions. +//! +//! A layer decorates an service and provides additional functionality. It +//! allows other services to be composed with the service that implements layer. +//! +//! A middleware implements the [`Layer`] and [`Service`] trait. +//! +//! [`Service`]: https://docs.rs/tower/*/tower/trait.Service.html + +mod identity; +mod layer_fn; +mod stack; +mod tuple; + +pub use self::{ + identity::Identity, + layer_fn::{layer_fn, LayerFn}, + stack::Stack, +}; + +/// Decorates a [`Service`], transforming either the request or the response. +/// +/// Often, many of the pieces needed for writing network applications can be +/// reused across multiple services. The `Layer` trait can be used to write +/// reusable components that can be applied to very different kinds of services; +/// for example, it can be applied to services operating on different protocols, +/// and to both the client and server side of a network transaction. +/// +/// # Log +/// +/// Take request logging as an example: +/// +/// ```rust +/// # use tower_service::Service; +/// # use std::task::{Poll, Context}; +/// # use tower_layer::Layer; +/// # use std::fmt; +/// +/// pub struct LogLayer { +/// target: &'static str, +/// } +/// +/// impl Layer for LogLayer { +/// type Service = LogService; +/// +/// fn layer(&self, service: S) -> Self::Service { +/// LogService { +/// target: self.target, +/// service +/// } +/// } +/// } +/// +/// // This service implements the Log behavior +/// pub struct LogService { +/// target: &'static str, +/// service: S, +/// } +/// +/// impl Service for LogService +/// where +/// S: Service, +/// Request: fmt::Debug, +/// { +/// type Response = S::Response; +/// type Error = S::Error; +/// type Future = S::Future; +/// +/// fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll> { +/// self.service.poll_ready(cx) +/// } +/// +/// fn call(&mut self, request: Request) -> Self::Future { +/// // Insert log statement here or other functionality +/// println!("request = {:?}, target = {:?}", request, self.target); +/// self.service.call(request) +/// } +/// } +/// ``` +/// +/// The above log implementation is decoupled from the underlying protocol and +/// is also decoupled from client or server concerns. In other words, the same +/// log middleware could be used in either a client or a server. +/// +/// [`Service`]: https://docs.rs/tower/*/tower/trait.Service.html +pub trait Layer { + /// The wrapped service + type Service; + /// Wrap the given service with the middleware, returning a new service + /// that has been decorated with the middleware. + fn layer(&self, inner: S) -> Self::Service; +} + +impl<'a, T, S> Layer for &'a T +where + T: ?Sized + Layer, +{ + type Service = T::Service; + + fn layer(&self, inner: S) -> Self::Service { + (**self).layer(inner) + } +} diff --git a/vendor/tower-layer/src/stack.rs b/vendor/tower-layer/src/stack.rs new file mode 100644 index 00000000..cb6bac7b --- /dev/null +++ b/vendor/tower-layer/src/stack.rs @@ -0,0 +1,62 @@ +use super::Layer; +use std::fmt; + +/// Two middlewares chained together. +#[derive(Clone)] +pub struct Stack { + inner: Inner, + outer: Outer, +} + +impl Stack { + /// Create a new `Stack`. + pub const fn new(inner: Inner, outer: Outer) -> Self { + Stack { inner, outer } + } +} + +impl Layer for Stack +where + Inner: Layer, + Outer: Layer, +{ + type Service = Outer::Service; + + fn layer(&self, service: S) -> Self::Service { + let inner = self.inner.layer(service); + + self.outer.layer(inner) + } +} + +impl fmt::Debug for Stack +where + Inner: fmt::Debug, + Outer: fmt::Debug, +{ + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + // The generated output of nested `Stack`s is very noisy and makes + // it harder to understand what is in a `ServiceBuilder`. + // + // Instead, this output is designed assuming that a `Stack` is + // usually quite nested, and inside a `ServiceBuilder`. Therefore, + // this skips using `f.debug_struct()`, since each one would force + // a new layer of indentation. + // + // - In compact mode, a nested stack ends up just looking like a flat + // list of layers. + // + // - In pretty mode, while a newline is inserted between each layer, + // the `DebugStruct` used in the `ServiceBuilder` will inject padding + // to that each line is at the same indentation level. + // + // Also, the order of [outer, inner] is important, since it reflects + // the order that the layers were added to the stack. + if f.alternate() { + // pretty + write!(f, "{:#?},\n{:#?}", self.outer, self.inner) + } else { + write!(f, "{:?}, {:?}", self.outer, self.inner) + } + } +} diff --git a/vendor/tower-layer/src/tuple.rs b/vendor/tower-layer/src/tuple.rs new file mode 100644 index 00000000..14b973ab --- /dev/null +++ b/vendor/tower-layer/src/tuple.rs @@ -0,0 +1,330 @@ +use crate::Layer; + +impl Layer for () { + type Service = S; + + fn layer(&self, service: S) -> Self::Service { + service + } +} + +impl Layer for (L1,) +where + L1: Layer, +{ + type Service = L1::Service; + + fn layer(&self, service: S) -> Self::Service { + let (l1,) = self; + l1.layer(service) + } +} + +impl Layer for (L1, L2) +where + L1: Layer, + L2: Layer, +{ + type Service = L1::Service; + + fn layer(&self, service: S) -> Self::Service { + let (l1, l2) = self; + l1.layer(l2.layer(service)) + } +} + +impl Layer for (L1, L2, L3) +where + L1: Layer, + L2: Layer, + L3: Layer, +{ + type Service = L1::Service; + + fn layer(&self, service: S) -> Self::Service { + let (l1, l2, l3) = self; + l1.layer((l2, l3).layer(service)) + } +} + +impl Layer for (L1, L2, L3, L4) +where + L1: Layer, + L2: Layer, + L3: Layer, + L4: Layer, +{ + type Service = L1::Service; + + fn layer(&self, service: S) -> Self::Service { + let (l1, l2, l3, l4) = self; + l1.layer((l2, l3, l4).layer(service)) + } +} + +impl Layer for (L1, L2, L3, L4, L5) +where + L1: Layer, + L2: Layer, + L3: Layer, + L4: Layer, + L5: Layer, +{ + type Service = L1::Service; + + fn layer(&self, service: S) -> Self::Service { + let (l1, l2, l3, l4, l5) = self; + l1.layer((l2, l3, l4, l5).layer(service)) + } +} + +impl Layer for (L1, L2, L3, L4, L5, L6) +where + L1: Layer, + L2: Layer, + L3: Layer, + L4: Layer, + L5: Layer, + L6: Layer, +{ + type Service = L1::Service; + + fn layer(&self, service: S) -> Self::Service { + let (l1, l2, l3, l4, l5, l6) = self; + l1.layer((l2, l3, l4, l5, l6).layer(service)) + } +} + +impl Layer for (L1, L2, L3, L4, L5, L6, L7) +where + L1: Layer, + L2: Layer, + L3: Layer, + L4: Layer, + L5: Layer, + L6: Layer, + L7: Layer, +{ + type Service = L1::Service; + + fn layer(&self, service: S) -> Self::Service { + let (l1, l2, l3, l4, l5, l6, l7) = self; + l1.layer((l2, l3, l4, l5, l6, l7).layer(service)) + } +} + +impl Layer for (L1, L2, L3, L4, L5, L6, L7, L8) +where + L1: Layer, + L2: Layer, + L3: Layer, + L4: Layer, + L5: Layer, + L6: Layer, + L7: Layer, + L8: Layer, +{ + type Service = L1::Service; + + fn layer(&self, service: S) -> Self::Service { + let (l1, l2, l3, l4, l5, l6, l7, l8) = self; + l1.layer((l2, l3, l4, l5, l6, l7, l8).layer(service)) + } +} + +impl Layer for (L1, L2, L3, L4, L5, L6, L7, L8, L9) +where + L1: Layer, + L2: Layer, + L3: Layer, + L4: Layer, + L5: Layer, + L6: Layer, + L7: Layer, + L8: Layer, + L9: Layer, +{ + type Service = L1::Service; + + fn layer(&self, service: S) -> Self::Service { + let (l1, l2, l3, l4, l5, l6, l7, l8, l9) = self; + l1.layer((l2, l3, l4, l5, l6, l7, l8, l9).layer(service)) + } +} + +impl Layer + for (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10) +where + L1: Layer, + L2: Layer, + L3: Layer, + L4: Layer, + L5: Layer, + L6: Layer, + L7: Layer, + L8: Layer, + L9: Layer, + L10: Layer, +{ + type Service = L1::Service; + + fn layer(&self, service: S) -> Self::Service { + let (l1, l2, l3, l4, l5, l6, l7, l8, l9, l10) = self; + l1.layer((l2, l3, l4, l5, l6, l7, l8, l9, l10).layer(service)) + } +} + +impl Layer + for (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11) +where + L1: Layer, + L2: Layer, + L3: Layer, + L4: Layer, + L5: Layer, + L6: Layer, + L7: Layer, + L8: Layer, + L9: Layer, + L10: Layer, + L11: Layer, +{ + type Service = L1::Service; + + fn layer(&self, service: S) -> Self::Service { + let (l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11) = self; + l1.layer((l2, l3, l4, l5, l6, l7, l8, l9, l10, l11).layer(service)) + } +} + +impl Layer + for (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12) +where + L1: Layer, + L2: Layer, + L3: Layer, + L4: Layer, + L5: Layer, + L6: Layer, + L7: Layer, + L8: Layer, + L9: Layer, + L10: Layer, + L11: Layer, + L12: Layer, +{ + type Service = L1::Service; + + fn layer(&self, service: S) -> Self::Service { + let (l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12) = self; + l1.layer((l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12).layer(service)) + } +} + +impl Layer + for (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13) +where + L1: Layer, + L2: Layer, + L3: Layer, + L4: Layer, + L5: Layer, + L6: Layer, + L7: Layer, + L8: Layer, + L9: Layer, + L10: Layer, + L11: Layer, + L12: Layer, + L13: Layer, +{ + type Service = L1::Service; + + fn layer(&self, service: S) -> Self::Service { + let (l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13) = self; + l1.layer((l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13).layer(service)) + } +} + +impl Layer + for (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14) +where + L1: Layer, + L2: Layer, + L3: Layer, + L4: Layer, + L5: Layer, + L6: Layer, + L7: Layer, + L8: Layer, + L9: Layer, + L10: Layer, + L11: Layer, + L12: Layer, + L13: Layer, + L14: Layer, +{ + type Service = L1::Service; + + fn layer(&self, service: S) -> Self::Service { + let (l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13, l14) = self; + l1.layer((l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13, l14).layer(service)) + } +} + +#[rustfmt::skip] +impl Layer + for (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15) +where + L1: Layer, + L2: Layer, + L3: Layer, + L4: Layer, + L5: Layer, + L6: Layer, + L7: Layer, + L8: Layer, + L9: Layer, + L10: Layer, + L11: Layer, + L12: Layer, + L13: Layer, + L14: Layer, + L15: Layer, +{ + type Service = L1::Service; + + fn layer(&self, service: S) -> Self::Service { + let (l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13, l14, l15) = self; + l1.layer((l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13, l14, l15).layer(service)) + } +} + +#[rustfmt::skip] +impl Layer + for (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16) +where + L1: Layer, + L2: Layer, + L3: Layer, + L4: Layer, + L5: Layer, + L6: Layer, + L7: Layer, + L8: Layer, + L9: Layer, + L10: Layer, + L11: Layer, + L12: Layer, + L13: Layer, + L14: Layer, + L15: Layer, + L16: Layer, +{ + type Service = L1::Service; + + fn layer(&self, service: S) -> Self::Service { + let (l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13, l14, l15, l16) = self; + l1.layer((l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13, l14, l15, l16).layer(service)) + } +} -- cgit v1.2.3