76 lines
38 KiB
Plaintext
76 lines
38 KiB
Plaintext
|
!<arch>
|
|||
|
|
/ 0 0 0 0 8 `
|
|||
|
|
// 60 `
|
|||
|
|
tower-7e99bbee0354f17e.tower.8c57441a1ee5275e-cgu.0.rcgu.o/
|
|||
|
|
lib.rmeta/ 0 0 0 644 37552 `
|
|||
|
|
ELF · 0‘ @ @ GNU À rust
|
|||
|
|
㎠#rustc 1.96.0 (ac68faa20 2026-05-25)ÁÀ뉊 ]!ÜÛê(¹Þ—šên -5be7b69c3ff7b5b8Á íàÄTËŸ ÜJîÄ)'ß\¥! -3d1337db07d0b3aeÁ ¤²XctÔ'ÐÓ©z¨É½Ó -a4945860e1c53b00Á ¤°ð ¾ä-±($²ï=©Ã -7e98a21bfd32b0edÁ–�òÖÀH•‘P IÓHã#£ -055f30b747f859b6Á rustc_std_workspace_coreÁCçß^ò½èÝ$Çÿ+Cé -c4878ee60b2242c9Á ŸÃï+Ñ]ŠqB<ÏïW# -8dd1dd90e70d0b6aÁ miniz_oxideÁ€š»J(P>àö÷g\K -1eb618da2918ab7fÁ adler2ÁÆ;+Þ®5¥ÌýÝ°¦ÛLˆ -f7919172d268e069Á hashbrownÁPäV9ÒÆèÜ�"ÊÖVŽ\ -0fc2184a5da6723aÁ rustc_std_workspace_allocÁs&ØòØy¯s•bæ!‰ýŠ -97e4bf30be240674Á
|
|||
|
|
std_detectÁhŠBîÙºÌI®Ë�Å�š -9dbbf8346ba7ac8bÁ rustc_demangleÁûë9´Ç×@Œ�’ùXFº -f33013f239bf9f14Á cfg_ifÁÜLh�ž§Œaã¯>� -0a71c8f33a838301Á addr2lineÁ׎Þ!]8V$É@@T· -e618e6be60e87ba2Á gimliÁ¸
|
|||
|
|
°µ~Î1‹Ñt ðÁ€w -1f7768a68858f670Á objectÁ
|
|||
|
|
áPÃ?À¶¼QHJ¥� -914cd6a4dbe590d1Á memchrÁ›º«8Ór2Ù $¨ûib‚ -cf21ca6f2bb15dcdÁë
|
|||
|
|
‹ás «LÖ€îâƒ×ɯŒ -ee6f3747e38367f0Á tower_layerÁ?Ü°®¢‚VyJT;Öiæð` -037597086710a3adÁ
|
|||
|
|
tower_serviceÁ_ i²yÆúÕ8�'ø6K© -426a99b575f4adedÁ
|
|||
|
|
opaque_futureÁl| » utilÁ„ » spawn-readyÁ¼% » filterÁ”B » makeÁ„Z ü c balanceÁ<â:»� œ‘: bufferÁ4À;» ”ñ: discoverÁD¡<»É ¤Î; î4€=»î”±< hedgeÁ,Û=»ý ŒŽ= limitÁ,µ>»˜
|
|||
|
|
Œè= ¬$�?»¬„Â> load_shedÁLî?» load-shedÁ¬™? ÿ$Ë@»ÿ„€@ ready_cacheÁ\°A» ready-cacheÁ¼×@ reconnectÁL˜B»³ ¬ÃA retryÁ,öB»Ò Œ©B spawn_readyÁ\ÜC»Ø¼ƒC steerÁ,¼D»Ž ŒïC timeoutÁ<šE»© œÉD É$ôE»É„©E
|
|||
|
|
service_fnÁT‰G»É„¢F
|
|||
|
|
ServiceExtÁT•G»É " MakeServiceÁ\ÇH»ÿ„àG À macrosÁ builderÁ >
|
|||
|
|
æ � layerÁ ¥ layer_fnÁ —
|
|||
|
|
into_innerÁ serviceÁ ¤ check_cloneÁ check_service_cloneÁ ¤
|
|||
|
|
check_serviceÁ ¤ ¥ ¦ – � × #¤ #� # ServiceÁ #ž ž ( ((((É - -- sealedÁ 4 SealedÁ 5¥ BoxErrorÁ ServiceBuilderÁ 8� 8ž ;� ;ƒ
|
|||
|
|
"
|
|||
|
|
"
|
|||
|
|
"
|
|||
|
|
'
|
|||
|
|
=
|
|||
|
|
5Ø 8 8 ï :ž ºTþOrpë � ³ 8 8 ï :ž ºTþOrpëää IdentityÁ å _pÁ )±ºëì,Z¢ ¿c¾ Ú 8 8 ï :ž ºTþOrpë� ¤ ; 8 8 8# 8س ¿cÚ@ä è
|
|||
|
|
Ùè 1 9 (¹ 8 è ½ ¾ = 4 ¾ ? ¾ I è � è — c m î³ Ñ ü¡ 0 ü¢ c \À ý‚B |å õ $± ; … S G C õ $² s ìš! T¬! è µª ò ¥è ¶! üö L 8 òò StackÁ õ innerÁ ö outerÁ &e4Aà�Òè Á! È! ü › ýë[ "Òèâ 8 8 ï :ž ºTþOrpëü ÜÐ ¾ $½ Ò ,à ü 0 è 0 $ ž( “ $ü* è ̇+ mô ê — ž † ò êê LayerFnÁ ì± ï<V°jŸ®ÿ´è 8 òò † õ” ö¤ &e4Aà�Öè œ + §+ ü�*Š ýÇ< ´ À èÖü�+ Í "Öè¬ 8 8 ï :ž ºTþOrpë§ ü¿*2 ¾ $°* ´ ¶* Ö „ § è ¥ , ±0 Å ¾ç T܉ è ì‰ üµ‰7 è Љ ¾ $lj / T§Œ è ̧Œ
|
|||
|
|
Ýè¤ < <¸Œ t²Œ ¿Œ ÆŒ üÇ‹ èù Ü Tï‹ É ,Ù‹ ù <à‹ Ú ¥ Ø W ð ² $¤ ® üÖŸX ¾ $òŸ ¾ $éŸ / $°© º© ü¼¨~ ¾ $㨠¾ $Ú¨ / $±¸ »¸ üœ·Ÿ ¾ $Æ· ¾ $½· 0 üƒ×
|
|||
|
|
ç
|
|||
|
|
…d ƒ×þ „‘× ì…× L \©× è ¿c üƒ×2 h
|
|||
|
|
ð` « W ”£× ´× üƒ×; ©
|
|||
|
|
÷` ] D¶× Ã× Ä× " üÀÖ„ Ö¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
ŸÈŸÈ È ErrorÁ O˜éBL \íÖ É ,ÇÖ c c ˆ ¢cµ
|
|||
|
|
` £c bufÁ ` àB¤GS
|
|||
|
|
ÎÖ ã`ã`
|
|||
|
|
DebugTupleÁ æ`×µ` ç`� µ` è`˵` é`
|
|||
|
|
empty_nameÁµ` ø/wŒ4@<) Ú ¶& q ¸& y º# ( Ú 0 ç ±« ” ×"´Úº#c Ø#3 ™$ø TäØ ‘ ¼äØ È
|
|||
|
|
Ý‘— 9 ,õØ dïØ úØ �Ù ' ü¯ØR ‘— Ü lÌØ ç ,¸Ø — ,¿Ø ‘ ¨ ”# ] ¸(µ (47À ïtÊG 8 1 LayerÁ,øH Ú 2ô<¥I 3ü ÙJ üÌ2 / `async fn(Request) -> Result<Response, Error>`Á ÿú tƒ # OverviewÁ ’ú ü–F C Tower is a library of modular and reusable components for buildingÁ üÝ* ' robust networking clients and servers.Á ˆú üŒJ G Tower provides a simple core abstraction, the [`Service`] trait, whichÁ ü×O L represents an asynchronous function taking a request and returning either aÁ ü§P M response or an error. This abstraction can be used to model both clients andÁ dø servers.Á …ú ü‰O L Generic components, like [timeouts], [rate limiting], and [load balancing],Á üÙI F can be modeled as [`Service`]s that wrap some inner service and applyÁ ü£P M additional behavior before or after the inner service is called. This allowsÁ üôT Q implementing these components in a protocol-agnostic, composable way. Typically,Á üÉ2 / such services are referred to as _middleware_.Á üú ü€ F C An additional abstraction, the [`Layer`] trait, is used to composeÁ üÇ J G middleware with [`Service`]s. If a [`Service`] can be thought of as anÁ ü’
|
|||
|
|
P M asynchronous function from a request type to a response type, a [`Layer`] isÁ üã
|
|||
|
|
P M a function taking a [`Service`] of one type and returning a [`Service`] of aÁ ü´ N K different type. The [`ServiceBuilder`] type is used to add middleware to aÁ üƒ 5 2 service by composing it with multiple [`Layer`]s.Á ¹ ú Ô½ ## The Tower EcosystemÁ Ø ú üÜ - * Tower is made up of the following crates:Á Š
|
|||
|
|
ú äŽ
|
|||
|
|
* [`tower`] (this crate)Á ¼«
|
|||
|
|
* [`tower-service`]Á ¬Ã
|
|||
|
|
* [`tower-layer`]Á ¤Ù
|
|||
|
|
* [`tower-test`]Á î
|
|||
|
|
ú üò
|
|||
|
|
O L Since the [`Service`] and [`Layer`] traits are important integration pointsÁ üÂK H for all libraries using Tower, they are kept as stable as possible, andÁ üŽM J breaking changes are made rarely. Therefore, they are defined in separateÁ üÜF C crates, [`tower-service`] and [`tower-layer`]. This crate containsÁ ü£E B re-exports of those core traits, implementations of commonly-usedÁ üéM J middleware, and [utilities] for working with [`Service`]s and [`Layer`]s.Á ü·O L Finally, the [`tower-test`] crate provides tools for testing programs usingÁ T‡ Tower.Á ’ú \– # UsageÁ ¢ú ü¦O L Tower provides an abstraction layer, and generic implementations of variousÁ üöO L middleware. This means that the `tower` crate on its own does *not* provideÁ üÆL I a working implementation of a network client or server. Instead, Tower'sÁ ü“F C [`Service` trait][`Service`] provides an integration point betweenÁ üÚI F application code, libraries providing middleware implementations, andÁ ü¤G D libraries that implement servers and/or clients for various networkÁ tì protocols.Á ûú üÿO L Depending on your particular use case, you might use Tower in several ways:Á Ïú üÓK H * **Implementing application logic** for a networked program. You mightÁ üŸM J use the [`Service`] trait to model your application's behavior, and useÁ üíN K the middleware [provided by this crate](#modules) and by other librariesÁ ü¼I F to add functionality to clients and servers provided by one or moreÁ ü† protocol implementations.Á ü¦O L * **Implementing middleware** to add custom behavior to network clients andÁ üöL I servers in a reusable manner. This might be general-purpose middlewareÁ üÃO L (and if it is, please consider releasing your middleware as a library forÁ ü“K H other Tower users!) or application-specific behavior that needs to beÁ üß1 . shared between multiple clients or servers.Á ü‘ K H * **Implementing a network protocol**. Libraries that implement networkÁ üÝ G D protocols (such as HTTP) can depend on `tower-service` to use theÁ ü¥ M J [`Service`] trait as an integration point between the protocol and userÁ üó P M code. For example, a client for some protocol might implement [`Service`],Á üÄ H E allowing users to add arbitrary Tower middleware to those clients.Á ü� L I Similarly, a server might be created from a user-provided [`Service`].Á Ú ú üÞ J G Additionally, when a network protocol requires functionality alreadyÁ ü© P M provided by existing Tower middleware, a protocol implementation might useÁ üú F C Tower middleware internally, as well as as an integration point.Á Á!ú ´Å! ## Library SupportÁ Ü!ú üà!N K A number of third-party libraries support Tower and the [`Service`] trait.Á ü¯": 7 The following is an incomplete list of such libraries:Á ê"ú üî"B ? * [`hyper`]: A fast and correct low-level HTTP implementation.Á ü±#J G * [`tonic`]: A [gRPC-over-HTTP/2][grpc] implementation built on top ofÁ üü#P M [`hyper`]. See [here][tonic-examples] for examples of using [`tonic`] withÁ dÍ$ Tower.Á üÚ$< 9 * [`warp`]: A lightweight, composable web framework. SeeÁ ü—%D A [here][warp-service] for details on using [`warp`] with Tower.Á üÜ%O L * [`tower-lsp`] and its fork, [`lspower`]: implementations of the [La
|
|||
|
|
\6Z\LN>@´a3D~'üñ) õ ´ ¤¡ <¤ õ
|
|||
|
|
ìÕ õ ¤¢ üù $ ! Create a new [`ServiceBuilder`].Á © õ
|
|||
|
|
|
|||
|
|
|
|||
|
|
̉ � Íìè Ž ¾ ü > ü© 4 1 Add a new layer `T` into the [`ServiceBuilder`].Á â ú üê L I This wraps the inner service with the service provided by a user-definedÁ ü» E B [`Layer`]. The provided layer must implement the [`Layer`] trait.Á … ú Ü� µe,´ ¾ÒŠ ¥ ÍìÒ º
|
|||
|
|
èÒ@ žI ü�*T ü½(] Z Add a [`Layer`] built from a function that accepts a service and returns another service.Á Ÿ)ú ü§)< 9 See the documentation for [`layer_fn`] for more details.Á è)ú üð)( % [`layer_fn`]: crate::layer::layer_fnÁD¤* ¾´Ö — Íì´ *
|
|||
|
|
è´
|
|||
|
|
± 䵉 üþˆ2 / Returns the underlying `Layer` implementation.ÁT¼‰ ¾è
|
|||
|
|
è¡üÇ‹Q üò‰= : Wrap the service `S` with the middleware provided by thisÁ ü´ŠB ? [`ServiceBuilder`]'s [`Layer`]'s, returning a new [`Service`].Á ûŠú ܃‹µe ü£‹ �e<΋ > >¾ ù À ¤ Ù‹ Íìù Ö‹ Úèù D�Œ
|
|||
|
|
èù $Ú‹Øa13 üÖŸ? ü€™. + Check that the builder implements `Clone`.Á ³™ú ü»™[ X This can be useful when debugging type errors in `ServiceBuilder`s with lots of layers.Á ›šú ü£šC @ Doesn't actually change the builder but serves as a type check.Á ëšú lóš
|
|||
|
|
# ExampleÁ …›ú \�› ```rustÁ ô�› use tower::ServiceBuilder;Á À›ú üÈ›' $ let builder = ServiceBuilder::new()Á üô›5 2 // Do something before processing the requestÁ ü®œ( % .map_request(|request: String| {Á üÛœ% " println!("got request!");Á œ…� requestÁ T�� })Á ü¬�4 1 // Ensure our `ServiceBuilder` can be clonedÁ ´å� .check_clone()Á ü€ž4 1 // Do something after processing the requestÁ ü¹ž* ' .map_response(|response: String| {Á üèž& # println!("got response!");Á ¤“Ÿ responseÁ \¬Ÿ });Á <¼Ÿ˜_\ÝŸ ¾¾ ؾ ,�
|
|||
|
|
èØü¼¨e ü´ ^ [ Check that the builder when given a service of type `S` produces a service that implementsÁ d—¡ `Clone`.Á ¨¡ú ü°¡[¯y �¢ú ü˜¢C¢z à¢ú lè¢üz ú¢ú \‚£ { ô’£µ{ µ£ú ´½£ # #[derive(Clone)]Á ¼Ø£ # struct MyService;Á ,ô£ #Á üþ£'ë{ üª¤5�| üä¤(Ý| ü‘¥%�} œ»¥¿} TÓ¥Ü} üâ¥O L // Ensure that the service produced when given a `MyService` implementsÁ ü¶¦+ ( .check_service_clone::<MyService>()Á üæ¦4Ð~ üŸ§*� üΧ&Ä ¤ù§ô \’¨’€ <¢¨˜_œÃ¨ ¾¾ ¤ Žy ר ŸyDý¨ ØÀ ,›©
|
|||
|
|
èù 6-/ üœ·† üÀ©] Z Check that the builder when given a service of type `S` produces a service with the givenÁ ü¢ª' $ request, response, and error types.Á Ϊú üÖª[¯y ¶«ú ü¾«C¢z †¬ú lŽ¬üz ¬ú \¨¬ { ô¸¬µ{ üÛ¬# use std::task::{Poll, Context};Á üƒ% " use tower::{Service, ServiceExt};Á ú ̵ // An example serviceÁ ¬Ó struct MyService;Á íú üõ) & impl Service<Request> for MyService {Á ü£® type Response = Response;Á ÌÇ® type Error = Error;Á üå®I F type Future = futures_util::future::Ready<Result<Response, Error>>;Á ³¯ú ü»¯W T fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {Á „—°
|
|||
|
|
// ...Á œ¬° # todo!()Á <Ä° }Á аú üØ°< 9 fn call(&mut self, request: Request) -> Self::Future {Á „™±�� œ®±·� <ƱÔ� ,Ò± }Á ܱú œä± struct Request;Á ¤ü± struct Response;Á Œ•² struct Error;Á «²ú ü³²% " struct WrappedResponse(Response);Á ݲú üå²'ë{ ü‘³Y V // At this point in the builder if given a `MyService` it produces a service thatÁ üï³L I // accepts `Request`s, produces `Response`s, and fails with `Error`sÁ üÀ´? < .check_service::<MyService, Request, Response, Error>()Á ü„µ. + // Wrap responses in `WrappedResponse`Á ü·µE B .map_response(|response: Response| WrappedResponse(response))Á ü�¶: 7 // Now the response type will be `WrappedResponse`Á üÀ¶= : .check_service::<MyService, _, WrappedResponse, _>();Á <‚·˜_l£· ¾¾ ¤ ¥ ¦ – Žy ±· Íì¥ ´· Íì¦ ·· Íì– º· ŸyDà· À – üþ·# À – Ö–d‰¸ À –
|
|||
|
|
ê–L—¸
|
|||
|
|
èù –֖ꖕ¥§ ž —™ �’ ü…Ö4 � ! ! âo ŠÖ ¿cè T�Ö¾" Àc " !# üÀÖ8 ÃÖ ? @ A ?¾ @ c c ˆ ¢cµ
|
|||
|
|
` £cŽ% ` àB¤GS
|
|||
|
|
AÝ$ ÇÖ
|
|||
|
|
"è$ÈÖ±¯üÈ×@ ¤ $ � % % $ Íì— Í× Íì‘ Ð× Ú‘— Dÿ×ç&' Ü Ý ' ;= 79 d�Ø<”Ø # # …)ü¯Ø*,²Ø B Bç —ç— Ü # ¸Ø #
|
|||
|
|
'—‘$¹Ø”)lŒF ü 2 / A collection of [`Layer`] based tower servicesÁ 3ú Ü7µe ,”F -±Dj *¦),t Ú +à<{ ê ,\\/1$&d¡ ü†" Utilities for combining layersÁ ©ú ü. + [`Identity`]: crate::layer::util::IdentityÁ Üܵe üø( % [`Stack`]: crate::layer::util::StackÁ $© ©DÊ ä /†,Ô ò 0\¼#%ôºG˜”ëH´–I¾TÉI 4ÍI 5œÚI 4äI 5 ¥ 6 5 6 Îì ´ÚI Úr ëI 5 ìŸ ìŸ$ " ŒœJ üôI' $ Alias for a type-erased error type.ÁD¥J �� ž BoxÁ ¡ˆˆ ¢‰ˆ l }.xÏ ¾ � ÌìçEçEèE GlobalÁ ¿±‡§í# äÁ ü‰/ , Declaratively construct [`Service`] values.Á ¹ú ü½Q N [`ServiceBuilder`] provides a [builder-like interface][builder] for composingÁ ü�* ' layers to be applied to a [`Service`].Á ºú l¾
|
|||
|
|
# ServiceÁ Ìú üÐO L A [`Service`] is a trait representing an asynchronous function of a requestÁ ü S P to a response. It is similar to `async fn(Request) -> Result<Response, Error>`.Á ôú üøI F A [`Service`] is typically bound to a single transport, such as a TCPÁ üÂN K connection. It defines how _all_ inbound or outbound requests are handledÁ ¼‘ by that connection.Á ©ú üL I [builder]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.htmlÁ úú \þ # OrderÁ Šú üŽP M The order in which layers are added impacts how requests are handled. LayersÁ üßO L that are added first will be called with the request first. The argument toÁ ü¯. + `service` will be last to see the request.Á Þú <â˜_ üêH E # // this (and other) doctest is ignored because we don't have a wayÁ ü³D A # // to say that it should only be run with cfg(feature = "...")Á Ìø # use tower::Service;Á ü’ ) & # use tower::builder::ServiceBuilder;Á ü¼ 8 5 # #[cfg(all(feature = "buffer", feature = "limit"))]Á üõ m j # async fn wrap<S>(svc: S) where S: Service<(), Error = &'static str> + 'static + Send, S::Future: Send {Á Ìã
|
|||
|
|
ServiceBuilder::new()Á ¤ý
|
|||
|
|
.buffer(100)Á ô’ .concurrency_limit(10)Á ¬± .service(svc)Á <Ç # ;Á <Ï # }Á <× ˜_ ß ú üã N K In the above example, the buffer layer receives the request first followedÁ ü² N K by `concurrency_limit`. `buffer` enables up to 100 request to be in-flightÁ ü�
|
|||
|
|
K H **on top of** the requests that have already been forwarded to the nextÁ üÍ
|
|||
|
|
R O layer. Combined with `concurrency_limit`, this allows up to 110 requests to beÁ t in-flight.Á ¯ú <³˜_ Ì»¾ª üÕ)᪠üÿ8”« ü¸mÖ« ̦̬ ôÀ‹ ¤ßî¬ ¬ô² <ŠÐ <’à <š˜_ ¢ú ü¦K H The above example is similar, but the order of layers is reversed. Now,Á üòQ N `concurrency_limit` applies first and only allows 10 requests to be in-flightÁ TÄ total.Á Ïú tÓ # ExamplesÁ âú üæ, ) A [`Service`] stack with a single layer:Á “ú <—˜_ ÌŸ¾ª ü¹)᪠üã # #[cfg(feature = "limit")]Á üƒ; 8 # use tower::limit::concurrency::ConcurrencyLimitLayer;Á ü¿ ‘µ üßmÖ« ÌÍ̬ ìç .concurrency_limit(5)Á ´… .service(svc);Á <œÐ <¤à <¬˜_ ´ú ü¸J G A [`Service`] stack with _multiple_ layers that contain rate limiting,Á üƒI F in-flight request limits, and a channel-backed, clonable [`Service`]:Á Íú <ј_ ÌÙ¾ª üó)᪠ô� # use std::time::Duration;Á ü¼8”« üõmÖ« Ìã̬ ”ý .buffer(5)Á ì�§¶ ü®. + .rate_limit(5, Duration::from_secs(1))Á ´ÝͶ <ôÐ <üà <„˜_ Œú ü� �e tÌ � 9 9 âo Û¾ ºTþOrpë : Dä,ä 8 8 è
|
|||
|
|
|
|||
|
|
� < < âoc Øè Û¾= Ù = �ƒ
|
|||
|
|
|
|||
|
|
C C¾ ¾ ; ¹ ;
|
|||
|
|
=è
|