Skip to main content

DiscoveryService

Struct DiscoveryService 

Source
pub struct DiscoveryService { /* private fields */ }
Expand description

Discovery service that exposes EndpointRegistry over RPC.

Implementations§

Source§

impl DiscoveryService

Source

pub fn self_announcer(&self) -> Result<DiscoverySelfAnnouncer, Error>

Source

pub fn new( signing_key: Arc<SigningKey>, jwt_verifying_key: VerifyingKey, transport: TransportConfig, ) -> DiscoveryService

Create a new discovery service with infrastructure.

signing_key is used for envelope signing (should be the per-service key derived via HKDF). jwt_verifying_key is the root-derived JWT verifying key for verifying service JWTs (derived from root via HKDF “hyprstream-jwt-v1”).

Source

pub fn with_state(self, state: DiscoveryState) -> DiscoveryService

Install the configured volatile-state backend before the service is shared.

Source

pub fn with_tls_endorsement( self, endorsement: Vec<u8>, domain: String, ) -> DiscoveryService

Set the pre-computed TLS endorsement and domain.

The endorsement is Sign(tls_private_key, "TLS_ENDORSEMENT_V1" || ed25519_pubkey || domain), computed once at startup by the service factory where TLS key materials are available. Discovery never touches the TLS private key directly.

Source

pub fn with_oauth_issuer(self, url: String) -> DiscoveryService

Set the OAuth issuer URL for RFC 9728 auth metadata responses.

Source

pub fn with_expected_audience(self, audience: String) -> DiscoveryService

Set the expected audience for JWT validation.

Source

pub fn with_jwt_key_source(self, src: Arc<dyn JwtKeySource>) -> DiscoveryService

Set the JWT key source for client JWT verification.

Source

pub fn with_auth_provider( self, provider: Box<dyn AuthorizationProvider>, ) -> DiscoveryService

Set the authorization provider for access control.

Source

pub fn with_record_resolver( self, resolver: Arc<dyn RecordResolver>, ) -> DiscoveryService

Set the record resolver backing getRecord/getRepo (#431).

Source

pub fn attach_process_accepted_state_source(&mut self) -> Result<(), Error>

Attach the process-pinned source to the Discovery daemon. The source was fixed and consumed before inventory factories were invoked.

Trait Implementations§

Source§

impl DiscoveryHandler for DiscoveryService

Source§

fn handle_query_candidates<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, data: &'life2 QueryCandidatesRequest, ) -> Pin<Box<dyn Future<Output = Result<DiscoveryResponseVariant, Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, DiscoveryService: 'async_trait,

#523 P0 / #524 — placement candidate query. The auto-generated dispatch gate already ran a discovery:QueryCandidates/query authz check before this handler was invoked; that only authorizes “may call queryCandidates at all”. Each surviving candidate additionally gets its own fail-closed placement:candidate:<did> check below (a denied node is silently omitted, not surfaced as an error) — mirroring why getRecord/getRepo layer a per-target check on top of the generic gate.

Pipeline: known node DIDs (placement directory) → hard-exclude any without a live reportNodeLiveness entry (decision: absence/expiry is exclusion, never a “stale” flag) → sync filter (label selectors AND, resource requests AND) via scheduling::filter → per-candidate async authz → rank (ascending load, DID tiebreak) via scheduling::rank → bound to maxCandidates (or [DEFAULT_MAX_CANDIDATES] when 0). totalMatching is the authorized-survivor count before the bound.

Source§

fn handle_report_node_liveness<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, data: &'life2 NodeLiveness, ) -> Pin<Box<dyn Future<Output = Result<DiscoveryResponseVariant, Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, DiscoveryService: 'async_trait,

#524 P1 — node liveness heartbeat. The auto-generated dispatch gate already ran a discovery:ReportNodeLiveness/write authz check before this handler was invoked. Before accepting a DID-specific heartbeat, additionally require write admission for that candidate. This prevents an authorized caller from using arbitrary heartbeat DIDs to grow the durable placement directory or trigger unbounded resolver work.

Re-inserting (heartbeating) an admitted node refreshes its TTL entry. The first heartbeat seen for a DID this directory hasn’t ingested a NodeRecord for yet may lazily trigger a repo poll. The bounded retry gate records an attempt before resolver access, so absent/invalid/non- node repos are retried only after [PLACEMENT_INGEST_RETRY_TTL]; a failure there does not fail the admitted heartbeat itself.

Source§

fn authorize<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, resource: &'life2 str, operation: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, DiscoveryService: 'async_trait,

Authorize an operation on a resource. Override to enforce policy. Read more
Source§

fn handle_list_services<'life0, 'life1, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, ) -> Pin<Box<dyn Future<Output = Result<DiscoveryResponseVariant, Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, DiscoveryService: 'async_trait,

