Lifecycle

checkpoint = sb.checkpoint()  # Create a durable checkpoint handle
child = sail.Sailbox.from_checkpoint(checkpoint.checkpoint_id, name="rollout-1")
sb.pause()                    # Checkpoint and pause until explicit resume
sb.sleep()                    # Checkpoint and sleep until network ingress, exec, or resume
sb.resume()                   # Resume a paused or sleeping Sailbox
sb.upgrade()                  # Update the Sailbox runtime by rebooting on the same disk
sb.terminate()                # Permanently destroy the Sailbox

const checkpoint = await sb.checkpoint(); // Create a durable checkpoint handle
const child = await Sailbox.fromCheckpoint({
  checkpointId: checkpoint.checkpointId,
  name: "rollout-1",
});
await sb.pause(); // Checkpoint and pause until explicit resume
await sb.sleep(); // Checkpoint and sleep until network ingress, exec, or resume
await sb.resume(); // Resume a paused or sleeping Sailbox
await sb.upgrade(); // Update the Sailbox runtime by rebooting on the same disk
await sb.terminate(); // Permanently destroy the Sailbox

use sail::CheckpointOptions;

// Create a durable checkpoint handle
let checkpoint = sb.checkpoint(CheckpointOptions::default()).await?;
let child = client
    .create_from_checkpoint(&checkpoint.checkpoint_id, "rollout-1", /* timeout */ None)
    .await?;
sb.pause().await?; // Checkpoint and pause until explicit resume
sb.sleep(/* wake_at */ None).await?; // Checkpoint and sleep until ingress, exec, or resume
sb.resume().await?; // Resume a paused or sleeping Sailbox
sb.upgrade().await?; // Update the Sailbox runtime
sb.terminate().await?; // Permanently destroy the Sailbox

sb = sail.Sailbox.create(
    app=app,
    name="interactive-session",
    auto_sleep=sail.AutoSleep.never(),
)

# Or use a 30-second idle window instead of Sail's default.
sb.set_auto_sleep(sail.AutoSleep.not_before(30))

const sb = await Sailbox.create({
  app,
  name: "interactive-session",
  autoSleep: { automatic: false },
});

// Or use a 30-second idle window instead of Sail's default.
await sb.setAutoSleep({ automatic: true, minSecondsBeforeSleep: 30 });

use sail::{AutoSleep, CreateSailboxRequest};
use std::time::Duration;

let sb = client
    .create_sailbox(
        &CreateSailboxRequest {
            app_id: app.id,
            name: "interactive-session".into(),
            auto_sleep: AutoSleep::Never,
            ..Default::default()
        },
        /* timeout */ None,
    )
    .await?;

// Or use a 30-second idle window instead of Sail's default.
sb.set_auto_sleep(AutoSleep::NotBefore(Duration::from_secs(30))).await?;

sb.exec("python3 setup.py").wait()
checkpoint = sb.checkpoint(name="after-setup", ttl_seconds=30 * 86400)
print(checkpoint.expires_at)

await (await sb.exec("python3 setup.py")).wait();
const checkpoint = await sb.checkpoint({
  name: "after-setup",
  ttlSeconds: 30 * 86400,
});
console.log(checkpoint.expiresAt);

use sail::CheckpointOptions;
use std::time::Duration;

use sail::ExecOptions;

let setup = sb
    .exec(
        vec!["python3".to_string(), "setup.py".to_string()],
        ExecOptions::default(),
    )
    .await?;
setup.wait().await?;
let checkpoint = sb
    .checkpoint(CheckpointOptions {
        name: Some("after-setup".to_string()),
        ttl: Some(Duration::from_secs(30 * 86400)),
    })
    .await?;
println!("{:?}", checkpoint.expires_at);

checkpoint = sb.checkpoint()
child = sail.Sailbox.from_checkpoint(
    checkpoint.checkpoint_id,
    name="experiment-1",
)

const checkpoint = await sb.checkpoint();
const child = await Sailbox.fromCheckpoint({
  checkpointId: checkpoint.checkpointId,
  name: "experiment-1",
});

use sail::CheckpointOptions;

let checkpoint = sb.checkpoint(CheckpointOptions::default()).await?;
let child = client
    .create_from_checkpoint(&checkpoint.checkpoint_id, "experiment-1", /* timeout */ None)
    .await?;

import asyncio

checkpoint = sb.checkpoint()

async def fan_out(n: int) -> list[sail.Sailbox]:
    results = await asyncio.gather(
        *(
            sail.Sailbox.from_checkpoint.aio(
                checkpoint.checkpoint_id,
                name=f"worker-{i}",
                timeout=600,
            )
            for i in range(n)
        ),
        # Keep the children that came up even if some restores fail.
        return_exceptions=True,
    )
    return [r for r in results if isinstance(r, sail.Sailbox)]

children = asyncio.run(fan_out(32))

const checkpoint = await sb.checkpoint();

const results = await Promise.allSettled(
  Array.from({ length: 32 }, (_, i) =>
    Sailbox.fromCheckpoint({
      checkpointId: checkpoint.checkpointId,
      name: `worker-${i}`,
      timeoutSeconds: 600,
    }),
  ),
);

// Keep the children that came up even if some restores fail.
const children = results.flatMap((r) =>
  r.status === "fulfilled" ? [r.value] : [],
);

use std::time::Duration;

use sail::CheckpointOptions;

let checkpoint = sb.checkpoint(CheckpointOptions::default()).await?;

// Build the names first so each one outlives the call that borrows it.
let names: Vec<String> = (0..32).map(|i| format!("worker-{i}")).collect();
let results = futures::future::join_all(names.iter().map(|name| {
    client.create_from_checkpoint(
        &checkpoint.checkpoint_id,
        Some(name.as_str()),
        Some(Duration::from_secs(600)),
    )
}))
.await;

// Keep the children that came up even if some restores fail.
let children: Vec<sail::Sailbox> = results.into_iter().flatten().collect();

sb.pause()
sb.resume()

await sb.pause();
await sb.resume();

sb.pause().await?;
sb.resume().await?;

sb.sleep()

await sb.sleep();

sb.sleep(/* wake_at */ None).await?;

sb.resume()

await sb.resume();

sb.resume().await?;

from datetime import datetime, timedelta, timezone

effective = sb.sleep(wake_at=datetime.now(timezone.utc) + timedelta(hours=2))

const effective = await sb.sleep(new Date(Date.now() + 2 * 60 * 60 * 1000));

use sail::time::{Duration, OffsetDateTime};

let effective = sb
    .sleep(Some(OffsetDateTime::now_utc() + Duration::hours(2)))
    .await?;

sail box sleep <id> --wake-at 2h

result = sb.upgrade()
print(result.applied)

const { applied } = await sb.upgrade();

let outcome = sb.upgrade().await?;
println!("applied now: {}", outcome.applied);

sb.terminate()

await sb.terminate();

sb.terminate().await?;