47 lines
20 KiB
Plaintext
47 lines
20 KiB
Plaintext
|
rust
|
|||
|
|
<EFBFBD>P #rustc 1.93.1 (01f6ddf75 2026-02-11)<29><02>ZF<5A>P<EFBFBD><50>v<EFBFBD><76><EFBFBD>]<5D>d9uu -4d8b4da6b4ab36bd<62> <02><05><11><><EFBFBD>GȬx<C8AC>92X<32>l -5bed970bceb2abc5<63> <02>.g<>:<3A><>Ld<4C><64>q<EFBFBD>T<EFBFBD>d -f090014afa110f38<33> <02>L<><4C><EFBFBD><EFBFBD><EFBFBD>l<EFBFBD>E,<07>R<EFBFBD><52> -3d16dd14375d91ab<61><02><11>b' ;<3B><>ݕ<EFBFBD><DD95>+<2B><>74 -cda84f9d48ee8a39<33> rustc_std_workspace_core<72><65><EFBFBD><EFBFBD><EFBFBD>7]<5D><><EFBFBD> <1F>}^ -d51aa419dcaa4806<30> hashbrown<77>\<5C><01><><EFBFBD>Y8
<0A> <0B>9!~ -828ad423d679028a<38> rustc_std_workspace_alloc<6F>)Z<7F><5A>T+@<15>U<EFBFBD><15><><EFBFBD> -456872f450a959d9<64>
|
|||
|
|
std_detect<EFBFBD><EFBFBD><<03>dpܞ.P\aܘ<61>L -20f4fe7d6fc49ef1<66> rustc_demangle<6C> $<24><><EFBFBD><EFBFBD><EFBFBD>.<2E>u
|
|||
|
|
@<40><>! -8707d0f6cef74754<35> windows_targets<74>aG<61>"T<>S<EFBFBD><53><02><> i -a000ab9e204fd71e<31> cfg_if<69>S]<5D><><EFBFBD><EFBFBD>]<5D><>8RH<52><48> -be85b4d8c54eea3b<33><02> <0C><08><><EFBFBD><EFBFBD>N<EFBFBD>}<7D>]<5D><>y^ -a8029966e34624a3<61> <02> Service<63> Request<73> Response<73> <02> <02>
|
|||
|
|
poll_ready<EFBFBD> <02> 'a<> S<> <01> <01> <02> <02> <01> <02> <01> <01> <01> <02> <02> <01> <02>
<01><01><01> <03><03> <03> Box<6F> <03><02><03> <03><02><03> l <0B><><EFBFBD><11> <1F> <01><03>E<03>E<03>E Global<61> <00><>T[+<2B>څ <01>
|
|||
|
|
<03>
|
|||
|
|
<02> <02>4<> <02><> |<<3C> <02>~ <02>$<24> <02><> <06> <00>i <00><>3 0 Definition of the core `Service` trait to Tower<65> <1C> <02> <00><>J G The [`Service`] trait provides the necessary abstractions for defining<6E> <00><>L I request / response clients and servers. It is simple but powerful and is<69> <00><>1 . used as the foundation for the rest of Tower.<2E> <02>| <02>} <02><> || <02>~ <02>{ <02><> <17><17><17><01><> <17><01><> <17><17><17><17><01><>R <00><>> ; An asynchronous function from a `Request` to a `Response`.<2E> <1C> <02> <00><>I F The `Service` trait is a simplified interface making it easy to write<74> <00><>J G network applications in a modular and reusable way, decoupled from the<68> <00><>G D underlying protocol. It is one of Tower's fundamental abstractions.<2E> <1C> <02> <00><>
# Functional<61> <1C> <02> <00><>F C A `Service` is a function of a `Request`. It immediately returns a<> <00><>C @ `Future` representing the eventual completion of processing the<68> <00><>H E request. The actual request processing may happen at any time in the<68> <00><>K H future, on any thread or executor. The processing may depend on calling<6E> <00><>N K other services. At some point in the future, the processing will complete,<2C> <00><> 9 6 and the `Future` will resolve to a response or error.<2E> <1C> <02> <00><> P M At a high level, the `Service::call` function represents an RPC request. The<68> <00><>
|
|||
|
|
0 - `Service` value can be a server or a client.<2E> <1C>
|
|||
|
|
<02> d<>
|
|||
|
|
# Server<65> <1C>
|
|||
|
|
<02> <00><>
|
|||
|
|
L I An RPC server *implements* the `Service` trait. Requests received by the<68> <00><> R O server over the network are deserialized and then passed as an argument to the<68> <00><> F C server value. The returned response is sent back over the network.<2E> <1C> <02> <00><> H E As an example, here is how an HTTP request is processed by a server:<3A> <1C>
<02> \<5C>
```rust<73> ĸ
# use std::pin::Pin;<3B> <00><>
% " # use std::task::{Poll, Context};<3B> <00><>
# use std::future::Future;<3B> <00><>! # use tower_service::Service;<3B> <00><>. + use http::{Request, Response, StatusCode};<3B> <1C> <02> <00><> struct HelloWorld;<3B> <1C> <02> <00><>3 0 impl Service<Request<Vec<u8>>> for HelloWorld {<7B> <00><>* ' type Response = Response<Vec<u8>>;<3B> <00><>! type Error = http::Error;<3B> <00><>Y V type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>;<3B> <1C> <02> <00><>Y V fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {<7B> <00><> Poll::Ready(Ok(()))<29> L<> }<7D> <1C> <02> <00><>C @ fn call(&mut self, req: Request<Vec<u8>>) -> Self::Future {<7B> <00><> // create the body<64> <00><>1 . let body: Vec<u8> = "hello, world!\n"<22> ܂ .as_bytes()<29> <00><> .to_owned();<3B> <00><>' $ // Create the HTTP response<73> <00><>* ' let resp = Response::builder()<29> <00><>' $ .status(StatusCode::OK)<29> ܶ .body(body)<29> <00><>= : .expect("Unable to create `http::Response`");<3B> <1C> <02> <00><>- * // create a response in a future.<2E> <00><> let fut = async {<7B> <00><> Ok(resp)<29> t<> };<3B> <1C> <02> <00><>9 6 // Return the response as an immediate future<72> <00><> Box::pin(fut)<29> L<> <01> ,<2C> }<7D> <<3C> ```<60> <1C> <02> d<> # Client<6E> <1C> <02> <00><>J G A client consumes a service by using a `Service` value. The client may<61> <00><>M J issue requests by invoking `call` and passing the request as an argument.<2E> <00><>E B It then receives the response by waiting for the returned future.<2E> <1C> <02> <00><>? < As an example, here is how a Redis request would be issued:<3A> <1C> <02> <00><> ```rust,ignore<72> <00><>% " let client = redis::Client::new()<29> <00><>3 0 .connect("127.0.0.1:6379".parse().unwrap())<29> <00><> .unwrap();<3B> <1C> <02> <00><>O L let resp = client.call(Cmd::set("foo", "this is the value of foo")).await?;<3B> <1C> <02> <00><>% " // Wait for the future to resolve<76> <00><>+ ( println!("Redis response: {:?}", resp);<3B> <<3C> <01># <1C> <02> <00><> # Middleware / Layer<65> <1C> <02> <00><> K H More often than not, all the pieces needed for writing robust, scalable<6C> <00><> K H network applications are the same no matter the underlying protocol. By<42> <00><> M J unifying the API for both clients and servers in a protocol agnostic way,<2C> <00><> E B it is possible to write middleware that provide these pieces in a<> <00><> reusable way.<2E> <1C> <02> <00><> Take timeouts as an example:<3A> <1C> <02> \<5C> <01> <00><> use tower_service::Service;<3B> ܚ use tower_layer::Layer;<3B> ܶ use futures::FutureExt;<3B> <00><> use std::future::Future;<3B> <00><> # use std::task::{Context, Poll};<3B> <00><> use std::time::Duration;<3B> <00><> use std::pin::Pin;<3B> <00><> use std::fmt;<3B> <00><> use std::error::Error;<3B> <1C> <02> <00><> ; 8 // Our timeout service, which wraps another service and<6E> <00><>!- * // adds a timeout to its response future.<2E> <00><>! pub struct Timeout<T> {<7B> <00><>! inner: T,<2C> Ԑ" timeout: Duration,<2C> ,<2C>" <01># <1C>" <02> ĵ" impl<T> Timeout<T> {<7B> <00><>"E B pub const fn new(inner: T, timeout: Duration) -> Timeout<T> {<7B> <00><># Timeout {<7B> <00><># inner,<2C> <00><># timeout<75> l<>#
|
|||
|
|
}<7D> L<># <01> ,<2C># <01># <1C># <02> <00><>#; 8 // The error returned if processing a request timed out<75> <00><>$ #[derive(Debug)]<5D> <00><>$ pub struct Expired;<3B> <1C>$ <02> <00><>$# impl fmt::Display for Expired {<7B> <00><>%B ? fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {<7B> <00><>% write!(f, "expired")<29> L<>% <01> ,<2C>% <01># <1C>& <02> <00><>& impl Error for Expired {}<7D> <1C>& <02> <00><>&H E // We can implement `Service` for `Timeout<T>` if `T` is a `Service`<60> <00><>&4 1 impl<T, Request> Service<Request> for Timeout<T><3E> L<>' where<72> <00><>' T: Service<Request>,<2C> <00><>' T::Future: 'static,<2C> <00><>'? < T::Error: Into<Box<dyn Error + Send + Sync>> + 'static,<2C> <00><>( T::Response: 'static,<2C> ,<2C>( {<7B> <00><>(T Q // `Timeout` doesn't modify the response type, so we use `T`'s response type<70> <00><>)$ ! type Response = T::Response;<3B> <00><>)X U // Errors may be either `Expired` if the timeout expired, or the inner service's<> <00><>*e b // `Error` type. Therefore, we return a boxed `dyn Error + Send + Sync` trait object to erase<73> <00><>+ // the error's type.<2E> <00><>+2 / type Error = Box<dyn Error + Send + Sync>;<3B> <00><>+Y <01> <1C>, <02> <00><>,Y <01> <00><>-J G // Our timeout service is ready if the inner service is ready.<2E> <00><>-\ Y // This is how backpressure can be propagated through a tree of nested services.<2E> <00><>.8 5 self.inner.poll_ready(cx).map_err(Into::into)<29> L<>. <01> <1C>. <02> <00><>.: 7 fn call(&mut self, req: Request) -> Self::Future {<7B> <00><>/B ? // Create a future that completes after `self.timeout`<60> <00><>/; 8 let timeout = tokio::time::sleep(self.timeout);<3B> <1C>0 <02> <00><>0T Q // Call the inner service and get a future that resolves to the response<73> <00><>1+ ( let fut = self.inner.call(req);<3B> <1C>1 <02> <00><>1` ] // Wrap those two futures in another future that completes when either one completes<65> t<>2 //<2F> <00><>2V S // If the inner service is too slow the `sleep` future will complete first<73> <00><>3[ X // And an error will be returned and `fut` will be dropped and not polled again<69> t<>3 <01>B <00><>3; 8 // We have to box the errors so the types match<63> <00><>4 let f = async move {<7B> <00><>4 tokio::select! {<7B> <00><>4" res = fut => {<7B> <00><>55 2 res.map_err(|err| err.into())<29> <00><>5 },<2C> <00><>5$ ! _ = timeout => {<7B> <00><>6N K Err(Box::new(Expired) as Box<dyn Error + Send + Sync>)<29> <00><>6 <01>F <00><>6 }<7D> t<>6 <01>" <1C>7 <02> <00><>7 Box::pin(f)<29> L<>7 <01> ,<2C>7 <01># <1C>7 <02> <00><>71 . // A layer for wrapping services in `Timeout`<60> <00><>7& # pub struct TimeoutLayer(Duration);<3B> <1C>8 <02> <00><>8 impl TimeoutLayer {<7B> <00><>83 0 pub const fn new(delay: Duration) -> Self {<7B> <00><>8 TimeoutLayer(delay)<29> L<>9 <01> ,<2C>9 <01># <1C>9 <02> <00><>9' $ impl<S> Layer<S> for TimeoutLayer {<7B> <00><>9" type Service = Timeout<S>;<3B> <1C>9 <02> <00><>93 0 fn layer(&self, service: S) -> Timeout<S> {<7B> <00><>:) & Timeout::new(service, self.0)<29> L<>: <01> ,<2C>: <01># <<3C>: <01># <1C>: <02> <00><>:N K The above timeout implementation is decoupled from the underlying protocol<6F> <00><>;M J and is also decoupled from client or server concerns. In other words, the<68> <00><>;I F same timeout middleware could be used in either a client or a server.<2E> <1C>< <02> <00><>< # Backpressure<72> <1C>< <02> <00><><Y V Calling a `Service` which is at capacity (i.e., it is temporarily unable to process a<> <00><>=N K request) should result in an error. The caller is responsible for ensuring<6E> <00><>>G D that the service is ready to receive the request before calling it.<2E> <1C>> <02> <00><>>L I `Service` provides a mechanism by which the caller is able to coordinate<74> <00><>?P M readiness. `Service::poll_ready` returns `Ready` if the service expects that<61> <00><>?$ ! it is able to process a
|
|||
|
|
|
|||
|
|
<02><> <01>c<01> t<>S <00>d <02><> <01>c<01>
|
|||
|
|
\<5C>S <00>d <02><> <01>c<01> <00><>SB <02><><01>d <00><>T4 <01>d<02><> <02><><02><> <02><><02> <02><><02> <02><> <02><><02><02><><02> <00>(<28>*<2A><>é<01>d<01>d<EFBFBD><64>T, <00>d} <00>dq <00>e
l<>S <00><>R# Responses given by the service.<2E>D<EFBFBD>S T<>S <00><>S# Errors produced by the service.<2E>,<2C>S <00><>SA <00><>S The future response value.<2E>4<EFBFBD>T <00><>^P <00><>TO L Returns `Poll::Ready(Ok(()))` when the service is able to process requests.<2E> <1C>U <02> <00><>UP M If the service is at capacity, then `Poll::Pending` is returned and the task<73> <00><>UF C is notified when the service becomes ready again. This function is<69> <00><>VK H expected to be called while on a task. Generally, this can be done with<74> <00><>W- * a simple `futures::future::poll_fn` call.<2E> <1C>W <02> <00><>W[ X If `Poll::Ready(Err(_))` is returned, the service is no longer able to service requests<74> <00><>X7 4 and the caller should discard the service instance.<2E> <1C>X <02> <00><>XW T Once `poll_ready` returns `Poll::Ready(Ok(()))`, a request may be dispatched to the<68> <00><>YJ G service using `call`. Until a request is dispatched, repeated calls to<74> <00><>ZS P `poll_ready` must return either `Poll::Ready(Ok(()))` or `Poll::Ready(Err(_))`.<2E> <1C>Z <02> <00><>ZY V Note that `poll_ready` may reserve shared resources that are consumed in a subsequent<6E> <00><>[\ Y invocation of `call`. Thus, it is critical for implementations to not assume that `call`<60> <00><>\[ X will always be invoked and to ensure that such resources are released if the service is<69> <00><>]Z W dropped before `call` is invoked or the future returned by `call` is dropped before it<69> t<>] is polled.<2E>T<EFBFBD>^ ! <1F>c <02>~<02>~ | <02>~ waker<65><02>~ <02>~ local_waker<65><02>~ <02>~ ext<78><02>~ <02>~ _marker<65><02>~ <02>~ _marker2<72><02>~ Ш<>s<EFBFBD>ʷ<EFBFBD> !<02><><02><> <02><><02> <02><><02> <02><><02><><02> <00> <09><><EFBFBD>x<EFBFBD>w<02><><02><> <02><><02> <02><><02> <02><> <02><><02><02><><02> <00>(<28>*<2A><>é <01>d <0C>^
<01>c<01> $<24>^ cx<63><14>^ <00><>c1 <00><>^? < Process the request and return the response asynchronously.<2E> <1C>_ <02> <00><>_? < This function is expected to be callable off task. As such,<2C> <00><>_> ; implementations should take care to not call `poll_ready`.<2E> <1C>` <02> <00><>`H E Before dispatching a request, `poll_ready` must be called and return<72> ԇa `Poll::Ready(Ok(()))`.<2E> <1C>a <02> d<>a # Panics<63> <1C>a <02> <00><>aG D Implementations are permitted to panic if `call` is invoked without<75> <00><>b6 3 obtaining `Poll::Ready(Ok(()))` from `poll_ready`.<2E> ,<2C><>bC 3futures do nothing unless you `.await` or poll them<65>$<24>c " "<22>c<01> <09>d <0C>c
<01>c<01> $<24>c req<65> <1C>c <00><>cW <01> <01> <01> <02><><01> <0C>c <02><><01> <<3C>c <01><01> <00><>d <02> <01><14>d <00>
|
|||
|
|
<14>c [] Z\ l<>d D<>d <01><01> T<>d ,<2C>d <01><01>
|
|||
|
|
\<5C>d 4<>d <01><01> <0B><>eL T<>e # $ % #<23> $<02>~<02>~ | <02>~<01>q<02>~ <02>~<01>q<02>~ <02>~<01>q<02>~ <02>~<01>q<02>~ <02>~<01>q<02>~ Ш<>s<EFBFBD>ʷ<EFBFBD> %<02><><02><> <02><><02> <02><><02> <02><><02><><02> <00> <09><><EFBFBD>x<EFBFBD>w<02><><02><> <02><><02> <02><><02> <02><> <02><><02><02><><02> <00>(<28>*<2A><>é<01>t<01>| <0C>e
<01><01><01>$<24>e <01>s<14>e <00><>e1 $<24>f & &<26><01><08>| <0C>f
<01><01><01>$<24>f request<73><<3C>f <00><>fT <01> <01> <02><><01> <0C>f <00>c<<3C>f <01> <01> <00><>g <00>
|
|||
|
|
>@ DF l<>g D<>g <01> <01> T<>g ,<2C>g <01> <01>
|
|||
|
|
\<5C>g 4<>g <01> <01> <0B><>hL T<>h ' ( ) '<27> (<02>~<02>~ | <02>~<01>q<02>~ <02>~<01>q<02>~ <02>~<01>q<02>~ <02>~<01>q<02>~ <02>~<01>q<02>~ Ш<>s<EFBFBD>ʷ<EFBFBD> )<02><><02><> <02><><02> <02><><02> <02><><02><><02> <00> <09><><EFBFBD>x<EFBFBD>w<02><><02><> <02><><02> <02><><02> <02><> <02><><02><02><><02> <00>(<28>*<2A><>é<01>tс <0C>h
<01> <01> $<24>h <01>s<14>h <00><>i1 $<24>i * *<2A><01> <09><> <0C>i
<01> <01> $<24>i <01><<3C>i <17> <0C>^ <14>^ <17>] <0C>e <14>e !&<0F>* <0C>h 0<14>h 6\: <01> std::mem<65> std::mem::replace<63> <01> <01><> <02><02> <01><> <02><02> <01> <01><> <01><> <02> <02><> <02><02> <02><02><02><02><02><02><><02><><02> ®<02> <02> <02> <02> <02> <02> <02> <02><02><02><02><02>J<02>K<02>J<02>J<02>K<03><03>50<><30>x<EFBFBD><78>.<2E>$<24>.ey~<7E> <09><10><><EFBFBD><EFBFBD><EFBFBD>~F<06><06><><EFBFBD>t<EFBFBD><74>s'ɫ<>+z<><7A>+"
|
|||
|
|
K<EFBFBD>6<15>v^*`m^Y<><59>ɠ<EFBFBD>Z<EFBFBD><5A><EFBFBD><EFBFBD><EFBFBD><EFBFBD> =6=<3D>7rҐ<72>z<14><><EFBFBD><<3C>M<>V <1D><><EFBFBD>+<2B><EFBFBD><7F><19><>y<EFBFBD><79>K<EFBFBD><4B>^<5E>D<EFBFBD>/{<7B><> -<2D>b<EFBFBD><62><EFBFBD>a<EFBFBD>k ѧ<>y<19>wW\<5C>kn- <0C><>x<EFBFBD>Dk7gS <1D>]<5D><>Q<EFBFBD>Ś됣L AoT<07><>K<EFBFBD>b<EFBFBD><62>/<2F>(z<12>~<7E><08>3- <1D>N<>qV<14>Ҿh<D2BE>><3E><>.<2E><><EFBFBD>e<EFBFBD><05><>N<EFBFBD><4E>)<29><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>x]<5D><>}<7D>n<EFBFBD><6E><EFBFBD><EFBFBD>P<7F>
<0A><13><><EFBFBD><1A><>⤊<17>h<EFBFBD>u<EFBFBD>Ou<4F>$몁<18>"<22>7wi<77>L<EFBFBD><4C><EFBFBD><EFBFBD><EFBFBD>"<14><><EFBFBD>u<0F>l%<25>z[<5B>^<5E>H<EFBFBD><48><0F>I.& <1D>>0~<16><01>Z<01>°<EFBFBD>|ҳr;<3B> <00>1<>1<>1 <00>1<>1i2 <00>1 <00>1<> <01> R$ <00>2 <00>2 3 S3 <00>
9 <00> < Y = y = <00> = <00> = ' ? <00> ? @ @ @ ` @ <00> @ <00> A <00> <00>1 <00>1 = <00>?
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
<18> 21 <00>23A3v8W< ]=}=<3D>=<3D>==? $@D@d@<40>@<40>A<EFBFBD>.47>BHN<06>2<EFBFBD>2<EFBFBD>23N3<4E>9<EFBFBD><3=9=H=U=u=<3D>=<3D>="?<3F>?@@ @<@\@|@<40>ACBGBMBSBXB]BcBiBnBrBxB~B 1 ; EK.1<EFBFBD>2<EFBFBD>23=3`8A< 7=;=J=Y=y=<3D>=<3D>='? @@ @@@`@<40>@<40>AFBKBQBVB[BaBgBlBpBvB|B<>B R1<52>2<EFBFBD>23J3<4A>9~<<3C>< C=R=f=<3D>=<3D>=<3D>>e?<3F>? @@-@M@m@<40>A&B 31<33>2<EFBFBD>23B3<42>9r<<3C>< ==L=^=~=<3D>=<3D>>Y?<3F>?@@%@E@e@<40>AB <00>9<EFBFBD><= j=<3D>=<3D>=?i?<3F>? 1@Q@q@<40>A*B w8X< <00>=>? <00>@<40>A y8Z< <00>=A? <00>@B d8E< <00>=+? <00>@<40>A <00> <00> <00>2 E=T= @@ <00>9<>< ?y? <00>A4B x1<78> ,1 <00>< <00>?<3F><02><02><02><02><02><02><02><02><02><02> $-5<CJQX_cjqx<03><03><03><03><03><03><03><03><03><03><03><03><03><03> <00>1<EFBFBD>1<EFBFBD>1x2y2 = = =$=(= <00>?<3F>?<3F>?<3F>?<3F>?<3F>B<EFBFBD> B z2 ,= <00>? ] a <17> <17><02> 0<><30>x<EFBFBD><78><15><>Z<EFBFBD>`*<2A> <02>J<EFBFBD>J<EFBFBD>J<EFBFBD>J<EFBFBD>J<EFBFBD>J<EFBFBD>ODHT + @ <02><> <00><>^<5E>D<EFBFBD>/{ <1D>]<5D><>Q<EFBFBD> $몁<18>"# <00>~<7E><08>3- <00><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 7rҐ<72>z<14>
|
|||
|
|
<00> <09><10><><EFBFBD><EFBFBD> <1D>N<>qV <00><><EFBFBD>"<14><><EFBFBD>% <00><><<3C>M<>V kn- <0C><> oT<07><>K<EFBFBD>b <00>ɠ<EFBFBD>Z<EFBFBD><5A><EFBFBD> <00><> -<2D>b<EFBFBD><62> <05><>N<EFBFBD><4E>) 0<><30>x<EFBFBD><78> P<7F>
<0A><13><> <16><01>Z<01><>) I.& <1D>>0~( <00><1A><>⤊! Ś됣L A +"
|
|||
|
|
K<EFBFBD>6<15> u<0F>l%<25>z[& <00>~F<06><06><> <00><>/<2F>(z <1D><><EFBFBD>+<2B><EFBFBD> <00>a<EFBFBD>k ѧ v^*`m^Y<> .<2E>$<24>.ey~ <00><><EFBFBD><EFBFBD><EFBFBD>x]<5D> <00>}<7D>n<EFBFBD><6E><EFBFBD><EFBFBD> <00>t<EFBFBD><74>s'ɫ <00><>|ҳr;<3B>* <00>^<5E>H<EFBFBD><48><0F>' <00>y<19>wW\<5C> x<>Dk7gS <00><19><>y<EFBFBD><79>K
<00>+z<><7A> <00>7wi<77>L<EFBFBD><4C>$ <00><>.<2E><><EFBFBD>e<EFBFBD> <00><><EFBFBD> =6=<3D> <14>Ҿh<D2BE>> <00>h<EFBFBD>u<EFBFBD>Ou<4F>" <00><><EFBFBD><EFBFBD>=@<11>O<><4F><EFBFBD><EFBFBD>Jz<4A>+<2B><>^+<2B><>~1\fpza?<3F> -<2D>r <09><>vS{?A<><41>fUN<4E>L)% Plk ~<7E><><EFBFBD><EFBFBD>=@<11>O<><4F><EFBFBD><EFBFBD>Jz eC:\Users\dxzq\.cargo\registry\src\mirrors.ustc.edu.cn-38d0e5eb5da2abae\tower-service-0.3.3\src\lib.rs<72> m'<27><>ۥ<EFBFBD>~[<5B>㠯o<1B>><3E><>Q)<29><><EFBFBD><7F>k<EFBFBD><10> <00>i<EFBFBD>i<EFBFBD> #64KM2 ?JKHGDILO:Q1
MSGI & "/4+"ZZ
|
|||
|
|
D 2 (+( >. :
|
|||
|
|
KNF@&4P&,LLNF! $ <. F
|
|||
|
|
<$C!
|
|||
|
|
I5
|
|||
|
|
@ U%Yf 3ZZK]9
|
|||
|
|
;C<U,aW\<!!#6%O
|
|||
|
|
2'4
|
|||
|
|
(#4*
|
|||
|
|
ONJZOHMQ%-aa`: & ")
|
|||
|
|
)% ZZ&
|
|||
|
|
50"@&
|
|||
|
|
U & ")
|
|||
|
|
)% ZZ&
|
|||
|
|
5,/G"&
|
|||
|
|
((#GTUKP2`<\OX^a`_UDDCM L;H64 ! S 8 -"! S 8 <00>@UGcs:=<3D>L<06><>5<EFBFBD>W mN x86_64-pc-windows-msvc<76>*<2A><>I<EFBFBD><49>wߠ<12>ɉ<EFBFBD>2
tower_service<63> -621ee16da2f32728<32>0<><30>x<EFBFBD><78>
<0A><> <01><01> <00>} + <0C> $ $ |+H ++>+V V > > > ] >> 0 4 ] 0 + V > <02><01> rust-end-file
|