use std::{collections::BTreeMap, time::Duration};
use chrono::{DateTime, TimeZone, Utc};
use reqwest::{Method, StatusCode};
use serde::{Deserialize, Serialize};
use tokio::time::Instant;
use crate::{
Traced,
client::Client,
error::SdkError,
image_builds::{DEFAULT_WAIT_LIMIT, ImageBuildError, InterruptSignal, new_client_request_id},
sandbox_images::{SandboxImageBuildEvent, cas_image_service_url, client_builder},
sandbox_templates::{SandboxTemplatesClient, models::SandboxTemplate},
};
pub const IMAGE_SERVICE_ID_PREFIX: &str = "image_";
pub const SANDBOX_TEMPLATE_ID_PREFIX: &str = "sandbox_template_";
pub const CAS_SNAPSHOT_FORMAT_VERSION: &str = "content_addressed_streaming_v1";
const CAS_V1_REFERENCE_PREFIX: &str = "cas-v1:";
const IMAGE_SERVICE_LIST_PAGE_SIZE: &str = "100";
#[derive(Debug)]
pub struct ImageDeletion {
pub family: DeletedImageFamily,
pub same_named_legacy: Option<LegacyImageDeletion>,
}
impl ImageDeletion {
fn only(family: DeletedImageFamily) -> Self {
Self {
family,
same_named_legacy: None,
}
}
pub fn failed_legacy_cleanup(&self) -> Option<(&str, Option<&str>, &SdkError)> {
match &self.same_named_legacy {
Some(LegacyImageDeletion::Failed { name, id, error }) => {
Some((name, id.as_deref(), error))
}
_ => None,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DeletedImageFamily {
Cas,
Legacy,
}
#[derive(Debug)]
pub enum LegacyImageDeletion {
Deleted {
name: String,
id: Option<String>,
},
Failed {
name: String,
id: Option<String>,
error: SdkError,
},
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ImageReference {
TemplateId(String),
ImageServiceId(String),
Name(String),
}
pub fn classify_image_reference(reference: &str) -> Result<ImageReference, SdkError> {
let reference = reference.trim();
if reference.is_empty() {
return Err(SdkError::ClientError(
"image reference must not be empty".to_string(),
));
}
if reference.starts_with(CAS_V1_REFERENCE_PREFIX) || is_lower_sha256_hex(reference) {
return Err(SdkError::ClientError(format!(
"'{reference}' is a content digest, not an image reference; use the image name or \
its image_ id"
)));
}
if reference.starts_with(SANDBOX_TEMPLATE_ID_PREFIX) {
return Ok(ImageReference::TemplateId(reference.to_string()));
}
if reference.starts_with(IMAGE_SERVICE_ID_PREFIX) {
return Ok(ImageReference::ImageServiceId(reference.to_string()));
}
Ok(ImageReference::Name(reference.to_string()))
}
pub(crate) fn is_lower_sha256_hex(value: &str) -> bool {
value.len() == 64
&& value
.bytes()
.all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b))
}
pub fn is_image_service_id(reference: &str) -> bool {
reference
.strip_prefix(IMAGE_SERVICE_ID_PREFIX)
.is_some_and(|rest| {
!rest.is_empty()
&& rest
.bytes()
.all(|b| b.is_ascii_lowercase() || b.is_ascii_digit())
})
}
pub fn validate_registered_name(name: &str) -> Result<(), String> {
if name.is_empty() {
return Err("image name must not be empty".to_string());
}
for reserved in [SANDBOX_TEMPLATE_ID_PREFIX, IMAGE_SERVICE_ID_PREFIX] {
if name.starts_with(reserved) {
return Err(format!(
"image name must not start with the reserved id prefix {reserved:?}"
));
}
}
if name.starts_with(CAS_V1_REFERENCE_PREFIX) {
return Err("image name must not be a cas-v1 reference".to_string());
}
Ok(())
}
pub fn validate_image_service_name(name: &str) -> Result<(), String> {
validate_registered_name(name)?;
if name.len() > 255 {
return Err("image name must be at most 255 characters".to_string());
}
let (repository, tag) = match name.split_once(':') {
Some((repository, tag)) => (repository, Some(tag)),
None => (name, None),
};
for component in repository.split('/') {
if !is_valid_name_component(component) {
return Err(format!(
"name component {component:?} must be lowercase alphanumeric segments joined by \
single '.', '_' or '-' separators"
));
}
}
if let Some(tag) = tag {
let valid_tag = !tag.is_empty()
&& tag.len() <= 128
&& tag.bytes().all(|b| {
b.is_ascii_lowercase() || b.is_ascii_digit() || matches!(b, b'_' | b'.' | b'-')
})
&& !tag.starts_with('.')
&& !tag.starts_with('-');
if !valid_tag {
return Err(format!("invalid tag {tag:?}"));
}
}
Ok(())
}
fn is_valid_name_component(component: &str) -> bool {
if component.is_empty() {
return false;
}
let mut previous_was_separator = true; for byte in component.bytes() {
let is_separator = matches!(byte, b'.' | b'_' | b'-');
if is_separator {
if previous_was_separator {
return false;
}
} else if !(byte.is_ascii_lowercase() || byte.is_ascii_digit()) {
return false;
}
previous_was_separator = is_separator;
}
!previous_was_separator
}
pub fn canonical_cas_image_name(name: &str) -> String {
name.to_ascii_lowercase()
}
pub fn cas_image_name_from(raw: &str, fallback: &str) -> String {
let lowered = canonical_cas_image_name(raw);
if is_addressable_cas_image_name(&lowered) {
return lowered;
}
let mut name = String::with_capacity(lowered.len());
for ch in lowered.chars() {
let ch = match ch {
ch @ ('a'..='z' | '0'..='9' | '.' | '_' | '-') => ch,
_ => '-',
};
if is_cas_name_separator(ch) && name.ends_with(is_cas_name_separator) {
continue;
}
name.push(ch);
}
let mut name = name.trim_matches(is_cas_name_separator).to_string();
name.truncate(MAX_CAS_IMAGE_NAME_LEN);
let name = name.trim_end_matches(is_cas_name_separator);
if is_addressable_cas_image_name(name) {
name.to_string()
} else {
fallback.to_string()
}
}
const MAX_CAS_IMAGE_NAME_LEN: usize = 255;
fn is_cas_name_separator(ch: char) -> bool {
matches!(ch, '.' | '_' | '-')
}
fn is_addressable_cas_image_name(name: &str) -> bool {
validate_image_service_name(name).is_ok() && !is_lower_sha256_hex(name)
}
pub fn is_cas_image(template: &SandboxTemplate) -> bool {
template.snapshot_format_version.as_deref() == Some(CAS_SNAPSHOT_FORMAT_VERSION)
}
pub fn created_at_sort_key(value: Option<&str>) -> Option<DateTime<Utc>> {
let value = value?.trim();
if let Ok(timestamp) = DateTime::parse_from_rfc3339(value) {
return Some(timestamp.with_timezone(&Utc));
}
let timestamp: f64 = value.parse().ok()?;
let seconds = if timestamp > 1e15 {
timestamp / 1_000_000.0
} else if timestamp > 1e12 {
timestamp / 1_000.0
} else {
timestamp
};
let whole_seconds = seconds.trunc() as i64;
let nanos = ((seconds.fract() * 1_000_000_000.0).round() as u32).min(999_999_999);
Utc.timestamp_opt(whole_seconds, nanos).single()
}
pub fn sort_merged_images(images: &mut [SandboxTemplate]) {
images.sort_by(|left, right| {
created_at_sort_key(right.created_at.as_deref())
.cmp(&created_at_sort_key(left.created_at.as_deref()))
.then_with(|| left.name.cmp(&right.name))
.then_with(|| is_cas_image(right).cmp(&is_cas_image(left)))
});
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ImageServiceImage {
pub id: String,
pub name: String,
pub snapshot_id: String,
pub global: bool,
pub physical_size_bytes: u64,
pub logical_size_bytes: u64,
pub created_at: String,
pub updated_at: String,
}
impl ImageServiceImage {
pub fn into_template(self) -> SandboxTemplate {
self.into()
}
}
impl From<ImageServiceImage> for SandboxTemplate {
fn from(image: ImageServiceImage) -> Self {
SandboxTemplate {
id: Some(image.id),
name: Some(image.name),
snapshot_uri: Some(format!("snapshot://{}", image.snapshot_id)),
snapshot_id: Some(image.snapshot_id),
snapshot_sandbox_id: None,
snapshot_format_version: Some(CAS_SNAPSHOT_FORMAT_VERSION.to_string()),
snapshot_size_bytes: Some(image.physical_size_bytes),
rootfs_disk_bytes: Some(image.logical_size_bytes),
rootfs_node_kind: Some("base".to_string()),
public: Some(image.global),
dockerfile: Some(String::new()),
created_by_user_id: None,
created_at: Some(image.created_at),
updated_at: Some(image.updated_at),
extra: BTreeMap::new(),
}
}
}
#[derive(Debug, Default, Deserialize)]
struct ImageServiceListPage {
#[serde(default)]
items: Vec<ImageServiceImage>,
#[serde(default)]
pagination: Option<ImageServicePagination>,
}
#[derive(Debug, Default, Deserialize)]
struct ImageServicePagination {
#[serde(default)]
next: Option<String>,
}
#[derive(Debug, Serialize)]
struct AdoptSnapshotRequest<'a> {
name: &'a str,
snapshot_id: &'a str,
public: bool,
}
#[derive(Debug, Deserialize)]
struct ImageServiceErrorBody {
#[serde(default)]
error: Option<String>,
#[serde(default)]
message: Option<String>,
}
fn tidy_error_message(message: String) -> String {
match serde_json::from_str::<ImageServiceErrorBody>(&message) {
Ok(body) => body.error.or(body.message).unwrap_or(message),
Err(_) => message,
}
}
fn tidy_error(error: SdkError) -> SdkError {
match error {
SdkError::ServerError { status, message } => SdkError::ServerError {
status,
message: tidy_error_message(message),
},
SdkError::Authentication(message) => SdkError::Authentication(tidy_error_message(message)),
SdkError::Authorization(message) => SdkError::Authorization(tidy_error_message(message)),
other => other,
}
}
#[derive(Clone)]
pub struct ImageServiceCatalog {
client: Client,
}
impl ImageServiceCatalog {
pub fn new(client: &Client, api_url: &str) -> Self {
Self {
client: client.with_base_url(&cas_image_service_url(api_url)),
}
}
pub async fn list_all(&self) -> Result<Vec<SandboxTemplate>, SdkError> {
let mut cursor: Option<String> = None;
let mut items = Vec::new();
loop {
let mut query: Vec<(&str, &str)> = vec![("page_size", IMAGE_SERVICE_LIST_PAGE_SIZE)];
if let Some(cursor) = cursor.as_deref() {
query.push(("cursor", cursor));
}
let request = self
.client
.build_get_json_request("/images", Some(&query))?;
let page = self
.client
.execute_json::<ImageServiceListPage>(request)
.await
.map_err(tidy_error)?
.into_inner();
items.extend(page.items.into_iter().map(SandboxTemplate::from));
match page
.pagination
.and_then(|pagination| pagination.next)
.filter(|next| !next.is_empty())
{
Some(next) => cursor = Some(next),
None => return Ok(items),
}
}
}
pub async fn get_by_name(&self, name: &str) -> Result<Option<SandboxTemplate>, SdkError> {
self.get_optional(&format!("/images/name/{name}")).await
}
pub async fn get_by_id(&self, image_id: &str) -> Result<Option<SandboxTemplate>, SdkError> {
self.get_optional(&format!("/images/{image_id}")).await
}
async fn get_optional(&self, path: &str) -> Result<Option<SandboxTemplate>, SdkError> {
let request = self.client.build_get_json_request(path, None)?;
match self.client.execute_json::<ImageServiceImage>(request).await {
Ok(traced) => Ok(Some(traced.into_inner().into())),
Err(SdkError::ServerError { status, .. }) if status == StatusCode::NOT_FOUND => {
Ok(None)
}
Err(error) => Err(tidy_error(error)),
}
}
pub async fn delete_by_name(&self, name: &str) -> Result<bool, SdkError> {
self.delete_optional(&format!("/images/name/{name}")).await
}
pub async fn delete_by_id(&self, image_id: &str) -> Result<bool, SdkError> {
self.delete_optional(&format!("/images/{image_id}")).await
}
async fn delete_optional(&self, path: &str) -> Result<bool, SdkError> {
let request = self.client.request(Method::DELETE, path).build()?;
match self.client.execute_traced(request).await {
Ok(_) => Ok(true),
Err(SdkError::ServerError { status, .. }) if status == StatusCode::NOT_FOUND => {
Ok(false)
}
Err(error) => Err(tidy_error(error)),
}
}
pub async fn adopt_snapshot(
&self,
name: &str,
snapshot_id: &str,
public: bool,
) -> Result<SnapshotAdoption, ImageBuildError> {
let request_id = new_client_request_id();
let wait = RegistrationWait::new(RegistrationWaitPolicy::default());
self.adopt_snapshot_with_request_id(
name,
snapshot_id,
public,
&request_id,
&wait,
&InterruptSignal::new(),
)
.await
}
pub async fn adopt_snapshot_and_wait<F>(
&self,
name: &str,
snapshot_id: &str,
public: bool,
interrupt: &InterruptSignal,
emit: F,
) -> Result<SandboxTemplate, ImageBuildError>
where
F: FnMut(SandboxImageBuildEvent),
{
self.adopt_snapshot_and_wait_with(
name,
snapshot_id,
public,
RegistrationWaitPolicy::default(),
interrupt,
emit,
)
.await
}
pub(crate) async fn adopt_snapshot_and_wait_with<F>(
&self,
name: &str,
snapshot_id: &str,
public: bool,
policy: RegistrationWaitPolicy,
interrupt: &InterruptSignal,
mut emit: F,
) -> Result<SandboxTemplate, ImageBuildError>
where
F: FnMut(SandboxImageBuildEvent),
{
let request_id = new_client_request_id();
let mut wait = RegistrationWait::new(policy);
loop {
match self
.adopt_snapshot_with_request_id(
name,
snapshot_id,
public,
&request_id,
&wait,
interrupt,
)
.await?
{
SnapshotAdoption::Published(image) => return Ok((*image).into_template()),
SnapshotAdoption::Pending { build_id } => {
if wait.build_id.is_none() {
emit(SandboxImageBuildEvent::Accepted {
build_id: build_id.clone(),
client_request_id: Some(request_id.clone()),
});
}
wait.build_id = Some(build_id.clone());
emit(SandboxImageBuildEvent::Status(format!(
"Registration of '{name}' pending (build {build_id}); waiting for \
publication..."
)));
let now = Instant::now();
if now >= wait.deadline {
return Err(wait.timeout(&request_id));
}
let delay = wait.policy.poll_interval.min(wait.deadline - now);
tokio::select! {
biased;
_ = interrupt.triggered() => {
let report = crate::image_service_builds::interruption_for_build(
&self.client,
&build_id,
Some(&request_id),
)
.await;
emit(SandboxImageBuildEvent::Interrupted(report.clone()));
return Err(ImageBuildError::Interrupted(report));
}
_ = tokio::time::sleep(delay) => {}
}
}
}
}
}
async fn adopt_snapshot_with_request_id(
&self,
name: &str,
snapshot_id: &str,
public: bool,
request_id: &str,
wait: &RegistrationWait,
interrupt: &InterruptSignal,
) -> Result<SnapshotAdoption, ImageBuildError> {
let body = serde_json::to_value(AdoptSnapshotRequest {
name,
snapshot_id,
public,
})?;
crate::image_service_builds::admit_direct(
&self.client,
"/images/from-snapshot",
&body,
request_id,
wait,
interrupt,
)
.await
}
}
#[derive(Debug, Clone, PartialEq)]
pub enum SnapshotAdoption {
Published(Box<ImageServiceImage>),
Pending { build_id: String },
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct RegistrationWaitPolicy {
pub limit: Duration,
pub poll_interval: Duration,
}
impl Default for RegistrationWaitPolicy {
fn default() -> Self {
Self {
limit: DEFAULT_WAIT_LIMIT,
poll_interval: crate::image_service_builds::BUILD_POLL_INTERVAL,
}
}
}
#[derive(Debug, Clone)]
pub(crate) struct RegistrationWait {
pub(crate) policy: RegistrationWaitPolicy,
pub(crate) started: Instant,
pub(crate) deadline: Instant,
pub(crate) build_id: Option<String>,
}
impl RegistrationWait {
pub(crate) fn new(policy: RegistrationWaitPolicy) -> Self {
let started = Instant::now();
Self {
policy,
started,
deadline: started + policy.limit,
build_id: None,
}
}
pub(crate) fn timeout(&self, request_id: &str) -> ImageBuildError {
ImageBuildError::Timeout {
build_id: self
.build_id
.clone()
.unwrap_or_else(|| format!("(request {request_id})")),
waited: self.started.elapsed(),
}
}
}
#[derive(Clone)]
pub struct SandboxImageCatalog {
templates: SandboxTemplatesClient,
image_service: ImageServiceCatalog,
}
impl SandboxImageCatalog {
pub fn new(client: Client, api_url: &str, scope: Option<(String, String)>) -> Self {
let image_service = ImageServiceCatalog::new(&client, api_url);
let templates = match scope {
Some((organization_id, project_id)) => {
SandboxTemplatesClient::new(client, organization_id, project_id)
}
None => SandboxTemplatesClient::new_api_key_scoped(client),
};
Self {
templates,
image_service,
}
}
pub fn from_credentials(
api_url: &str,
bearer_token: &str,
use_scope_headers: bool,
organization_id: Option<&str>,
project_id: Option<&str>,
user_agent: Option<&str>,
) -> Result<Self, SdkError> {
let scope = if use_scope_headers {
match (organization_id, project_id) {
(Some(organization_id), Some(project_id)) => {
Some((organization_id.to_string(), project_id.to_string()))
}
_ => {
return Err(SdkError::ClientError(
"organization and project IDs are required with personal access token \
authentication"
.to_string(),
));
}
}
} else {
None
};
let client = client_builder(
api_url,
bearer_token,
use_scope_headers,
organization_id,
project_id,
user_agent,
)
.build()?;
Ok(Self::new(client, api_url, scope))
}
pub fn image_service(&self) -> &ImageServiceCatalog {
&self.image_service
}
pub fn templates(&self) -> &SandboxTemplatesClient {
&self.templates
}
pub async fn find(&self, reference: &str) -> Result<Option<SandboxTemplate>, SdkError> {
match classify_image_reference(reference)? {
ImageReference::TemplateId(id) => {
if let Some(template) = self.templates.get_by_id(&id).await? {
return Ok(Some(template.into_inner()));
}
self.find_by_name(&id).await
}
ImageReference::ImageServiceId(id) => {
if let Some(image) = self.image_service.get_by_id(&id).await? {
return Ok(Some(image));
}
self.find_by_name(&id).await
}
ImageReference::Name(name) => self.find_by_name(&name).await,
}
}
async fn find_by_name(&self, name: &str) -> Result<Option<SandboxTemplate>, SdkError> {
let cas_name = canonical_cas_image_name(name);
if validate_image_service_name(&cas_name).is_ok()
&& let Some(image) = self.image_service.get_by_name(&cas_name).await?
{
return Ok(Some(image));
}
Ok(self
.templates
.find_by_name(name)
.await?
.map(Traced::into_inner))
}
pub async fn delete(&self, reference: &str) -> Result<(), SdkError> {
self.delete_reporting(reference).await.map(|_| ())
}
pub async fn delete_reporting(&self, reference: &str) -> Result<ImageDeletion, SdkError> {
let deleted = match classify_image_reference(reference)? {
ImageReference::TemplateId(id) => {
if self.templates.delete_by_id(&id).await? {
Some(ImageDeletion::only(DeletedImageFamily::Legacy))
} else {
self.delete_by_name(&id).await?
}
}
ImageReference::ImageServiceId(id) => {
if self.image_service.delete_by_id(&id).await? {
Some(ImageDeletion::only(DeletedImageFamily::Cas))
} else {
self.delete_by_name(&id).await?
}
}
ImageReference::Name(name) => self.delete_by_name(&name).await?,
};
deleted.ok_or_else(|| SdkError::ServerError {
status: StatusCode::NOT_FOUND,
message: format!("image '{}' not found", reference.trim()),
})
}
async fn delete_by_name(&self, name: &str) -> Result<Option<ImageDeletion>, SdkError> {
let cas_name = canonical_cas_image_name(name);
if validate_image_service_name(&cas_name).is_ok()
&& self.image_service.delete_by_name(&cas_name).await?
{
return Ok(Some(ImageDeletion {
family: DeletedImageFamily::Cas,
same_named_legacy: self.delete_same_named_legacy_image(&cas_name).await,
}));
}
Ok(self
.templates
.delete_by_name(name)
.await?
.then(|| ImageDeletion::only(DeletedImageFamily::Legacy)))
}
async fn delete_same_named_legacy_image(&self, name: &str) -> Option<LegacyImageDeletion> {
let template = match self.templates.find_by_name(name).await {
Ok(template) => template?.into_inner(),
Err(error) => {
return Some(LegacyImageDeletion::Failed {
name: name.to_string(),
id: None,
error,
});
}
};
let deleted = match template.id.as_deref() {
Some(id) => self.templates.delete_by_id(id).await,
None => self.templates.delete_by_name(name).await,
};
match deleted {
Ok(true) => Some(LegacyImageDeletion::Deleted {
name: name.to_string(),
id: template.id,
}),
Ok(false) => None,
Err(error) => Some(LegacyImageDeletion::Failed {
name: name.to_string(),
id: template.id,
error,
}),
}
}
pub async fn list(&self) -> Result<Vec<SandboxTemplate>, SdkError> {
let (templates, images) =
tokio::try_join!(self.templates.list(), self.image_service.list_all())?;
let mut all = templates.into_inner();
all.extend(images);
sort_merged_images(&mut all);
Ok(all)
}
}
#[cfg(test)]
mod tests {
use super::*;
const CAS_IMAGE_NAME_CASES: &[(&str, &str)] = &[
("app", "app"),
("MyProject", "myproject"),
("App:V1", "app:v1"),
("app.v2", "app.v2"),
("My Project", "my-project"),
("my project", "my-project"),
("my__app", "my_app"),
("-app-", "app"),
("._app_.", "app"),
("\u{dc}n\u{ef}code", "n-code"),
("\u{65e5}\u{672c}", "sandbox-image"),
("", "sandbox-image"),
("...", "sandbox-image"),
("image_foo", "sandbox-image"),
("sandbox_template_x", "sandbox-image"),
(
"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
"sandbox-image",
),
];
#[test]
fn cas_image_name_from_follows_the_shared_rule() {
for (raw, expected) in CAS_IMAGE_NAME_CASES {
assert_eq!(
cas_image_name_from(raw, "sandbox-image"),
*expected,
"{raw:?}"
);
}
let long = format!("{}-bc", "a".repeat(254));
assert_eq!(cas_image_name_from(&long, "sandbox-image"), "a".repeat(254));
}
#[test]
fn generated_cas_image_names_are_valid_and_already_canonical() {
for (raw, _) in CAS_IMAGE_NAME_CASES {
let name = cas_image_name_from(raw, "sandbox-image");
assert!(validate_image_service_name(&name).is_ok(), "{name:?}");
assert_eq!(canonical_cas_image_name(&name), name, "{name:?}");
assert_eq!(
classify_image_reference(&name).unwrap(),
ImageReference::Name(name.clone())
);
}
}
#[test]
fn canonical_cas_image_names_lowercase_ascii_only() {
assert_eq!(canonical_cas_image_name("Team/App:V1"), "team/app:v1");
assert_eq!(canonical_cas_image_name("myproject"), "myproject");
assert_eq!(canonical_cas_image_name("\u{c9}t\u{c9}"), "\u{c9}t\u{c9}");
}
#[test]
fn failed_legacy_cleanup_reports_only_a_failed_legacy_delete() {
let failed = ImageDeletion {
family: DeletedImageFamily::Cas,
same_named_legacy: Some(LegacyImageDeletion::Failed {
name: "app".to_string(),
id: Some("sandbox_template_1".to_string()),
error: SdkError::ServerError {
status: StatusCode::CONFLICT,
message: "retry the delete".to_string(),
},
}),
};
let (name, id, error) = failed.failed_legacy_cleanup().unwrap();
assert_eq!(name, "app");
assert_eq!(id, Some("sandbox_template_1"));
assert!(error.to_string().contains("retry the delete"), "{error}");
let deleted = ImageDeletion {
family: DeletedImageFamily::Cas,
same_named_legacy: Some(LegacyImageDeletion::Deleted {
name: "app".to_string(),
id: None,
}),
};
assert!(deleted.failed_legacy_cleanup().is_none());
assert!(
ImageDeletion::only(DeletedImageFamily::Legacy)
.failed_legacy_cleanup()
.is_none()
);
}
fn template(name: &str, created_at: Option<&str>, format: &str) -> SandboxTemplate {
SandboxTemplate {
name: Some(name.to_string()),
created_at: created_at.map(str::to_string),
snapshot_format_version: Some(format.to_string()),
..Default::default()
}
}
#[test]
fn references_dispatch_by_prefix_and_digests_are_refused() {
assert_eq!(
classify_image_reference("sandbox_template_abc").unwrap(),
ImageReference::TemplateId("sandbox_template_abc".to_string())
);
assert_eq!(
classify_image_reference(" image_abc123 ").unwrap(),
ImageReference::ImageServiceId("image_abc123".to_string())
);
assert_eq!(
classify_image_reference("team/app:v1").unwrap(),
ImageReference::Name("team/app:v1".to_string())
);
for digest in [format!("cas-v1:{}", "a".repeat(64)), "a".repeat(64)] {
let error = classify_image_reference(&digest).unwrap_err().to_string();
assert!(
error.contains("use the image name or its image_ id"),
"{error}"
);
}
assert!(classify_image_reference(" ").is_err());
}
#[test]
fn reserved_prefixes_are_not_names() {
assert!(validate_registered_name("image_x").is_err());
assert!(validate_registered_name("sandbox_template_x").is_err());
assert!(validate_registered_name(&format!("cas-v1:{}", "a".repeat(64))).is_err());
assert!(validate_registered_name("MyImage").is_ok());
assert!(validate_registered_name("team/app:v1").is_ok());
}
#[test]
fn image_service_grammar_routes_only_lowercase_names() {
for name in [
"team/app",
"team/app:v1.2-rc",
"python",
"ghcr.io/org/app:v1",
] {
assert!(validate_image_service_name(name).is_ok(), "{name}");
}
for name in [
"MyImage",
"team//app",
"-leading",
"team/app:.tag",
"a b",
"image_abc",
"sandbox_template_abc",
] {
assert!(validate_image_service_name(name).is_err(), "{name}");
}
assert!(is_image_service_id("image_abc123"));
assert!(!is_image_service_id("image_"));
assert!(!is_image_service_id("image_ABC"));
assert!(!is_image_service_id("sandbox_template_x"));
}
#[test]
fn created_at_parses_rfc3339_and_epoch_numbers() {
let rfc = created_at_sort_key(Some("2026-10-15T00:00:00.000Z")).unwrap();
assert_eq!(rfc.timestamp(), 1_792_022_400);
assert_eq!(
created_at_sort_key(Some("1792022400")).unwrap().timestamp(),
1_792_022_400
);
assert_eq!(
created_at_sort_key(Some("1792022400000"))
.unwrap()
.timestamp(),
1_792_022_400
);
assert_eq!(created_at_sort_key(Some("not a time")), None);
assert_eq!(created_at_sort_key(None), None);
}
#[test]
fn merged_listing_sorts_newest_then_name_then_cas_first() {
let mut images = vec![
template("zeta", Some("2026-10-14T00:00:00Z"), "durable_archive_v1"),
template("alpha", Some("2026-10-15T00:00:00Z"), "durable_archive_v1"),
template(
"alpha",
Some("2026-10-15T00:00:00Z"),
CAS_SNAPSHOT_FORMAT_VERSION,
),
template("beta", None, "durable_archive_v1"),
template("beta", Some("2026-10-15T00:00:00Z"), "durable_archive_v1"),
];
sort_merged_images(&mut images);
let order: Vec<(String, bool)> = images
.iter()
.map(|image| (image.name.clone().unwrap(), is_cas_image(image)))
.collect();
assert_eq!(
order,
vec![
("alpha".to_string(), true),
("alpha".to_string(), false),
("beta".to_string(), false),
("zeta".to_string(), false),
("beta".to_string(), false),
]
);
}
#[test]
fn image_service_records_map_onto_the_template_shape() {
let image: ImageServiceImage = serde_json::from_value(serde_json::json!({
"id": "image_abc",
"name": "team/app",
"snapshot_id": "snap123",
"global": true,
"physical_size_bytes": 42,
"logical_size_bytes": 10_737_418_240_u64,
"created_at": "2026-10-15T00:00:00.000Z",
"updated_at": "2026-10-15T00:00:00.000Z",
}))
.unwrap();
let template: SandboxTemplate = image.into();
let json = serde_json::to_value(&template).unwrap();
assert_eq!(
json,
serde_json::json!({
"id": "image_abc",
"name": "team/app",
"snapshotId": "snap123",
"snapshotSandboxId": null,
"snapshotUri": "snapshot://snap123",
"snapshotFormatVersion": CAS_SNAPSHOT_FORMAT_VERSION,
"snapshotSizeBytes": 42,
"rootfsDiskBytes": 10_737_418_240_u64,
"rootfsNodeKind": "base",
"public": true,
"dockerfile": "",
"createdAt": "2026-10-15T00:00:00.000Z",
"updatedAt": "2026-10-15T00:00:00.000Z",
}),
"no imageId or buildId extras"
);
assert!(is_cas_image(&template));
assert!(
serde_json::from_value::<ImageServiceImage>(serde_json::json!({
"id": "image_abc",
"name": "team/app",
"snapshot_id": "snap123",
"public": true,
"rootfs_disk_bytes": 10_737_418_240_u64,
}))
.is_err()
);
}
#[test]
fn image_service_error_bodies_reduce_to_their_message() {
let error = tidy_error(SdkError::ServerError {
status: StatusCode::CONFLICT,
message: r#"{"error":"image is being deleted"}"#.to_string(),
});
assert!(error.to_string().contains("image is being deleted"));
assert!(!error.to_string().contains('{'));
let plain = tidy_error(SdkError::Authorization("Forbidden".to_string()));
assert!(plain.to_string().contains("Forbidden"));
}
}