Struct acme2::Order

pub struct Order {
    pub status: OrderStatus,
    pub expires: Option<String>,
    pub identifiers: Vec<Identifier>,
    pub not_before: Option<String>,
    pub not_after: Option<String>,
    pub error: Option<ServerError>,
    /* private fields */
}

An order represents a subscribers’s request for a certificate from the ACME server, and is used to track the progress of that order through to issuance.

This must be created through an OrderBuilder.

Fields

status: OrderStatus

The status of this order.

expires: Option<String>

The timestamp after which the server will consider this order invalid.

identifiers: Vec<Identifier>

An array of identifier objects that the order pertains to.

not_before: Option<String>

The requested value of the notBefore field in the certificate.

not_after: Option<String>

The requested value of the notAfter field in the certificate.

error: Option<ServerError>

The error that occurred while processing the order, if any.

Implementations

impl Order

pub async fn authorizations(&self) -> Result<Vec<Authorization>, Error>

Retrieve all of the Authorizations needed for this order.

The authorization may already be in a Valid state, if an authorization for this identifier was already completed through a seperate order.

impl Order

pub async fn finalize(&self, csr: Csr) -> Result<Order, Error>

Finalize an order (request the final certificate).

For finalization to complete, the state of the order must be in the OrderStatus::Ready state. You can use Order::wait_ready to wait until this is the case.

In most cases this will not complete immediately. You should always call Order::wait_done after this operation to wait until the ACME server has finished finalization, and the certificate is ready for download.

pub async fn certificate(&self) -> Result<Option<Vec<X509>>, Error>

Download the certificate. The order must be in the OrderStatus::Valid state for this to complete.

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

Update the order to match the current server state.

Most users should use Order::wait_ready or Order::wait_done.

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

Wait for this order to go into a state other than OrderStatus::Pending.

This happens when all crate::Authorizations in this order have been completed (have the crate::AuthorizationStatus::Valid state).

Will complete immediately if the order 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.

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

Wait for the order to go into the OrderStatus::Valid or OrderStatus::Invalid state.

This will happen after the order has gone into the OrderStatus::Ready state, and the order has been requested to be finalized.

Will complete immediately if the order 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 Debug for Order

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Order

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.