Struct CanopyClient 

pub struct CanopyClient { /* private fields */ }

HTTP client with auth configured for talking to a canopy server.

Tries two auth paths in order of preference:

1. Tailscale: if the canopy tailnet endpoint is reachable, plain HTTPS works (auth is implicit via tailscale identity).
2. mTLS: a fresh self-signed cert from the device key, short-lived ([CERT_VALIDITY_DAYS]); for long-running daemons, Self::renew should tick on CERT_RENEW_AFTER to swap in a fresh cert before expiry.

Self::refresh re-probes tailscale and swaps modes on reload.

Implementations

impl CanopyClient

pub async fn new( device_key_pem: Option<&str>, make_builder: impl Fn() -> ClientBuilder + Send + Sync + 'static, ) -> Result<Option<Self>>

Build a canopy client against the default public (DEFAULT_CANOPY_URL) and tailscale (TAILSCALE_URL) endpoints. Use Self::with_urls to override them.

Probes the tailscale endpoint first; if reachable, uses it. Otherwise, if a device key PEM is provided, builds an mTLS client. Returns Ok(None) if neither path is available.

make_builder supplies the base reqwest::ClientBuilder — see ClientBuilderFactory.

pub async fn with_urls( base_url: Url, tailscale_url: Url, device_key_pem: Option<&str>, make_builder: impl Fn() -> ClientBuilder + Send + Sync + 'static, ) -> Result<Option<Self>>

Build a canopy client against explicit endpoints.

base_url is canopy’s public API URL (the registration’s api_url), used on the mTLS path; tailscale_url is the tailnet endpoint used on the tailscale path. Both are fixed for the client’s lifetime. See Self::new for the other arguments and the default-endpoint form.

pub async fn is_tailscale(&self) -> bool

Returns true if the client is currently using the tailscale path.

pub async fn refresh(&self) -> Result<()>

Re-probe tailscale and swap modes if the picture has changed.

Intended to be called when the daemon receives a reload signal.

pub async fn renew(&self) -> Result<()>

Rebuild the underlying HTTP client with a fresh certificate.

No-op in tailscale mode (no cert to rotate). In mTLS mode, atomically replaces the live client; in-flight requests continue with the old client until they complete.

impl CanopyClient

pub async fn artifacts( &self, version: &str, artifact_type: &str, platform: &str, ) -> Result<Artifact>

POST /artifacts/{version}/{artifact_type}/{platform}

pub async fn backup_capabilities(&self, body: &CapabilitiesArgs) -> Result<()>

POST /backup-capabilities

pub async fn backup_credentials( &self, body: &CredentialsArgs, ) -> Result<CredentialProcessOutput>

POST /backup-credentials

pub async fn backup_report(&self, body: &ReportArgs) -> Result<()>

POST /backup-report

pub async fn backup_target(&self) -> Result<BackupTarget>

GET /backup-target

pub async fn bestool_snippets(&self) -> Result<Value>

GET /bestool/snippets

pub async fn events(&self, body: &NewEvent) -> Result<Issue>

POST /events

pub async fn restore_capabilities(&self, body: &CapabilitiesArgs) -> Result<()>

POST /restore-capabilities

pub async fn restore_credentials( &self, body: &CredentialsArgs, ) -> Result<RestoreCredentials>

POST /restore-credentials

pub async fn restore_verification(&self, body: &VerificationArgs) -> Result<()>

POST /restore-verification

pub async fn restore_worklist(&self) -> Result<Vec<WorklistEntry>>

GET /restore-worklist

pub async fn servers(&self) -> Result<Vec<PublicServer>>

GET /servers

pub async fn servers_register_begin( &self, body: &BeginArgs, ) -> Result<BeginResponse>

POST /servers/register/begin

pub async fn servers_register_complete( &self, body: &CompleteArgs, ) -> Result<CompleteResponse>

POST /servers/register/complete

pub async fn status( &self, server_id: &str, body: &Value, ) -> Result<StatusResponse>

POST /status/{server_id}

pub async fn tags(&self) -> Result<TagMap>

Merged tags for the calling device’s server.

The device authenticates with its certificate; we resolve the (unique) server backed by that device, then overlay the server’s tags onto the group’s tags (server wins on key collision). For ungrouped servers, returns just the server’s own tags.

On top of the stored tags we inject synthetic, read-only tags describing the server under the reserved canopy: namespace: canopy:kind, canopy:rank (when set), and canopy:group-id / canopy:group-name (when grouped). Operator-set tags can’t use that prefix, so they never collide. See [Server::tags_for_device].

• 401: no certificate / cert doesn’t match a known device.
• 412: device is registered but isn’t attached to a server yet.
• 409: device is somehow attached to multiple servers (shouldn’t happen — the servers.device_id unique index guarantees this can’t occur, but the handler still surfaces the case rather than silently picking one).

GET /tags

pub async fn get_versions(&self) -> Result<Vec<Version>>

GET /versions

pub async fn versions_update_for( &self, version: &str, ) -> Result<Vec<ViewVersion>>

GET /versions/update-for/{version}

pub async fn delete_versions(&self, version: &str) -> Result<()>

DELETE /versions/{version}

pub async fn post_versions(&self, version: &str) -> Result<Version>

POST /versions/{version}

pub async fn versions_artifacts(&self, version: &str) -> Result<Vec<Artifact>>

GET /versions/{version}/artifacts

Trait Implementations

impl Debug for CanopyClient

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

Formats the value using the given formatter.