Handle listServices request.
Source§

fn handle_get_endpoints<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, data: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<DiscoveryResponseVariant, Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, DiscoveryService: 'async_trait,

Handle getEndpoints request.
Source§

fn handle_get_schema<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, data: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<DiscoveryResponseVariant, Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, DiscoveryService: 'async_trait,

Handle getSchema request.
Source§

fn handle_ping<'life0, 'life1, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, ) -> Pin<Box<dyn Future<Output = Result<DiscoveryResponseVariant, Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, DiscoveryService: 'async_trait,

Handle ping request.
Source§

fn handle_get_auth_metadata<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, data: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<DiscoveryResponseVariant, Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, DiscoveryService: 'async_trait,

Handle getAuthMetadata request.
Source§

fn handle_prepare_stream<'life0, 'life1, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, ) -> Pin<Box<dyn Future<Output = Result<DiscoveryResponseVariant, Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, DiscoveryService: 'async_trait,

Handle prepareStream request.
Source§

fn handle_get_stream<'life0, 'life1, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, ) -> Pin<Box<dyn Future<Output = Result<DiscoveryResponseVariant, Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, DiscoveryService: 'async_trait,

Handle getStream request.
Source§

fn handle_list_streams<'life0, 'life1, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, ) -> Pin<Box<dyn Future<Output = Result<DiscoveryResponseVariant, Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, DiscoveryService: 'async_trait,

Handle listStreams request.
Source§

fn handle_announce<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, data: &'life2 ServiceAnnouncement, ) -> Pin<Box<dyn Future<Output = Result<DiscoveryResponseVariant, Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, DiscoveryService: 'async_trait,

Handle announce request.
Source§

fn handle_register_entity_statement<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, data: &'life2 RegisterEntityStatementRequest, ) -> Pin<Box<dyn Future<Output = Result<DiscoveryResponseVariant, Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, DiscoveryService: 'async_trait,

Handle registerEntityStatement request.
Source§

fn handle_get_entity_statement<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, data: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<DiscoveryResponseVariant, Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, DiscoveryService: 'async_trait,

Handle getEntityStatement request.
Source§

fn handle_register_envelope_keyset<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, data: &'life2 RegisterEnvelopeKeysetRequest, ) -> Pin<Box<dyn Future<Output = Result<DiscoveryResponseVariant, Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, DiscoveryService: 'async_trait,

Handle registerEnvelopeKeyset request.
Source§

fn handle_get_envelope_keyset<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, data: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<DiscoveryResponseVariant, Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, DiscoveryService: 'async_trait,

Handle getEnvelopeKeyset request.
Source§

fn handle_list_known_issuers<'life0, 'life1, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, ) -> Pin<Box<dyn Future<Output = Result<DiscoveryResponseVariant, Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, DiscoveryService: 'async_trait,

Handle listKnownIssuers request.
Source§

fn handle_get_record<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, data: &'life2 GetRecordRequest, ) -> Pin<Box<dyn Future<Output = Result<DiscoveryResponseVariant, Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, DiscoveryService: 'async_trait,

Handle getRecord request.
Source§

fn handle_get_repo<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, value: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<DiscoveryResponseVariant, Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, DiscoveryService: 'async_trait,

Handle getRepo request.
Source§

fn is_resource_authorized<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, resource: &'life2 str, operation: &'life3 str, ) -> Pin<Box<dyn Future<Output = bool> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: 'async_trait,

Check if a specific resource+operation is authorized (non-failing). Read more
Source§

impl RequestService for DiscoveryService

Source§

fn decode_request_body( &self, signed_body: &[u8], ) -> Result<DecodedRequestBody, Error>

Decode the signed request body exactly once (bounded) and derive the full numeric method leaf path (v16 §5.2 step 4). Read more
Source§

fn handle_request<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, body: &'life2 DecodedRequestBody, ) -> Pin<Box<dyn Future<Output = Result<(Vec<u8>, Option<Pin<Box<dyn Future<Output = ()>>>>), Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, DiscoveryService: 'async_trait,

Process a request and return a response with optional continuation. Read more
Source§

