Struct Client 

pub struct Client { /* private fields */ }

A configured Sail client. Cheap to clone; shares transport across clones.

Implementations

impl Client

pub fn builder(api_key: impl Into<String>) -> ClientBuilder

Start a ClientBuilder.

pub fn from_env() -> Result<Client, SailError>

Build a client from the environment (SAIL_API_KEY, …).

pub fn from_config(config: Config) -> Result<Client, SailError>

Build a client from an already-resolved Config.

pub fn config(&self) -> &Config

The resolved configuration.

pub async fn create_sailbox( &self, req: &CreateSailboxRequest, timeout: Option<Duration>, ) -> Result<Sailbox, SailError>

Create a Sailbox. timeout bounds each attempt of the synchronous create (which can take minutes server-side); the call retries with one idempotency key so the backend can dedupe rather than duplicate, and gives up after roughly max_attempts * timeout. An interrupted or re-invoked create is a new request and may leave a prior Sailbox behind under the same name. 10 minutes is a good default; None leaves each attempt unbounded. If the budget is exhausted the Sailbox may still be coming up server-side; find or terminate it by name.

pub async fn list_sailboxes( &self, query: &ListSailboxesQuery, ) -> Result<SailboxPage, SailError>

List Sailboxes in the current org.

pub async fn sailbox_spend( &self, query: &SailboxSpendQuery, ) -> Result<SailboxSpendResponse, SailError>

Estimate Sailbox spend for the current organization over a time window.

pub async fn sailbox_metrics( &self, sailbox_id: &str, query: &SailboxMetricsQuery, ) -> Result<SailboxMetricsResponse, SailError>

Fetch a Sailbox’s resource-usage time series.

pub async fn create_from_checkpoint( &self, checkpoint_id: &str, name: Option<&str>, timeout: Option<Duration>, ) -> Result<Sailbox, SailError>

Create a new running Sailbox from a durable checkpoint handle. The new Sailbox restores the memory saved in the checkpoint as well as the writable disk, so processes the original was running carry on here, and it runs independently of the Sailbox that took the checkpoint. Commands started with Sailbox::exec stop here, though their writes up to the checkpoint are kept, and one started with background keeps running. Start the other execs the new Sailbox needs. Sometimes it comes up cold instead, with the disk intact and nothing running, and a Sailbox that mounts a volume always does. Volumes are mounted on it at the same paths as on the original, and they are the same volumes, so both Sailboxes read and write the same files.

name sets the new Sailbox’s display name, and the server derives one when it is omitted. timeout is accepted and ignored: the call blocks until the restore finishes, so apply your own deadline if you need one. It must be positive when given.

pub async fn org_ssh_ca_public_key(&self) -> Result<String, SailError>

The caller org’s SSH CA public key (created on first use).

pub async fn issue_user_cert( &self, public_key: &str, timeout: Option<Duration>, ) -> Result<IssuedUserCert, SailError>

Sign public_key into a short-lived org-CA certificate (principal root). timeout (seconds) bounds a single no-retry attempt; None retries.

pub async fn get_volume( &self, name: &str, mint_if_missing: bool, ) -> Result<VolumeInfo, SailError>

Look up (optionally minting) an NFS volume by name.

pub async fn list_volumes( &self, max_objects: Option<i64>, ) -> Result<Vec<VolumeInfo>, SailError>

List NFS volumes in the current org.

pub async fn delete_volume( &self, volume_id: &str, allow_missing: bool, ) -> Result<Option<VolumeInfo>, SailError>

Delete a volume by id.

pub async fn find_app( &self, name: &str, mint_if_missing: bool, ) -> Result<App, SailError>

Find an app by name, optionally minting it.

pub async fn list_apps(&self) -> Result<Vec<App>, SailError>

Every app the current org owns, newest first.

impl Client

pub async fn build_image( &self, spec: &ImageSpec, retry_timeout_secs: f64, mode: BuildMode, ) -> Result<ImageBuild, SailError>

Submit or resume a custom image build. Poll Client::get_image_build_status until the status is ready or failed, or use Client::build_image_definition for the whole pipeline.

mode selects whether an image already built for this spec satisfies the call or the image is built again; see BuildMode.

pub async fn get_image_build_status( &self, image_id: &str, retry_timeout_secs: f64, ) -> Result<ImageBuild, SailError>

Poll one custom image build’s status.

pub async fn resolve_image( &self, def: &ImageDefinition, ) -> Result<ImageSpec, SailError>

Resolve an ImageDefinition into a content-addressed ImageSpec: walk local directories, hash every file, and upload content the server does not already have.

pub async fn build_image_definition( &self, def: &ImageDefinition, timeout: Duration, mode: BuildMode, ) -> Result<ImageSpec, SailError>

Resolve an ImageDefinition and build it to ready, returning the content-addressed ImageSpec to create Sailboxes from. A bare builtin base skips the build. timeout bounds the whole pipeline (hashing, uploads, and the build); 30 minutes is a good default, and Duration::MAX waits indefinitely. Local files are re-hashed on every call, so edits always reach the build, and rebuilding an unchanged, already-built image returns quickly. For an image imported from a registry (ImageDefinition::oci_ref), the returned spec is pinned to the exact registry version the build used, so Sailboxes created from it get those bytes even if the tag moves later.

mode selects whether the image already built for this definition satisfies the call or the image is built again; see BuildMode.

impl Client

pub fn sailbox(&self, sailbox_id: impl Into<String>) -> Sailbox

Bind an existing Sailbox id to this client without a network call, giving the method-style surface over it.

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Client

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

Formats the value using the given formatter.