Enum EndpointPolicy 

pub enum EndpointPolicy<'a> {
    Fixed(EndpointIdentity<'a>),
    OfficialSet(&'a [EndpointIdentity<'a>]),
    RegionDerived(RegionEndpoint<'a>),
    AcknowledgedCustom(AcknowledgedCustomEndpoint<'a>),
}

Allocation-free provider-owned endpoint admission policy.

Variants

Fixed(EndpointIdentity<'a>)

One immutable provider endpoint.

OfficialSet(&'a [EndpointIdentity<'a>])

A bounded finite set of official provider endpoints.

RegionDerived(RegionEndpoint<'a>)

One endpoint derived from a provider region.

AcknowledgedCustom(AcknowledgedCustomEndpoint<'a>)

One explicitly acknowledged custom credential destination.

Implementations

impl<'a> EndpointPolicy<'a>

pub const fn fixed(identity: EndpointIdentity<'a>) -> Self

Admits one fixed provider-owned endpoint.

Examples found in repository

examples/prepared_request.rs (line 77)

    fn prepare<'storage>(
        &self,
        storage: PreparationStorage<'storage>,
    ) -> Result<PreparedRequest<'storage>, Self::Error> {
        let (target_storage, _body_storage) = storage.into_parts();
        let target = target_storage
            .get_mut(..17)
            .ok_or(PrepareError::TargetBuffer)?;
        target.copy_from_slice(b"/resources?page=1");
        let target = core::str::from_utf8(target).map_err(|_| PrepareError::InvalidTarget)?;
        let target = RequestTarget::new(target).map_err(|_| PrepareError::InvalidTarget)?;
        let request = TransportRequest::new(Method::Get, target);
        let metadata = OperationMetadata::new(
            OperationImpact::ReadOnly,
            RequestSemantics::Safe,
            RetryEligibility::ExplicitPolicy,
            CostIntent::NoKnownCost,
        )
        .map_err(|_| PrepareError::InvalidMetadata)?;
        let response_policy = ResponsePolicy::new(
            &OK_STATUS,
            ContentTypePolicy::Required(&JSON_MEDIA),
            ResponseBodyPolicy::Required,
            65_536,
        )
        .map_err(|_| PrepareError::InvalidResponsePolicy)?;
        let endpoint =
            EndpointIdentity::new(EndpointScheme::Https, "api.example.invalid", 443, "/v1")
                .map_err(|_| PrepareError::InvalidEndpoint)?;
        Ok(PreparedRequest::new(
            request,
            ProviderService::from_marker::<ComputeService>(EndpointPolicy::fixed(endpoint)),
            metadata,
            response_policy,
        ))
    }

pub fn official_set( identities: &'a [EndpointIdentity<'a>], ) -> Result<Self, EndpointPolicyError>

Admits one of a bounded finite provider-owned endpoint set.

pub const fn region_derived(endpoint: RegionEndpoint<'a>) -> Self

Admits one provider-derived regional endpoint.

pub const fn acknowledged_custom( endpoint: AcknowledgedCustomEndpoint<'a>, ) -> Self

Admits one explicitly acknowledged custom credential destination.

pub const fn kind(self) -> EndpointPolicyKind

Returns the policy’s trust provenance.

pub fn admits(self, candidate: EndpointIdentity<'_>) -> bool

Reports whether the exact destination is admitted.

pub fn verify( self, candidate: EndpointIdentity<'_>, ) -> Result<(), EndpointPolicyError>

Fails closed unless the exact destination is admitted.

Trait Implementations

impl<'a> Clone for EndpointPolicy<'a>

fn clone(&self) -> EndpointPolicy<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Copy for EndpointPolicy<'a>

impl<'a> Debug for EndpointPolicy<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Eq for EndpointPolicy<'a>

impl<'a> PartialEq for EndpointPolicy<'a>

fn eq(&self, other: &EndpointPolicy<'a>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<'a> StructuralPartialEq for EndpointPolicy<'a>