fn name(&self) -> &str

Service name (for logging and registry).
Source§

fn transport(&self) -> &TransportConfig

Transport configuration (endpoint binding).
Source§

fn signing_key(&self) -> SigningKey

Ed25519 signing key for signing responses.
Source§

fn expected_audience(&self) -> Option<&str>

Expected audience (resource URL) for JWT validation. Read more
Source§

fn jwt_key_source(&self) -> Option<Arc<dyn JwtKeySource>>

JWT key source for token verification. Read more
Source§

fn build_error_payload(&self, request_id: u64, error: &str) -> Vec<u8> ⓘ

Build a generic error response payload for unexpected errors. Read more
Source§

fn producer_reach_config_handle( &self, ) -> Option<Arc<RwLock<RawRwLock, ProducerReachConfig>>>

Mutable reach source filled by the unified service spawner after the service’s QUIC and iroh listeners bind.
Source§

fn moq_origin_handle( &self, ) -> Option<Arc<RwLock<RawRwLock, Option<MoqStreamOrigin>>>>

Optional per-service MoQ origin source. The unified spawner installs a scoped origin here when this service has a relay configured.
Source§

fn pq_signing_key(&self) -> Option<SigningKey<MlDsa65>>

ML-DSA-65 signing key for the post-quantum half of the response COSE composite (#275). Returning None makes process_request fail closed before dispatch; it never selects an EdDSA-only response. The matching ML-DSA-65 public key must be anchored in the client’s PQ trust store for Hybrid verification to succeed (peer attestation). Read more
Source§

fn verifying_key(&self) -> VerifyingKey

Ed25519 verifying key for envelope signature verification.
Source§

fn delegated_user_audience( &self, _signer_pubkey: &[u8; 32], _untrusted_aud: Option<&str>, ) -> Option<&str>

Select an exact, configured audience for an already-admitted delegated user bearer. The unverified claim is only a selector: implementations must return their own configured string, never a borrowed token value. Direct and service credentials always use expected_audience instead.
Source§

fn accept_delegated_resource_leaf( &self, _ctx: &EnvelopeContext, _body: &DecodedRequestBody, ) -> bool

Admit a non-native resource bearer only for a decoded signed request leaf. Default denial preserves every service’s native issuer boundary.
Source§

fn require_cnf_binding(&self) -> bool

Whether to reject JWTs that lack a cnf key binding (jwk or jkt). Read more
Source§

fn credential_revocation_store(&self) -> Option<&dyn CredentialRevocationStore>

Credential revocation store for access token revocation. Read more
Source§

fn jwt_verify_policy(&self) -> CryptoPolicy

Fu4/#677: the minimum JWT alg policy enforced in verify_claims. Read more
Source§

fn resolve_key_subject(&self, signer_pubkey: &[u8; 32]) -> Option<Subject>

Resolve a verified signer key to an authorization subject (#446). Read more
Source§

fn cache_key_binding( &self, _verifying_key: VerifyingKey, _subject: &str, _jwt: &str, _expires_at: i64, )

Cache a verified key→subject binding in the trust store. Read more
Source§

fn accept_delegated_bearer(&self, _signer_pubkey: &[u8; 32]) -> bool

Accept a relayed bearer from this verified envelope signer. Services enabling this must pin an independently configured controller key.
Source§

fn accept_deferred_federate_credential(&self) -> bool

Opt in only when this serving instance has a complete request-local holder-proof, current-primary and durable Policy-use adapter. Default false preserves the generic verifier’s reserved-profile denial.
Source§

fn admit_deferred_federate_request<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _body: &'life2 DecodedRequestBody, _proof: &'life3 ParsedProof, ) -> Pin<Box<dyn Future<Output = Result<(VerifiedProof, [u8; 32], String, String, ProofReplayKey, u64), Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: 'async_trait,

Verify the original holder’s proof and bind it to the exact decoded body/leaf/resource/action before identity publication. This stage must not consume replay state: generated method-policy and MAC authorization still run afterward. Durable Policy admission happens in commit_deferred_federate_request only after those gates pass.
Source§

fn commit_deferred_federate_request<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _resource: &'life2 str, _operation: &'life3 str, _replay_key: &'life4 ProofReplayKey, _replay_expiry: u64, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, Self: 'async_trait,

Perform fresh Policy admission and durable replay consumption after the generated method-policy and mandatory MAC gates, immediately before handler dispatch. Implementations must fail closed if the durable admission service is unavailable. The default never admits a request.
Source§

fn verify_internal_work_bearer<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _token: &'life2 str, _protected: &'life3 ProtectedHeader, ) -> Pin<Box<dyn Future<Output = Result<InternalWorkClaims, Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: 'async_trait,

