use crate::permissions::{ManagementPermissions, PermissionProfile, PermissionsConfig};
use crate::{
Platform, Resource, ResourceLifecycle, ResourceRef, ResourceType, StackInputDefinition,
};
use bon::Builder;
use indexmap::IndexMap;
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use std::collections::BTreeMap;
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
#[serde(rename_all = "camelCase")]
pub struct ResourceEntry {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
pub config: Resource,
pub lifecycle: ResourceLifecycle,
pub dependencies: Vec<ResourceRef>,
#[serde(default)]
pub remote_access: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub enabled_when: Option<String>,
}
impl ResourceEntry {
pub fn new<T: crate::ResourceDefinition>(resource: T, lifecycle: ResourceLifecycle) -> Self {
StackBuilder::entry(resource, lifecycle)
}
pub fn display_name(mut self, name: impl Into<String>) -> Self {
self.display_name = Some(name.into());
self
}
pub fn description(mut self, description: impl Into<String>) -> Self {
self.description = Some(description.into());
self
}
pub fn display_name_or_id(&self) -> &str {
self.display_name
.as_deref()
.unwrap_or_else(|| self.config.id())
}
pub fn combined_dependencies(&self) -> Vec<ResourceRef> {
let mut dependencies = self.config.get_dependencies();
dependencies.extend(self.dependencies.clone());
dependencies
}
pub fn has_remote_bindings(&self) -> bool {
crate::remote_bindings::remote_binding_for_entry(self).is_some()
}
pub fn publishes_binding_params(&self) -> bool {
self.remote_access
|| self
.config
.downcast_ref::<crate::Vault>()
.is_some_and(|vault| {
matches!(
vault.id.as_str(),
crate::SECRETS_VAULT_ID | crate::DEPLOYER_SECRETS_VAULT_ID
)
})
}
}
#[derive(Builder, Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
#[serde(rename_all = "camelCase")]
#[builder(start_fn = new)]
pub struct Stack {
#[builder(start_fn)]
pub id: String,
#[builder(field)]
pub resources: IndexMap<String, ResourceEntry>,
#[builder(field)]
#[serde(default)]
pub permissions: PermissionsConfig,
#[builder(field)]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub supported_platforms: Option<Vec<Platform>>,
#[builder(field)]
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub inputs: Vec<StackInputDefinition>,
#[builder(field)]
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub dynamic_container_repositories: Vec<String>,
#[builder(field)]
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub dynamic_container_image_resources: Vec<String>,
#[builder(field)]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub operations: Option<crate::OperationsConfig>,
#[builder(field)]
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub built_architectures: BTreeMap<String, Vec<crate::instance_catalog::Architecture>>,
#[builder(field)]
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub extensions: Vec<crate::ExtensionManifest>,
}
impl Stack {
pub fn built_architectures_of(
&self,
resource_id: &str,
) -> &[crate::instance_catalog::Architecture] {
self.built_architectures
.get(resource_id)
.map(Vec::as_slice)
.unwrap_or_default()
}
pub fn application_vault_ids(&self) -> Vec<String> {
self.resources()
.filter(|(_, entry)| entry.config.resource_type() == crate::Vault::RESOURCE_TYPE)
.map(|(id, _)| id.clone())
.filter(|id| id != crate::SECRETS_VAULT_ID && id != crate::DEPLOYER_SECRETS_VAULT_ID)
.collect()
}
pub fn queue_visibility_timeout_seconds(&self, queue_id: &str) -> u32 {
self.resources
.values()
.filter_map(|entry| {
let worker = entry.config.downcast_ref::<crate::Worker>()?;
worker
.triggers
.iter()
.filter_map(|trigger| match trigger {
crate::WorkerTrigger::Queue { queue, batch } if queue.id == queue_id => {
Some(worker.timeout_seconds.saturating_mul(6).saturating_add(
batch.as_ref().map_or(0, |batch| batch.max_window_seconds),
))
}
_ => None,
})
.max()
})
.max()
.unwrap_or(30)
.clamp(30, 43_200)
}
pub fn container_linkers(&self, container_id: &str) -> Vec<ResourceRef> {
self.linkers(&ResourceRef::new(
crate::Container::RESOURCE_TYPE,
container_id,
))
}
pub fn linkers(&self, target: &ResourceRef) -> Vec<ResourceRef> {
self.resources
.iter()
.filter_map(|(id, entry)| {
let links = if let Some(resource) = entry.config.downcast_ref::<crate::Worker>() {
&resource.links
} else if let Some(resource) = entry.config.downcast_ref::<crate::Container>() {
&resource.links
} else if let Some(resource) = entry.config.downcast_ref::<crate::Daemon>() {
&resource.links
} else if let Some(resource) = entry.config.downcast_ref::<crate::Build>() {
&resource.links
} else if let Some(resource) = entry.config.downcast_ref::<crate::Sandbox>() {
&resource.links
} else {
return None;
};
links
.contains(target)
.then(|| ResourceRef::new(entry.config.resource_type(), id.clone()))
})
.collect()
}
pub fn setup_owned_digest(&self) -> String {
let (resources, live_sandbox_inputs) = self.setup_owned_projection();
let encoded = if live_sandbox_inputs.is_empty() {
serde_json::to_vec(&resources)
} else {
serde_json::to_vec(&(&resources, &live_sandbox_inputs))
}
.expect("canonical setup-owned projection always serializes");
format!("{:x}", Sha256::digest(encoded))
}
pub fn setup_owned_entry_digests(&self) -> BTreeMap<String, String> {
let (resources, live_sandbox_inputs) = self.setup_owned_projection();
resources
.iter()
.map(|(id, value)| {
let encoded = serde_json::to_vec(value).expect("canonical entry always serializes");
((*id).clone(), format!("{:x}", Sha256::digest(encoded)))
})
.chain(live_sandbox_inputs.iter().map(|(id, inputs)| {
let encoded =
serde_json::to_vec(inputs).expect("canonical inputs always serialize");
(
format!("{id}#setupInputs"),
format!("{:x}", Sha256::digest(encoded)),
)
}))
.collect()
}
fn setup_owned_projection(
&self,
) -> (
Vec<(&String, serde_json::Value)>,
Vec<(&String, Vec<(&'static str, serde_json::Value)>)>,
) {
let mut resources = self
.resources
.iter()
.filter(|(_, entry)| entry.lifecycle == ResourceLifecycle::Frozen)
.map(|(id, entry)| {
let mut value =
serde_json::to_value(entry).expect("resource entries always serialize to JSON");
let object = value.as_object_mut().expect("resource entry is an object");
object.remove("displayName");
object.remove("description");
if let Some(sandbox) = entry.config.downcast_ref::<crate::Sandbox>() {
value["config"]["egress"] = sandbox.setup_digest_value();
value["config"]
.as_object_mut()
.expect("resource config is an object")
.remove("defaultPolicy");
}
if entry
.config
.downcast_ref::<crate::AzureStorageAccount>()
.is_some()
{
if let Some(settings) = crate::AzureStorageAccount::setup_settings_digest(self)
{
value["azureStorageSettings"] = settings.into();
}
}
canonicalize_json(&mut value);
if entry.config.downcast_ref::<crate::Queue>().is_some()
&& self.resources.values().any(|consumer| {
consumer
.config
.downcast_ref::<crate::Worker>()
.is_some_and(|worker| worker.queue_batch_config(id).is_some())
})
{
value["queueBatchVisibilityTimeout"] =
self.queue_visibility_timeout_seconds(id).into();
}
if crate::queue_needs_project_push_subscriber(self, id) {
value["queueProjectPushSubscriber"] = true.into();
}
(id, value)
})
.collect::<Vec<_>>();
resources.sort_unstable_by(|(left, _), (right, _)| left.cmp(right));
let mut live_sandbox_inputs = self
.resources
.iter()
.filter(|(_, entry)| entry.lifecycle == ResourceLifecycle::Live)
.filter_map(|(id, entry)| {
let sandbox = entry.config.downcast_ref::<crate::Sandbox>()?;
let mut inputs = crate::sandbox_setup_inputs::comparable_aws_sandbox_setup_inputs(
self,
sandbox,
entry.lifecycle,
);
for (_, value) in &mut inputs {
canonicalize_json(value);
}
Some((id, inputs))
})
.collect::<Vec<_>>();
live_sandbox_inputs.sort_unstable_by_key(|(id, _)| *id);
(resources, live_sandbox_inputs)
}
pub fn setup_update_digest(&self) -> String {
let mut permissions = serde_json::to_value(&self.permissions)
.expect("permission profiles always serialize to JSON");
canonicalize_json(&mut permissions);
let encoded = serde_json::to_vec(&(self.setup_owned_digest(), permissions))
.expect("setup update projection always serializes");
format!("{:x}", Sha256::digest(encoded))
}
pub fn resources(&self) -> impl Iterator<Item = (&String, &ResourceEntry)> {
self.resources.iter()
}
pub fn resources_mut(&mut self) -> impl Iterator<Item = (&String, &mut ResourceEntry)> {
self.resources.iter_mut()
}
pub fn id(&self) -> &str {
&self.id
}
pub fn current() -> StackRef {
StackRef::Current
}
pub fn permissions(&self) -> &PermissionsConfig {
&self.permissions
}
pub fn permission_profiles(&self) -> &IndexMap<String, PermissionProfile> {
&self.permissions.profiles
}
pub fn management(&self) -> &ManagementPermissions {
&self.permissions.management
}
pub fn supported_platforms(&self) -> Option<&[Platform]> {
self.supported_platforms.as_deref()
}
pub fn inputs(&self) -> &[StackInputDefinition] {
&self.inputs
}
pub fn supports_platform(&self, platform: &Platform) -> bool {
match &self.supported_platforms {
Some(platforms) => platforms.contains(platform),
None => true,
}
}
pub fn descriptor(
&self,
resource_type: &ResourceType,
) -> Option<&crate::ResourceTypeDescriptor> {
self.defining_extension(resource_type)
.and_then(|extension| extension.resource_types.get(resource_type))
}
fn defining_extension(
&self,
resource_type: &ResourceType,
) -> Option<&crate::ExtensionManifest> {
if !crate::custom_resource::is_custom_resource_type(resource_type.as_ref()) {
return None;
}
self.extensions.iter().find(|extension| {
extension.owns(resource_type) && extension.resource_types.contains_key(resource_type)
})
}
pub fn check_setup_format(
&self,
resource_id: &str,
resource_type: &ResourceType,
format: crate::SetupFormat,
platform: Platform,
) -> crate::Result<()> {
let Some(extension) = self.defining_extension(resource_type) else {
return Ok(());
};
if extension.resource_types[resource_type]
.setup
.platforms(format)
.contains(&platform)
{
return Ok(());
}
Err(alien_error::AlienError::new(
crate::ErrorData::OperationNotSupported {
operation: format!("{format} setup"),
reason: format!(
"resource '{resource_id}' has type {resource_type} from extension '{}', which has no {format} emitter for it on {platform}, so {format} setup is off for every stack that uses it",
extension.name
),
},
))
}
}
fn canonicalize_json(value: &mut serde_json::Value) {
match value {
serde_json::Value::Array(values) => {
for value in values {
canonicalize_json(value);
}
}
serde_json::Value::Object(object) => {
let mut entries = std::mem::take(object).into_iter().collect::<Vec<_>>();
entries.sort_unstable_by(|(left, _), (right, _)| left.cmp(right));
for (key, mut value) in entries {
canonicalize_json(&mut value);
object.insert(key, value);
}
}
_ => {}
}
}
impl StackBuilder {
pub fn add_entry(self, entry: ResourceEntry) -> Self {
self.insert(entry)
}
pub fn add<T: crate::ResourceDefinition>(
self,
resource: T,
lifecycle: ResourceLifecycle,
) -> Self {
self.add_with_dependencies(resource, lifecycle, vec![])
}
pub fn add_with_dependencies<T: crate::ResourceDefinition>(
self,
resource: T,
lifecycle: ResourceLifecycle,
additional_dependencies: Vec<ResourceRef>,
) -> Self {
let mut entry = Self::entry(resource, lifecycle);
entry.dependencies = additional_dependencies;
self.insert(entry)
}
#[doc(hidden)]
pub fn add_enabled_when<T: crate::ResourceDefinition>(
self,
resource: T,
lifecycle: ResourceLifecycle,
input_id: impl Into<String>,
) -> Self {
let mut entry = Self::entry(resource, lifecycle);
entry.enabled_when = Some(input_id.into());
self.insert(entry)
}
pub fn add_with_remote_access<T: crate::ResourceDefinition>(
self,
resource: T,
lifecycle: ResourceLifecycle,
) -> Self {
let mut entry = Self::entry(resource, lifecycle);
entry.remote_access = true;
self.insert(entry)
}
fn entry<T: crate::ResourceDefinition>(
resource: T,
lifecycle: ResourceLifecycle,
) -> ResourceEntry {
ResourceEntry {
config: Resource::new(resource),
lifecycle,
dependencies: Vec::new(),
display_name: None,
description: None,
remote_access: false,
enabled_when: None,
}
}
fn insert(mut self, entry: ResourceEntry) -> Self {
self.resources.insert(entry.config.id().to_string(), entry);
self
}
pub fn permissions(mut self, permissions: PermissionsConfig) -> Self {
self.permissions = permissions;
self
}
pub fn permission(mut self, name: impl Into<String>, profile: PermissionProfile) -> Self {
self.permissions.profiles.insert(name.into(), profile);
self
}
pub fn platforms(mut self, platforms: Vec<Platform>) -> Self {
self.supported_platforms = Some(platforms);
self
}
pub fn inputs(mut self, inputs: Vec<StackInputDefinition>) -> Self {
self.inputs = inputs;
self
}
pub fn operations(mut self, operations: crate::OperationsConfig) -> Self {
self.operations = Some(operations);
self
}
pub fn management(mut self, management: ManagementPermissions) -> Self {
self.permissions.management = management;
self
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
#[serde(rename_all = "camelCase")]
pub enum StackRef {
Current,
External(String),
}
impl StackRef {
pub fn from_stack(stack: &Stack) -> Self {
StackRef::External(stack.id().to_string())
}
}
impl From<&Stack> for StackRef {
fn from(stack: &Stack) -> Self {
StackRef::External(stack.id().to_string())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::resource::ResourceLifecycle;
use crate::{
Container, ContainerCode, Daemon, DaemonCode, PermissionSetReference, ResourceSpec,
Storage, Worker, WorkerCode,
};
use insta::assert_json_snapshot;
fn resource_entry<T: crate::ResourceDefinition>(
resource: T,
lifecycle: ResourceLifecycle,
remote_access: bool,
) -> ResourceEntry {
ResourceEntry {
config: Resource::new(resource),
lifecycle,
dependencies: Vec::new(),
display_name: None,
description: None,
remote_access,
enabled_when: None,
}
}
#[test]
fn remote_bindings_require_a_setup_rendered_resource_and_opt_in() {
assert!(resource_entry(
Storage::new("archive".to_string()).build(),
ResourceLifecycle::Frozen,
true,
)
.has_remote_bindings());
assert!(!resource_entry(
Storage::new("archive".to_string()).build(),
ResourceLifecycle::Frozen,
false,
)
.has_remote_bindings());
assert!(!resource_entry(
Storage::new("archive".to_string()).build(),
ResourceLifecycle::Live,
true,
)
.has_remote_bindings());
let sandbox = crate::Sandbox::new("agents".to_string())
.code(crate::SandboxCode::Image {
image: "s3://alien-bundles/sandbox/bundle.zip".to_string(),
bundled_from: None,
})
.egress(crate::SandboxEgress::Allow)
.lifecycle(crate::SandboxLifecyclePolicy {
max_lifetime_seconds: None,
idle_pause_seconds: None,
..Default::default()
})
.build();
assert!(resource_entry(sandbox, ResourceLifecycle::Live, true).has_remote_bindings());
assert!(!resource_entry(
Worker::new("worker".to_string())
.code(WorkerCode::Image {
image: "example.com/worker:latest".to_string(),
})
.permissions("worker-execution".to_string())
.build(),
ResourceLifecycle::Frozen,
true,
)
.has_remote_bindings());
}
#[test]
fn test_stack_serialization() {
use crate::WorkerCode;
let storage = Storage::new("my-bucket".to_string())
.public_read(true)
.build();
let worker = Worker::new("my-worker".to_string())
.code(WorkerCode::Image {
image: "rust:latest".to_string(),
})
.permissions("execution".to_string())
.link(&storage)
.build();
let mut permissions = IndexMap::new();
let mut execution_profile = PermissionProfile::new();
execution_profile.0.insert(
"*".to_string(),
vec![
PermissionSetReference::from_name("storage/data-read"),
PermissionSetReference::from_name("storage/data-write"),
],
);
permissions.insert("execution".to_string(), execution_profile);
let stack_builder = Stack::new("test-stack".to_string())
.add(storage, ResourceLifecycle::Frozen)
.add(worker.clone(), ResourceLifecycle::Live);
let stack = stack_builder
.permissions(PermissionsConfig {
profiles: permissions,
management: ManagementPermissions::Auto,
})
.build();
let serialized_stack =
serde_json::to_string_pretty(&stack).expect("Failed to serialize stack");
let deserialized_stack: Stack =
serde_json::from_str(&serialized_stack).expect("Failed to deserialize stack");
assert_eq!(
stack, deserialized_stack,
"Original and deserialized stacks do not match."
);
let mut settings = insta::Settings::clone_current();
settings.set_sort_maps(true);
settings.bind(|| {
assert_json_snapshot!("stack_serialization_account_managed", stack);
});
}
#[test]
fn test_empty_stack_serialization() {
let stack_builder = Stack::new("empty-test-stack".to_string());
let stack = stack_builder
.permissions(PermissionsConfig::new()) .build();
let serialized_stack =
serde_json::to_string_pretty(&stack).expect("Failed to serialize empty stack");
let deserialized_stack: Stack =
serde_json::from_str(&serialized_stack).expect("Failed to deserialize empty stack");
assert_eq!(
stack, deserialized_stack,
"Original and deserialized empty stacks do not match."
);
let mut settings = insta::Settings::clone_current();
settings.set_sort_maps(true);
settings.bind(|| {
assert_json_snapshot!("empty_stack_serialization_account", stack);
});
}
#[test]
fn stack_deserializes_resources_without_public_endpoints() {
let container = Container::new("api".to_string())
.code(ContainerCode::Image {
image: "example.com/api:latest".to_string(),
})
.cpu(ResourceSpec {
min: "0.5".to_string(),
desired: "1".to_string(),
})
.memory(ResourceSpec {
min: "512Mi".to_string(),
desired: "1Gi".to_string(),
})
.port(8080)
.permissions("container-execution".to_string())
.build();
let daemon = Daemon::new("agent".to_string())
.code(DaemonCode::Image {
image: "example.com/agent:latest".to_string(),
})
.permissions("daemon-execution".to_string())
.build();
let worker = Worker::new("worker".to_string())
.code(WorkerCode::Image {
image: "example.com/worker:latest".to_string(),
})
.permissions("worker-execution".to_string())
.build();
let stack = Stack::new("legacy-stack".to_string())
.add(container, ResourceLifecycle::Live)
.add(daemon, ResourceLifecycle::Live)
.add(worker, ResourceLifecycle::Live)
.build();
let mut legacy_json = serde_json::to_value(stack).expect("stack should serialize");
for resource_id in ["api", "agent", "worker"] {
legacy_json
.pointer_mut(&format!("/resources/{resource_id}/config"))
.and_then(serde_json::Value::as_object_mut)
.expect("resource config should be an object")
.remove("publicEndpoints");
}
let stack: Stack =
serde_json::from_value(legacy_json).expect("legacy stack should deserialize");
let container = stack
.resources
.get("api")
.and_then(|entry| entry.config.downcast_ref::<Container>())
.expect("api should be a container");
assert!(container.public_endpoints.is_empty());
let daemon = stack
.resources
.get("agent")
.and_then(|entry| entry.config.downcast_ref::<Daemon>())
.expect("agent should be a daemon");
assert!(daemon.public_endpoints.is_empty());
let worker = stack
.resources
.get("worker")
.and_then(|entry| entry.config.downcast_ref::<Worker>())
.expect("worker should be a worker");
assert!(worker.public_endpoints.is_empty());
}
#[test]
fn test_stack_with_permissions() {
use crate::permissions::PermissionProfile;
use indexmap::IndexMap;
let storage = Storage::new("test-storage".to_string()).build();
let mut permission_profile = PermissionProfile::new();
permission_profile.0.insert(
"*".to_string(),
vec![PermissionSetReference::from_name("storage/data-read")],
);
let mut permissions = IndexMap::new();
permissions.insert("reader".to_string(), permission_profile);
let stack = Stack::new("test-permissions-stack".to_string())
.add(storage, ResourceLifecycle::Frozen)
.permissions(PermissionsConfig {
profiles: permissions,
management: ManagementPermissions::Auto,
})
.build();
assert_eq!(stack.permission_profiles().len(), 1);
assert!(stack.permission_profiles().contains_key("reader"));
let reader_profile = stack.permission_profiles().get("reader").unwrap();
assert_eq!(reader_profile.0.len(), 1);
assert!(reader_profile.0.contains_key("*"));
let global_permissions = reader_profile.0.get("*").unwrap();
assert_eq!(
global_permissions,
&vec![PermissionSetReference::from_name("storage/data-read")]
);
let serialized = serde_json::to_string_pretty(&stack).expect("Failed to serialize");
let deserialized: Stack = serde_json::from_str(&serialized).expect("Failed to deserialize");
assert_eq!(stack, deserialized);
}
#[test]
fn test_stack_with_management_permissions() {
use crate::permissions::{ManagementPermissions, PermissionProfile};
let storage = Storage::new("test-storage".to_string()).build();
let mut management_profile = PermissionProfile::new();
management_profile.0.insert(
"*".to_string(),
vec![PermissionSetReference::from_name("vault/data-write")],
);
let stack_auto = Stack::new("test-auto-management-stack".to_string())
.add(storage.clone(), ResourceLifecycle::Frozen)
.management(ManagementPermissions::auto())
.build();
assert!(stack_auto.management().is_auto());
assert!(stack_auto.management().profile().is_none());
let stack_extend = Stack::new("test-extend-management-stack".to_string())
.add(storage.clone(), ResourceLifecycle::Frozen)
.management(ManagementPermissions::extend(management_profile.clone()))
.build();
assert!(stack_extend.management().is_extend());
assert_eq!(
stack_extend.management().profile().unwrap(),
&management_profile
);
let stack_override = Stack::new("test-override-management-stack".to_string())
.add(storage.clone(), ResourceLifecycle::Frozen)
.management(ManagementPermissions::override_(management_profile.clone()))
.build();
assert!(stack_override.management().is_override());
assert_eq!(
stack_override.management().profile().unwrap(),
&management_profile
);
let stack_default = Stack::new("test-default-management-stack".to_string())
.add(storage, ResourceLifecycle::Frozen)
.build();
assert!(stack_default.management().is_auto());
let serialized = serde_json::to_string_pretty(&stack_extend).expect("Failed to serialize");
let deserialized: Stack = serde_json::from_str(&serialized).expect("Failed to deserialize");
assert_eq!(stack_extend, deserialized);
}
fn dead_letter_stack(with_worker: bool, worker_lifecycle: ResourceLifecycle) -> Stack {
use crate::{Queue, QueueDeadLetter, Worker, WorkerCode, WorkerTrigger};
let failed = Queue::new("failed".to_string()).build();
let tasks = Queue::new("tasks".to_string())
.dead_letter(
QueueDeadLetter::builder()
.queue(ResourceRef::new(Queue::RESOURCE_TYPE, "failed"))
.build(),
)
.build();
let mut stack = Stack::new("dlq".to_string())
.add(failed, ResourceLifecycle::Frozen)
.add(tasks.clone(), ResourceLifecycle::Frozen);
if with_worker {
stack = stack.add(
Worker::new("consumer".to_string())
.code(WorkerCode::Image {
image: "img".to_string(),
})
.permissions("execution".to_string())
.trigger(WorkerTrigger::queue(&tasks))
.build(),
worker_lifecycle,
);
}
stack.build()
}
#[test]
fn a_live_worker_trigger_on_a_frozen_dead_letter_queue_changes_the_setup_digest() {
let without = dead_letter_stack(false, ResourceLifecycle::Live);
let with = dead_letter_stack(true, ResourceLifecycle::Live);
assert_ne!(without.setup_update_digest(), with.setup_update_digest());
assert_ne!(without.setup_owned_digest(), with.setup_owned_digest());
}
#[test]
fn the_dead_letter_queue_digest_is_unchanged_when_no_project_grant_is_needed() {
let plain_stack = dead_letter_stack(false, ResourceLifecycle::Live);
let (plain, _) = plain_stack.setup_owned_projection();
assert!(plain
.iter()
.all(|(_, v)| v.get("queueProjectPushSubscriber").is_none()));
let frozen_stack = dead_letter_stack(true, ResourceLifecycle::Frozen);
let (frozen_worker, _) = frozen_stack.setup_owned_projection();
assert!(frozen_worker
.iter()
.all(|(_, v)| v.get("queueProjectPushSubscriber").is_none()));
let live_stack = dead_letter_stack(true, ResourceLifecycle::Live);
let (live_worker, _) = live_stack.setup_owned_projection();
assert!(live_worker
.iter()
.any(|(id, v)| *id == "tasks" && v["queueProjectPushSubscriber"] == true));
assert!(live_worker
.iter()
.filter(|(id, _)| *id != "tasks")
.all(|(_, v)| v.get("queueProjectPushSubscriber").is_none()));
}
#[test]
fn presentation_metadata_preserves_setup_fingerprints_and_old_entries() {
let original = Stack::new("metadata".to_string())
.add(
Storage::new("documents".to_string()).build(),
ResourceLifecycle::Frozen,
)
.build();
let mut documented = original.clone();
let entry = documented.resources.get_mut("documents").unwrap();
entry.display_name = Some("Document storage".to_string());
entry.description = Some("Uploaded documents and processed results.".to_string());
assert_eq!(
original.setup_owned_digest(),
documented.setup_owned_digest()
);
assert_eq!(
original.setup_update_digest(),
documented.setup_update_digest()
);
assert_eq!(
original.resources["documents"].config,
documented.resources["documents"].config
);
let old_json = serde_json::to_value(&original).unwrap();
assert!(old_json["resources"]["documents"]
.get("displayName")
.is_none());
let loaded: Stack = serde_json::from_value(old_json).unwrap();
assert_eq!(
loaded.resources["documents"].display_name_or_id(),
"documents"
);
assert!(loaded.resources["documents"].description.is_none());
let round_trip: Stack =
serde_json::from_value(serde_json::to_value(&documented).unwrap()).unwrap();
assert_eq!(round_trip, documented);
}
fn digest_sandbox(id: &str, image: &str, private_base_image: Option<&str>) -> crate::Sandbox {
crate::Sandbox::new(id.to_string())
.code(crate::SandboxCode::Image {
image: image.to_string(),
bundled_from: None,
})
.maybe_private_base_image(private_base_image.map(str::to_string))
.egress(crate::SandboxEgress::None)
.lifecycle(crate::SandboxLifecyclePolicy {
max_lifetime_seconds: None,
idle_pause_seconds: None,
..Default::default()
})
.build()
}
#[test]
fn setup_owned_digest_is_stable_without_a_live_sandbox() {
let stack = Stack::new("golden".to_string())
.add(
Storage::new("ledger".to_string()).build(),
ResourceLifecycle::Frozen,
)
.add(
digest_sandbox(
"frozen-agents",
"s3://bucket/frozen.zip",
Some("123456789012.dkr.ecr.us-east-1.amazonaws.com/team/base:1"),
),
ResourceLifecycle::Frozen,
)
.add(
Storage::new("scratch".to_string()).build(),
ResourceLifecycle::Live,
)
.build();
assert_eq!(
stack.setup_owned_digest(),
"aacf34583a0bb9e3d48dd08be0bdd1da0f1d1e3666f93b844ecb0e1506ca537e"
);
}
struct LiveSandbox {
image: &'static str,
private_base_image: Option<&'static str>,
egress: crate::SandboxEgress,
network_id: &'static str,
remote_access: bool,
}
const BASE_A: &str = "123456789012.dkr.ecr.us-east-1.amazonaws.com/team/base-a:1";
impl LiveSandbox {
fn installed() -> Self {
Self {
image: "s3://bucket/sandbox-bundle/v1/bundle.zip",
private_base_image: Some(BASE_A),
egress: crate::SandboxEgress::Allow,
network_id: "net-a",
remote_access: false,
}
}
fn digest(self) -> String {
let mut sandbox = digest_sandbox("agents", self.image, self.private_base_image);
sandbox.egress = self.egress;
let mut stack = Stack::new("stack".to_string())
.add(
crate::Network::new(self.network_id.to_string())
.settings(crate::NetworkSettings::Create {
cidr: Some("10.0.0.0/16".to_string()),
availability_zones: 2,
})
.build(),
ResourceLifecycle::Frozen,
)
.add(sandbox, ResourceLifecycle::Live)
.build();
stack
.resources
.get_mut("agents")
.expect("sandbox")
.remote_access = self.remote_access;
let entry = &stack.resources["agents"];
crate::sandbox_setup_inputs::aws_sandbox_setup_inputs(
&stack,
entry.config.downcast_ref().expect("sandbox"),
entry.lifecycle,
crate::sandbox_setup_inputs::SETUP_INPUTS_COMPARISON_ACCOUNT,
)
.expect("the inputs resolve, so no case is compared by its whole configuration");
stack.setup_owned_digest()
}
}
#[test]
fn setup_owned_digest_follows_a_live_sandboxs_setup_inputs_but_not_its_image() {
let installed = LiveSandbox::installed().digest();
for (unchanged, why) in [
(
LiveSandbox {
image: "s3://bucket/sandbox-bundle/v2/bundle.zip",
..LiveSandbox::installed()
},
"a new bundle under the same prefix",
),
(
LiveSandbox {
private_base_image: Some(
"123456789012.dkr.ecr.us-east-1.amazonaws.com/team/base-a:2",
),
..LiveSandbox::installed()
},
"a new tag",
),
(
LiveSandbox {
private_base_image: Some(
"123456789012.dkr.ecr.us-east-1.amazonaws.com/team/base-a@sha256:abc",
),
..LiveSandbox::installed()
},
"a digest",
),
(
LiveSandbox {
private_base_image: Some(
"123456789012.dkr.ecr.us-east-1.amazonaws.com/team/base-b:1",
),
..LiveSandbox::installed()
},
"another repository",
),
(
LiveSandbox {
private_base_image: Some(
"210987654321.dkr.ecr.us-east-1.amazonaws.com/team/base-a:1",
),
..LiveSandbox::installed()
},
"another account",
),
(
LiveSandbox {
private_base_image: Some(
"123456789012.dkr.ecr.{region}.amazonaws.com/team/base-a:1",
),
..LiveSandbox::installed()
},
"the deployment's region",
),
(
LiveSandbox {
image: "s3://other-bucket/sandbox-bundle/v1/bundle.zip",
..LiveSandbox::installed()
},
"another bundle bucket",
),
] {
assert_eq!(
installed,
unchanged.digest(),
"{why} is the runtime's to roll: a Live sandbox builds from the store and repository its setup granted"
);
}
for (changed, what) in [
(
LiveSandbox {
private_base_image: None,
..LiveSandbox::installed()
},
"a dropped private base",
),
(
LiveSandbox {
egress: crate::SandboxEgress::None,
..LiveSandbox::installed()
},
"egress allow to deny",
),
(
LiveSandbox {
image: "s3://bucket/other-prefix/v1/bundle.zip",
..LiveSandbox::installed()
},
"another bundle prefix",
),
(
LiveSandbox {
remote_access: true,
..LiveSandbox::installed()
},
"a remote grant",
),
(
LiveSandbox {
private_base_image: Some(
"123456789012.dkr.ecr.us-east-1.amazonaws.com/cache/team/base-a:1",
),
..LiveSandbox::installed()
},
"a base repository in another namespace",
),
(
LiveSandbox {
private_base_image: Some(
"123456789012.dkr.ecr.us-east-1.amazonaws.com/base-a:1",
),
..LiveSandbox::installed()
},
"a base repository with no namespace",
),
] {
assert_ne!(installed, changed.digest(), "{what} is setup-owned");
}
let deny = |network_id| {
LiveSandbox {
egress: crate::SandboxEgress::None,
network_id,
..LiveSandbox::installed()
}
.digest()
};
assert_ne!(
deny("net-a"),
deny("net-b"),
"the connector's network is setup-owned"
);
}
#[test]
fn setup_owned_digest_is_order_independent() {
let first = Stack::new("first".to_string())
.add(
Storage::new("alpha".to_string()).build(),
ResourceLifecycle::Frozen,
)
.add(
Storage::new("beta".to_string()).build(),
ResourceLifecycle::Frozen,
)
.add(
Storage::new("live-one".to_string()).build(),
ResourceLifecycle::Live,
)
.build();
let second = Stack::new("second".to_string())
.add(
Storage::new("beta".to_string()).build(),
ResourceLifecycle::Frozen,
)
.add(
Storage::new("alpha".to_string()).build(),
ResourceLifecycle::Frozen,
)
.add(
Storage::new("live-two".to_string()).build(),
ResourceLifecycle::Live,
)
.build();
assert_eq!(first.setup_owned_digest(), second.setup_owned_digest());
assert_eq!(
first.setup_owned_entry_digests(),
second.setup_owned_entry_digests()
);
}
#[test]
fn setup_owned_entry_digests_name_only_the_changed_entries() {
let installed = Stack::new("stack".to_string())
.add(
Storage::new("alpha".to_string()).build(),
ResourceLifecycle::Frozen,
)
.add(
Storage::new("beta".to_string()).build(),
ResourceLifecycle::Frozen,
)
.add(
Storage::new("live".to_string()).build(),
ResourceLifecycle::Live,
)
.build();
let target = Stack::new("stack".to_string())
.add(
Storage::new("alpha".to_string()).build(),
ResourceLifecycle::Frozen,
)
.add(
Storage::new("beta".to_string()).versioning(true).build(),
ResourceLifecycle::Frozen,
)
.add(
Storage::new("live".to_string()).versioning(true).build(),
ResourceLifecycle::Live,
)
.build();
let installed_entries = installed.setup_owned_entry_digests();
let target_entries = target.setup_owned_entry_digests();
assert_ne!(installed.setup_owned_digest(), target.setup_owned_digest());
assert_eq!(
installed_entries.keys().collect::<Vec<_>>(),
vec!["alpha", "beta"]
);
assert_eq!(
installed_entries.keys().collect::<Vec<_>>(),
target_entries.keys().collect::<Vec<_>>()
);
assert_eq!(installed_entries["alpha"], target_entries["alpha"]);
assert_ne!(installed_entries["beta"], target_entries["beta"]);
assert!(installed_entries
.values()
.chain(target_entries.values())
.all(|digest| digest.len() == 64));
}
fn acme_manifest() -> serde_json::Value {
serde_json::json!({
"name": "acme",
"version": "0.1.0",
"digest": "sha256:4ff931a2",
"resourceTypes": {
"acme/dns-zone": {
"lifecycles": ["frozen", "live"],
"holdsData": false,
"setup": {
"cloudformation": ["aws"],
"terraform": ["aws", "gcp", "azure"],
"helm": ["kubernetes"],
"importers": ["aws", "gcp", "azure"]
},
"controllerPlatforms": ["aws", "gcp", "azure"],
"permissionSets": [{
"id": "acme/dns-zone/provision",
"description": "Create, read and delete the zone",
"platforms": {
"aws": [{
"grant": { "actions": ["route53:CreateHostedZone"] },
"binding": {
"stack": { "resources": ["*"] },
"resource": { "resources": ["*"] }
}
}]
}
}],
"link": { "permissionSets": ["acme/dns-zone/records-write"] },
"schemas": {
"config": { "type": "object", "required": ["id", "domain"] },
"outputs": { "type": "object", "required": ["zoneId"] }
}
}
}
})
}
fn dns_zone() -> crate::CustomResource {
crate::CustomResource::from_untagged(
"acme/dns-zone",
serde_json::json!({ "id": "zone", "domain": "internal.acme.dev" }),
)
.unwrap()
}
#[test]
fn a_stack_without_extensions_writes_no_extensions_field() {
let stack = Stack::new("app".to_string())
.add(dns_zone(), ResourceLifecycle::Frozen)
.build();
let json = serde_json::to_value(&stack).unwrap();
assert!(json.get("extensions").is_none(), "{json}");
assert_eq!(serde_json::from_value::<Stack>(json).unwrap(), stack);
}
#[test]
fn a_stack_carries_its_extensions_and_finds_the_types_they_define() {
let mut stack = Stack::new("app".to_string())
.add(dns_zone(), ResourceLifecycle::Frozen)
.build();
stack.extensions = vec![serde_json::from_value(acme_manifest()).unwrap()];
let json = serde_json::to_value(&stack).unwrap();
assert_eq!(json["extensions"], serde_json::json!([acme_manifest()]));
let stack: Stack = serde_json::from_value(json).unwrap();
let descriptor = stack
.descriptor(&ResourceType::from("acme/dns-zone"))
.expect("acme declares acme/dns-zone");
assert!(!descriptor.holds_data);
assert_eq!(
descriptor.lifecycles,
[ResourceLifecycle::Frozen, ResourceLifecycle::Live]
);
assert_eq!(
descriptor.link.permission_sets,
["acme/dns-zone/records-write"]
);
assert!(stack
.descriptor(&ResourceType::from("acme/record"))
.is_none());
}
#[test]
fn a_descriptor_writes_services_and_the_network_only_when_the_type_asks_for_them() {
let descriptor: crate::ResourceTypeDescriptor =
serde_json::from_value(acme_manifest()["resourceTypes"]["acme/dns-zone"].clone())
.unwrap();
assert!(descriptor.services.is_empty());
assert!(!descriptor.requires_network);
let json = serde_json::to_value(&descriptor).unwrap();
assert_eq!(json, acme_manifest()["resourceTypes"]["acme/dns-zone"]);
let mut asking = json;
asking["services"] = serde_json::json!({
"gcp": ["dns.googleapis.com"],
"azure": ["Microsoft.Network"]
});
asking["requiresNetwork"] = true.into();
let descriptor: crate::ResourceTypeDescriptor =
serde_json::from_value(asking.clone()).unwrap();
assert_eq!(
descriptor.services[&crate::Platform::Gcp],
["dns.googleapis.com"]
);
assert!(descriptor.requires_network);
assert_eq!(serde_json::to_value(&descriptor).unwrap(), asking);
}
#[test]
fn a_type_that_requires_the_network_keeps_one_like_a_database() {
let zone = crate::CustomResource::from_untagged(
"acme/dns-zone",
serde_json::json!({ "id": "zone", "domain": "internal.acme.dev" }),
)
.unwrap();
let mut stack = Stack::new("app".to_string())
.add(zone, ResourceLifecycle::Frozen)
.build();
let keeps = |stack: &Stack| {
stack
.resources()
.any(|(_, entry)| crate::keeps_cloud_network(stack, entry))
};
let mut manifest = acme_manifest();
stack.extensions = vec![serde_json::from_value(manifest.clone()).unwrap()];
assert!(!keeps(&stack));
manifest["resourceTypes"]["acme/dns-zone"]["requiresNetwork"] = true.into();
stack.extensions = vec![serde_json::from_value(manifest).unwrap()];
assert!(keeps(&stack));
}
#[test]
fn a_manifest_that_lists_a_built_in_type_does_not_describe_it() {
let mut manifest = acme_manifest();
let zone = manifest["resourceTypes"]["acme/dns-zone"].clone();
manifest["resourceTypes"]["storage"] = zone;
let mut stack = Stack::new("app".to_string()).build();
stack.extensions = vec![serde_json::from_value(manifest).unwrap()];
assert!(stack.descriptor(&Storage::RESOURCE_TYPE).is_none());
}
#[test]
fn a_type_listed_by_an_extension_of_another_name_has_no_descriptor() {
let mut evil = acme_manifest();
evil["name"] = "evil".into();
let mut stack = Stack::new("app".to_string()).build();
stack.extensions = vec![serde_json::from_value(evil).unwrap()];
let zone = ResourceType::from("acme/dns-zone");
assert!(stack.descriptor(&zone).is_none());
stack
.extensions
.push(serde_json::from_value(acme_manifest()).unwrap());
assert!(std::ptr::eq(
stack.descriptor(&zone).unwrap(),
&stack.extensions[1].resource_types[&zone]
));
}
}