fn mk_ingress<T, I, P, R>(&self, profiles: P, resolve: R) -> svc::ArcNewTcp<T, I>
    where
        T: Param<OrigDstAddr> + Clone + Send + Sync + 'static,
        I: io::AsyncRead + io::AsyncWrite + io::Peek + io::PeerAddr,
        I: Debug + Unpin + Send + Sync + 'static,
        R: Clone + Send + Sync + Unpin + 'static,
        R: Resolve<ConcreteAddr, Endpoint = Metadata, Error = Error>,
        R::Resolution: Send,
        R::Future: Send + Unpin,
        P: profiles::GetProfile<profiles::LookupAddr> + Clone + Send + Sync + Unpin + 'static,
        P::Future: Send,
        P::Error: Send,
    {
        // The fallback stack is the same thing as the normal proxy stack, but
        // it doesn't include TCP metrics, since they are already instrumented
        // on this ingress stack.
        let fallback = {
            let logical = self.to_tcp_connect().push_logical(resolve.clone());
            let endpoint = self.to_tcp_connect().push_endpoint();
            endpoint
                .push_switch_logical(logical.into_inner())
                .push_discover(profiles.clone())
                .into_inner()
        };

        self.to_tcp_connect()
            .push_tcp_endpoint()
            .push_http_endpoint()
            .push_ingress(profiles, resolve, fallback)
            .push_tcp_instrument(|t: &T| info_span!("ingress", addr = %t.param()))
            .into_inner()
    }
/// Builds a an "ingress mode" proxy.
///
/// Ingress-mode proxies route based on request headers instead of using the
/// original destination. Protocol detection is **always** performed. If it
/// fails, we revert to using the normal IP-based discovery
Builds a an "ingress mode" proxy.
Ingress-mode proxies route based on request headers instead of using the
original destination. Protocol detection is **always** performed. If it
fails, we revert to using the normal IP-based discovery
Builds a an " ingress mode " proxy . Ingress - mode proxies route based on request headers instead of using the original destination . Protocol detection is ** always ** performed . If it fails we revert to using the normal IP - based discovery
fn mk_ingress<T, I, P, R>(&self, profiles: P, resolve: R) -> svc::ArcNewTcp<T, I>
    where
        T: Param<OrigDstAddr> + Clone + Send + Sync + 'static,
        I: io::AsyncRead + io::AsyncWrite + io::Peek + io::PeerAddr,
        I: Debug + Unpin + Send + Sync + 'static,
        R: Clone + Send + Sync + Unpin + 'static,
        R: Resolve<ConcreteAddr, Endpoint = Metadata, Error = Error>,
        R::Resolution: Send,
        R::Future: Send + Unpin,
        P: profiles::GetProfile<profiles::LookupAddr> + Clone + Send + Sync + Unpin + 'static,
        P::Future: Send,
        P::Error: Send,
    {
        // The fallback stack is the same thing as the normal proxy stack, but
        // it doesn't include TCP metrics, since they are already instrumented
        // on this ingress stack.
        let fallback = {
            let logical = self.to_tcp_connect().push_logical(resolve.clone());
            let endpoint = self.to_tcp_connect().push_endpoint();
            endpoint
                .push_switch_logical(logical.into_inner())
                .push_discover(profiles.clone())
                .into_inner()
        };
        self.to_tcp_connect()
            .push_tcp_endpoint()
            .push_http_endpoint()
            .push_ingress(profiles, resolve, fallback)
            .push_tcp_instrument(|t: &T| info_span!("ingress", addr = %t.param()))
            .into_inner()
    }
fn mk_ingress < T , I , P , R > ( & self , profiles : P , resolve : R ) -> svc :: ArcNewTcp < T , I > where T : Param < OrigDstAddr > + Clone + Send + Sync + ' static , I : io :: AsyncRead + io :: AsyncWrite + io :: Peek + io :: PeerAddr , I : Debug + Unpin + Send + Sync + ' static , R : Clone + Send + Sync + Unpin + ' static , R : Resolve < ConcreteAddr , Endpoint = Metadata , Error = Error > , R :: Resolution : Send , R :: Future : Send + Unpin , P : profiles :: GetProfile < profiles :: LookupAddr > + Clone + Send + Sync + Unpin + ' static , P :: Future : Send , P :: Error : Send , { // The fallback stack is the same thing as the normal proxy stack, but // it doesn't include TCP metrics, since they are already instrumented // on this ingress stack. let fallback = { let logical = self . to_tcp_connect ( ) . push_logical ( resolve . clone ( ) ) ; let endpoint = self . to_tcp_connect ( ) . push_endpoint ( ) ; endpoint . push_switch_logical ( logical . into_inner ( ) ) . push_discover ( profiles . clone ( ) ) . into_inner ( ) } ; self . to_tcp_connect ( ) . push_tcp_endpoint ( ) . push_http_endpoint ( ) . push_ingress ( profiles , resolve , fallback ) . push_tcp_instrument ( | t : & T | info_span ! ( " " addr t param ( ) ) ) . into_inner ( ) }
Builds a an "ingress mode" proxy.
Builds a an " ingress mode " proxy .
&self
profiles
P
resolve
R