Verify an iw+jwt internal execution work order presented as the direct JWT (single-service Model→Inference boundary, user-approved D5). Read more
Source§

fn verify_claims<'life0, 'life1, 'async_trait>( &'life0 self, ctx: &'life1 mut EnvelopeContext, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

E2E JWT verification with unified key source. Read more
Source§

impl Resolver for DiscoveryService

Source§

fn resolve<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, kind: SocketKind, ) -> Pin<Box<dyn Future<Output = Result<TransportConfig, Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, DiscoveryService: 'async_trait,

Resolve a service endpoint. Read more

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
§

impl<T> Any for T
where T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

§

fn type_name(&self) -> &'static str

§

impl<T> AnySync for T
where T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send> ⓘ

§

impl<'a, T, E> AsTaggedExplicit<'a, E> for T
where T: 'a,

§

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

§

impl<'a, T, E> AsTaggedImplicit<'a, E> for T
where T: 'a,

§

fn implicit( self, class: Class, constructed: bool, tag: u32, ) -> TaggedParser<'a, Implicit, Self, E>

Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> FutureExt for T

§

fn with_context(self, otel_cx: Context) -> WithContext<Self>

Attaches the provided Context to this type, returning a WithContext wrapper. Read more
§

fn with_current_context(self) -> WithContext<Self>

Attaches the current Context to this type, returning a WithContext wrapper. Read more
§

impl<T, W> HasTypeWitness<W> for T
where W: MakeTypeWitness<Arg = T>, T: ?Sized,

§

const WITNESS: W = W::MAKE

A constant of the type witness
§

impl<T> Identity for T
where T: ?Sized,

§

const TYPE_EQ: TypeEq<T, <T as Identity>::Type> = TypeEq::NEW

Proof that Self is the same type as Self::Type, provides methods for casting between Self and Self::Type.
§

type Type = T

The same type as Self, used to emulate type equality bounds (T == U) with associated type equality constraints (T: Identity<Type = U>).
§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> IntoRequest<T> for T

Source§

fn into_request(self) -> Request<T>

Wrap the input message T in a tonic::Request
§

impl<T> JaggedSlice<T> for T

§

type Index = Index2

§

fn push_into(self, array: &mut Jagged<T>)

§

fn insert_into(self, index: <T as JaggedSlice<T>>::Index, array: &mut Jagged<T>)

§

impl<T> Pointable for T

§

const ALIGN: usize

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
§

impl<T> PolicyExt for T
where T: ?Sized,

§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] only if self and other return Action::Follow. Read more
§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] if either self or other returns Action::Follow. Read more
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
§

impl<T> ServiceExt for T

§

fn map_response_body<F>(self, f: F) -> MapResponseBody<Self, F>
where Self: Sized,

Apply a transformation to the response body. Read more
§

fn trace_for_http(self) -> Trace<Self, SharedClassifier<ServerErrorsAsFailures>>
where Self: Sized,

High level tracing that classifies responses using HTTP status codes. Read more
§

fn trace_for_grpc(self) -> Trace<Self, SharedClassifier<GrpcErrorsAsFailures>>
where Self: Sized,

High level tracing that classifies responses using gRPC headers. Read more
§

fn follow_redirects(self) -> FollowRedirect<Self>
where Self: Sized,

Follow redirect resposes using the Standard policy. Read more
Source§

impl<S> Spawnable for S
where S: RequestService + Send + Sync,

Source§

fn name(&self) -> &str

Service name (for logging and registry).
Source§

fn registrations(&self) -> Vec<(SocketKind, TransportConfig)>

Endpoints to register with EndpointRegistry. Read more
Source§

fn run( self: Box<S>, shutdown: Arc<Notify>, on_ready: Option<Sender<()>>, ) -> Result<(), RpcError>

Run the service on current thread (blocking). Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

impl<T> ErasedDestructor for T
where T: 'static,

§

impl<T> MaybeSend for T
where T: Send,

§

impl<T> MaybeSend for T
where T: Send,

§

impl<T> MaybeSync for T
where T: Sync,

§

impl<T> MaybeSync for T
where T: Sync,