Struct Order

pub struct Order<'a> { /* private fields */ }

Wrapped Account with order info

Implementations

impl<'a> Order<'a>

pub fn state(&self) -> &Order

Get (local) order state

pub fn account(&self) -> &'a Account<'a>

Get reference to Account linked to this Order

pub async fn refresh( &mut self, ctx: Context, ) -> Result<(&Order, Option<Duration>), ClientError>

Refresh Order state, and return it (and potential retry-after delay in case we want to refresh again)

This also returns a duration which the server has requested to wait before calling this again if any

pub async fn get_authorizations( &self, ctx: Context, ) -> Result<Vec<Authorization>, ClientError>

Get list of server::Authorizations linked to this Order

pub async fn get_authorization( &self, ctx: Context, authorization_url: &str, ) -> Result<Authorization, ClientError>

Get server::Authorization which is stored on the given url

pub async fn finish_challenge( &self, ctx: Context, challenge: &mut Challenge, ) -> Result<(), ClientError>

Finish the current challenge

This does two things behind the scene

1. Notify acme server that challenge is ready and should be verified by the server (Self::notify_challenge_ready)
2. Polls the acme server until the server has verified this challenge and has updated its internal status (Self::wait_until_challenge_finished)

pub async fn notify_challenge_ready( &self, ctx: Context, challenge: &Challenge, ) -> Result<(), ClientError>

Notify ACME server that the given challenge is ready

Server will now try to verify this and we should keep polling the server with Self::wait_until_challenge_finished() to wait for the result.

pub async fn refresh_challenge( &self, ctx: Context, challenge: &mut Challenge, ) -> Result<Option<Duration>, ClientError>

Referesh the given challenge

This returns a duration which the server has requested to wait before calling this again if any

pub async fn wait_until_challenge_finished( &self, ctx: Context, challenge: &mut Challenge, ) -> Result<(), ClientError>

Poll acme server until the challenge is finished (challenge.status == server::ChallengeStatus::Valid | server::ChallengeStatus::Invalid)

pub async fn wait_until_all_authorizations_finished( &mut self, ctx: Context, ) -> Result<&Order, ClientError>

Keep polling acme server until all server::Authorizations have finished

Note for this to work each server::Authorization needs to have one valid challenge

pub async fn finalize<T>( &mut self, ctx: Context, csr_der: T, ) -> Result<&Order, ClientError>

where T: AsRef<[u8]>,

Finalize the order and request ACME server to generate a certifcate from the provided certificate params

Note: for this to work all server::Authorizations need to have finished (order.status == server::OrderStatus::Ready)

pub async fn wait_until_certificate_ready( &mut self, ctx: Context, ) -> Result<&Order, ClientError>

Keep polling acme server until the certificate is ready (order.status == server::OrderStatus::Valid)

pub async fn download_certificate_no_checks( &self, ctx: Context, ) -> Result<String, ClientError>

Download the certificate generated by the server

Note: for this to work the certificate needs to be ready (order.status == server::OrderStatus::Valid). Use Self::download_certificate instead to also wait for this correct status before downloading.

pub async fn download_certificate( &mut self, ctx: Context, ) -> Result<String, ClientError>

Wait until certificate is ready and then download it

To directly download the certificate without waiting for the correct status use Self::download_certificate_no_checks instead

pub async fn wait_until_status( &mut self, ctx: Context, status: OrderStatus, ) -> Result<&Order, ClientError>

Keep polling until the order has reached the given status

pub fn create_key_authorization( &self, challenge: &Challenge, ) -> Result<KeyAuthorization, OpaqueError>

Create KeyAuthorization for the given challenge

pub fn create_tls_challenge_data( &self, challenge: &Challenge, identifier: &Identifier, ) -> Result<(PrivatePkcs8KeyDer<'_>, Certificate), OpaqueError>

Create challenge data need for tls-alpn challenge

This function returns a private private key and certificate which a TLS backend should expose on port 443 (on the configured domain)