Struct Challenge 

pub struct Challenge {
    pub type: String,
    pub status: ChallengeStatus,
    pub validated: Option<String>,
    pub error: Option<ServerError>,
    pub token: Option<String>,
    /* private fields */
}

A challenge represents a means for the server to validate that an account has control over an identifier (domain).

A challenge can only be acquired through an Authorization.

Fields

type: String

The type of challenge encoded in the object.

status: ChallengeStatus

The status of this challenge.

validated: Option<String>

The time at which the server validated this challenge.

error: Option<ServerError>

Error that occurred while the server was validating the challenge, if any.

token: Option<String>

A random value that uniquely identifies the challenge.

Implementations

impl Challenge

pub fn key_authorization(&self) -> Result<Option<String>, Error>

The key authorization is the token that the HTTP01 challenge should be serving for the ACME server to inspect.

pub fn key_authorization_encoded(&self) -> Result<Option<String>, Error>

The encoded key authorization is the token that the DNS01 challenge should be serving for the ACME server to inspect.

pub async fn validate(&self) -> Result<Challenge, Error>

Initiate validation of the challenge by the ACME server.

Before calling this method, you should have set up your challenge token so it is available for the ACME server to check.

In most cases this will not complete immediately. You should always call Challenge::wait_done after this operation to wait until the ACME server has finished validation.

pub async fn poll(&self) -> Result<Challenge, Error>

Update the challenge to match the current server state.

Most users should use Challenge::wait_done.

pub async fn wait_done( self, poll_interval: Duration, attempts: usize, ) -> Result<Challenge, Error>

Wait for the authorization to go into the AuthorizationStatus::Valid or AuthorizationStatus::Invalid state.

Will complete immediately if the authorization is already in one of these states.

Specify the interval at which to poll the acme server, and how often to attempt polling before timing out. Polling should not happen faster than about every 5 seconds to avoid rate limits in the acme server.

Trait Implementations

impl Clone for Challenge

fn clone(&self) -> Challenge

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Challenge

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Challenge

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.