92 lines
24 KiB
Plaintext
92 lines
24 KiB
Plaintext
|
!<arch>
|
|||
|
|
/ 0 0 0 0 8 `
|
|||
|
|
// 76 `
|
|||
|
|
tower_service-5cde83e30b362864.tower_service.e7b573d5bb113974-cgu.0.rcgu.o/
|
|||
|
|
lib.rmeta/ 0 0 0 644 23664 `
|
|||
|
|
ELF · ðZ @ @ GNU À rust
|
|||
|
|
¨X #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Á À ServiceÁ RequestÁ ResponseÁ ErrorÁ FutureÁ
|
|||
|
|
poll_readyÁ Ñ 'aÁ ¤ ó � � œ © Ñ ¤ ó � � œ © Ñ
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
Ťó �� ž BoxÁ ¡ˆˆ ¢‰ˆ l }.xÏ ¤çEçEèE GlobalÁ ¿±‡§í# ó
|
|||
|
|
�
|
|||
|
|
DÚe ¼Úe Tãe
|
|||
|
|
ë
|
|||
|
|
ò
|
|||
|
|
, îe tãe ÷e üƒet œØžØ ŸØÈ Øˆ ¡Ø¢Ø´ ‰‰Nµý¤ÃÖ¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
ë
|
|||
|
|
ò
|
|||
|
|
|
|||
|
|
Ôµe ë
|
|||
|
|
L‘e Ì�Ì� k Î� wakerÁ¸� Ï� local_wakerÁ¸� Ð� extÁ¸� Ñ� _markerÁ¸� Ò� _marker2Á¸� f'EwÚ]¾å œe � Ÿ ¨ cxÁ! } § É D¹f ´¹f $Âf
|
|||
|
|
|
|||
|
|
ë
|
|||
|
|
ò
|
|||
|
|
, <Çf lÂf Õf üýeX ë
|
|||
|
|
ò
|
|||
|
|
L¥f Ž L…f ò
|
|||
|
|
<�f � requestÁ& Y Œ¤ Dåh ›› UniqueÁ �‰ � žñ
|
|||
|
|
� �8Åá™-Ýñ¿ ‰‰ § ‹‰ ï íe¼îËè¿*¿ ¿ ” ¼åh Tîh
|
|||
|
|
¿ ñ À ùh tîh ‚i üŽht œØžØ ŸØÈ Øˆ ¡Ø¢Ø´ ‰‰Nµý¤ÃÖ¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
ù
|
|||
|
|
¿ ñ
|
|||
|
|
ÔÀh þ
|
|||
|
|
Lœh � §h ¿ ´ þ
|
|||
|
|
¼ $ - Ê1 ý ßH DÄi È Œ¼ $ ´Äi $Íi
|
|||
|
|
|
|||
|
|
¿ ñ P <Òi lÍi ài üˆiX ¿ ñ L°i Æ L�i ñ <›i Û ¨ þ
|
|||
|
|
¼ ) †- ` ç« À œ4Î ‚Ø k<æ Ì� ·$ï œØ ü âi üº3 0 Definition of the core `Service` trait to TowerÁ î ú üòJ G The [`Service`] trait provides the necessary abstractions for definingÁ ü½L I request / response clients and servers. It is simple but powerful and isÁ üŠ1 . used as the foundation for the rest of Tower.Á À‚ œƒ ‚Ø k‚ Ì� ·� œØ ÈËÎœÁ ÅLÚ ¹¼«®ÔÂR ü÷> ; An asynchronous function from a `Request` to a `Response`.Á ¶ ú üºI F The `Service` trait is a simplified interface making it easy to writeÁ ü„J G network applications in a modular and reusable way, decoupled from theÁ üÏG D underlying protocol. It is one of Tower's fundamental abstractions.Á — ú „›
|
|||
|
|
# FunctionalÁ ¬ ú ü°F C A `Service` is a function of a `Request`. It immediately returns aÁ ü÷C @ `Future` representing the eventual completion of processing theÁ ü»H E request. The actual request processing may happen at any time in theÁ ü„K H future, on any thread or executor. The processing may depend on callingÁ üÐN K other services. At some point in the future, the processing will complete,Á üŸ 9 6 and the `Future` will resolve to a response or error.Á Ù ú üÝ P M At a high level, the `Service::call` function represents an RPC request. TheÁ ü®
|
|||
|
|
0 - `Service` value can be a server or a client.Á ß
|
|||
|
|
ú dã
|
|||
|
|
# ServerÁ ð
|
|||
|
|
ú üô
|
|||
|
|
L I An RPC server *implements* the `Service` trait. Requests received by theÁ üÁ R O server over the network are deserialized and then passed as an argument to theÁ ü” F C server value. The returned response is sent back over the network.Á Û ú üß H E As an example, here is how an HTTP request is processed by a server:Á ¨
|
|||
|
|
ú \¬
|
|||
|
|
```rustÁ ĸ
|
|||
|
|
# use std::pin::Pin;Á üÑ
|
|||
|
|
% " # use std::task::{Poll, Context};Á ô÷
|
|||
|
|
# use std::future::Future;Á ü–! # use tower_service::Service;Á ü¸. + use http::{Request, Response, StatusCode};Á ç ú ´ë struct HelloWorld;Á ‚ ú ü†3 0 impl Service<Request<Vec<u8>>> for HelloWorld {Á üº* ' type Response = Response<Vec<u8>>;Á üå! type Error = http::Error;Á ü‡Y V type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>;Á á ú üåY V fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {Á ü¿ Poll::Ready(Ok(()))Á Lß }Á é ú üíC @ fn call(&mut self, req: Request<Vec<u8>>) -> Self::Future {Á ô± // create the bodyÁ üÐ1 . let body: Vec<u8> = "hello, world!\n"Á Ü‚ .as_bytes()Á äž .to_owned();Á ü»' $ // Create the HTTP responseÁ üã* ' let resp = Response::builder()Á üŽ' $ .status(StatusCode::OK)Á ܶ .body(body)Á üÒ= : .expect("Unable to create `http::Response`");Á � ú ü”- * // create a response in a future.Á ì let fut = async {Á Äà Ok(resp)Á tù };Á ˆ ú üŒ9 6 // Return the response as an immediate futureÁ ÌÆ Box::pin(fut)Á Là Ø* ,ê }Á <ð ```Á ø ú dü # ClientÁ ‰ ú ü�J G A client consumes a service by using a `Service` value. The client mayÁ üØM J issue requests by invoking `call` and passing the request as an argument.Á ü¦E B It then receives the response by waiting for the returned future.Á ì ú üð? < As an example, here is how a Redis request would be issued:Á ° ú ”´ ```rust,ignoreÁ üÇ% " let client = redis::Client::new()Á üí3 0 .connect("127.0.0.1:6379".parse().unwrap())Á ”¡ .unwrap();Á ´ ú ü¸O L let resp = client.call(Cmd::set("foo", "this is the value of foo")).await?;Á ˆ ú üŒ% " // Wait for the future to resolveÁ ü²+ ( println!("Redis response: {:?}", resp);Á <Þ ›1 æ ú Äê # Middleware / LayerÁ ƒ ú ü‡ K H More often than not, all the pieces needed for writing robust, scalableÁ üÓ K H network applications are the same no matter the underlying protocol. ByÁ üŸ M J unifying the API for both clients and servers in a protocol agnostic way,Á üí E B it is possible to write middleware that provide these pieces in aÁ Œ³ reusable way.Á Å ú üÉ Take timeouts as an example:Á ê ú \î œ% üú use tower_service::Service;Á Üš use tower_layer::Layer;Á ܶ use futures::FutureExt;Á äÒ use std::future::Future;Á üï # use std::task::{Context, Poll};Á ä“ use std::time::Duration;Á ´° use std::pin::Pin;Á ŒÇ use std::fmt;Á ÔÙ use std::error::Error;Á ô ú üø ; 8 // Our timeout service, which wraps another service andÁ ü´!- * // adds a timeout to its response future.Á Üâ! pub struct Timeout<T> {Á Œþ! inner: T,Á Ô�" timeout: Duration,Á ,«" �1 ±" ú ĵ" impl<T> Timeout<T> {Á üÎ"E B pub const fn new(inner: T, timeout: Duration) -> Timeout<T> {Á ¬”# Timeout {Á ´ª# inner,Á ¼Á# timeoutÁ lÙ#
|
|||
|
|
}Á Lç# Ø* ,ñ# �1 ÷# ú üû#; 8 // The error returned if processing a request timed outÁ ¤·$ #[derive(Debug)]Á ¼Ì$ pub struct Expired;Á ä$ ú üè$# impl fmt::Display for Expired {Á üŒ%B ? fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {Á üÏ% write!(f, "expired")Á Lð% Ø* ,ú% �1 €& ú ì„& impl Error for Expired {}Á ¢& ú ü¦&H E // We can implement `Service` for `Timeout<T>` if `T` is a `Service`Á üï&4 1 impl<T, Request> Service<Request> for Timeout<T>Á L¤' whereÁ ä®' T: Service<Request>,Á ÜË' T::Future: 'static,Á üç'? < T::Error: Into<Box<dyn Error + Send + Sync>> + 'static,Á ì§( T::Response: 'static,Á ,Å( {Á üË(T Q // `Timeout` doesn't modify the response type, so we use `T`'s response typeÁ ü )$ ! type Response = T::Response;Á üÅ)X U // Errors may be either `Expired` if the timeout expired, or the inner service'sÁ üž*e b // `Error` type. Therefore, we return a boxed `dyn Error + Send + Sync` trait object to eraseÁ ä„+ // the error's type.Á ü¡+2 / type Error = Box<dyn Error + Send + Sync>;Á üÔ+Y Þ( ®, ú ü²,Y Í) üŒ-J G // Our timeout service is ready if the inner service is ready.Á ü×-\ Y // This is how backpressure can be propagated through a tree of nested services.Á ü´.8 5 self.inner.poll_ready(cx).map_err(Into::into)Á Lí. Ø* ÷. ú üû.: 7 fn call(&mut self, req: Request) -> Self::Future {Á ü¶/B ? // Create a future that completes after `self.timeout`Á üù/; 8 let timeout = tokio::time::sleep(self.timeout);Á µ0 ú ü¹0T Q // Call the inner service and get a future that resolves to the responseÁ üŽ1+ ( let fut = self.inner.call(req);Á º1 ú ü¾1` ] // Wrap those two futures in another future that completes when either one completesÁ tŸ2 //Á ü®2V S // If the inner service is too slow the `sleep` future will complete firstÁ ü…3[ X // And an error will be returned and `fut` will be dropped and not polled againÁ tá3 ÄQ üð3; 8 // We have to box the errors so the types matchÁ ü¬4 let f = async move {Á üÍ4 tokio::select! {Á üî4" res = fut => {Á ü‘55 2 res.map_err(|err| err.into())Á ´Ç5 },Á üÞ5$ ! _ = timeout => {Á üƒ6N K Err(Box::new(Expired) as Box<dyn Error + Send + Sync>)Á ´Ò6 °U Œé6 }Á tû6 ù/ Š7 ú ¼Ž7 Box::pin(f)Á L¦7 Ø* ,°7 �1 ¶7 ú üº71 . // A layer for wrapping services in `Timeout`Á üì7& # pub struct TimeoutLayer(Duration);Á “8 ú ¼—8 impl TimeoutLayer {Á ü¯83 0 pub const fn new(delay: Duration) -> Self {Á üã8 TimeoutLayer(delay)Á Lƒ9 Ø* ,�9 �1 “9 ú ü—9' $ impl<S> Layer<S> for TimeoutLayer {Á ü¿9" type Service = Timeout<S>;Á â9 ú üæ93 0 fn layer(&self, service: S) -> Timeout<S> {Á üš:) & Timeout::new(service, self.0)Á LÄ: Ø* ,Î: �1 <Ô: ›1 Ü: ú üà:N K The above timeout implementation is decoupled from the underlying protocolÁ ü¯;M J and is also decoupled from client or server concerns. In other words, theÁ üý;I F same timeout middleware could be used in either a client or a server.Á Ç< ú ”Ë< # BackpressureÁ Þ< ú üâ<Y V Calling a `Service` which is at capacity (i.e., it is temporarily unable to process aÁ ü¼=N K request) should result in an error. The caller is responsible for ensuringÁ ü‹>G D that the service is ready to receive the request before calling it.Á Ó> ú ü×>L I `Service` provides a mechanism by which the caller is able to coordinateÁ ü¤?P M readiness. `Servic
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
Íì¬sñ t‹S ìs Íì¬sñ
|
|||
|
|
\ÇS ‹t Íì¬sñ üûSB ‚زt üˆT4 ²tƒØ Ö¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
ôs“tü�T, ªt} Ätq Õt
|
|||
|
|
|
|||
|
|
l‹S üãR# Responses given by the service.ÁD�S TÇS üŸS# Errors produced by the service.Á,ÌS üûSA ôØS The future response value.Á4€T ü‰^P üÃTO L Returns `Poll::Ready(Ok(()))` when the service is able to process requests.Á —U ú üŸUP M If the service is at capacity, then `Poll::Pending` is returned and the taskÁ üôUF C is notified when the service becomes ready again. This function isÁ ü¿VK H expected to be called while on a task. Generally, this can be done withÁ ü�W- * a simple `futures::future::poll_fn` call.Á ÁW ú üÉW[ X If `Poll::Ready(Err(_))` is returned, the service is no longer able to service requestsÁ ü©X7 4 and the caller should discard the service instance.Á åX ú üíXW T Once `poll_ready` returns `Poll::Ready(Ok(()))`, a request may be dispatched to theÁ üÉYJ G service using `call`. Until a request is dispatched, repeated calls toÁ ü˜ZS P `poll_ready` must return either `Poll::Ready(Ok(()))` or `Poll::Ready(Err(_))`.Á ðZ ú üøZY V Note that `poll_ready` may reserve shared resources that are consumed in a subsequentÁ üÖ[\ Y invocation of `call`. Thus, it is critical for implementations to not assume that `call`Á ü·\[ X will always be invoked and to ensure that such resources are released if the service isÁ ü—]Z W dropped before `call` is invoked or the future returned by `call` is dropped before itÁ tö] is polled.ÁTŒ^ ! ¬s Ì�Ì� k Î�´
|
|||
|
|
¸� Ï�Ç
|
|||
|
|
¸� Ð�à
|
|||
|
|
¸� Ñ�ñ
|
|||
|
|
¸� Ò�†¸� f'EwÚ]¾å !œØžØ ŸØÈ Øˆ ¡Ø¢Ø´ ‰‰Nµý¤ÃÖ¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
ù
|
|||
|
|
“t —^
|
|||
|
|
¬sñ $œ^ Ê¢^ ü–c1 üß^? < Process the request and return the response asynchronously.Á £_ ú ü«_? < This function is expected to be callable off task. As such,Á üï_> ; implementations should take care to not call `poll_ready`.Á ²` ú üº`H E Before dispatching a request, `poll_ready` must be called and returnÁ Ô‡a `Poll::Ready(Ok(()))`.Á ¦a ú d®a # PanicsÁ ¿a ú üÇaG D Implementations are permitted to panic if `call` is invoked withoutÁ ü“b6 3 obtaining `Poll::Ready(Ok(()))` from `poll_ready`.Á .üÎbC 3futures do nothing unless you `.await` or poll themÁ$™c " "¬sñ ²t žc
|
|||
|
|
|
|||
|
|
¬sñ $£c reqÁ ©c üËcW Å ¤ ó Íìë
|
|||
|
|
Ôc Íìò
|
|||
|
|
<×c ë
|
|||
|
|
ò
|
|||
|
|
„Œd ë
|
|||
|
|
ÅŸd å
|
|||
|
|
|
|||
|
|
|
|||
|
|
Ðc [] Z\ l©d D®d ë
|
|||
|
|
ò
|
|||
|
|
TÊd ,Ïd ü
|
|||
|
|
\åd 4êd ËüƒeL T†e # $ % #å
|