Compare commits
11
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
433987413e | ||
|
|
5488eb73ec | ||
|
|
f9f8c625d1 | ||
|
|
6df6ffac4e | ||
|
|
2219a7217d | ||
|
|
cc612516a2 | ||
|
|
599dc1867b | ||
|
|
4e7440f25e | ||
|
|
e80d30ddb0 | ||
|
|
44774883a0 | ||
|
|
a0365bb80b |
No files matched your search
@@ -11,6 +11,12 @@ on:
|
||||
options: [story, feature]
|
||||
default: story
|
||||
required: true
|
||||
deploy_target:
|
||||
description: Deployment target for this run
|
||||
type: choice
|
||||
options: [none, production]
|
||||
default: none
|
||||
required: true
|
||||
push:
|
||||
branches:
|
||||
- main
|
||||
@@ -499,7 +505,7 @@ jobs:
|
||||
runs-on: ubuntu-latest
|
||||
needs:
|
||||
- required-checks
|
||||
if: ${{ gitea.event_name == 'push' && gitea.ref == 'refs/heads/main' }}
|
||||
if: ${{ gitea.event_name == 'workflow_dispatch' && gitea.ref == 'refs/heads/main' && inputs.validation_level == 'feature' && inputs.deploy_target == 'production' }}
|
||||
env:
|
||||
REGISTRY: git.itexp.me
|
||||
IMAGE_TAG: ${{ gitea.sha }}
|
||||
|
||||
Generated
+1
@@ -826,6 +826,7 @@ dependencies = [
|
||||
name = "crank-registry"
|
||||
version = "0.3.1"
|
||||
dependencies = [
|
||||
"async-trait",
|
||||
"crank-artifacts",
|
||||
"crank-core",
|
||||
"crank-mapping",
|
||||
|
||||
@@ -2,6 +2,10 @@
|
||||
mod admin_auth_command;
|
||||
#[path = "crank_migrate/db_connect.rs"]
|
||||
mod db_connect;
|
||||
#[path = "crank_migrate/reporting.rs"]
|
||||
mod reporting;
|
||||
|
||||
use reporting::{active_rotation, ensure_no_options, read_required_key_file, rotation_json};
|
||||
|
||||
use crank_config::{ConfigSource, parse_migrator};
|
||||
use crank_registry::{
|
||||
@@ -11,7 +15,7 @@ use crank_registry::{
|
||||
};
|
||||
use crank_runtime::SecretCrypto;
|
||||
use serde_json::json;
|
||||
use std::{path::Path, process::ExitCode};
|
||||
use std::process::ExitCode;
|
||||
use time::OffsetDateTime;
|
||||
const MASTER_KEY_ROTATION_PAGE_SIZE: i64 = 1_000;
|
||||
#[tokio::main]
|
||||
@@ -765,6 +769,59 @@ async fn process_rotation_batch(
|
||||
processed += 1;
|
||||
}
|
||||
}
|
||||
let mut after_task_id: Option<String> = None;
|
||||
loop {
|
||||
let tasks = registry
|
||||
.list_tasks_for_master_key_epoch_page(
|
||||
rotation.source_epoch,
|
||||
after_task_id.as_deref(),
|
||||
MASTER_KEY_ROTATION_PAGE_SIZE,
|
||||
)
|
||||
.await
|
||||
.map_err(CliError::from_registry)?;
|
||||
if tasks.is_empty() {
|
||||
break;
|
||||
}
|
||||
for task in tasks {
|
||||
after_task_id = Some(task.task_id.clone());
|
||||
if task.target_epoch == Some(rotation.target_epoch) {
|
||||
continue;
|
||||
}
|
||||
if max_versions.is_some_and(|limit| processed as usize >= limit) {
|
||||
return Ok(processed);
|
||||
}
|
||||
let plaintext = current_crypto
|
||||
.decrypt_for_epoch(&task.key_version, task.epoch, &task.ciphertext)
|
||||
.map_err(|_| {
|
||||
CliError::new(
|
||||
"master_key_rotation_verification_failed",
|
||||
"master_key.rotation",
|
||||
"rerun_rotation_or_abort",
|
||||
)
|
||||
})?;
|
||||
let target_ciphertext = target_crypto.encrypt(&plaintext).map_err(|_| {
|
||||
CliError::new(
|
||||
"master_key_rotation_verification_failed",
|
||||
"master_key.rotation",
|
||||
"rerun_rotation_or_abort",
|
||||
)
|
||||
})?;
|
||||
let now = OffsetDateTime::now_utc();
|
||||
registry
|
||||
.stage_master_key_rotation_task_ciphertext(
|
||||
&rotation.id,
|
||||
&task.task_id,
|
||||
rotation.source_epoch,
|
||||
&target_ciphertext,
|
||||
target_crypto.key_version(),
|
||||
rotation.target_epoch,
|
||||
&now,
|
||||
)
|
||||
.await
|
||||
.map_err(CliError::from_registry)?;
|
||||
processed += 1;
|
||||
}
|
||||
}
|
||||
Ok(processed)
|
||||
}
|
||||
|
||||
@@ -818,6 +875,47 @@ async fn verify_staged_targets(
|
||||
verified += 1;
|
||||
}
|
||||
}
|
||||
let mut after_task_id: Option<String> = None;
|
||||
loop {
|
||||
let tasks = registry
|
||||
.list_target_tasks_for_master_key_rotation_page(
|
||||
rotation.target_epoch,
|
||||
after_task_id.as_deref(),
|
||||
MASTER_KEY_ROTATION_PAGE_SIZE,
|
||||
)
|
||||
.await
|
||||
.map_err(CliError::from_registry)?;
|
||||
if tasks.is_empty() {
|
||||
break;
|
||||
}
|
||||
for task in tasks {
|
||||
after_task_id = Some(task.task_id.clone());
|
||||
let ciphertext = task.target_ciphertext.as_deref().ok_or_else(|| {
|
||||
CliError::new(
|
||||
"master_key_rotation_verification_failed",
|
||||
"master_key.rotation",
|
||||
"rerun_rotation_or_abort",
|
||||
)
|
||||
})?;
|
||||
let key_version = task.target_key_version.as_deref().ok_or_else(|| {
|
||||
CliError::new(
|
||||
"master_key_rotation_verification_failed",
|
||||
"master_key.rotation",
|
||||
"rerun_rotation_or_abort",
|
||||
)
|
||||
})?;
|
||||
target_crypto
|
||||
.decrypt_for_epoch(key_version, rotation.target_epoch, ciphertext)
|
||||
.map_err(|_| {
|
||||
CliError::new(
|
||||
"master_key_rotation_verification_failed",
|
||||
"master_key.rotation",
|
||||
"rerun_rotation_or_abort",
|
||||
)
|
||||
})?;
|
||||
verified += 1;
|
||||
}
|
||||
}
|
||||
if verified != rotation.total_secret_versions {
|
||||
return Err(CliError::new(
|
||||
"master_key_rotation_verification_failed",
|
||||
@@ -877,89 +975,3 @@ fn decrypt_current(
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
async fn active_rotation(
|
||||
registry: &PostgresRegistry,
|
||||
allowed_states: &[&str],
|
||||
) -> Result<Option<MasterKeyRotationRecord>, CliError> {
|
||||
let status = registry
|
||||
.master_key_rotation_status()
|
||||
.await
|
||||
.map_err(CliError::from_registry)?;
|
||||
Ok(status
|
||||
.rotations
|
||||
.into_iter()
|
||||
.find(|rotation| allowed_states.contains(&rotation.state.as_str())))
|
||||
}
|
||||
|
||||
fn rotation_json(rotation: &MasterKeyRotationRecord) -> serde_json::Value {
|
||||
json!({
|
||||
"id": rotation.id,
|
||||
"source_epoch": rotation.source_epoch,
|
||||
"target_epoch": rotation.target_epoch,
|
||||
"state": rotation.state,
|
||||
"backup_ref": rotation.backup_ref.as_ref().map(|_| "configured"),
|
||||
"checkpoint_secret_id": rotation.checkpoint_secret_id,
|
||||
"total_secret_versions": rotation.total_secret_versions,
|
||||
"processed_secret_versions": rotation.processed_secret_versions,
|
||||
"verified_secret_versions": rotation.verified_secret_versions,
|
||||
"failure_code": rotation.failure_code,
|
||||
})
|
||||
}
|
||||
|
||||
fn read_required_key_file(path: Option<&str>) -> Result<String, CliError> {
|
||||
let path = path.ok_or_else(|| {
|
||||
CliError::new("invalid_command", "cli.arguments", "run_master_key_status")
|
||||
})?;
|
||||
if path.len() > 512 || path.bytes().any(|byte| byte.is_ascii_control()) {
|
||||
return Err(CliError::new(
|
||||
"master_key_input_invalid",
|
||||
"master_key.input",
|
||||
"verify_operator_input",
|
||||
));
|
||||
}
|
||||
let metadata = std::fs::metadata(Path::new(path)).map_err(|_| {
|
||||
CliError::new(
|
||||
"master_key_input_invalid",
|
||||
"master_key.input",
|
||||
"verify_operator_input",
|
||||
)
|
||||
})?;
|
||||
if !metadata.is_file() || metadata.len() > 16_384 {
|
||||
return Err(CliError::new(
|
||||
"master_key_input_invalid",
|
||||
"master_key.input",
|
||||
"verify_operator_input",
|
||||
));
|
||||
}
|
||||
let value = std::fs::read_to_string(Path::new(path)).map_err(|_| {
|
||||
CliError::new(
|
||||
"master_key_input_invalid",
|
||||
"master_key.input",
|
||||
"verify_operator_input",
|
||||
)
|
||||
})?;
|
||||
if value.trim().is_empty() {
|
||||
return Err(CliError::new(
|
||||
"master_key_input_invalid",
|
||||
"master_key.input",
|
||||
"verify_operator_input",
|
||||
));
|
||||
}
|
||||
Ok(value)
|
||||
}
|
||||
fn ensure_no_options(options: &MasterKeyOptions) -> Result<(), CliError> {
|
||||
if options.current_key_file.is_some()
|
||||
|| options.target_key_file.is_some()
|
||||
|| options.backup_ref.is_some()
|
||||
|| options.rotation_id.is_some()
|
||||
|| options.max_versions.is_some()
|
||||
{
|
||||
return Err(CliError::new(
|
||||
"invalid_command",
|
||||
"cli.arguments",
|
||||
"run_master_key_status",
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,98 @@
|
||||
//! Leaf/reporting helpers of the migrator CLI.
|
||||
//!
|
||||
//! Extracted from `crank-migrate.rs` without behaviour changes so the binary entry stays within
|
||||
//! the code-health line limit.
|
||||
|
||||
use std::path::Path;
|
||||
|
||||
use crank_registry::{MasterKeyRotationRecord, PostgresRegistry};
|
||||
use serde_json::json;
|
||||
|
||||
use super::{CliError, MasterKeyOptions};
|
||||
|
||||
pub(super) async fn active_rotation(
|
||||
registry: &PostgresRegistry,
|
||||
allowed_states: &[&str],
|
||||
) -> Result<Option<MasterKeyRotationRecord>, CliError> {
|
||||
let status = registry
|
||||
.master_key_rotation_status()
|
||||
.await
|
||||
.map_err(CliError::from_registry)?;
|
||||
Ok(status
|
||||
.rotations
|
||||
.into_iter()
|
||||
.find(|rotation| allowed_states.contains(&rotation.state.as_str())))
|
||||
}
|
||||
|
||||
pub(super) fn rotation_json(rotation: &MasterKeyRotationRecord) -> serde_json::Value {
|
||||
json!({
|
||||
"id": rotation.id,
|
||||
"source_epoch": rotation.source_epoch,
|
||||
"target_epoch": rotation.target_epoch,
|
||||
"state": rotation.state,
|
||||
"backup_ref": rotation.backup_ref.as_ref().map(|_| "configured"),
|
||||
"checkpoint_secret_id": rotation.checkpoint_secret_id,
|
||||
"total_secret_versions": rotation.total_secret_versions,
|
||||
"processed_secret_versions": rotation.processed_secret_versions,
|
||||
"verified_secret_versions": rotation.verified_secret_versions,
|
||||
"failure_code": rotation.failure_code,
|
||||
})
|
||||
}
|
||||
|
||||
pub(super) fn read_required_key_file(path: Option<&str>) -> Result<String, CliError> {
|
||||
let path = path.ok_or_else(|| {
|
||||
CliError::new("invalid_command", "cli.arguments", "run_master_key_status")
|
||||
})?;
|
||||
if path.len() > 512 || path.bytes().any(|byte| byte.is_ascii_control()) {
|
||||
return Err(CliError::new(
|
||||
"master_key_input_invalid",
|
||||
"master_key.input",
|
||||
"verify_operator_input",
|
||||
));
|
||||
}
|
||||
let metadata = std::fs::metadata(Path::new(path)).map_err(|_| {
|
||||
CliError::new(
|
||||
"master_key_input_invalid",
|
||||
"master_key.input",
|
||||
"verify_operator_input",
|
||||
)
|
||||
})?;
|
||||
if !metadata.is_file() || metadata.len() > 16_384 {
|
||||
return Err(CliError::new(
|
||||
"master_key_input_invalid",
|
||||
"master_key.input",
|
||||
"verify_operator_input",
|
||||
));
|
||||
}
|
||||
let value = std::fs::read_to_string(Path::new(path)).map_err(|_| {
|
||||
CliError::new(
|
||||
"master_key_input_invalid",
|
||||
"master_key.input",
|
||||
"verify_operator_input",
|
||||
)
|
||||
})?;
|
||||
if value.trim().is_empty() {
|
||||
return Err(CliError::new(
|
||||
"master_key_input_invalid",
|
||||
"master_key.input",
|
||||
"verify_operator_input",
|
||||
));
|
||||
}
|
||||
Ok(value)
|
||||
}
|
||||
|
||||
pub(super) fn ensure_no_options(options: &MasterKeyOptions) -> Result<(), CliError> {
|
||||
if options.current_key_file.is_some()
|
||||
|| options.target_key_file.is_some()
|
||||
|| options.backup_ref.is_some()
|
||||
|| options.rotation_id.is_some()
|
||||
|| options.max_versions.is_some()
|
||||
{
|
||||
return Err(CliError::new(
|
||||
"invalid_command",
|
||||
"cli.arguments",
|
||||
"run_master_key_status",
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -181,6 +181,7 @@ mod tests {
|
||||
idempotency: None,
|
||||
safety: None,
|
||||
approval_policy: None,
|
||||
execution_policy: None,
|
||||
auth_profile_ref: None,
|
||||
headers: BTreeMap::new(),
|
||||
},
|
||||
|
||||
@@ -3,7 +3,7 @@ use std::{io, net::SocketAddr, process::ExitCode, time::Duration};
|
||||
use admin_api::{
|
||||
app::build_app,
|
||||
auth::{AuthSettings, BootstrapAdminConfig},
|
||||
pool_metrics::spawn_postgres_pool_metrics,
|
||||
pool_metrics::{spawn_admission_metrics, spawn_postgres_pool_metrics},
|
||||
reconciliation::{open_reconciliation_store, spawn_artifact_reconciliation},
|
||||
service::AdminServiceBuilder,
|
||||
state::AppState,
|
||||
@@ -169,6 +169,7 @@ async fn run(
|
||||
};
|
||||
if metrics_enabled {
|
||||
spawn_postgres_pool_metrics(registry.pool().clone());
|
||||
spawn_admission_metrics(registry.pool().clone());
|
||||
}
|
||||
let base_url = config
|
||||
.runtime
|
||||
@@ -214,6 +215,16 @@ async fn run(
|
||||
.with_limits(runtime_limits)
|
||||
.with_response_cache(cache_stores.response.clone())
|
||||
.with_coordination_store(cache_stores.coordination.clone())
|
||||
.with_admission(std::sync::Arc::new(
|
||||
crank_registry::PostgresExecutionAdmission::new(
|
||||
registry.pool().clone(),
|
||||
crank_registry::AdmissionLimits {
|
||||
global_limit: runtime_limits.max_concurrent_unary,
|
||||
..crank_registry::AdmissionLimits::default()
|
||||
},
|
||||
crank_core::AdmissionSchedulerConfig::default(),
|
||||
)?,
|
||||
))
|
||||
.build();
|
||||
let identity_provider =
|
||||
PasswordIdentityProvider::new(registry.clone(), auth_settings.password_pepper.clone());
|
||||
@@ -321,6 +332,12 @@ fn preflight_config(config: &AdminProcessConfig) -> Result<(), crank_config::Con
|
||||
config.runtime.max_concurrent_sessions,
|
||||
)
|
||||
.map_err(|_| invalid("runtime.limits"))?;
|
||||
crank_registry::AdmissionLimits {
|
||||
global_limit: config.runtime.max_concurrent_unary,
|
||||
..crank_registry::AdmissionLimits::default()
|
||||
}
|
||||
.validate()
|
||||
.map_err(|_| invalid("runtime.admission"))?;
|
||||
runtime_cache_config(config).map_err(|_| invalid("cache"))?;
|
||||
RequestRateLimitConfig::new(
|
||||
config.rate_limit.requests_per_second,
|
||||
|
||||
@@ -11,3 +11,17 @@ pub fn spawn_postgres_pool_metrics(pool: PgPool) -> tokio::task::JoinHandle<()>
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// Story 4.1: samples the authoritative admission queue so the oldest-waiting age grows (and returns
|
||||
/// to zero) without waiting for a new request.
|
||||
pub fn spawn_admission_metrics(pool: PgPool) -> tokio::task::JoinHandle<()> {
|
||||
tokio::spawn(async move {
|
||||
let mut interval = tokio::time::interval(Duration::from_secs(5));
|
||||
loop {
|
||||
interval.tick().await;
|
||||
if let Ok(snapshot) = crank_registry::admission_snapshot(&pool).await {
|
||||
crank_observability::record_admission_oldest_waiting(snapshot.oldest_waiting_ms);
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
@@ -37,13 +37,22 @@ pub async fn readiness(State(state): State<AppState>) -> impl IntoResponse {
|
||||
} else {
|
||||
"not_ready"
|
||||
};
|
||||
let execution_admission = if checks.execution_admission {
|
||||
"ready"
|
||||
} else {
|
||||
"not_ready"
|
||||
};
|
||||
if checks.is_ready() {
|
||||
(
|
||||
StatusCode::OK,
|
||||
Json(json!({
|
||||
"service": "admin-api",
|
||||
"status": "ready",
|
||||
"checks": { "postgres": postgres, "artifact_storage": artifact_storage }
|
||||
"checks": {
|
||||
"postgres": postgres,
|
||||
"artifact_storage": artifact_storage,
|
||||
"execution_admission": execution_admission
|
||||
}
|
||||
})),
|
||||
)
|
||||
} else {
|
||||
@@ -52,7 +61,11 @@ pub async fn readiness(State(state): State<AppState>) -> impl IntoResponse {
|
||||
Json(json!({
|
||||
"service": "admin-api",
|
||||
"status": "not_ready",
|
||||
"checks": { "postgres": postgres, "artifact_storage": artifact_storage }
|
||||
"checks": {
|
||||
"postgres": postgres,
|
||||
"artifact_storage": artifact_storage,
|
||||
"execution_admission": execution_admission
|
||||
}
|
||||
})),
|
||||
)
|
||||
}
|
||||
@@ -67,6 +80,7 @@ mod tests {
|
||||
let checks = ReadinessChecks {
|
||||
postgres: false,
|
||||
artifact_storage: true,
|
||||
execution_admission: true,
|
||||
};
|
||||
assert!(!checks.is_ready());
|
||||
assert_eq!(
|
||||
@@ -92,6 +106,7 @@ mod tests {
|
||||
let checks = ReadinessChecks {
|
||||
postgres: true,
|
||||
artifact_storage: false,
|
||||
execution_admission: true,
|
||||
};
|
||||
assert!(!checks.is_ready());
|
||||
assert_eq!(
|
||||
@@ -111,4 +126,14 @@ mod tests {
|
||||
"not_ready"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn readiness_checks_identify_an_admission_state_failure() {
|
||||
let checks = ReadinessChecks {
|
||||
postgres: true,
|
||||
artifact_storage: true,
|
||||
execution_admission: false,
|
||||
};
|
||||
assert!(!checks.is_ready());
|
||||
}
|
||||
}
|
||||
@@ -55,8 +55,8 @@ use crate::{
|
||||
storage::LocalArtifactStorage,
|
||||
};
|
||||
use operation_validation::{
|
||||
validate_approval_policy, validate_execution_timeout, validate_idempotency_policy,
|
||||
validate_protocol_target, validate_response_cache_policy,
|
||||
validate_approval_policy, validate_execution_policy, validate_execution_timeout,
|
||||
validate_idempotency_policy, validate_protocol_target, validate_response_cache_policy,
|
||||
};
|
||||
|
||||
#[derive(Clone)]
|
||||
@@ -104,11 +104,12 @@ pub use crate::dto::*;
|
||||
pub struct ReadinessChecks {
|
||||
pub postgres: bool,
|
||||
pub artifact_storage: bool,
|
||||
pub execution_admission: bool,
|
||||
}
|
||||
|
||||
impl ReadinessChecks {
|
||||
pub const fn is_ready(self) -> bool {
|
||||
self.postgres && self.artifact_storage
|
||||
self.postgres && self.artifact_storage && self.execution_admission
|
||||
}
|
||||
}
|
||||
|
||||
@@ -150,6 +151,8 @@ pub(super) struct CredentialAuditRecord<'a> {
|
||||
impl AdminService {
|
||||
pub async fn readiness(&self) -> ReadinessChecks {
|
||||
let postgres = self.registry.ping().await.is_ok();
|
||||
// Story 4.1: the mandatory admission state is a readiness dependency of every execution.
|
||||
let execution_admission = self.registry.execution_admission_health().await.is_ok();
|
||||
let store = Arc::clone(&self.artifact_store);
|
||||
let artifact_storage = tokio::task::spawn_blocking(move || store.check_health())
|
||||
.await
|
||||
@@ -157,6 +160,7 @@ impl AdminService {
|
||||
ReadinessChecks {
|
||||
postgres,
|
||||
artifact_storage,
|
||||
execution_admission,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -725,6 +729,7 @@ impl AdminService {
|
||||
validate_response_cache_policy(&payload.target, &payload.execution_config)?;
|
||||
validate_idempotency_policy(&payload.target, &payload.execution_config)?;
|
||||
validate_approval_policy(&payload.execution_config)?;
|
||||
validate_execution_policy(&payload.execution_config)?;
|
||||
payload.input_mapping.validate_paths()?;
|
||||
payload.output_mapping.validate_paths()?;
|
||||
Ok(())
|
||||
@@ -738,6 +743,7 @@ impl AdminService {
|
||||
validate_response_cache_policy(&operation.target, &operation.execution_config)?;
|
||||
validate_idempotency_policy(&operation.target, &operation.execution_config)?;
|
||||
validate_approval_policy(&operation.execution_config)?;
|
||||
validate_execution_policy(&operation.execution_config)?;
|
||||
operation.input_mapping.validate_paths()?;
|
||||
operation.output_mapping.validate_paths()?;
|
||||
Ok(())
|
||||
|
||||
@@ -441,6 +441,7 @@ fn demo_rest_operation_payload() -> OperationPayload {
|
||||
idempotency: None,
|
||||
safety: None,
|
||||
approval_policy: None,
|
||||
execution_policy: None,
|
||||
auth_profile_ref: None,
|
||||
headers: BTreeMap::new(),
|
||||
},
|
||||
|
||||
@@ -635,6 +635,7 @@ impl AdminService {
|
||||
idempotency: None,
|
||||
safety: None,
|
||||
approval_policy: None,
|
||||
execution_policy: None,
|
||||
auth_profile_ref: None,
|
||||
headers: BTreeMap::new(),
|
||||
},
|
||||
|
||||
@@ -610,6 +610,7 @@ impl AdminService {
|
||||
idempotency: None,
|
||||
safety: None,
|
||||
approval_policy: None,
|
||||
execution_policy: None,
|
||||
auth_profile_ref,
|
||||
headers: BTreeMap::new(),
|
||||
},
|
||||
|
||||
@@ -160,6 +160,23 @@ pub(super) fn validate_approval_policy(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(super) fn validate_execution_policy(
|
||||
execution_config: &crank_core::ExecutionConfig,
|
||||
) -> Result<(), ApiError> {
|
||||
let Some(policy) = execution_config.execution_policy.as_ref() else {
|
||||
return Ok(());
|
||||
};
|
||||
if let Err(error) = policy.validate() {
|
||||
return Err(ApiError::validation_with_context(
|
||||
error.to_string(),
|
||||
json!({
|
||||
"field": "execution_config.execution_policy.deadline_ms",
|
||||
}),
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::collections::BTreeMap;
|
||||
@@ -171,8 +188,8 @@ mod tests {
|
||||
};
|
||||
|
||||
use super::{
|
||||
validate_approval_policy, validate_execution_timeout, validate_idempotency_policy,
|
||||
validate_response_cache_policy,
|
||||
validate_approval_policy, validate_execution_policy, validate_execution_timeout,
|
||||
validate_idempotency_policy, validate_response_cache_policy,
|
||||
};
|
||||
|
||||
fn cacheable_execution_config() -> ExecutionConfig {
|
||||
@@ -183,6 +200,7 @@ mod tests {
|
||||
idempotency: None,
|
||||
safety: None,
|
||||
approval_policy: None,
|
||||
execution_policy: None,
|
||||
auth_profile_ref: None,
|
||||
headers: BTreeMap::new(),
|
||||
}
|
||||
@@ -201,6 +219,7 @@ mod tests {
|
||||
}),
|
||||
safety: None,
|
||||
approval_policy: None,
|
||||
execution_policy: None,
|
||||
auth_profile_ref: None,
|
||||
headers: BTreeMap::new(),
|
||||
}
|
||||
@@ -365,4 +384,36 @@ mod tests {
|
||||
"approval ttl must be between 1 and 300 seconds"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn accepts_published_execution_policy_and_absent_legacy_policy() {
|
||||
let mut config = cacheable_execution_config();
|
||||
validate_execution_policy(&config).unwrap();
|
||||
|
||||
config.execution_policy = Some(crank_core::ToolExecutionPolicy {
|
||||
mode: crank_core::ToolExecutionMode::Adaptive,
|
||||
deadline_ms: 120_000,
|
||||
no_tasks_fallback: crank_core::NoTasksFallback::Unsupported,
|
||||
});
|
||||
validate_execution_policy(&config).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_zero_and_overflowing_execution_policy_deadline() {
|
||||
let mut config = cacheable_execution_config();
|
||||
config.execution_policy = Some(crank_core::ToolExecutionPolicy {
|
||||
mode: crank_core::ToolExecutionMode::Synchronous,
|
||||
deadline_ms: 0,
|
||||
no_tasks_fallback: crank_core::NoTasksFallback::Synchronous,
|
||||
});
|
||||
let error = validate_execution_policy(&config).unwrap_err();
|
||||
assert!(matches!(error, crate::error::ApiError::Validation { .. }));
|
||||
|
||||
config.execution_policy = Some(crank_core::ToolExecutionPolicy {
|
||||
mode: crank_core::ToolExecutionMode::Background,
|
||||
deadline_ms: crank_core::MAX_TOOL_DEADLINE_MS + 1,
|
||||
no_tasks_fallback: crank_core::NoTasksFallback::Synchronous,
|
||||
});
|
||||
assert!(validate_execution_policy(&config).is_err());
|
||||
}
|
||||
}
|
||||
@@ -495,6 +495,7 @@ pub(super) fn test_operation_payload(base_url: &str, name: &str) -> OperationPay
|
||||
idempotency: None,
|
||||
safety: None,
|
||||
approval_policy: None,
|
||||
execution_policy: None,
|
||||
auth_profile_ref: None,
|
||||
headers: BTreeMap::new(),
|
||||
},
|
||||
|
||||
@@ -29,7 +29,7 @@ sha2.workspace = true
|
||||
sqlx.workspace = true
|
||||
thiserror.workspace = true
|
||||
time.workspace = true
|
||||
tokio = { workspace = true, features = ["sync"] }
|
||||
tokio = { workspace = true, features = ["sync", "signal"] }
|
||||
tracing.workspace = true
|
||||
tracing-subscriber.workspace = true
|
||||
uuid.workspace = true
|
||||
@@ -45,5 +45,6 @@ opentelemetry_sdk.workspace = true
|
||||
prost.workspace = true
|
||||
reqwest.workspace = true
|
||||
tower.workspace = true
|
||||
tokio = { workspace = true, features = ["net", "time"] }
|
||||
tracing-opentelemetry.workspace = true
|
||||
metrics-util = "0.20.4"
|
||||
+193
-11
@@ -1,7 +1,7 @@
|
||||
use std::{io, process::ExitCode, time::Duration};
|
||||
|
||||
use crank_community_mcp::{
|
||||
auth::CommunityMachineCredentialVerifier, build_app_with_artifacts,
|
||||
auth::CommunityMachineCredentialVerifier, build_app_with_artifacts_and_tasks,
|
||||
session::PostgresTransportSessionStore,
|
||||
};
|
||||
use crank_config::{
|
||||
@@ -14,13 +14,14 @@ use crank_observability::{
|
||||
OtlpTraceConfig, RedactionLimits, SentryConfig, ServiceIdentity, capture_critical_error,
|
||||
};
|
||||
use crank_registry::{
|
||||
MASTER_KEY_CIPHER_CONTRACT, MasterKeyIdentityCandidate, PostgresPoolConfig, PostgresRegistry,
|
||||
AdmissionLimits, MASTER_KEY_CIPHER_CONTRACT, MasterKeyIdentityCandidate,
|
||||
PostgresExecutionAdmission, PostgresPoolConfig, PostgresRegistry, PostgresTaskStore,
|
||||
};
|
||||
use crank_runtime::{
|
||||
RequestRateLimitConfig, RequestRateLimiter, RuntimeCacheConfig, RuntimeCacheStores,
|
||||
RuntimeLimits, SecretCrypto,
|
||||
};
|
||||
use mcp_server::pool_metrics::spawn_postgres_pool_metrics;
|
||||
use mcp_server::pool_metrics::{spawn_admission_metrics, spawn_postgres_pool_metrics};
|
||||
use sqlx::postgres::PgConnectOptions;
|
||||
use tokio::net::TcpListener;
|
||||
use tracing::info;
|
||||
@@ -175,6 +176,7 @@ async fn run(
|
||||
};
|
||||
if metrics_enabled {
|
||||
spawn_postgres_pool_metrics(registry.pool().clone());
|
||||
spawn_admission_metrics(registry.pool().clone());
|
||||
}
|
||||
let session_store = PostgresTransportSessionStore::from_pool(registry.pool().clone()).await?;
|
||||
let secret_crypto =
|
||||
@@ -190,12 +192,55 @@ async fn run(
|
||||
.with_limits(runtime_limits)
|
||||
.with_response_cache(cache_stores.response.clone())
|
||||
.with_coordination_store(cache_stores.coordination.clone())
|
||||
.with_admission(execution_admission(
|
||||
registry.pool().clone(),
|
||||
runtime_limits,
|
||||
)?)
|
||||
.build();
|
||||
// Published static Resources are read from the same immutable content-addressed root the
|
||||
// admin-api publishes into. The compatibility constructor keeps an unprovisioned/unsafe root
|
||||
// fail-closed per read instead of preventing startup; nothing is ever written from this process.
|
||||
let artifact_store = crank_artifacts::ArtifactStore::new(config.storage_root.clone());
|
||||
let app = build_app_with_artifacts(
|
||||
// Story 4.2/4.3: the durable Task application entry shares the registry pool, the published
|
||||
// catalog refresh interval and the exact admission limits of the runtime; the public wire stays
|
||||
// synchronous/unsupported while a fenced in-process worker executes accepted Tasks.
|
||||
let task_store = std::sync::Arc::new(PostgresTaskStore::new(
|
||||
registry.pool().clone(),
|
||||
admission_limits(runtime_limits),
|
||||
crank_core::AdmissionSchedulerConfig::default(),
|
||||
)?);
|
||||
let tasks = std::sync::Arc::new(crank_community_mcp::TaskApplication::new(
|
||||
registry.clone(),
|
||||
Duration::from_millis(config.refresh_ms),
|
||||
cache_stores.coordination.clone(),
|
||||
crank_runtime::TaskService::with_secret_crypto(
|
||||
task_store.clone(),
|
||||
std::sync::Arc::new(secret_crypto.clone()),
|
||||
),
|
||||
));
|
||||
// Story 4.3: the durable Task worker runs in this process over the same PostgreSQL store,
|
||||
// published catalog, executor and encrypted-input authority as the accepting application.
|
||||
let task_handler =
|
||||
std::sync::Arc::new(crank_community_mcp::TaskWorkerHandler::from_application(
|
||||
&tasks,
|
||||
registry.clone(),
|
||||
runtime.clone(),
|
||||
secret_crypto.clone(),
|
||||
));
|
||||
let task_worker = std::sync::Arc::new(crank_runtime::TaskWorker::new(
|
||||
task_store,
|
||||
task_handler,
|
||||
crank_runtime::TaskWorkerConfig {
|
||||
owner: format!("mcp-server-{}", std::process::id()),
|
||||
..crank_runtime::TaskWorkerConfig::default()
|
||||
},
|
||||
)?);
|
||||
let (task_shutdown_tx, task_shutdown_rx) = tokio::sync::watch::channel(false);
|
||||
let task_worker_handle = tokio::spawn({
|
||||
let worker = task_worker.clone();
|
||||
async move { worker.run_until_shutdown(task_shutdown_rx).await }
|
||||
});
|
||||
let app = build_app_with_artifacts_and_tasks(
|
||||
registry,
|
||||
Duration::from_millis(config.refresh_ms),
|
||||
config.runtime.base_url.clone(),
|
||||
@@ -211,6 +256,7 @@ async fn run(
|
||||
std::sync::Arc::new(CommunityMachineCredentialVerifier),
|
||||
runtime_limits.max_concurrent_sessions,
|
||||
artifact_store,
|
||||
tasks,
|
||||
);
|
||||
let listener = TcpListener::bind(config.bind_addr).await?;
|
||||
|
||||
@@ -231,15 +277,77 @@ async fn run(
|
||||
info!(name: "mcp.server.listening", bind_address = %config.bind_addr, "mcp-server listening");
|
||||
*startup_completed = true;
|
||||
|
||||
if let Some(metrics_server) = metrics_server {
|
||||
tokio::select! {
|
||||
result = axum::serve(listener, app) => result?,
|
||||
result = metrics_server.serve() => result?,
|
||||
let serve_result: Result<(), Box<dyn std::error::Error>> = async {
|
||||
if let Some(metrics_server) = metrics_server {
|
||||
tokio::select! {
|
||||
result = serve_with_worker_shutdown(app, listener, shutdown_signal(), task_shutdown_tx.clone()) => result?,
|
||||
result = metrics_server.serve() => result?,
|
||||
}
|
||||
} else {
|
||||
serve_with_worker_shutdown(app, listener, shutdown_signal(), task_shutdown_tx.clone())
|
||||
.await?;
|
||||
}
|
||||
} else {
|
||||
axum::serve(listener, app).await?;
|
||||
Ok(())
|
||||
}
|
||||
.await;
|
||||
|
||||
// Stop new claims; active attempts checkpoint/drain or are cancelled inside the bounded worker
|
||||
// shutdown timeout (<=30s), and queued PostgreSQL work is left for recovery.
|
||||
task_shutdown_tx.send(true).ok();
|
||||
if tokio::time::timeout(Duration::from_secs(30), task_worker_handle)
|
||||
.await
|
||||
.is_err()
|
||||
{
|
||||
tracing::warn!(
|
||||
name: "mcp.task_worker.shutdown_timeout",
|
||||
"durable Task worker did not stop within the story shutdown budget"
|
||||
);
|
||||
}
|
||||
serve_result
|
||||
}
|
||||
|
||||
/// Gracefully stop the durable Task worker as soon as shutdown is requested, while still
|
||||
/// draining in-flight HTTP connections before returning.
|
||||
async fn serve_with_worker_shutdown<S>(
|
||||
app: axum::Router,
|
||||
listener: tokio::net::TcpListener,
|
||||
signal: S,
|
||||
worker_stop: tokio::sync::watch::Sender<bool>,
|
||||
) -> std::io::Result<()>
|
||||
where
|
||||
S: std::future::Future<Output = ()> + Send + 'static,
|
||||
{
|
||||
let worker_stop_graceful = worker_stop.clone();
|
||||
let graceful = async move {
|
||||
signal.await;
|
||||
let _ = worker_stop_graceful.send(true);
|
||||
};
|
||||
let result = axum::serve(listener, app)
|
||||
.with_graceful_shutdown(graceful)
|
||||
.await;
|
||||
let _ = worker_stop.send(true);
|
||||
result
|
||||
}
|
||||
|
||||
/// Process shutdown trigger for the HTTP surface and the durable Task worker.
|
||||
async fn shutdown_signal() {
|
||||
let ctrl_c = async {
|
||||
let _ = tokio::signal::ctrl_c().await;
|
||||
};
|
||||
#[cfg(unix)]
|
||||
let terminate = async {
|
||||
if let Ok(mut signal) =
|
||||
tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
|
||||
{
|
||||
signal.recv().await;
|
||||
}
|
||||
};
|
||||
#[cfg(not(unix))]
|
||||
let terminate = std::future::pending::<()>();
|
||||
tokio::select! {
|
||||
_ = ctrl_c => {}
|
||||
_ = terminate => {}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn init_observability(
|
||||
@@ -287,6 +395,25 @@ fn init_observability(
|
||||
)?)
|
||||
}
|
||||
|
||||
fn admission_limits(runtime_limits: RuntimeLimits) -> AdmissionLimits {
|
||||
AdmissionLimits {
|
||||
global_limit: runtime_limits.max_concurrent_unary,
|
||||
..AdmissionLimits::default()
|
||||
}
|
||||
}
|
||||
|
||||
fn execution_admission(
|
||||
pool: sqlx::PgPool,
|
||||
runtime_limits: RuntimeLimits,
|
||||
) -> Result<std::sync::Arc<dyn crank_core::ExecutionAdmission>, Box<dyn std::error::Error>> {
|
||||
let store = PostgresExecutionAdmission::new(
|
||||
pool,
|
||||
admission_limits(runtime_limits),
|
||||
crank_core::AdmissionSchedulerConfig::default(),
|
||||
)?;
|
||||
Ok(std::sync::Arc::new(store))
|
||||
}
|
||||
|
||||
fn preflight_config(config: &McpProcessConfig) -> Result<(), crank_config::ConfigError> {
|
||||
let invalid = |field| crank_config::ConfigError::single(DiagnosticCode::InvalidType, field);
|
||||
database_options(&config.database).map_err(|_| invalid("database.source"))?;
|
||||
@@ -307,6 +434,12 @@ fn preflight_config(config: &McpProcessConfig) -> Result<(), crank_config::Confi
|
||||
config.runtime.max_concurrent_sessions,
|
||||
)
|
||||
.map_err(|_| invalid("runtime.limits"))?;
|
||||
crank_registry::AdmissionLimits {
|
||||
global_limit: config.runtime.max_concurrent_unary,
|
||||
..crank_registry::AdmissionLimits::default()
|
||||
}
|
||||
.validate()
|
||||
.map_err(|_| invalid("runtime.admission"))?;
|
||||
runtime_cache_config(config).map_err(|_| invalid("cache"))?;
|
||||
RequestRateLimitConfig::new(
|
||||
config.rate_limit.requests_per_second,
|
||||
@@ -460,3 +593,52 @@ fn runtime_cache_config(
|
||||
.map(|value| value.expose_secret().to_owned()),
|
||||
)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use axum::{Router, routing::get};
|
||||
use std::time::Duration;
|
||||
use tokio::sync::{oneshot, watch};
|
||||
|
||||
async fn slow_handler() -> &'static str {
|
||||
tokio::time::sleep(Duration::from_millis(600)).await;
|
||||
"ok"
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn worker_stops_before_http_drain_completes() {
|
||||
let app = Router::new().route("/slow", get(slow_handler));
|
||||
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let addr = listener.local_addr().unwrap();
|
||||
let (stop_tx, mut stop_rx) = watch::channel(false);
|
||||
let (signal_tx, signal_rx) = oneshot::channel::<()>();
|
||||
|
||||
let handle = tokio::spawn(serve_with_worker_shutdown(
|
||||
app,
|
||||
listener,
|
||||
async {
|
||||
let _ = signal_rx.await;
|
||||
},
|
||||
stop_tx,
|
||||
));
|
||||
|
||||
let client = reqwest::Client::new();
|
||||
let request = client.get(format!("http://{}/slow", addr));
|
||||
let in_flight = tokio::spawn(async move { request.send().await });
|
||||
|
||||
tokio::time::sleep(Duration::from_millis(150)).await;
|
||||
let _ = signal_tx.send(());
|
||||
|
||||
tokio::time::timeout(Duration::from_millis(250), stop_rx.changed())
|
||||
.await
|
||||
.expect("worker stop signal should arrive before HTTP drain")
|
||||
.expect("watch changed");
|
||||
assert!(*stop_rx.borrow());
|
||||
|
||||
let response = in_flight.await.unwrap().unwrap();
|
||||
assert!(response.status().is_success());
|
||||
let serve_result = handle.await.unwrap();
|
||||
assert!(serve_result.is_ok());
|
||||
}
|
||||
}
|
||||
@@ -11,3 +11,17 @@ pub fn spawn_postgres_pool_metrics(pool: PgPool) -> tokio::task::JoinHandle<()>
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// Story 4.1: samples the authoritative admission queue so the oldest-waiting age grows (and returns
|
||||
/// to zero) without waiting for a new request.
|
||||
pub fn spawn_admission_metrics(pool: PgPool) -> tokio::task::JoinHandle<()> {
|
||||
tokio::spawn(async move {
|
||||
let mut interval = tokio::time::interval(Duration::from_secs(5));
|
||||
loop {
|
||||
interval.tick().await;
|
||||
if let Ok(snapshot) = crank_registry::admission_snapshot(&pool).await {
|
||||
crank_observability::record_admission_oldest_waiting(snapshot.oldest_waiting_ms);
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,874 @@
|
||||
//! ATDD Story 4.1 (FR-21/FR-24): the runtime asks one authoritative store for admission.
|
||||
//!
|
||||
//! Real PostgreSQL state, two independent `RuntimeExecutor` instances (the multi-process shape) and a
|
||||
//! counted adapter: one shared global budget, typed overload with retry guidance, typed unsupported
|
||||
//! fallback, deadline that includes queue waiting and zero outbound calls on every refusal.
|
||||
//!
|
||||
//! Lives in the `mcp-server` app crate because the runtime must not depend on the registry crate; this
|
||||
//! app already wires both and this is the real deployment shape.
|
||||
|
||||
use std::{
|
||||
collections::BTreeMap,
|
||||
sync::{
|
||||
Arc, Mutex,
|
||||
atomic::{AtomicUsize, Ordering},
|
||||
},
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
|
||||
use async_trait::async_trait;
|
||||
use crank_core::{
|
||||
AdapterResponse, AdmissionMode, AdmissionRequest, AdmissionScope, ApprovalEvidence,
|
||||
ConfirmationPolicy, ExecutionAdmission, ExecutionConfig, ExecutionErrorCode, ExecutionMode,
|
||||
ExecutionOrigin, ExecutionStage, HttpMethod, InvocationSource, NoTasksFallback, Operation,
|
||||
OperationId, OperationSafetyClass, OperationSafetyPolicy, OperationSecurityLevel,
|
||||
OperationStatus, OutcomeCertainty, Protocol, ProtocolAdapter, RestTarget,
|
||||
RuntimeRequestContext, Target, ToolDescription, ToolExecutionMode, ToolExecutionPolicy,
|
||||
WorkspaceId,
|
||||
};
|
||||
use crank_mapping::MappingSet;
|
||||
use crank_registry::{AdmissionLimits, PostgresExecutionAdmission};
|
||||
use crank_runtime::{RuntimeExecutor, RuntimeExecutorBuilder, RuntimeLimits};
|
||||
use crank_schema::{Schema, SchemaKind};
|
||||
use serde_json::json;
|
||||
use sqlx::PgPool;
|
||||
use time::OffsetDateTime;
|
||||
|
||||
struct CountingAdapter {
|
||||
calls: Arc<AtomicUsize>,
|
||||
current: Arc<AtomicUsize>,
|
||||
peak: Arc<AtomicUsize>,
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl ProtocolAdapter for CountingAdapter {
|
||||
fn protocol(&self) -> Protocol {
|
||||
Protocol::Rest
|
||||
}
|
||||
|
||||
fn supports_mode(&self, mode: ExecutionMode) -> bool {
|
||||
mode == ExecutionMode::Unary
|
||||
}
|
||||
|
||||
async fn invoke_unary(
|
||||
&self,
|
||||
_target: &Target,
|
||||
_prepared: &crank_core::PreparedRequest,
|
||||
context: &RuntimeRequestContext,
|
||||
) -> Result<AdapterResponse, crank_core::ProtocolAdapterError> {
|
||||
context.mark_dispatch_started();
|
||||
self.calls.fetch_add(1, Ordering::SeqCst);
|
||||
let current = self.current.fetch_add(1, Ordering::SeqCst) + 1;
|
||||
self.peak.fetch_max(current, Ordering::SeqCst);
|
||||
tokio::time::sleep(Duration::from_millis(150)).await;
|
||||
self.current.fetch_sub(1, Ordering::SeqCst);
|
||||
Ok(AdapterResponse {
|
||||
status_code: 200,
|
||||
headers: BTreeMap::new(),
|
||||
body: json!({"ok": true}),
|
||||
data: json!({"ok": true}),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn schema(kind: SchemaKind) -> Schema {
|
||||
Schema {
|
||||
kind,
|
||||
format: None,
|
||||
description: None,
|
||||
required: false,
|
||||
nullable: false,
|
||||
default_value: None,
|
||||
fields: BTreeMap::new(),
|
||||
items: None,
|
||||
enum_values: Vec::new(),
|
||||
variants: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
fn operation(policy: Option<ToolExecutionPolicy>) -> Operation<Schema, MappingSet> {
|
||||
Operation {
|
||||
id: OperationId::new("op_admission_budget"),
|
||||
name: "admission_budget".to_owned(),
|
||||
display_name: "Admission budget".to_owned(),
|
||||
category: "general".to_owned(),
|
||||
protocol: Protocol::Rest,
|
||||
security_level: OperationSecurityLevel::Standard,
|
||||
status: OperationStatus::Published,
|
||||
version: 7,
|
||||
target: Target::Rest(RestTarget {
|
||||
base_url: "https://api.example.com".to_owned(),
|
||||
method: HttpMethod::Get,
|
||||
path_template: "/v1/items".to_owned(),
|
||||
static_headers: BTreeMap::new(),
|
||||
request_contract: None,
|
||||
response_contract: Vec::new(),
|
||||
multipart_field_mime_types: BTreeMap::new(),
|
||||
}),
|
||||
input_schema: schema(SchemaKind::Object),
|
||||
output_schema: schema(SchemaKind::Object),
|
||||
input_mapping: MappingSet::default(),
|
||||
output_mapping: MappingSet::default(),
|
||||
execution_config: ExecutionConfig {
|
||||
timeout_ms: 5_000,
|
||||
execution_policy: policy,
|
||||
..ExecutionConfig::default()
|
||||
},
|
||||
tool_description: ToolDescription {
|
||||
title: "Admission".to_owned(),
|
||||
description: "Admission budget probe".to_owned(),
|
||||
tags: Vec::new(),
|
||||
examples: Vec::new(),
|
||||
},
|
||||
samples: None,
|
||||
generated_draft: None,
|
||||
config_export: None,
|
||||
wizard_state: None,
|
||||
created_at: OffsetDateTime::now_utc(),
|
||||
updated_at: OffsetDateTime::now_utc(),
|
||||
published_at: None,
|
||||
}
|
||||
}
|
||||
|
||||
async fn execute(
|
||||
executor: &RuntimeExecutor,
|
||||
operation: &crank_runtime::RuntimeOperation,
|
||||
input: &serde_json::Value,
|
||||
) -> Result<serde_json::Value, crank_core::ExecutionFailure> {
|
||||
let workspace = WorkspaceId::new("ws_test");
|
||||
let context = crank_runtime::RuntimeRequestContext::from_correlation(
|
||||
&crank_core::CorrelationContext::generate(),
|
||||
)
|
||||
.with_metering_context(workspace.clone(), None, InvocationSource::AdminTestRun);
|
||||
execute_in(executor, operation, input, &context).await
|
||||
}
|
||||
|
||||
async fn execute_in(
|
||||
executor: &RuntimeExecutor,
|
||||
operation: &crank_runtime::RuntimeOperation,
|
||||
input: &serde_json::Value,
|
||||
context: &crank_runtime::RuntimeRequestContext,
|
||||
) -> Result<serde_json::Value, crank_core::ExecutionFailure> {
|
||||
let workspace = context
|
||||
.metering_context()
|
||||
.map(|metering| metering.workspace_id.clone())
|
||||
.unwrap_or_else(|| WorkspaceId::new("ws_test"));
|
||||
let request = crank_runtime::RuntimeExecutionRequest::try_new(
|
||||
&workspace,
|
||||
ExecutionOrigin::AdminDraft,
|
||||
None,
|
||||
operation,
|
||||
input,
|
||||
crank_runtime::ExecutionAuthorization::Authorized,
|
||||
None,
|
||||
context,
|
||||
Instant::now() + Duration::from_secs(30),
|
||||
)
|
||||
.map_err(|_| {
|
||||
crank_core::ExecutionFailure::new(
|
||||
ExecutionErrorCode::RuntimeInternal,
|
||||
crank_core::CorrelationContext::new(
|
||||
context.request_id.clone(),
|
||||
context.trace_context.clone(),
|
||||
),
|
||||
)
|
||||
})?;
|
||||
executor
|
||||
.execute_outcome(request)
|
||||
.await
|
||||
.map(|success| success.output)
|
||||
}
|
||||
|
||||
async fn schema_pool(schema_url: &str) -> PgPool {
|
||||
let pool = PgPool::connect(schema_url)
|
||||
.await
|
||||
.expect("admission schema pool");
|
||||
crank_registry::MigrationAuthority::apply(&pool)
|
||||
.await
|
||||
.expect("migration authority applies the admission schema");
|
||||
pool
|
||||
}
|
||||
|
||||
fn admission_store(pool: PgPool, global: usize, queue: usize) -> Arc<PostgresExecutionAdmission> {
|
||||
Arc::new(
|
||||
PostgresExecutionAdmission::new(
|
||||
pool,
|
||||
AdmissionLimits {
|
||||
global_limit: global,
|
||||
agent_limit: 8,
|
||||
tool_limit: 8,
|
||||
queue_limit: queue,
|
||||
},
|
||||
crank_core::AdmissionSchedulerConfig::default(),
|
||||
)
|
||||
.expect("valid admission limits"),
|
||||
)
|
||||
}
|
||||
|
||||
fn executor(
|
||||
store: Arc<PostgresExecutionAdmission>,
|
||||
calls: Arc<AtomicUsize>,
|
||||
current: Arc<AtomicUsize>,
|
||||
peak: Arc<AtomicUsize>,
|
||||
) -> RuntimeExecutor {
|
||||
RuntimeExecutorBuilder::new()
|
||||
.register_adapter(Arc::new(CountingAdapter {
|
||||
calls,
|
||||
current,
|
||||
peak,
|
||||
}))
|
||||
.with_limits(RuntimeLimits::try_new(8, 2).expect("local limits"))
|
||||
.with_admission(store)
|
||||
.build()
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn two_executors_share_one_global_budget() {
|
||||
let schema_url = crank_test_support::postgres_schema_url("admission_budget").await;
|
||||
let pool = schema_pool(&schema_url).await;
|
||||
let store = admission_store(pool.clone(), 2, 8);
|
||||
let calls = Arc::new(AtomicUsize::new(0));
|
||||
let current = Arc::new(AtomicUsize::new(0));
|
||||
let peak = Arc::new(AtomicUsize::new(0));
|
||||
let first = executor(
|
||||
Arc::clone(&store),
|
||||
Arc::clone(&calls),
|
||||
Arc::clone(¤t),
|
||||
Arc::clone(&peak),
|
||||
);
|
||||
let second = executor(
|
||||
Arc::clone(&store),
|
||||
Arc::clone(&calls),
|
||||
Arc::clone(¤t),
|
||||
Arc::clone(&peak),
|
||||
);
|
||||
|
||||
let operation: crank_runtime::RuntimeOperation = operation(None).into();
|
||||
let mut tasks = Vec::new();
|
||||
for index in 0..4 {
|
||||
let executor = if index % 2 == 0 {
|
||||
first.clone()
|
||||
} else {
|
||||
second.clone()
|
||||
};
|
||||
let operation = operation.clone();
|
||||
tasks.push(tokio::spawn(async move {
|
||||
execute(&executor, &operation, &json!({})).await
|
||||
}));
|
||||
}
|
||||
let mut completed = 0;
|
||||
for task in tasks {
|
||||
match task.await.expect("execution task") {
|
||||
Ok(_) => completed += 1,
|
||||
Err(failure) => panic!("admission must grant every request: {failure:?}"),
|
||||
}
|
||||
}
|
||||
assert_eq!(completed, 4);
|
||||
assert_eq!(calls.load(Ordering::SeqCst), 4);
|
||||
assert!(
|
||||
peak.load(Ordering::SeqCst) <= 2,
|
||||
"peak concurrency {} exceeded the shared global limit",
|
||||
peak.load(Ordering::SeqCst)
|
||||
);
|
||||
assert_eq!(store.snapshot().await.unwrap().executing, 0);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn saturation_returns_typed_overload_without_an_outbound_call() {
|
||||
let schema_url = crank_test_support::postgres_schema_url("admission_overload").await;
|
||||
let pool = schema_pool(&schema_url).await;
|
||||
let store = admission_store(pool, 1, 1);
|
||||
let calls = Arc::new(AtomicUsize::new(0));
|
||||
let current = Arc::new(AtomicUsize::new(0));
|
||||
let peak = Arc::new(AtomicUsize::new(0));
|
||||
let runtime = executor(
|
||||
Arc::clone(&store),
|
||||
Arc::clone(&calls),
|
||||
Arc::clone(¤t),
|
||||
Arc::clone(&peak),
|
||||
);
|
||||
|
||||
// Another process already holds the only global permit.
|
||||
let held = match store
|
||||
.admit(AdmissionRequest {
|
||||
scope: AdmissionScope {
|
||||
workspace_id: "ws_test".to_owned(),
|
||||
agent_key: "admin".to_owned(),
|
||||
operation_id: "op_admission_budget".to_owned(),
|
||||
operation_version: 7,
|
||||
},
|
||||
mode: AdmissionMode::Synchronous,
|
||||
policy_mode: ToolExecutionMode::Synchronous,
|
||||
no_tasks_fallback: NoTasksFallback::Synchronous,
|
||||
approval: ApprovalEvidence::NotRequired,
|
||||
fingerprint: "fp_holder".to_owned(),
|
||||
expires_at_unix_ms: crank_core::current_unix_ms() + 10_000,
|
||||
})
|
||||
.await
|
||||
.expect("admission store is reachable")
|
||||
{
|
||||
crank_core::AdmissionOutcome::Permitted(permit) => permit,
|
||||
other => panic!("expected a permit, got {other:?}"),
|
||||
};
|
||||
|
||||
let waiting_operation: crank_runtime::RuntimeOperation = operation(Some(ToolExecutionPolicy {
|
||||
mode: ToolExecutionMode::Synchronous,
|
||||
deadline_ms: 250,
|
||||
no_tasks_fallback: NoTasksFallback::Synchronous,
|
||||
}))
|
||||
.into();
|
||||
let waiting_runtime = runtime.clone();
|
||||
let first_waiting_operation = waiting_operation.clone();
|
||||
let waiting = tokio::spawn(async move {
|
||||
execute(&waiting_runtime, &first_waiting_operation, &json!({})).await
|
||||
});
|
||||
// Let the first request occupy the bounded queue before the next one arrives.
|
||||
while store.snapshot().await.unwrap().waiting == 0 {
|
||||
tokio::time::sleep(Duration::from_millis(5)).await;
|
||||
}
|
||||
let overloaded = execute(&runtime, &waiting_operation, &json!({})).await;
|
||||
let failure = overloaded.expect_err("a full queue must refuse the request");
|
||||
assert_eq!(
|
||||
failure.error_code(),
|
||||
ExecutionErrorCode::ExecutionOverloaded
|
||||
);
|
||||
assert_eq!(failure.stage(), ExecutionStage::Admission);
|
||||
assert_eq!(failure.retry_after_ms(), Some(250));
|
||||
|
||||
// The queued request hits its absolute deadline instead of dispatching. That refusal happened
|
||||
// inside admission (nothing was ever dispatched), so the client must see an admission-stage
|
||||
// overload with retry guidance — not an `upstream_timeout`.
|
||||
let expired = waiting
|
||||
.await
|
||||
.expect("waiting task")
|
||||
.expect_err("deadline must refuse");
|
||||
assert_eq!(
|
||||
expired.error_code(),
|
||||
ExecutionErrorCode::ExecutionOverloaded,
|
||||
"queue waiting counts against the published deadline"
|
||||
);
|
||||
assert_eq!(expired.stage(), ExecutionStage::Admission);
|
||||
assert_eq!(expired.retry_after_ms(), Some(250));
|
||||
assert_eq!(expired.outcome_certainty(), OutcomeCertainty::Certain);
|
||||
assert_eq!(
|
||||
calls.load(Ordering::SeqCst),
|
||||
0,
|
||||
"no outbound call on refusal"
|
||||
);
|
||||
assert!(store.release(&held).await.unwrap());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn background_policy_without_a_task_transport_is_typed_unsupported() {
|
||||
let schema_url = crank_test_support::postgres_schema_url("admission_unsupported").await;
|
||||
let pool = schema_pool(&schema_url).await;
|
||||
let store = admission_store(pool, 2, 4);
|
||||
let calls = Arc::new(AtomicUsize::new(0));
|
||||
let current = Arc::new(AtomicUsize::new(0));
|
||||
let peak = Arc::new(AtomicUsize::new(0));
|
||||
let runtime = executor(
|
||||
Arc::clone(&store),
|
||||
Arc::clone(&calls),
|
||||
Arc::clone(¤t),
|
||||
Arc::clone(&peak),
|
||||
);
|
||||
|
||||
let operation: crank_runtime::RuntimeOperation = operation(Some(ToolExecutionPolicy {
|
||||
mode: ToolExecutionMode::Background,
|
||||
deadline_ms: 2_000,
|
||||
no_tasks_fallback: NoTasksFallback::Unsupported,
|
||||
}))
|
||||
.into();
|
||||
let failure = execute(&runtime, &operation, &json!({}))
|
||||
.await
|
||||
.expect_err("no Task transport exists in Story 4.1");
|
||||
assert_eq!(
|
||||
failure.error_code(),
|
||||
ExecutionErrorCode::ExecutionModeUnsupported
|
||||
);
|
||||
assert_eq!(calls.load(Ordering::SeqCst), 0);
|
||||
let snapshot = store.snapshot().await.unwrap();
|
||||
assert_eq!(snapshot.waiting, 0);
|
||||
assert_eq!(snapshot.executing, 0);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn background_policy_with_a_synchronous_fallback_keeps_the_sync_response_shape() {
|
||||
let schema_url = crank_test_support::postgres_schema_url("admission_fallback").await;
|
||||
let pool = schema_pool(&schema_url).await;
|
||||
let store = admission_store(pool, 2, 4);
|
||||
let calls = Arc::new(AtomicUsize::new(0));
|
||||
let current = Arc::new(AtomicUsize::new(0));
|
||||
let peak = Arc::new(AtomicUsize::new(0));
|
||||
let runtime = executor(
|
||||
Arc::clone(&store),
|
||||
Arc::clone(&calls),
|
||||
Arc::clone(¤t),
|
||||
Arc::clone(&peak),
|
||||
);
|
||||
|
||||
let operation: crank_runtime::RuntimeOperation = operation(Some(ToolExecutionPolicy {
|
||||
mode: ToolExecutionMode::Adaptive,
|
||||
deadline_ms: 2_000,
|
||||
no_tasks_fallback: NoTasksFallback::Synchronous,
|
||||
}))
|
||||
.into();
|
||||
let output = execute(&runtime, &operation, &json!({}))
|
||||
.await
|
||||
.expect("adaptive resolves through the published synchronous fallback");
|
||||
// The response shape is unchanged by admission: an operation without output mapping still
|
||||
// returns the same mapped output object it returned before Story 4.1.
|
||||
assert_eq!(output, json!({}));
|
||||
assert_eq!(calls.load(Ordering::SeqCst), 1);
|
||||
assert_eq!(store.snapshot().await.unwrap().executing, 0);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn admission_store_outage_fails_closed_before_dispatch() {
|
||||
let schema_url = crank_test_support::postgres_schema_url("admission_outage").await;
|
||||
let pool = schema_pool(&schema_url).await;
|
||||
let store = admission_store(pool.clone(), 2, 4);
|
||||
let calls = Arc::new(AtomicUsize::new(0));
|
||||
let current = Arc::new(AtomicUsize::new(0));
|
||||
let peak = Arc::new(AtomicUsize::new(0));
|
||||
let runtime = executor(
|
||||
Arc::clone(&store),
|
||||
Arc::clone(&calls),
|
||||
Arc::clone(¤t),
|
||||
Arc::clone(&peak),
|
||||
);
|
||||
// The mandatory state disappears after the store was built: every execution must fail closed.
|
||||
sqlx::query("drop table execution_admission_entries")
|
||||
.execute(&pool)
|
||||
.await
|
||||
.expect("drop the mandatory admission state");
|
||||
let operation: crank_runtime::RuntimeOperation = operation(None).into();
|
||||
let failure = execute(&runtime, &operation, &json!({}))
|
||||
.await
|
||||
.expect_err("a missing mandatory store must fail closed");
|
||||
assert_eq!(
|
||||
failure.error_code(),
|
||||
ExecutionErrorCode::SafetyStoreUnavailable
|
||||
);
|
||||
assert_eq!(calls.load(Ordering::SeqCst), 0);
|
||||
assert!(store.health().await.is_err());
|
||||
}
|
||||
|
||||
/// Admission store that records the snapshot it was asked to decide on (Story 4.1, AC2/F2).
|
||||
struct RecordingAdmission {
|
||||
inner: Arc<PostgresExecutionAdmission>,
|
||||
requests: Mutex<Vec<AdmissionRequest>>,
|
||||
permits: AtomicUsize,
|
||||
releases: AtomicUsize,
|
||||
}
|
||||
|
||||
impl RecordingAdmission {
|
||||
fn new(inner: Arc<PostgresExecutionAdmission>) -> Self {
|
||||
Self {
|
||||
inner,
|
||||
requests: Mutex::new(Vec::new()),
|
||||
permits: AtomicUsize::new(0),
|
||||
releases: AtomicUsize::new(0),
|
||||
}
|
||||
}
|
||||
|
||||
fn requests(&self) -> Vec<AdmissionRequest> {
|
||||
self.requests.lock().expect("admission log").clone()
|
||||
}
|
||||
|
||||
fn permits(&self) -> usize {
|
||||
self.permits.load(Ordering::SeqCst)
|
||||
}
|
||||
|
||||
fn releases(&self) -> usize {
|
||||
self.releases.load(Ordering::SeqCst)
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl ExecutionAdmission for RecordingAdmission {
|
||||
async fn health(&self) -> Result<(), crank_core::AdmissionStoreError> {
|
||||
self.inner.health().await
|
||||
}
|
||||
|
||||
async fn admit(
|
||||
&self,
|
||||
request: AdmissionRequest,
|
||||
) -> Result<crank_core::AdmissionOutcome, crank_core::AdmissionStoreError> {
|
||||
self.requests
|
||||
.lock()
|
||||
.expect("admission log")
|
||||
.push(request.clone());
|
||||
let outcome = self.inner.admit(request).await?;
|
||||
if matches!(outcome, crank_core::AdmissionOutcome::Permitted(_)) {
|
||||
self.permits.fetch_add(1, Ordering::SeqCst);
|
||||
}
|
||||
Ok(outcome)
|
||||
}
|
||||
|
||||
async fn release(
|
||||
&self,
|
||||
permit: &crank_core::AdmissionPermit,
|
||||
) -> Result<bool, crank_core::AdmissionStoreError> {
|
||||
let released = self.inner.release(permit).await?;
|
||||
if released {
|
||||
self.releases.fetch_add(1, Ordering::SeqCst);
|
||||
}
|
||||
Ok(released)
|
||||
}
|
||||
|
||||
async fn cancel(
|
||||
&self,
|
||||
ticket_id: u64,
|
||||
owner_token: &str,
|
||||
) -> Result<bool, crank_core::AdmissionStoreError> {
|
||||
self.inner.cancel(ticket_id, owner_token).await
|
||||
}
|
||||
|
||||
async fn snapshot(
|
||||
&self,
|
||||
) -> Result<crank_core::AdmissionQueueSnapshot, crank_core::AdmissionStoreError> {
|
||||
self.inner.snapshot().await
|
||||
}
|
||||
}
|
||||
|
||||
fn confirmation_operation(version: u32) -> crank_runtime::RuntimeOperation {
|
||||
let mut source = operation(None);
|
||||
source.id = OperationId::new("op_admission_confirmation");
|
||||
source.name = "admission_confirmation".to_owned();
|
||||
source.version = version;
|
||||
let Target::Rest(target) = &mut source.target;
|
||||
target.method = HttpMethod::Delete;
|
||||
source.execution_config.safety = Some(OperationSafetyPolicy {
|
||||
class: OperationSafetyClass::Destructive,
|
||||
confirmation: Some(ConfirmationPolicy { ttl_ms: 60_000 }),
|
||||
});
|
||||
source.into()
|
||||
}
|
||||
|
||||
fn confirmation_runtime(
|
||||
admission: Arc<RecordingAdmission>,
|
||||
coordination: Option<Arc<dyn crank_core::CoordinationStateStore>>,
|
||||
calls: Arc<AtomicUsize>,
|
||||
) -> RuntimeExecutor {
|
||||
let store: Arc<dyn ExecutionAdmission> = admission;
|
||||
let builder = RuntimeExecutorBuilder::new()
|
||||
.register_adapter(Arc::new(CountingAdapter {
|
||||
calls,
|
||||
current: Arc::new(AtomicUsize::new(0)),
|
||||
peak: Arc::new(AtomicUsize::new(0)),
|
||||
}))
|
||||
.with_limits(RuntimeLimits::try_new(8, 2).expect("local limits"))
|
||||
.with_admission(store);
|
||||
match coordination {
|
||||
Some(coordination) => builder.with_coordination_store(coordination).build(),
|
||||
None => builder.build(),
|
||||
}
|
||||
}
|
||||
|
||||
fn confirmation_context() -> crank_runtime::RuntimeRequestContext {
|
||||
crank_runtime::RuntimeRequestContext::from_correlation(
|
||||
&crank_core::CorrelationContext::generate(),
|
||||
)
|
||||
.with_response_cache_scope("ws_test", "agent_a")
|
||||
.with_metering_context(
|
||||
WorkspaceId::new("ws_test"),
|
||||
None,
|
||||
InvocationSource::AdminTestRun,
|
||||
)
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn confirmation_requiring_call_takes_a_permit_only_with_verified_approval() {
|
||||
let schema_url = crank_test_support::postgres_schema_url("admission_confirmation").await;
|
||||
let pool = schema_pool(&schema_url).await;
|
||||
let recording = Arc::new(RecordingAdmission::new(Arc::new(
|
||||
PostgresExecutionAdmission::new(
|
||||
pool,
|
||||
AdmissionLimits {
|
||||
global_limit: 4,
|
||||
agent_limit: 4,
|
||||
tool_limit: 4,
|
||||
queue_limit: 8,
|
||||
},
|
||||
crank_core::AdmissionSchedulerConfig::default(),
|
||||
)
|
||||
.expect("valid admission limits"),
|
||||
)));
|
||||
let coordination: Arc<dyn crank_core::CoordinationStateStore> =
|
||||
Arc::new(crank_runtime::InMemoryCoordinationStateStore::default());
|
||||
let calls = Arc::new(AtomicUsize::new(0));
|
||||
let runtime = confirmation_runtime(
|
||||
Arc::clone(&recording),
|
||||
Some(Arc::clone(&coordination)),
|
||||
Arc::clone(&calls),
|
||||
);
|
||||
let operation = confirmation_operation(3);
|
||||
let context = confirmation_context();
|
||||
let input = json!({ "reason": "remove the stale item" });
|
||||
|
||||
// 1. No approval yet: the existing challenge is returned and no execution capacity is taken.
|
||||
let challenge = execute_in(&runtime, &operation, &input, &context)
|
||||
.await
|
||||
.expect_err("an unapproved destructive call must only stage confirmation");
|
||||
assert_eq!(
|
||||
challenge.error_code(),
|
||||
ExecutionErrorCode::ConfirmationRequired
|
||||
);
|
||||
let token = challenge
|
||||
.confirmation()
|
||||
.expect("expected the confirmation challenge")
|
||||
.token()
|
||||
.to_owned();
|
||||
assert_eq!(
|
||||
recording.permits(),
|
||||
0,
|
||||
"an unapproved request must not take an execution permit"
|
||||
);
|
||||
assert_eq!(calls.load(Ordering::SeqCst), 0);
|
||||
let requests = recording.requests();
|
||||
assert_eq!(
|
||||
requests.len(),
|
||||
1,
|
||||
"the one admission snapshot is consulted once"
|
||||
);
|
||||
assert_eq!(
|
||||
requests[0].approval,
|
||||
ApprovalEvidence::NotGranted,
|
||||
"admission must see the real approval state, not a fixed NotRequired"
|
||||
);
|
||||
assert_eq!(requests[0].scope.operation_version, 3);
|
||||
let snapshot = recording.snapshot().await.expect("admission snapshot");
|
||||
assert_eq!((snapshot.executing, snapshot.waiting), (0, 0));
|
||||
|
||||
// 2. An approval issued for another published version never opens this execution.
|
||||
let other_version = confirmation_operation(4);
|
||||
let foreign = execute_in(
|
||||
&runtime,
|
||||
&other_version,
|
||||
&input,
|
||||
&context.clone().with_confirmation_token(token.clone()),
|
||||
)
|
||||
.await
|
||||
.expect_err("a foreign approval must not authorise this version");
|
||||
assert_eq!(
|
||||
foreign.error_code(),
|
||||
ExecutionErrorCode::ConfirmationInvalid
|
||||
);
|
||||
assert_eq!(recording.permits(), 0);
|
||||
assert_eq!(
|
||||
recording.requests().len(),
|
||||
1,
|
||||
"an unusable approval is refused before any capacity request"
|
||||
);
|
||||
|
||||
// 3. An approval is bound to its exact input as well.
|
||||
let mismatched_input = json!({ "reason": "remove another item" });
|
||||
let mismatched = execute_in(
|
||||
&runtime,
|
||||
&operation,
|
||||
&mismatched_input,
|
||||
&context.clone().with_confirmation_token(token.clone()),
|
||||
)
|
||||
.await
|
||||
.expect_err("a confirmation token must not authorise different input");
|
||||
assert_eq!(
|
||||
mismatched.error_code(),
|
||||
ExecutionErrorCode::ConfirmationInvalid
|
||||
);
|
||||
assert_eq!(recording.permits(), 0);
|
||||
assert_eq!(recording.requests().len(), 1);
|
||||
|
||||
// 4. The matching approval passes admission with truthful evidence and executes exactly once.
|
||||
let executed = execute_in(
|
||||
&runtime,
|
||||
&operation,
|
||||
&input,
|
||||
&context.clone().with_confirmation_token(token.clone()),
|
||||
)
|
||||
.await
|
||||
.expect("a verified approval executes");
|
||||
assert!(executed.is_object());
|
||||
assert_eq!(calls.load(Ordering::SeqCst), 1);
|
||||
let requests = recording.requests();
|
||||
assert_eq!(requests.len(), 2);
|
||||
assert_eq!(requests[1].approval, ApprovalEvidence::Granted);
|
||||
assert_eq!(requests[1].scope.operation_version, 3);
|
||||
assert_eq!(recording.permits(), 1);
|
||||
assert_eq!(
|
||||
recording.releases(),
|
||||
1,
|
||||
"the permit is released after execution"
|
||||
);
|
||||
assert_eq!(recording.snapshot().await.expect("snapshot").executing, 0);
|
||||
|
||||
// 5. Replay of the consumed confirmation is refused before capacity and without a side effect.
|
||||
let replay = execute_in(
|
||||
&runtime,
|
||||
&operation,
|
||||
&input,
|
||||
&context.clone().with_confirmation_token(token),
|
||||
)
|
||||
.await
|
||||
.expect_err("a confirmation token is single-use");
|
||||
assert_eq!(replay.error_code(), ExecutionErrorCode::ConfirmationInvalid);
|
||||
assert_eq!(calls.load(Ordering::SeqCst), 1);
|
||||
assert_eq!(recording.permits(), 1);
|
||||
assert_eq!(
|
||||
recording.requests().len(),
|
||||
2,
|
||||
"a replayed approval never reaches admission"
|
||||
);
|
||||
|
||||
// 6. The trusted approved-recovery path still passes the same gate with real evidence.
|
||||
let approved = execute_in(
|
||||
&runtime,
|
||||
&operation,
|
||||
&json!({ "reason": "approved by an operator" }),
|
||||
&context.with_approval_granted(),
|
||||
)
|
||||
.await;
|
||||
assert!(approved.is_ok());
|
||||
assert_eq!(calls.load(Ordering::SeqCst), 2);
|
||||
let requests = recording.requests();
|
||||
assert_eq!(requests.len(), 3);
|
||||
assert_eq!(requests[2].approval, ApprovalEvidence::Granted);
|
||||
assert_eq!(recording.permits(), 2);
|
||||
assert_eq!(recording.snapshot().await.expect("snapshot").executing, 0);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn mandatory_safety_store_outage_fails_closed_before_admission() {
|
||||
let schema_url = crank_test_support::postgres_schema_url("admission_confirmation_outage").await;
|
||||
let pool = schema_pool(&schema_url).await;
|
||||
let recording = Arc::new(RecordingAdmission::new(Arc::new(
|
||||
PostgresExecutionAdmission::new(
|
||||
pool,
|
||||
AdmissionLimits {
|
||||
global_limit: 4,
|
||||
agent_limit: 4,
|
||||
tool_limit: 4,
|
||||
queue_limit: 8,
|
||||
},
|
||||
crank_core::AdmissionSchedulerConfig::default(),
|
||||
)
|
||||
.expect("valid admission limits"),
|
||||
)));
|
||||
let calls = Arc::new(AtomicUsize::new(0));
|
||||
// Confirmation is mandatory for this Tool, but no safety store is wired: the request must fail
|
||||
// closed instead of reserving capacity and hoping for an in-memory fallback.
|
||||
let runtime = confirmation_runtime(Arc::clone(&recording), None, Arc::clone(&calls));
|
||||
let operation = confirmation_operation(3);
|
||||
|
||||
let failure = execute_in(
|
||||
&runtime,
|
||||
&operation,
|
||||
&json!({ "reason": "no store" }),
|
||||
&confirmation_context(),
|
||||
)
|
||||
.await
|
||||
.expect_err("a mandatory safety store outage must fail closed");
|
||||
assert_eq!(
|
||||
failure.error_code(),
|
||||
ExecutionErrorCode::SafetyStoreUnavailable
|
||||
);
|
||||
assert_eq!(calls.load(Ordering::SeqCst), 0);
|
||||
assert_eq!(recording.permits(), 0);
|
||||
let after_missing_store = recording.requests().len();
|
||||
|
||||
// The same Tool with a claimed approval and a *failing* safety store never reaches the capacity
|
||||
// store at all: the approval claim stays unverified, so no permit and no outbound call exist.
|
||||
let failing = confirmation_runtime(
|
||||
Arc::clone(&recording),
|
||||
Some(Arc::new(UnavailableSafetyStore)),
|
||||
Arc::clone(&calls),
|
||||
);
|
||||
let outage = execute_in(
|
||||
&failing,
|
||||
&operation,
|
||||
&json!({ "reason": "failing store" }),
|
||||
&confirmation_context().with_confirmation_token("ct_unavailable"),
|
||||
)
|
||||
.await
|
||||
.expect_err("an unreachable safety store must refuse the claimed approval");
|
||||
assert_eq!(
|
||||
outage.error_code(),
|
||||
ExecutionErrorCode::SafetyStoreUnavailable
|
||||
);
|
||||
assert_eq!(
|
||||
recording.requests().len(),
|
||||
after_missing_store,
|
||||
"an unverified approval never becomes a capacity request"
|
||||
);
|
||||
assert_eq!(recording.permits(), 0);
|
||||
assert_eq!(calls.load(Ordering::SeqCst), 0);
|
||||
}
|
||||
|
||||
/// Coordination store whose mandatory backend is down: every operation fails closed.
|
||||
struct UnavailableSafetyStore;
|
||||
|
||||
impl UnavailableSafetyStore {
|
||||
fn error() -> crank_core::CacheStoreError {
|
||||
crank_core::CacheStoreError::Unavailable {
|
||||
message: "test backend unavailable".to_owned(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl crank_core::CoordinationStateStore for UnavailableSafetyStore {
|
||||
async fn get_value(
|
||||
&self,
|
||||
_scope: crank_core::CacheScope,
|
||||
_key: &str,
|
||||
) -> Result<Option<crank_core::CoordinationStateValue>, crank_core::CacheStoreError> {
|
||||
Err(Self::error())
|
||||
}
|
||||
|
||||
async fn put_value(
|
||||
&self,
|
||||
_scope: crank_core::CacheScope,
|
||||
_key: &str,
|
||||
_value: crank_core::CoordinationStateValue,
|
||||
_ttl: Duration,
|
||||
) -> Result<(), crank_core::CacheStoreError> {
|
||||
Err(Self::error())
|
||||
}
|
||||
|
||||
async fn delete_value(
|
||||
&self,
|
||||
_scope: crank_core::CacheScope,
|
||||
_key: &str,
|
||||
) -> Result<(), crank_core::CacheStoreError> {
|
||||
Err(Self::error())
|
||||
}
|
||||
|
||||
async fn take_value(
|
||||
&self,
|
||||
_scope: crank_core::CacheScope,
|
||||
_key: &str,
|
||||
) -> Result<Option<crank_core::CoordinationStateValue>, crank_core::CacheStoreError> {
|
||||
Err(Self::error())
|
||||
}
|
||||
|
||||
async fn reserve_value(
|
||||
&self,
|
||||
_scope: crank_core::CacheScope,
|
||||
_key: &str,
|
||||
_value: crank_core::CoordinationStateValue,
|
||||
_ttl: Duration,
|
||||
) -> Result<crank_core::CoordinationStateReservation, crank_core::CacheStoreError> {
|
||||
Err(Self::error())
|
||||
}
|
||||
|
||||
async fn compare_and_set_value(
|
||||
&self,
|
||||
_scope: crank_core::CacheScope,
|
||||
_key: &str,
|
||||
_expected: &crank_core::CoordinationStateValue,
|
||||
_value: crank_core::CoordinationStateValue,
|
||||
_ttl: Duration,
|
||||
) -> Result<bool, crank_core::CacheStoreError> {
|
||||
Err(Self::error())
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,7 @@
|
||||
mod integration {
|
||||
mod catalog_access;
|
||||
mod common;
|
||||
mod durable_tasks;
|
||||
mod era_isolation;
|
||||
mod execution_certainty;
|
||||
mod execution_stages;
|
||||
|
||||
@@ -621,6 +621,7 @@ pub(super) fn test_operation(base_url: &str, name: &str) -> Operation<Schema, Ma
|
||||
idempotency: None,
|
||||
safety: None,
|
||||
approval_policy: None,
|
||||
execution_policy: None,
|
||||
auth_profile_ref: None,
|
||||
headers: BTreeMap::new(),
|
||||
},
|
||||
|
||||
@@ -0,0 +1,413 @@
|
||||
//! Story 4.3 ATDD: durable Attempt ID reaches the adapter attempt span (PF-1).
|
||||
//!
|
||||
//! End-to-end: a real durable Task worker dispatches a retrying GET through a real local
|
||||
//! upstream, and the `adapter_attempt` spans carry the same durable Attempt ID that is
|
||||
//! persisted in `tasks.current_attempt_id` on both attempts.
|
||||
|
||||
use super::super::common;
|
||||
|
||||
use axum::Router;
|
||||
use axum::http::StatusCode;
|
||||
use axum::routing::get;
|
||||
use crank_community_mcp::TaskWorkerHandler;
|
||||
use crank_core::{
|
||||
AgentOperationBinding, CorrelationContext, RetryPolicy, Target, ToolExecutionPolicy,
|
||||
};
|
||||
use crank_runtime::{
|
||||
OutboundHttpPolicy, SecretCrypto, TaskWorker, TaskWorkerConfig, community_with_outbound_policy,
|
||||
};
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
use std::sync::{Arc, Mutex};
|
||||
use time::OffsetDateTime;
|
||||
use tracing::{Id, Subscriber, field::Visit};
|
||||
use tracing_subscriber::{Layer, layer::SubscriberExt, registry::LookupSpan};
|
||||
|
||||
const AGENT_SLUG: &str = "reports";
|
||||
const TOOL_NAME: &str = "attempt_trace";
|
||||
const KEY: &str = "attempt-trace-key-1";
|
||||
|
||||
async fn publish(
|
||||
registry: &crank_registry::PostgresRegistry,
|
||||
operation_id: &crank_core::OperationId,
|
||||
version: u32,
|
||||
) {
|
||||
registry
|
||||
.publish_operation(crank_registry::PublishRequest {
|
||||
workspace_id: &common::test_workspace_id(),
|
||||
operation_id,
|
||||
version,
|
||||
published_at: &OffsetDateTime::parse(
|
||||
"2026-03-26T10:00:00Z",
|
||||
&time::format_description::well_known::Rfc3339,
|
||||
)
|
||||
.unwrap(),
|
||||
published_by: Some("alice"),
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
async fn application_with_store(
|
||||
registry: &crank_registry::PostgresRegistry,
|
||||
) -> (
|
||||
crank_community_mcp::TaskApplication,
|
||||
std::sync::Arc<crank_registry::PostgresTaskStore>,
|
||||
SecretCrypto,
|
||||
) {
|
||||
let crypto = SecretCrypto::new("test-master-key-00000000000000000000000000000000").unwrap();
|
||||
let observed_at = OffsetDateTime::now_utc();
|
||||
registry
|
||||
.verify_or_register_master_key_identity(crank_registry::MasterKeyIdentityCandidate {
|
||||
epoch: crypto.master_key_epoch(),
|
||||
fingerprint: crypto.master_key_fingerprint(),
|
||||
cipher_contract: crank_registry::MASTER_KEY_CIPHER_CONTRACT,
|
||||
observed_at: &observed_at,
|
||||
})
|
||||
.await
|
||||
.expect("test master-key identity registered");
|
||||
let store = std::sync::Arc::new(
|
||||
crank_registry::PostgresTaskStore::new(
|
||||
registry.pool().clone(),
|
||||
crank_registry::AdmissionLimits {
|
||||
global_limit: 4,
|
||||
agent_limit: 4,
|
||||
tool_limit: 4,
|
||||
queue_limit: 8,
|
||||
},
|
||||
Default::default(),
|
||||
)
|
||||
.expect("valid task store configuration"),
|
||||
);
|
||||
let tasks = crank_community_mcp::TaskApplication::new(
|
||||
registry.clone(),
|
||||
std::time::Duration::ZERO,
|
||||
std::sync::Arc::new(crank_runtime::InMemoryCoordinationStateStore::default()),
|
||||
crank_runtime::TaskService::with_secret_crypto(
|
||||
store.clone(),
|
||||
std::sync::Arc::new(crypto.clone()),
|
||||
),
|
||||
);
|
||||
(tasks, store, crypto)
|
||||
}
|
||||
|
||||
async fn principal(
|
||||
registry: &crank_registry::PostgresRegistry,
|
||||
name: &str,
|
||||
scopes: &[crank_core::PlatformApiKeyScope],
|
||||
) -> crank_community_mcp::TaskPrincipal {
|
||||
let token = common::create_platform_api_key(registry, AGENT_SLUG, name, scopes).await;
|
||||
let secret_hash = common::hash_access_secret(&token);
|
||||
let api_key = registry
|
||||
.get_platform_api_key_by_secret_for_agent_slug(
|
||||
common::test_workspace_slug(),
|
||||
AGENT_SLUG,
|
||||
&secret_hash,
|
||||
)
|
||||
.await
|
||||
.unwrap()
|
||||
.expect("an active platform key resolves");
|
||||
registry
|
||||
.touch_platform_api_key(
|
||||
&api_key.api_key.workspace_id,
|
||||
&api_key.api_key.id,
|
||||
&OffsetDateTime::now_utc(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
crank_community_mcp::TaskPrincipal::Agent {
|
||||
workspace_slug: common::test_workspace_slug().to_owned(),
|
||||
agent_slug: AGENT_SLUG.to_owned(),
|
||||
credential: crank_core::VerifiedMachineCredential {
|
||||
machine_access_mode: crank_core::MachineAccessMode::StaticAgentKey,
|
||||
max_security_level: crank_core::OperationSecurityLevel::Standard,
|
||||
scopes: api_key.api_key.scopes.clone(),
|
||||
platform_api_key_id: Some(api_key.api_key.id.clone()),
|
||||
},
|
||||
}
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn adapter_attempt_span_carries_durable_attempt_id() {
|
||||
let registry = common::test_registry().await;
|
||||
let calls = Arc::new(AtomicUsize::new(0));
|
||||
let upstream_app = Router::new().route(
|
||||
"/crm/leads",
|
||||
get({
|
||||
let calls = Arc::clone(&calls);
|
||||
move || {
|
||||
let calls = Arc::clone(&calls);
|
||||
async move {
|
||||
let n = calls.fetch_add(1, Ordering::SeqCst);
|
||||
if n == 0 {
|
||||
return (
|
||||
StatusCode::INTERNAL_SERVER_ERROR,
|
||||
axum::Json(serde_json::json!({"error":"boom"})),
|
||||
);
|
||||
}
|
||||
(
|
||||
StatusCode::OK,
|
||||
axum::Json(serde_json::json!({"id":"lead-1"})),
|
||||
)
|
||||
}
|
||||
}
|
||||
}),
|
||||
);
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let server = tokio::spawn(async move { axum::serve(listener, upstream_app).await.unwrap() });
|
||||
let upstream = format!("http://{address}");
|
||||
|
||||
let mut operation = common::test_operation(&upstream, TOOL_NAME);
|
||||
let Target::Rest(target) = &mut operation.target;
|
||||
target.method = crank_core::HttpMethod::Get;
|
||||
operation.execution_config.execution_policy = Some(ToolExecutionPolicy {
|
||||
mode: crank_core::ToolExecutionMode::Background,
|
||||
deadline_ms: 60_000,
|
||||
no_tasks_fallback: crank_core::NoTasksFallback::Unsupported,
|
||||
});
|
||||
operation.execution_config.retry_policy = Some(RetryPolicy { max_attempts: 2 });
|
||||
registry
|
||||
.create_operation(&common::test_workspace_id(), &operation, Some("alice"))
|
||||
.await
|
||||
.unwrap();
|
||||
publish(®istry, &operation.id, 1).await;
|
||||
common::publish_agent_with_bindings(
|
||||
®istry,
|
||||
AGENT_SLUG,
|
||||
vec![AgentOperationBinding {
|
||||
operation_id: operation.id.clone(),
|
||||
operation_version: 1,
|
||||
tool_name: operation.name.clone(),
|
||||
tool_title: operation.tool_description.title.clone(),
|
||||
tool_description_override: None,
|
||||
enabled: true,
|
||||
}],
|
||||
)
|
||||
.await;
|
||||
|
||||
let caller = principal(
|
||||
®istry,
|
||||
"attempt-trace",
|
||||
&[
|
||||
crank_core::PlatformApiKeyScope::Read,
|
||||
crank_core::PlatformApiKeyScope::Write,
|
||||
],
|
||||
)
|
||||
.await;
|
||||
|
||||
let (tasks, store, crypto) = application_with_store(®istry).await;
|
||||
let acceptance = tasks
|
||||
.accept_background(
|
||||
&caller,
|
||||
TOOL_NAME,
|
||||
None,
|
||||
KEY,
|
||||
&serde_json::json!({"email": "user@example.com"}),
|
||||
&CorrelationContext::generate(),
|
||||
)
|
||||
.await
|
||||
.expect("durable acceptance");
|
||||
|
||||
let runtime =
|
||||
community_with_outbound_policy(OutboundHttpPolicy::allowing_hosts(["127.0.0.1"])).build();
|
||||
let handler = Arc::new(TaskWorkerHandler::from_application(
|
||||
&tasks,
|
||||
registry.clone(),
|
||||
runtime,
|
||||
crypto,
|
||||
));
|
||||
let mut config = TaskWorkerConfig::default();
|
||||
config.owner = "runtime-worker-attempt-trace".to_owned();
|
||||
config.batch_limit = 1;
|
||||
config.lease_ms = 10_000;
|
||||
config.poll_interval = std::time::Duration::from_millis(50);
|
||||
config.max_inflight = 1;
|
||||
config.shutdown_timeout = std::time::Duration::from_secs(5);
|
||||
let worker = TaskWorker::new(store.clone(), handler, config).expect("valid worker");
|
||||
let stop_flag = worker.stop_flag();
|
||||
|
||||
let capture = TraceCapture::default();
|
||||
let subscriber = tracing_subscriber::registry().with(capture.clone());
|
||||
let _guard = tracing::subscriber::set_default(subscriber);
|
||||
|
||||
let worker_task = tokio::spawn(async move { worker.run().await });
|
||||
|
||||
let mut state = None;
|
||||
for _ in 0..200 {
|
||||
tokio::time::sleep(std::time::Duration::from_millis(50)).await;
|
||||
let current: Option<String> =
|
||||
sqlx::query_scalar("select state from tasks where task_id = $1")
|
||||
.bind(acceptance.task_id.as_uuid())
|
||||
.fetch_optional(registry.pool())
|
||||
.await
|
||||
.unwrap();
|
||||
state = current;
|
||||
if state.as_deref() == Some("completed") {
|
||||
break;
|
||||
}
|
||||
}
|
||||
stop_flag.store(true, Ordering::SeqCst);
|
||||
tokio::time::timeout(std::time::Duration::from_secs(10), worker_task)
|
||||
.await
|
||||
.expect("worker stops inside the budget")
|
||||
.expect("worker exits cleanly")
|
||||
.expect("worker reports no error");
|
||||
server.abort();
|
||||
|
||||
let durable_attempt_id: Option<String> = sqlx::query_scalar::<_, Option<String>>(
|
||||
"select current_attempt_id from tasks where task_id = $1",
|
||||
)
|
||||
.bind(acceptance.task_id.as_uuid())
|
||||
.fetch_one(registry.pool())
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(state.as_deref(), Some("completed"));
|
||||
|
||||
let spans = capture.snapshot();
|
||||
let attempt_spans: Vec<_> = spans
|
||||
.iter()
|
||||
.filter(|s| s.name == "adapter_attempt")
|
||||
.collect();
|
||||
assert_eq!(attempt_spans.len(), 2, "two adapter_attempt spans");
|
||||
for span in &attempt_spans {
|
||||
let aid = span.fields.get("attempt_id").cloned().unwrap_or_default();
|
||||
assert!(!aid.is_empty(), "attempt_id must not be empty");
|
||||
assert!(
|
||||
!aid.contains("traceparent"),
|
||||
"attempt_id must not contain traceparent"
|
||||
);
|
||||
assert_eq!(
|
||||
Some(aid.as_str()),
|
||||
durable_attempt_id.as_deref(),
|
||||
"span attempt_id must equal durable attempt id"
|
||||
);
|
||||
}
|
||||
let ids: Vec<String> = attempt_spans
|
||||
.iter()
|
||||
.map(|s| s.fields.get("attempt_id").cloned().unwrap_or_default())
|
||||
.collect();
|
||||
assert_eq!(ids[0], ids[1], "same durable id on both retries");
|
||||
assert_eq!(
|
||||
spans
|
||||
.iter()
|
||||
.filter(|span| span.name == "durable_task_attempt")
|
||||
.count(),
|
||||
1,
|
||||
"one durable attempt span per dispatch"
|
||||
);
|
||||
let runtime_span = spans
|
||||
.iter()
|
||||
.find(|span| span.name == "runtime.execute")
|
||||
.expect("runtime.execute span");
|
||||
assert_eq!(
|
||||
runtime_span.parent_name,
|
||||
Some("durable_task_attempt"),
|
||||
"the execution continues the durable attempt trace"
|
||||
);
|
||||
for span in &attempt_spans {
|
||||
assert_eq!(
|
||||
span.parent_name,
|
||||
Some("runtime.execute"),
|
||||
"each retry is a child attempt span under the durable execution"
|
||||
);
|
||||
}
|
||||
|
||||
let attempts: Vec<String> = attempt_spans
|
||||
.iter()
|
||||
.map(|s| s.fields.get("attempt").cloned().unwrap_or_default())
|
||||
.collect();
|
||||
assert!(attempts.contains(&"1".to_string()));
|
||||
assert!(attempts.contains(&"2".to_string()));
|
||||
for span in &attempt_spans {
|
||||
assert_eq!(
|
||||
span.fields.get("max_attempts").cloned().unwrap_or_default(),
|
||||
"2"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// TraceCapture minimal port from crates/crank-runtime/tests/stages.rs
|
||||
#[derive(Clone, Default)]
|
||||
struct TraceCapture {
|
||||
spans: Arc<Mutex<Vec<CapturedSpan>>>,
|
||||
}
|
||||
|
||||
impl TraceCapture {
|
||||
fn snapshot(&self) -> Vec<CapturedSpan> {
|
||||
self.spans.lock().expect("span lock").clone()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
struct CapturedSpan {
|
||||
name: &'static str,
|
||||
parent_name: Option<&'static str>,
|
||||
fields: std::collections::BTreeMap<String, String>,
|
||||
}
|
||||
|
||||
impl<S> Layer<S> for TraceCapture
|
||||
where
|
||||
S: Subscriber + for<'lookup> LookupSpan<'lookup>,
|
||||
{
|
||||
fn on_new_span(
|
||||
&self,
|
||||
attributes: &tracing::span::Attributes<'_>,
|
||||
id: &Id,
|
||||
context: tracing_subscriber::layer::Context<'_, S>,
|
||||
) {
|
||||
let parent = attributes
|
||||
.parent()
|
||||
.and_then(|parent| context.span(parent))
|
||||
.or_else(|| {
|
||||
attributes
|
||||
.is_contextual()
|
||||
.then(|| context.lookup_current())
|
||||
.flatten()
|
||||
});
|
||||
let mut visitor = FieldVisitor::default();
|
||||
attributes.record(&mut visitor);
|
||||
let mut spans = self.spans.lock().expect("span lock");
|
||||
let index = spans.len();
|
||||
spans.push(CapturedSpan {
|
||||
name: attributes.metadata().name(),
|
||||
parent_name: parent.map(|span| span.metadata().name()),
|
||||
fields: visitor.fields,
|
||||
});
|
||||
context
|
||||
.span(id)
|
||||
.expect("span exists")
|
||||
.extensions_mut()
|
||||
.insert(index);
|
||||
}
|
||||
|
||||
fn on_record(
|
||||
&self,
|
||||
id: &Id,
|
||||
values: &tracing::span::Record<'_>,
|
||||
context: tracing_subscriber::layer::Context<'_, S>,
|
||||
) {
|
||||
let mut visitor = FieldVisitor::default();
|
||||
values.record(&mut visitor);
|
||||
let span = context.span(id).expect("span exists");
|
||||
let index = *span.extensions().get::<usize>().expect("capture index");
|
||||
self.spans.lock().expect("span lock")[index]
|
||||
.fields
|
||||
.extend(visitor.fields);
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct FieldVisitor {
|
||||
fields: std::collections::BTreeMap<String, String>,
|
||||
}
|
||||
|
||||
impl Visit for FieldVisitor {
|
||||
fn record_str(&mut self, field: &tracing::field::Field, value: &str) {
|
||||
self.fields
|
||||
.insert(field.name().to_owned(), value.to_owned());
|
||||
}
|
||||
fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn std::fmt::Debug) {
|
||||
self.fields
|
||||
.insert(field.name().to_owned(), format!("{value:?}"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,610 @@
|
||||
//! ATDD Story 4.2 (FR-22/FR-23): the durable Task application entry over a real published catalog
|
||||
//! and a real PostgreSQL schema.
|
||||
//!
|
||||
//! These oracles drive the production application entry (`TaskApplication`) that the mcp-server
|
||||
//! composition root constructs: a verified machine credential is checked against the published Tool,
|
||||
//! the Task is accepted durably, a freshly constructed application instance reads the same identity
|
||||
//! and pins, replay/version conflicts never rebind, foreign callers receive no metadata, and a missing
|
||||
//! Task store fails closed and reports readiness as not ready. The public `tools/call` wire stays
|
||||
//! synchronous/unsupported: this suite never calls it.
|
||||
|
||||
use super::common;
|
||||
|
||||
use std::time::Duration;
|
||||
|
||||
use crank_community_mcp::{TaskApplication, TaskApplicationError, TaskPrincipal};
|
||||
use crank_core::{
|
||||
AgentOperationBinding, CorrelationContext, NoTasksFallback, PlatformApiKeyScope, RequestId,
|
||||
TaskAcceptRequest, TaskEnvelope, TaskId, TaskOwnerKind, TaskPins, TaskState, TaskStore,
|
||||
TaskSupportIds, ToolExecutionMode, ToolExecutionPolicy,
|
||||
};
|
||||
use crank_registry::{
|
||||
AdmissionLimits, CreateVersionRequest, PostgresRegistry, PostgresTaskStore, PublishRequest,
|
||||
};
|
||||
use crank_runtime::{InMemoryCoordinationStateStore, SecretCrypto, TaskService};
|
||||
use serde_json::json;
|
||||
use sqlx::{PgPool, Row};
|
||||
use time::{OffsetDateTime, format_description::well_known::Rfc3339};
|
||||
|
||||
const AGENT_SLUG: &str = "reports";
|
||||
const TOOL_NAME: &str = "report_gen";
|
||||
const KEY: &str = "retry-key-1";
|
||||
|
||||
fn operation(policy: ToolExecutionPolicy) -> crank_registry::RegistryOperation {
|
||||
let mut operation = common::test_operation("https://api.example.com", TOOL_NAME);
|
||||
operation.execution_config.execution_policy = Some(policy);
|
||||
operation
|
||||
}
|
||||
|
||||
fn background_policy() -> ToolExecutionPolicy {
|
||||
ToolExecutionPolicy {
|
||||
mode: ToolExecutionMode::Background,
|
||||
deadline_ms: 60_000,
|
||||
no_tasks_fallback: NoTasksFallback::Unsupported,
|
||||
}
|
||||
}
|
||||
|
||||
async fn seed_tool(registry: &PostgresRegistry, policy: ToolExecutionPolicy) {
|
||||
let operation = operation(policy);
|
||||
registry
|
||||
.create_operation(&common::test_workspace_id(), &operation, Some("alice"))
|
||||
.await
|
||||
.unwrap();
|
||||
publish(registry, &operation.id, 1).await;
|
||||
// A second, explicitly synchronous Tool of the same Agent: the durable entry must refuse it.
|
||||
let synchronous = common::test_operation("https://api.example.com", "report_sync");
|
||||
registry
|
||||
.create_operation(&common::test_workspace_id(), &synchronous, Some("alice"))
|
||||
.await
|
||||
.unwrap();
|
||||
publish(registry, &synchronous.id, 1).await;
|
||||
let binding = AgentOperationBinding {
|
||||
operation_id: operation.id.clone(),
|
||||
operation_version: 1,
|
||||
tool_name: operation.name.clone(),
|
||||
tool_title: operation.tool_description.title.clone(),
|
||||
tool_description_override: None,
|
||||
enabled: true,
|
||||
};
|
||||
let synchronous_binding = AgentOperationBinding {
|
||||
operation_id: synchronous.id.clone(),
|
||||
operation_version: 1,
|
||||
tool_name: synchronous.name.clone(),
|
||||
tool_title: synchronous.tool_description.title.clone(),
|
||||
tool_description_override: None,
|
||||
enabled: true,
|
||||
};
|
||||
common::publish_agent_with_bindings(registry, AGENT_SLUG, vec![binding, synchronous_binding])
|
||||
.await;
|
||||
}
|
||||
|
||||
async fn publish(
|
||||
registry: &PostgresRegistry,
|
||||
operation_id: &crank_core::OperationId,
|
||||
version: u32,
|
||||
) {
|
||||
registry
|
||||
.publish_operation(PublishRequest {
|
||||
workspace_id: &common::test_workspace_id(),
|
||||
operation_id,
|
||||
version,
|
||||
published_at: &OffsetDateTime::parse("2026-03-26T10:00:00Z", &Rfc3339).unwrap(),
|
||||
published_by: Some("alice"),
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
async fn publish_tool_version(registry: &PostgresRegistry, version: u32) {
|
||||
let mut next = operation(background_policy());
|
||||
next.version = version;
|
||||
next.status = crank_core::OperationStatus::Draft;
|
||||
next.published_at = None;
|
||||
registry
|
||||
.create_version(CreateVersionRequest {
|
||||
workspace_id: &common::test_workspace_id(),
|
||||
snapshot: &next,
|
||||
change_note: Some("next publication"),
|
||||
created_by: Some("alice"),
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
publish(registry, &next.id, version).await;
|
||||
// The agent catalog must bind the published Tool version for the new publication to be addressed.
|
||||
let agent_id = common::test_agent_id(AGENT_SLUG);
|
||||
let draft = crank_core::AgentVersion {
|
||||
agent_id: agent_id.clone(),
|
||||
version: 2,
|
||||
status: crank_core::AgentStatus::Draft,
|
||||
instructions: json!({}),
|
||||
tool_selection_policy: Default::default(),
|
||||
created_at: OffsetDateTime::parse("2026-03-26T10:01:00Z", &Rfc3339).unwrap(),
|
||||
};
|
||||
registry
|
||||
.create_agent_draft_version(crank_registry::CreateAgentDraftVersionRequest {
|
||||
workspace_id: &common::test_workspace_id(),
|
||||
agent_id: &agent_id,
|
||||
version: &draft,
|
||||
bindings: &[AgentOperationBinding {
|
||||
operation_id: next.id.clone(),
|
||||
operation_version: version,
|
||||
tool_name: next.name.clone(),
|
||||
tool_title: next.tool_description.title.clone(),
|
||||
tool_description_override: None,
|
||||
enabled: true,
|
||||
}],
|
||||
updated_at: &OffsetDateTime::parse("2026-03-26T10:01:00Z", &Rfc3339).unwrap(),
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
registry
|
||||
.publish_agent(crank_registry::PublishAgentRequest {
|
||||
workspace_id: &common::test_workspace_id(),
|
||||
agent_id: &agent_id,
|
||||
version: 2,
|
||||
published_at: &OffsetDateTime::parse("2026-03-26T10:02:00Z", &Rfc3339).unwrap(),
|
||||
published_by: Some("alice"),
|
||||
expected_state: None,
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
const TEST_MASTER_KEY: &str = "test-master-key-00000000000000000000000000000000";
|
||||
|
||||
fn task_service(pool: PgPool, crypto: SecretCrypto) -> TaskService {
|
||||
let store = PostgresTaskStore::new(
|
||||
pool,
|
||||
AdmissionLimits {
|
||||
global_limit: 4,
|
||||
agent_limit: 4,
|
||||
tool_limit: 4,
|
||||
queue_limit: 8,
|
||||
},
|
||||
Default::default(),
|
||||
)
|
||||
.expect("valid task store configuration");
|
||||
TaskService::with_secret_crypto(std::sync::Arc::new(store), std::sync::Arc::new(crypto))
|
||||
}
|
||||
|
||||
/// The application entry under the same encrypted-input authority the production process uses.
|
||||
async fn application(registry: &PostgresRegistry) -> TaskApplication {
|
||||
let crypto = SecretCrypto::new(TEST_MASTER_KEY).expect("test master key");
|
||||
let observed_at = OffsetDateTime::now_utc();
|
||||
registry
|
||||
.verify_or_register_master_key_identity(crank_registry::MasterKeyIdentityCandidate {
|
||||
epoch: crypto.master_key_epoch(),
|
||||
fingerprint: crypto.master_key_fingerprint(),
|
||||
cipher_contract: crank_registry::MASTER_KEY_CIPHER_CONTRACT,
|
||||
observed_at: &observed_at,
|
||||
})
|
||||
.await
|
||||
.expect("test master-key identity registered");
|
||||
TaskApplication::new(
|
||||
registry.clone(),
|
||||
Duration::from_millis(0),
|
||||
std::sync::Arc::new(InMemoryCoordinationStateStore::default()),
|
||||
task_service(registry.pool().clone(), crypto),
|
||||
)
|
||||
}
|
||||
|
||||
async fn principal(
|
||||
registry: &PostgresRegistry,
|
||||
name: &str,
|
||||
scopes: &[PlatformApiKeyScope],
|
||||
) -> TaskPrincipal {
|
||||
let token = common::create_platform_api_key(registry, AGENT_SLUG, name, scopes).await;
|
||||
// The production machine-access path resolves the presented secret against the active platform
|
||||
// key of the addressed Agent and derives the scope identity from that verified record.
|
||||
let secret_hash = common::hash_access_secret(&token);
|
||||
let api_key = registry
|
||||
.get_platform_api_key_by_secret_for_agent_slug(
|
||||
common::test_workspace_slug(),
|
||||
AGENT_SLUG,
|
||||
&secret_hash,
|
||||
)
|
||||
.await
|
||||
.unwrap()
|
||||
.expect("an active platform key resolves");
|
||||
registry
|
||||
.touch_platform_api_key(
|
||||
&api_key.api_key.workspace_id,
|
||||
&api_key.api_key.id,
|
||||
&OffsetDateTime::now_utc(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
TaskPrincipal::Agent {
|
||||
workspace_slug: common::test_workspace_slug().to_owned(),
|
||||
agent_slug: AGENT_SLUG.to_owned(),
|
||||
credential: crank_core::VerifiedMachineCredential {
|
||||
machine_access_mode: crank_core::MachineAccessMode::StaticAgentKey,
|
||||
max_security_level: crank_core::OperationSecurityLevel::Standard,
|
||||
scopes: api_key.api_key.scopes.clone(),
|
||||
platform_api_key_id: Some(api_key.api_key.id.clone()),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn unsampled_correlation() -> CorrelationContext {
|
||||
CorrelationContext::new(
|
||||
crank_core::RequestId::generate(),
|
||||
crank_core::TraceContext::parse("00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-00")
|
||||
.unwrap(),
|
||||
)
|
||||
}
|
||||
|
||||
async fn counts(pool: &PgPool) -> (i64, i64) {
|
||||
let row = sqlx::query(
|
||||
"select
|
||||
(select count(*)::bigint from tasks) as tasks,
|
||||
(select count(*)::bigint from execution_admission_entries where task_id is not null)
|
||||
as intents",
|
||||
)
|
||||
.fetch_one(pool)
|
||||
.await
|
||||
.unwrap();
|
||||
(row.get("tasks"), row.get("intents"))
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_verified_caller_receives_a_durable_task_that_a_new_instance_reads() {
|
||||
let registry = common::test_registry().await;
|
||||
seed_tool(®istry, background_policy()).await;
|
||||
let caller = principal(
|
||||
®istry,
|
||||
"task-accept",
|
||||
&[PlatformApiKeyScope::Read, PlatformApiKeyScope::Write],
|
||||
)
|
||||
.await;
|
||||
let correlation = unsampled_correlation();
|
||||
let app = application(®istry).await;
|
||||
|
||||
let acceptance = app
|
||||
.accept_background(
|
||||
&caller,
|
||||
TOOL_NAME,
|
||||
None,
|
||||
KEY,
|
||||
&json!({"report": "q3"}),
|
||||
&correlation,
|
||||
)
|
||||
.await
|
||||
.expect("acceptance over the real publication");
|
||||
assert_eq!(acceptance.state, TaskState::Queued);
|
||||
assert!(!acceptance.replayed);
|
||||
assert_eq!(acceptance.operation_version, 1);
|
||||
assert_eq!(acceptance.support.request_id, *correlation.request_id());
|
||||
assert_eq!(acceptance.support.trace_id, *correlation.trace_id());
|
||||
assert!(!acceptance.support.trace_sampled);
|
||||
assert_eq!(
|
||||
uuid::Uuid::parse_str(&acceptance.task_id.to_string())
|
||||
.unwrap()
|
||||
.get_version_num(),
|
||||
7,
|
||||
"the durable Task id is UUIDv7"
|
||||
);
|
||||
// Task, dispatch intent and queue slot committed together.
|
||||
assert_eq!(counts(registry.pool()).await, (1, 1));
|
||||
|
||||
// A freshly constructed application + service reads the same durable identity and pins.
|
||||
let reader = application(®istry).await;
|
||||
let record = reader
|
||||
.status(&caller, TOOL_NAME, acceptance.task_id)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(record.state, TaskState::Queued);
|
||||
assert_eq!(record.pins.operation_version, 1);
|
||||
assert_eq!(record.pins.policy_mode, ToolExecutionMode::Background);
|
||||
assert_eq!(record.support.request_id, acceptance.support.request_id);
|
||||
assert_eq!(record.support.traceparent, acceptance.support.traceparent);
|
||||
assert!(!record.support.trace_sampled);
|
||||
let outcome = reader
|
||||
.result(&caller, TOOL_NAME, acceptance.task_id)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(outcome.result.is_none() && outcome.error.is_none());
|
||||
|
||||
// Replay of the same scoped key and input returns the accepted Task instead of a new one.
|
||||
let replay = app
|
||||
.accept_background(
|
||||
&caller,
|
||||
TOOL_NAME,
|
||||
None,
|
||||
KEY,
|
||||
&json!({"report": "q3"}),
|
||||
&unsampled_correlation(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(replay.task_id, acceptance.task_id);
|
||||
assert!(replay.replayed);
|
||||
assert_eq!(counts(registry.pool()).await, (1, 1));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_new_publication_never_rebinds_an_accepted_task() {
|
||||
let registry = common::test_registry().await;
|
||||
seed_tool(®istry, background_policy()).await;
|
||||
let caller = principal(
|
||||
®istry,
|
||||
"task-rebind",
|
||||
&[PlatformApiKeyScope::Read, PlatformApiKeyScope::Write],
|
||||
)
|
||||
.await;
|
||||
let app = application(®istry).await;
|
||||
let accepted = app
|
||||
.accept_background(
|
||||
&caller,
|
||||
TOOL_NAME,
|
||||
None,
|
||||
KEY,
|
||||
&json!({"report": "q3"}),
|
||||
&unsampled_correlation(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let before = app
|
||||
.status(&caller, TOOL_NAME, accepted.task_id)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
publish_tool_version(®istry, 2).await;
|
||||
|
||||
// The same retry keeps the accepted Task and its v1 pin; it never becomes a v2 Task.
|
||||
let replay = app
|
||||
.accept_background(
|
||||
&caller,
|
||||
TOOL_NAME,
|
||||
None,
|
||||
KEY,
|
||||
&json!({"report": "q3"}),
|
||||
&unsampled_correlation(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(replay.task_id, accepted.task_id);
|
||||
assert_eq!(replay.operation_version, 1);
|
||||
let after = app
|
||||
.status(&caller, TOOL_NAME, accepted.task_id)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(after.pins.operation_version, 1);
|
||||
assert_eq!(after.support.request_id, before.support.request_id);
|
||||
assert_eq!(counts(registry.pool()).await, (1, 1));
|
||||
|
||||
// An explicit other exact version is a typed conflict, not a rebind.
|
||||
let explicit = app
|
||||
.accept_background(
|
||||
&caller,
|
||||
TOOL_NAME,
|
||||
Some(2),
|
||||
KEY,
|
||||
&json!({"report": "q3"}),
|
||||
&unsampled_correlation(),
|
||||
)
|
||||
.await
|
||||
.expect_err("a different explicit pin cannot rebind the accepted Task");
|
||||
assert_eq!(explicit, TaskApplicationError::VersionUnavailable);
|
||||
// The original explicit pin still resolves to the accepted Task.
|
||||
let pinned = app
|
||||
.accept_background(
|
||||
&caller,
|
||||
TOOL_NAME,
|
||||
Some(1),
|
||||
KEY,
|
||||
&json!({"report": "q3"}),
|
||||
&unsampled_correlation(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(pinned.task_id, accepted.task_id);
|
||||
assert_eq!(counts(registry.pool()).await, (1, 1));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn foreign_and_insufficient_callers_receive_no_task_metadata() {
|
||||
let registry = common::test_registry().await;
|
||||
seed_tool(®istry, background_policy()).await;
|
||||
let owner = principal(
|
||||
®istry,
|
||||
"task-owner",
|
||||
&[PlatformApiKeyScope::Read, PlatformApiKeyScope::Write],
|
||||
)
|
||||
.await;
|
||||
let app = application(®istry).await;
|
||||
let accepted = app
|
||||
.accept_background(
|
||||
&owner,
|
||||
TOOL_NAME,
|
||||
None,
|
||||
KEY,
|
||||
&json!({"report": "q3"}),
|
||||
&unsampled_correlation(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
// Positive control: the owner reads its Task.
|
||||
assert!(
|
||||
app.status(&owner, TOOL_NAME, accepted.task_id)
|
||||
.await
|
||||
.is_ok()
|
||||
);
|
||||
|
||||
// A second verified key of the same Agent is another authorization scope: no payload, no metadata.
|
||||
let foreign_scope =
|
||||
principal(®istry, "task-other-scope", &[PlatformApiKeyScope::Read]).await;
|
||||
match app
|
||||
.status(&foreign_scope, TOOL_NAME, accepted.task_id)
|
||||
.await
|
||||
{
|
||||
Err(TaskApplicationError::NotFound) => {}
|
||||
other => panic!("foreign scope must be not-found without metadata, got {other:?}"),
|
||||
}
|
||||
assert!(matches!(
|
||||
app.result(&foreign_scope, TOOL_NAME, accepted.task_id)
|
||||
.await,
|
||||
Err(TaskApplicationError::NotFound)
|
||||
));
|
||||
|
||||
// A synchronous publication is not accepted as background work at all.
|
||||
let synchronous_app = application(®istry).await;
|
||||
let refused = synchronous_app
|
||||
.accept_background(
|
||||
&owner,
|
||||
"report_sync",
|
||||
None,
|
||||
"sync-key",
|
||||
&json!({"report": "q3"}),
|
||||
&unsampled_correlation(),
|
||||
)
|
||||
.await
|
||||
.expect_err("a synchronous policy has no durable acceptance");
|
||||
assert_eq!(refused, TaskApplicationError::NotBackground);
|
||||
assert_eq!(counts(registry.pool()).await, (1, 1));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn admin_owned_tasks_are_scoped_to_that_admin_and_workspace() {
|
||||
let registry = common::test_registry().await;
|
||||
seed_tool(®istry, background_policy()).await;
|
||||
let app = application(®istry).await;
|
||||
let admin = TaskPrincipal::Admin {
|
||||
workspace_slug: common::test_workspace_slug().to_owned(),
|
||||
agent_slug: AGENT_SLUG.to_owned(),
|
||||
user_id: "user_admin_1".to_owned(),
|
||||
};
|
||||
let accepted = app
|
||||
.accept_background(
|
||||
&admin,
|
||||
TOOL_NAME,
|
||||
None,
|
||||
KEY,
|
||||
&json!({"report": "q3"}),
|
||||
&unsampled_correlation(),
|
||||
)
|
||||
.await
|
||||
.expect("an authenticated administrator accepts durable work");
|
||||
assert_eq!(accepted.state, TaskState::Queued);
|
||||
// Positive control: the same administrator reads its own Task.
|
||||
assert!(
|
||||
app.status(&admin, TOOL_NAME, accepted.task_id)
|
||||
.await
|
||||
.is_ok()
|
||||
);
|
||||
|
||||
// An administrator is never a wildcard owner: another admin user and the owning Agent of the
|
||||
// same workspace both see nothing.
|
||||
let other_admin = TaskPrincipal::Admin {
|
||||
workspace_slug: common::test_workspace_slug().to_owned(),
|
||||
agent_slug: AGENT_SLUG.to_owned(),
|
||||
user_id: "user_admin_2".to_owned(),
|
||||
};
|
||||
assert_eq!(
|
||||
app.status(&other_admin, TOOL_NAME, accepted.task_id)
|
||||
.await
|
||||
.unwrap_err(),
|
||||
TaskApplicationError::NotFound
|
||||
);
|
||||
assert_eq!(
|
||||
app.result(&other_admin, TOOL_NAME, accepted.task_id)
|
||||
.await
|
||||
.unwrap_err(),
|
||||
TaskApplicationError::NotFound
|
||||
);
|
||||
let agent = principal(®istry, "task-admin-cross", &[PlatformApiKeyScope::Read]).await;
|
||||
assert_eq!(
|
||||
app.status(&agent, TOOL_NAME, accepted.task_id)
|
||||
.await
|
||||
.unwrap_err(),
|
||||
TaskApplicationError::NotFound
|
||||
);
|
||||
|
||||
// An admin identity addressed to another workspace cannot resolve the publication at all.
|
||||
let foreign_workspace = TaskPrincipal::Admin {
|
||||
workspace_slug: "other-workspace".to_owned(),
|
||||
agent_slug: AGENT_SLUG.to_owned(),
|
||||
user_id: "user_admin_1".to_owned(),
|
||||
};
|
||||
assert_eq!(
|
||||
app.accept_background(
|
||||
&foreign_workspace,
|
||||
TOOL_NAME,
|
||||
None,
|
||||
"foreign-key",
|
||||
&json!({"report": "q3"}),
|
||||
&unsampled_correlation(),
|
||||
)
|
||||
.await
|
||||
.unwrap_err(),
|
||||
TaskApplicationError::NotFound
|
||||
);
|
||||
assert_eq!(counts(registry.pool()).await, (1, 1));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_missing_task_store_fails_closed_and_readiness_reports_not_ready() {
|
||||
let database_url = crank_test_support::postgres_schema_url("durable_tasks_outage").await;
|
||||
let pool = PgPool::connect(&database_url).await.unwrap();
|
||||
// No migration: the durable Task state does not exist.
|
||||
let outage_registry = PostgresRegistry::connect(&database_url).await;
|
||||
assert!(
|
||||
outage_registry.is_err(),
|
||||
"an unmigrated registry cannot be used"
|
||||
);
|
||||
|
||||
crank_registry::MigrationAuthority::apply(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
let registry = PostgresRegistry::connect(&database_url).await.unwrap();
|
||||
seed_tool(®istry, background_policy()).await;
|
||||
let caller = principal(
|
||||
®istry,
|
||||
"task-outage",
|
||||
&[PlatformApiKeyScope::Read, PlatformApiKeyScope::Write],
|
||||
)
|
||||
.await;
|
||||
let app = application(®istry).await;
|
||||
assert!(app.health().await.is_ok());
|
||||
|
||||
// Fail closed: without the Task schema the entry accepts nothing and reports dependency failure.
|
||||
sqlx::query("drop table tasks cascade")
|
||||
.execute(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(app.health().await.is_err());
|
||||
let error = app
|
||||
.accept_background(
|
||||
&caller,
|
||||
TOOL_NAME,
|
||||
None,
|
||||
KEY,
|
||||
&json!({"report": "q3"}),
|
||||
&unsampled_correlation(),
|
||||
)
|
||||
.await
|
||||
.expect_err("no durable Task store, no acceptance");
|
||||
assert!(matches!(
|
||||
error,
|
||||
TaskApplicationError::Task(crank_core::TaskError::Unavailable { .. })
|
||||
));
|
||||
|
||||
// Readiness of the app that wires the same store reports the durable Task dependency as not ready.
|
||||
let router = common::build_test_app(registry.clone(), Duration::from_millis(0), None);
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let server = tokio::spawn(async move {
|
||||
axum::serve(listener, router).await.unwrap();
|
||||
});
|
||||
let response = reqwest::get(format!("http://{address}/ready"))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(response.status(), reqwest::StatusCode::SERVICE_UNAVAILABLE);
|
||||
let body: serde_json::Value = response.json().await.unwrap();
|
||||
assert_eq!(body["checks"]["durable_tasks"], json!("not_ready"));
|
||||
server.abort();
|
||||
}
|
||||
|
||||
mod attempt_trace;
|
||||
mod shutdown_window;
|
||||
mod task_worker;
|
||||
@@ -0,0 +1,190 @@
|
||||
//! Story 4.3 QA caveat proof: the narrow post-checkpoint / pre-permit stop window.
|
||||
//!
|
||||
//! Split from `task_worker.rs` to keep both integration files inside the code-health limit.
|
||||
|
||||
use super::*;
|
||||
|
||||
/// A stop that lands after the durable dispatch checkpoint but before the sealed dispatch permit
|
||||
/// exists finalizes the Task as failed(`shutdown_before_dispatch`) without any outbound call, and
|
||||
/// does not consume work that is still queued.
|
||||
///
|
||||
/// The window is made deterministic instead of raced: a `BEFORE UPDATE` trigger delays only the
|
||||
/// durable dispatch checkpoint, so the stop flag is set while that checkpoint statement is still in
|
||||
/// flight (before `TaskDispatchPermit`/`TaskHandler::execute` can exist).
|
||||
#[tokio::test]
|
||||
async fn task_worker_stop_between_checkpoint_and_dispatch_never_reaches_upstream() {
|
||||
use crank_core::{TaskAccess, TaskLease, TaskOwnerKind};
|
||||
use crank_runtime::{
|
||||
TaskAttemptOutcome, TaskDispatchPermit, TaskHandler, TaskWorker, TaskWorkerConfig,
|
||||
TaskWorkerError,
|
||||
};
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
|
||||
let registry = common::test_registry().await;
|
||||
// The test registry exposes a single pooled connection: delaying the checkpoint inside its own
|
||||
// statement keeps the window deterministic without competing for a second connection.
|
||||
sqlx::raw_sql(sqlx::AssertSqlSafe(
|
||||
"create function delay_task_dispatch_checkpoint() returns trigger language plpgsql as $$
|
||||
begin
|
||||
if new.current_attempt_id is not null and old.current_attempt_id is null then
|
||||
perform pg_sleep(1.5);
|
||||
end if;
|
||||
return new;
|
||||
end $$;
|
||||
create trigger delay_task_dispatch_checkpoint before update on tasks
|
||||
for each row execute function delay_task_dispatch_checkpoint();",
|
||||
))
|
||||
.execute(registry.pool())
|
||||
.await
|
||||
.expect("checkpoint delay trigger");
|
||||
let store = Arc::new(
|
||||
PostgresTaskStore::new(
|
||||
registry.pool().clone(),
|
||||
AdmissionLimits {
|
||||
global_limit: 4,
|
||||
agent_limit: 4,
|
||||
tool_limit: 4,
|
||||
queue_limit: 8,
|
||||
},
|
||||
Default::default(),
|
||||
)
|
||||
.expect("valid task store configuration"),
|
||||
);
|
||||
let mut accepted = Vec::new();
|
||||
for (seed, scoped_key) in [("q", "a"), ("r", "c")] {
|
||||
let request = TaskAcceptRequest {
|
||||
task_id: TaskId::generate(),
|
||||
workspace_id: common::test_workspace_id().to_string(),
|
||||
owner_kind: TaskOwnerKind::Agent,
|
||||
owner_id: "agent_a".to_owned(),
|
||||
authorization_scope: "credential:pk_stop_window".to_owned(),
|
||||
platform_api_key_id: None,
|
||||
operation_id: "op_report".to_owned(),
|
||||
pins: TaskPins {
|
||||
operation_version: 1,
|
||||
policy_mode: ToolExecutionMode::Background,
|
||||
execution_deadline_unix_ms: 1_900_000_000_000,
|
||||
retain_until_unix_ms: 1_900_000_000_000 + 60_000,
|
||||
approval_reference: None,
|
||||
},
|
||||
scoped_key: scoped_key.repeat(64),
|
||||
input_fingerprint: scoped_key.repeat(64),
|
||||
input: TaskEnvelope::try_redacted(&json!({ "report": seed })).unwrap(),
|
||||
support: TaskSupportIds::new(
|
||||
RequestId::generate(),
|
||||
&crank_core::TraceContext::parse(
|
||||
"00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-00",
|
||||
)
|
||||
.unwrap(),
|
||||
),
|
||||
executable_input_ciphertext: None,
|
||||
executable_input_key_version: None,
|
||||
executable_input_master_key_epoch: None,
|
||||
};
|
||||
accepted.push(store.accept(request).await.expect("PG accepts"));
|
||||
}
|
||||
|
||||
// The first revalidation waits for the test; the second Task is never claimed (batch_limit = 1).
|
||||
let revalidate_entered = Arc::new(tokio::sync::Semaphore::new(0));
|
||||
let revalidate_release = Arc::new(tokio::sync::Semaphore::new(0));
|
||||
let executed = Arc::new(AtomicUsize::new(0));
|
||||
struct GatedHandler {
|
||||
entered: Arc<tokio::sync::Semaphore>,
|
||||
release: Arc<tokio::sync::Semaphore>,
|
||||
executed: Arc<AtomicUsize>,
|
||||
}
|
||||
#[async_trait::async_trait]
|
||||
impl TaskHandler for GatedHandler {
|
||||
async fn revalidate(&self, _lease: &TaskLease) -> Result<(), TaskWorkerError> {
|
||||
self.entered.add_permits(1);
|
||||
let _ = self.release.acquire().await;
|
||||
Ok(())
|
||||
}
|
||||
async fn execute(
|
||||
&self,
|
||||
_lease: &TaskLease,
|
||||
_attempt_id: &str,
|
||||
_cancelled: Arc<std::sync::atomic::AtomicBool>,
|
||||
_permit: TaskDispatchPermit,
|
||||
) -> TaskAttemptOutcome {
|
||||
self.executed.fetch_add(1, Ordering::SeqCst);
|
||||
TaskAttemptOutcome::Completed(json!({ "ok": true }))
|
||||
}
|
||||
}
|
||||
let handler: Arc<dyn TaskHandler> = Arc::new(GatedHandler {
|
||||
entered: revalidate_entered.clone(),
|
||||
release: revalidate_release.clone(),
|
||||
executed: executed.clone(),
|
||||
});
|
||||
let mut config = TaskWorkerConfig::default();
|
||||
config.owner = "runtime-worker-stop-window".to_owned();
|
||||
config.batch_limit = 1;
|
||||
config.lease_ms = 30_000;
|
||||
config.poll_interval = Duration::from_millis(50);
|
||||
config.renewal_interval = Duration::from_secs(20);
|
||||
config.max_inflight = 1;
|
||||
config.shutdown_timeout = Duration::from_secs(20);
|
||||
let worker = TaskWorker::new(store.clone(), handler, config).expect("valid worker");
|
||||
let stop_flag = worker.stop_flag();
|
||||
let worker_task = tokio::spawn(async move { worker.run().await });
|
||||
|
||||
tokio::time::timeout(Duration::from_secs(5), revalidate_entered.acquire())
|
||||
.await
|
||||
.expect("worker must claim the first Task and enter revalidation")
|
||||
.expect("revalidation gate is open")
|
||||
.forget();
|
||||
|
||||
// Let revalidation continue; the checkpoint now runs while the trigger holds it for 1.5s.
|
||||
revalidate_release.add_permits(1);
|
||||
tokio::time::sleep(Duration::from_millis(300)).await;
|
||||
|
||||
// The stop now lands while the durable checkpoint statement is still in flight: the worker may
|
||||
// finalize the Task, but no permit exists yet, so no outbound call can start.
|
||||
let stop_requested = std::time::Instant::now();
|
||||
stop_flag.store(true, Ordering::SeqCst);
|
||||
|
||||
tokio::time::timeout(Duration::from_secs(30), worker_task)
|
||||
.await
|
||||
.expect("worker stops inside the 30s budget")
|
||||
.expect("worker exits cleanly")
|
||||
.expect("worker reports no error");
|
||||
assert!(
|
||||
stop_requested.elapsed() >= Duration::from_millis(500),
|
||||
"the checkpoint must have still been in flight when the stop arrived"
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
executed.load(Ordering::SeqCst),
|
||||
0,
|
||||
"a stop between checkpoint and permit must never reach the upstream adapter"
|
||||
);
|
||||
let access = TaskAccess {
|
||||
workspace_id: common::test_workspace_id().to_string(),
|
||||
owner_kind: TaskOwnerKind::Agent,
|
||||
owner_id: "agent_a".to_owned(),
|
||||
authorization_scope: "credential:pk_stop_window".to_owned(),
|
||||
};
|
||||
let record = store.read(&access, accepted[0].task_id).await.unwrap();
|
||||
assert_eq!(record.state, TaskState::Failed);
|
||||
assert_eq!(record.attempts, 1, "the durable checkpoint did commit");
|
||||
assert!(record.current_attempt_id.is_some());
|
||||
assert_eq!(
|
||||
record
|
||||
.error
|
||||
.as_ref()
|
||||
.and_then(|error| error.value().get("code"))
|
||||
.and_then(|code| code.as_str()),
|
||||
Some("shutdown_before_dispatch")
|
||||
);
|
||||
|
||||
// Work that was still queued is not consumed by the stopped worker.
|
||||
let queued = store.read(&access, accepted[1].task_id).await.unwrap();
|
||||
assert_eq!(queued.state, TaskState::Queued);
|
||||
let recovered = store
|
||||
.claim_batch("worker_after_stop", 4, 10_000)
|
||||
.await
|
||||
.expect("queued work stays claimable");
|
||||
assert_eq!(recovered.len(), 1);
|
||||
assert_eq!(recovered[0].record.task_id, accepted[1].task_id);
|
||||
}
|
||||
@@ -0,0 +1,822 @@
|
||||
//! Story 4.3 ATDD: fenced durable Task worker leases, recovery and real upstream dispatch.
|
||||
//!
|
||||
//! Split from `durable_tasks.rs` to keep both integration files inside the code-health limit.
|
||||
|
||||
use super::*;
|
||||
|
||||
/// Store-level positive control only: PostgreSQL leases/fencing/recovery work without Valkey or a
|
||||
/// task-worker process. This does not exercise TaskWorker startup, a bounded authoritative scan,
|
||||
/// graceful shutdown, outbound dispatch, or runtime recovery timing, which remain unimplemented.
|
||||
#[tokio::test]
|
||||
async fn task_worker_store_lease_recovery_contract() {
|
||||
let registry = common::test_registry().await;
|
||||
let store = PostgresTaskStore::new(
|
||||
registry.pool().clone(),
|
||||
AdmissionLimits {
|
||||
global_limit: 4,
|
||||
agent_limit: 4,
|
||||
tool_limit: 4,
|
||||
queue_limit: 8,
|
||||
},
|
||||
Default::default(),
|
||||
)
|
||||
.expect("valid task store configuration");
|
||||
|
||||
// Positive control: no Valkey or worker process is involved; PostgreSQL alone accepts and
|
||||
// leases durable work, preserving the same admission-backed intent.
|
||||
let request = TaskAcceptRequest {
|
||||
task_id: TaskId::generate(),
|
||||
workspace_id: common::test_workspace_id().to_string(),
|
||||
owner_kind: TaskOwnerKind::Agent,
|
||||
owner_id: "agent_a".to_owned(),
|
||||
authorization_scope: "credential:pk_1".to_owned(),
|
||||
platform_api_key_id: None,
|
||||
operation_id: "op_report".to_owned(),
|
||||
pins: TaskPins {
|
||||
operation_version: 1,
|
||||
policy_mode: ToolExecutionMode::Background,
|
||||
execution_deadline_unix_ms: 1_900_000_000_000,
|
||||
retain_until_unix_ms: 1_900_000_000_000 + 60_000,
|
||||
approval_reference: None,
|
||||
},
|
||||
scoped_key: "a".repeat(64),
|
||||
input_fingerprint: "b".repeat(64),
|
||||
input: TaskEnvelope::try_redacted(&json!({"report": "q3"})).unwrap(),
|
||||
support: TaskSupportIds::new(
|
||||
RequestId::generate(),
|
||||
&crank_core::TraceContext::parse(
|
||||
"00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-00",
|
||||
)
|
||||
.unwrap(),
|
||||
),
|
||||
// This store-level control exercises lease/fence behavior, not the encrypted acceptance path.
|
||||
executable_input_ciphertext: None,
|
||||
executable_input_key_version: None,
|
||||
executable_input_master_key_epoch: None,
|
||||
};
|
||||
let accepted = store.accept(request).await.expect("PG accepts");
|
||||
let leases = store
|
||||
.claim_batch("worker_1", 4, 10_000)
|
||||
.await
|
||||
.expect("claim");
|
||||
assert_eq!(leases.len(), 1);
|
||||
assert_eq!(leases[0].record.task_id, accepted.task_id);
|
||||
let lease = leases[0].clone();
|
||||
|
||||
// A stale or competing owner cannot win CAS with the issued fencing token.
|
||||
assert!(
|
||||
store
|
||||
.renew_lease("worker_2", lease.record.task_id, lease.fence, 10_000)
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
assert!(
|
||||
store
|
||||
.write_progress(
|
||||
"worker_1",
|
||||
lease.record.task_id,
|
||||
lease.fence + 1,
|
||||
TaskEnvelope::try_redacted(&json!({"progress": 1})).unwrap(),
|
||||
)
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
|
||||
// A stale fencing token can never checkpoint dispatch, even under the issuing owner.
|
||||
assert!(
|
||||
store
|
||||
.checkpoint_dispatch(
|
||||
"worker_1",
|
||||
lease.record.task_id,
|
||||
lease.fence + 1,
|
||||
"attempt-stale".to_owned()
|
||||
)
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
// The valid owner still commits the dispatch checkpoint before any outbound work.
|
||||
assert!(
|
||||
store
|
||||
.checkpoint_dispatch(
|
||||
"worker_1",
|
||||
lease.record.task_id,
|
||||
lease.fence,
|
||||
"attempt-1".to_owned(),
|
||||
)
|
||||
.await
|
||||
.unwrap()
|
||||
.current_attempt_id
|
||||
.as_deref()
|
||||
== Some("attempt-1")
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn task_worker_runtime_dispatch_and_recovery_contract() {
|
||||
use async_trait::async_trait;
|
||||
use crank_core::{TaskAccess, TaskLease, TaskOwnerKind};
|
||||
use crank_runtime::{
|
||||
TaskAttemptOutcome, TaskDispatchPermit, TaskHandler, TaskWorker, TaskWorkerConfig,
|
||||
TaskWorkerError,
|
||||
};
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
|
||||
let registry = common::test_registry().await;
|
||||
let pool = registry.pool().clone();
|
||||
let store = Arc::new(
|
||||
PostgresTaskStore::new(
|
||||
pool.clone(),
|
||||
AdmissionLimits {
|
||||
global_limit: 4,
|
||||
agent_limit: 4,
|
||||
tool_limit: 4,
|
||||
queue_limit: 8,
|
||||
},
|
||||
Default::default(),
|
||||
)
|
||||
.expect("valid task store configuration"),
|
||||
);
|
||||
let observed = Arc::new(AtomicUsize::new(0));
|
||||
|
||||
// Positive control: PostgreSQL alone accepts the durable Task.
|
||||
let request = TaskAcceptRequest {
|
||||
task_id: TaskId::generate(),
|
||||
workspace_id: common::test_workspace_id().to_string(),
|
||||
owner_kind: TaskOwnerKind::Agent,
|
||||
owner_id: "agent_a".to_owned(),
|
||||
authorization_scope: "credential:pk_runtime".to_owned(),
|
||||
platform_api_key_id: None,
|
||||
operation_id: "op_report".to_owned(),
|
||||
pins: TaskPins {
|
||||
operation_version: 1,
|
||||
policy_mode: ToolExecutionMode::Background,
|
||||
execution_deadline_unix_ms: 1_900_000_000_000,
|
||||
retain_until_unix_ms: 1_900_000_000_000 + 60_000,
|
||||
approval_reference: None,
|
||||
},
|
||||
scoped_key: "r".repeat(64),
|
||||
input_fingerprint: "b".repeat(64),
|
||||
input: TaskEnvelope::try_redacted(&json!({"email": "q3"})).unwrap(),
|
||||
support: TaskSupportIds::new(
|
||||
RequestId::generate(),
|
||||
&crank_core::TraceContext::parse(
|
||||
"00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-00",
|
||||
)
|
||||
.unwrap(),
|
||||
),
|
||||
executable_input_ciphertext: None,
|
||||
executable_input_key_version: None,
|
||||
executable_input_master_key_epoch: None,
|
||||
};
|
||||
let accepted = store.accept(request).await.expect("PG accepts");
|
||||
let task_id = accepted.task_id;
|
||||
|
||||
struct RuntimeHandler {
|
||||
observed: Arc<AtomicUsize>,
|
||||
}
|
||||
#[async_trait]
|
||||
impl TaskHandler for RuntimeHandler {
|
||||
async fn revalidate(&self, _lease: &TaskLease) -> Result<(), TaskWorkerError> {
|
||||
Ok(())
|
||||
}
|
||||
async fn execute(
|
||||
&self,
|
||||
_lease: &TaskLease,
|
||||
_attempt_id: &str,
|
||||
_cancelled: Arc<std::sync::atomic::AtomicBool>,
|
||||
_permit: TaskDispatchPermit,
|
||||
) -> TaskAttemptOutcome {
|
||||
self.observed.fetch_add(1, Ordering::SeqCst);
|
||||
TaskAttemptOutcome::Completed(serde_json::json!({"ok": true}))
|
||||
}
|
||||
}
|
||||
let handler: Arc<dyn TaskHandler> = Arc::new(RuntimeHandler {
|
||||
observed: observed.clone(),
|
||||
});
|
||||
|
||||
// PG-only authoritative dispatch: no Valkey or upstream process is involved.
|
||||
let mut config = TaskWorkerConfig::default();
|
||||
config.owner = "runtime-worker-1".to_owned();
|
||||
config.batch_limit = 1;
|
||||
config.lease_ms = 10_000;
|
||||
config.poll_interval = Duration::from_millis(100);
|
||||
config.renewal_interval = Duration::from_millis(1_000);
|
||||
config.max_inflight = 1;
|
||||
config.shutdown_timeout = Duration::from_secs(5);
|
||||
let worker = TaskWorker::new(store.clone(), handler, config).expect("valid worker");
|
||||
let stop_flag = worker.stop_flag();
|
||||
let worker_task = tokio::spawn(async move { worker.run().await });
|
||||
|
||||
let access = TaskAccess {
|
||||
workspace_id: common::test_workspace_id().to_string(),
|
||||
owner_kind: TaskOwnerKind::Agent,
|
||||
owner_id: "agent_a".to_owned(),
|
||||
authorization_scope: "credential:pk_runtime".to_owned(),
|
||||
};
|
||||
let mut state = None;
|
||||
for _ in 0..100 {
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
if let Ok(record) = store.read(&access, task_id).await {
|
||||
state = Some(record.state);
|
||||
if record.state == TaskState::Completed {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
stop_flag.store(true, Ordering::SeqCst);
|
||||
let _ = tokio::time::timeout(Duration::from_secs(10), worker_task).await;
|
||||
|
||||
assert_eq!(state, Some(TaskState::Completed));
|
||||
assert_eq!(
|
||||
observed.load(Ordering::SeqCst),
|
||||
1,
|
||||
"exactly one outbound attempt"
|
||||
);
|
||||
// Terminal state is not duplicated.
|
||||
let record = store.read(&access, task_id).await.expect("terminal read");
|
||||
assert_eq!(record.state, TaskState::Completed);
|
||||
|
||||
// Bounded shutdown with no fresh work returns promptly.
|
||||
let mut idle_config = TaskWorkerConfig::default();
|
||||
idle_config.owner = "runtime-worker-idle".to_owned();
|
||||
idle_config.poll_interval = Duration::from_millis(50);
|
||||
idle_config.shutdown_timeout = Duration::from_secs(2);
|
||||
let idle_worker = TaskWorker::new(
|
||||
store.clone(),
|
||||
handler_for_no_work(store.clone()),
|
||||
idle_config,
|
||||
)
|
||||
.expect("valid idle worker");
|
||||
idle_worker.stop();
|
||||
let started = std::time::Instant::now();
|
||||
idle_worker.run().await.expect("idle worker stops");
|
||||
assert!(started.elapsed() <= Duration::from_secs(30));
|
||||
}
|
||||
|
||||
/// Story 4.3 ATDD: failed pre-dispatch revalidation finishes the attempt without any outbound call.
|
||||
#[tokio::test]
|
||||
async fn task_worker_revalidation_denial_never_dispatches() {
|
||||
use crank_core::{TaskAccess, TaskError, TaskLease, TaskOwnerKind};
|
||||
use crank_runtime::{
|
||||
TaskAttemptOutcome, TaskDispatchPermit, TaskHandler, TaskWorker, TaskWorkerConfig,
|
||||
TaskWorkerError,
|
||||
};
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
|
||||
let registry = common::test_registry().await;
|
||||
let store = Arc::new(
|
||||
PostgresTaskStore::new(
|
||||
registry.pool().clone(),
|
||||
AdmissionLimits {
|
||||
global_limit: 4,
|
||||
agent_limit: 4,
|
||||
tool_limit: 4,
|
||||
queue_limit: 8,
|
||||
},
|
||||
Default::default(),
|
||||
)
|
||||
.expect("valid task store configuration"),
|
||||
);
|
||||
let request = TaskAcceptRequest {
|
||||
task_id: TaskId::generate(),
|
||||
workspace_id: common::test_workspace_id().to_string(),
|
||||
owner_kind: TaskOwnerKind::Agent,
|
||||
owner_id: "agent_a".to_owned(),
|
||||
authorization_scope: "credential:pk_denied".to_owned(),
|
||||
platform_api_key_id: None,
|
||||
operation_id: "op_report".to_owned(),
|
||||
pins: TaskPins {
|
||||
operation_version: 1,
|
||||
policy_mode: ToolExecutionMode::Background,
|
||||
execution_deadline_unix_ms: 1_900_000_000_000,
|
||||
retain_until_unix_ms: 1_900_000_000_000 + 60_000,
|
||||
approval_reference: None,
|
||||
},
|
||||
scoped_key: "d".repeat(64),
|
||||
input_fingerprint: "b".repeat(64),
|
||||
input: TaskEnvelope::try_redacted(&json!({"report": "q3"})).unwrap(),
|
||||
support: TaskSupportIds::new(
|
||||
RequestId::generate(),
|
||||
&crank_core::TraceContext::parse(
|
||||
"00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01",
|
||||
)
|
||||
.unwrap(),
|
||||
),
|
||||
executable_input_ciphertext: None,
|
||||
executable_input_key_version: None,
|
||||
executable_input_master_key_epoch: None,
|
||||
};
|
||||
let accepted = store.accept(request).await.expect("PG accepts");
|
||||
|
||||
struct DeniedHandler {
|
||||
observed: Arc<AtomicUsize>,
|
||||
}
|
||||
#[async_trait::async_trait]
|
||||
impl TaskHandler for DeniedHandler {
|
||||
async fn revalidate(&self, _lease: &TaskLease) -> Result<(), TaskWorkerError> {
|
||||
Err(TaskWorkerError::Store(TaskError::invalid(
|
||||
"publication or credential revoked",
|
||||
)))
|
||||
}
|
||||
async fn execute(
|
||||
&self,
|
||||
_lease: &TaskLease,
|
||||
_attempt_id: &str,
|
||||
_cancelled: Arc<std::sync::atomic::AtomicBool>,
|
||||
_permit: TaskDispatchPermit,
|
||||
) -> TaskAttemptOutcome {
|
||||
self.observed.fetch_add(1, Ordering::SeqCst);
|
||||
TaskAttemptOutcome::Completed(json!({"ok": true}))
|
||||
}
|
||||
}
|
||||
let observed = Arc::new(AtomicUsize::new(0));
|
||||
let handler: Arc<dyn TaskHandler> = Arc::new(DeniedHandler {
|
||||
observed: observed.clone(),
|
||||
});
|
||||
let mut config = TaskWorkerConfig::default();
|
||||
config.owner = "runtime-worker-denied".to_owned();
|
||||
config.batch_limit = 1;
|
||||
config.lease_ms = 10_000;
|
||||
config.poll_interval = Duration::from_millis(50);
|
||||
config.max_inflight = 1;
|
||||
config.shutdown_timeout = Duration::from_secs(5);
|
||||
let worker = TaskWorker::new(store.clone(), handler, config).expect("valid worker");
|
||||
let stop_flag = worker.stop_flag();
|
||||
let worker_task = tokio::spawn(async move { worker.run().await });
|
||||
|
||||
let access = TaskAccess {
|
||||
workspace_id: common::test_workspace_id().to_string(),
|
||||
owner_kind: TaskOwnerKind::Agent,
|
||||
owner_id: "agent_a".to_owned(),
|
||||
authorization_scope: "credential:pk_denied".to_owned(),
|
||||
};
|
||||
let mut state = None;
|
||||
for _ in 0..100 {
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
if let Ok(record) = store.read(&access, accepted.task_id).await {
|
||||
state = Some(record.state);
|
||||
if record.state == TaskState::Failed {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
stop_flag.store(true, Ordering::SeqCst);
|
||||
let _ = tokio::time::timeout(Duration::from_secs(10), worker_task).await;
|
||||
|
||||
assert_eq!(state, Some(TaskState::Failed));
|
||||
assert_eq!(
|
||||
observed.load(Ordering::SeqCst),
|
||||
0,
|
||||
"invalidated work never reaches the upstream"
|
||||
);
|
||||
}
|
||||
|
||||
fn handler_for_no_work(
|
||||
_store: std::sync::Arc<PostgresTaskStore>,
|
||||
) -> std::sync::Arc<dyn crank_runtime::TaskHandler> {
|
||||
struct NoWorkHandler;
|
||||
#[async_trait::async_trait]
|
||||
impl crank_runtime::TaskHandler for NoWorkHandler {
|
||||
async fn revalidate(
|
||||
&self,
|
||||
_lease: &crank_core::TaskLease,
|
||||
) -> Result<(), crank_runtime::TaskWorkerError> {
|
||||
Ok(())
|
||||
}
|
||||
async fn execute(
|
||||
&self,
|
||||
_lease: &crank_core::TaskLease,
|
||||
_attempt_id: &str,
|
||||
_cancelled: std::sync::Arc<std::sync::atomic::AtomicBool>,
|
||||
_permit: crank_runtime::TaskDispatchPermit,
|
||||
) -> crank_runtime::TaskAttemptOutcome {
|
||||
crank_runtime::TaskAttemptOutcome::Completed(serde_json::json!({"ok": true}))
|
||||
}
|
||||
}
|
||||
std::sync::Arc::new(NoWorkHandler)
|
||||
}
|
||||
|
||||
/// Story 4.3 end-to-end ATDD: the production durable-Task handler, the real runtime executor and a
|
||||
/// real local HTTP upstream observe exactly one dispatch after the fenced checkpoint, while the
|
||||
/// accepted parent trace is continued on the wire.
|
||||
#[tokio::test]
|
||||
async fn task_worker_dispatches_one_real_upstream_attempt_with_parent_trace() {
|
||||
use axum::Router;
|
||||
use axum::http::{HeaderMap, StatusCode};
|
||||
use axum::routing::post;
|
||||
use crank_community_mcp::TaskWorkerHandler;
|
||||
use crank_core::{AgentOperationBinding, PlatformApiKeyScope};
|
||||
use crank_runtime::{SecretCrypto, TaskWorker, TaskWorkerConfig};
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
let registry = common::test_registry().await;
|
||||
let calls = Arc::new(AtomicUsize::new(0));
|
||||
let seen_traceparent = Arc::new(Mutex::new(None::<String>));
|
||||
|
||||
let app = Router::new().route(
|
||||
"/crm/leads",
|
||||
post({
|
||||
let calls = Arc::clone(&calls);
|
||||
let seen = Arc::clone(&seen_traceparent);
|
||||
move |headers: HeaderMap| {
|
||||
let calls = Arc::clone(&calls);
|
||||
let seen = Arc::clone(&seen);
|
||||
async move {
|
||||
calls.fetch_add(1, Ordering::SeqCst);
|
||||
if let Some(value) = headers
|
||||
.get("traceparent")
|
||||
.and_then(|value| value.to_str().ok())
|
||||
{
|
||||
*seen.lock().unwrap() = Some(value.to_owned());
|
||||
}
|
||||
(StatusCode::OK, axum::Json(json!({"id": "lead-1"})))
|
||||
}
|
||||
}
|
||||
}),
|
||||
);
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let server = tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
|
||||
let upstream = format!("http://{address}");
|
||||
|
||||
let mut operation = common::test_operation(&upstream, TOOL_NAME);
|
||||
operation.execution_config.execution_policy = Some(background_policy());
|
||||
registry
|
||||
.create_operation(&common::test_workspace_id(), &operation, Some("alice"))
|
||||
.await
|
||||
.unwrap();
|
||||
publish(®istry, &operation.id, 1).await;
|
||||
common::publish_agent_with_bindings(
|
||||
®istry,
|
||||
AGENT_SLUG,
|
||||
vec![AgentOperationBinding {
|
||||
operation_id: operation.id.clone(),
|
||||
operation_version: 1,
|
||||
tool_name: operation.name.clone(),
|
||||
tool_title: operation.tool_description.title.clone(),
|
||||
tool_description_override: None,
|
||||
enabled: true,
|
||||
}],
|
||||
)
|
||||
.await;
|
||||
|
||||
let caller = principal(
|
||||
®istry,
|
||||
"task-worker-e2e",
|
||||
&[PlatformApiKeyScope::Read, PlatformApiKeyScope::Write],
|
||||
)
|
||||
.await;
|
||||
let correlation = unsampled_correlation();
|
||||
let crypto = SecretCrypto::new("test-master-key-00000000000000000000000000000000").unwrap();
|
||||
let observed_at = OffsetDateTime::now_utc();
|
||||
registry
|
||||
.verify_or_register_master_key_identity(crank_registry::MasterKeyIdentityCandidate {
|
||||
epoch: crypto.master_key_epoch(),
|
||||
fingerprint: crypto.master_key_fingerprint(),
|
||||
cipher_contract: crank_registry::MASTER_KEY_CIPHER_CONTRACT,
|
||||
observed_at: &observed_at,
|
||||
})
|
||||
.await
|
||||
.expect("test master-key identity registered");
|
||||
let store = Arc::new(
|
||||
PostgresTaskStore::new(
|
||||
registry.pool().clone(),
|
||||
AdmissionLimits {
|
||||
global_limit: 4,
|
||||
agent_limit: 4,
|
||||
tool_limit: 4,
|
||||
queue_limit: 8,
|
||||
},
|
||||
Default::default(),
|
||||
)
|
||||
.expect("valid task store configuration"),
|
||||
);
|
||||
let tasks = TaskApplication::new(
|
||||
registry.clone(),
|
||||
Duration::ZERO,
|
||||
Arc::new(InMemoryCoordinationStateStore::default()),
|
||||
TaskService::with_secret_crypto(store.clone(), Arc::new(crypto.clone())),
|
||||
);
|
||||
let acceptance = tasks
|
||||
.accept_background(
|
||||
&caller,
|
||||
TOOL_NAME,
|
||||
None,
|
||||
"worker-e2e-key",
|
||||
&json!({"email": "user@example.com"}),
|
||||
&correlation,
|
||||
)
|
||||
.await
|
||||
.expect("durable acceptance with executable input");
|
||||
|
||||
let runtime = crank_runtime::community_with_outbound_policy(
|
||||
crank_runtime::OutboundHttpPolicy::allowing_hosts(["127.0.0.1"]),
|
||||
)
|
||||
.build();
|
||||
let handler = Arc::new(TaskWorkerHandler::from_application(
|
||||
&tasks,
|
||||
registry.clone(),
|
||||
runtime,
|
||||
crypto,
|
||||
));
|
||||
let mut config = TaskWorkerConfig::default();
|
||||
config.owner = "runtime-worker-e2e".to_owned();
|
||||
config.batch_limit = 1;
|
||||
config.lease_ms = 10_000;
|
||||
config.poll_interval = Duration::from_millis(50);
|
||||
config.max_inflight = 1;
|
||||
config.shutdown_timeout = Duration::from_secs(5);
|
||||
let worker = TaskWorker::new(store.clone(), handler, config).expect("valid worker");
|
||||
let stop_flag = worker.stop_flag();
|
||||
let worker_task = tokio::spawn(async move { worker.run().await });
|
||||
|
||||
let mut state = None;
|
||||
for _ in 0..200 {
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
let current: Option<String> =
|
||||
sqlx::query_scalar("select state from tasks where task_id = $1")
|
||||
.bind(acceptance.task_id.as_uuid())
|
||||
.fetch_optional(registry.pool())
|
||||
.await
|
||||
.unwrap();
|
||||
state = current;
|
||||
if state.as_deref() == Some("completed") {
|
||||
break;
|
||||
}
|
||||
}
|
||||
stop_flag.store(true, Ordering::SeqCst);
|
||||
let _ = tokio::time::timeout(Duration::from_secs(10), worker_task).await;
|
||||
server.abort();
|
||||
|
||||
assert_eq!(state.as_deref(), Some("completed"));
|
||||
assert_eq!(calls.load(Ordering::SeqCst), 1, "exactly one upstream call");
|
||||
assert_eq!(
|
||||
seen_traceparent.lock().unwrap().as_deref(),
|
||||
Some(correlation.trace_context().traceparent()),
|
||||
"the durable attempt continues the accepted parent trace"
|
||||
);
|
||||
}
|
||||
|
||||
/// Story 4.3 end-to-end ATDD: an ambiguous post-checkpoint upstream failure is persisted as
|
||||
/// `outcome_unknown` (not a retryable failure) and is not redispatched automatically.
|
||||
#[tokio::test]
|
||||
async fn task_worker_ambiguous_upstream_error_becomes_outcome_unknown() {
|
||||
use axum::Router;
|
||||
use axum::http::StatusCode;
|
||||
use axum::routing::post;
|
||||
use crank_community_mcp::TaskWorkerHandler;
|
||||
use crank_core::{AgentOperationBinding, PlatformApiKeyScope};
|
||||
use crank_runtime::{SecretCrypto, TaskWorker, TaskWorkerConfig};
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::Ordering;
|
||||
|
||||
let registry = common::test_registry().await;
|
||||
let upstream_app = Router::new().route(
|
||||
"/crm/leads",
|
||||
post(|| async { (StatusCode::SERVICE_UNAVAILABLE, "upstream unavailable") }),
|
||||
);
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let server = tokio::spawn(async move { axum::serve(listener, upstream_app).await.unwrap() });
|
||||
let upstream = format!("http://{address}");
|
||||
|
||||
let mut operation = common::test_operation(&upstream, TOOL_NAME);
|
||||
operation.execution_config.execution_policy = Some(background_policy());
|
||||
registry
|
||||
.create_operation(&common::test_workspace_id(), &operation, Some("alice"))
|
||||
.await
|
||||
.unwrap();
|
||||
publish(®istry, &operation.id, 1).await;
|
||||
common::publish_agent_with_bindings(
|
||||
®istry,
|
||||
AGENT_SLUG,
|
||||
vec![AgentOperationBinding {
|
||||
operation_id: operation.id.clone(),
|
||||
operation_version: 1,
|
||||
tool_name: operation.name.clone(),
|
||||
tool_title: operation.tool_description.title.clone(),
|
||||
tool_description_override: None,
|
||||
enabled: true,
|
||||
}],
|
||||
)
|
||||
.await;
|
||||
|
||||
let caller = principal(
|
||||
®istry,
|
||||
"task-worker-uncertain",
|
||||
&[PlatformApiKeyScope::Read, PlatformApiKeyScope::Write],
|
||||
)
|
||||
.await;
|
||||
let correlation = unsampled_correlation();
|
||||
let crypto = SecretCrypto::new("test-master-key-00000000000000000000000000000000").unwrap();
|
||||
let observed_at = OffsetDateTime::now_utc();
|
||||
registry
|
||||
.verify_or_register_master_key_identity(crank_registry::MasterKeyIdentityCandidate {
|
||||
epoch: crypto.master_key_epoch(),
|
||||
fingerprint: crypto.master_key_fingerprint(),
|
||||
cipher_contract: crank_registry::MASTER_KEY_CIPHER_CONTRACT,
|
||||
observed_at: &observed_at,
|
||||
})
|
||||
.await
|
||||
.expect("test master-key identity registered");
|
||||
let store = Arc::new(
|
||||
PostgresTaskStore::new(
|
||||
registry.pool().clone(),
|
||||
AdmissionLimits {
|
||||
global_limit: 4,
|
||||
agent_limit: 4,
|
||||
tool_limit: 4,
|
||||
queue_limit: 8,
|
||||
},
|
||||
Default::default(),
|
||||
)
|
||||
.expect("valid task store configuration"),
|
||||
);
|
||||
let tasks = TaskApplication::new(
|
||||
registry.clone(),
|
||||
Duration::ZERO,
|
||||
Arc::new(InMemoryCoordinationStateStore::default()),
|
||||
TaskService::with_secret_crypto(store.clone(), Arc::new(crypto.clone())),
|
||||
);
|
||||
let acceptance = tasks
|
||||
.accept_background(
|
||||
&caller,
|
||||
TOOL_NAME,
|
||||
None,
|
||||
"worker-uncertain-key",
|
||||
&json!({"email": "user@example.com"}),
|
||||
&correlation,
|
||||
)
|
||||
.await
|
||||
.expect("durable acceptance with executable input");
|
||||
|
||||
let runtime = crank_runtime::community_with_outbound_policy(
|
||||
crank_runtime::OutboundHttpPolicy::allowing_hosts(["127.0.0.1"]),
|
||||
)
|
||||
.build();
|
||||
let handler = Arc::new(TaskWorkerHandler::from_application(
|
||||
&tasks,
|
||||
registry.clone(),
|
||||
runtime,
|
||||
crypto,
|
||||
));
|
||||
let mut config = TaskWorkerConfig::default();
|
||||
config.owner = "runtime-worker-uncertain".to_owned();
|
||||
config.batch_limit = 1;
|
||||
config.lease_ms = 10_000;
|
||||
config.poll_interval = Duration::from_millis(50);
|
||||
config.max_inflight = 1;
|
||||
config.shutdown_timeout = Duration::from_secs(5);
|
||||
let worker = TaskWorker::new(store.clone(), handler, config).expect("valid worker");
|
||||
let stop_flag = worker.stop_flag();
|
||||
let worker_task = tokio::spawn(async move { worker.run().await });
|
||||
|
||||
let mut state = None;
|
||||
for _ in 0..200 {
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
let current: Option<String> =
|
||||
sqlx::query_scalar("select state from tasks where task_id = $1")
|
||||
.bind(acceptance.task_id.as_uuid())
|
||||
.fetch_optional(registry.pool())
|
||||
.await
|
||||
.unwrap();
|
||||
state = current;
|
||||
if state.as_deref() == Some("outcome_unknown") {
|
||||
break;
|
||||
}
|
||||
}
|
||||
stop_flag.store(true, Ordering::SeqCst);
|
||||
let _ = tokio::time::timeout(Duration::from_secs(10), worker_task).await;
|
||||
server.abort();
|
||||
|
||||
assert_eq!(state.as_deref(), Some("outcome_unknown"));
|
||||
// No automatic retry: another authoritative scan never redispaches the uncertain attempt.
|
||||
assert!(
|
||||
store
|
||||
.claim_batch("worker_after", 4, 10_000)
|
||||
.await
|
||||
.unwrap()
|
||||
.is_empty()
|
||||
);
|
||||
}
|
||||
|
||||
/// Story 4.3 ATDD: graceful stop stops new claims but lets an active attempt reach its fenced
|
||||
/// terminal commit within the 30s budget.
|
||||
#[tokio::test]
|
||||
async fn task_worker_graceful_stop_drains_active_attempt() {
|
||||
use crank_core::{TaskAccess, TaskLease, TaskOwnerKind};
|
||||
use crank_runtime::{
|
||||
TaskAttemptOutcome, TaskDispatchPermit, TaskHandler, TaskWorker, TaskWorkerConfig,
|
||||
TaskWorkerError,
|
||||
};
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
|
||||
let registry = common::test_registry().await;
|
||||
let store = Arc::new(
|
||||
PostgresTaskStore::new(
|
||||
registry.pool().clone(),
|
||||
AdmissionLimits {
|
||||
global_limit: 4,
|
||||
agent_limit: 4,
|
||||
tool_limit: 4,
|
||||
queue_limit: 8,
|
||||
},
|
||||
Default::default(),
|
||||
)
|
||||
.expect("valid task store configuration"),
|
||||
);
|
||||
let request = TaskAcceptRequest {
|
||||
task_id: TaskId::generate(),
|
||||
workspace_id: common::test_workspace_id().to_string(),
|
||||
owner_kind: TaskOwnerKind::Agent,
|
||||
owner_id: "agent_a".to_owned(),
|
||||
authorization_scope: "credential:pk_drain".to_owned(),
|
||||
platform_api_key_id: None,
|
||||
operation_id: "op_report".to_owned(),
|
||||
pins: TaskPins {
|
||||
operation_version: 1,
|
||||
policy_mode: ToolExecutionMode::Background,
|
||||
execution_deadline_unix_ms: 1_900_000_000_000,
|
||||
retain_until_unix_ms: 1_900_000_000_000 + 60_000,
|
||||
approval_reference: None,
|
||||
},
|
||||
scoped_key: "s".repeat(64),
|
||||
input_fingerprint: "d".repeat(64),
|
||||
input: TaskEnvelope::try_redacted(&json!({"report": "q3"})).unwrap(),
|
||||
support: TaskSupportIds::new(
|
||||
RequestId::generate(),
|
||||
&crank_core::TraceContext::parse(
|
||||
"00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-00",
|
||||
)
|
||||
.unwrap(),
|
||||
),
|
||||
executable_input_ciphertext: None,
|
||||
executable_input_key_version: None,
|
||||
executable_input_master_key_epoch: None,
|
||||
};
|
||||
let accepted = store.accept(request).await.expect("PG accepts");
|
||||
|
||||
struct SlowHandler {
|
||||
started: Arc<AtomicUsize>,
|
||||
}
|
||||
#[async_trait::async_trait]
|
||||
impl TaskHandler for SlowHandler {
|
||||
async fn revalidate(&self, _lease: &TaskLease) -> Result<(), TaskWorkerError> {
|
||||
Ok(())
|
||||
}
|
||||
async fn execute(
|
||||
&self,
|
||||
_lease: &TaskLease,
|
||||
_attempt_id: &str,
|
||||
_cancelled: Arc<std::sync::atomic::AtomicBool>,
|
||||
_permit: TaskDispatchPermit,
|
||||
) -> TaskAttemptOutcome {
|
||||
self.started.fetch_add(1, Ordering::SeqCst);
|
||||
tokio::time::sleep(Duration::from_millis(500)).await;
|
||||
TaskAttemptOutcome::Completed(json!({"ok": true}))
|
||||
}
|
||||
}
|
||||
let started = Arc::new(AtomicUsize::new(0));
|
||||
let handler: Arc<dyn TaskHandler> = Arc::new(SlowHandler {
|
||||
started: started.clone(),
|
||||
});
|
||||
let mut config = TaskWorkerConfig::default();
|
||||
config.owner = "runtime-worker-drain".to_owned();
|
||||
config.batch_limit = 1;
|
||||
config.lease_ms = 10_000;
|
||||
config.poll_interval = Duration::from_millis(50);
|
||||
config.max_inflight = 1;
|
||||
config.shutdown_timeout = Duration::from_secs(20);
|
||||
let worker = TaskWorker::new(store.clone(), handler, config).expect("valid worker");
|
||||
let stop_flag = worker.stop_flag();
|
||||
let worker_task = tokio::spawn(async move { worker.run().await });
|
||||
|
||||
for _ in 0..100 {
|
||||
if started.load(Ordering::SeqCst) > 0 {
|
||||
break;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(20)).await;
|
||||
}
|
||||
assert_eq!(started.load(Ordering::SeqCst), 1, "attempt started");
|
||||
let stop_requested = std::time::Instant::now();
|
||||
stop_flag.store(true, Ordering::SeqCst);
|
||||
tokio::time::timeout(Duration::from_secs(30), worker_task)
|
||||
.await
|
||||
.expect("worker stops inside the 30s budget")
|
||||
.expect("worker exits cleanly")
|
||||
.expect("worker reports no error");
|
||||
assert!(stop_requested.elapsed() <= Duration::from_secs(30));
|
||||
|
||||
let access = TaskAccess {
|
||||
workspace_id: common::test_workspace_id().to_string(),
|
||||
owner_kind: TaskOwnerKind::Agent,
|
||||
owner_id: "agent_a".to_owned(),
|
||||
authorization_scope: "credential:pk_drain".to_owned(),
|
||||
};
|
||||
let record = store.read(&access, accepted.task_id).await.unwrap();
|
||||
assert_eq!(record.state, TaskState::Completed);
|
||||
}
|
||||
@@ -20,7 +20,8 @@ use std::{
|
||||
use axum::http::header;
|
||||
use crank_artifacts::ArtifactStore;
|
||||
use crank_core::{
|
||||
Agent, AgentId, AgentStatus, AgentVersion, PlatformApiKeyScope, ToolSelectionPolicy,
|
||||
Agent, AgentId, AgentStatus, AgentVersion, PlatformApiKeyScope, ToolAccessMode, ToolGroup,
|
||||
ToolSearchSettings, ToolSelectionPolicy,
|
||||
ids::{PromptId, ResourceId},
|
||||
prompt::{PromptDefinition, PromptSensitivity},
|
||||
};
|
||||
@@ -47,10 +48,13 @@ const META_CLIENT_INFO: &str = "io.modelcontextprotocol/clientInfo";
|
||||
|
||||
const RESOURCE_LIST_CHANGED: &str = "notifications/resources/list_changed";
|
||||
const PROMPT_LIST_CHANGED: &str = "notifications/prompts/list_changed";
|
||||
const TOOL_LIST_CHANGED: &str = "notifications/tools/list_changed";
|
||||
const SUBSCRIPTIONS_ACKNOWLEDGED: &str = "notifications/subscriptions/acknowledged";
|
||||
const SUBSCRIPTION_ID_KEY: &str = "io.modelcontextprotocol/subscriptionId";
|
||||
|
||||
const AGENT_SLUG: &str = "sales-signals";
|
||||
/// A second published Agent of the same workspace: its catalog must never reach another Agent.
|
||||
const OTHER_AGENT_SLUG: &str = "sales-other";
|
||||
|
||||
static NEXT_ROOT: AtomicU64 = AtomicU64::new(0);
|
||||
|
||||
@@ -254,6 +258,26 @@ impl SignalsEndpoint {
|
||||
tool_bindings: &[crank_core::AgentOperationBinding],
|
||||
resource_bindings: &[AgentResourceBinding],
|
||||
prompt_bindings: &[AgentPromptBinding],
|
||||
) {
|
||||
self.configure_draft_with_policy(
|
||||
version,
|
||||
tool_bindings,
|
||||
&ToolSelectionPolicy::default(),
|
||||
resource_bindings,
|
||||
prompt_bindings,
|
||||
)
|
||||
.await;
|
||||
}
|
||||
|
||||
/// The same transition with an explicit Tool selection policy (Story 3.5: the policy is part of
|
||||
/// the served `tools/list` projection).
|
||||
async fn configure_draft_with_policy(
|
||||
&self,
|
||||
version: u32,
|
||||
tool_bindings: &[crank_core::AgentOperationBinding],
|
||||
tool_selection_policy: &ToolSelectionPolicy,
|
||||
resource_bindings: &[AgentResourceBinding],
|
||||
prompt_bindings: &[AgentPromptBinding],
|
||||
) {
|
||||
self.registry
|
||||
.save_agent_catalog_config_editable_with_prompts(
|
||||
@@ -262,7 +286,7 @@ impl SignalsEndpoint {
|
||||
agent_id: &self.agent_id,
|
||||
agent_version: version,
|
||||
bindings: tool_bindings,
|
||||
tool_selection_policy: &ToolSelectionPolicy::default(),
|
||||
tool_selection_policy,
|
||||
resource_bindings,
|
||||
expected_state: None,
|
||||
},
|
||||
@@ -410,6 +434,169 @@ impl SignalsEndpoint {
|
||||
)
|
||||
.await;
|
||||
}
|
||||
|
||||
/// The reverse Tool-only commit: the second Tool binding leaves the published snapshot while the
|
||||
/// visible Resource/Prompt projection stays identical.
|
||||
async fn commit_tool_only_revert(&self) {
|
||||
let version = self.next_draft_version().await;
|
||||
self.open_draft(version).await;
|
||||
self.configure_draft(
|
||||
version,
|
||||
&self.tool_bindings(),
|
||||
&[self.notice_binding()],
|
||||
&self.extended_prompts(),
|
||||
)
|
||||
.await;
|
||||
self.publish_version(version).await;
|
||||
}
|
||||
|
||||
/// The search-mode Tool selection policy of this Agent: one group over the bound Tool.
|
||||
fn search_policy(&self) -> ToolSelectionPolicy {
|
||||
ToolSelectionPolicy {
|
||||
mode: ToolAccessMode::Search,
|
||||
groups: vec![ToolGroup {
|
||||
id: "crm".to_owned(),
|
||||
name: "CRM".to_owned(),
|
||||
description: "CRM operations".to_owned(),
|
||||
tool_names: vec![self.operation.name.clone()],
|
||||
}],
|
||||
search: ToolSearchSettings::default(),
|
||||
}
|
||||
}
|
||||
|
||||
/// A commit that changes only the Tool selection policy: same Tool, Resource and Prompt
|
||||
/// bindings, direct mode -> search mode. The served `tools/list` changes from the bound Tool to
|
||||
/// `search_tools`/`call_tool`, so this is a visible Tool catalog change.
|
||||
async fn commit_policy_only_change(&self) {
|
||||
let version = self.next_draft_version().await;
|
||||
self.open_draft(version).await;
|
||||
self.configure_draft_with_policy(
|
||||
version,
|
||||
&self.tool_bindings(),
|
||||
&self.search_policy(),
|
||||
&[],
|
||||
&self.base_prompts(),
|
||||
)
|
||||
.await;
|
||||
self.publish_version(version).await;
|
||||
}
|
||||
|
||||
/// A search-mode commit that only adds a Tool binding: `tools/list` still serves exactly
|
||||
/// `search_tools`/`call_tool`, so it must not announce a Tools change.
|
||||
async fn commit_search_mode_binding_change(&self) {
|
||||
let version = self.next_draft_version().await;
|
||||
self.open_draft(version).await;
|
||||
self.configure_draft_with_policy(
|
||||
version,
|
||||
&self.both_tool_bindings(),
|
||||
&self.search_policy(),
|
||||
&[],
|
||||
&self.base_prompts(),
|
||||
)
|
||||
.await;
|
||||
self.publish_version(version).await;
|
||||
}
|
||||
|
||||
/// Publish an independent Agent of the same workspace, bound to the first fixture operation, and
|
||||
/// return its read-only MCP client key.
|
||||
async fn publish_other_agent(&self, slug: &str) -> String {
|
||||
let agent_id = test_agent_id(slug);
|
||||
let now = OffsetDateTime::now_utc();
|
||||
self.registry
|
||||
.create_agent(CreateAgentRequest {
|
||||
agent: &Agent {
|
||||
id: agent_id.clone(),
|
||||
workspace_id: test_workspace_id(),
|
||||
slug: slug.to_owned(),
|
||||
display_name: slug.to_owned(),
|
||||
description: "Story 3.5 isolation fixture".to_owned(),
|
||||
status: AgentStatus::Draft,
|
||||
current_draft_version: 1,
|
||||
latest_published_version: None,
|
||||
created_at: now,
|
||||
updated_at: now,
|
||||
published_at: None,
|
||||
},
|
||||
version: &AgentVersion {
|
||||
agent_id: agent_id.clone(),
|
||||
version: 1,
|
||||
status: AgentStatus::Draft,
|
||||
instructions: json!({}),
|
||||
tool_selection_policy: ToolSelectionPolicy::default(),
|
||||
created_at: now,
|
||||
},
|
||||
bindings: &[binding_for_operation(&self.operation)],
|
||||
})
|
||||
.await
|
||||
.expect("the second Agent is created");
|
||||
self.registry
|
||||
.publish_agent(PublishAgentRequest {
|
||||
workspace_id: &test_workspace_id(),
|
||||
agent_id: &agent_id,
|
||||
version: 1,
|
||||
published_at: &OffsetDateTime::now_utc(),
|
||||
published_by: Some("alice"),
|
||||
expected_state: None,
|
||||
})
|
||||
.await
|
||||
.expect("the second Agent publishes");
|
||||
create_platform_api_key(
|
||||
&self.registry,
|
||||
slug,
|
||||
"mcp-signals-other",
|
||||
&[PlatformApiKeyScope::Read],
|
||||
)
|
||||
.await
|
||||
}
|
||||
|
||||
/// A committed Tool-only change of the independent Agent: it binds the second fixture Tool.
|
||||
async fn commit_other_agent_tool_change(&self, slug: &str) {
|
||||
let agent_id = test_agent_id(slug);
|
||||
let version = AgentVersion {
|
||||
agent_id: agent_id.clone(),
|
||||
version: 2,
|
||||
status: AgentStatus::Draft,
|
||||
instructions: json!({}),
|
||||
tool_selection_policy: ToolSelectionPolicy::default(),
|
||||
created_at: OffsetDateTime::now_utc(),
|
||||
};
|
||||
self.registry
|
||||
.create_agent_draft_version(CreateAgentDraftVersionRequest {
|
||||
workspace_id: &test_workspace_id(),
|
||||
agent_id: &agent_id,
|
||||
version: &version,
|
||||
bindings: &[],
|
||||
updated_at: &OffsetDateTime::now_utc(),
|
||||
})
|
||||
.await
|
||||
.expect("a second draft version of the other Agent opens");
|
||||
self.registry
|
||||
.save_agent_catalog_config_editable_with_prompts(
|
||||
SaveAgentCatalogConfigRequest {
|
||||
workspace_id: &test_workspace_id(),
|
||||
agent_id: &agent_id,
|
||||
agent_version: 2,
|
||||
bindings: &self.both_tool_bindings(),
|
||||
tool_selection_policy: &ToolSelectionPolicy::default(),
|
||||
resource_bindings: &[],
|
||||
expected_state: None,
|
||||
},
|
||||
&[],
|
||||
)
|
||||
.await
|
||||
.expect("the other Agent's second catalog config saves");
|
||||
self.registry
|
||||
.publish_agent(PublishAgentRequest {
|
||||
workspace_id: &test_workspace_id(),
|
||||
agent_id: &agent_id,
|
||||
version: 2,
|
||||
published_at: &OffsetDateTime::now_utc(),
|
||||
published_by: Some("alice"),
|
||||
expected_state: None,
|
||||
})
|
||||
.await
|
||||
.expect("the other Agent's second version publishes");
|
||||
}
|
||||
}
|
||||
|
||||
/// A live SSE response, read event by event.
|
||||
@@ -714,6 +901,17 @@ fn resource_uris(list: &Value) -> Vec<String> {
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn tool_names(list: &Value) -> Vec<String> {
|
||||
let mut names: Vec<String> = list["result"]["tools"]
|
||||
.as_array()
|
||||
.unwrap_or_else(|| panic!("tools/list must return a page: {list}"))
|
||||
.iter()
|
||||
.map(|tool| tool["name"].as_str().unwrap().to_owned())
|
||||
.collect();
|
||||
names.sort();
|
||||
names
|
||||
}
|
||||
|
||||
/// Write a stand file that only the current user may read (credential files live here).
|
||||
fn write_private(path: &PathBuf, contents: &str) {
|
||||
use std::io::Write as _;
|
||||
|
||||
@@ -127,12 +127,20 @@ async fn legacy_stream_announces_a_committed_catalog_change_after_the_commit() {
|
||||
"resources/list must serve the newly bound Resource: {resources}"
|
||||
);
|
||||
|
||||
// A Tool-only commit keeps the Resource/Prompt projection: no further signal.
|
||||
// A Tool-only commit keeps the Resource/Prompt projection: only a Tools frame follows (Story 3.5).
|
||||
endpoint.commit_tool_only_change().await;
|
||||
let frame = stream
|
||||
.expect_frame("the committed Tools list-change signal")
|
||||
.await;
|
||||
assert_eq!(frame["method"], TOOL_LIST_CHANGED);
|
||||
assert!(
|
||||
frame.get("params").is_none(),
|
||||
"a legacy list-change notification carries no parameters: {frame}"
|
||||
);
|
||||
stream
|
||||
.expect_silence(
|
||||
Duration::from_millis(2_500),
|
||||
"signal for a Tool-only commit",
|
||||
"a Resource or Prompt signal for a Tool-only commit",
|
||||
)
|
||||
.await;
|
||||
}
|
||||
@@ -162,7 +170,11 @@ async fn modern_listen_stream_acknowledges_then_announces_coalesced_changes() {
|
||||
);
|
||||
assert_eq!(
|
||||
acknowledgement["params"]["notifications"],
|
||||
json!({ "promptsListChanged": true, "resourcesListChanged": true }),
|
||||
json!({
|
||||
"promptsListChanged": true,
|
||||
"resourcesListChanged": true,
|
||||
"toolsListChanged": true
|
||||
}),
|
||||
"only the implemented list-change types are acknowledged: {acknowledgement}"
|
||||
);
|
||||
|
||||
@@ -173,7 +185,7 @@ async fn modern_listen_stream_acknowledges_then_announces_coalesced_changes() {
|
||||
endpoint.commit_tool_only_change().await;
|
||||
|
||||
let mut methods = Vec::new();
|
||||
for _ in 0..2 {
|
||||
for _ in 0..3 {
|
||||
let frame = stream
|
||||
.expect_frame("the coalesced list-change signal")
|
||||
.await;
|
||||
@@ -185,7 +197,8 @@ async fn modern_listen_stream_acknowledges_then_announces_coalesced_changes() {
|
||||
methods,
|
||||
vec![
|
||||
PROMPT_LIST_CHANGED.to_owned(),
|
||||
RESOURCE_LIST_CHANGED.to_owned()
|
||||
RESOURCE_LIST_CHANGED.to_owned(),
|
||||
TOOL_LIST_CHANGED.to_owned()
|
||||
]
|
||||
);
|
||||
stream
|
||||
@@ -228,8 +241,8 @@ async fn modern_listen_delivers_only_the_negotiated_signal_types() {
|
||||
);
|
||||
assert_eq!(
|
||||
acknowledgement["params"]["notifications"],
|
||||
json!({ "promptsListChanged": true }),
|
||||
"only the implemented and requested type is acknowledged: {acknowledgement}"
|
||||
json!({ "promptsListChanged": true, "toolsListChanged": true }),
|
||||
"only the implemented and requested types are acknowledged: {acknowledgement}"
|
||||
);
|
||||
|
||||
// The watcher takes its baseline before it can report anything.
|
||||
@@ -256,7 +269,7 @@ async fn modern_listen_delivers_only_the_negotiated_signal_types() {
|
||||
json!("prompts-only")
|
||||
);
|
||||
|
||||
// Neither `toolsListChanged` nor `resourceSubscriptions` were honoured, so nothing else follows.
|
||||
// No Tool commit happened, so no Tools frame follows; `resourceSubscriptions` was not honoured.
|
||||
stream
|
||||
.expect_silence(
|
||||
Duration::from_millis(2_500),
|
||||
@@ -354,6 +367,11 @@ async fn a_lost_notification_is_recovered_through_the_authoritative_methods() {
|
||||
discover["result"]["capabilities"]["resources"]["listChanged"],
|
||||
json!(true)
|
||||
);
|
||||
assert_eq!(
|
||||
discover["result"]["capabilities"]["tools"]["listChanged"],
|
||||
json!(true),
|
||||
"the Tools list-change capability is advertised: {discover}"
|
||||
);
|
||||
let resources = endpoint.modern("resources/list", json!({})).await;
|
||||
assert!(
|
||||
resource_uris(&resources)
|
||||
@@ -414,3 +432,360 @@ async fn a_lost_notification_is_recovered_through_the_authoritative_methods() {
|
||||
"re-initialization serves the authoritative catalog: {prompts}"
|
||||
);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Story 3.5 (FR-14): Tool catalog change signals. A client that negotiated the Tools list-changed
|
||||
// notification learns about a *committed* Tool catalog change, and `tools/list` stays the
|
||||
// authoritative source for a client without the notification or after a reconnect.
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
|
||||
/// AT-3.5-01/02 (modern): the Tools signal is delivered only to the stream that negotiated it, once
|
||||
/// per committed change, and `tools/list` serves the same committed snapshot.
|
||||
#[tokio::test]
|
||||
async fn modern_tools_list_changed_is_delivered_only_to_a_client_that_asks_for_it() {
|
||||
let endpoint = signals_endpoint().await;
|
||||
let mut tools = endpoint
|
||||
.listen(json!(51), json!({ "toolsListChanged": true }))
|
||||
.await;
|
||||
let mut prompts = endpoint
|
||||
.listen(json!(52), json!({ "promptsListChanged": true }))
|
||||
.await;
|
||||
|
||||
let acknowledgement = tools.expect_frame("the Tools acknowledgment").await;
|
||||
assert_eq!(acknowledgement["method"], SUBSCRIPTIONS_ACKNOWLEDGED);
|
||||
assert_eq!(
|
||||
acknowledgement["params"]["notifications"],
|
||||
json!({ "toolsListChanged": true }),
|
||||
"the Tools list-change type must be honoured and acknowledged: {acknowledgement}"
|
||||
);
|
||||
let other = prompts.expect_frame("the Prompts acknowledgment").await;
|
||||
assert_eq!(
|
||||
other["params"]["notifications"],
|
||||
json!({ "promptsListChanged": true }),
|
||||
"a stream that did not ask for Tools is acknowledged without it: {other}"
|
||||
);
|
||||
|
||||
// The watchers take their baseline before they can report anything.
|
||||
tokio::time::sleep(Duration::from_millis(1_500)).await;
|
||||
|
||||
// A draft-only edit is not a commit: nothing is announced.
|
||||
endpoint.edit_draft_without_publishing().await;
|
||||
tools
|
||||
.expect_silence(
|
||||
Duration::from_millis(2_500),
|
||||
"Tools signal for a draft-only edit",
|
||||
)
|
||||
.await;
|
||||
|
||||
// A committed Resource/Prompt change is not a Tools change: the Tools stream stays silent while
|
||||
// the Prompts stream receives exactly its own type.
|
||||
endpoint.commit_resource_and_prompt_change().await;
|
||||
let prompt_frame = prompts
|
||||
.expect_frame("the committed Prompt list-change signal")
|
||||
.await;
|
||||
assert_eq!(prompt_frame["method"], PROMPT_LIST_CHANGED);
|
||||
tools
|
||||
.expect_silence(
|
||||
Duration::from_millis(2_500),
|
||||
"Tools signal for a Resource/Prompt commit",
|
||||
)
|
||||
.await;
|
||||
|
||||
// One committed Tool catalog change is announced exactly once.
|
||||
endpoint.commit_tool_only_change().await;
|
||||
let frame = tools
|
||||
.expect_frame("the committed Tools list-change signal")
|
||||
.await;
|
||||
assert_eq!(frame["jsonrpc"], json!("2.0"));
|
||||
assert_eq!(frame["method"], TOOL_LIST_CHANGED);
|
||||
assert_eq!(frame["params"]["_meta"][SUBSCRIPTION_ID_KEY], json!(51));
|
||||
tools
|
||||
.expect_silence(Duration::from_millis(2_500), "a repeated Tools signal")
|
||||
.await;
|
||||
|
||||
// The prompts-only stream was never told about Tools, even though the commit happened after it
|
||||
// opened.
|
||||
prompts
|
||||
.expect_silence(Duration::from_millis(1_200), "unrequested Tools signal")
|
||||
.await;
|
||||
|
||||
// `tools/list` is authoritative for the same committed state, notification or not.
|
||||
let list = endpoint.modern("tools/list", json!({})).await;
|
||||
assert_eq!(
|
||||
tool_names(&list),
|
||||
vec!["crm_create_lead".to_owned(), "crm_create_second".to_owned()]
|
||||
);
|
||||
}
|
||||
|
||||
/// AT-3.5-01/02 (legacy): the legacy `GET` stream carries the Tools signal after the commit; a
|
||||
/// Resource/Prompt commit produces no Tools frame; a committed change of another Agent is never
|
||||
/// disclosed on this stream, and `tools/list` stays authoritative.
|
||||
#[tokio::test]
|
||||
async fn legacy_stream_announces_a_committed_tools_change_and_never_another_agents() {
|
||||
let endpoint = signals_endpoint().await;
|
||||
let other_key = endpoint.publish_other_agent(OTHER_AGENT_SLUG).await;
|
||||
let session = endpoint.legacy_session().await;
|
||||
|
||||
let mut stream = endpoint.legacy_stream(&session).await;
|
||||
tokio::time::sleep(Duration::from_millis(1_500)).await;
|
||||
stream
|
||||
.expect_silence(Duration::from_millis(1_200), "signal before any commit")
|
||||
.await;
|
||||
|
||||
// A committed Resource/Prompt change keeps the Tool binding set: no Tools frame.
|
||||
endpoint.commit_resource_and_prompt_change().await;
|
||||
let mut methods = Vec::new();
|
||||
for _ in 0..2 {
|
||||
let frame = stream.expect_frame("the committed catalog signals").await;
|
||||
assert!(
|
||||
frame.get("params").is_none(),
|
||||
"a legacy list-change notification carries no parameters: {frame}"
|
||||
);
|
||||
methods.push(frame["method"].as_str().unwrap().to_owned());
|
||||
}
|
||||
methods.sort();
|
||||
assert_eq!(
|
||||
methods,
|
||||
vec![
|
||||
PROMPT_LIST_CHANGED.to_owned(),
|
||||
RESOURCE_LIST_CHANGED.to_owned()
|
||||
],
|
||||
"a Resource/Prompt commit must not announce Tools"
|
||||
);
|
||||
|
||||
// A committed Tool change of another Agent of the same workspace never reaches this stream or
|
||||
// this Agent's `tools/list`.
|
||||
endpoint
|
||||
.commit_other_agent_tool_change(OTHER_AGENT_SLUG)
|
||||
.await;
|
||||
stream
|
||||
.expect_silence(
|
||||
Duration::from_millis(2_500),
|
||||
"Tools signal for another Agent's commit",
|
||||
)
|
||||
.await;
|
||||
let isolated = endpoint.legacy(&session, "tools/list", json!({})).await;
|
||||
assert_eq!(
|
||||
tool_names(&isolated),
|
||||
vec!["crm_create_lead".to_owned()],
|
||||
"another Agent's commit must not change this Agent's catalog: {isolated}"
|
||||
);
|
||||
// The commit really happened: the other Agent serves its own two-Tool catalog.
|
||||
let other_url = agent_mcp_url(&endpoint.base_url, OTHER_AGENT_SLUG);
|
||||
let other_session = initialize_session(&endpoint.client, &other_url, &other_key).await;
|
||||
let other_list = endpoint
|
||||
.client
|
||||
.post(&other_url)
|
||||
.header(header::ACCEPT, "application/json, text/event-stream")
|
||||
.header(header::AUTHORIZATION, format!("Bearer {other_key}"))
|
||||
.header("MCP-Protocol-Version", LEGACY_REVISION)
|
||||
.header("MCP-Session-Id", &other_session)
|
||||
.json(&json!({
|
||||
"jsonrpc": "2.0",
|
||||
"id": 7,
|
||||
"method": "tools/list",
|
||||
"params": {}
|
||||
}))
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
let other_list: Value = serde_json::from_str(&other_list.text().await.unwrap()).unwrap();
|
||||
assert_eq!(
|
||||
tool_names(&other_list),
|
||||
vec!["crm_create_lead".to_owned(), "crm_create_second".to_owned()],
|
||||
"the other Agent's committed catalog changed: {other_list}"
|
||||
);
|
||||
|
||||
// This Agent's committed Tool change is announced after the commit, exactly once.
|
||||
endpoint.commit_tool_only_change().await;
|
||||
let frame = stream
|
||||
.expect_frame("the committed Tools list-change signal")
|
||||
.await;
|
||||
assert_eq!(frame["method"], TOOL_LIST_CHANGED);
|
||||
assert!(
|
||||
frame.get("params").is_none(),
|
||||
"a legacy list-change notification carries no parameters: {frame}"
|
||||
);
|
||||
stream
|
||||
.expect_silence(
|
||||
Duration::from_millis(2_500),
|
||||
"a repeated or unrequested signal",
|
||||
)
|
||||
.await;
|
||||
|
||||
let list = endpoint.legacy(&session, "tools/list", json!({})).await;
|
||||
assert_eq!(
|
||||
tool_names(&list),
|
||||
vec!["crm_create_lead".to_owned(), "crm_create_second".to_owned()],
|
||||
"tools/list must serve the committed catalog without the notification: {list}"
|
||||
);
|
||||
}
|
||||
|
||||
/// AT-3.5-04: the Tools signal follows the same projection `tools/list` serves, so a committed
|
||||
/// publication that only changes the Tool selection policy is announced on both revisions, while a
|
||||
/// committed binding change that leaves `tools/list` unchanged is silent.
|
||||
#[tokio::test]
|
||||
async fn a_policy_only_commit_is_announced_on_both_revisions_and_an_invisible_change_is_silent() {
|
||||
let endpoint = signals_endpoint().await;
|
||||
let direct_projection = vec!["crm_create_lead".to_owned()];
|
||||
// `tool_names` sorts the served page.
|
||||
let search_projection = vec!["call_tool".to_owned(), "search_tools".to_owned()];
|
||||
|
||||
// Both revisions negotiate the Tools signal and take their baseline before anything can arrive.
|
||||
let mut modern = endpoint
|
||||
.listen(json!(61), json!({ "toolsListChanged": true }))
|
||||
.await;
|
||||
let acknowledgement = modern.expect_frame("the Tools acknowledgment").await;
|
||||
assert_eq!(acknowledgement["method"], SUBSCRIPTIONS_ACKNOWLEDGED);
|
||||
assert_eq!(
|
||||
acknowledgement["params"]["notifications"],
|
||||
json!({ "toolsListChanged": true })
|
||||
);
|
||||
let session = endpoint.legacy_session().await;
|
||||
let mut legacy = endpoint.legacy_stream(&session).await;
|
||||
tokio::time::sleep(Duration::from_millis(1_500)).await;
|
||||
|
||||
// The served projection before the commit is the direct-mode binding itself.
|
||||
assert_eq!(
|
||||
tool_names(&endpoint.modern("tools/list", json!({})).await),
|
||||
direct_projection
|
||||
);
|
||||
|
||||
// A policy-only commit: identical Tool/Resource/Prompt bindings, direct -> search mode. The
|
||||
// served list changes, so each negotiated stream receives exactly one Tools frame.
|
||||
endpoint.commit_policy_only_change().await;
|
||||
let modern_frame = modern
|
||||
.expect_frame("the committed Tools list-change signal (modern)")
|
||||
.await;
|
||||
assert_eq!(modern_frame["method"], TOOL_LIST_CHANGED);
|
||||
assert_eq!(
|
||||
modern_frame["params"]["_meta"][SUBSCRIPTION_ID_KEY],
|
||||
json!(61)
|
||||
);
|
||||
let legacy_frame = legacy
|
||||
.expect_frame("the committed Tools list-change signal (legacy)")
|
||||
.await;
|
||||
assert_eq!(legacy_frame["method"], TOOL_LIST_CHANGED);
|
||||
assert!(
|
||||
legacy_frame.get("params").is_none(),
|
||||
"a legacy list-change notification carries no parameters: {legacy_frame}"
|
||||
);
|
||||
modern
|
||||
.expect_silence(
|
||||
Duration::from_millis(2_500),
|
||||
"a repeated modern Tools signal",
|
||||
)
|
||||
.await;
|
||||
legacy
|
||||
.expect_silence(
|
||||
Duration::from_millis(2_500),
|
||||
"a repeated legacy Tools signal",
|
||||
)
|
||||
.await;
|
||||
|
||||
// `tools/list` is authoritative for the new projection on both revisions.
|
||||
assert_eq!(
|
||||
tool_names(&endpoint.modern("tools/list", json!({})).await),
|
||||
search_projection
|
||||
);
|
||||
assert_eq!(
|
||||
tool_names(&endpoint.legacy(&session, "tools/list", json!({})).await),
|
||||
search_projection
|
||||
);
|
||||
|
||||
// The inverse direction: in search mode a binding-only commit does not change `tools/list`, so
|
||||
// neither stream may claim a visible Tool change.
|
||||
endpoint.commit_search_mode_binding_change().await;
|
||||
modern
|
||||
.expect_silence(
|
||||
Duration::from_millis(3_500),
|
||||
"a Tools signal for an unchanged modern tools/list",
|
||||
)
|
||||
.await;
|
||||
legacy
|
||||
.expect_silence(
|
||||
Duration::from_millis(2_500),
|
||||
"a Tools signal for an unchanged legacy tools/list",
|
||||
)
|
||||
.await;
|
||||
assert_eq!(
|
||||
tool_names(&endpoint.modern("tools/list", json!({})).await),
|
||||
search_projection
|
||||
);
|
||||
}
|
||||
|
||||
/// AT-3.5-02/03: a client that missed the notification recovers Tool discovery from the authoritative
|
||||
/// state — the modern stateless client after a reconnect, and the legacy client after re-initializing
|
||||
/// a retired session — and a reconnected stream never replays the missed change.
|
||||
#[tokio::test]
|
||||
async fn a_reconnected_client_recovers_tools_discovery_from_the_authoritative_state() {
|
||||
let endpoint = signals_endpoint().await;
|
||||
|
||||
// Modern: the commit happens while no stream is open at all, then a client reconnects.
|
||||
endpoint.commit_tool_only_change().await;
|
||||
let mut reconnected = endpoint
|
||||
.listen(
|
||||
json!("after-reconnect"),
|
||||
json!({ "toolsListChanged": true }),
|
||||
)
|
||||
.await;
|
||||
let acknowledgement = reconnected.expect_frame("the Tools acknowledgment").await;
|
||||
assert_eq!(
|
||||
acknowledgement["params"]["notifications"],
|
||||
json!({ "toolsListChanged": true })
|
||||
);
|
||||
// The baseline of a new stream is the committed state: the missed change is not replayed.
|
||||
reconnected
|
||||
.expect_silence(
|
||||
Duration::from_millis(2_500),
|
||||
"a replayed Tools signal after reconnect",
|
||||
)
|
||||
.await;
|
||||
let list = endpoint.modern("tools/list", json!({})).await;
|
||||
assert_eq!(
|
||||
tool_names(&list),
|
||||
vec!["crm_create_lead".to_owned(), "crm_create_second".to_owned()],
|
||||
"a client without the notification recovers the committed catalog: {list}"
|
||||
);
|
||||
|
||||
// Legacy: one more committed Tool change is announced on the live stream, then the session is
|
||||
// retired and the client re-initializes.
|
||||
let session = endpoint.legacy_session().await;
|
||||
let mut stale = endpoint.legacy_stream(&session).await;
|
||||
tokio::time::sleep(Duration::from_millis(1_500)).await;
|
||||
endpoint.commit_tool_only_revert().await;
|
||||
let frame = stale
|
||||
.expect_frame("the committed Tools list-change signal")
|
||||
.await;
|
||||
assert_eq!(frame["method"], TOOL_LIST_CHANGED);
|
||||
|
||||
let deleted = endpoint
|
||||
.client
|
||||
.delete(&endpoint.mcp_url)
|
||||
.header(
|
||||
header::AUTHORIZATION,
|
||||
format!("Bearer {}", endpoint.api_key),
|
||||
)
|
||||
.header("MCP-Protocol-Version", LEGACY_REVISION)
|
||||
.header("MCP-Session-Id", &session)
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(deleted.status(), reqwest::StatusCode::NO_CONTENT);
|
||||
|
||||
let fresh = endpoint.legacy_session().await;
|
||||
let list = endpoint.legacy(&fresh, "tools/list", json!({})).await;
|
||||
assert_eq!(
|
||||
tool_names(&list),
|
||||
vec!["crm_create_lead".to_owned()],
|
||||
"re-initialization serves the committed catalog: {list}"
|
||||
);
|
||||
// A stream reopened after the reconnect starts from the committed baseline, not from a replay.
|
||||
let mut reopened = endpoint.legacy_stream(&fresh).await;
|
||||
reopened
|
||||
.expect_silence(
|
||||
Duration::from_millis(2_500),
|
||||
"a replayed Tools signal on a reconnected stream",
|
||||
)
|
||||
.await;
|
||||
}
|
||||
@@ -1036,6 +1036,7 @@ var TRANSLATIONS = {
|
||||
'wizard.error.secret_name_required': 'Secret name is required.',
|
||||
'wizard.error.secret_value_required': 'Secret value is required.',
|
||||
'wizard.error.save_upstream_first': 'Save the API host after creating a new authorization profile before continuing.',
|
||||
'wizard.error.execution_policy_invalid': 'Execution policy is invalid: mode, deadline from 1 to 3600000 ms and no-Tasks fallback are required.',
|
||||
'wizard.toast.auth_profile_created_title': 'Authorization profile created',
|
||||
'wizard.toast.auth_profile_created_body': 'New authorization profile is ready and selected.',
|
||||
'wizard.toast.auth_profile_error_title': 'Authorization profile creation failed',
|
||||
@@ -2353,6 +2354,7 @@ var TRANSLATIONS = {
|
||||
'wizard.error.secret_name_required': 'Нужно указать имя секрета.',
|
||||
'wizard.error.secret_value_required': 'Нужно указать значение секрета.',
|
||||
'wizard.error.save_upstream_first': 'Сначала сохраните API-хост после создания нового профиля авторизации.',
|
||||
'wizard.error.execution_policy_invalid': 'Политика выполнения некорректна: нужны режим, deadline от 1 до 3600000 мс и поведение без Tasks.',
|
||||
'wizard.toast.auth_profile_created_title': 'Профиль авторизации создан',
|
||||
'wizard.toast.auth_profile_created_body': 'Новый профиль авторизации готов и уже выбран.',
|
||||
'wizard.toast.auth_profile_error_title': 'Не удалось создать профиль авторизации',
|
||||
|
||||
@@ -214,10 +214,33 @@ function parseExecutionConfig(text) {
|
||||
auth_profile_ref: authProfileRef,
|
||||
headers: headers,
|
||||
};
|
||||
var executionPolicy = parseExecutionPolicy(value.execution_policy);
|
||||
if (executionPolicy) {
|
||||
config.execution_policy = executionPolicy;
|
||||
}
|
||||
|
||||
return config;
|
||||
}
|
||||
|
||||
// Story 4.1: the published execution policy must survive a wizard save. The editor is a free-form
|
||||
// document, so unknown/legacy shapes stay untouched: only a fully valid policy is projected, and an
|
||||
// explicit invalid value is reported instead of being silently replaced by defaults.
|
||||
function parseExecutionPolicy(raw) {
|
||||
if (raw === undefined || raw === null) return null;
|
||||
if (typeof raw !== 'object' || Array.isArray(raw)) {
|
||||
throw new Error(tKey('wizard.error.execution_policy_invalid'));
|
||||
}
|
||||
var mode = raw.mode === undefined ? 'synchronous' : raw.mode;
|
||||
var fallback = raw.no_tasks_fallback === undefined ? 'synchronous' : raw.no_tasks_fallback;
|
||||
var deadline = Number(raw.deadline_ms);
|
||||
if (['synchronous', 'background', 'adaptive'].indexOf(mode) < 0
|
||||
|| ['synchronous', 'unsupported'].indexOf(fallback) < 0
|
||||
|| !Number.isInteger(deadline) || deadline < 1 || deadline > 3600000) {
|
||||
throw new Error(tKey('wizard.error.execution_policy_invalid'));
|
||||
}
|
||||
return { mode: mode, deadline_ms: deadline, no_tasks_fallback: fallback };
|
||||
}
|
||||
|
||||
function currentUpstream() {
|
||||
var selected = upstreams.find(function(item) { return item.id === selectedUpstreamId; });
|
||||
if (selected) return selected;
|
||||
@@ -415,6 +438,13 @@ function executionConfigToEditorValue(config) {
|
||||
var value = {
|
||||
timeout_ms: config.timeout_ms,
|
||||
};
|
||||
if (config.execution_policy) {
|
||||
value.execution_policy = {
|
||||
mode: config.execution_policy.mode,
|
||||
deadline_ms: config.execution_policy.deadline_ms,
|
||||
no_tasks_fallback: config.execution_policy.no_tasks_fallback,
|
||||
};
|
||||
}
|
||||
if (config.retry_policy) {
|
||||
value.retry = { max_attempts: config.retry_policy.max_attempts };
|
||||
}
|
||||
|
||||
@@ -0,0 +1,139 @@
|
||||
const { test, expect } = require('@playwright/test');
|
||||
const { getCurrentWorkspace, login } = require('./helpers');
|
||||
|
||||
// Story 4.1 (FR-21): the published execution policy is part of the Tool version and must survive a
|
||||
// wizard save. The editor is a free-form document, so a no-op edit must not erase it and an explicit
|
||||
// invalid value must be reported instead of being silently replaced by defaults.
|
||||
function draftSnapshot(operationId) {
|
||||
return {
|
||||
id: operationId,
|
||||
name: operationId,
|
||||
display_name: 'Policy rates',
|
||||
category: 'general',
|
||||
protocol: 'rest',
|
||||
target: {
|
||||
kind: 'rest',
|
||||
base_url: 'https://api.example.test',
|
||||
method: 'GET',
|
||||
path_template: '/rates',
|
||||
static_headers: {},
|
||||
},
|
||||
input_schema: {
|
||||
type: 'object',
|
||||
description: null,
|
||||
required: false,
|
||||
nullable: false,
|
||||
default_value: null,
|
||||
fields: {},
|
||||
items: null,
|
||||
enum_values: [],
|
||||
variants: [],
|
||||
},
|
||||
output_schema: {
|
||||
type: 'object',
|
||||
description: null,
|
||||
required: false,
|
||||
nullable: false,
|
||||
default_value: null,
|
||||
fields: {},
|
||||
items: null,
|
||||
enum_values: [],
|
||||
variants: [],
|
||||
},
|
||||
input_mapping: { rules: [] },
|
||||
output_mapping: { rules: [{ source: '$.response.body.rate', target: '$.output.rate', required: true }] },
|
||||
execution_config: {
|
||||
timeout_ms: 10000,
|
||||
retry_policy: null,
|
||||
auth_profile_ref: null,
|
||||
headers: {},
|
||||
approval_policy: null,
|
||||
execution_policy: {
|
||||
mode: 'adaptive',
|
||||
deadline_ms: 45000,
|
||||
no_tasks_fallback: 'unsupported',
|
||||
},
|
||||
},
|
||||
tool_description: { title: 'Policy rates', description: 'Get rates.', tags: [], examples: [] },
|
||||
wizard_state: { input_sample: {}, output_sample: {}, test_input: {}, import_findings: [] },
|
||||
};
|
||||
}
|
||||
|
||||
test('wizard round-trips the published execution policy and rejects an invalid edit', async ({ page }) => {
|
||||
await login(page);
|
||||
const workspace = await getCurrentWorkspace(page);
|
||||
const operationId = 'policy_rates_41';
|
||||
const operationPath = `/api/admin/workspaces/${encodeURIComponent(workspace.id)}/operations/${operationId}`;
|
||||
const savedPayloads = [];
|
||||
|
||||
await page.route(operationPath, async (route) => {
|
||||
if (route.request().method() === 'PATCH') {
|
||||
savedPayloads.push(route.request().postDataJSON());
|
||||
await route.fulfill({
|
||||
contentType: 'application/json',
|
||||
body: JSON.stringify({ operation_id: operationId, workspace_id: workspace.id, version: 2, status: 'draft' }),
|
||||
});
|
||||
return;
|
||||
}
|
||||
await route.fulfill({
|
||||
contentType: 'application/json',
|
||||
body: JSON.stringify({
|
||||
id: operationId,
|
||||
workspace_id: workspace.id,
|
||||
name: operationId,
|
||||
display_name: 'Policy rates',
|
||||
category: 'general',
|
||||
protocol: 'rest',
|
||||
status: 'draft',
|
||||
current_draft_version: 1,
|
||||
draft_version_ref: { version: 1, status: 'draft' },
|
||||
published_version_ref: null,
|
||||
agent_refs: [],
|
||||
}),
|
||||
});
|
||||
});
|
||||
await page.route(`${operationPath}/versions/*`, async (route) => {
|
||||
await route.fulfill({
|
||||
contentType: 'application/json',
|
||||
body: JSON.stringify({
|
||||
operation_id: operationId,
|
||||
workspace_id: workspace.id,
|
||||
version: 1,
|
||||
status: 'draft',
|
||||
snapshot: draftSnapshot(operationId),
|
||||
}),
|
||||
});
|
||||
});
|
||||
await page.route('**/operations/analyze-quality', async (route) => {
|
||||
await route.fulfill({ contentType: 'application/json', body: JSON.stringify({ blocking: false, findings: [] }) });
|
||||
});
|
||||
page.on('dialog', (dialog) => dialog.accept());
|
||||
|
||||
await page.goto(`/wizard/?mode=edit&operationId=${operationId}`);
|
||||
await expect(page.locator('#tool-display-name')).toHaveValue('Policy rates');
|
||||
|
||||
const editorValue = await page.locator('#tool-exec-config').inputValue();
|
||||
expect(editorValue).toContain('execution_policy');
|
||||
expect(editorValue).toContain('adaptive');
|
||||
expect(editorValue).toContain('45000');
|
||||
expect(editorValue).toContain('unsupported');
|
||||
|
||||
// A real edit still saves the pinned policy unchanged.
|
||||
await page.evaluate(() => window.CrankWizardShell.doGoToStep(4));
|
||||
await page.locator('#tool-display-name').fill('Policy rates edited');
|
||||
await page.locator('.btn-save-draft').click();
|
||||
await expect.poll(() => savedPayloads.length).toBe(1);
|
||||
expect(savedPayloads[0].execution_config.execution_policy).toEqual({
|
||||
mode: 'adaptive',
|
||||
deadline_ms: 45000,
|
||||
no_tasks_fallback: 'unsupported',
|
||||
});
|
||||
|
||||
// An explicit invalid policy is refused instead of being silently rewritten to defaults.
|
||||
await page.evaluate(() => window.CrankWizardShell.doGoToStep(5));
|
||||
await expect(page.locator('#tool-exec-config')).toBeVisible();
|
||||
await page.locator('#tool-exec-config').fill('timeout_ms: 10000\nexecution_policy:\n mode: background\n deadline_ms: 0\n');
|
||||
await page.locator('.btn-save-draft').click();
|
||||
await expect(page.locator('#tool-exec-config')).toHaveValue(/deadline_ms: 0/);
|
||||
expect(savedPayloads.length).toBe(1);
|
||||
});
|
||||
@@ -272,7 +272,10 @@ fn record_unknown_approval_access_denial(reason: &'static str) {
|
||||
);
|
||||
}
|
||||
|
||||
fn allows_scope(scopes: &[PlatformApiKeyScope], required_scope: PlatformApiKeyScope) -> bool {
|
||||
pub(super) fn allows_scope(
|
||||
scopes: &[PlatformApiKeyScope],
|
||||
required_scope: PlatformApiKeyScope,
|
||||
) -> bool {
|
||||
match required_scope {
|
||||
PlatformApiKeyScope::Read => scopes.iter().any(|scope| {
|
||||
matches!(
|
||||
|
||||
@@ -51,13 +51,15 @@ mod auth_resolution;
|
||||
mod dispatch;
|
||||
mod endpoint;
|
||||
mod legacy_dispatch;
|
||||
|
||||
mod task_worker;
|
||||
mod tasks;
|
||||
use self::approvals::{
|
||||
approve_request, deny_request, get_approval_request, list_pending_approvals,
|
||||
};
|
||||
pub(super) use self::auth_resolution::resolve_operation_auth;
|
||||
use self::endpoint::{mcp_delete, mcp_get, mcp_post};
|
||||
|
||||
pub use self::task_worker::TaskWorkerHandler;
|
||||
pub use self::tasks::{TaskApplication, TaskApplicationError, TaskPrincipal};
|
||||
// Test-only import surface: the BUILD-internal `app/tests.rs` module reaches these two
|
||||
// through `super`, and the plain lib build does not use them (same pattern as
|
||||
// `#[cfg(test)] use invocation_history::observe_invocation_history_outcome;` above).
|
||||
@@ -92,6 +94,9 @@ pub(super) struct AppState {
|
||||
pub(super) signal_streams: Arc<crate::protocol::StreamRegistry>,
|
||||
/// Story 3.4: the bounded table of the `tools/call` requests a legacy client can still cancel.
|
||||
pub(super) in_flight: Arc<self::lifecycle::InFlightCalls>,
|
||||
/// Story 4.2: durable background Tasks over the same registry pool. The public wire stays
|
||||
/// synchronous/unsupported; readiness depends on this mandatory store.
|
||||
tasks: Arc<TaskApplication>,
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
@@ -137,6 +142,7 @@ pub fn build_app(
|
||||
DEFAULT_MAX_CONCURRENT_SESSIONS,
|
||||
false,
|
||||
None,
|
||||
None,
|
||||
)
|
||||
}
|
||||
|
||||
@@ -192,6 +198,7 @@ pub fn build_app_with_background_workers_and_limits(
|
||||
max_concurrent_sessions,
|
||||
true,
|
||||
None,
|
||||
None,
|
||||
)
|
||||
}
|
||||
|
||||
@@ -227,6 +234,41 @@ pub fn build_app_with_artifacts(
|
||||
max_concurrent_sessions,
|
||||
true,
|
||||
Some(artifact_store),
|
||||
None,
|
||||
)
|
||||
}
|
||||
|
||||
/// Production launcher entry point with the durable Task application entry constructed by the
|
||||
/// process composition root from the same registry pool and admission limits as the runtime.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn build_app_with_artifacts_and_tasks(
|
||||
registry: PostgresRegistry,
|
||||
refresh_interval: Duration,
|
||||
public_base_url: Option<String>,
|
||||
secret_crypto: SecretCrypto,
|
||||
runtime: RuntimeExecutor,
|
||||
api_rate_limiter: RequestRateLimiter,
|
||||
coordination_store: Arc<dyn CoordinationStateStore>,
|
||||
sessions: SharedSessionStore,
|
||||
credential_verifier: SharedMachineCredentialVerifier,
|
||||
max_concurrent_sessions: usize,
|
||||
artifact_store: crank_artifacts::ArtifactStore,
|
||||
tasks: Arc<TaskApplication>,
|
||||
) -> Router {
|
||||
build_app_inner(
|
||||
registry,
|
||||
refresh_interval,
|
||||
public_base_url,
|
||||
secret_crypto,
|
||||
runtime,
|
||||
api_rate_limiter,
|
||||
coordination_store,
|
||||
sessions,
|
||||
credential_verifier,
|
||||
max_concurrent_sessions,
|
||||
true,
|
||||
Some(artifact_store),
|
||||
Some(tasks),
|
||||
)
|
||||
}
|
||||
|
||||
@@ -244,8 +286,23 @@ fn build_app_inner(
|
||||
max_concurrent_sessions: usize,
|
||||
start_background_workers: bool,
|
||||
artifact_store: Option<crank_artifacts::ArtifactStore>,
|
||||
tasks: Option<Arc<TaskApplication>>,
|
||||
) -> Router {
|
||||
let session_metrics = ActiveSessionMetrics::start(Arc::clone(&sessions));
|
||||
let tasks = tasks.unwrap_or_else(|| {
|
||||
let store = crank_registry::PostgresTaskStore::new(
|
||||
registry.pool().clone(),
|
||||
crank_registry::AdmissionLimits::default(),
|
||||
crank_core::AdmissionSchedulerConfig::default(),
|
||||
)
|
||||
.expect("default admission limits and scheduler weights are valid");
|
||||
Arc::new(TaskApplication::new(
|
||||
registry.clone(),
|
||||
refresh_interval,
|
||||
Arc::clone(&coordination_store),
|
||||
crank_runtime::TaskService::new(Arc::new(store)),
|
||||
))
|
||||
});
|
||||
let state = Arc::new(AppState {
|
||||
registry: registry.clone(),
|
||||
catalog: PublishedToolCatalog::new(registry, refresh_interval, coordination_store),
|
||||
@@ -263,6 +320,7 @@ fn build_app_inner(
|
||||
in_flight: Arc::new(lifecycle::InFlightCalls::new(
|
||||
lifecycle::MAX_IN_FLIGHT_CALLS,
|
||||
)),
|
||||
tasks,
|
||||
});
|
||||
if start_background_workers {
|
||||
spawn_approval_recovery(Arc::clone(&state));
|
||||
@@ -311,24 +369,55 @@ async fn health() -> Json<Value> {
|
||||
}
|
||||
|
||||
async fn readiness(State(state): State<Arc<AppState>>) -> Response {
|
||||
match state.registry.ping().await {
|
||||
Ok(()) => Json(json!({
|
||||
let postgres_ready = state.registry.ping().await.is_ok();
|
||||
// Story 4.1: admission state is a mandatory dependency of every execution, so readiness must
|
||||
// reflect it rather than reporting ready on a bare `select 1`.
|
||||
let admission_ready = state.registry.execution_admission_health().await.is_ok();
|
||||
// Story 4.2: the durable Task store is mandatory for a durable acceptance acknowledgement.
|
||||
let durable_tasks_ready = state.tasks.health().await.is_ok();
|
||||
if postgres_ready && admission_ready && durable_tasks_ready {
|
||||
return Json(json!({
|
||||
"service": "mcp-server",
|
||||
"status": "ready",
|
||||
"checks": { "postgres": "ready" }
|
||||
"checks": {
|
||||
"postgres": "ready",
|
||||
"execution_admission": "ready",
|
||||
"durable_tasks": "ready"
|
||||
}
|
||||
}))
|
||||
.into_response(),
|
||||
Err(_) => (
|
||||
StatusCode::SERVICE_UNAVAILABLE,
|
||||
Json(json!({
|
||||
"service": "mcp-server",
|
||||
"status": "not_ready",
|
||||
"checks": { "postgres": "not_ready" },
|
||||
"error": "database is unavailable"
|
||||
})),
|
||||
)
|
||||
.into_response(),
|
||||
.into_response();
|
||||
}
|
||||
let mut checks = serde_json::Map::new();
|
||||
checks.insert(
|
||||
"postgres".to_owned(),
|
||||
json!(if postgres_ready { "ready" } else { "not_ready" }),
|
||||
);
|
||||
checks.insert(
|
||||
"execution_admission".to_owned(),
|
||||
json!(if admission_ready {
|
||||
"ready"
|
||||
} else {
|
||||
"not_ready"
|
||||
}),
|
||||
);
|
||||
checks.insert(
|
||||
"durable_tasks".to_owned(),
|
||||
json!(if durable_tasks_ready {
|
||||
"ready"
|
||||
} else {
|
||||
"not_ready"
|
||||
}),
|
||||
);
|
||||
(
|
||||
StatusCode::SERVICE_UNAVAILABLE,
|
||||
Json(json!({
|
||||
"service": "mcp-server",
|
||||
"status": "not_ready",
|
||||
"checks": checks,
|
||||
"error": "a mandatory dependency is unavailable"
|
||||
})),
|
||||
)
|
||||
.into_response()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -19,18 +19,31 @@ pub(crate) async fn resolve_operation_auth(
|
||||
workspace_id: &crank_core::WorkspaceId,
|
||||
execution_config: &crank_core::ExecutionConfig,
|
||||
) -> Result<Option<ResolvedAuth>, RuntimeError> {
|
||||
if execution_config.auth_profile_ref.is_none() {
|
||||
return Ok(None);
|
||||
}
|
||||
let span = Stage::AuthResolve.span();
|
||||
let result = resolve_runtime_auth_for_task(
|
||||
resolve_operation_auth_with(
|
||||
&state.registry,
|
||||
&state.secret_crypto,
|
||||
workspace_id,
|
||||
execution_config,
|
||||
)
|
||||
.instrument(span.clone())
|
||||
.await;
|
||||
.await
|
||||
}
|
||||
|
||||
/// Same resolution for callers that hold the authoritative registry/secret-crypto pair without the
|
||||
/// HTTP application state (the durable Task worker).
|
||||
pub(crate) async fn resolve_operation_auth_with(
|
||||
registry: &PostgresRegistry,
|
||||
secret_crypto: &SecretCrypto,
|
||||
workspace_id: &crank_core::WorkspaceId,
|
||||
execution_config: &crank_core::ExecutionConfig,
|
||||
) -> Result<Option<ResolvedAuth>, RuntimeError> {
|
||||
if execution_config.auth_profile_ref.is_none() {
|
||||
return Ok(None);
|
||||
}
|
||||
let span = Stage::AuthResolve.span();
|
||||
let result =
|
||||
resolve_runtime_auth_for_task(registry, secret_crypto, workspace_id, execution_config)
|
||||
.instrument(span.clone())
|
||||
.await;
|
||||
match &result {
|
||||
Ok(_) => StageOutcome::Success.record(&span),
|
||||
Err(_) => {
|
||||
|
||||
@@ -103,7 +103,7 @@ pub(super) async fn mcp_get(
|
||||
};
|
||||
|
||||
// Story 3.19: the pinned legacy transport forbids broadcasting one JSON-RPC message across the
|
||||
// SSE streams of a session, so exactly one admitted `GET` receives the Resource/Prompt
|
||||
// SSE streams of a session, so exactly one admitted `GET` receives the Resource/Prompt/Tool
|
||||
// list-change signals. A newer `GET` takes them over and the older stream simply ends; a
|
||||
// `DELETE` retires the producer, so a stale generation never writes into a reconnect.
|
||||
let Some(generation) = state.signal_streams.admit(&session_id) else {
|
||||
@@ -115,7 +115,7 @@ pub(super) async fn mcp_get(
|
||||
crate::protocol::Watch {
|
||||
workspace_slug: path.workspace_slug.clone(),
|
||||
agent_slug: path.agent_slug.clone(),
|
||||
signals: crate::protocol::Signals::BOTH,
|
||||
signals: crate::protocol::Signals::ALL,
|
||||
wire: crate::protocol::Wire::Legacy,
|
||||
legacy_stream: Some((
|
||||
Arc::clone(&state.signal_streams),
|
||||
|
||||
@@ -0,0 +1,282 @@
|
||||
//! Application-level durable Task handler for Story 4.3.
|
||||
|
||||
use std::sync::Arc;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use async_trait::async_trait;
|
||||
use crank_core::{
|
||||
AgentId, ExecutionOrigin, MachineAccessMode, OperationSecurityLevel, PlatformApiKeyScope,
|
||||
TaskError, TaskLease, TaskOwnerKind, TraceContext, VerifiedMachineCredential, WorkspaceId,
|
||||
current_unix_ms,
|
||||
};
|
||||
use crank_registry::PostgresRegistry;
|
||||
use crank_registry::PublishedAgentTool;
|
||||
use crank_runtime::{
|
||||
ExecutionAuthorization, ExecutionRequestError, RuntimeExecutionRequest, RuntimeExecutor,
|
||||
SecretCrypto, TaskDispatchPermit, TaskHandler, TaskService, TaskWorkerError,
|
||||
};
|
||||
|
||||
use super::TaskApplication;
|
||||
use super::auth_resolution::resolve_operation_auth_with;
|
||||
use super::tool_resolution::runtime_operation;
|
||||
use crate::access::{allows_scope, credential_allows_security_level};
|
||||
use crate::catalog::PublishedToolCatalog;
|
||||
|
||||
pub struct TaskWorkerHandler {
|
||||
registry: PostgresRegistry,
|
||||
catalog: PublishedToolCatalog,
|
||||
runtime: RuntimeExecutor,
|
||||
secret_crypto: SecretCrypto,
|
||||
service: TaskService,
|
||||
}
|
||||
|
||||
impl TaskWorkerHandler {
|
||||
/// Production construction from the same application entry, registry and runtime the MCP
|
||||
/// process serves requests with. The worker needs no HTTP state, only these authoritative
|
||||
/// dependencies.
|
||||
pub fn from_application(
|
||||
tasks: &TaskApplication,
|
||||
registry: PostgresRegistry,
|
||||
runtime: RuntimeExecutor,
|
||||
secret_crypto: SecretCrypto,
|
||||
) -> Self {
|
||||
Self {
|
||||
registry,
|
||||
catalog: tasks.catalog(),
|
||||
runtime,
|
||||
secret_crypto,
|
||||
service: tasks.task_service(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Authoritative pre-dispatch authorization of one leased Task (Story 4.3).
|
||||
///
|
||||
/// Resolves the exact pinned Published Version in the current publication, repeats the approval
|
||||
/// policy and revalidates the typed persisted Platform API key identity against the registry:
|
||||
/// the key must still be active, unexpired and bound to this workspace/agent, and its exact
|
||||
/// scopes/security level must still authorize the operation. Any denial is a typed error, so the
|
||||
/// worker finishes the attempt without dispatch (fail closed before any network use).
|
||||
///
|
||||
/// An administrator Task has no authoritative Task revalidation API in the registry, so it stays
|
||||
/// fail-closed here instead of inventing authority.
|
||||
async fn authorize(&self, lease: &TaskLease) -> Result<PublishedAgentTool, TaskError> {
|
||||
if lease.record.owner_kind != TaskOwnerKind::Agent {
|
||||
return Err(TaskError::invalid(
|
||||
"admin task authority revalidation is not implemented",
|
||||
));
|
||||
}
|
||||
let Some(key_id) = lease.record.platform_api_key_id.as_ref() else {
|
||||
return Err(TaskError::invalid("task authority reference is missing"));
|
||||
};
|
||||
|
||||
let workspace_id = WorkspaceId::new(lease.record.workspace_id.as_str());
|
||||
let agent_id = AgentId::new(lease.record.owner_id.as_str());
|
||||
let workspace = self
|
||||
.registry
|
||||
.get_workspace(&workspace_id)
|
||||
.await
|
||||
.map_err(|_| TaskError::unavailable("published catalog unavailable"))?
|
||||
.ok_or_else(|| TaskError::invalid("task workspace no longer exists"))?;
|
||||
let agents = self
|
||||
.registry
|
||||
.list_agents(&workspace_id)
|
||||
.await
|
||||
.map_err(|_| TaskError::unavailable("published catalog unavailable"))?;
|
||||
let agent = agents
|
||||
.into_iter()
|
||||
.find(|agent| agent.id.as_str() == lease.record.owner_id.as_str())
|
||||
.ok_or_else(|| TaskError::invalid("task agent no longer exists"))?;
|
||||
|
||||
let catalog = self
|
||||
.catalog
|
||||
.get_catalog(&workspace.workspace.slug, &agent.slug)
|
||||
.await
|
||||
.map_err(|_| TaskError::unavailable("published catalog unavailable"))?;
|
||||
let tool = catalog
|
||||
.tools
|
||||
.into_iter()
|
||||
.find(|tool| {
|
||||
tool.operation.id.as_str() == lease.record.operation_id.as_str()
|
||||
&& tool.operation.version == lease.record.pins.operation_version
|
||||
})
|
||||
.ok_or_else(|| TaskError::invalid("task published operation pin no longer matches"))?;
|
||||
|
||||
if tool.workspace_id.as_str() != lease.record.workspace_id.as_str() {
|
||||
return Err(TaskError::invalid("task workspace binding mismatch"));
|
||||
}
|
||||
if tool.agent_id.as_str() != lease.record.owner_id.as_str() {
|
||||
return Err(TaskError::invalid("task agent binding mismatch"));
|
||||
}
|
||||
if tool
|
||||
.operation
|
||||
.execution_config
|
||||
.approval_policy
|
||||
.as_ref()
|
||||
.is_some_and(|policy| policy.required)
|
||||
{
|
||||
return Err(TaskError::invalid(
|
||||
"missing approval proof for task operation",
|
||||
));
|
||||
}
|
||||
|
||||
// Authoritative revalidation of the exact immutable key identity. A revoked, expired,
|
||||
// foreign-workspace or foreign-agent key is absent here and never reaches the network.
|
||||
let key = self
|
||||
.registry
|
||||
.revalidate_platform_api_key(&workspace_id, &agent_id, key_id)
|
||||
.await
|
||||
.map_err(|_| TaskError::unavailable("task authority store unavailable"))?
|
||||
.ok_or_else(|| TaskError::invalid("task authority is no longer active"))?;
|
||||
let credential = VerifiedMachineCredential {
|
||||
machine_access_mode: MachineAccessMode::StaticAgentKey,
|
||||
max_security_level: OperationSecurityLevel::Standard,
|
||||
scopes: key.api_key.scopes.clone(),
|
||||
platform_api_key_id: Some(key.api_key.id.clone()),
|
||||
};
|
||||
if !allows_scope(&credential.scopes, PlatformApiKeyScope::Write) {
|
||||
return Err(TaskError::invalid("task authority scope is insufficient"));
|
||||
}
|
||||
if !credential_allows_security_level(&credential, tool.operation.security_level) {
|
||||
return Err(TaskError::invalid(
|
||||
"task authority security level is insufficient",
|
||||
));
|
||||
}
|
||||
Ok(tool)
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl TaskHandler for TaskWorkerHandler {
|
||||
async fn revalidate(&self, lease: &TaskLease) -> Result<(), TaskWorkerError> {
|
||||
self.authorize(lease)
|
||||
.await
|
||||
.map_err(TaskWorkerError::Store)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn execute(
|
||||
&self,
|
||||
lease: &TaskLease,
|
||||
_attempt_id: &str,
|
||||
cancelled: Arc<std::sync::atomic::AtomicBool>,
|
||||
permit: TaskDispatchPermit,
|
||||
) -> crank_runtime::TaskAttemptOutcome {
|
||||
use crank_runtime::TaskAttemptOutcome;
|
||||
use std::sync::atomic::Ordering;
|
||||
|
||||
// The lease may have been lost between the checkpoint and the outbound call; never dispatch
|
||||
// on behalf of a worker that no longer owns the Task.
|
||||
if cancelled.load(Ordering::Acquire) {
|
||||
return TaskAttemptOutcome::OutcomeUnknown;
|
||||
}
|
||||
|
||||
let tool = match self.authorize(lease).await {
|
||||
Ok(tool) => tool,
|
||||
Err(error) => {
|
||||
return TaskAttemptOutcome::Failed(serde_json::json!({"code": error.to_string()}));
|
||||
}
|
||||
};
|
||||
|
||||
let input = match self.service.executable_input(lease).await {
|
||||
Ok(input) => input,
|
||||
Err(error) => {
|
||||
return TaskAttemptOutcome::Failed(serde_json::json!({"code": error.to_string()}));
|
||||
}
|
||||
};
|
||||
|
||||
let operation = runtime_operation(&tool);
|
||||
let now_ms = current_unix_ms();
|
||||
let deadline_ms = lease.record.pins.execution_deadline_unix_ms;
|
||||
if deadline_ms <= now_ms {
|
||||
return TaskAttemptOutcome::Failed(
|
||||
serde_json::json!({"code": "task deadline elapsed"}),
|
||||
);
|
||||
}
|
||||
let deadline = Instant::now()
|
||||
+ Duration::from_millis((deadline_ms - now_ms).min(i64::MAX as i64) as u64);
|
||||
let workspace_id = WorkspaceId::new(lease.record.workspace_id.as_str());
|
||||
let agent_id = AgentId::new(lease.record.owner_id.as_str());
|
||||
let resolved_auth = match resolve_operation_auth_with(
|
||||
&self.registry,
|
||||
&self.secret_crypto,
|
||||
&workspace_id,
|
||||
&operation.execution_config,
|
||||
)
|
||||
.await
|
||||
{
|
||||
Ok(auth) => auth,
|
||||
Err(error) => {
|
||||
return TaskAttemptOutcome::Failed(
|
||||
serde_json::json!({ "code": error.to_string() }),
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
// Continue the parent trace persisted with the accepted Task; the worker's attempt span is a
|
||||
// child of it, and the executor records the attempt identity. Trace data stays out of labels.
|
||||
let trace_context = match TraceContext::parse(&lease.record.support.traceparent) {
|
||||
Ok(context) => context,
|
||||
Err(_) => {
|
||||
return TaskAttemptOutcome::Failed(
|
||||
serde_json::json!({ "code": "task trace parent is invalid" }),
|
||||
);
|
||||
}
|
||||
};
|
||||
let request_context = crank_runtime::RuntimeRequestContext::new(
|
||||
lease.record.support.request_id.clone(),
|
||||
trace_context,
|
||||
)
|
||||
.with_metering_context(
|
||||
workspace_id.clone(),
|
||||
Some(agent_id.clone()),
|
||||
crank_core::InvocationSource::AgentToolCall,
|
||||
);
|
||||
|
||||
let request = match RuntimeExecutionRequest::try_new(
|
||||
&workspace_id,
|
||||
ExecutionOrigin::AgentSnapshot,
|
||||
Some(&agent_id),
|
||||
&operation,
|
||||
&input,
|
||||
ExecutionAuthorization::Authorized,
|
||||
resolved_auth.as_ref(),
|
||||
&request_context,
|
||||
deadline,
|
||||
) {
|
||||
Ok(request) => request,
|
||||
Err(error) => {
|
||||
return TaskAttemptOutcome::Failed(match error {
|
||||
ExecutionRequestError::InvalidOrigin => {
|
||||
serde_json::json!({"code": "invalid execution origin"})
|
||||
}
|
||||
ExecutionRequestError::InvalidOperationVersion => {
|
||||
serde_json::json!({"code": "invalid operation version"})
|
||||
}
|
||||
ExecutionRequestError::DeadlineElapsed => {
|
||||
serde_json::json!({"code": "task deadline elapsed"})
|
||||
}
|
||||
ExecutionRequestError::InvalidMeteringScope => {
|
||||
serde_json::json!({"code": "invalid metering scope"})
|
||||
}
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
if cancelled.load(Ordering::Acquire) {
|
||||
return TaskAttemptOutcome::OutcomeUnknown;
|
||||
}
|
||||
match self.runtime.execute_task_outcome(request, permit).await {
|
||||
Ok(success) => TaskAttemptOutcome::Completed(success.output),
|
||||
Err(failure) => {
|
||||
// An ambiguous outbound failure is recorded as uncertainty, never as a retryable
|
||||
// failure: the durable checkpoint already exists, so Story 4.4 may reconcile it.
|
||||
if failure.outcome_certainty() == crank_core::OutcomeCertainty::OutcomeUnknown {
|
||||
return TaskAttemptOutcome::OutcomeUnknown;
|
||||
}
|
||||
TaskAttemptOutcome::Failed(
|
||||
serde_json::json!({ "code": format!("{:?}", failure.error_code()) }),
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,322 @@
|
||||
//! Application entry of durable background Tasks (Story 4.2, FR-22/FR-23).
|
||||
//!
|
||||
//! The entry takes an already authenticated principal (a verified machine credential, or an
|
||||
//! administrator identity verified by the calling admin surface), resolves the exact published Tool,
|
||||
//! repeats the caller's authorization, pins the Published Version/policy/deadline and delegates the
|
||||
//! durable acceptance to the runtime Task service. The repository owns the transaction, so the
|
||||
//! returned Task ID exists only after Task + dispatch intent + queue slot committed.
|
||||
//!
|
||||
//! Deliberately not wired: the public MCP `tools/call`/Tasks wire (Story 4.7) and the worker/leases
|
||||
//! (Story 4.3). The existing synchronous/unsupported `tools/call` path is unchanged, and this entry
|
||||
//! never spawns an ephemeral execution future.
|
||||
|
||||
use std::sync::Arc;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use crank_core::{
|
||||
CorrelationContext, PlatformApiKeyId, TaskAcceptance, TaskAccess, TaskError, TaskId,
|
||||
TaskOwnerKind, TaskRecord, ToolExecutionMode,
|
||||
};
|
||||
use crank_registry::{PostgresRegistry, PublishedAgentTool};
|
||||
use crank_runtime::{TaskAcceptDraft, TaskOutcome, TaskService};
|
||||
use serde_json::Value;
|
||||
|
||||
use crate::access::credential_allows_security_level;
|
||||
use crate::catalog::PublishedToolCatalog;
|
||||
|
||||
/// Authenticated principal of one Task operation. The authorization scope identity is derived here
|
||||
/// from the verified credential/admin identity, never from a caller-supplied request string.
|
||||
#[derive(Clone, Debug)]
|
||||
pub enum TaskPrincipal {
|
||||
Agent {
|
||||
workspace_slug: String,
|
||||
agent_slug: String,
|
||||
credential: crank_core::VerifiedMachineCredential,
|
||||
},
|
||||
/// Administrator identity that the admin surface already authenticated. It is never a wildcard:
|
||||
/// owner, workspace and authorization scope all participate in the stored predicate.
|
||||
Admin {
|
||||
workspace_slug: String,
|
||||
agent_slug: String,
|
||||
user_id: String,
|
||||
},
|
||||
}
|
||||
|
||||
impl TaskPrincipal {
|
||||
fn workspace_slug(&self) -> &str {
|
||||
match self {
|
||||
Self::Agent { workspace_slug, .. } | Self::Admin { workspace_slug, .. } => {
|
||||
workspace_slug
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn agent_slug(&self) -> &str {
|
||||
match self {
|
||||
Self::Agent { agent_slug, .. } | Self::Admin { agent_slug, .. } => agent_slug,
|
||||
}
|
||||
}
|
||||
|
||||
fn owner(&self, tool: &PublishedAgentTool) -> (TaskOwnerKind, String) {
|
||||
match self {
|
||||
Self::Agent { .. } => (TaskOwnerKind::Agent, tool.agent_id.as_str().to_owned()),
|
||||
Self::Admin { user_id, .. } => (TaskOwnerKind::Admin, user_id.clone()),
|
||||
}
|
||||
}
|
||||
|
||||
/// Typed immutable Platform API key identity of this principal. A verified agent credential
|
||||
/// without a key ID cannot be revalidated by a worker, so it is refused instead of accepted;
|
||||
/// an administrator has no machine key and is stored as `None` (the worker fails closed).
|
||||
fn platform_api_key_id(&self) -> Result<Option<PlatformApiKeyId>, TaskApplicationError> {
|
||||
match self {
|
||||
Self::Agent { credential, .. } => credential
|
||||
.platform_api_key_id
|
||||
.clone()
|
||||
.map(Some)
|
||||
.ok_or(TaskApplicationError::Denied),
|
||||
Self::Admin { .. } => Ok(None),
|
||||
}
|
||||
}
|
||||
|
||||
/// Bounded server-derived authorization scope identity of this principal.
|
||||
fn authorization_scope(&self) -> String {
|
||||
let identity = match self {
|
||||
Self::Agent { credential, .. } => {
|
||||
let mut scopes = credential
|
||||
.scopes
|
||||
.iter()
|
||||
.map(|scope| format!("{scope:?}"))
|
||||
.collect::<Vec<_>>();
|
||||
scopes.sort();
|
||||
format!(
|
||||
"key:{}|mode:{:?}|level:{:?}|scopes:{}",
|
||||
credential
|
||||
.platform_api_key_id
|
||||
.as_ref()
|
||||
.map(|id| id.as_str().to_owned())
|
||||
.unwrap_or_else(|| "-".to_owned()),
|
||||
credential.machine_access_mode,
|
||||
credential.max_security_level,
|
||||
scopes.join(",")
|
||||
)
|
||||
}
|
||||
Self::Admin { user_id, .. } => format!("admin:{user_id}"),
|
||||
};
|
||||
identity.chars().take(160).collect()
|
||||
}
|
||||
}
|
||||
|
||||
/// Typed refusal of the application entry. `NotFound`/`Denied` never reveal whether a foreign Task
|
||||
/// exists, and no variant carries Task payload or fingerprint.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
|
||||
pub enum TaskApplicationError {
|
||||
#[error("task request was not found")]
|
||||
NotFound,
|
||||
#[error("task request is not authorized")]
|
||||
Denied,
|
||||
#[error("the published Tool policy does not accept durable background work")]
|
||||
NotBackground,
|
||||
#[error("the requested published Tool version is not available")]
|
||||
VersionUnavailable,
|
||||
#[error("this Tool requires a verified approval before acceptance")]
|
||||
ApprovalRequired,
|
||||
#[error(transparent)]
|
||||
Task(#[from] TaskError),
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct TaskApplication {
|
||||
catalog: PublishedToolCatalog,
|
||||
service: TaskService,
|
||||
}
|
||||
|
||||
impl TaskApplication {
|
||||
/// Production construction of the application entry over the process registry, the published
|
||||
/// catalog and the durable Task service.
|
||||
pub fn new(
|
||||
registry: PostgresRegistry,
|
||||
refresh_interval: Duration,
|
||||
coordination_store: Arc<dyn crank_core::CoordinationStateStore>,
|
||||
service: TaskService,
|
||||
) -> Self {
|
||||
Self {
|
||||
catalog: PublishedToolCatalog::new(registry, refresh_interval, coordination_store),
|
||||
service,
|
||||
}
|
||||
}
|
||||
|
||||
/// Runtime task service carrying encrypted executable input.
|
||||
pub fn task_service(&self) -> TaskService {
|
||||
self.service.clone()
|
||||
}
|
||||
|
||||
/// Published catalog of the same application entry, for the durable Task worker's pre-dispatch
|
||||
/// revalidation.
|
||||
pub(super) fn catalog(&self) -> PublishedToolCatalog {
|
||||
self.catalog.clone()
|
||||
}
|
||||
|
||||
/// Readiness of the durable Task store this entry depends on.
|
||||
pub async fn health(&self) -> Result<(), TaskError> {
|
||||
self.service.health().await
|
||||
}
|
||||
|
||||
/// Accepts one background request for an already authenticated principal.
|
||||
///
|
||||
/// `expected_version` is the caller's explicit Published Version pin. Without it the current
|
||||
/// publication is pinned for new work and a retry of the same scoped key returns the stored Task
|
||||
/// even after a newer publication. An explicit pin may only retry the Task accepted with that
|
||||
/// exact version: a different pin is a typed conflict, never a rebind.
|
||||
pub async fn accept_background(
|
||||
&self,
|
||||
principal: &TaskPrincipal,
|
||||
tool_name: &str,
|
||||
expected_version: Option<u32>,
|
||||
scoped_key: &str,
|
||||
input: &Value,
|
||||
correlation: &CorrelationContext,
|
||||
) -> Result<TaskAcceptance, TaskApplicationError> {
|
||||
let tool = self.resolve_authorized_tool(principal, tool_name).await?;
|
||||
let current_version = tool.operation.version;
|
||||
let Some(policy) = tool.operation.execution_config.execution_policy else {
|
||||
return Err(TaskApplicationError::NotBackground);
|
||||
};
|
||||
if policy.mode == ToolExecutionMode::Synchronous {
|
||||
return Err(TaskApplicationError::NotBackground);
|
||||
}
|
||||
if tool
|
||||
.operation
|
||||
.execution_config
|
||||
.approval_policy
|
||||
.as_ref()
|
||||
.is_some_and(|approval| approval.required)
|
||||
{
|
||||
// Without a verified, non-consuming approval reference this entry fails closed instead
|
||||
// of accepting work a worker could never safely execute.
|
||||
return Err(TaskApplicationError::ApprovalRequired);
|
||||
}
|
||||
let platform_api_key_id = principal.platform_api_key_id()?;
|
||||
let draft = |operation_version: u32| {
|
||||
let (owner_kind, owner_id) = principal.owner(&tool);
|
||||
TaskAcceptDraft {
|
||||
workspace_id: tool.workspace_id.as_str().to_owned(),
|
||||
owner_kind,
|
||||
owner_id,
|
||||
authorization_scope: principal.authorization_scope(),
|
||||
platform_api_key_id: platform_api_key_id.clone(),
|
||||
operation_id: tool.operation.id.as_str().to_owned(),
|
||||
operation_version,
|
||||
policy_mode: policy.mode,
|
||||
scoped_key: scoped_key.to_owned(),
|
||||
input: input.clone(),
|
||||
correlation: correlation.clone(),
|
||||
deadline: Instant::now() + Duration::from_millis(policy.deadline_ms.max(1)),
|
||||
retention_ms: TaskService::default_retention_ms(),
|
||||
approval_reference: None,
|
||||
}
|
||||
};
|
||||
|
||||
let Some(requested) = expected_version else {
|
||||
return Ok(self.service.accept(draft(current_version)).await?);
|
||||
};
|
||||
let draft = draft(requested);
|
||||
match self.service.lookup(&draft).await? {
|
||||
Some(record) => {
|
||||
if record.input_fingerprint != TaskService::input_fingerprint(input)? {
|
||||
return Err(TaskApplicationError::Task(TaskError::FingerprintConflict));
|
||||
}
|
||||
if record.pins.operation_version != requested {
|
||||
return Err(TaskApplicationError::VersionUnavailable);
|
||||
}
|
||||
Ok(TaskAcceptance {
|
||||
task_id: record.task_id,
|
||||
state: record.state,
|
||||
operation_version: record.pins.operation_version,
|
||||
support: record.support,
|
||||
created_at_unix_ms: record.created_at_unix_ms,
|
||||
retain_until_unix_ms: record.pins.retain_until_unix_ms,
|
||||
replayed: true,
|
||||
})
|
||||
}
|
||||
None if requested == current_version => Ok(self.service.accept(draft).await?),
|
||||
// A new Task can only be accepted against the currently published version.
|
||||
None => Err(TaskApplicationError::VersionUnavailable),
|
||||
}
|
||||
}
|
||||
|
||||
/// Owner-scoped status read of one Task of the addressed published Tool.
|
||||
pub async fn status(
|
||||
&self,
|
||||
principal: &TaskPrincipal,
|
||||
tool_name: &str,
|
||||
task_id: TaskId,
|
||||
) -> Result<TaskRecord, TaskApplicationError> {
|
||||
let access = self.task_access(principal, tool_name).await?;
|
||||
match self.service.status(&access, task_id).await {
|
||||
Ok(record) => Ok(record),
|
||||
Err(TaskError::NotFound) => Err(TaskApplicationError::NotFound),
|
||||
Err(error) => Err(TaskApplicationError::Task(error)),
|
||||
}
|
||||
}
|
||||
|
||||
/// Owner-scoped result projection of one Task of the addressed published Tool.
|
||||
pub async fn result(
|
||||
&self,
|
||||
principal: &TaskPrincipal,
|
||||
tool_name: &str,
|
||||
task_id: TaskId,
|
||||
) -> Result<TaskOutcome, TaskApplicationError> {
|
||||
let access = self.task_access(principal, tool_name).await?;
|
||||
match self.service.result(&access, task_id).await {
|
||||
Ok(outcome) => Ok(outcome),
|
||||
Err(TaskError::NotFound) => Err(TaskApplicationError::NotFound),
|
||||
Err(error) => Err(TaskApplicationError::Task(error)),
|
||||
}
|
||||
}
|
||||
|
||||
async fn task_access(
|
||||
&self,
|
||||
principal: &TaskPrincipal,
|
||||
tool_name: &str,
|
||||
) -> Result<TaskAccess, TaskApplicationError> {
|
||||
let tool = self.resolve_authorized_tool(principal, tool_name).await?;
|
||||
let (owner_kind, owner_id) = principal.owner(&tool);
|
||||
Ok(TaskAccess {
|
||||
workspace_id: tool.workspace_id.as_str().to_owned(),
|
||||
owner_kind,
|
||||
owner_id,
|
||||
authorization_scope: principal.authorization_scope(),
|
||||
})
|
||||
}
|
||||
|
||||
/// Resolves the addressed Tool of the principal's published catalog and repeats its authorization
|
||||
/// check. A foreign workspace, an unknown Tool and an insufficient security level are typed
|
||||
/// refusals without metadata.
|
||||
async fn resolve_authorized_tool(
|
||||
&self,
|
||||
principal: &TaskPrincipal,
|
||||
tool_name: &str,
|
||||
) -> Result<PublishedAgentTool, TaskApplicationError> {
|
||||
let catalog = self
|
||||
.catalog
|
||||
.get_catalog(principal.workspace_slug(), principal.agent_slug())
|
||||
.await
|
||||
.map_err(|_| TaskApplicationError::NotFound)?;
|
||||
let tool = catalog
|
||||
.tools
|
||||
.into_iter()
|
||||
.find(|tool| tool.tool_name == tool_name)
|
||||
.ok_or(TaskApplicationError::NotFound)?;
|
||||
if let TaskPrincipal::Admin { workspace_slug, .. } = principal
|
||||
&& tool.workspace_slug != *workspace_slug
|
||||
{
|
||||
return Err(TaskApplicationError::Denied);
|
||||
}
|
||||
if let TaskPrincipal::Agent { credential, .. } = principal
|
||||
&& !credential_allows_security_level(credential, tool.operation.security_level)
|
||||
{
|
||||
return Err(TaskApplicationError::Denied);
|
||||
}
|
||||
Ok(tool)
|
||||
}
|
||||
}
|
||||
@@ -550,6 +550,7 @@ pub(super) fn test_operation(base_url: &str) -> Operation<Schema, MappingSet> {
|
||||
idempotency: None,
|
||||
safety: None,
|
||||
approval_policy: None,
|
||||
execution_policy: None,
|
||||
auth_profile_ref: None,
|
||||
headers: BTreeMap::new(),
|
||||
},
|
||||
|
||||
@@ -16,6 +16,7 @@ mod tool_search;
|
||||
mod transport;
|
||||
|
||||
pub use app::{
|
||||
build_app, build_app_with_artifacts, build_app_with_background_workers,
|
||||
build_app_with_background_workers_and_limits,
|
||||
TaskApplication, TaskApplicationError, TaskPrincipal, TaskWorkerHandler, build_app,
|
||||
build_app_with_artifacts, build_app_with_artifacts_and_tasks,
|
||||
build_app_with_background_workers, build_app_with_background_workers_and_limits,
|
||||
};
|
||||
@@ -373,7 +373,9 @@ pub(crate) const CAPABILITY_DESCRIPTORS: &[CapabilityIdDescriptor] = &[
|
||||
extension: None,
|
||||
deprecated: None,
|
||||
sub_features: FeatureSet(&["listChanged"]),
|
||||
advertised: Some(("tools", &[("listChanged", false)])),
|
||||
// Story 3.5: the adapter emits `notifications/tools/list_changed` from the committed
|
||||
// published Tool bindings of the Agent snapshot, so the declaration is now true.
|
||||
advertised: Some(("tools", &[("listChanged", true)])),
|
||||
revisions: MODERN_AND_LEGACY,
|
||||
},
|
||||
CapabilityIdDescriptor {
|
||||
|
||||
@@ -39,7 +39,7 @@ fn static_registration_is_unique_and_advertises_only_the_registered_capability()
|
||||
"logging": {},
|
||||
"prompts": {"listChanged": true},
|
||||
"resources": {"listChanged": true, "subscribe": false},
|
||||
"tools": {"listChanged": false}
|
||||
"tools": {"listChanged": true}
|
||||
}),
|
||||
"the registered advertisement must be the same reviewed object in {revision}"
|
||||
);
|
||||
@@ -50,7 +50,7 @@ fn static_registration_is_unique_and_advertises_only_the_registered_capability()
|
||||
"logging": {},
|
||||
"prompts": {"listChanged": true},
|
||||
"resources": {"listChanged": true, "subscribe": false},
|
||||
"tools": {"listChanged": false}
|
||||
"tools": {"listChanged": true}
|
||||
}),
|
||||
"the production advertisement entry point must serve {revision}"
|
||||
);
|
||||
@@ -264,7 +264,7 @@ fn an_inert_test_descriptor_changes_both_projections_and_is_never_registered_in_
|
||||
"logging": {},
|
||||
"prompts": {"listChanged": true},
|
||||
"resources": {"listChanged": true, "subscribe": false},
|
||||
"tools": {"listChanged": false}
|
||||
"tools": {"listChanged": true}
|
||||
})
|
||||
);
|
||||
assert_eq!(
|
||||
@@ -275,7 +275,7 @@ fn an_inert_test_descriptor_changes_both_projections_and_is_never_registered_in_
|
||||
"logging": {},
|
||||
"prompts": {"listChanged": true},
|
||||
"resources": {"listChanged": true, "subscribe": false},
|
||||
"tools": {"listChanged": false}
|
||||
"tools": {"listChanged": true}
|
||||
})
|
||||
);
|
||||
assert_eq!(
|
||||
@@ -286,7 +286,7 @@ fn an_inert_test_descriptor_changes_both_projections_and_is_never_registered_in_
|
||||
"logging": {},
|
||||
"prompts": {"listChanged": true},
|
||||
"resources": {"listChanged": true, "subscribe": false},
|
||||
"tools": {"listChanged": false}
|
||||
"tools": {"listChanged": true}
|
||||
})
|
||||
);
|
||||
|
||||
@@ -470,7 +470,7 @@ fn a_single_era_descriptor_never_leaks_into_the_other_era_advertisement() {
|
||||
"logging": {},
|
||||
"prompts": {"listChanged": true},
|
||||
"resources": {"listChanged": true, "subscribe": false},
|
||||
"tools": {"listChanged": false}
|
||||
"tools": {"listChanged": true}
|
||||
}),
|
||||
"the other era advertisement stays the reviewed object"
|
||||
);
|
||||
@@ -761,7 +761,7 @@ fn adding_and_removing_a_method_descriptor_changes_the_dispatch_decision() {
|
||||
"logging": {},
|
||||
"prompts": {"listChanged": true},
|
||||
"resources": {"listChanged": true, "subscribe": false},
|
||||
"tools": {"listChanged": false}
|
||||
"tools": {"listChanged": true}
|
||||
})
|
||||
);
|
||||
}
|
||||
|
||||
@@ -1,13 +1,15 @@
|
||||
//! Story 3.19: Resource and Prompt list-change signals (FR-19).
|
||||
//! Story 3.19: Resource and Prompt list-change signals (FR-19); Story 3.5 adds the Tools signal of
|
||||
//! the same seam (FR-14).
|
||||
//!
|
||||
//! The positive result of the story is that a client which asked for the list-change signal of its
|
||||
//! revision learns that the *committed* Resource or Prompt catalog changed, and that the ordinary
|
||||
//! `resources/list`, `resources/read`, `resources/templates/list`, `prompts/list` and `prompts/get`
|
||||
//! stay authoritative for a client that misses the notification.
|
||||
//! revision learns that the *committed* Resource, Prompt or Tool catalog changed, and that the
|
||||
//! ordinary `resources/list`, `resources/read`, `resources/templates/list`, `prompts/list`,
|
||||
//! `prompts/get` and `tools/list` stay authoritative for a client that misses the notification.
|
||||
//!
|
||||
//! Shape of the chosen seam (ARC decision, kanban t_c12863fb): a **stream-local watcher**. One open
|
||||
//! notification stream owns one bounded periodic read of the published Agent catalog the stream is
|
||||
//! scoped to; a change of the visible Resource/Prompt binding projection produces the revision's
|
||||
//! scoped to; a change of the visible Resource/Prompt/Tool projection of that snapshot (the Resource
|
||||
//! and Prompt bindings plus the exact Tool definitions `tools/list` serves) produces the revision's
|
||||
//! list-change notification. There is no post-commit hook, no cross-process bus and no durable
|
||||
//! queue: the committed catalog is the source of truth, so a signal can never be produced before its
|
||||
//! commit, and a failed read can never roll the commit back — it only skips that tick and stays
|
||||
@@ -55,6 +57,8 @@ pub(crate) const SUBSCRIPTION_ID_KEY: &str = "io.modelcontextprotocol/subscripti
|
||||
pub(crate) const RESOURCE_LIST_CHANGED: &str = "notifications/resources/list_changed";
|
||||
/// `notifications/prompts/list_changed` (both approved revisions).
|
||||
pub(crate) const PROMPT_LIST_CHANGED: &str = "notifications/prompts/list_changed";
|
||||
/// `notifications/tools/list_changed` (both approved revisions, Story 3.5).
|
||||
pub(crate) const TOOL_LIST_CHANGED: &str = "notifications/tools/list_changed";
|
||||
/// `notifications/subscriptions/acknowledged` (modern revision only).
|
||||
pub(crate) const SUBSCRIPTIONS_ACKNOWLEDGED: &str = "notifications/subscriptions/acknowledged";
|
||||
|
||||
@@ -79,29 +83,32 @@ pub(crate) const MAX_FILTER_URI_BYTES: usize = 2_048;
|
||||
/// The one safe detail of a malformed or oversized `subscriptions/listen` filter.
|
||||
pub(crate) const INVALID_LISTEN_FILTER: &str = "invalid subscriptions/listen notification filter";
|
||||
|
||||
/// The two list-change signal types this server implements.
|
||||
/// The three list-change signal types this server implements.
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
|
||||
pub(crate) struct Signals {
|
||||
pub(crate) resources: bool,
|
||||
pub(crate) prompts: bool,
|
||||
pub(crate) tools: bool,
|
||||
}
|
||||
|
||||
impl Signals {
|
||||
/// Both types: the legacy revision defines no client opt-in, so its stream carries both.
|
||||
pub(crate) const BOTH: Self = Self {
|
||||
/// All types: the legacy revision defines no client opt-in, so its stream carries every type.
|
||||
pub(crate) const ALL: Self = Self {
|
||||
resources: true,
|
||||
prompts: true,
|
||||
tools: true,
|
||||
};
|
||||
|
||||
#[cfg_attr(not(test), allow(dead_code))] // read by the unit oracle of the projection
|
||||
pub(crate) fn any(self) -> bool {
|
||||
self.resources || self.prompts
|
||||
self.resources || self.prompts || self.tools
|
||||
}
|
||||
|
||||
fn intersect(self, other: Self) -> Self {
|
||||
Self {
|
||||
resources: self.resources && other.resources,
|
||||
prompts: self.prompts && other.prompts,
|
||||
tools: self.tools && other.tools,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -114,8 +121,6 @@ impl Signals {
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub(crate) struct ListenFilter {
|
||||
#[serde(default)]
|
||||
/// `toolsListChanged` is not implemented in this scope and is therefore never acknowledged.
|
||||
#[allow(dead_code)]
|
||||
tools_list_changed: bool,
|
||||
#[serde(default)]
|
||||
prompts_list_changed: bool,
|
||||
@@ -145,9 +150,9 @@ pub(crate) enum FilterOutcome {
|
||||
impl ListenFilter {
|
||||
/// Validate the bounded inputs and keep only the honoured types.
|
||||
///
|
||||
/// `toolsListChanged` and `resourceSubscriptions` are not implemented in the current scope, which
|
||||
/// is what the acknowledgment reports: they are simply not honoured, and the pinned schema
|
||||
/// forbids the server from sending a type it did not agree to.
|
||||
/// `resourceSubscriptions` is not implemented in the current scope, which is what the
|
||||
/// acknowledgment reports: it is simply not honoured, and the pinned schema forbids the server
|
||||
/// from sending a type it did not agree to.
|
||||
pub(crate) fn accepted(&self) -> FilterOutcome {
|
||||
if self.resource_subscriptions.len() > MAX_FILTER_URIS
|
||||
|| self
|
||||
@@ -160,6 +165,7 @@ impl ListenFilter {
|
||||
FilterOutcome::Accepted(Signals {
|
||||
resources: self.resources_list_changed,
|
||||
prompts: self.prompts_list_changed,
|
||||
tools: self.tools_list_changed,
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -173,16 +179,23 @@ fn acknowledged_filter_wire(accepted: Signals) -> Value {
|
||||
if accepted.resources {
|
||||
filter.insert("resourcesListChanged".to_owned(), Value::Bool(true));
|
||||
}
|
||||
if accepted.tools {
|
||||
filter.insert("toolsListChanged".to_owned(), Value::Bool(true));
|
||||
}
|
||||
Value::Object(filter)
|
||||
}
|
||||
|
||||
/// The exact bound Resource/Prompt projection of one published Agent catalog.
|
||||
/// The exact bound Resource/Prompt/Tool projection of one published Agent catalog.
|
||||
///
|
||||
/// The projection is derived from the same committed catalog read that already feeds
|
||||
/// `resources/list`, `resources/templates/list`, `prompts/list` and `prompts/get`: the exact Resource
|
||||
/// and Prompt bindings of the published Agent snapshot, in deterministic binding order.
|
||||
/// `catalog_revision` alone is *not* the comparison key — a commit that only changes Tools must not
|
||||
/// produce a Resource/Prompt signal — so the two binding vectors are compared on their own.
|
||||
/// `resources/list`, `resources/templates/list`, `prompts/list`, `prompts/get` and `tools/list`: the
|
||||
/// exact Resource and Prompt bindings of the published Agent snapshot, in deterministic binding
|
||||
/// order, and the exact Tool definitions that `tools/list` would serve. The Tool part is taken from
|
||||
/// [`crate::manifest::catalog_tool_definitions`] rather than from the bindings, because that is the
|
||||
/// projection the client sees: it also depends on the Tool selection policy (mode, groups, search
|
||||
/// settings), and in `Search` mode it does not depend on the bindings at all. `catalog_revision`
|
||||
/// alone is *not* the comparison key — a commit that only changes Tools must not produce a Resource
|
||||
/// or Prompt signal, and vice versa — so the three projections are compared on their own.
|
||||
///
|
||||
/// shortcut: a Resource revocation invalidates a bound publication without a new Agent snapshot, so
|
||||
/// it does not change this projection and produces no list-change signal; the revocation gate at
|
||||
@@ -192,40 +205,45 @@ fn acknowledged_filter_wire(accepted: Signals) -> Value {
|
||||
pub(crate) struct CatalogFingerprint {
|
||||
resources: Vec<(String, u32)>,
|
||||
prompts: Vec<(String, u32)>,
|
||||
/// Canonical JSON of every definition `tools/list` serves, sorted so a re-ordered read is not a
|
||||
/// false change.
|
||||
tools: Vec<String>,
|
||||
}
|
||||
|
||||
impl CatalogFingerprint {
|
||||
pub(crate) fn of(catalog: &PublishedAgentCatalog) -> Self {
|
||||
let mut resources = catalog
|
||||
.resources
|
||||
.iter()
|
||||
.map(|binding| {
|
||||
fn sorted<T: Ord>(values: impl Iterator<Item = T>) -> Vec<T> {
|
||||
let mut sorted = values.collect::<Vec<_>>();
|
||||
sorted.sort_unstable();
|
||||
sorted
|
||||
}
|
||||
Self {
|
||||
resources: sorted(catalog.resources.iter().map(|binding| {
|
||||
(
|
||||
binding.resource_id.as_str().to_owned(),
|
||||
binding.resource_version,
|
||||
)
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
let mut prompts = catalog
|
||||
.prompts
|
||||
.iter()
|
||||
.map(|binding| {
|
||||
})),
|
||||
prompts: sorted(catalog.prompts.iter().map(|binding| {
|
||||
(
|
||||
binding.prompt_id.as_str().to_owned(),
|
||||
binding.prompt_version,
|
||||
)
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
resources.sort();
|
||||
prompts.sort();
|
||||
Self { resources, prompts }
|
||||
})),
|
||||
tools: sorted(
|
||||
crate::manifest::catalog_tool_definitions(catalog)
|
||||
.into_iter()
|
||||
.map(|definition| definition.to_string()),
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
/// The list-change types whose visible binding projection differs between `previous` and `self`.
|
||||
/// The list-change types whose visible projection differs between `previous` and `self`.
|
||||
pub(crate) fn changes_since(&self, previous: &Self) -> Signals {
|
||||
Signals {
|
||||
resources: self.resources != previous.resources,
|
||||
prompts: self.prompts != previous.prompts,
|
||||
tools: self.tools != previous.tools,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -241,10 +259,11 @@ pub(crate) enum Wire {
|
||||
|
||||
impl Wire {
|
||||
fn signal_frames(&self, signals: Signals) -> Vec<String> {
|
||||
let mut frames = Vec::with_capacity(2);
|
||||
let mut frames = Vec::with_capacity(3);
|
||||
for (changed, method) in [
|
||||
(signals.resources, RESOURCE_LIST_CHANGED),
|
||||
(signals.prompts, PROMPT_LIST_CHANGED),
|
||||
(signals.tools, TOOL_LIST_CHANGED),
|
||||
] {
|
||||
if !changed {
|
||||
continue;
|
||||
|
||||
@@ -2,35 +2,59 @@
|
||||
//! wire frames of both approved revisions and the bounded legacy stream ownership.
|
||||
|
||||
use std::{
|
||||
collections::BTreeMap,
|
||||
io,
|
||||
sync::{Arc, Mutex},
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
|
||||
use crank_core::ToolSelectionPolicy;
|
||||
use crank_core::ids::{PromptId, ResourceId};
|
||||
use crank_core::{
|
||||
ExecutionConfig, HttpMethod, Operation, OperationId, OperationSecurityLevel, OperationStatus,
|
||||
Protocol, RestTarget, Target, ToolAccessMode, ToolDescription, ToolGroup, ToolSearchSettings,
|
||||
ToolSelectionPolicy, WorkspaceId,
|
||||
};
|
||||
use crank_mapping::MappingSet;
|
||||
use crank_registry::PublishedAgentCatalog;
|
||||
use crank_registry::model::{AgentPromptBinding, AgentResourceBinding};
|
||||
use crank_registry::model::{AgentPromptBinding, AgentResourceBinding, PublishedAgentTool};
|
||||
use crank_schema::{Schema, SchemaKind};
|
||||
use serde_json::{Value, json};
|
||||
use time::OffsetDateTime;
|
||||
use tokio::sync::mpsc;
|
||||
|
||||
use super::{
|
||||
CatalogFingerprint, FilterOutcome, INVALID_LISTEN_FILTER, ListenFilter, MAX_FILTER_URIS,
|
||||
MAX_SUBSCRIPTION_ID_BYTES, PROMPT_LIST_CHANGED, RESOURCE_LIST_CHANGED, ReadError, Reader,
|
||||
SIGNAL_QUEUE_CAPACITY, SUBSCRIPTION_ID_KEY, SUBSCRIPTIONS_ACKNOWLEDGED, Signals,
|
||||
StreamRegistry, Watch, Wire, acknowledged_frame, run, subscription_id,
|
||||
StreamRegistry, TOOL_LIST_CHANGED, Watch, Wire, acknowledged_frame, run, subscription_id,
|
||||
};
|
||||
|
||||
fn catalog(
|
||||
resources: &[(&str, u32)],
|
||||
prompts: &[(&str, u32)],
|
||||
catalog_revision: &str,
|
||||
) -> PublishedAgentCatalog {
|
||||
catalog_with(
|
||||
ToolSelectionPolicy::default(),
|
||||
Vec::new(),
|
||||
resources,
|
||||
prompts,
|
||||
catalog_revision,
|
||||
)
|
||||
}
|
||||
|
||||
fn catalog_with(
|
||||
tool_selection_policy: ToolSelectionPolicy,
|
||||
tools: Vec<PublishedAgentTool>,
|
||||
resources: &[(&str, u32)],
|
||||
prompts: &[(&str, u32)],
|
||||
catalog_revision: &str,
|
||||
) -> PublishedAgentCatalog {
|
||||
PublishedAgentCatalog {
|
||||
agent_version: 1,
|
||||
catalog_revision: catalog_revision.to_owned(),
|
||||
tool_selection_policy: ToolSelectionPolicy::default(),
|
||||
tools: Vec::new(),
|
||||
tool_selection_policy,
|
||||
tools,
|
||||
resources: resources
|
||||
.iter()
|
||||
.map(|(id, version)| AgentResourceBinding {
|
||||
@@ -48,6 +72,94 @@ fn catalog(
|
||||
}
|
||||
}
|
||||
|
||||
fn search_policy(tool_names: &[&str]) -> ToolSelectionPolicy {
|
||||
ToolSelectionPolicy {
|
||||
mode: ToolAccessMode::Search,
|
||||
groups: vec![ToolGroup {
|
||||
id: "crm".to_owned(),
|
||||
name: "CRM".to_owned(),
|
||||
description: "CRM operations".to_owned(),
|
||||
tool_names: tool_names.iter().map(|name| (*name).to_owned()).collect(),
|
||||
}],
|
||||
search: ToolSearchSettings::default(),
|
||||
}
|
||||
}
|
||||
|
||||
fn empty_object_schema() -> Schema {
|
||||
Schema {
|
||||
kind: SchemaKind::Object,
|
||||
format: None,
|
||||
description: None,
|
||||
required: false,
|
||||
nullable: false,
|
||||
default_value: None,
|
||||
fields: BTreeMap::new(),
|
||||
items: None,
|
||||
enum_values: Vec::new(),
|
||||
variants: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/// One published Tool binding whose served definition is exactly `title`/`description`.
|
||||
fn published_tool(name: &str, title: &str, description: &str, version: u32) -> PublishedAgentTool {
|
||||
PublishedAgentTool {
|
||||
workspace_id: WorkspaceId::new("ws_test"),
|
||||
workspace_slug: "ws-test".to_owned(),
|
||||
agent_id: "agent_test".into(),
|
||||
agent_slug: "agent".to_owned(),
|
||||
operation: Operation {
|
||||
id: OperationId::new(format!("op_{name}")),
|
||||
name: name.to_owned(),
|
||||
display_name: title.to_owned(),
|
||||
category: "test".to_owned(),
|
||||
protocol: Protocol::Rest,
|
||||
security_level: OperationSecurityLevel::Standard,
|
||||
status: OperationStatus::Published,
|
||||
version,
|
||||
target: Target::Rest(RestTarget {
|
||||
base_url: "https://example.test".to_owned(),
|
||||
method: HttpMethod::Get,
|
||||
path_template: "/leads".to_owned(),
|
||||
static_headers: BTreeMap::new(),
|
||||
request_contract: None,
|
||||
response_contract: Vec::new(),
|
||||
multipart_field_mime_types: BTreeMap::new(),
|
||||
}),
|
||||
input_schema: empty_object_schema(),
|
||||
output_schema: empty_object_schema(),
|
||||
input_mapping: MappingSet { rules: Vec::new() },
|
||||
output_mapping: MappingSet { rules: Vec::new() },
|
||||
execution_config: ExecutionConfig {
|
||||
timeout_ms: 10_000,
|
||||
retry_policy: None,
|
||||
response_cache: None,
|
||||
idempotency: None,
|
||||
safety: None,
|
||||
approval_policy: None,
|
||||
execution_policy: None,
|
||||
auth_profile_ref: None,
|
||||
headers: BTreeMap::new(),
|
||||
},
|
||||
tool_description: ToolDescription {
|
||||
title: title.to_owned(),
|
||||
description: description.to_owned(),
|
||||
tags: Vec::new(),
|
||||
examples: Vec::new(),
|
||||
},
|
||||
samples: None,
|
||||
generated_draft: None,
|
||||
config_export: None,
|
||||
wizard_state: None,
|
||||
created_at: OffsetDateTime::UNIX_EPOCH,
|
||||
updated_at: OffsetDateTime::UNIX_EPOCH,
|
||||
published_at: None,
|
||||
},
|
||||
tool_name: name.to_owned(),
|
||||
tool_title: title.to_owned(),
|
||||
tool_description: description.to_owned(),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_committed_resource_binding_is_a_resource_change_only() {
|
||||
let before = CatalogFingerprint::of(&catalog(&[("res_a", 1)], &[("prm_a", 1)], "rev-1"));
|
||||
@@ -61,7 +173,8 @@ fn a_committed_resource_binding_is_a_resource_change_only() {
|
||||
after.changes_since(&before),
|
||||
Signals {
|
||||
resources: true,
|
||||
prompts: false
|
||||
prompts: false,
|
||||
tools: false
|
||||
}
|
||||
);
|
||||
assert!(!before.changes_since(&after).prompts);
|
||||
@@ -69,7 +182,8 @@ fn a_committed_resource_binding_is_a_resource_change_only() {
|
||||
before.changes_since(&after),
|
||||
Signals {
|
||||
resources: true,
|
||||
prompts: false
|
||||
prompts: false,
|
||||
tools: false
|
||||
}
|
||||
);
|
||||
}
|
||||
@@ -83,7 +197,8 @@ fn a_committed_prompt_binding_is_a_prompt_change_only() {
|
||||
after.changes_since(&before),
|
||||
Signals {
|
||||
resources: false,
|
||||
prompts: true
|
||||
prompts: true,
|
||||
tools: false
|
||||
}
|
||||
);
|
||||
}
|
||||
@@ -97,15 +212,219 @@ fn a_pinned_version_bump_is_a_change_even_when_the_binding_names_are_stable() {
|
||||
after.changes_since(&before),
|
||||
Signals {
|
||||
resources: true,
|
||||
prompts: false
|
||||
prompts: false,
|
||||
tools: false
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_tool_only_catalog_commit_is_silent() {
|
||||
// `catalog_revision` moved, but the visible Resource/Prompt projection did not: a Tool-only
|
||||
// commit must not produce a Resource or Prompt list-change signal.
|
||||
fn a_committed_tool_definition_change_is_a_tool_change_only() {
|
||||
let lead = || published_tool("crm_create_lead", "Create Lead", "Creates a lead", 1);
|
||||
let before = CatalogFingerprint::of(&catalog_with(
|
||||
ToolSelectionPolicy::default(),
|
||||
vec![lead()],
|
||||
&[("res_a", 1)],
|
||||
&[("prm_a", 1)],
|
||||
"rev-1",
|
||||
));
|
||||
let added = CatalogFingerprint::of(&catalog_with(
|
||||
ToolSelectionPolicy::default(),
|
||||
vec![
|
||||
lead(),
|
||||
published_tool(
|
||||
"crm_create_second",
|
||||
"Create Second",
|
||||
"Creates a second lead",
|
||||
1,
|
||||
),
|
||||
],
|
||||
&[("res_a", 1)],
|
||||
&[("prm_a", 1)],
|
||||
"rev-2",
|
||||
));
|
||||
let retitled = CatalogFingerprint::of(&catalog_with(
|
||||
ToolSelectionPolicy::default(),
|
||||
vec![published_tool(
|
||||
"crm_create_lead",
|
||||
"Create a lead",
|
||||
"Creates a lead",
|
||||
1,
|
||||
)],
|
||||
&[("res_a", 1)],
|
||||
&[("prm_a", 1)],
|
||||
"rev-2",
|
||||
));
|
||||
|
||||
let tools_only = Signals {
|
||||
resources: false,
|
||||
prompts: false,
|
||||
tools: true,
|
||||
};
|
||||
assert_eq!(added.changes_since(&before), tools_only);
|
||||
assert_eq!(
|
||||
retitled.changes_since(&before),
|
||||
tools_only,
|
||||
"a retitled binding changes the visible Tool projection without a new Operation version"
|
||||
);
|
||||
// The reverse direction is a Tool change as well: a removed binding is a real change.
|
||||
assert!(before.changes_since(&added).tools);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_republished_operation_version_with_an_identical_definition_is_silent() {
|
||||
// `tools/list` serves the definition, not the Operation version: a version bump that leaves the
|
||||
// served definition unchanged is not a client-visible Tool catalog change.
|
||||
let before = CatalogFingerprint::of(&catalog_with(
|
||||
ToolSelectionPolicy::default(),
|
||||
vec![published_tool(
|
||||
"crm_create_lead",
|
||||
"Create Lead",
|
||||
"Creates a lead",
|
||||
1,
|
||||
)],
|
||||
&[("res_a", 1)],
|
||||
&[("prm_a", 1)],
|
||||
"rev-1",
|
||||
));
|
||||
let after = CatalogFingerprint::of(&catalog_with(
|
||||
ToolSelectionPolicy::default(),
|
||||
vec![published_tool(
|
||||
"crm_create_lead",
|
||||
"Create Lead",
|
||||
"Creates a lead",
|
||||
2,
|
||||
)],
|
||||
&[("res_a", 1)],
|
||||
&[("prm_a", 1)],
|
||||
"rev-2",
|
||||
));
|
||||
|
||||
assert!(!after.changes_since(&before).any());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_policy_only_commit_that_changes_tools_list_is_a_tool_change_only() {
|
||||
// The Tool selection policy is part of the served `tools/list` projection: switching the same
|
||||
// bindings from direct to search mode replaces the served tools with `search_tools`/`call_tool`.
|
||||
let tool = published_tool("crm_create_lead", "Create Lead", "Creates a lead", 1);
|
||||
let direct = CatalogFingerprint::of(&catalog_with(
|
||||
ToolSelectionPolicy::default(),
|
||||
vec![tool.clone()],
|
||||
&[("res_a", 1)],
|
||||
&[("prm_a", 1)],
|
||||
"rev-1",
|
||||
));
|
||||
let search = CatalogFingerprint::of(&catalog_with(
|
||||
search_policy(&["crm_create_lead"]),
|
||||
vec![tool],
|
||||
&[("res_a", 1)],
|
||||
&[("prm_a", 1)],
|
||||
"rev-2",
|
||||
));
|
||||
|
||||
let tools_only = Signals {
|
||||
resources: false,
|
||||
prompts: false,
|
||||
tools: true,
|
||||
};
|
||||
assert_eq!(search.changes_since(&direct), tools_only);
|
||||
assert_eq!(direct.changes_since(&search), tools_only);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_policy_field_invisible_to_tools_list_is_silent() {
|
||||
// `search.max_results` is only served inside the search-mode definitions: in direct mode it
|
||||
// changes nothing the client receives.
|
||||
let tool = || published_tool("crm_create_lead", "Create Lead", "Creates a lead", 1);
|
||||
let before = CatalogFingerprint::of(&catalog_with(
|
||||
ToolSelectionPolicy::default(),
|
||||
vec![tool()],
|
||||
&[],
|
||||
&[],
|
||||
"rev-1",
|
||||
));
|
||||
let after = CatalogFingerprint::of(&catalog_with(
|
||||
ToolSelectionPolicy {
|
||||
search: ToolSearchSettings { max_results: 5 },
|
||||
..ToolSelectionPolicy::default()
|
||||
},
|
||||
vec![tool()],
|
||||
&[],
|
||||
&[],
|
||||
"rev-2",
|
||||
));
|
||||
|
||||
assert!(!after.changes_since(&before).any());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_search_mode_binding_change_is_silent_when_tools_list_is_unchanged() {
|
||||
// In search mode the served list is `search_tools`/`call_tool`; the bindings behind it are not
|
||||
// part of `tools/list`, so a binding-only commit must not claim a visible Tool change.
|
||||
let policy = search_policy(&["crm_create_lead"]);
|
||||
let before = CatalogFingerprint::of(&catalog_with(
|
||||
policy.clone(),
|
||||
vec![published_tool(
|
||||
"crm_create_lead",
|
||||
"Create Lead",
|
||||
"Creates a lead",
|
||||
1,
|
||||
)],
|
||||
&[],
|
||||
&[],
|
||||
"rev-1",
|
||||
));
|
||||
let after = CatalogFingerprint::of(&catalog_with(
|
||||
policy,
|
||||
vec![
|
||||
published_tool("crm_create_lead", "Create Lead", "Creates a lead", 1),
|
||||
published_tool(
|
||||
"crm_create_second",
|
||||
"Create Second",
|
||||
"Creates a second lead",
|
||||
1,
|
||||
),
|
||||
],
|
||||
&[],
|
||||
&[],
|
||||
"rev-2",
|
||||
));
|
||||
|
||||
assert!(!after.changes_since(&before).any());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_resource_or_prompt_change_is_not_a_tool_change() {
|
||||
let tool = || published_tool("crm_create_lead", "Create Lead", "Creates a lead", 1);
|
||||
let before = CatalogFingerprint::of(&catalog_with(
|
||||
ToolSelectionPolicy::default(),
|
||||
vec![tool()],
|
||||
&[("res_a", 1)],
|
||||
&[("prm_a", 1)],
|
||||
"rev-1",
|
||||
));
|
||||
let changed = CatalogFingerprint::of(&catalog_with(
|
||||
ToolSelectionPolicy::default(),
|
||||
vec![tool()],
|
||||
&[("res_a", 2)],
|
||||
&[("prm_a", 1), ("prm_b", 1)],
|
||||
"rev-1",
|
||||
));
|
||||
|
||||
assert_eq!(
|
||||
changed.changes_since(&before),
|
||||
Signals {
|
||||
resources: true,
|
||||
prompts: true,
|
||||
tools: false
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_catalog_revision_bump_without_a_visible_change_is_silent() {
|
||||
// `catalog_revision` moved, but no visible Resource/Prompt/Tool projection did: no signal.
|
||||
let before = CatalogFingerprint::of(&catalog(&[("res_a", 1)], &[("prm_a", 1)], "rev-1"));
|
||||
let after = CatalogFingerprint::of(&catalog(&[("res_a", 1)], &[("prm_a", 1)], "rev-2"));
|
||||
|
||||
@@ -130,13 +449,14 @@ fn the_projection_is_order_independent_and_has_no_duplicate_growth() {
|
||||
|
||||
#[test]
|
||||
fn the_legacy_frames_carry_a_closed_method_name_and_no_parameters() {
|
||||
let frames = Wire::Legacy.signal_frames(Signals::BOTH);
|
||||
let frames = Wire::Legacy.signal_frames(Signals::ALL);
|
||||
|
||||
assert_eq!(
|
||||
frames,
|
||||
vec![
|
||||
json!({"jsonrpc": "2.0", "method": RESOURCE_LIST_CHANGED}).to_string(),
|
||||
json!({"jsonrpc": "2.0", "method": PROMPT_LIST_CHANGED}).to_string(),
|
||||
json!({"jsonrpc": "2.0", "method": TOOL_LIST_CHANGED}).to_string(),
|
||||
]
|
||||
);
|
||||
// No URI, name or payload of a changed object is part of a list-change notification.
|
||||
@@ -146,7 +466,7 @@ fn the_legacy_frames_carry_a_closed_method_name_and_no_parameters() {
|
||||
#[test]
|
||||
fn the_modern_frames_carry_the_subscription_id_of_their_listen_request() {
|
||||
let id = json!(41);
|
||||
let frames = Wire::Modern(id.clone()).signal_frames(Signals::BOTH);
|
||||
let frames = Wire::Modern(id.clone()).signal_frames(Signals::ALL);
|
||||
|
||||
assert_eq!(
|
||||
frames,
|
||||
@@ -163,6 +483,12 @@ fn the_modern_frames_carry_the_subscription_id_of_their_listen_request() {
|
||||
"params": { "_meta": { SUBSCRIPTION_ID_KEY: 41 } }
|
||||
})
|
||||
.to_string(),
|
||||
json!({
|
||||
"jsonrpc": "2.0",
|
||||
"method": TOOL_LIST_CHANGED,
|
||||
"params": { "_meta": { SUBSCRIPTION_ID_KEY: 41 } }
|
||||
})
|
||||
.to_string(),
|
||||
]
|
||||
);
|
||||
assert_eq!(
|
||||
@@ -176,6 +502,7 @@ fn only_the_requested_and_honoured_types_are_encoded() {
|
||||
let frames = Wire::Modern(json!(1)).signal_frames(Signals {
|
||||
resources: false,
|
||||
prompts: true,
|
||||
tools: false,
|
||||
});
|
||||
|
||||
assert_eq!(frames.len(), 1);
|
||||
@@ -189,6 +516,7 @@ fn the_acknowledgment_reports_exactly_the_honoured_subset() {
|
||||
Signals {
|
||||
resources: true,
|
||||
prompts: false,
|
||||
tools: true,
|
||||
},
|
||||
))
|
||||
.unwrap();
|
||||
@@ -197,7 +525,7 @@ fn the_acknowledgment_reports_exactly_the_honoured_subset() {
|
||||
assert_eq!(frame["params"]["_meta"][SUBSCRIPTION_ID_KEY], json!(7));
|
||||
assert_eq!(
|
||||
frame["params"]["notifications"],
|
||||
json!({ "resourcesListChanged": true })
|
||||
json!({ "resourcesListChanged": true, "toolsListChanged": true })
|
||||
);
|
||||
}
|
||||
|
||||
@@ -224,8 +552,10 @@ fn the_filter_keeps_only_the_implemented_list_change_types() {
|
||||
signals,
|
||||
Signals {
|
||||
resources: false,
|
||||
prompts: true
|
||||
}
|
||||
prompts: true,
|
||||
tools: true
|
||||
},
|
||||
"the honoured set is the requested list-change subset: {signals:?}"
|
||||
),
|
||||
FilterOutcome::Invalid(detail) => panic!("a bounded filter must be accepted: {detail}"),
|
||||
}
|
||||
@@ -372,7 +702,7 @@ async fn a_failed_catalog_read_is_observable_and_loses_no_committed_change() {
|
||||
Watch {
|
||||
workspace_slug: "workspace-canary".to_owned(),
|
||||
agent_slug: "agent-canary".to_owned(),
|
||||
signals: Signals::BOTH,
|
||||
signals: Signals::ALL,
|
||||
wire: Wire::Legacy,
|
||||
legacy_stream: None,
|
||||
deadline: Some(Instant::now() + Duration::from_millis(2_100)),
|
||||
|
||||
@@ -284,6 +284,7 @@ fn operation() -> RegistryOperation {
|
||||
idempotency: None,
|
||||
safety: None,
|
||||
approval_policy: None,
|
||||
execution_policy: None,
|
||||
auth_profile_ref: None,
|
||||
headers: BTreeMap::new(),
|
||||
},
|
||||
|
||||
@@ -0,0 +1,531 @@
|
||||
//! Typed execution-admission seam (Story 4.1, FR-21/FR-24).
|
||||
//!
|
||||
//! Admission is the single gate in front of every real Tool execution: it decides whether the
|
||||
//! caller receives a scoped permit or a durable enqueue decision, and it owns the deployment-wide
|
||||
//! global/per-Agent/per-Tool capacity and the bounded waiting queue. The authoritative state lives
|
||||
//! in PostgreSQL (`crank-registry`), so several processes share one budget.
|
||||
//!
|
||||
//! Deliberately absent from this contract: credentials, connection or protocol revision (they must
|
||||
//! never widen a quota), request bodies and prepared headers (payload ownership is Story 4.2).
|
||||
|
||||
use async_trait::async_trait;
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::{NoTasksFallback, ToolExecutionMode};
|
||||
|
||||
pub const ADMISSION_FINGERPRINT_MAX_BYTES: usize = 128;
|
||||
pub const ADMISSION_OWNER_TOKEN_MAX_BYTES: usize = 64;
|
||||
pub const MAX_RETRY_AFTER_MS: u64 = 60_000;
|
||||
/// Bounded retry guidance for an admission refusal (capacity or queue wait exhausted). One value for
|
||||
/// the store and every runtime so the client contract stays stable.
|
||||
pub const ADMISSION_OVERLOAD_RETRY_AFTER_MS: u64 = 250;
|
||||
|
||||
/// Current wall clock in unix milliseconds (absolute deadlines are persisted as unix ms).
|
||||
pub fn current_unix_ms() -> i64 {
|
||||
i64::try_from(
|
||||
std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.map(|elapsed| elapsed.as_millis())
|
||||
.unwrap_or_default(),
|
||||
)
|
||||
.unwrap_or(i64::MAX)
|
||||
}
|
||||
|
||||
/// Bucket used for an execution that has no Agent (admin draft/test-run): an explicit admin origin
|
||||
/// bucket that is still bounded by the global limit.
|
||||
pub const ADMIN_ORIGIN_KEY: &str = "admin";
|
||||
|
||||
/// Exact execution identity pinned at admission time.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
pub struct AdmissionScope {
|
||||
pub workspace_id: String,
|
||||
/// Agent id, or [`ADMIN_ORIGIN_KEY`] for an Agent-less administrative execution.
|
||||
pub agent_key: String,
|
||||
pub operation_id: String,
|
||||
/// Quota keys exclude the version; the version is pinned for execution semantics only.
|
||||
pub operation_version: u32,
|
||||
}
|
||||
|
||||
impl AdmissionScope {
|
||||
/// Quota key of the Agent bucket: `(workspace, agent)`.
|
||||
pub fn agent_bucket(&self) -> String {
|
||||
format!("{}:{}", self.workspace_id, self.agent_key)
|
||||
}
|
||||
|
||||
/// Quota key of the Tool bucket: `(workspace, operation)` without version.
|
||||
pub fn tool_bucket(&self) -> String {
|
||||
format!("{}:{}", self.workspace_id, self.operation_id)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
pub enum AdmissionMode {
|
||||
/// The caller waits for a scoped permit and dispatches inside it.
|
||||
Synchronous,
|
||||
/// The store commits a durable enqueue decision and reserves queue capacity.
|
||||
Background,
|
||||
}
|
||||
|
||||
impl AdmissionMode {
|
||||
pub const fn as_str(self) -> &'static str {
|
||||
match self {
|
||||
Self::Synchronous => "synchronous",
|
||||
Self::Background => "background",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Non-consuming approval evidence gathered by the runtime before admission.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum ApprovalEvidence {
|
||||
/// The operation does not require confirmation.
|
||||
NotRequired,
|
||||
/// A verified approval exists for this exact scope and input.
|
||||
Granted,
|
||||
/// Confirmation is required and no verified approval exists yet.
|
||||
NotGranted,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct AdmissionRequest {
|
||||
pub scope: AdmissionScope,
|
||||
pub mode: AdmissionMode,
|
||||
/// Published policy mode that produced this request.
|
||||
pub policy_mode: ToolExecutionMode,
|
||||
pub no_tasks_fallback: NoTasksFallback,
|
||||
pub approval: ApprovalEvidence,
|
||||
/// Bounded request identity used only to correlate one admission entry.
|
||||
pub fingerprint: String,
|
||||
/// Absolute deadline (unix milliseconds), already including queue waiting time.
|
||||
pub expires_at_unix_ms: i64,
|
||||
}
|
||||
|
||||
impl AdmissionRequest {
|
||||
pub fn validate(&self) -> Result<(), AdmissionStoreError> {
|
||||
if self.fingerprint.is_empty()
|
||||
|| self.fingerprint.len() > ADMISSION_FINGERPRINT_MAX_BYTES
|
||||
|| self
|
||||
.fingerprint
|
||||
.bytes()
|
||||
.any(|byte| byte.is_ascii_control() || byte == b' ')
|
||||
{
|
||||
return Err(AdmissionStoreError::invalid(
|
||||
"admission fingerprint is outside its allowed bounds",
|
||||
));
|
||||
}
|
||||
if self.scope.workspace_id.is_empty() || self.scope.workspace_id.len() > 160 {
|
||||
return Err(AdmissionStoreError::invalid(
|
||||
"admission workspace is invalid",
|
||||
));
|
||||
}
|
||||
if self.scope.agent_key.is_empty() || self.scope.agent_key.len() > 160 {
|
||||
return Err(AdmissionStoreError::invalid("admission agent is invalid"));
|
||||
}
|
||||
if self.scope.operation_id.is_empty() || self.scope.operation_id.len() > 160 {
|
||||
return Err(AdmissionStoreError::invalid(
|
||||
"admission operation is invalid",
|
||||
));
|
||||
}
|
||||
if self.scope.operation_version == 0 {
|
||||
return Err(AdmissionStoreError::invalid(
|
||||
"admission operation version must be positive",
|
||||
));
|
||||
}
|
||||
if self.expires_at_unix_ms <= 0 {
|
||||
return Err(AdmissionStoreError::invalid(
|
||||
"admission deadline is invalid",
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// Scoped permit. Held for the whole local execution future (including retries) and released
|
||||
/// explicitly; a dropped permit is cleaned up by a bounded owner-token CAS, never reused by TTL.
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct AdmissionPermit {
|
||||
pub ticket_id: u64,
|
||||
pub owner_token: String,
|
||||
pub scope: AdmissionScope,
|
||||
pub mode: AdmissionMode,
|
||||
pub policy_mode: ToolExecutionMode,
|
||||
}
|
||||
|
||||
/// Durable enqueue decision: a reserved queue slot with exact Published Version semantics.
|
||||
/// It is not a public Task id and it never authorises a worker dispatch (Story 4.2).
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct AdmissionDecision {
|
||||
pub ticket_id: u64,
|
||||
pub scope: AdmissionScope,
|
||||
pub expires_at_unix_ms: i64,
|
||||
pub policy_mode: ToolExecutionMode,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub enum AdmissionOutcome {
|
||||
Permitted(AdmissionPermit),
|
||||
Enqueued(AdmissionDecision),
|
||||
/// Capacity or queue bounds were exhausted before any unbounded allocation.
|
||||
Overloaded {
|
||||
retry_after_ms: u64,
|
||||
},
|
||||
/// The queue wait reached the absolute deadline; nothing was dispatched.
|
||||
DeadlineElapsed,
|
||||
/// Confirmation is mandatory for this operation and no verified approval exists.
|
||||
ApprovalRequired,
|
||||
/// The published policy does not advertise durable Tasks and refuses the fallback.
|
||||
Unsupported,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq)]
|
||||
pub struct AdmissionQueueSnapshot {
|
||||
pub waiting: u64,
|
||||
pub executing: u64,
|
||||
/// Age of the oldest waiting request in the authoritative queue, in milliseconds.
|
||||
pub oldest_waiting_ms: Option<u64>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
|
||||
pub enum AdmissionStoreError {
|
||||
/// The mandatory safety/capacity store cannot confirm state; every dependent path fails closed.
|
||||
#[error("execution admission store is unavailable: {message}")]
|
||||
Unavailable { message: String },
|
||||
/// The store rejected a malformed admission request.
|
||||
#[error("execution admission request is invalid: {message}")]
|
||||
Invalid { message: String },
|
||||
}
|
||||
|
||||
impl AdmissionStoreError {
|
||||
pub fn unavailable(message: impl Into<String>) -> Self {
|
||||
Self::Unavailable {
|
||||
message: message.into(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn invalid(message: impl Into<String>) -> Self {
|
||||
Self::Invalid {
|
||||
message: message.into(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
pub trait ExecutionAdmission: Send + Sync {
|
||||
/// Proves the mandatory admission state is usable (schema and operations reachable).
|
||||
async fn health(&self) -> Result<(), AdmissionStoreError>;
|
||||
|
||||
/// Waits (bounded by `expires_at_unix_ms`) for a scoped permit, or commits a durable enqueue
|
||||
/// decision for a background request, or returns a typed refusal.
|
||||
async fn admit(
|
||||
&self,
|
||||
request: AdmissionRequest,
|
||||
) -> Result<AdmissionOutcome, AdmissionStoreError>;
|
||||
|
||||
/// Releases the caller's own permit. Idempotent: a repeated release returns `false`.
|
||||
async fn release(&self, permit: &AdmissionPermit) -> Result<bool, AdmissionStoreError>;
|
||||
|
||||
/// Removes the caller's own waiting ticket. Idempotent and never touches a foreign ticket.
|
||||
async fn cancel(&self, ticket_id: u64, owner_token: &str) -> Result<bool, AdmissionStoreError>;
|
||||
|
||||
/// Bounded authoritative queue readings for low-cardinality metrics.
|
||||
async fn snapshot(&self) -> Result<AdmissionQueueSnapshot, AdmissionStoreError>;
|
||||
}
|
||||
|
||||
/// One waiting entry as seen by the fairness scheduler.
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct AdmissionQueueEntry {
|
||||
pub ticket_id: u64,
|
||||
/// Authoritative insertion order inside `(Agent, Tool)`; never rewritten.
|
||||
pub sequence: u64,
|
||||
pub agent_key: String,
|
||||
pub operation_id: String,
|
||||
}
|
||||
|
||||
/// Weighted round-robin state persisted with the authoritative queue.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq)]
|
||||
pub struct AdmissionCursor {
|
||||
pub agent: Option<String>,
|
||||
pub agent_credit: u32,
|
||||
pub tool: Option<String>,
|
||||
pub tool_credit: u32,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub struct AdmissionSchedulerConfig {
|
||||
pub agent_weight: u32,
|
||||
pub tool_weight: u32,
|
||||
}
|
||||
|
||||
impl Default for AdmissionSchedulerConfig {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
agent_weight: 1,
|
||||
tool_weight: 1,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl AdmissionSchedulerConfig {
|
||||
pub fn validate(&self) -> Result<(), AdmissionStoreError> {
|
||||
if !(1..=64).contains(&self.agent_weight) || !(1..=64).contains(&self.tool_weight) {
|
||||
return Err(AdmissionStoreError::invalid(
|
||||
"admission weights must be between 1 and 64",
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// Result of one fair-selection step: the queue index to grant and the cursor to persist when the
|
||||
/// grant actually happens. The cursor is not mutated on a blocked head, so a blocked head keeps its
|
||||
/// turn instead of being skipped by newer arrivals.
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct AdmissionSelection {
|
||||
pub index: usize,
|
||||
pub cursor: AdmissionCursor,
|
||||
}
|
||||
|
||||
/// Hierarchical weighted round-robin: Agents first, then the Tools of the chosen Agent, FIFO inside
|
||||
/// `(Agent, Tool)`. A new waiter never resets the cursor and never inherits idle credit.
|
||||
pub fn select_next_grant(
|
||||
queue: &[AdmissionQueueEntry],
|
||||
cursor: &AdmissionCursor,
|
||||
config: AdmissionSchedulerConfig,
|
||||
) -> Option<AdmissionSelection> {
|
||||
if queue.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let agent_weight = config.agent_weight.max(1);
|
||||
let tool_weight = config.tool_weight.max(1);
|
||||
let mut agents: Vec<&str> = queue.iter().map(|entry| entry.agent_key.as_str()).collect();
|
||||
agents.sort_unstable();
|
||||
agents.dedup();
|
||||
|
||||
let mut next = cursor.clone();
|
||||
let agent = match cursor.agent.as_deref() {
|
||||
Some(current) if cursor.agent_credit > 0 && agents.contains(¤t) => current.to_owned(),
|
||||
_ => {
|
||||
let chosen = match cursor.agent.as_deref() {
|
||||
None => agents[0].to_owned(),
|
||||
Some(current) => agents
|
||||
.iter()
|
||||
.copied()
|
||||
.find(|candidate| *candidate > current)
|
||||
.unwrap_or(agents[0])
|
||||
.to_owned(),
|
||||
};
|
||||
if cursor.agent.as_deref() != Some(chosen.as_str()) {
|
||||
next.tool = None;
|
||||
next.tool_credit = 0;
|
||||
}
|
||||
next.agent = Some(chosen.clone());
|
||||
next.agent_credit = agent_weight;
|
||||
chosen
|
||||
}
|
||||
};
|
||||
|
||||
let mut tools: Vec<&str> = queue
|
||||
.iter()
|
||||
.filter(|entry| entry.agent_key == agent)
|
||||
.map(|entry| entry.operation_id.as_str())
|
||||
.collect();
|
||||
tools.sort_unstable();
|
||||
tools.dedup();
|
||||
|
||||
let tool = match cursor.tool.as_deref() {
|
||||
Some(current) if cursor.tool_credit > 0 && tools.contains(¤t) => current.to_owned(),
|
||||
_ => {
|
||||
let chosen = match cursor.tool.as_deref() {
|
||||
None => tools[0].to_owned(),
|
||||
Some(current) => tools
|
||||
.iter()
|
||||
.copied()
|
||||
.find(|candidate| *candidate > current)
|
||||
.unwrap_or(tools[0])
|
||||
.to_owned(),
|
||||
};
|
||||
next.tool = Some(chosen.clone());
|
||||
next.tool_credit = tool_weight;
|
||||
chosen
|
||||
}
|
||||
};
|
||||
|
||||
let index = queue
|
||||
.iter()
|
||||
.position(|entry| entry.agent_key == agent && entry.operation_id == tool)?;
|
||||
next.agent_credit = next.agent_credit.saturating_sub(1);
|
||||
next.tool_credit = next.tool_credit.saturating_sub(1);
|
||||
Some(AdmissionSelection {
|
||||
index,
|
||||
cursor: next,
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{
|
||||
ADMIN_ORIGIN_KEY, AdmissionCursor, AdmissionMode, AdmissionRequest,
|
||||
AdmissionSchedulerConfig, AdmissionScope, AdmissionStoreError, ApprovalEvidence,
|
||||
select_next_grant,
|
||||
};
|
||||
use crate::{NoTasksFallback, ToolExecutionMode};
|
||||
|
||||
fn entry(ticket_id: u64, agent: &str, tool: &str) -> super::AdmissionQueueEntry {
|
||||
super::AdmissionQueueEntry {
|
||||
ticket_id,
|
||||
sequence: ticket_id,
|
||||
agent_key: agent.to_owned(),
|
||||
operation_id: tool.to_owned(),
|
||||
}
|
||||
}
|
||||
|
||||
fn request() -> AdmissionRequest {
|
||||
AdmissionRequest {
|
||||
scope: AdmissionScope {
|
||||
workspace_id: "ws_default".to_owned(),
|
||||
agent_key: ADMIN_ORIGIN_KEY.to_owned(),
|
||||
operation_id: "op_leads".to_owned(),
|
||||
operation_version: 3,
|
||||
},
|
||||
mode: AdmissionMode::Synchronous,
|
||||
policy_mode: ToolExecutionMode::Synchronous,
|
||||
no_tasks_fallback: NoTasksFallback::Synchronous,
|
||||
approval: ApprovalEvidence::NotRequired,
|
||||
fingerprint: "fp_0123456789".to_owned(),
|
||||
expires_at_unix_ms: 1_790_000_000_000,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn quota_keys_exclude_version_and_keep_agent_bucket() {
|
||||
let scope = request().scope;
|
||||
assert_eq!(scope.agent_bucket(), "ws_default:admin");
|
||||
assert_eq!(scope.tool_bucket(), "ws_default:op_leads");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn request_validation_rejects_zero_deadline_and_oversized_fingerprint() {
|
||||
let mut invalid = request();
|
||||
invalid.expires_at_unix_ms = 0;
|
||||
assert!(matches!(
|
||||
invalid.validate(),
|
||||
Err(AdmissionStoreError::Invalid { .. })
|
||||
));
|
||||
|
||||
let mut invalid = request();
|
||||
invalid.fingerprint = "x".repeat(super::ADMISSION_FINGERPRINT_MAX_BYTES + 1);
|
||||
assert!(invalid.validate().is_err());
|
||||
|
||||
let mut invalid = request();
|
||||
invalid.scope.operation_version = 0;
|
||||
assert!(invalid.validate().is_err());
|
||||
|
||||
assert!(request().validate().is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn weights_are_bounded_positive_configuration() {
|
||||
assert!(
|
||||
AdmissionSchedulerConfig {
|
||||
agent_weight: 0,
|
||||
tool_weight: 1
|
||||
}
|
||||
.validate()
|
||||
.is_err()
|
||||
);
|
||||
assert!(
|
||||
AdmissionSchedulerConfig {
|
||||
agent_weight: 1,
|
||||
tool_weight: 65
|
||||
}
|
||||
.validate()
|
||||
.is_err()
|
||||
);
|
||||
assert!(AdmissionSchedulerConfig::default().validate().is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn weighted_round_robin_serves_each_agent_its_quantum() {
|
||||
let mut queue = vec![
|
||||
entry(1, "agent_a", "op_1"),
|
||||
entry(2, "agent_a", "op_1"),
|
||||
entry(3, "agent_a", "op_1"),
|
||||
entry(4, "agent_b", "op_1"),
|
||||
entry(5, "agent_b", "op_1"),
|
||||
];
|
||||
let config = AdmissionSchedulerConfig {
|
||||
agent_weight: 2,
|
||||
tool_weight: 1,
|
||||
};
|
||||
let mut cursor = AdmissionCursor::default();
|
||||
let mut order = Vec::new();
|
||||
while !queue.is_empty() {
|
||||
let selection = select_next_grant(&queue, &cursor, config).unwrap();
|
||||
order.push(queue.remove(selection.index).agent_key.clone());
|
||||
cursor = selection.cursor;
|
||||
}
|
||||
assert_eq!(
|
||||
order,
|
||||
vec!["agent_a", "agent_a", "agent_b", "agent_b", "agent_a"]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fifo_inside_one_tool_and_round_robin_between_tools() {
|
||||
let mut queue = vec![
|
||||
entry(1, "agent_a", "op_1"),
|
||||
entry(2, "agent_a", "op_1"),
|
||||
entry(3, "agent_a", "op_2"),
|
||||
];
|
||||
let config = AdmissionSchedulerConfig::default();
|
||||
let mut cursor = AdmissionCursor::default();
|
||||
let mut order = Vec::new();
|
||||
while !queue.is_empty() {
|
||||
let selection = select_next_grant(&queue, &cursor, config).unwrap();
|
||||
// A granted ticket leaves the waiting queue: granted entries are never re-granted.
|
||||
order.push(queue.remove(selection.index).ticket_id);
|
||||
cursor = selection.cursor;
|
||||
}
|
||||
// One grant per Tool per round; FIFO is preserved inside each `(Agent, Tool)` queue.
|
||||
assert_eq!(order, vec![1, 3, 2]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn new_arrival_does_not_reset_cursor_or_receive_idle_credit() {
|
||||
let queue = vec![entry(1, "agent_a", "op_1")];
|
||||
let config = AdmissionSchedulerConfig {
|
||||
agent_weight: 2,
|
||||
tool_weight: 1,
|
||||
};
|
||||
let cursor = AdmissionCursor::default();
|
||||
let first = select_next_grant(&queue, &cursor, config).unwrap();
|
||||
assert_eq!(first.cursor.agent.as_deref(), Some("agent_a"));
|
||||
assert_eq!(first.cursor.agent_credit, 1);
|
||||
|
||||
// A later Agent joins; the cursor keeps its remaining quantum for `agent_a`.
|
||||
let queue = vec![entry(1, "agent_a", "op_1"), entry(2, "agent_b", "op_9")];
|
||||
let second = select_next_grant(&queue, &first.cursor, config).unwrap();
|
||||
assert_eq!(queue[second.index].agent_key, "agent_a");
|
||||
assert_eq!(second.cursor.agent_credit, 0);
|
||||
|
||||
let third = select_next_grant(&queue, &second.cursor, config).unwrap();
|
||||
assert_eq!(queue[third.index].agent_key, "agent_b");
|
||||
assert_eq!(third.cursor.agent_credit, 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn empty_queue_keeps_cursor_untouched() {
|
||||
let cursor = AdmissionCursor {
|
||||
agent: Some("agent_b".to_owned()),
|
||||
agent_credit: 1,
|
||||
tool: Some("op_1".to_owned()),
|
||||
tool_credit: 0,
|
||||
};
|
||||
assert_eq!(
|
||||
select_next_grant(&[], &cursor, AdmissionSchedulerConfig::default()),
|
||||
None
|
||||
);
|
||||
assert_eq!(cursor.agent.as_deref(), Some("agent_b"));
|
||||
}
|
||||
}
|
||||
@@ -1,4 +1,5 @@
|
||||
pub mod access;
|
||||
pub mod admission;
|
||||
pub mod agent;
|
||||
pub mod approval;
|
||||
pub mod auth;
|
||||
@@ -17,6 +18,7 @@ pub mod prompt_composition;
|
||||
pub mod protocol;
|
||||
pub mod resource;
|
||||
pub mod secret;
|
||||
pub mod task;
|
||||
pub mod tool_catalog;
|
||||
pub mod tool_quality;
|
||||
pub mod tool_search;
|
||||
@@ -60,10 +62,11 @@ pub mod domain {
|
||||
pub use crate::onboarding::{OnboardingProjection, OnboardingStep, OnboardingStepId};
|
||||
pub use crate::operation::{
|
||||
ConfigExport, ConfirmationPolicy, ExecutionConfig, GeneratedDraft, GeneratedDraftStatus,
|
||||
IdempotencyMode, IdempotencyPolicy, Operation, OperationApprovalMode,
|
||||
IdempotencyMode, IdempotencyPolicy, NoTasksFallback, Operation, OperationApprovalMode,
|
||||
OperationApprovalPayloadPreviewMode, OperationApprovalPolicy, OperationApprovalRiskLevel,
|
||||
OperationSafetyClass, OperationSafetyPolicy, OperationStatus, ResponseCachePolicy,
|
||||
RestTarget, RetryPolicy, Samples, Target, ToolDescription, ToolExample, WizardState,
|
||||
RestTarget, RetryPolicy, Samples, Target, ToolDescription, ToolExample, ToolExecutionMode,
|
||||
ToolExecutionPolicy, WizardState,
|
||||
};
|
||||
pub use crate::product_event::{
|
||||
OnboardingMilestone, PRODUCT_EVENT_IDEMPOTENCY_KEY_MAX_BYTES, PRODUCT_EVENT_SCHEMA_VERSION,
|
||||
@@ -71,6 +74,15 @@ pub mod domain {
|
||||
};
|
||||
pub use crate::protocol::{AuthKind, ExportMode, HttpMethod, Protocol};
|
||||
pub use crate::secret::{Secret, SecretKind, SecretStatus, SecretVersion};
|
||||
pub use crate::task::{
|
||||
TASK_APPROVAL_REFERENCE_MAX_BYTES, TASK_DEFAULT_RETENTION_MS, TASK_ENVELOPE_MAX_BYTES,
|
||||
TASK_ENVELOPE_MAX_DEPTH, TASK_ENVELOPE_MAX_NODES,
|
||||
TASK_EXECUTABLE_INPUT_CIPHERTEXT_MAX_BYTES, TASK_EXECUTABLE_INPUT_MAX_BYTES,
|
||||
TASK_IDENTITY_MAX_BYTES, TASK_MAX_RETENTION_MS, TASK_PURGE_BATCH_LIMIT,
|
||||
TASK_SCOPED_KEY_MAX_BYTES, TaskAcceptRequest, TaskAcceptance, TaskAccess, TaskEnvelope,
|
||||
TaskError, TaskFinishRequest, TaskId, TaskOwnerKind, TaskPins, TaskPurgeReport, TaskRecord,
|
||||
TaskState, TaskSupportIds,
|
||||
};
|
||||
pub use crate::tool_catalog::{ToolCatalogAnalysis, ToolCatalogBudget};
|
||||
pub use crate::tool_quality::{
|
||||
ToolQualityCatalogTool, ToolQualityFinding, ToolQualityMappingRule, ToolQualityMappingSet,
|
||||
@@ -108,12 +120,20 @@ pub mod ports {
|
||||
PreparedRequest, ProtocolAdapter, ProtocolAdapterError, ResponseCacheScope,
|
||||
RuntimeRequestContext, SharedProtocolAdapter,
|
||||
};
|
||||
pub use crate::task::TaskStore;
|
||||
}
|
||||
|
||||
pub use access::{
|
||||
InvitationStatus, InvitationToken, Membership, MembershipRole, PlatformApiKey,
|
||||
PlatformApiKeyKind, PlatformApiKeyScope, PlatformApiKeyStatus, User, UserStatus,
|
||||
};
|
||||
pub use admission::{
|
||||
ADMIN_ORIGIN_KEY, ADMISSION_FINGERPRINT_MAX_BYTES, ADMISSION_OVERLOAD_RETRY_AFTER_MS,
|
||||
AdmissionCursor, AdmissionDecision, AdmissionMode, AdmissionOutcome, AdmissionPermit,
|
||||
AdmissionQueueEntry, AdmissionQueueSnapshot, AdmissionRequest, AdmissionSchedulerConfig,
|
||||
AdmissionScope, AdmissionSelection, AdmissionStoreError, ApprovalEvidence, ExecutionAdmission,
|
||||
MAX_RETRY_AFTER_MS, current_unix_ms, select_next_grant,
|
||||
};
|
||||
pub use agent::{
|
||||
Agent, AgentOperationBinding, AgentStatus, AgentVersion, ToolAccessMode, ToolGroup,
|
||||
ToolSearchSettings, ToolSelectionPolicy, ToolSelectionPolicyError,
|
||||
@@ -168,13 +188,14 @@ pub use observability::{
|
||||
pub use onboarding::{OnboardingProjection, OnboardingStep, OnboardingStepId};
|
||||
pub use operation::{
|
||||
ConfigExport, ConfirmationPolicy, ExecutionConfig, GeneratedDraft, GeneratedDraftStatus,
|
||||
IdempotencyMode, IdempotencyPolicy, Operation, OperationApprovalMode,
|
||||
OperationApprovalPayloadPreviewMode, OperationApprovalPolicy, OperationApprovalRiskLevel,
|
||||
OperationAvailability, OperationLifecycle, OperationLifecycleAction, OperationLifecycleError,
|
||||
OperationSafetyClass, OperationSafetyPolicy, OperationStatus, OperationVersionState,
|
||||
ResponseCachePolicy, RestRequestContract, RestRequestContractVersion, RestRequestDescriptor,
|
||||
RestResponseDescriptor, RestTarget, RetryPolicy, Samples, Target, ToolDescription, ToolExample,
|
||||
WizardState,
|
||||
IdempotencyMode, IdempotencyPolicy, MAX_TOOL_DEADLINE_MS, NoTasksFallback, Operation,
|
||||
OperationApprovalMode, OperationApprovalPayloadPreviewMode, OperationApprovalPolicy,
|
||||
OperationApprovalRiskLevel, OperationAvailability, OperationLifecycle,
|
||||
OperationLifecycleAction, OperationLifecycleError, OperationSafetyClass, OperationSafetyPolicy,
|
||||
OperationStatus, OperationVersionState, ResponseCachePolicy, RestRequestContract,
|
||||
RestRequestContractVersion, RestRequestDescriptor, RestResponseDescriptor, RestTarget,
|
||||
RetryPolicy, Samples, Target, ToolDescription, ToolExample, ToolExecutionMode,
|
||||
ToolExecutionPolicy, ToolExecutionPolicyError, WizardState,
|
||||
};
|
||||
pub use product_event::{
|
||||
OnboardingMilestone, PRODUCT_EVENT_IDEMPOTENCY_KEY_MAX_BYTES, PRODUCT_EVENT_SCHEMA_VERSION,
|
||||
@@ -182,6 +203,14 @@ pub use product_event::{
|
||||
};
|
||||
pub use protocol::{AuthKind, ExportMode, HttpMethod, Protocol};
|
||||
pub use secret::{Secret, SecretKind, SecretStatus, SecretVersion};
|
||||
pub use task::{
|
||||
TASK_DEFAULT_RETENTION_MS, TASK_ENVELOPE_MAX_BYTES, TASK_EXECUTABLE_INPUT_CIPHERTEXT_MAX_BYTES,
|
||||
TASK_EXECUTABLE_INPUT_MAX_BYTES, TASK_MAX_RETENTION_MS, TASK_PURGE_BATCH_LIMIT,
|
||||
TASK_SCOPED_KEY_MAX_BYTES, TaskAcceptRequest, TaskAcceptance, TaskAccess, TaskEnvelope,
|
||||
TaskError, TaskFinishRequest, TaskId, TaskLease, TaskOwnerKind, TaskPins, TaskPurgeReport,
|
||||
TaskRecord, TaskState, TaskStore, TaskSupportIds, contains_sensitive_task_keys,
|
||||
redact_task_envelope, sensitive_task_key, validate_task_envelope,
|
||||
};
|
||||
pub use tool_catalog::{
|
||||
RECOMMENDED_TOOL_CATALOG_CONTEXT_TOKENS, ToolCatalogAnalysis, ToolCatalogAnalysisError,
|
||||
ToolCatalogBudget, analyze_tool_catalog,
|
||||
|
||||
@@ -270,6 +270,72 @@ pub struct OperationApprovalPolicy {
|
||||
pub elicitation_message: Option<String>,
|
||||
}
|
||||
|
||||
/// Published execution mode of one Tool (Story 4.1, FR-21).
|
||||
///
|
||||
/// This is a scheduling policy of the Published Tool version. It is deliberately separate from
|
||||
/// `ext::protocol::ExecutionMode`, which describes the protocol adapter (streaming vs unary).
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
pub enum ToolExecutionMode {
|
||||
#[default]
|
||||
Synchronous,
|
||||
Background,
|
||||
Adaptive,
|
||||
}
|
||||
|
||||
/// Behaviour promised to a client that does not negotiate durable Tasks (Story 4.1).
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
pub enum NoTasksFallback {
|
||||
/// Execute through the same synchronous admission path.
|
||||
#[default]
|
||||
Synchronous,
|
||||
/// Reject with a typed unsupported-execution-mode failure; never a Task ID.
|
||||
Unsupported,
|
||||
}
|
||||
|
||||
pub const MAX_TOOL_DEADLINE_MS: u64 = 3_600_000;
|
||||
|
||||
/// Execution policy pinned by a Published Tool version.
|
||||
///
|
||||
/// Absence of the policy keeps the pre-4.1 behaviour: synchronous execution bounded by
|
||||
/// `ExecutionConfig::timeout_ms`, with no background path.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct ToolExecutionPolicy {
|
||||
#[serde(default)]
|
||||
pub mode: ToolExecutionMode,
|
||||
/// Absolute budget of one execution, counted from the start of admission.
|
||||
pub deadline_ms: u64,
|
||||
#[serde(default)]
|
||||
pub no_tasks_fallback: NoTasksFallback,
|
||||
}
|
||||
|
||||
impl Default for ToolExecutionPolicy {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
mode: ToolExecutionMode::Synchronous,
|
||||
deadline_ms: 30_000,
|
||||
no_tasks_fallback: NoTasksFallback::Synchronous,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ToolExecutionPolicy {
|
||||
pub fn validate(&self) -> Result<(), ToolExecutionPolicyError> {
|
||||
if !(1..=MAX_TOOL_DEADLINE_MS).contains(&self.deadline_ms) {
|
||||
return Err(ToolExecutionPolicyError::DeadlineOutOfRange);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, thiserror::Error)]
|
||||
pub enum ToolExecutionPolicyError {
|
||||
#[error("tool execution deadline must be between 1 and {MAX_TOOL_DEADLINE_MS} ms")]
|
||||
DeadlineOutOfRange,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct ExecutionConfig {
|
||||
@@ -285,6 +351,8 @@ pub struct ExecutionConfig {
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub approval_policy: Option<OperationApprovalPolicy>,
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub execution_policy: Option<ToolExecutionPolicy>,
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub auth_profile_ref: Option<AuthProfileId>,
|
||||
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
|
||||
pub headers: BTreeMap<String, String>,
|
||||
@@ -444,9 +512,10 @@ mod tests {
|
||||
edition::OperationSecurityLevel,
|
||||
ids::{AuthProfileId, OperationId},
|
||||
operation::{
|
||||
ConfigExport, ExecutionConfig, Operation, OperationAvailability, OperationLifecycle,
|
||||
OperationLifecycleAction, OperationLifecycleError, OperationStatus,
|
||||
ConfigExport, ExecutionConfig, NoTasksFallback, Operation, OperationAvailability,
|
||||
OperationLifecycle, OperationLifecycleAction, OperationLifecycleError, OperationStatus,
|
||||
OperationVersionState, RestTarget, Samples, Target, ToolDescription, ToolExample,
|
||||
ToolExecutionMode, ToolExecutionPolicy,
|
||||
},
|
||||
protocol::{AuthKind, ExportMode, HttpMethod, Protocol},
|
||||
};
|
||||
@@ -664,6 +733,7 @@ updated_at: 2026-03-25T08:10:00Z
|
||||
idempotency: None,
|
||||
safety: None,
|
||||
approval_policy: None,
|
||||
execution_policy: None,
|
||||
auth_profile_ref: Some(AuthProfileId::new("auth_01")),
|
||||
headers: BTreeMap::new(),
|
||||
},
|
||||
@@ -684,4 +754,76 @@ updated_at: 2026-03-25T08:10:00Z
|
||||
published_at: None,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn execution_policy_round_trips_all_modes_and_fallbacks() {
|
||||
for (mode, fallback) in [
|
||||
(ToolExecutionMode::Synchronous, NoTasksFallback::Synchronous),
|
||||
(ToolExecutionMode::Background, NoTasksFallback::Synchronous),
|
||||
(ToolExecutionMode::Background, NoTasksFallback::Unsupported),
|
||||
(ToolExecutionMode::Adaptive, NoTasksFallback::Unsupported),
|
||||
] {
|
||||
let config = ExecutionConfig {
|
||||
execution_policy: Some(ToolExecutionPolicy {
|
||||
mode,
|
||||
deadline_ms: 45_000,
|
||||
no_tasks_fallback: fallback,
|
||||
}),
|
||||
..ExecutionConfig::default()
|
||||
};
|
||||
let encoded = serde_json::to_value(&config).unwrap();
|
||||
assert_eq!(encoded["execution_policy"]["deadline_ms"], json!(45_000));
|
||||
let decoded: ExecutionConfig = serde_json::from_value(encoded).unwrap();
|
||||
assert_eq!(decoded, config);
|
||||
assert_eq!(
|
||||
decoded.execution_policy.unwrap().mode,
|
||||
mode,
|
||||
"the published mode must survive the JSON round-trip"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn legacy_execution_config_without_policy_stays_synchronous() {
|
||||
let legacy: ExecutionConfig =
|
||||
serde_json::from_value(json!({ "timeout_ms": 12_000 })).unwrap();
|
||||
assert_eq!(legacy.execution_policy, None);
|
||||
assert_eq!(legacy.timeout_ms, 12_000);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn execution_policy_rejects_explicit_invalid_deadline() {
|
||||
assert!(
|
||||
ToolExecutionPolicy {
|
||||
mode: ToolExecutionMode::Background,
|
||||
deadline_ms: 0,
|
||||
no_tasks_fallback: NoTasksFallback::Synchronous,
|
||||
}
|
||||
.validate()
|
||||
.is_err()
|
||||
);
|
||||
assert!(
|
||||
ToolExecutionPolicy {
|
||||
mode: ToolExecutionMode::Adaptive,
|
||||
deadline_ms: crate::operation::MAX_TOOL_DEADLINE_MS + 1,
|
||||
no_tasks_fallback: NoTasksFallback::Unsupported,
|
||||
}
|
||||
.validate()
|
||||
.is_err()
|
||||
);
|
||||
assert!(ToolExecutionPolicy::default().validate().is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn execution_policy_rejects_unknown_fields() {
|
||||
assert!(
|
||||
serde_json::from_value::<ToolExecutionPolicy>(json!({
|
||||
"mode": "background",
|
||||
"deadline_ms": 1000,
|
||||
"no_tasks_fallback": "synchronous",
|
||||
"task_queue": "default"
|
||||
}))
|
||||
.is_err()
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,874 @@
|
||||
//! Durable background Task seam (Story 4.2, FR-22/FR-23).
|
||||
//!
|
||||
//! A Task is the internal, protocol-independent record of one accepted background request. This
|
||||
//! module owns the domain vocabulary only: the lifecycle states, the accepted identity/pins, the
|
||||
//! bounded persisted envelopes and the `TaskStore` port. The protocol adapter (Story 4.7) and the
|
||||
//! worker (Story 4.3) do not define these semantics; the authoritative store lives in PostgreSQL
|
||||
//! (`crank-registry`), so an accepted Task survives a crash or restart.
|
||||
//!
|
||||
//! Deliberately absent: credentials, prepared headers, approval bearer tokens and any claim that a
|
||||
//! Task was executed. A terminal state is written by a conditional transition only.
|
||||
|
||||
use async_trait::async_trait;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::Value;
|
||||
use uuid::Uuid;
|
||||
|
||||
use crate::correlation::{RequestId, TraceContext, TraceId};
|
||||
use crate::ids::PlatformApiKeyId;
|
||||
use crate::operation::ToolExecutionMode;
|
||||
|
||||
/// Byte budget of every persisted Task envelope (input, progress, result, error, schema metadata).
|
||||
pub const TASK_ENVELOPE_MAX_BYTES: usize = 32_768;
|
||||
/// Maximum byte budget of the decrypted executable Task input.
|
||||
pub const TASK_EXECUTABLE_INPUT_MAX_BYTES: usize = TASK_ENVELOPE_MAX_BYTES;
|
||||
/// Maximum byte budget of the stored encrypted executable Task input ciphertext.
|
||||
pub const TASK_EXECUTABLE_INPUT_CIPHERTEXT_MAX_BYTES: usize = 98_304;
|
||||
/// Maximum nesting depth of a persisted Task envelope.
|
||||
pub const TASK_ENVELOPE_MAX_DEPTH: usize = 8;
|
||||
/// Maximum number of JSON members/nodes of a persisted Task envelope.
|
||||
pub const TASK_ENVELOPE_MAX_NODES: usize = 256;
|
||||
/// Bound of every scope/owner/operation identity column.
|
||||
pub const TASK_IDENTITY_MAX_BYTES: usize = 160;
|
||||
/// Bound of the caller-supplied idempotency key before it becomes a scoped digest.
|
||||
pub const TASK_SCOPED_KEY_MAX_BYTES: usize = 128;
|
||||
/// Bound of a saved approval reference (an identifier, never a bearer token).
|
||||
pub const TASK_APPROVAL_REFERENCE_MAX_BYTES: usize = 160;
|
||||
/// Default retention of a terminal Task after its execution deadline (internal bounded default).
|
||||
pub const TASK_DEFAULT_RETENTION_MS: i64 = 86_400_000;
|
||||
/// Upper bound on the retention an accepted Task may pin.
|
||||
pub const TASK_MAX_RETENTION_MS: i64 = 30 * 86_400_000;
|
||||
/// Upper bound of one retention/housekeeping batch.
|
||||
pub const TASK_PURGE_BATCH_LIMIT: u32 = 128;
|
||||
|
||||
/// Stable identity of one accepted Task. Generated as UUIDv7 and returned only after the accepting
|
||||
/// transaction committed, so the ID never exists without its durable record.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
|
||||
#[serde(transparent)]
|
||||
pub struct TaskId(Uuid);
|
||||
|
||||
impl TaskId {
|
||||
pub fn generate() -> Self {
|
||||
Self(Uuid::now_v7())
|
||||
}
|
||||
|
||||
pub fn parse(value: &str) -> Result<Self, TaskError> {
|
||||
Uuid::parse_str(value)
|
||||
.map(Self)
|
||||
.map_err(|_| TaskError::invalid("task identity is not a UUID"))
|
||||
}
|
||||
|
||||
pub fn as_uuid(self) -> Uuid {
|
||||
self.0
|
||||
}
|
||||
}
|
||||
|
||||
impl std::fmt::Display for TaskId {
|
||||
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
self.0.fmt(formatter)
|
||||
}
|
||||
}
|
||||
|
||||
/// Closed Task lifecycle vocabulary. `outcome_unknown` is a non-terminal state: a value commit that
|
||||
/// failed to confirm its dispatch is never collapsed into a plain failure.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
pub enum TaskState {
|
||||
Queued,
|
||||
Working,
|
||||
InputRequired,
|
||||
OutcomeUnknown,
|
||||
Completed,
|
||||
Failed,
|
||||
Cancelled,
|
||||
}
|
||||
|
||||
impl TaskState {
|
||||
pub const fn as_str(self) -> &'static str {
|
||||
match self {
|
||||
Self::Queued => "queued",
|
||||
Self::Working => "working",
|
||||
Self::InputRequired => "input_required",
|
||||
Self::OutcomeUnknown => "outcome_unknown",
|
||||
Self::Completed => "completed",
|
||||
Self::Failed => "failed",
|
||||
Self::Cancelled => "cancelled",
|
||||
}
|
||||
}
|
||||
|
||||
pub fn parse(value: &str) -> Result<Self, TaskError> {
|
||||
match value {
|
||||
"queued" => Ok(Self::Queued),
|
||||
"working" => Ok(Self::Working),
|
||||
"input_required" => Ok(Self::InputRequired),
|
||||
"outcome_unknown" => Ok(Self::OutcomeUnknown),
|
||||
"completed" => Ok(Self::Completed),
|
||||
"failed" => Ok(Self::Failed),
|
||||
"cancelled" => Ok(Self::Cancelled),
|
||||
_ => Err(TaskError::invalid("unknown task state")),
|
||||
}
|
||||
}
|
||||
|
||||
pub const fn is_terminal(self) -> bool {
|
||||
matches!(self, Self::Completed | Self::Failed | Self::Cancelled)
|
||||
}
|
||||
|
||||
/// One conditional transition may only move along this table. A terminal state has no successor,
|
||||
/// so a repeated terminal write can never rewrite an accepted result.
|
||||
pub const fn allows_transition_to(self, next: Self) -> bool {
|
||||
match self {
|
||||
Self::Queued => matches!(next, Self::Working | Self::Failed | Self::Cancelled),
|
||||
Self::Working => matches!(
|
||||
next,
|
||||
Self::InputRequired
|
||||
| Self::OutcomeUnknown
|
||||
| Self::Completed
|
||||
| Self::Failed
|
||||
| Self::Cancelled
|
||||
),
|
||||
Self::InputRequired => matches!(next, Self::Working | Self::Failed | Self::Cancelled),
|
||||
Self::OutcomeUnknown => {
|
||||
matches!(next, Self::Completed | Self::Failed | Self::Cancelled)
|
||||
}
|
||||
Self::Completed | Self::Failed | Self::Cancelled => false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Who owns the accepted Task. An administrator is never a wildcard owner of every Task: the owner
|
||||
/// identity and the authorization scope are separate, both-pinned columns.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
pub enum TaskOwnerKind {
|
||||
Agent,
|
||||
Admin,
|
||||
}
|
||||
|
||||
impl TaskOwnerKind {
|
||||
pub const fn as_str(self) -> &'static str {
|
||||
match self {
|
||||
Self::Agent => "agent",
|
||||
Self::Admin => "admin",
|
||||
}
|
||||
}
|
||||
|
||||
pub fn parse(value: &str) -> Result<Self, TaskError> {
|
||||
match value {
|
||||
"agent" => Ok(Self::Agent),
|
||||
"admin" => Ok(Self::Admin),
|
||||
_ => Err(TaskError::invalid("unknown task owner kind")),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Support identities captured at acceptance. They are stored and returned independently of
|
||||
/// sampling, and a replay never rewrites them.
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct TaskSupportIds {
|
||||
pub request_id: RequestId,
|
||||
pub trace_id: TraceId,
|
||||
pub traceparent: String,
|
||||
pub trace_sampled: bool,
|
||||
}
|
||||
|
||||
impl TaskSupportIds {
|
||||
pub fn new(request_id: RequestId, trace_context: &TraceContext) -> Self {
|
||||
Self {
|
||||
request_id,
|
||||
trace_id: trace_context.trace_id().clone(),
|
||||
traceparent: trace_context.traceparent().to_owned(),
|
||||
trace_sampled: trace_context.is_sampled(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Re-validates both the trace identity and the parent context: a Task must never persist an
|
||||
/// inconsistent or malformed support pair, and an unsampled context is still a valid parent.
|
||||
pub fn validate(&self) -> Result<(), TaskError> {
|
||||
if self.trace_id.as_str().is_empty() {
|
||||
return Err(TaskError::invalid("task trace identity is missing"));
|
||||
}
|
||||
let context = TraceContext::parse(&self.traceparent)
|
||||
.map_err(|_| TaskError::invalid("task trace parent is invalid"))?;
|
||||
if context.trace_id() != &self.trace_id || context.is_sampled() != self.trace_sampled {
|
||||
return Err(TaskError::invalid("task trace parent is inconsistent"));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// Execution semantics pinned at acceptance: a later publication never rewrites them.
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct TaskPins {
|
||||
pub operation_version: u32,
|
||||
pub policy_mode: ToolExecutionMode,
|
||||
pub execution_deadline_unix_ms: i64,
|
||||
/// Retention deadline of the record; never the same thing as the execution deadline.
|
||||
pub retain_until_unix_ms: i64,
|
||||
/// Verified approval evidence reference (identifier only, never a bearer token).
|
||||
pub approval_reference: Option<String>,
|
||||
}
|
||||
|
||||
impl TaskPins {
|
||||
pub fn validate(&self) -> Result<(), TaskError> {
|
||||
if self.operation_version == 0 {
|
||||
return Err(TaskError::invalid(
|
||||
"task operation version must be positive",
|
||||
));
|
||||
}
|
||||
if self.execution_deadline_unix_ms <= 0 {
|
||||
return Err(TaskError::invalid("task execution deadline is invalid"));
|
||||
}
|
||||
if self.retain_until_unix_ms < self.execution_deadline_unix_ms {
|
||||
return Err(TaskError::invalid(
|
||||
"task retention deadline precedes execution",
|
||||
));
|
||||
}
|
||||
if self.retain_until_unix_ms - self.execution_deadline_unix_ms > TASK_MAX_RETENTION_MS {
|
||||
return Err(TaskError::invalid("task retention exceeds its bound"));
|
||||
}
|
||||
if let Some(reference) = self.approval_reference.as_deref()
|
||||
&& (reference.is_empty()
|
||||
|| reference.len() > TASK_APPROVAL_REFERENCE_MAX_BYTES
|
||||
|| reference.bytes().any(|byte| byte.is_ascii_control()))
|
||||
{
|
||||
return Err(TaskError::invalid("task approval reference is invalid"));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// Bounded, classified payload of a Task. Construction validates the byte/depth/node budget and
|
||||
/// redacts secret-bearing fields before anything is hashed or persisted.
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct TaskEnvelope {
|
||||
value: Value,
|
||||
}
|
||||
|
||||
impl TaskEnvelope {
|
||||
/// Validates the caller-provided value, then stores a redacted copy of it. The caller hashes the
|
||||
/// original value separately, so redaction never collapses two different requests into one.
|
||||
pub fn try_redacted(input: &Value) -> Result<Self, TaskError> {
|
||||
validate_task_envelope(input)?;
|
||||
Ok(Self {
|
||||
value: redact_task_envelope(input),
|
||||
})
|
||||
}
|
||||
|
||||
/// Accepts a value that was already validated and redacted at a trust boundary.
|
||||
pub fn from_persisted(value: Value) -> Result<Self, TaskError> {
|
||||
validate_task_envelope(&value)?;
|
||||
Ok(Self { value })
|
||||
}
|
||||
|
||||
pub fn value(&self) -> &Value {
|
||||
&self.value
|
||||
}
|
||||
|
||||
pub fn into_value(self) -> Value {
|
||||
self.value
|
||||
}
|
||||
}
|
||||
|
||||
/// Validates the size, nesting depth and node count of one Task envelope. Every byte, collection and
|
||||
/// node is counted before the value is cloned, hashed or persisted.
|
||||
pub fn validate_task_envelope(value: &Value) -> Result<(), TaskError> {
|
||||
let encoded = serde_json::to_vec(value)
|
||||
.map_err(|_| TaskError::invalid("task envelope is not serializable"))?;
|
||||
if encoded.len() > TASK_ENVELOPE_MAX_BYTES {
|
||||
return Err(TaskError::invalid("task envelope exceeds its byte budget"));
|
||||
}
|
||||
let mut nodes = 0usize;
|
||||
check_budget(value, 1, &mut nodes)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn check_budget(value: &Value, depth: usize, nodes: &mut usize) -> Result<(), TaskError> {
|
||||
if depth > TASK_ENVELOPE_MAX_DEPTH {
|
||||
return Err(TaskError::invalid("task envelope exceeds its depth budget"));
|
||||
}
|
||||
*nodes += 1;
|
||||
if *nodes > TASK_ENVELOPE_MAX_NODES {
|
||||
return Err(TaskError::invalid("task envelope exceeds its node budget"));
|
||||
}
|
||||
match value {
|
||||
Value::Object(object) => {
|
||||
for (key, child) in object {
|
||||
check_budget_name(key)?;
|
||||
check_budget(child, depth + 1, nodes)?;
|
||||
}
|
||||
}
|
||||
Value::Array(values) => {
|
||||
for child in values {
|
||||
check_budget(child, depth + 1, nodes)?;
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn check_budget_name(key: &str) -> Result<(), TaskError> {
|
||||
if key.len() > TASK_IDENTITY_MAX_BYTES {
|
||||
return Err(TaskError::invalid("task envelope key exceeds its budget"));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Field-name classification of secret-bearing values. A matching field keeps its position but never
|
||||
/// its plaintext in the persisted envelope.
|
||||
pub fn sensitive_task_key(name: &str) -> bool {
|
||||
let lowered = name.to_ascii_lowercase();
|
||||
[
|
||||
"password",
|
||||
"passwd",
|
||||
"secret",
|
||||
"token",
|
||||
"api_key",
|
||||
"apikey",
|
||||
"authorization",
|
||||
"credential",
|
||||
"private_key",
|
||||
"cookie",
|
||||
"signature",
|
||||
]
|
||||
.iter()
|
||||
.any(|marker| lowered.contains(marker))
|
||||
}
|
||||
|
||||
/// Redacted projection of an already validated envelope.
|
||||
pub fn redact_task_envelope(value: &Value) -> Value {
|
||||
match value {
|
||||
Value::Object(object) => Value::Object(
|
||||
object
|
||||
.iter()
|
||||
.map(|(key, child)| {
|
||||
let value = if sensitive_task_key(key) {
|
||||
Value::String("[redacted]".to_owned())
|
||||
} else {
|
||||
redact_task_envelope(child)
|
||||
};
|
||||
(key.clone(), value)
|
||||
})
|
||||
.collect(),
|
||||
),
|
||||
Value::Array(values) => Value::Array(values.iter().map(redact_task_envelope).collect()),
|
||||
other => other.clone(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Recursive check used to fail closed on sensitive fields before encryption.
|
||||
pub fn contains_sensitive_task_keys(value: &Value) -> bool {
|
||||
match value {
|
||||
Value::Object(object) => object
|
||||
.iter()
|
||||
.any(|(key, child)| sensitive_task_key(key) || contains_sensitive_task_keys(child)),
|
||||
Value::Array(values) => values.iter().any(contains_sensitive_task_keys),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
/// Write request of a new durable Task. The store owns the transaction: Task, dispatch intent and
|
||||
/// queue capacity commit together, and no acknowledgement exists before that commit.
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct TaskAcceptRequest {
|
||||
pub task_id: TaskId,
|
||||
pub workspace_id: String,
|
||||
pub owner_kind: TaskOwnerKind,
|
||||
pub owner_id: String,
|
||||
pub authorization_scope: String,
|
||||
/// Typed identity of the Platform API key that authorized the acceptance (Story 4.3). Only the
|
||||
/// immutable key ID is stored, never the bearer secret; a worker revalidates it authoritatively.
|
||||
/// `None` means the accepting principal has no machine key (administrator) and fail-closes.
|
||||
pub platform_api_key_id: Option<PlatformApiKeyId>,
|
||||
pub operation_id: String,
|
||||
pub pins: TaskPins,
|
||||
/// Digest of the caller key over the full owner/authorization/Tool scope.
|
||||
pub scoped_key: String,
|
||||
/// Digest of the canonical validated executable input.
|
||||
pub input_fingerprint: String,
|
||||
pub input: TaskEnvelope,
|
||||
pub support: TaskSupportIds,
|
||||
/// Bounded encrypted executable input, persisted alongside the redacted input projection.
|
||||
pub executable_input_ciphertext: Option<String>,
|
||||
pub executable_input_key_version: Option<String>,
|
||||
pub executable_input_master_key_epoch: Option<i64>,
|
||||
}
|
||||
|
||||
impl TaskAcceptRequest {
|
||||
pub fn validate(&self) -> Result<(), TaskError> {
|
||||
for (field, value) in [
|
||||
("workspace", self.workspace_id.as_str()),
|
||||
("owner", self.owner_id.as_str()),
|
||||
("authorization scope", self.authorization_scope.as_str()),
|
||||
("operation", self.operation_id.as_str()),
|
||||
] {
|
||||
if value.is_empty() || value.len() > TASK_IDENTITY_MAX_BYTES {
|
||||
return Err(TaskError::invalid(format!("task {field} is invalid")));
|
||||
}
|
||||
}
|
||||
if let Some(key_id) = self.platform_api_key_id.as_ref()
|
||||
&& (key_id.as_str().is_empty() || key_id.as_str().len() > TASK_IDENTITY_MAX_BYTES)
|
||||
{
|
||||
return Err(TaskError::invalid(
|
||||
"task platform api key reference is invalid",
|
||||
));
|
||||
}
|
||||
if self.scoped_key.len() < 16 || self.scoped_key.len() > TASK_SCOPED_KEY_MAX_BYTES {
|
||||
return Err(TaskError::invalid("task scoped key digest is invalid"));
|
||||
}
|
||||
if self.input_fingerprint.len() != 64
|
||||
|| !self
|
||||
.input_fingerprint
|
||||
.bytes()
|
||||
.all(|byte| byte.is_ascii_hexdigit() && !byte.is_ascii_uppercase())
|
||||
{
|
||||
return Err(TaskError::invalid("task input fingerprint is invalid"));
|
||||
}
|
||||
self.pins.validate()?;
|
||||
self.support.validate()?;
|
||||
let has_ciphertext = self.executable_input_ciphertext.is_some();
|
||||
let has_key = self.executable_input_key_version.is_some();
|
||||
let has_epoch = self.executable_input_master_key_epoch.is_some();
|
||||
match (has_ciphertext, has_key, has_epoch) {
|
||||
(false, false, false) => {}
|
||||
(true, true, true) => {
|
||||
let ciphertext = self.executable_input_ciphertext.as_deref().unwrap();
|
||||
if ciphertext.is_empty()
|
||||
|| ciphertext.len() > TASK_EXECUTABLE_INPUT_CIPHERTEXT_MAX_BYTES
|
||||
{
|
||||
return Err(TaskError::invalid(
|
||||
"task executable input ciphertext is invalid",
|
||||
));
|
||||
}
|
||||
let key_version = self.executable_input_key_version.as_deref().unwrap();
|
||||
if key_version.is_empty() || key_version.len() > 64 {
|
||||
return Err(TaskError::invalid(
|
||||
"task executable input ciphertext is invalid",
|
||||
));
|
||||
}
|
||||
if self.executable_input_master_key_epoch.unwrap_or_default() < 1 {
|
||||
return Err(TaskError::invalid(
|
||||
"task executable input ciphertext is invalid",
|
||||
));
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
return Err(TaskError::invalid(
|
||||
"task executable input ciphertext is invalid",
|
||||
));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// Successful acceptance, returned only after the accepting transaction committed. A replay returns
|
||||
/// the stored identity and support IDs of the original acceptance.
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct TaskAcceptance {
|
||||
pub task_id: TaskId,
|
||||
pub state: TaskState,
|
||||
/// Exact Published Version pinned by this acceptance; a replay returns the stored pin.
|
||||
pub operation_version: u32,
|
||||
pub support: TaskSupportIds,
|
||||
pub created_at_unix_ms: i64,
|
||||
pub retain_until_unix_ms: i64,
|
||||
pub replayed: bool,
|
||||
}
|
||||
|
||||
/// Owner-side access proof of a read or a terminal write. It is built by the application layer from
|
||||
/// the verified principal, never from a caller-supplied marker, and every store query carries the
|
||||
/// whole predicate so a foreign row is never fetched.
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct TaskAccess {
|
||||
pub workspace_id: String,
|
||||
pub owner_kind: TaskOwnerKind,
|
||||
pub owner_id: String,
|
||||
pub authorization_scope: String,
|
||||
}
|
||||
|
||||
impl TaskAccess {
|
||||
pub fn validate(&self) -> Result<(), TaskError> {
|
||||
for (field, value) in [
|
||||
("workspace", self.workspace_id.as_str()),
|
||||
("owner", self.owner_id.as_str()),
|
||||
("authorization scope", self.authorization_scope.as_str()),
|
||||
] {
|
||||
if value.is_empty() || value.len() > TASK_IDENTITY_MAX_BYTES {
|
||||
return Err(TaskError::invalid(format!("task {field} is invalid")));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// Read model of one Task. Lifecycle fields, pins and support IDs stay readable together; the
|
||||
/// protocol adapter only maps them.
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct TaskRecord {
|
||||
pub task_id: TaskId,
|
||||
pub state: TaskState,
|
||||
pub workspace_id: String,
|
||||
pub owner_kind: TaskOwnerKind,
|
||||
pub owner_id: String,
|
||||
pub authorization_scope: String,
|
||||
/// Typed immutable identity of the Platform API key that authorized the acceptance; the worker
|
||||
/// revalidates this exact key against the registry before any outbound dispatch.
|
||||
pub platform_api_key_id: Option<PlatformApiKeyId>,
|
||||
pub operation_id: String,
|
||||
/// Canonical digest of the accepted executable input (compare-and-conflict identity).
|
||||
pub input_fingerprint: String,
|
||||
pub pins: TaskPins,
|
||||
pub support: TaskSupportIds,
|
||||
pub input: TaskEnvelope,
|
||||
pub progress: Option<TaskEnvelope>,
|
||||
pub result: Option<TaskEnvelope>,
|
||||
pub error: Option<TaskEnvelope>,
|
||||
pub attempts: u32,
|
||||
/// Monotonic lease/fencing token. It never resets and protects Task state mutations.
|
||||
pub fence: u64,
|
||||
/// Random process-instance lease owner, if a worker currently owns the Task.
|
||||
pub lease_owner: Option<String>,
|
||||
/// Lease expiry epoch milliseconds, if the Task is claimed.
|
||||
pub lease_until_unix_ms: Option<i64>,
|
||||
/// Current dispatch attempt identity, committed before any outbound adapter call.
|
||||
pub current_attempt_id: Option<String>,
|
||||
/// Dispatch checkpoint epoch milliseconds, if an outbound attempt was committed.
|
||||
pub dispatch_started_at_unix_ms: Option<i64>,
|
||||
/// Monotonic lifecycle version used by the terminal CAS.
|
||||
pub version: u32,
|
||||
pub created_at_unix_ms: i64,
|
||||
pub updated_at_unix_ms: i64,
|
||||
}
|
||||
|
||||
/// One conditional terminal transition. Exactly one concurrent writer wins; the losers observe the
|
||||
/// accepted state and never rewrite the result.
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct TaskFinishRequest {
|
||||
pub access: TaskAccess,
|
||||
pub task_id: TaskId,
|
||||
pub expected_state: TaskState,
|
||||
pub expected_version: u32,
|
||||
pub target_state: TaskState,
|
||||
pub result: Option<TaskEnvelope>,
|
||||
pub error: Option<TaskEnvelope>,
|
||||
}
|
||||
|
||||
impl TaskFinishRequest {
|
||||
pub fn validate(&self) -> Result<(), TaskError> {
|
||||
self.access.validate()?;
|
||||
if !self.target_state.is_terminal() {
|
||||
return Err(TaskError::invalid("task finish target is not terminal"));
|
||||
}
|
||||
if self.expected_state.is_terminal() {
|
||||
return Err(TaskError::invalid("task finish source is already terminal"));
|
||||
}
|
||||
if !self.expected_state.allows_transition_to(self.target_state) {
|
||||
return Err(TaskError::invalid("task state transition is not allowed"));
|
||||
}
|
||||
if self.target_state == TaskState::Completed && self.result.is_none() {
|
||||
return Err(TaskError::invalid("a completed task requires a result"));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// Bounded retention outcome.
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
|
||||
pub struct TaskPurgeReport {
|
||||
/// Queued Tasks that passed their execution deadline and were failed with their intent removed.
|
||||
pub expired_queued: u64,
|
||||
/// Terminal Tasks that passed their retention deadline.
|
||||
pub expired_terminal: u64,
|
||||
}
|
||||
|
||||
/// Typed Task failure. A denial and a missing Task share one outward shape, so a foreign caller can
|
||||
/// never distinguish "not yours" from "does not exist".
|
||||
#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
|
||||
pub enum TaskError {
|
||||
#[error("task request is invalid: {message}")]
|
||||
Invalid { message: String },
|
||||
#[error("task store is unavailable: {message}")]
|
||||
Unavailable { message: String },
|
||||
#[error("task was not found")]
|
||||
NotFound,
|
||||
#[error("task request conflicts with the accepted request")]
|
||||
FingerprintConflict,
|
||||
#[error("task lifecycle transition was rejected")]
|
||||
StateConflict,
|
||||
#[error("background task capacity is exhausted")]
|
||||
Overloaded { retry_after_ms: u64 },
|
||||
}
|
||||
|
||||
impl TaskError {
|
||||
pub fn invalid(message: impl Into<String>) -> Self {
|
||||
Self::Invalid {
|
||||
message: message.into(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn unavailable(message: impl Into<String>) -> Self {
|
||||
Self::Unavailable {
|
||||
message: message.into(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether the caller may tell this failure apart from an absent Task.
|
||||
pub fn is_not_found(&self) -> bool {
|
||||
matches!(self, Self::NotFound)
|
||||
}
|
||||
}
|
||||
|
||||
/// Leased view of a claimed Task: its durable record plus lease fencing identity.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct TaskLease {
|
||||
pub record: TaskRecord,
|
||||
pub owner: String,
|
||||
pub fence: u64,
|
||||
pub lease_until: i64,
|
||||
}
|
||||
|
||||
/// Authoritative durable Task port.
|
||||
#[async_trait]
|
||||
pub trait TaskStore: Send + Sync {
|
||||
/// Proves the durable Task state is usable (schema and operations reachable).
|
||||
async fn health(&self) -> Result<(), TaskError>;
|
||||
|
||||
/// Atomically accepts a Task: Task record, dispatch intent and one queue slot commit together.
|
||||
async fn accept(&self, request: TaskAcceptRequest) -> Result<TaskAcceptance, TaskError>;
|
||||
|
||||
/// Reads one Task inside the caller's owner scope.
|
||||
async fn read(&self, access: &TaskAccess, task_id: TaskId) -> Result<TaskRecord, TaskError>;
|
||||
|
||||
/// Scoped lookup of an already accepted Task by its full-scope idempotency digest. Used to keep a
|
||||
/// retry of an explicitly pinned version from becoming new work; `None` means "not accepted yet".
|
||||
async fn find(
|
||||
&self,
|
||||
access: &TaskAccess,
|
||||
operation_id: &str,
|
||||
scoped_key: &str,
|
||||
) -> Result<Option<TaskRecord>, TaskError>;
|
||||
|
||||
/// Applies exactly one conditional terminal transition and releases its intent atomically.
|
||||
async fn finish(&self, request: TaskFinishRequest) -> Result<TaskRecord, TaskError>;
|
||||
|
||||
/// Reads encrypted executable input only under a valid, unexpired current lease.
|
||||
async fn read_executable_input(
|
||||
&self,
|
||||
owner: &str,
|
||||
task_id: TaskId,
|
||||
fence: u64,
|
||||
) -> Result<(String, String, i64), TaskError>;
|
||||
|
||||
/// Bounded retention...
|
||||
async fn purge_expired(&self, batch: u32) -> Result<TaskPurgeReport, TaskError>;
|
||||
|
||||
/// Claims a bounded batch of queued or safely recoverable Tasks under leases.
|
||||
async fn claim_batch(
|
||||
&self,
|
||||
owner: &str,
|
||||
batch_limit: u32,
|
||||
lease_ms: i64,
|
||||
) -> Result<Vec<TaskLease>, TaskError>;
|
||||
|
||||
/// Renews a lease owned by `owner` when fence and expiry still match.
|
||||
async fn renew_lease(
|
||||
&self,
|
||||
owner: &str,
|
||||
task_id: TaskId,
|
||||
fence: u64,
|
||||
lease_ms: i64,
|
||||
) -> Result<TaskLease, TaskError>;
|
||||
|
||||
/// Persists redacted progress under a valid lease.
|
||||
async fn write_progress(
|
||||
&self,
|
||||
owner: &str,
|
||||
task_id: TaskId,
|
||||
fence: u64,
|
||||
progress: TaskEnvelope,
|
||||
) -> Result<TaskRecord, TaskError>;
|
||||
|
||||
/// Commits an outbound attempt identity and dispatch timestamp before network use.
|
||||
async fn checkpoint_dispatch(
|
||||
&self,
|
||||
owner: &str,
|
||||
task_id: TaskId,
|
||||
fence: u64,
|
||||
attempt_id: String,
|
||||
) -> Result<TaskRecord, TaskError>;
|
||||
|
||||
/// Applies a terminal transition only under a valid lease and releases intent atomically.
|
||||
async fn finish_leased(
|
||||
&self,
|
||||
request: TaskFinishRequest,
|
||||
owner: &str,
|
||||
fence: u64,
|
||||
) -> Result<TaskRecord, TaskError>;
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use serde_json::json;
|
||||
|
||||
fn request() -> TaskAcceptRequest {
|
||||
TaskAcceptRequest {
|
||||
task_id: TaskId::generate(),
|
||||
workspace_id: "ws_default".to_owned(),
|
||||
owner_kind: TaskOwnerKind::Agent,
|
||||
owner_id: "agent_a".to_owned(),
|
||||
authorization_scope: "credential:pk_1".to_owned(),
|
||||
platform_api_key_id: Some(PlatformApiKeyId::new("pk_1")),
|
||||
operation_id: "op_report".to_owned(),
|
||||
pins: TaskPins {
|
||||
operation_version: 3,
|
||||
policy_mode: ToolExecutionMode::Background,
|
||||
execution_deadline_unix_ms: 1_790_000_000_000,
|
||||
retain_until_unix_ms: 1_790_000_000_000 + 1_000,
|
||||
approval_reference: Some("appr_1".to_owned()),
|
||||
},
|
||||
scoped_key: "a".repeat(64),
|
||||
input_fingerprint: "b".repeat(64),
|
||||
input: TaskEnvelope::try_redacted(&json!({"report": "q3"})).unwrap(),
|
||||
support: TaskSupportIds::new(
|
||||
RequestId::generate(),
|
||||
&TraceContext::parse("00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-00")
|
||||
.unwrap(),
|
||||
),
|
||||
executable_input_ciphertext: None,
|
||||
executable_input_key_version: None,
|
||||
executable_input_master_key_epoch: None,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn uuid_v7_task_ids_are_unique_and_round_trip() {
|
||||
let first = TaskId::generate();
|
||||
let second = TaskId::generate();
|
||||
assert_ne!(first, second);
|
||||
assert_eq!(TaskId::parse(&first.to_string()).unwrap(), first);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn terminal_states_have_no_successor() {
|
||||
for terminal in [
|
||||
TaskState::Completed,
|
||||
TaskState::Failed,
|
||||
TaskState::Cancelled,
|
||||
] {
|
||||
assert!(terminal.is_terminal());
|
||||
for next in [
|
||||
TaskState::Queued,
|
||||
TaskState::Working,
|
||||
TaskState::Completed,
|
||||
TaskState::Failed,
|
||||
] {
|
||||
assert!(!terminal.allows_transition_to(next));
|
||||
}
|
||||
}
|
||||
assert!(TaskState::Queued.allows_transition_to(TaskState::Working));
|
||||
assert!(TaskState::Working.allows_transition_to(TaskState::OutcomeUnknown));
|
||||
assert!(!TaskState::Queued.allows_transition_to(TaskState::Completed));
|
||||
assert!(!TaskState::InputRequired.allows_transition_to(TaskState::Completed));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn envelope_bounds_reject_bytes_depth_and_nodes() {
|
||||
assert!(TaskEnvelope::try_redacted(&json!({"a": 1})).is_ok());
|
||||
assert!(
|
||||
TaskEnvelope::try_redacted(&json!({"a": "x".repeat(TASK_ENVELOPE_MAX_BYTES)})).is_err()
|
||||
);
|
||||
|
||||
let mut deep = json!(1);
|
||||
for _ in 0..=TASK_ENVELOPE_MAX_DEPTH {
|
||||
deep = json!({"n": deep});
|
||||
}
|
||||
assert!(TaskEnvelope::try_redacted(&deep).is_err());
|
||||
|
||||
let wide = Value::Array((0..=TASK_ENVELOPE_MAX_NODES).map(|_| json!(1)).collect());
|
||||
assert!(TaskEnvelope::try_redacted(&wide).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn secret_bearing_fields_are_redacted_and_keep_their_shape() {
|
||||
let envelope = TaskEnvelope::try_redacted(&json!({
|
||||
"query": "leads",
|
||||
"auth": {"api_key": "sk_live_1", "nested": [{"password": "p"}]}
|
||||
}))
|
||||
.unwrap();
|
||||
let value = envelope.value();
|
||||
assert_eq!(value["query"], json!("leads"));
|
||||
assert_eq!(value["auth"]["api_key"], json!("[redacted]"));
|
||||
assert_eq!(value["auth"]["nested"][0]["password"], json!("[redacted]"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unsampled_support_ids_are_valid_and_consistent() {
|
||||
let support = TaskSupportIds::new(
|
||||
RequestId::generate(),
|
||||
&TraceContext::parse("00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-00")
|
||||
.unwrap(),
|
||||
);
|
||||
assert!(!support.trace_sampled);
|
||||
assert!(support.traceparent.ends_with("-00"));
|
||||
support.validate().unwrap();
|
||||
|
||||
let mut inconsistent = support.clone();
|
||||
inconsistent.traceparent = inconsistent.traceparent.replace("-00", "-01");
|
||||
assert!(inconsistent.validate().is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn accept_request_validation_holds_the_identity_and_pin_bounds() {
|
||||
assert!(request().validate().is_ok());
|
||||
|
||||
let mut oversized = request();
|
||||
oversized.workspace_id = "w".repeat(TASK_IDENTITY_MAX_BYTES + 1);
|
||||
assert!(oversized.validate().is_err());
|
||||
|
||||
let mut bad_fingerprint = request();
|
||||
bad_fingerprint.input_fingerprint = "XYZ".to_owned();
|
||||
assert!(bad_fingerprint.validate().is_err());
|
||||
|
||||
let mut bad_retention = request();
|
||||
bad_retention.pins.retain_until_unix_ms = bad_retention.pins.execution_deadline_unix_ms - 1;
|
||||
assert!(bad_retention.validate().is_err());
|
||||
|
||||
// The persisted authority reference is bounded and never empty.
|
||||
let mut empty_key_reference = request();
|
||||
empty_key_reference.platform_api_key_id = Some(PlatformApiKeyId::new(""));
|
||||
assert!(empty_key_reference.validate().is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn finish_requires_a_terminal_reachable_transition() {
|
||||
let access = TaskAccess {
|
||||
workspace_id: "ws_default".to_owned(),
|
||||
owner_kind: TaskOwnerKind::Agent,
|
||||
owner_id: "agent_a".to_owned(),
|
||||
authorization_scope: "credential:pk_1".to_owned(),
|
||||
};
|
||||
let base = TaskFinishRequest {
|
||||
access,
|
||||
task_id: TaskId::generate(),
|
||||
expected_state: TaskState::Working,
|
||||
expected_version: 1,
|
||||
target_state: TaskState::Completed,
|
||||
result: Some(TaskEnvelope::try_redacted(&json!({"ok": true})).unwrap()),
|
||||
error: None,
|
||||
};
|
||||
assert!(base.validate().is_ok());
|
||||
|
||||
let mut non_terminal = base.clone();
|
||||
non_terminal.target_state = TaskState::Working;
|
||||
assert!(non_terminal.validate().is_err());
|
||||
|
||||
let mut terminal_source = base.clone();
|
||||
terminal_source.expected_state = TaskState::Completed;
|
||||
assert!(terminal_source.validate().is_err());
|
||||
|
||||
let mut completed_without_result = base;
|
||||
completed_without_result.result = None;
|
||||
assert!(completed_without_result.validate().is_err());
|
||||
}
|
||||
}
|
||||
@@ -231,6 +231,7 @@ fn default_execution_config() -> ExecutionConfig {
|
||||
idempotency: None,
|
||||
safety: None,
|
||||
approval_policy: None,
|
||||
execution_policy: None,
|
||||
auth_profile_ref: None,
|
||||
headers: BTreeMap::new(),
|
||||
}
|
||||
|
||||
@@ -564,6 +564,7 @@ fn default_execution_config() -> ExecutionConfig {
|
||||
idempotency: None,
|
||||
safety: None,
|
||||
approval_policy: None,
|
||||
execution_policy: None,
|
||||
auth_profile_ref: None,
|
||||
headers: BTreeMap::new(),
|
||||
}
|
||||
|
||||
@@ -217,6 +217,34 @@ string_enum! {
|
||||
Concurrency => "concurrency",
|
||||
RateLimit => "rate_limit",
|
||||
McpStream => "mcp_stream",
|
||||
Admission => "admission",
|
||||
}
|
||||
}
|
||||
|
||||
string_enum! {
|
||||
pub enum RejectionReason {
|
||||
Limit => "limit",
|
||||
Capacity => "capacity",
|
||||
QueueFull => "queue_full",
|
||||
Deadline => "deadline",
|
||||
Unsupported => "unsupported",
|
||||
DependencyUnavailable => "dependency_unavailable",
|
||||
}
|
||||
}
|
||||
|
||||
string_enum! {
|
||||
pub enum ScopeKind {
|
||||
Process => "process",
|
||||
Global => "global",
|
||||
Agent => "agent",
|
||||
Tool => "tool",
|
||||
}
|
||||
}
|
||||
|
||||
string_enum! {
|
||||
pub enum AdmissionModeLabel {
|
||||
Synchronous => "synchronous",
|
||||
Background => "background",
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -16,14 +16,15 @@ mod schema;
|
||||
|
||||
pub use exemplar::{ExemplarObservation, ExemplarTraceId, exemplar_snapshot};
|
||||
pub use labels::{
|
||||
CacheOutcome, ConfirmationOutcome, DbPoolState, Exporter, HttpMethod, HttpRoute,
|
||||
HttpStatusClass, IdempotencyOutcome, InvocationSource, LimitStage, McpMethod, McpOutcome,
|
||||
McpResponseMode, SignalType, ToolErrorKind, ToolOutcome, UpstreamOperationKind,
|
||||
UpstreamOutcome,
|
||||
AdmissionModeLabel, CacheOutcome, ConfirmationOutcome, DbPoolState, Exporter, HttpMethod,
|
||||
HttpRoute, HttpStatusClass, IdempotencyOutcome, InvocationSource, LimitStage, McpMethod,
|
||||
McpOutcome, McpResponseMode, RejectionReason, ScopeKind, SignalType, ToolErrorKind,
|
||||
ToolOutcome, UpstreamOperationKind, UpstreamOutcome,
|
||||
};
|
||||
pub use record::{
|
||||
InFlightGuard, ToolInvocationMetrics, UpstreamRequestMetrics, bind_metric_service,
|
||||
bound_metric_service, initialize_gauges, normalize_http_route, record_cache_outcome,
|
||||
bound_metric_service, initialize_gauges, normalize_http_route, record_admission_oldest_waiting,
|
||||
record_admission_queue_wait, record_admission_rejection, record_cache_outcome,
|
||||
record_confirmation_outcome, record_export_failure, record_http_request,
|
||||
record_http_request_with_exemplar, record_idempotency_outcome, record_invocation_history_lost,
|
||||
record_limit_rejection, record_mcp_request, record_mcp_request_with_exemplar,
|
||||
|
||||
@@ -5,10 +5,10 @@ use metrics::Gauge;
|
||||
|
||||
use crate::schema::{MetricDefinition, metric_schema};
|
||||
use crate::{
|
||||
CacheOutcome, ConfirmationOutcome, DbPoolState, ExemplarTraceId, Exporter, HttpMethod,
|
||||
HttpRoute, HttpStatusClass, IdempotencyOutcome, InvocationSource, LimitStage, McpMethod,
|
||||
McpOutcome, McpResponseMode, MetricBindingError, MetricService, SignalType, ToolErrorKind,
|
||||
ToolOutcome, UpstreamOperationKind, UpstreamOutcome,
|
||||
AdmissionModeLabel, CacheOutcome, ConfirmationOutcome, DbPoolState, ExemplarTraceId, Exporter,
|
||||
HttpMethod, HttpRoute, HttpStatusClass, IdempotencyOutcome, InvocationSource, LimitStage,
|
||||
McpMethod, McpOutcome, McpResponseMode, MetricBindingError, MetricService, RejectionReason,
|
||||
ScopeKind, SignalType, ToolErrorKind, ToolOutcome, UpstreamOperationKind, UpstreamOutcome,
|
||||
};
|
||||
|
||||
static BINDING: OnceLock<MetricService> = OnceLock::new();
|
||||
@@ -352,11 +352,47 @@ pub fn record_limit_rejection(stage: LimitStage) {
|
||||
}
|
||||
metrics::counter!(
|
||||
"crank_runtime_limit_rejections_total",
|
||||
"stage" => stage.as_str()
|
||||
"stage" => stage.as_str(),
|
||||
"reason" => RejectionReason::Limit.as_str(),
|
||||
"scope_kind" => ScopeKind::Process.as_str()
|
||||
)
|
||||
.increment(1);
|
||||
}
|
||||
|
||||
/// Typed admission refusal with finite, low-cardinality labels only: no workspace, Agent, Tool,
|
||||
/// request id, fingerprint or arbitrary error text ever becomes a label.
|
||||
pub fn record_admission_rejection(reason: RejectionReason, scope_kind: ScopeKind) {
|
||||
if bound_family("crank_runtime_limit_rejections_total").is_none() {
|
||||
return;
|
||||
}
|
||||
metrics::counter!(
|
||||
"crank_runtime_limit_rejections_total",
|
||||
"stage" => LimitStage::Admission.as_str(),
|
||||
"reason" => reason.as_str(),
|
||||
"scope_kind" => scope_kind.as_str()
|
||||
)
|
||||
.increment(1);
|
||||
}
|
||||
|
||||
pub fn record_admission_queue_wait(mode: AdmissionModeLabel, waited_ms: u64) {
|
||||
if bound_family("crank_runtime_admission_queue_wait_seconds").is_none() {
|
||||
return;
|
||||
}
|
||||
metrics::gauge!(
|
||||
"crank_runtime_admission_queue_wait_seconds",
|
||||
"mode" => mode.as_str()
|
||||
)
|
||||
.set(waited_ms as f64 / 1000.0);
|
||||
}
|
||||
|
||||
pub fn record_admission_oldest_waiting(oldest_waiting_ms: Option<u64>) {
|
||||
if bound_family("crank_runtime_admission_oldest_waiting_seconds").is_none() {
|
||||
return;
|
||||
}
|
||||
let seconds = oldest_waiting_ms.unwrap_or_default() as f64 / 1000.0;
|
||||
metrics::gauge!("crank_runtime_admission_oldest_waiting_seconds").set(seconds);
|
||||
}
|
||||
|
||||
pub fn record_cache_outcome(outcome: CacheOutcome) {
|
||||
if bound_family("crank_runtime_cache_total").is_none() {
|
||||
return;
|
||||
|
||||
@@ -3,16 +3,17 @@
|
||||
|
||||
use super::routes::{BOTH, HTTP_ROUTE_DOMAIN, MCP};
|
||||
use crate::labels::{
|
||||
CacheOutcome, ConfirmationOutcome, DbPoolState, Exporter, HttpMethod, HttpStatusClass,
|
||||
IdempotencyOutcome, InvocationSource, LimitStage, McpMethod, McpOutcome, McpResponseMode,
|
||||
SignalType, ToolErrorKind, ToolOutcome, UpstreamOperationKind, UpstreamOutcome,
|
||||
AdmissionModeLabel, CacheOutcome, ConfirmationOutcome, DbPoolState, Exporter, HttpMethod,
|
||||
HttpStatusClass, IdempotencyOutcome, InvocationSource, LimitStage, McpMethod, McpOutcome,
|
||||
McpResponseMode, RejectionReason, ScopeKind, SignalType, ToolErrorKind, ToolOutcome,
|
||||
UpstreamOperationKind, UpstreamOutcome,
|
||||
};
|
||||
|
||||
pub const METRIC_SCHEMA_VERSION: u32 = 2;
|
||||
pub const MAX_METRIC_FAMILIES: usize = 128;
|
||||
pub const MAX_PRODUCT_LABELS_PER_FAMILY: usize = 4;
|
||||
pub const MAX_LOGICAL_SERIES_PER_PROCESS: usize = 6_285;
|
||||
pub const MAX_RENDERED_SERIES_PER_PROCESS: usize = 19_515;
|
||||
pub const MAX_LOGICAL_SERIES_PER_PROCESS: usize = 6_381;
|
||||
pub const MAX_RENDERED_SERIES_PER_PROCESS: usize = 19_611;
|
||||
pub const MAX_EXEMPLAR_SLOTS_PER_PROCESS: usize = 12_348;
|
||||
pub const MAX_EXPOSITION_BYTES: usize = 8 * 1024 * 1024;
|
||||
|
||||
@@ -179,6 +180,9 @@ const TOOL_ERRORS: &[&str] = ToolErrorKind::VALUES;
|
||||
const OPERATION_KINDS: &[&str] = UpstreamOperationKind::VALUES;
|
||||
const UPSTREAM_OUTCOMES: &[&str] = UpstreamOutcome::VALUES;
|
||||
const LIMIT_STAGES: &[&str] = LimitStage::VALUES;
|
||||
const REJECTION_REASONS: &[&str] = RejectionReason::VALUES;
|
||||
const SCOPE_KINDS: &[&str] = ScopeKind::VALUES;
|
||||
const ADMISSION_MODES: &[&str] = AdmissionModeLabel::VALUES;
|
||||
const CACHE_OUTCOMES: &[&str] = CacheOutcome::VALUES;
|
||||
const IDEMPOTENCY_OUTCOMES: &[&str] = IdempotencyOutcome::VALUES;
|
||||
const CONFIRMATION_OUTCOMES: &[&str] = ConfirmationOutcome::VALUES;
|
||||
@@ -403,13 +407,39 @@ pub(crate) const METRIC_SCHEMA: &[MetricDefinition] = &[
|
||||
"crank_runtime_limit_rejections_total",
|
||||
MetricKind::Counter,
|
||||
MetricUnit::Count,
|
||||
&["stage"],
|
||||
&[domain("stage", LIMIT_STAGES)],
|
||||
&["stage", "reason", "scope_kind"],
|
||||
&[
|
||||
domain("stage", LIMIT_STAGES),
|
||||
domain("reason", REJECTION_REASONS),
|
||||
domain("scope_kind", SCOPE_KINDS),
|
||||
],
|
||||
&[],
|
||||
BOTH,
|
||||
3,
|
||||
96,
|
||||
"Runtime executions rejected by a bounded limit.",
|
||||
),
|
||||
metric(
|
||||
"crank_runtime_admission_queue_wait_seconds",
|
||||
MetricKind::Gauge,
|
||||
MetricUnit::Seconds,
|
||||
&["mode"],
|
||||
&[domain("mode", ADMISSION_MODES)],
|
||||
&[],
|
||||
BOTH,
|
||||
2,
|
||||
"Wait of the most recently admitted execution before it received a scoped permit.",
|
||||
),
|
||||
metric(
|
||||
"crank_runtime_admission_oldest_waiting_seconds",
|
||||
MetricKind::Gauge,
|
||||
MetricUnit::Seconds,
|
||||
&[],
|
||||
&[],
|
||||
&[],
|
||||
BOTH,
|
||||
1,
|
||||
"Age of the oldest waiting admission request.",
|
||||
),
|
||||
metric(
|
||||
"crank_runtime_cache_total",
|
||||
MetricKind::Counter,
|
||||
|
||||
@@ -1,12 +1,13 @@
|
||||
use std::{collections::BTreeSet, time::Duration};
|
||||
|
||||
use crank_metrics::{
|
||||
CacheOutcome, ConfirmationOutcome, DbPoolState, Exporter, HttpMethod, HttpRoute,
|
||||
HttpStatusClass, IdempotencyOutcome, InFlightGuard, InvocationSource, LimitStage, McpMethod,
|
||||
McpOutcome, McpResponseMode, MetricService, SignalType, ToolErrorKind, ToolInvocationMetrics,
|
||||
ToolOutcome, UpstreamOperationKind, UpstreamOutcome, UpstreamRequestMetrics,
|
||||
bind_metric_service, initialize_gauges, metric_schema, record_cache_outcome,
|
||||
record_confirmation_outcome, record_export_failure, record_http_request,
|
||||
AdmissionModeLabel, CacheOutcome, ConfirmationOutcome, DbPoolState, Exporter, HttpMethod,
|
||||
HttpRoute, HttpStatusClass, IdempotencyOutcome, InFlightGuard, InvocationSource, LimitStage,
|
||||
McpMethod, McpOutcome, McpResponseMode, MetricService, RejectionReason, ScopeKind, SignalType,
|
||||
ToolErrorKind, ToolInvocationMetrics, ToolOutcome, UpstreamOperationKind, UpstreamOutcome,
|
||||
UpstreamRequestMetrics, bind_metric_service, initialize_gauges, metric_schema,
|
||||
record_admission_oldest_waiting, record_admission_queue_wait, record_admission_rejection,
|
||||
record_cache_outcome, record_confirmation_outcome, record_export_failure, record_http_request,
|
||||
record_idempotency_outcome, record_invocation_history_lost, record_limit_rejection,
|
||||
record_mcp_request, record_tool_invocation, record_upstream_request, set_catalog,
|
||||
set_db_pool_connections, set_mcp_active_sessions, set_mcp_session_metrics_fresh,
|
||||
@@ -71,6 +72,9 @@ fn schema_names_are_unique_and_labels_are_closed() {
|
||||
"state",
|
||||
"signal_type",
|
||||
"exporter",
|
||||
"reason",
|
||||
"scope_kind",
|
||||
"mode",
|
||||
];
|
||||
for metric in schema {
|
||||
assert!(
|
||||
@@ -265,6 +269,9 @@ fn every_recording_api_matches_the_declared_schema() {
|
||||
Duration::from_millis(1),
|
||||
);
|
||||
record_limit_rejection(LimitStage::Concurrency);
|
||||
record_admission_rejection(RejectionReason::Capacity, ScopeKind::Global);
|
||||
record_admission_queue_wait(AdmissionModeLabel::Synchronous, 5);
|
||||
record_admission_oldest_waiting(Some(5));
|
||||
record_cache_outcome(CacheOutcome::Hit);
|
||||
record_idempotency_outcome(IdempotencyOutcome::Replay);
|
||||
record_confirmation_outcome(ConfirmationOutcome::Required);
|
||||
|
||||
@@ -48,10 +48,10 @@ fn schema_v1_is_complete_deterministic_and_inside_the_frozen_budget() {
|
||||
|
||||
#[test]
|
||||
fn frozen_budget_edges_are_exact() {
|
||||
assert!(validate_budget(6_284, 19_514).is_ok());
|
||||
assert!(validate_budget(6_285, 19_515).is_ok());
|
||||
assert!(validate_budget(6_286, 16_000).is_err());
|
||||
assert!(validate_budget(6_000, 19_516).is_err());
|
||||
assert!(validate_budget(6_380, 19_610).is_ok());
|
||||
assert!(validate_budget(6_381, 19_611).is_ok());
|
||||
assert!(validate_budget(6_382, 19_000).is_err());
|
||||
assert!(validate_budget(6_000, 19_612).is_err());
|
||||
assert_eq!(
|
||||
crank_metrics::max_exemplar_slots(MetricService::AdminApi),
|
||||
12_348
|
||||
@@ -79,15 +79,15 @@ fn canonical_schema_validation_reports_its_category() {
|
||||
assert_eq!(
|
||||
schema_budget(MetricService::AdminApi),
|
||||
Ok(crank_metrics::SchemaBudget {
|
||||
logical_series: 6_285,
|
||||
rendered_series: 19_515
|
||||
logical_series: 6_381,
|
||||
rendered_series: 19_611
|
||||
})
|
||||
);
|
||||
assert_eq!(
|
||||
schema_budget(MetricService::McpServer),
|
||||
Ok(crank_metrics::SchemaBudget {
|
||||
logical_series: 1_083,
|
||||
rendered_series: 3_558
|
||||
logical_series: 1_179,
|
||||
rendered_series: 3_654
|
||||
})
|
||||
);
|
||||
}
|
||||
|
||||
@@ -543,22 +543,22 @@ fn root_budgets_are_per_process_only() {
|
||||
"root обязан объявлять ровно один ключ budgets"
|
||||
);
|
||||
assert!(rendered.ends_with(
|
||||
",\"budgets\":[{\"process\":\"admin_api\",\"families\":15,\"logical_series\":6285,\
|
||||
\"rendered_series\":19515,\"exemplar_slots\":12348},{\"process\":\"mcp_server\",\
|
||||
\"families\":23,\"logical_series\":1083,\"rendered_series\":3558,\"exemplar_slots\":2310}]}\n"
|
||||
",\"budgets\":[{\"process\":\"admin_api\",\"families\":17,\"logical_series\":6381,\
|
||||
\"rendered_series\":19611,\"exemplar_slots\":12348},{\"process\":\"mcp_server\",\
|
||||
\"families\":25,\"logical_series\":1179,\"rendered_series\":3654,\"exemplar_slots\":2310}]}\n"
|
||||
));
|
||||
assert_eq!(
|
||||
schema_budget(MetricService::AdminApi),
|
||||
Ok(crank_metrics::SchemaBudget {
|
||||
logical_series: 6_285,
|
||||
rendered_series: 19_515
|
||||
logical_series: 6_381,
|
||||
rendered_series: 19_611
|
||||
})
|
||||
);
|
||||
assert_eq!(
|
||||
schema_budget(MetricService::McpServer),
|
||||
Ok(crank_metrics::SchemaBudget {
|
||||
logical_series: 1_083,
|
||||
rendered_series: 3_558
|
||||
logical_series: 1_179,
|
||||
rendered_series: 3_654
|
||||
})
|
||||
);
|
||||
}
|
||||
@@ -566,11 +566,11 @@ fn root_budgets_are_per_process_only() {
|
||||
/// TD-M3 — frozen caps и границы `validate_exemplar_budget` точны.
|
||||
#[test]
|
||||
fn frozen_caps_and_edges_are_exact() {
|
||||
assert_eq!(MAX_LOGICAL_SERIES_PER_PROCESS, 6_285);
|
||||
assert_eq!(MAX_RENDERED_SERIES_PER_PROCESS, 19_515);
|
||||
assert_eq!(MAX_LOGICAL_SERIES_PER_PROCESS, 6_381);
|
||||
assert_eq!(MAX_RENDERED_SERIES_PER_PROCESS, 19_611);
|
||||
assert_eq!(MAX_EXEMPLAR_SLOTS_PER_PROCESS, 12_348);
|
||||
assert!(validate_budget(6_285, 19_515).is_ok());
|
||||
assert!(validate_budget(6_286, 19_515).is_err());
|
||||
assert!(validate_budget(6_381, 19_611).is_ok());
|
||||
assert!(validate_budget(6_382, 19_611).is_err());
|
||||
assert!(validate_exemplar_budget(12_347).is_ok());
|
||||
assert!(validate_exemplar_budget(12_348).is_ok());
|
||||
assert!(validate_exemplar_budget(12_349).is_err());
|
||||
|
||||
@@ -13,7 +13,7 @@ mod schema;
|
||||
pub use config::{ObservabilityConfig, ObservabilityConfigError, ServiceIdentity};
|
||||
pub use crank_metrics::{
|
||||
DURATION_BUCKETS_SECONDS, MetricDefinition, MetricKind, MetricService, MetricUnit,
|
||||
bind_metric_service, bound_metric_service, metric_schema,
|
||||
bind_metric_service, bound_metric_service, metric_schema, record_admission_oldest_waiting,
|
||||
};
|
||||
pub use error_reporting::{
|
||||
CriticalErrorCategory, SentryConfig, SentryConfigError, capture_critical_error,
|
||||
|
||||
@@ -7,6 +7,7 @@ publish.workspace = true
|
||||
version.workspace = true
|
||||
|
||||
[dependencies]
|
||||
async-trait = "0.1"
|
||||
crank-artifacts = { path = "../crank-artifacts" }
|
||||
crank-core = { path = "../crank-core" }
|
||||
crank-mapping = { path = "../crank-mapping" }
|
||||
|
||||
@@ -116,6 +116,7 @@ pub use model::{
|
||||
YamlImportJob, YamlImportJobCompletion, YamlImportJobId, YamlImportJobStatus,
|
||||
};
|
||||
pub use postgres::{
|
||||
AuthorizedResourceRead, BoundResourceAdmission, PostgresPoolConfig, PostgresPoolConfigError,
|
||||
PostgresRegistry,
|
||||
AdmissionLimits, AuthorizedResourceRead, BoundResourceAdmission, PostgresExecutionAdmission,
|
||||
PostgresPoolConfig, PostgresPoolConfigError, PostgresRegistry, PostgresTaskStore,
|
||||
admission_health, admission_snapshot, tasks_health,
|
||||
};
|
||||
@@ -6,6 +6,11 @@ mod artifact_cleanup_indexes_v13;
|
||||
mod artifact_metadata_v12;
|
||||
mod authority;
|
||||
mod baseline_v1;
|
||||
mod durable_tasks_v25;
|
||||
mod durable_tasks_v26;
|
||||
mod durable_tasks_v27;
|
||||
mod durable_tasks_v28;
|
||||
mod execution_admission_v24;
|
||||
mod execution_outcome_v5;
|
||||
mod import_plan_v14;
|
||||
mod master_key_identity_v7;
|
||||
@@ -35,6 +40,11 @@ mod schema_guard_v19;
|
||||
mod schema_guard_v20;
|
||||
mod schema_guard_v22;
|
||||
mod schema_guard_v23;
|
||||
mod schema_guard_v24;
|
||||
mod schema_guard_v25;
|
||||
mod schema_guard_v26;
|
||||
mod schema_guard_v27;
|
||||
mod schema_guard_v28;
|
||||
mod schema_guard_v7;
|
||||
mod schema_guard_v8;
|
||||
mod schema_guard_v9;
|
||||
|
||||
@@ -4,6 +4,11 @@ use super::agent_resource_bindings_v18;
|
||||
use super::approval_side_effects_v10;
|
||||
use super::artifact_cleanup_indexes_v13;
|
||||
use super::artifact_metadata_v12;
|
||||
use super::durable_tasks_v25;
|
||||
use super::durable_tasks_v26;
|
||||
use super::durable_tasks_v27;
|
||||
use super::durable_tasks_v28;
|
||||
use super::execution_admission_v24;
|
||||
use super::execution_outcome_v5;
|
||||
use super::import_plan_v14;
|
||||
use super::master_key_identity_v7;
|
||||
@@ -39,9 +44,10 @@ use preflight::*;
|
||||
use contract::baseline_source_digest;
|
||||
use contract::validate_descriptors;
|
||||
const MIGRATION_LOCK_ID: i64 = 0x4352_414E_4B4D_4947;
|
||||
const CURRENT_VERSION: i64 = 23;
|
||||
const CURRENT_VERSION: i64 = 28;
|
||||
const IMPLEMENTED_VERSIONS: &[i64] = &[
|
||||
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
|
||||
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
|
||||
27, 28,
|
||||
];
|
||||
const BASELINE_SOURCE_SHA256: &str =
|
||||
"eb1656fc5b4b5be9ee390d237d1d58e4b2274ae5ba9b7ba06a2f3f860dfda675";
|
||||
@@ -330,6 +336,36 @@ impl MigrationAuthority {
|
||||
prompt_dependencies_v23::SOURCE_SHA256,
|
||||
22,
|
||||
),
|
||||
expand_descriptor(
|
||||
24,
|
||||
execution_admission_v24::NAME,
|
||||
execution_admission_v24::SOURCE_SHA256,
|
||||
23,
|
||||
),
|
||||
expand_descriptor(
|
||||
25,
|
||||
durable_tasks_v25::NAME,
|
||||
durable_tasks_v25::SOURCE_SHA256,
|
||||
24,
|
||||
),
|
||||
expand_descriptor(
|
||||
26,
|
||||
durable_tasks_v26::NAME,
|
||||
durable_tasks_v26::SOURCE_SHA256,
|
||||
25,
|
||||
),
|
||||
expand_descriptor(
|
||||
27,
|
||||
durable_tasks_v27::NAME,
|
||||
durable_tasks_v27::SOURCE_SHA256,
|
||||
26,
|
||||
),
|
||||
expand_descriptor(
|
||||
28,
|
||||
durable_tasks_v28::NAME,
|
||||
durable_tasks_v28::SOURCE_SHA256,
|
||||
27,
|
||||
),
|
||||
]
|
||||
}
|
||||
pub fn validate_sequence() -> Result<(), MigrationError> {
|
||||
@@ -489,6 +525,21 @@ impl MigrationAuthority {
|
||||
if from < 23 {
|
||||
prompt_dependencies_v23::apply(&mut transaction, &Self::sequence()[22]).await?;
|
||||
}
|
||||
if from < 24 {
|
||||
execution_admission_v24::apply(&mut transaction, &Self::sequence()[23]).await?;
|
||||
}
|
||||
if from < 25 {
|
||||
durable_tasks_v25::apply(&mut transaction, &Self::sequence()[24]).await?;
|
||||
}
|
||||
if from < 26 {
|
||||
durable_tasks_v26::apply(&mut transaction, &Self::sequence()[25]).await?;
|
||||
}
|
||||
if from < 27 {
|
||||
durable_tasks_v27::apply(&mut transaction, &Self::sequence()[26]).await?;
|
||||
}
|
||||
if from < 28 {
|
||||
durable_tasks_v28::apply(&mut transaction, &Self::sequence()[27]).await?;
|
||||
}
|
||||
match inspect(&mut transaction).await? {
|
||||
MigrationPreflight::Current {
|
||||
version: CURRENT_VERSION,
|
||||
|
||||
@@ -140,6 +140,8 @@ pub(super) fn validate_descriptors(
|
||||
!= agent_resource_bindings_v18::SOURCE_SHA256
|
||||
|| sha256_hex(resource_security_revocations_v19::SOURCE.as_bytes())
|
||||
!= resource_security_revocations_v19::SOURCE_SHA256
|
||||
|| sha256_hex(execution_admission_v24::SOURCE.as_bytes())
|
||||
!= execution_admission_v24::SOURCE_SHA256
|
||||
{
|
||||
return Err(MigrationError::new(
|
||||
"invalid_contract",
|
||||
|
||||
@@ -148,6 +148,7 @@ pub(super) async fn inspect(
|
||||
owned_relations::PROMPTS,
|
||||
owned_relations::PROMPT_PUBLICATIONS,
|
||||
owned_relations::PROMPT_DEPENDENCIES,
|
||||
owned_relations::EXECUTION_ADMISSION,
|
||||
] {
|
||||
validate_required_relations(connection, relations, CURRENT_VERSION).await?;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,45 @@
|
||||
use sqlx::{Postgres, Transaction, query};
|
||||
|
||||
use super::authority::{MigrationDescriptor, MigrationError};
|
||||
|
||||
pub(super) const NAME: &str = "durable-tasks-v25";
|
||||
pub(super) const SOURCE: &str = include_str!("durable_tasks_v25.sql");
|
||||
pub(super) const SOURCE_SHA256: &str =
|
||||
"ada48bfb7d7130c84ab38217795608cd368ccb28af66faafbdfc4fc7609f67cd";
|
||||
|
||||
pub(super) async fn apply(
|
||||
transaction: &mut Transaction<'_, Postgres>,
|
||||
descriptor: &MigrationDescriptor,
|
||||
) -> Result<(), MigrationError> {
|
||||
sqlx::raw_sql(SOURCE)
|
||||
.execute(&mut **transaction)
|
||||
.await
|
||||
.map_err(|_| {
|
||||
MigrationError::new(
|
||||
"apply_failed",
|
||||
"apply.durable_tasks_v25",
|
||||
Some(25),
|
||||
"restore_known_good_backup",
|
||||
)
|
||||
})?;
|
||||
query(
|
||||
"insert into __crank_migrations (version, name, checksum, phase, compatibility)
|
||||
values ($1, $2, $3, $4, $5)",
|
||||
)
|
||||
.bind(descriptor.version)
|
||||
.bind(descriptor.name)
|
||||
.bind(&descriptor.checksum)
|
||||
.bind(descriptor.phase)
|
||||
.bind(descriptor.compatibility)
|
||||
.execute(&mut **transaction)
|
||||
.await
|
||||
.map_err(|_| {
|
||||
MigrationError::new(
|
||||
"apply_failed",
|
||||
"apply.canonical_ledger",
|
||||
Some(25),
|
||||
"restore_known_good_backup",
|
||||
)
|
||||
})?;
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,90 @@
|
||||
-- V25: durable background Tasks (Story 4.2, FR-22, FR-23).
|
||||
--
|
||||
-- Одна строка `tasks` — принятая durable работа. Идентификатор Task (UUIDv7), owner scope,
|
||||
-- authorization scope, запрошенный Tool и точная published-версия, canonical fingerprint входа,
|
||||
-- support IDs (Request/Trace/parent TraceContext независимо от sampling) и bounded envelopes
|
||||
-- закрепляются в той же PostgreSQL transaction, что и dispatch intent
|
||||
-- (`execution_admission_entries.task_id`) и его queue slot. До commit наружу не выдаётся ни ID, ни ack.
|
||||
--
|
||||
-- `scoped_key` — digest caller-ключа по полному (workspace, owner kind/id, authorization scope,
|
||||
-- operation) scope; UNIQUE по этому набору и есть защита идемпотентности. Повтор того же ключа с тем
|
||||
-- же canonical fingerprint возвращает сохранённую Task, другой fingerprint — typed conflict.
|
||||
--
|
||||
-- `retain_until` — срок хранения записи, а не execution deadline: пока запись в retention, replay
|
||||
-- находит тот же Task. Удаление terminal-записей возможно только после retain_until; queued/working/
|
||||
-- input_required/outcome_unknown не удаляются никогда ради лимита.
|
||||
--
|
||||
-- Строка не хранит credentials, bearer/prepared headers и confirmation tokens: секретные поля входа
|
||||
-- редактируются до записи, а approval хранится безопасной ссылкой.
|
||||
|
||||
create table tasks (
|
||||
task_id uuid not null,
|
||||
workspace_id text not null,
|
||||
owner_kind text not null,
|
||||
owner_id text not null,
|
||||
authorization_scope text not null,
|
||||
operation_id text not null,
|
||||
operation_version integer not null,
|
||||
scoped_key text not null,
|
||||
input_fingerprint text not null,
|
||||
request_id text not null,
|
||||
trace_id text not null,
|
||||
traceparent text not null,
|
||||
trace_sampled boolean not null,
|
||||
policy_mode text not null,
|
||||
approval_reference text,
|
||||
state text not null,
|
||||
version integer not null default 1,
|
||||
attempts integer not null default 0,
|
||||
input_envelope jsonb not null,
|
||||
progress_envelope jsonb,
|
||||
result_envelope jsonb,
|
||||
error_envelope jsonb,
|
||||
execution_deadline timestamptz not null,
|
||||
retain_until timestamptz not null,
|
||||
created_at timestamptz not null default now(),
|
||||
updated_at timestamptz not null default now(),
|
||||
constraint tasks_pkey primary key (task_id),
|
||||
constraint tasks_workspace_check check (octet_length(workspace_id) between 1 and 160),
|
||||
constraint tasks_owner_kind_check check (owner_kind in ('agent', 'admin')),
|
||||
constraint tasks_owner_check check (octet_length(owner_id) between 1 and 160),
|
||||
constraint tasks_authorization_scope_check check (
|
||||
octet_length(authorization_scope) between 1 and 160
|
||||
),
|
||||
constraint tasks_operation_check check (octet_length(operation_id) between 1 and 160),
|
||||
constraint tasks_operation_version_check check (operation_version >= 1),
|
||||
constraint tasks_scoped_key_check check (octet_length(scoped_key) between 16 and 128),
|
||||
constraint tasks_fingerprint_check check (octet_length(input_fingerprint) = 64),
|
||||
constraint tasks_request_check check (octet_length(request_id) between 1 and 128),
|
||||
constraint tasks_trace_check check (octet_length(trace_id) = 32),
|
||||
constraint tasks_traceparent_check check (octet_length(traceparent) = 55),
|
||||
constraint tasks_policy_mode_check check (
|
||||
policy_mode in ('synchronous', 'background', 'adaptive')
|
||||
),
|
||||
constraint tasks_state_check check (
|
||||
state in ('queued', 'working', 'input_required', 'outcome_unknown',
|
||||
'completed', 'failed', 'cancelled')
|
||||
),
|
||||
constraint tasks_lifecycle_check check (version >= 1 and attempts >= 0),
|
||||
constraint tasks_retention_check check (retain_until >= execution_deadline),
|
||||
constraint tasks_approval_check check (
|
||||
approval_reference is null or octet_length(approval_reference) between 1 and 160
|
||||
)
|
||||
);
|
||||
|
||||
create unique index tasks_scoped_key_uidx
|
||||
on tasks (workspace_id, owner_kind, owner_id, authorization_scope, operation_id, scoped_key);
|
||||
|
||||
create index tasks_retention_idx on tasks (state, retain_until, task_id);
|
||||
|
||||
create index tasks_deadline_idx on tasks (state, execution_deadline, task_id);
|
||||
|
||||
-- Dispatch intent: прежняя reserved-строка admission становится точкой связи Task и capacity.
|
||||
-- FK без cascade: удаление принятой Task не маскируется housekeeping-удалением intent.
|
||||
alter table execution_admission_entries
|
||||
add column task_id uuid,
|
||||
add constraint execution_admission_entries_task_fkey
|
||||
foreign key (task_id) references tasks (task_id);
|
||||
|
||||
create unique index execution_admission_entries_task_uidx
|
||||
on execution_admission_entries (task_id) where task_id is not null;
|
||||
@@ -0,0 +1,45 @@
|
||||
use sqlx::{Postgres, Transaction, query};
|
||||
|
||||
use super::authority::{MigrationDescriptor, MigrationError};
|
||||
|
||||
pub(super) const NAME: &str = "durable-tasks-v26";
|
||||
pub(super) const SOURCE: &str = include_str!("durable_tasks_v26.sql");
|
||||
pub(super) const SOURCE_SHA256: &str =
|
||||
"6dcbf9990deabb3984a333acbfc3cb490cfc886c2ec30093e3b46d9113616089";
|
||||
|
||||
pub(super) async fn apply(
|
||||
transaction: &mut Transaction<'_, Postgres>,
|
||||
descriptor: &MigrationDescriptor,
|
||||
) -> Result<(), MigrationError> {
|
||||
sqlx::raw_sql(SOURCE)
|
||||
.execute(&mut **transaction)
|
||||
.await
|
||||
.map_err(|_| {
|
||||
MigrationError::new(
|
||||
"apply_failed",
|
||||
"apply.durable_tasks_v26",
|
||||
Some(26),
|
||||
"restore_known_good_backup",
|
||||
)
|
||||
})?;
|
||||
query(
|
||||
"insert into __crank_migrations (version, name, checksum, phase, compatibility)
|
||||
values ($1, $2, $3, $4, $5)",
|
||||
)
|
||||
.bind(descriptor.version)
|
||||
.bind(descriptor.name)
|
||||
.bind(&descriptor.checksum)
|
||||
.bind(descriptor.phase)
|
||||
.bind(descriptor.compatibility)
|
||||
.execute(&mut **transaction)
|
||||
.await
|
||||
.map_err(|_| {
|
||||
MigrationError::new(
|
||||
"apply_failed",
|
||||
"apply.durable_tasks_v26",
|
||||
Some(26),
|
||||
"restore_known_good_backup",
|
||||
)
|
||||
})?;
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
-- V26: PostgreSQL lease/fencing/CAS additions for durable background Tasks (Story 4.3).
|
||||
alter table tasks add column if not exists fence bigint not null default 0;
|
||||
alter table tasks add column if not exists lease_owner text;
|
||||
alter table tasks add column if not exists lease_until timestamptz;
|
||||
alter table tasks add column if not exists current_attempt_id text;
|
||||
alter table tasks add column if not exists dispatch_started_at timestamptz;
|
||||
@@ -0,0 +1,45 @@
|
||||
use sqlx::{Postgres, Transaction, query};
|
||||
|
||||
use super::authority::{MigrationDescriptor, MigrationError};
|
||||
|
||||
pub(super) const NAME: &str = "durable-tasks-v27";
|
||||
pub(super) const SOURCE: &str = include_str!("durable_tasks_v27.sql");
|
||||
pub(super) const SOURCE_SHA256: &str =
|
||||
"a3c5335cbf81c244359faaee993487ae132d8b3be6b9c63fa322788021273dc8";
|
||||
|
||||
pub(super) async fn apply(
|
||||
transaction: &mut Transaction<'_, Postgres>,
|
||||
descriptor: &MigrationDescriptor,
|
||||
) -> Result<(), MigrationError> {
|
||||
sqlx::raw_sql(SOURCE)
|
||||
.execute(&mut **transaction)
|
||||
.await
|
||||
.map_err(|_| {
|
||||
MigrationError::new(
|
||||
"apply_failed",
|
||||
"apply.durable_tasks_v27",
|
||||
Some(27),
|
||||
"restore_known_good_backup",
|
||||
)
|
||||
})?;
|
||||
query(
|
||||
"insert into __crank_migrations (version, name, checksum, phase, compatibility)
|
||||
values ($1, $2, $3, $4, $5)",
|
||||
)
|
||||
.bind(descriptor.version)
|
||||
.bind(descriptor.name)
|
||||
.bind(&descriptor.checksum)
|
||||
.bind(descriptor.phase)
|
||||
.bind(descriptor.compatibility)
|
||||
.execute(&mut **transaction)
|
||||
.await
|
||||
.map_err(|_| {
|
||||
MigrationError::new(
|
||||
"apply_failed",
|
||||
"apply.durable_tasks_v27",
|
||||
Some(27),
|
||||
"restore_known_good_backup",
|
||||
)
|
||||
})?;
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
-- V27: encrypted executable Task input (Story 4.3).
|
||||
alter table tasks add column if not exists executable_input_ciphertext text;
|
||||
alter table tasks add column if not exists executable_input_key_version text;
|
||||
alter table tasks add column if not exists executable_input_master_key_epoch bigint;
|
||||
|
||||
alter table tasks add constraint tasks_executable_input_key_version_check check (
|
||||
executable_input_ciphertext is null
|
||||
or (executable_input_key_version is not null and octet_length(executable_input_key_version) between 1 and 64)
|
||||
);
|
||||
|
||||
alter table tasks add column if not exists target_executable_input_ciphertext text;
|
||||
alter table tasks add column if not exists target_executable_input_key_version text;
|
||||
alter table tasks add column if not exists target_executable_input_master_key_epoch bigint;
|
||||
|
||||
alter table tasks add constraint tasks_executable_input_epoch_check check (
|
||||
executable_input_ciphertext is null
|
||||
or (executable_input_master_key_epoch is not null
|
||||
and executable_input_master_key_epoch >= 1)
|
||||
);
|
||||
@@ -0,0 +1,45 @@
|
||||
use sqlx::{Postgres, Transaction, query};
|
||||
|
||||
use super::authority::{MigrationDescriptor, MigrationError};
|
||||
|
||||
pub(super) const NAME: &str = "durable-tasks-v28";
|
||||
pub(super) const SOURCE: &str = include_str!("durable_tasks_v28.sql");
|
||||
pub(super) const SOURCE_SHA256: &str =
|
||||
"4dc77739c2ea1e32a4b00abd70df0f00fd82b7cf7933372f869f2c1e997a3676";
|
||||
|
||||
pub(super) async fn apply(
|
||||
transaction: &mut Transaction<'_, Postgres>,
|
||||
descriptor: &MigrationDescriptor,
|
||||
) -> Result<(), MigrationError> {
|
||||
sqlx::raw_sql(SOURCE)
|
||||
.execute(&mut **transaction)
|
||||
.await
|
||||
.map_err(|_| {
|
||||
MigrationError::new(
|
||||
"apply_failed",
|
||||
"apply.durable_tasks_v28",
|
||||
Some(28),
|
||||
"restore_known_good_backup",
|
||||
)
|
||||
})?;
|
||||
query(
|
||||
"insert into __crank_migrations (version, name, checksum, phase, compatibility)
|
||||
values ($1, $2, $3, $4, $5)",
|
||||
)
|
||||
.bind(descriptor.version)
|
||||
.bind(descriptor.name)
|
||||
.bind(&descriptor.checksum)
|
||||
.bind(descriptor.phase)
|
||||
.bind(descriptor.compatibility)
|
||||
.execute(&mut **transaction)
|
||||
.await
|
||||
.map_err(|_| {
|
||||
MigrationError::new(
|
||||
"apply_failed",
|
||||
"apply.durable_tasks_v28",
|
||||
Some(28),
|
||||
"restore_known_good_backup",
|
||||
)
|
||||
})?;
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
-- V28: typed Platform API key authority reference of a durable Task (Story 4.3).
|
||||
-- Only the immutable key identifier is stored, never the bearer secret.
|
||||
alter table tasks add column if not exists platform_api_key_id text;
|
||||
|
||||
alter table tasks add constraint tasks_platform_api_key_id_check check (
|
||||
platform_api_key_id is null
|
||||
or octet_length(platform_api_key_id) between 1 and 160
|
||||
);
|
||||
@@ -0,0 +1,45 @@
|
||||
use sqlx::{Postgres, Transaction, query};
|
||||
|
||||
use super::authority::{MigrationDescriptor, MigrationError};
|
||||
|
||||
pub(super) const NAME: &str = "execution-admission-v24";
|
||||
pub(super) const SOURCE: &str = include_str!("execution_admission_v24.sql");
|
||||
pub(super) const SOURCE_SHA256: &str =
|
||||
"efe021ebcd68bbed64edaa1e90c3a851f7b167b94ba65d88f525d58160f02681";
|
||||
|
||||
pub(super) async fn apply(
|
||||
transaction: &mut Transaction<'_, Postgres>,
|
||||
descriptor: &MigrationDescriptor,
|
||||
) -> Result<(), MigrationError> {
|
||||
sqlx::raw_sql(SOURCE)
|
||||
.execute(&mut **transaction)
|
||||
.await
|
||||
.map_err(|_| {
|
||||
MigrationError::new(
|
||||
"apply_failed",
|
||||
"apply.execution_admission_v24",
|
||||
Some(24),
|
||||
"restore_known_good_backup",
|
||||
)
|
||||
})?;
|
||||
query(
|
||||
"insert into __crank_migrations (version, name, checksum, phase, compatibility)
|
||||
values ($1, $2, $3, $4, $5)",
|
||||
)
|
||||
.bind(descriptor.version)
|
||||
.bind(descriptor.name)
|
||||
.bind(&descriptor.checksum)
|
||||
.bind(descriptor.phase)
|
||||
.bind(descriptor.compatibility)
|
||||
.execute(&mut **transaction)
|
||||
.await
|
||||
.map_err(|_| {
|
||||
MigrationError::new(
|
||||
"apply_failed",
|
||||
"apply.canonical_ledger",
|
||||
Some(24),
|
||||
"restore_known_good_backup",
|
||||
)
|
||||
})?;
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
-- V24: authoritative execution admission state (Story 4.1, FR-21, FR-24).
|
||||
--
|
||||
-- Один deployment-wide admission: PostgreSQL хранит cursor/fairness state, ожидающие тикеты,
|
||||
-- выданные permits и durable enqueue decisions, поэтому несколько процессов делят общий бюджет.
|
||||
--
|
||||
-- `execution_admission_entries` — bounded набор: waiting (ожидает capacity), executing (scoped
|
||||
-- permit выдан, держится до явного release) и reserved (durable enqueue decision с зарезервированным
|
||||
-- queue slot; не исполняется и не рекламируется как Task до Story 4.2).
|
||||
--
|
||||
-- Строка не хранит ни credentials, ни connection/session id, ни prepared headers, ни тело запроса:
|
||||
-- quota key — (workspace, agent) и (workspace, operation) без version. `operation_version` пишется
|
||||
-- только как pin исполняемых semantics и не участвует в квотах.
|
||||
--
|
||||
-- `expires_at` — абсолютный deadline. Queue decisions без dispatch можно expire по deadline; активный
|
||||
-- permit НЕ освобождается по TTL (иначе paused/crashed owner обойдёт global limit): его снимает только
|
||||
-- явный release/cancel владельца.
|
||||
|
||||
create table execution_admission_controllers (
|
||||
workspace_id text not null,
|
||||
cursor_agent text,
|
||||
cursor_agent_credit integer not null default 0,
|
||||
cursor_tool text,
|
||||
cursor_tool_credit integer not null default 0,
|
||||
updated_at timestamptz not null default now(),
|
||||
constraint execution_admission_controllers_pkey primary key (workspace_id),
|
||||
constraint execution_admission_controllers_workspace_check check (
|
||||
octet_length(workspace_id) between 1 and 160
|
||||
),
|
||||
constraint execution_admission_controllers_agent_credit_check check (
|
||||
cursor_agent_credit between 0 and 64
|
||||
),
|
||||
constraint execution_admission_controllers_tool_credit_check check (
|
||||
cursor_tool_credit between 0 and 64
|
||||
)
|
||||
);
|
||||
|
||||
create table execution_admission_entries (
|
||||
ticket_id bigint generated always as identity,
|
||||
workspace_id text not null,
|
||||
agent_key text not null,
|
||||
operation_id text not null,
|
||||
operation_version integer not null,
|
||||
mode text not null,
|
||||
policy_mode text not null,
|
||||
state text not null,
|
||||
owner_token text not null,
|
||||
fingerprint text not null,
|
||||
created_at timestamptz not null default now(),
|
||||
expires_at timestamptz not null,
|
||||
granted_at timestamptz,
|
||||
constraint execution_admission_entries_pkey primary key (ticket_id),
|
||||
constraint execution_admission_entries_workspace_check check (
|
||||
octet_length(workspace_id) between 1 and 160
|
||||
),
|
||||
constraint execution_admission_entries_agent_check check (
|
||||
octet_length(agent_key) between 1 and 160
|
||||
),
|
||||
constraint execution_admission_entries_operation_check check (
|
||||
octet_length(operation_id) between 1 and 160
|
||||
),
|
||||
constraint execution_admission_entries_version_check check (operation_version >= 1),
|
||||
constraint execution_admission_entries_mode_check check (
|
||||
mode in ('synchronous', 'background')
|
||||
),
|
||||
constraint execution_admission_entries_policy_mode_check check (
|
||||
policy_mode in ('synchronous', 'background', 'adaptive')
|
||||
),
|
||||
constraint execution_admission_entries_state_check check (
|
||||
state in ('waiting', 'executing', 'reserved')
|
||||
),
|
||||
constraint execution_admission_entries_owner_check check (
|
||||
octet_length(owner_token) between 1 and 64
|
||||
),
|
||||
constraint execution_admission_entries_fingerprint_check check (
|
||||
octet_length(fingerprint) between 1 and 128
|
||||
),
|
||||
constraint execution_admission_entries_reserved_mode_check check (
|
||||
state <> 'reserved' or mode = 'background'
|
||||
)
|
||||
);
|
||||
|
||||
create unique index execution_admission_entries_owner_uidx
|
||||
on execution_admission_entries (owner_token);
|
||||
|
||||
create index execution_admission_entries_state_idx
|
||||
on execution_admission_entries (state, workspace_id, ticket_id);
|
||||
|
||||
create index execution_admission_entries_agent_idx
|
||||
on execution_admission_entries (state, workspace_id, agent_key);
|
||||
|
||||
create index execution_admission_entries_operation_idx
|
||||
on execution_admission_entries (state, workspace_id, operation_id);
|
||||
@@ -55,6 +55,11 @@ pub(super) const PROMPT_PUBLICATIONS: &[&str] = &["prompt_publications", "agent_
|
||||
pub(super) const PROMPT_DEPENDENCIES: &[&str] =
|
||||
&["prompt_dependencies", "prompt_message_resource_refs"];
|
||||
|
||||
pub(super) const EXECUTION_ADMISSION: &[&str] = &[
|
||||
"execution_admission_controllers",
|
||||
"execution_admission_entries",
|
||||
];
|
||||
|
||||
pub(super) const ARTIFACT_METADATA: &[&str] = &["artifact_blobs", "artifact_sources"];
|
||||
|
||||
pub(super) const IMPORT_PLAN: &[&str] = &["import_plans", "import_plan_applications"];
|
||||
|
||||
@@ -468,6 +468,53 @@ pub(super) async fn validate_schema_fingerprint(
|
||||
} else {
|
||||
super::schema_guard_v23::validate_v23_prompt_dependencies(connection).await?;
|
||||
}
|
||||
if current_version < 24 {
|
||||
if !super::schema_guard_v24::validate_v24_absent(connection).await? {
|
||||
return Err(schema_error(current_version));
|
||||
}
|
||||
} else {
|
||||
super::schema_guard_v24::validate_v24_execution_admission(connection, current_version)
|
||||
.await?;
|
||||
}
|
||||
if current_version < 25 {
|
||||
if !super::schema_guard_v25::validate_v25_absent(connection).await? {
|
||||
return Err(schema_error(current_version));
|
||||
}
|
||||
if !super::schema_guard_v26::validate_v26_absent(connection).await? {
|
||||
return Err(schema_error(current_version));
|
||||
}
|
||||
if !super::schema_guard_v27::validate_v27_absent(connection).await? {
|
||||
return Err(schema_error(current_version));
|
||||
}
|
||||
if !super::schema_guard_v28::validate_v28_absent(connection).await? {
|
||||
return Err(schema_error(current_version));
|
||||
}
|
||||
} else if current_version < 26 {
|
||||
super::schema_guard_v25::validate_v25_durable_tasks(connection).await?;
|
||||
if !super::schema_guard_v26::validate_v26_absent(connection).await? {
|
||||
return Err(schema_error(current_version));
|
||||
}
|
||||
if !super::schema_guard_v28::validate_v28_absent(connection).await? {
|
||||
return Err(schema_error(current_version));
|
||||
}
|
||||
} else if current_version < 27 {
|
||||
super::schema_guard_v26::validate_v26_durable_tasks(connection).await?;
|
||||
if !super::schema_guard_v27::validate_v27_absent(connection).await? {
|
||||
return Err(schema_error(current_version));
|
||||
}
|
||||
if !super::schema_guard_v28::validate_v28_absent(connection).await? {
|
||||
return Err(schema_error(current_version));
|
||||
}
|
||||
} else if current_version < 28 {
|
||||
super::schema_guard_v26::validate_v26_base_columns(connection).await?;
|
||||
super::schema_guard_v27::validate_v27_durable_tasks(connection).await?;
|
||||
if !super::schema_guard_v28::validate_v28_absent(connection).await? {
|
||||
return Err(schema_error(current_version));
|
||||
}
|
||||
} else {
|
||||
super::schema_guard_v26::validate_v26_base_columns(connection).await?;
|
||||
super::schema_guard_v28::validate_v28_durable_tasks(connection).await?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
||||
@@ -51,6 +51,8 @@ pub(crate) const OWNED_RELATIONS: &[&str] = &[
|
||||
"prompt_messages",
|
||||
"prompt_dependencies",
|
||||
"prompt_message_resource_refs",
|
||||
"execution_admission_controllers",
|
||||
"execution_admission_entries",
|
||||
];
|
||||
|
||||
pub(crate) const REQUIRED_COLUMNS: &[(&str, &[&str])] = &[
|
||||
|
||||
@@ -0,0 +1,277 @@
|
||||
//! V24 schema guard: authoritative execution admission state (Story 4.1, FR-21/FR-24).
|
||||
//!
|
||||
//! Схема V24 либо полностью отсутствует (миграция ещё не применена), либо присутствует ровно в
|
||||
//! ожидаемой форме: controller-row с weighted round-robin cursor и bounded entries с закрытым
|
||||
//! словарём mode/policy_mode/state, уникальным owner token и индексами квот.
|
||||
|
||||
use sqlx::{PgConnection, Row, query};
|
||||
|
||||
use super::authority::MigrationError;
|
||||
use super::schema_guard::relation_exists;
|
||||
|
||||
const CONTROLLERS: &str = "execution_admission_controllers";
|
||||
const ENTRIES: &str = "execution_admission_entries";
|
||||
|
||||
const OWNED_RELATIONS: &[&str] = &[CONTROLLERS, ENTRIES];
|
||||
|
||||
const CONTROLLER_COLUMNS: &[(&str, &str, bool)] = &[
|
||||
("workspace_id", "text", false),
|
||||
("cursor_agent", "text", true),
|
||||
("cursor_agent_credit", "integer", false),
|
||||
("cursor_tool", "text", true),
|
||||
("cursor_tool_credit", "integer", false),
|
||||
("updated_at", "timestamp with time zone", false),
|
||||
];
|
||||
|
||||
const ENTRY_COLUMNS: &[(&str, &str, bool)] = &[
|
||||
("ticket_id", "bigint", false),
|
||||
("workspace_id", "text", false),
|
||||
("agent_key", "text", false),
|
||||
("operation_id", "text", false),
|
||||
("operation_version", "integer", false),
|
||||
("mode", "text", false),
|
||||
("policy_mode", "text", false),
|
||||
("state", "text", false),
|
||||
("owner_token", "text", false),
|
||||
("fingerprint", "text", false),
|
||||
("created_at", "timestamp with time zone", false),
|
||||
("expires_at", "timestamp with time zone", false),
|
||||
("granted_at", "timestamp with time zone", true),
|
||||
];
|
||||
|
||||
/// V25 adds the nullable Task dispatch-intent link to the same reserved row. At version 24 the
|
||||
/// column must not exist yet, so the guard validates the shape of the version it describes.
|
||||
fn entry_columns(current_version: i64) -> Vec<(&'static str, &'static str, bool)> {
|
||||
let mut columns = ENTRY_COLUMNS.to_vec();
|
||||
if current_version >= 25 {
|
||||
columns.push(("task_id", "uuid", true));
|
||||
}
|
||||
columns
|
||||
}
|
||||
|
||||
fn constraint_count(table: &str, current_version: i64) -> Option<usize> {
|
||||
match table {
|
||||
CONTROLLERS => Some(4),
|
||||
ENTRIES if current_version >= 25 => Some(12),
|
||||
ENTRIES => Some(11),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
const UNIQUE_INDEXES: &[&str] = &["execution_admission_entries_owner_uidx"];
|
||||
|
||||
fn v24_error(stage: &'static str) -> MigrationError {
|
||||
MigrationError::new(
|
||||
"partial_sequence",
|
||||
stage,
|
||||
Some(24),
|
||||
"restore_known_good_backup",
|
||||
)
|
||||
}
|
||||
|
||||
/// Схема V24 отсутствует целиком (для current_version < 24).
|
||||
pub(super) async fn validate_v24_absent(
|
||||
connection: &mut PgConnection,
|
||||
) -> Result<bool, MigrationError> {
|
||||
for relation in OWNED_RELATIONS {
|
||||
if relation_exists(connection, relation).await? {
|
||||
return Ok(false);
|
||||
}
|
||||
}
|
||||
for index in UNIQUE_INDEXES {
|
||||
if index_exists(connection, index).await? {
|
||||
return Ok(false);
|
||||
}
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
/// Схема V24 присутствует в ожидаемой форме (для current_version >= 24).
|
||||
pub(super) async fn validate_v24_execution_admission(
|
||||
connection: &mut PgConnection,
|
||||
current_version: i64,
|
||||
) -> Result<(), MigrationError> {
|
||||
for relation in OWNED_RELATIONS {
|
||||
if !relation_exists(connection, relation).await? {
|
||||
return Err(v24_error("v24.relations"));
|
||||
}
|
||||
}
|
||||
let tables = [
|
||||
(CONTROLLERS, CONTROLLER_COLUMNS.to_vec()),
|
||||
(ENTRIES, entry_columns(current_version)),
|
||||
];
|
||||
for (table, columns) in tables {
|
||||
validate_columns(connection, table, &columns).await?;
|
||||
}
|
||||
for table in [CONTROLLERS, ENTRIES] {
|
||||
let expected = constraint_count(table, current_version).unwrap_or_default();
|
||||
let count: i64 = query(
|
||||
"select count(*)::bigint as count
|
||||
from pg_catalog.pg_constraint c
|
||||
join pg_catalog.pg_class t on t.oid = c.conrelid
|
||||
join pg_catalog.pg_namespace n on n.oid = t.relnamespace
|
||||
where n.nspname = current_schema() and t.relname = $1",
|
||||
)
|
||||
.bind(table)
|
||||
.fetch_one(&mut *connection)
|
||||
.await
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?
|
||||
.try_get("count")
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?;
|
||||
if count != i64::try_from(expected).unwrap_or_default() {
|
||||
return Err(v24_error("v24.constraints"));
|
||||
}
|
||||
}
|
||||
for (table, constraint) in [
|
||||
(CONTROLLERS, "execution_admission_controllers_pkey"),
|
||||
(ENTRIES, "execution_admission_entries_pkey"),
|
||||
(ENTRIES, "execution_admission_entries_state_check"),
|
||||
] {
|
||||
if !constraint_exists(connection, table, constraint).await? {
|
||||
return Err(v24_error("v24.constraint_missing"));
|
||||
}
|
||||
}
|
||||
if !normalized_expression(
|
||||
connection,
|
||||
ENTRIES,
|
||||
"execution_admission_entries_state_check",
|
||||
)
|
||||
.await?
|
||||
.is_some_and(|expression| {
|
||||
super::schema_guard::enum_constraint_matches(
|
||||
&expression,
|
||||
"state",
|
||||
&["waiting", "executing", "reserved"],
|
||||
)
|
||||
}) {
|
||||
return Err(v24_error("v24.state_vocabulary"));
|
||||
}
|
||||
for index in UNIQUE_INDEXES {
|
||||
let unique = index_unique(connection, index).await?;
|
||||
if unique != Some(true) {
|
||||
return Err(v24_error("v24.indexes"));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn validate_columns(
|
||||
connection: &mut PgConnection,
|
||||
table: &str,
|
||||
columns: &[(&str, &str, bool)],
|
||||
) -> Result<(), MigrationError> {
|
||||
let count: i64 = query(
|
||||
"select count(*)::bigint as count from information_schema.columns
|
||||
where table_schema = current_schema() and table_name = $1",
|
||||
)
|
||||
.bind(table)
|
||||
.fetch_one(&mut *connection)
|
||||
.await
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?
|
||||
.try_get("count")
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?;
|
||||
if count != i64::try_from(columns.len()).unwrap_or_default() {
|
||||
return Err(v24_error("v24.columns"));
|
||||
}
|
||||
for (column, data_type, nullable) in columns {
|
||||
let row = query(
|
||||
"select data_type, is_nullable from information_schema.columns
|
||||
where table_schema = current_schema() and table_name = $1 and column_name = $2",
|
||||
)
|
||||
.bind(table)
|
||||
.bind(column)
|
||||
.fetch_optional(&mut *connection)
|
||||
.await
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?;
|
||||
let valid = row.is_some_and(|row| {
|
||||
row.try_get::<String, _>("data_type").ok().as_deref() == Some(*data_type)
|
||||
&& row.try_get::<String, _>("is_nullable").ok().as_deref()
|
||||
== Some(if *nullable { "YES" } else { "NO" })
|
||||
});
|
||||
if !valid {
|
||||
return Err(v24_error("v24.columns"));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn constraint_exists(
|
||||
connection: &mut PgConnection,
|
||||
table: &str,
|
||||
constraint: &str,
|
||||
) -> Result<bool, MigrationError> {
|
||||
query(
|
||||
"select exists (
|
||||
select 1 from pg_catalog.pg_constraint c
|
||||
join pg_catalog.pg_class t on t.oid = c.conrelid
|
||||
join pg_catalog.pg_namespace n on n.oid = t.relnamespace
|
||||
where n.nspname = current_schema() and t.relname = $1 and c.conname = $2
|
||||
) as present",
|
||||
)
|
||||
.bind(table)
|
||||
.bind(constraint)
|
||||
.fetch_one(&mut *connection)
|
||||
.await
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?
|
||||
.try_get::<bool, _>("present")
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))
|
||||
}
|
||||
|
||||
async fn normalized_expression(
|
||||
connection: &mut PgConnection,
|
||||
table: &str,
|
||||
constraint: &str,
|
||||
) -> Result<Option<String>, MigrationError> {
|
||||
let row = query(
|
||||
"select pg_get_expr(c.conbin, c.conrelid) as expression
|
||||
from pg_catalog.pg_constraint c
|
||||
join pg_catalog.pg_class t on t.oid = c.conrelid
|
||||
join pg_catalog.pg_namespace n on n.oid = t.relnamespace
|
||||
where n.nspname = current_schema() and t.relname = $1 and c.conname = $2
|
||||
and c.contype = 'c'",
|
||||
)
|
||||
.bind(table)
|
||||
.bind(constraint)
|
||||
.fetch_optional(&mut *connection)
|
||||
.await
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?;
|
||||
Ok(row.and_then(|row| row.try_get::<String, _>("expression").ok()))
|
||||
}
|
||||
|
||||
async fn index_exists(connection: &mut PgConnection, index: &str) -> Result<bool, MigrationError> {
|
||||
query(
|
||||
"select exists (
|
||||
select 1 from pg_catalog.pg_class idx
|
||||
join pg_catalog.pg_namespace n on n.oid = idx.relnamespace
|
||||
where n.nspname = current_schema() and idx.relname = $1
|
||||
) as present",
|
||||
)
|
||||
.bind(index)
|
||||
.fetch_one(&mut *connection)
|
||||
.await
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?
|
||||
.try_get::<bool, _>("present")
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))
|
||||
}
|
||||
|
||||
async fn index_unique(
|
||||
connection: &mut PgConnection,
|
||||
index: &str,
|
||||
) -> Result<Option<bool>, MigrationError> {
|
||||
let row = query(
|
||||
"select i.indisunique, i.indisvalid
|
||||
from pg_catalog.pg_index i
|
||||
join pg_catalog.pg_class idx on idx.oid = i.indexrelid
|
||||
join pg_catalog.pg_namespace n on n.oid = idx.relnamespace
|
||||
where n.nspname = current_schema() and idx.relname = $1",
|
||||
)
|
||||
.bind(index)
|
||||
.fetch_optional(&mut *connection)
|
||||
.await
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?;
|
||||
Ok(row.and_then(|row| {
|
||||
let unique = row.try_get::<bool, _>("indisunique").ok()?;
|
||||
let valid = row.try_get::<bool, _>("indisvalid").ok()?;
|
||||
Some(unique && valid)
|
||||
}))
|
||||
}
|
||||
@@ -0,0 +1,247 @@
|
||||
//! V25 schema guard: durable background Tasks (Story 4.2, FR-22/FR-23).
|
||||
//!
|
||||
//! Схема V25 либо полностью отсутствует (миграция ещё не применена), либо присутствует ровно в
|
||||
//! ожидаемой форме: таблица `tasks` с закрытым словарём state/policy_mode и scoped uniqueness, плюс
|
||||
//! nullable `task_id` на существующей reserved-строке admission с FK и UNIQUE-индексом.
|
||||
|
||||
use sqlx::{PgConnection, Row, query};
|
||||
|
||||
use super::authority::MigrationError;
|
||||
use super::schema_guard::relation_exists;
|
||||
|
||||
const TASKS: &str = "tasks";
|
||||
const ENTRIES: &str = "execution_admission_entries";
|
||||
const SCOPED_INDEX: &str = "tasks_scoped_key_uidx";
|
||||
const TASK_INDEX: &str = "execution_admission_entries_task_uidx";
|
||||
const TASK_FK: &str = "execution_admission_entries_task_fkey";
|
||||
|
||||
const TASK_COLUMNS: &[(&str, &str, bool)] = &[
|
||||
("task_id", "uuid", false),
|
||||
("workspace_id", "text", false),
|
||||
("owner_kind", "text", false),
|
||||
("owner_id", "text", false),
|
||||
("authorization_scope", "text", false),
|
||||
("operation_id", "text", false),
|
||||
("operation_version", "integer", false),
|
||||
("scoped_key", "text", false),
|
||||
("input_fingerprint", "text", false),
|
||||
("request_id", "text", false),
|
||||
("trace_id", "text", false),
|
||||
("traceparent", "text", false),
|
||||
("trace_sampled", "boolean", false),
|
||||
("policy_mode", "text", false),
|
||||
("approval_reference", "text", true),
|
||||
("state", "text", false),
|
||||
("version", "integer", false),
|
||||
("attempts", "integer", false),
|
||||
("input_envelope", "jsonb", false),
|
||||
("progress_envelope", "jsonb", true),
|
||||
("result_envelope", "jsonb", true),
|
||||
("error_envelope", "jsonb", true),
|
||||
("execution_deadline", "timestamp with time zone", false),
|
||||
("retain_until", "timestamp with time zone", false),
|
||||
("created_at", "timestamp with time zone", false),
|
||||
("updated_at", "timestamp with time zone", false),
|
||||
];
|
||||
|
||||
fn v25_error(stage: &'static str) -> MigrationError {
|
||||
MigrationError::new(
|
||||
"partial_sequence",
|
||||
stage,
|
||||
Some(25),
|
||||
"restore_known_good_backup",
|
||||
)
|
||||
}
|
||||
|
||||
/// Схема V25 отсутствует целиком (для current_version < 25).
|
||||
pub(super) async fn validate_v25_absent(
|
||||
connection: &mut PgConnection,
|
||||
) -> Result<bool, MigrationError> {
|
||||
if relation_exists(connection, TASKS).await? {
|
||||
return Ok(false);
|
||||
}
|
||||
if super::schema_guard::column_exists(connection, ENTRIES, "task_id").await? {
|
||||
return Ok(false);
|
||||
}
|
||||
for index in [SCOPED_INDEX, TASK_INDEX] {
|
||||
if index_exists(connection, index).await? {
|
||||
return Ok(false);
|
||||
}
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
/// Схема V25 присутствует в ожидаемой форме (для current_version >= 25).
|
||||
pub(super) async fn validate_v25_durable_tasks(
|
||||
connection: &mut PgConnection,
|
||||
) -> Result<(), MigrationError> {
|
||||
if !relation_exists(connection, TASKS).await? {
|
||||
return Err(v25_error("v25.relations"));
|
||||
}
|
||||
let count: i64 = query(
|
||||
"select count(*)::bigint as count from information_schema.columns
|
||||
where table_schema = current_schema() and table_name = $1",
|
||||
)
|
||||
.bind(TASKS)
|
||||
.fetch_one(&mut *connection)
|
||||
.await
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?
|
||||
.try_get("count")
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?;
|
||||
if count != i64::try_from(TASK_COLUMNS.len()).unwrap_or_default() {
|
||||
return Err(v25_error("v25.columns"));
|
||||
}
|
||||
for (column, data_type, nullable) in TASK_COLUMNS {
|
||||
let row = query(
|
||||
"select data_type, is_nullable from information_schema.columns
|
||||
where table_schema = current_schema() and table_name = $1 and column_name = $2",
|
||||
)
|
||||
.bind(TASKS)
|
||||
.bind(column)
|
||||
.fetch_optional(&mut *connection)
|
||||
.await
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?;
|
||||
let valid = row.is_some_and(|row| {
|
||||
row.try_get::<String, _>("data_type").ok().as_deref() == Some(*data_type)
|
||||
&& row.try_get::<String, _>("is_nullable").ok().as_deref()
|
||||
== Some(if *nullable { "YES" } else { "NO" })
|
||||
});
|
||||
if !valid {
|
||||
return Err(v25_error("v25.columns"));
|
||||
}
|
||||
}
|
||||
if !super::schema_guard::column_exists(connection, ENTRIES, "task_id").await? {
|
||||
return Err(v25_error("v25.intent_column"));
|
||||
}
|
||||
for (constraint, vocabulary) in [
|
||||
(
|
||||
"tasks_state_check",
|
||||
[
|
||||
"queued",
|
||||
"working",
|
||||
"input_required",
|
||||
"outcome_unknown",
|
||||
"completed",
|
||||
"failed",
|
||||
"cancelled",
|
||||
]
|
||||
.as_slice(),
|
||||
),
|
||||
(
|
||||
"tasks_policy_mode_check",
|
||||
["synchronous", "background", "adaptive"].as_slice(),
|
||||
),
|
||||
] {
|
||||
let expression = normalized_expression(connection, TASKS, constraint).await?;
|
||||
if !expression.is_some_and(|expression| {
|
||||
super::schema_guard::enum_constraint_matches(
|
||||
&expression,
|
||||
column_of(constraint),
|
||||
vocabulary,
|
||||
)
|
||||
}) {
|
||||
return Err(v25_error("v25.vocabulary"));
|
||||
}
|
||||
}
|
||||
for (index, table) in [(SCOPED_INDEX, TASKS), (TASK_INDEX, ENTRIES)] {
|
||||
if index_unique(connection, table, index).await? != Some(true) {
|
||||
return Err(v25_error("v25.indexes"));
|
||||
}
|
||||
}
|
||||
if !constraint_exists(connection, ENTRIES, TASK_FK).await? {
|
||||
return Err(v25_error("v25.intent_fk"));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn column_of(constraint: &str) -> &'static str {
|
||||
if constraint.contains("policy_mode") {
|
||||
"policy_mode"
|
||||
} else {
|
||||
"state"
|
||||
}
|
||||
}
|
||||
|
||||
async fn constraint_exists(
|
||||
connection: &mut PgConnection,
|
||||
table: &str,
|
||||
constraint: &str,
|
||||
) -> Result<bool, MigrationError> {
|
||||
query(
|
||||
"select exists (
|
||||
select 1 from pg_catalog.pg_constraint c
|
||||
join pg_catalog.pg_class t on t.oid = c.conrelid
|
||||
join pg_catalog.pg_namespace n on n.oid = t.relnamespace
|
||||
where n.nspname = current_schema() and t.relname = $1 and c.conname = $2
|
||||
) as present",
|
||||
)
|
||||
.bind(table)
|
||||
.bind(constraint)
|
||||
.fetch_one(&mut *connection)
|
||||
.await
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?
|
||||
.try_get::<bool, _>("present")
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))
|
||||
}
|
||||
|
||||
async fn normalized_expression(
|
||||
connection: &mut PgConnection,
|
||||
table: &str,
|
||||
constraint: &str,
|
||||
) -> Result<Option<String>, MigrationError> {
|
||||
let row = query(
|
||||
"select pg_get_expr(c.conbin, c.conrelid) as expression
|
||||
from pg_catalog.pg_constraint c
|
||||
join pg_catalog.pg_class t on t.oid = c.conrelid
|
||||
join pg_catalog.pg_namespace n on n.oid = t.relnamespace
|
||||
where n.nspname = current_schema() and t.relname = $1 and c.conname = $2
|
||||
and c.contype = 'c'",
|
||||
)
|
||||
.bind(table)
|
||||
.bind(constraint)
|
||||
.fetch_optional(&mut *connection)
|
||||
.await
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?;
|
||||
Ok(row.and_then(|row| row.try_get::<String, _>("expression").ok()))
|
||||
}
|
||||
|
||||
async fn index_exists(connection: &mut PgConnection, index: &str) -> Result<bool, MigrationError> {
|
||||
query(
|
||||
"select exists (
|
||||
select 1 from pg_catalog.pg_class idx
|
||||
join pg_catalog.pg_namespace n on n.oid = idx.relnamespace
|
||||
where n.nspname = current_schema() and idx.relname = $1
|
||||
) as present",
|
||||
)
|
||||
.bind(index)
|
||||
.fetch_one(&mut *connection)
|
||||
.await
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?
|
||||
.try_get::<bool, _>("present")
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))
|
||||
}
|
||||
|
||||
async fn index_unique(
|
||||
connection: &mut PgConnection,
|
||||
table: &str,
|
||||
index: &str,
|
||||
) -> Result<Option<bool>, MigrationError> {
|
||||
let row = query(
|
||||
"select i.indisunique, i.indisvalid
|
||||
from pg_catalog.pg_index i
|
||||
join pg_catalog.pg_class idx on idx.oid = i.indexrelid
|
||||
join pg_catalog.pg_class t on t.oid = i.indrelid
|
||||
join pg_catalog.pg_namespace n on n.oid = idx.relnamespace
|
||||
where n.nspname = current_schema() and idx.relname = $1 and t.relname = $2",
|
||||
)
|
||||
.bind(index)
|
||||
.bind(table)
|
||||
.fetch_optional(&mut *connection)
|
||||
.await
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?;
|
||||
Ok(row.and_then(|row| {
|
||||
let unique = row.try_get::<bool, _>("indisunique").ok()?;
|
||||
let valid = row.try_get::<bool, _>("indisvalid").ok()?;
|
||||
Some(unique && valid)
|
||||
}))
|
||||
}
|
||||
@@ -0,0 +1,120 @@
|
||||
//! V26 schema guard: lease/fencing columns for durable background Tasks (Story 4.3).
|
||||
|
||||
use sqlx::{PgConnection, Row, query};
|
||||
|
||||
use super::authority::MigrationError;
|
||||
use super::schema_guard::relation_exists;
|
||||
|
||||
const TASKS: &str = "tasks";
|
||||
|
||||
const TASK_COLUMNS: &[(&str, &str, bool)] = &[
|
||||
("task_id", "uuid", false),
|
||||
("workspace_id", "text", false),
|
||||
("owner_kind", "text", false),
|
||||
("owner_id", "text", false),
|
||||
("authorization_scope", "text", false),
|
||||
("operation_id", "text", false),
|
||||
("operation_version", "integer", false),
|
||||
("scoped_key", "text", false),
|
||||
("input_fingerprint", "text", false),
|
||||
("request_id", "text", false),
|
||||
("trace_id", "text", false),
|
||||
("traceparent", "text", false),
|
||||
("trace_sampled", "boolean", false),
|
||||
("policy_mode", "text", false),
|
||||
("approval_reference", "text", true),
|
||||
("state", "text", false),
|
||||
("version", "integer", false),
|
||||
("attempts", "integer", false),
|
||||
("input_envelope", "jsonb", false),
|
||||
("progress_envelope", "jsonb", true),
|
||||
("result_envelope", "jsonb", true),
|
||||
("error_envelope", "jsonb", true),
|
||||
("execution_deadline", "timestamp with time zone", false),
|
||||
("retain_until", "timestamp with time zone", false),
|
||||
("created_at", "timestamp with time zone", false),
|
||||
("updated_at", "timestamp with time zone", false),
|
||||
("fence", "bigint", false),
|
||||
("lease_owner", "text", true),
|
||||
("lease_until", "timestamp with time zone", true),
|
||||
("current_attempt_id", "text", true),
|
||||
("dispatch_started_at", "timestamp with time zone", true),
|
||||
];
|
||||
|
||||
fn v26_error(stage: &'static str) -> MigrationError {
|
||||
MigrationError::new(
|
||||
"partial_sequence",
|
||||
stage,
|
||||
Some(26),
|
||||
"restore_known_good_backup",
|
||||
)
|
||||
}
|
||||
|
||||
pub(super) async fn validate_v26_absent(
|
||||
connection: &mut PgConnection,
|
||||
) -> Result<bool, MigrationError> {
|
||||
if relation_exists(connection, TASKS).await? {
|
||||
// delegate to v25 absent for relation mostly; V26 columns must not exist.
|
||||
for column in [
|
||||
"fence",
|
||||
"lease_owner",
|
||||
"lease_until",
|
||||
"current_attempt_id",
|
||||
"dispatch_started_at",
|
||||
] {
|
||||
if super::schema_guard::column_exists(connection, TASKS, column).await? {
|
||||
return Ok(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
pub(super) async fn validate_v26_base_columns(
|
||||
connection: &mut PgConnection,
|
||||
) -> Result<(), MigrationError> {
|
||||
if !relation_exists(connection, TASKS).await? {
|
||||
return Err(v26_error("v26.relations"));
|
||||
}
|
||||
for (column, data_type, nullable) in TASK_COLUMNS {
|
||||
let row = query(
|
||||
"select data_type, is_nullable from information_schema.columns
|
||||
where table_schema = current_schema() and table_name = $1 and column_name = $2",
|
||||
)
|
||||
.bind(TASKS)
|
||||
.bind(column)
|
||||
.fetch_optional(&mut *connection)
|
||||
.await
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?;
|
||||
let valid = row.is_some_and(|row| {
|
||||
row.try_get::<String, _>("data_type").ok().as_deref() == Some(*data_type)
|
||||
&& row.try_get::<String, _>("is_nullable").ok().as_deref()
|
||||
== Some(if *nullable { "YES" } else { "NO" })
|
||||
});
|
||||
if !valid {
|
||||
return Err(v26_error("v26.columns"));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(super) async fn validate_v26_durable_tasks(
|
||||
connection: &mut PgConnection,
|
||||
) -> Result<(), MigrationError> {
|
||||
validate_v26_base_columns(connection).await?;
|
||||
let count: i64 = query(
|
||||
"select count(*)::bigint as count from information_schema.columns
|
||||
where table_schema = current_schema() and table_name = $1",
|
||||
)
|
||||
.bind(TASKS)
|
||||
.fetch_one(&mut *connection)
|
||||
.await
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?
|
||||
.try_get("count")
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?;
|
||||
if count != i64::try_from(TASK_COLUMNS.len()).unwrap_or_default() {
|
||||
return Err(v26_error("v26.columns"));
|
||||
}
|
||||
// Constraints/index checks inherited conceptually from V25; V26 adds columns only.
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,85 @@
|
||||
//! V27 schema guard: encrypted executable Task input columns (Story 4.3).
|
||||
|
||||
use sqlx::{PgConnection, Row, query};
|
||||
|
||||
use super::authority::MigrationError;
|
||||
use super::schema_guard::relation_exists;
|
||||
use super::schema_guard_v26::validate_v26_base_columns;
|
||||
|
||||
const TASKS: &str = "tasks";
|
||||
|
||||
pub(super) async fn validate_v27_absent(
|
||||
connection: &mut PgConnection,
|
||||
) -> Result<bool, MigrationError> {
|
||||
if relation_exists(connection, TASKS).await? {
|
||||
for column in [
|
||||
"executable_input_ciphertext",
|
||||
"executable_input_key_version",
|
||||
"executable_input_master_key_epoch",
|
||||
] {
|
||||
if super::schema_guard::column_exists(connection, TASKS, column).await? {
|
||||
return Ok(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
pub(super) async fn validate_v27_durable_tasks(
|
||||
connection: &mut PgConnection,
|
||||
) -> Result<(), MigrationError> {
|
||||
validate_v26_base_columns(connection).await?;
|
||||
// Additional V27 columns.
|
||||
let extra = [
|
||||
("executable_input_ciphertext", "text", true),
|
||||
("executable_input_key_version", "text", true),
|
||||
("executable_input_master_key_epoch", "bigint", true),
|
||||
("target_executable_input_ciphertext", "text", true),
|
||||
("target_executable_input_key_version", "text", true),
|
||||
("target_executable_input_master_key_epoch", "bigint", true),
|
||||
];
|
||||
for (column, data_type, nullable) in extra {
|
||||
let row = query(
|
||||
"select data_type, is_nullable from information_schema.columns
|
||||
where table_schema = current_schema() and table_name = $1 and column_name = $2",
|
||||
)
|
||||
.bind(TASKS)
|
||||
.bind(column)
|
||||
.fetch_optional(&mut *connection)
|
||||
.await
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?;
|
||||
let valid = row.is_some_and(|row| {
|
||||
row.try_get::<String, _>("data_type").ok().as_deref() == Some(data_type)
|
||||
&& row.try_get::<String, _>("is_nullable").ok().as_deref()
|
||||
== Some(if nullable { "YES" } else { "NO" })
|
||||
});
|
||||
if !valid {
|
||||
return Err(MigrationError::new(
|
||||
"partial_sequence",
|
||||
"v27.columns",
|
||||
Some(27),
|
||||
"restore_known_good_backup",
|
||||
));
|
||||
}
|
||||
}
|
||||
// Exact total column count for version 27: 43 V26 columns + 3 V27 columns.
|
||||
let count: i64 = query(
|
||||
"select count(*)::bigint as count from information_schema.columns
|
||||
where table_schema = current_schema() and table_name = $1",
|
||||
)
|
||||
.bind(TASKS)
|
||||
.fetch_one(&mut *connection)
|
||||
.await
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?
|
||||
.try_get("count")
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?;
|
||||
if count != i64::try_from(37).unwrap_or_default() {
|
||||
return Err(MigrationError::new(
|
||||
"partial_sequence",
|
||||
"v27.columns",
|
||||
Some(27),
|
||||
"restore_known_good_backup",
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,89 @@
|
||||
//! V28 schema guard: typed Platform API key authority reference of a durable Task (Story 4.3).
|
||||
|
||||
use sqlx::{PgConnection, Row, query};
|
||||
|
||||
use super::authority::MigrationError;
|
||||
use super::schema_guard::relation_exists;
|
||||
|
||||
const TASKS: &str = "tasks";
|
||||
|
||||
pub(super) async fn validate_v28_absent(
|
||||
connection: &mut PgConnection,
|
||||
) -> Result<bool, MigrationError> {
|
||||
if relation_exists(connection, TASKS).await? {
|
||||
if super::schema_guard::column_exists(connection, TASKS, "platform_api_key_id").await? {
|
||||
return Ok(false);
|
||||
}
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
pub(super) async fn validate_v28_durable_tasks(
|
||||
connection: &mut PgConnection,
|
||||
) -> Result<(), MigrationError> {
|
||||
// The V27 column set is still required and unchanged; V28 only appends one column.
|
||||
validate_v27_base_columns(connection).await?;
|
||||
let row = query(
|
||||
"select data_type, is_nullable from information_schema.columns
|
||||
where table_schema = current_schema() and table_name = $1 and column_name = $2",
|
||||
)
|
||||
.bind(TASKS)
|
||||
.bind("platform_api_key_id")
|
||||
.fetch_optional(&mut *connection)
|
||||
.await
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?;
|
||||
let valid = row.is_some_and(|row| {
|
||||
row.try_get::<String, _>("data_type").ok().as_deref() == Some("text")
|
||||
&& row.try_get::<String, _>("is_nullable").ok().as_deref() == Some("YES")
|
||||
});
|
||||
if !valid {
|
||||
return Err(MigrationError::new(
|
||||
"partial_sequence",
|
||||
"v28.columns",
|
||||
Some(28),
|
||||
"restore_known_good_backup",
|
||||
));
|
||||
}
|
||||
// Exact total column count for version 28: the 37 V27 columns + 1 V28 column.
|
||||
let count: i64 = query(
|
||||
"select count(*)::bigint as count from information_schema.columns
|
||||
where table_schema = current_schema() and table_name = $1",
|
||||
)
|
||||
.bind(TASKS)
|
||||
.fetch_one(&mut *connection)
|
||||
.await
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?
|
||||
.try_get("count")
|
||||
.map_err(|_| MigrationError::storage("preflight.schema"))?;
|
||||
if count != i64::try_from(38).unwrap_or_default() {
|
||||
return Err(MigrationError::new(
|
||||
"partial_sequence",
|
||||
"v28.columns",
|
||||
Some(28),
|
||||
"restore_known_good_backup",
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// V27 columns must still be exactly present before V28 is considered applied.
|
||||
async fn validate_v27_base_columns(connection: &mut PgConnection) -> Result<(), MigrationError> {
|
||||
for column in [
|
||||
"executable_input_ciphertext",
|
||||
"executable_input_key_version",
|
||||
"executable_input_master_key_epoch",
|
||||
"target_executable_input_ciphertext",
|
||||
"target_executable_input_key_version",
|
||||
"target_executable_input_master_key_epoch",
|
||||
] {
|
||||
if !super::schema_guard::column_exists(connection, TASKS, column).await? {
|
||||
return Err(MigrationError::new(
|
||||
"partial_sequence",
|
||||
"v28.columns",
|
||||
Some(28),
|
||||
"restore_known_good_backup",
|
||||
));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,819 @@
|
||||
//! PostgreSQL implementation of the mandatory execution-admission store (Story 4.1, FR-21/FR-24).
|
||||
//!
|
||||
//! Source of truth for capacity and durable enqueue decisions of every process: a short transaction
|
||||
//! locks one deployment controller row and one workspace controller row in a fixed order, then reads
|
||||
//! bounded counters, inserts/transitions at most one entry and persists the weighted round-robin
|
||||
//! cursor. No network call happens under the transaction and no connection is held while a waiter is
|
||||
//! idle between attempts.
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
use std::time::Duration;
|
||||
|
||||
use async_trait::async_trait;
|
||||
use crank_core::{
|
||||
AdmissionCursor, AdmissionDecision, AdmissionMode, AdmissionOutcome, AdmissionPermit,
|
||||
AdmissionQueueEntry, AdmissionQueueSnapshot, AdmissionRequest, AdmissionSchedulerConfig,
|
||||
AdmissionStoreError, ApprovalEvidence, ExecutionAdmission, NoTasksFallback, TaskError,
|
||||
select_next_grant,
|
||||
};
|
||||
use sqlx::{PgPool, Postgres, Row, Transaction};
|
||||
use uuid::Uuid;
|
||||
|
||||
const DEPLOYMENT_CONTROLLER: &str = "*";
|
||||
const OVERLOAD_RETRY_AFTER_MS: u64 = crank_core::ADMISSION_OVERLOAD_RETRY_AFTER_MS;
|
||||
const MAX_WAIT_BACKOFF_MS: u64 = 250;
|
||||
const INITIAL_WAIT_BACKOFF_MS: u64 = 5;
|
||||
const EXPIRED_CLEANUP_BATCH: i64 = 128;
|
||||
const QUEUE_READ_LIMIT: i64 = 1024;
|
||||
|
||||
/// Deployment-wide bounds of one admission store. They come from validated deployment
|
||||
/// configuration, never from a request.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub struct AdmissionLimits {
|
||||
pub global_limit: usize,
|
||||
pub agent_limit: usize,
|
||||
pub tool_limit: usize,
|
||||
pub queue_limit: usize,
|
||||
}
|
||||
|
||||
impl Default for AdmissionLimits {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
global_limit: 64,
|
||||
agent_limit: 16,
|
||||
tool_limit: 8,
|
||||
queue_limit: 32,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl AdmissionLimits {
|
||||
pub fn validate(&self) -> Result<(), AdmissionStoreError> {
|
||||
for (field, value) in [
|
||||
("global_limit", self.global_limit),
|
||||
("agent_limit", self.agent_limit),
|
||||
("tool_limit", self.tool_limit),
|
||||
] {
|
||||
if !(1..=65_535).contains(&value) {
|
||||
return Err(AdmissionStoreError::invalid(format!(
|
||||
"admission {field} is outside its allowed bounds"
|
||||
)));
|
||||
}
|
||||
}
|
||||
if !(1..=1_024).contains(&self.queue_limit) {
|
||||
return Err(AdmissionStoreError::invalid(
|
||||
"admission queue_limit is outside its allowed bounds",
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct PostgresExecutionAdmission {
|
||||
pool: PgPool,
|
||||
limits: AdmissionLimits,
|
||||
scheduler: AdmissionSchedulerConfig,
|
||||
}
|
||||
|
||||
impl PostgresExecutionAdmission {
|
||||
pub fn new(
|
||||
pool: PgPool,
|
||||
limits: AdmissionLimits,
|
||||
scheduler: AdmissionSchedulerConfig,
|
||||
) -> Result<Self, AdmissionStoreError> {
|
||||
limits.validate()?;
|
||||
scheduler.validate()?;
|
||||
Ok(Self {
|
||||
pool,
|
||||
limits,
|
||||
scheduler,
|
||||
})
|
||||
}
|
||||
|
||||
fn unavailable(error: impl std::fmt::Display) -> AdmissionStoreError {
|
||||
AdmissionStoreError::unavailable(format!(
|
||||
"execution admission store is unavailable: {error}"
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
struct AttemptContext<'a> {
|
||||
request: &'a AdmissionRequest,
|
||||
owner_token: &'a str,
|
||||
}
|
||||
|
||||
enum Attempt {
|
||||
Granted,
|
||||
Enqueued(u64),
|
||||
Waiting,
|
||||
Overloaded,
|
||||
Expired,
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl ExecutionAdmission for PostgresExecutionAdmission {
|
||||
async fn health(&self) -> Result<(), AdmissionStoreError> {
|
||||
admission_health(&self.pool).await
|
||||
}
|
||||
|
||||
async fn admit(
|
||||
&self,
|
||||
request: AdmissionRequest,
|
||||
) -> Result<AdmissionOutcome, AdmissionStoreError> {
|
||||
request.validate()?;
|
||||
if request.approval == ApprovalEvidence::NotGranted {
|
||||
return Ok(AdmissionOutcome::ApprovalRequired);
|
||||
}
|
||||
if request.mode == AdmissionMode::Background
|
||||
&& request.no_tasks_fallback == NoTasksFallback::Unsupported
|
||||
{
|
||||
return Ok(AdmissionOutcome::Unsupported);
|
||||
}
|
||||
|
||||
let owner_token = format!("adm_{}", Uuid::now_v7().simple());
|
||||
let mut ticket: Option<u64> = None;
|
||||
let mut backoff = INITIAL_WAIT_BACKOFF_MS;
|
||||
loop {
|
||||
if crank_core::current_unix_ms() >= request.expires_at_unix_ms {
|
||||
if let Some(ticket_id) = ticket {
|
||||
self.cancel(ticket_id, &owner_token).await?;
|
||||
}
|
||||
return Ok(AdmissionOutcome::DeadlineElapsed);
|
||||
}
|
||||
let attempt = self
|
||||
.attempt(
|
||||
AttemptContext {
|
||||
request: &request,
|
||||
owner_token: &owner_token,
|
||||
},
|
||||
&mut ticket,
|
||||
)
|
||||
.await?;
|
||||
match attempt {
|
||||
Attempt::Granted => {
|
||||
return Ok(AdmissionOutcome::Permitted(AdmissionPermit {
|
||||
ticket_id: ticket.unwrap_or_default(),
|
||||
owner_token,
|
||||
scope: request.scope.clone(),
|
||||
mode: request.mode,
|
||||
policy_mode: request.policy_mode,
|
||||
}));
|
||||
}
|
||||
Attempt::Enqueued(ticket_id) => {
|
||||
return Ok(AdmissionOutcome::Enqueued(AdmissionDecision {
|
||||
ticket_id,
|
||||
scope: request.scope.clone(),
|
||||
expires_at_unix_ms: request.expires_at_unix_ms,
|
||||
policy_mode: request.policy_mode,
|
||||
}));
|
||||
}
|
||||
Attempt::Expired => {
|
||||
return Ok(AdmissionOutcome::DeadlineElapsed);
|
||||
}
|
||||
Attempt::Overloaded => {
|
||||
return Ok(AdmissionOutcome::Overloaded {
|
||||
retry_after_ms: OVERLOAD_RETRY_AFTER_MS,
|
||||
});
|
||||
}
|
||||
Attempt::Waiting => {
|
||||
let remaining = request
|
||||
.expires_at_unix_ms
|
||||
.saturating_sub(crank_core::current_unix_ms())
|
||||
.max(1);
|
||||
let sleep_ms = i64::try_from(backoff).unwrap_or(remaining).min(remaining);
|
||||
tokio::time::sleep(Duration::from_millis(
|
||||
u64::try_from(sleep_ms).unwrap_or(backoff),
|
||||
))
|
||||
.await;
|
||||
backoff = (backoff * 2).min(MAX_WAIT_BACKOFF_MS);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn release(&self, permit: &AdmissionPermit) -> Result<bool, AdmissionStoreError> {
|
||||
let result = sqlx::query(
|
||||
"delete from execution_admission_entries
|
||||
where ticket_id = $1 and owner_token = $2 and state = 'executing'
|
||||
and task_id is null",
|
||||
)
|
||||
.bind(i64::try_from(permit.ticket_id).unwrap_or(i64::MAX))
|
||||
.bind(&permit.owner_token)
|
||||
.execute(&self.pool)
|
||||
.await
|
||||
.map_err(Self::unavailable)?;
|
||||
Ok(result.rows_affected() > 0)
|
||||
}
|
||||
|
||||
async fn cancel(&self, ticket_id: u64, owner_token: &str) -> Result<bool, AdmissionStoreError> {
|
||||
let result = sqlx::query(
|
||||
"delete from execution_admission_entries
|
||||
where ticket_id = $1 and owner_token = $2 and state in ('waiting', 'reserved')
|
||||
and task_id is null",
|
||||
)
|
||||
.bind(i64::try_from(ticket_id).unwrap_or(i64::MAX))
|
||||
.bind(owner_token)
|
||||
.execute(&self.pool)
|
||||
.await
|
||||
.map_err(Self::unavailable)?;
|
||||
Ok(result.rows_affected() > 0)
|
||||
}
|
||||
|
||||
async fn snapshot(&self) -> Result<AdmissionQueueSnapshot, AdmissionStoreError> {
|
||||
admission_snapshot(&self.pool).await
|
||||
}
|
||||
}
|
||||
|
||||
/// Readiness probe of the mandatory admission state: both tables must be reachable and readable.
|
||||
pub async fn admission_health(pool: &PgPool) -> Result<(), AdmissionStoreError> {
|
||||
sqlx::query(
|
||||
"select count(*)::bigint from execution_admission_controllers where workspace_id = $1",
|
||||
)
|
||||
.bind(DEPLOYMENT_CONTROLLER)
|
||||
.fetch_one(pool)
|
||||
.await
|
||||
.map_err(PostgresExecutionAdmission::unavailable)?;
|
||||
sqlx::query("select count(*)::bigint from execution_admission_entries where false")
|
||||
.fetch_one(pool)
|
||||
.await
|
||||
.map_err(PostgresExecutionAdmission::unavailable)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Authoritative queue readings of the deployment-wide admission state.
|
||||
pub async fn admission_snapshot(
|
||||
pool: &PgPool,
|
||||
) -> Result<AdmissionQueueSnapshot, AdmissionStoreError> {
|
||||
let row = sqlx::query(
|
||||
"select
|
||||
count(*) filter (where state in ('waiting', 'reserved')) as queued,
|
||||
count(*) filter (where state = 'executing') as executing,
|
||||
coalesce(
|
||||
(extract(epoch from (now() - min(created_at) filter (where state in ('waiting', 'reserved')))) * 1000)::bigint,
|
||||
-1
|
||||
) as oldest_waiting_ms
|
||||
from execution_admission_entries",
|
||||
)
|
||||
.fetch_one(pool)
|
||||
.await
|
||||
.map_err(PostgresExecutionAdmission::unavailable)?;
|
||||
let queued: i64 = row
|
||||
.try_get("queued")
|
||||
.map_err(PostgresExecutionAdmission::unavailable)?;
|
||||
let executing: i64 = row
|
||||
.try_get("executing")
|
||||
.map_err(PostgresExecutionAdmission::unavailable)?;
|
||||
let oldest: i64 = row
|
||||
.try_get("oldest_waiting_ms")
|
||||
.map_err(PostgresExecutionAdmission::unavailable)?;
|
||||
Ok(AdmissionQueueSnapshot {
|
||||
waiting: u64::try_from(queued).unwrap_or_default(),
|
||||
executing: u64::try_from(executing).unwrap_or_default(),
|
||||
oldest_waiting_ms: (oldest >= 0).then(|| u64::try_from(oldest).unwrap_or_default()),
|
||||
})
|
||||
}
|
||||
|
||||
impl PostgresExecutionAdmission {
|
||||
async fn attempt(
|
||||
&self,
|
||||
context: AttemptContext<'_>,
|
||||
ticket: &mut Option<u64>,
|
||||
) -> Result<Attempt, AdmissionStoreError> {
|
||||
let mut transaction = self.pool.begin().await.map_err(Self::unavailable)?;
|
||||
sqlx::query("set local lock_timeout = '3000ms'")
|
||||
.execute(&mut *transaction)
|
||||
.await
|
||||
.map_err(Self::unavailable)?;
|
||||
sqlx::query("set local statement_timeout = '5000ms'")
|
||||
.execute(&mut *transaction)
|
||||
.await
|
||||
.map_err(Self::unavailable)?;
|
||||
|
||||
match self.attempt_locked(&mut transaction, context, ticket).await {
|
||||
Ok(attempt) => {
|
||||
transaction.commit().await.map_err(Self::unavailable)?;
|
||||
Ok(attempt)
|
||||
}
|
||||
Err(AttemptError::Contended) => {
|
||||
transaction.rollback().await.ok();
|
||||
Ok(Attempt::Waiting)
|
||||
}
|
||||
Err(AttemptError::Overloaded) => {
|
||||
transaction.rollback().await.ok();
|
||||
Ok(Attempt::Overloaded)
|
||||
}
|
||||
Err(AttemptError::Failure(error)) => {
|
||||
transaction.rollback().await.ok();
|
||||
Err(AdmissionStoreError::unavailable(error.to_string()))
|
||||
}
|
||||
Err(AttemptError::AdmissionFailure(error)) => {
|
||||
transaction.rollback().await.ok();
|
||||
Err(error)
|
||||
}
|
||||
Err(AttemptError::UniqueViolation) => {
|
||||
transaction.rollback().await.ok();
|
||||
Err(AdmissionStoreError::unavailable(
|
||||
"execution admission hit an unexpected unique conflict",
|
||||
))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn attempt_locked(
|
||||
&self,
|
||||
transaction: &mut Transaction<'_, Postgres>,
|
||||
context: AttemptContext<'_>,
|
||||
ticket: &mut Option<u64>,
|
||||
) -> Result<Attempt, AttemptError> {
|
||||
let workspace_id = context.request.scope.workspace_id.as_str();
|
||||
let cursor = lock_admission_in_tx(transaction, workspace_id).await?;
|
||||
|
||||
// Expired queue decisions and waiting tickets leave the bounded queue; held permits and
|
||||
// Task-linked dispatch intents never do (Story 4.2 owns the durable Task lifetime).
|
||||
cleanup_expired_unlinked(transaction).await?;
|
||||
|
||||
if ticket.is_none() {
|
||||
let queued = bounded_queue_len(transaction).await?;
|
||||
if queued >= u64::try_from(self.limits.queue_limit).unwrap_or(u64::MAX) {
|
||||
return Err(AttemptError::Overloaded);
|
||||
}
|
||||
let state = match context.request.mode {
|
||||
AdmissionMode::Synchronous => "waiting",
|
||||
AdmissionMode::Background => "reserved",
|
||||
};
|
||||
let ticket_id = insert_admission_entry(
|
||||
transaction,
|
||||
context.request,
|
||||
context.owner_token,
|
||||
state,
|
||||
None,
|
||||
)
|
||||
.await?;
|
||||
*ticket = Some(ticket_id);
|
||||
if context.request.mode == AdmissionMode::Background {
|
||||
return Ok(Attempt::Enqueued(ticket_id));
|
||||
}
|
||||
}
|
||||
|
||||
self.grant_next(transaction, workspace_id, &cursor).await?;
|
||||
|
||||
let Some(ticket_id) = *ticket else {
|
||||
return Ok(Attempt::Waiting);
|
||||
};
|
||||
let state: Option<String> =
|
||||
sqlx::query("select state from execution_admission_entries where ticket_id = $1")
|
||||
.bind(i64::try_from(ticket_id).unwrap_or(i64::MAX))
|
||||
.fetch_optional(&mut **transaction)
|
||||
.await
|
||||
.map_err(AttemptError::from_sql)?
|
||||
.map(|row| row.try_get("state"))
|
||||
.transpose()
|
||||
.map_err(AttemptError::from_sql)?;
|
||||
match state.as_deref() {
|
||||
Some("executing") => Ok(Attempt::Granted),
|
||||
Some(_) => Ok(Attempt::Waiting),
|
||||
// The ticket expired inside the store (or was removed by another cleanup).
|
||||
None => Ok(Attempt::Expired),
|
||||
}
|
||||
}
|
||||
|
||||
/// Grants at most one waiting ticket per transaction, following the persisted weighted
|
||||
/// round-robin cursor. A blocked head keeps its turn: nothing later is granted in its place.
|
||||
async fn grant_next(
|
||||
&self,
|
||||
transaction: &mut Transaction<'_, Postgres>,
|
||||
workspace_id: &str,
|
||||
cursor: &AdmissionCursor,
|
||||
) -> Result<(), AttemptError> {
|
||||
let rows = sqlx::query(
|
||||
"select ticket_id, agent_key, operation_id from execution_admission_entries
|
||||
where workspace_id = $1 and state = 'waiting'
|
||||
order by ticket_id
|
||||
limit $2",
|
||||
)
|
||||
.bind(workspace_id)
|
||||
.bind(QUEUE_READ_LIMIT)
|
||||
.fetch_all(&mut **transaction)
|
||||
.await
|
||||
.map_err(AttemptError::from_sql)?;
|
||||
if rows.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
let queue = rows
|
||||
.iter()
|
||||
.map(|row| {
|
||||
Ok(AdmissionQueueEntry {
|
||||
ticket_id: u64::try_from(
|
||||
row.try_get::<i64, _>("ticket_id")
|
||||
.map_err(AttemptError::from_sql)?,
|
||||
)
|
||||
.unwrap_or_default(),
|
||||
sequence: 0,
|
||||
agent_key: row.try_get("agent_key").map_err(AttemptError::from_sql)?,
|
||||
operation_id: row
|
||||
.try_get("operation_id")
|
||||
.map_err(AttemptError::from_sql)?,
|
||||
})
|
||||
})
|
||||
.collect::<Result<Vec<_>, AttemptError>>()?;
|
||||
let Some(selection) = select_next_grant(&queue, cursor, self.scheduler) else {
|
||||
return Ok(());
|
||||
};
|
||||
let head = &queue[selection.index];
|
||||
|
||||
let global_executing: i64 = sqlx::query(
|
||||
"select count(*)::bigint as count from execution_admission_entries
|
||||
where state = 'executing'",
|
||||
)
|
||||
.fetch_one(&mut **transaction)
|
||||
.await
|
||||
.map_err(AttemptError::from_sql)?
|
||||
.try_get("count")
|
||||
.map_err(AttemptError::from_sql)?;
|
||||
let agent_counts = scoped_counts(transaction, workspace_id, "agent_key").await?;
|
||||
let tool_counts = scoped_counts(transaction, workspace_id, "operation_id").await?;
|
||||
if u64::try_from(global_executing).unwrap_or(u64::MAX)
|
||||
>= u64::try_from(self.limits.global_limit).unwrap_or(u64::MAX)
|
||||
{
|
||||
return Ok(());
|
||||
}
|
||||
let agent_executing = agent_counts
|
||||
.get(head.agent_key.as_str())
|
||||
.copied()
|
||||
.unwrap_or_default();
|
||||
if agent_executing >= u64::try_from(self.limits.agent_limit).unwrap_or(u64::MAX) {
|
||||
return Ok(());
|
||||
}
|
||||
let tool_executing = tool_counts
|
||||
.get(head.operation_id.as_str())
|
||||
.copied()
|
||||
.unwrap_or_default();
|
||||
if tool_executing >= u64::try_from(self.limits.tool_limit).unwrap_or(u64::MAX) {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
sqlx::query(
|
||||
"update execution_admission_entries
|
||||
set state = 'executing', granted_at = now()
|
||||
where ticket_id = $1 and state = 'waiting'",
|
||||
)
|
||||
.bind(i64::try_from(head.ticket_id).unwrap_or(i64::MAX))
|
||||
.execute(&mut **transaction)
|
||||
.await
|
||||
.map_err(AttemptError::from_sql)?;
|
||||
sqlx::query(
|
||||
"update execution_admission_controllers
|
||||
set cursor_agent = $2,
|
||||
cursor_agent_credit = $3,
|
||||
cursor_tool = $4,
|
||||
cursor_tool_credit = $5,
|
||||
updated_at = now()
|
||||
where workspace_id = $1",
|
||||
)
|
||||
.bind(workspace_id)
|
||||
.bind(selection.cursor.agent.as_deref())
|
||||
.bind(i32::try_from(selection.cursor.agent_credit).unwrap_or_default())
|
||||
.bind(selection.cursor.tool.as_deref())
|
||||
.bind(i32::try_from(selection.cursor.tool_credit).unwrap_or_default())
|
||||
.execute(&mut **transaction)
|
||||
.await
|
||||
.map_err(AttemptError::from_sql)?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// Takes both controller locks in the fixed `'*'` -> workspace order. Shared by the synchronous
|
||||
/// admission attempt and the durable Task repository, so both serialize on the same controller rows
|
||||
/// and one task/queue invariant holds. Callers own the transaction; nothing here commits or sleeps.
|
||||
pub(super) async fn lock_admission_in_tx(
|
||||
transaction: &mut Transaction<'_, Postgres>,
|
||||
workspace_id: &str,
|
||||
) -> Result<AdmissionCursor, AttemptError> {
|
||||
sqlx::query(
|
||||
"insert into execution_admission_controllers (workspace_id)
|
||||
values ($1), ($2)
|
||||
on conflict (workspace_id) do nothing",
|
||||
)
|
||||
.bind(DEPLOYMENT_CONTROLLER)
|
||||
.bind(workspace_id)
|
||||
.execute(&mut **transaction)
|
||||
.await
|
||||
.map_err(AttemptError::from_sql)?;
|
||||
|
||||
lock_controller(transaction, DEPLOYMENT_CONTROLLER).await?;
|
||||
lock_controller(transaction, workspace_id).await
|
||||
}
|
||||
|
||||
/// Bounded cleanup of expired waiting/reserved rows that are not a durable Task dispatch intent.
|
||||
pub(super) async fn cleanup_expired_unlinked(
|
||||
transaction: &mut Transaction<'_, Postgres>,
|
||||
) -> Result<(), AttemptError> {
|
||||
sqlx::query(
|
||||
"delete from execution_admission_entries
|
||||
where ticket_id in (
|
||||
select ticket_id from execution_admission_entries
|
||||
where state in ('waiting', 'reserved') and expires_at <= now()
|
||||
and task_id is null
|
||||
order by ticket_id
|
||||
limit $1
|
||||
)",
|
||||
)
|
||||
.bind(EXPIRED_CLEANUP_BATCH)
|
||||
.execute(&mut **transaction)
|
||||
.await
|
||||
.map_err(AttemptError::from_sql)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Authoritative bounded queue length: waiting and reserved rows share one budget.
|
||||
pub(super) async fn bounded_queue_len(
|
||||
transaction: &mut Transaction<'_, Postgres>,
|
||||
) -> Result<u64, AttemptError> {
|
||||
let queued: i64 = sqlx::query(
|
||||
"select count(*)::bigint as count from execution_admission_entries
|
||||
where state in ('waiting', 'reserved')",
|
||||
)
|
||||
.fetch_one(&mut **transaction)
|
||||
.await
|
||||
.map_err(AttemptError::from_sql)?
|
||||
.try_get("count")
|
||||
.map_err(AttemptError::from_sql)?;
|
||||
Ok(u64::try_from(queued).unwrap_or(u64::MAX))
|
||||
}
|
||||
|
||||
/// Inserts one bounded admission row. A Task-linked row is the durable dispatch intent of the Task
|
||||
/// accepted in the same transaction, so its capacity slot can never be silently reclaimed.
|
||||
pub(super) async fn insert_admission_entry(
|
||||
transaction: &mut Transaction<'_, Postgres>,
|
||||
request: &AdmissionRequest,
|
||||
owner_token: &str,
|
||||
state: &str,
|
||||
task_id: Option<Uuid>,
|
||||
) -> Result<u64, AttemptError> {
|
||||
let row = sqlx::query(
|
||||
"insert into execution_admission_entries (
|
||||
workspace_id, agent_key, operation_id, operation_version, mode, policy_mode,
|
||||
state, owner_token, fingerprint, expires_at, task_id
|
||||
) values ($1, $2, $3, $4, $5, $6, $7, $8, $9,
|
||||
to_timestamp($10::double precision / 1000.0), $11)
|
||||
returning ticket_id",
|
||||
)
|
||||
.bind(&request.scope.workspace_id)
|
||||
.bind(&request.scope.agent_key)
|
||||
.bind(&request.scope.operation_id)
|
||||
.bind(i32::try_from(request.scope.operation_version).unwrap_or(i32::MAX))
|
||||
.bind(request.mode.as_str())
|
||||
.bind(policy_mode_str(request))
|
||||
.bind(state)
|
||||
.bind(owner_token)
|
||||
.bind(&request.fingerprint)
|
||||
.bind(request.expires_at_unix_ms)
|
||||
.bind(task_id)
|
||||
.fetch_one(&mut **transaction)
|
||||
.await
|
||||
.map_err(AttemptError::from_sql)?;
|
||||
let ticket_id: i64 = row.try_get("ticket_id").map_err(AttemptError::from_sql)?;
|
||||
Ok(u64::try_from(ticket_id).unwrap_or_default())
|
||||
}
|
||||
|
||||
/// Shared grant step used by the durable Task store: grants one reserved Task intent if capacity allows,
|
||||
/// marks it `executing`, persists the weighted round-robin cursor, and returns its Task id. It reuses
|
||||
/// the same selector/capacity logic as synchronous admission so no second policy exists.
|
||||
pub(super) async fn grant_next_task(
|
||||
transaction: &mut Transaction<'_, Postgres>,
|
||||
workspace_id: &str,
|
||||
cursor: &AdmissionCursor,
|
||||
limits: &AdmissionLimits,
|
||||
scheduler: AdmissionSchedulerConfig,
|
||||
) -> Result<(Option<Uuid>, AdmissionCursor), AttemptError> {
|
||||
let rows = sqlx::query(
|
||||
"select ticket_id, agent_key, operation_id, task_id
|
||||
from execution_admission_entries
|
||||
where state = 'reserved' and task_id is not null
|
||||
order by ticket_id
|
||||
limit $1
|
||||
for update skip locked",
|
||||
)
|
||||
.bind(QUEUE_READ_LIMIT)
|
||||
.fetch_all(&mut **transaction)
|
||||
.await
|
||||
.map_err(AttemptError::from_sql)?;
|
||||
if rows.is_empty() {
|
||||
return Ok((None, cursor.clone()));
|
||||
}
|
||||
struct Candidate {
|
||||
entry: AdmissionQueueEntry,
|
||||
task_id: Uuid,
|
||||
}
|
||||
let mut candidates = Vec::with_capacity(rows.len());
|
||||
for row in rows {
|
||||
let ticket_id: i64 = row.try_get("ticket_id").map_err(AttemptError::from_sql)?;
|
||||
let task_id: Uuid = row.try_get("task_id").map_err(AttemptError::from_sql)?;
|
||||
candidates.push(Candidate {
|
||||
entry: AdmissionQueueEntry {
|
||||
ticket_id: u64::try_from(ticket_id).unwrap_or_default(),
|
||||
sequence: 0,
|
||||
agent_key: row.try_get("agent_key").map_err(AttemptError::from_sql)?,
|
||||
operation_id: row
|
||||
.try_get("operation_id")
|
||||
.map_err(AttemptError::from_sql)?,
|
||||
},
|
||||
task_id,
|
||||
});
|
||||
}
|
||||
let queue: Vec<AdmissionQueueEntry> = candidates.iter().map(|c| c.entry.clone()).collect();
|
||||
let Some(selection) = select_next_grant(&queue, cursor, scheduler) else {
|
||||
return Ok((None, cursor.clone()));
|
||||
};
|
||||
let head_index = selection.index;
|
||||
let head = &candidates[head_index];
|
||||
|
||||
let global_executing: i64 = sqlx::query(
|
||||
"select count(*)::bigint as count from execution_admission_entries where state = 'executing'",
|
||||
)
|
||||
.fetch_one(&mut **transaction)
|
||||
.await
|
||||
.map_err(AttemptError::from_sql)?
|
||||
.try_get("count")
|
||||
.map_err(AttemptError::from_sql)?;
|
||||
let agent_counts = sqlx::query(
|
||||
"select agent_key as key, count(*)::bigint as count
|
||||
from execution_admission_entries where state = 'executing' group by agent_key",
|
||||
)
|
||||
.fetch_all(&mut **transaction)
|
||||
.await
|
||||
.map_err(AttemptError::from_sql)?;
|
||||
let mut agent_map = std::collections::BTreeMap::new();
|
||||
for row in agent_counts {
|
||||
let key: String = row.try_get("key").map_err(AttemptError::from_sql)?;
|
||||
let count: i64 = row.try_get("count").map_err(AttemptError::from_sql)?;
|
||||
agent_map.insert(key, u64::try_from(count).unwrap_or_default());
|
||||
}
|
||||
let tool_counts = sqlx::query(
|
||||
"select operation_id as key, count(*)::bigint as count
|
||||
from execution_admission_entries where state = 'executing' group by operation_id",
|
||||
)
|
||||
.fetch_all(&mut **transaction)
|
||||
.await
|
||||
.map_err(AttemptError::from_sql)?;
|
||||
let mut tool_map = std::collections::BTreeMap::new();
|
||||
for row in tool_counts {
|
||||
let key: String = row.try_get("key").map_err(AttemptError::from_sql)?;
|
||||
let count: i64 = row.try_get("count").map_err(AttemptError::from_sql)?;
|
||||
tool_map.insert(key, u64::try_from(count).unwrap_or_default());
|
||||
}
|
||||
|
||||
if u64::try_from(global_executing).unwrap_or(u64::MAX)
|
||||
>= u64::try_from(limits.global_limit).unwrap_or(u64::MAX)
|
||||
{
|
||||
return Ok((None, cursor.clone()));
|
||||
}
|
||||
let agent_executing = agent_map
|
||||
.get(head.entry.agent_key.as_str())
|
||||
.copied()
|
||||
.unwrap_or_default();
|
||||
if agent_executing >= u64::try_from(limits.agent_limit).unwrap_or(u64::MAX) {
|
||||
return Ok((None, cursor.clone()));
|
||||
}
|
||||
let tool_executing = tool_map
|
||||
.get(head.entry.operation_id.as_str())
|
||||
.copied()
|
||||
.unwrap_or_default();
|
||||
if tool_executing >= u64::try_from(limits.tool_limit).unwrap_or(u64::MAX) {
|
||||
return Ok((None, cursor.clone()));
|
||||
}
|
||||
|
||||
sqlx::query(
|
||||
"update execution_admission_entries
|
||||
set state = 'executing', granted_at = clock_timestamp()
|
||||
where ticket_id = $1 and state = 'reserved'",
|
||||
)
|
||||
.bind(i64::try_from(head.entry.ticket_id).unwrap_or(i64::MAX))
|
||||
.execute(&mut **transaction)
|
||||
.await
|
||||
.map_err(AttemptError::from_sql)?;
|
||||
|
||||
sqlx::query(
|
||||
"update execution_admission_controllers
|
||||
set cursor_agent = $2,
|
||||
cursor_agent_credit = $3,
|
||||
cursor_tool = $4,
|
||||
cursor_tool_credit = $5,
|
||||
updated_at = now()
|
||||
where workspace_id = $1",
|
||||
)
|
||||
.bind(workspace_id)
|
||||
.bind(selection.cursor.agent.as_deref())
|
||||
.bind(i32::try_from(selection.cursor.agent_credit).unwrap_or_default())
|
||||
.bind(selection.cursor.tool.as_deref())
|
||||
.bind(i32::try_from(selection.cursor.tool_credit).unwrap_or_default())
|
||||
.execute(&mut **transaction)
|
||||
.await
|
||||
.map_err(AttemptError::from_sql)?;
|
||||
|
||||
Ok((Some(head.task_id), selection.cursor))
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub(super) enum AttemptError {
|
||||
/// Lock or statement timeout: the transaction made no decision and the waiter retries.
|
||||
Contended,
|
||||
/// Bounded queue capacity is exhausted: a typed overload outcome, never an unbounded wait.
|
||||
Overloaded,
|
||||
/// A foreign unique constraint aborted the transaction; the caller rolls back and rereads.
|
||||
UniqueViolation,
|
||||
/// Durable-Task side failure (the Task repository maps it to its own typed error).
|
||||
Failure(TaskError),
|
||||
/// Admission side failure.
|
||||
AdmissionFailure(AdmissionStoreError),
|
||||
}
|
||||
|
||||
impl AttemptError {
|
||||
pub(super) fn from_sql(error: sqlx::Error) -> Self {
|
||||
if let Some(database) = error.as_database_error()
|
||||
&& matches!(database.code().as_deref(), Some("55P03" | "57014"))
|
||||
{
|
||||
return Self::Contended;
|
||||
}
|
||||
Self::AdmissionFailure(PostgresExecutionAdmission::unavailable(error))
|
||||
}
|
||||
}
|
||||
|
||||
async fn lock_controller(
|
||||
transaction: &mut Transaction<'_, Postgres>,
|
||||
workspace_id: &str,
|
||||
) -> Result<AdmissionCursor, AttemptError> {
|
||||
sqlx::query(
|
||||
"update execution_admission_controllers set updated_at = updated_at
|
||||
where workspace_id = $1",
|
||||
)
|
||||
.bind(workspace_id)
|
||||
.execute(&mut **transaction)
|
||||
.await
|
||||
.map_err(AttemptError::from_sql)?;
|
||||
let row = sqlx::query(
|
||||
"select cursor_agent, cursor_agent_credit, cursor_tool, cursor_tool_credit
|
||||
from execution_admission_controllers where workspace_id = $1",
|
||||
)
|
||||
.bind(workspace_id)
|
||||
.fetch_one(&mut **transaction)
|
||||
.await
|
||||
.map_err(AttemptError::from_sql)?;
|
||||
Ok(AdmissionCursor {
|
||||
agent: row
|
||||
.try_get("cursor_agent")
|
||||
.map_err(AttemptError::from_sql)?,
|
||||
agent_credit: u32::try_from(
|
||||
row.try_get::<i32, _>("cursor_agent_credit")
|
||||
.map_err(AttemptError::from_sql)?
|
||||
.max(0),
|
||||
)
|
||||
.unwrap_or_default(),
|
||||
tool: row.try_get("cursor_tool").map_err(AttemptError::from_sql)?,
|
||||
tool_credit: u32::try_from(
|
||||
row.try_get::<i32, _>("cursor_tool_credit")
|
||||
.map_err(AttemptError::from_sql)?
|
||||
.max(0),
|
||||
)
|
||||
.unwrap_or_default(),
|
||||
})
|
||||
}
|
||||
|
||||
async fn scoped_counts(
|
||||
transaction: &mut Transaction<'_, Postgres>,
|
||||
workspace_id: &str,
|
||||
column: &str,
|
||||
) -> Result<BTreeMap<String, u64>, AttemptError> {
|
||||
let statement = if column == "agent_key" {
|
||||
"select agent_key as key, count(*)::bigint as count
|
||||
from execution_admission_entries
|
||||
where workspace_id = $1 and state = 'executing'
|
||||
group by agent_key"
|
||||
} else {
|
||||
"select operation_id as key, count(*)::bigint as count
|
||||
from execution_admission_entries
|
||||
where workspace_id = $1 and state = 'executing'
|
||||
group by operation_id"
|
||||
};
|
||||
let rows = sqlx::query(statement)
|
||||
.bind(workspace_id)
|
||||
.fetch_all(&mut **transaction)
|
||||
.await
|
||||
.map_err(AttemptError::from_sql)?;
|
||||
let mut counts = BTreeMap::new();
|
||||
for row in rows {
|
||||
let key: String = row.try_get("key").map_err(AttemptError::from_sql)?;
|
||||
let count: i64 = row.try_get("count").map_err(AttemptError::from_sql)?;
|
||||
counts.insert(key, u64::try_from(count).unwrap_or_default());
|
||||
}
|
||||
Ok(counts)
|
||||
}
|
||||
|
||||
fn policy_mode_str(request: &AdmissionRequest) -> &'static str {
|
||||
match request.policy_mode {
|
||||
crank_core::ToolExecutionMode::Synchronous => "synchronous",
|
||||
crank_core::ToolExecutionMode::Background => "background",
|
||||
crank_core::ToolExecutionMode::Adaptive => "adaptive",
|
||||
}
|
||||
}
|
||||
@@ -170,6 +170,69 @@ impl PostgresRegistry {
|
||||
.transpose()
|
||||
}
|
||||
|
||||
/// Authoritative revalidation of the Platform API key that authorized a durable Task (Story 4.3).
|
||||
///
|
||||
/// The key is returned only when the exact immutable ID is still active, unexpired and bound to
|
||||
/// the same workspace and agent; otherwise `None`, so a worker fails closed. Only the immutable
|
||||
/// identity is supplied here — the bearer secret is never stored or re-read.
|
||||
pub async fn revalidate_platform_api_key(
|
||||
&self,
|
||||
workspace_id: &WorkspaceId,
|
||||
agent_id: &AgentId,
|
||||
key_id: &PlatformApiKeyId,
|
||||
) -> Result<Option<PlatformApiKeyRecord>, RegistryError> {
|
||||
let row = sqlx::query(
|
||||
"select
|
||||
k.id,
|
||||
k.workspace_id,
|
||||
k.agent_id,
|
||||
k.key_kind,
|
||||
k.name,
|
||||
k.prefix,
|
||||
k.scopes_json,
|
||||
k.status,
|
||||
k.created_at,
|
||||
k.last_used_at,
|
||||
k.expires_at,
|
||||
k.allowed_origins_json
|
||||
from platform_api_keys k
|
||||
where k.id = $1
|
||||
and k.workspace_id = $2
|
||||
and k.agent_id = $3
|
||||
and k.key_kind = 'mcp_client'
|
||||
and k.status = 'active'
|
||||
and (k.expires_at is null or k.expires_at > now())
|
||||
limit 1",
|
||||
)
|
||||
.bind(key_id.as_str())
|
||||
.bind(workspace_id.as_str())
|
||||
.bind(agent_id.as_str())
|
||||
.fetch_optional(&self.pool)
|
||||
.await?;
|
||||
|
||||
row.map(|row| {
|
||||
Ok(PlatformApiKeyRecord {
|
||||
api_key: PlatformApiKey {
|
||||
id: PlatformApiKeyId::new(row.get::<String, _>("id")),
|
||||
workspace_id: WorkspaceId::new(row.get::<String, _>("workspace_id")),
|
||||
agent_id: row.get::<Option<String>, _>("agent_id").map(AgentId::new),
|
||||
key_kind: deserialize_enum_text(&row.get::<String, _>("key_kind"), "key_kind")?,
|
||||
name: row.get("name"),
|
||||
prefix: row.get("prefix"),
|
||||
scopes: deserialize_json_value(row.get::<Value, _>("scopes_json"))?,
|
||||
status: deserialize_enum_text(&row.get::<String, _>("status"), "status")?,
|
||||
created_at: row.get("created_at"),
|
||||
last_used_at: row.get("last_used_at"),
|
||||
expires_at: row.get("expires_at"),
|
||||
allowed_origins: deserialize_json_value(
|
||||
row.get::<Value, _>("allowed_origins_json"),
|
||||
)?,
|
||||
},
|
||||
})
|
||||
})
|
||||
.transpose()
|
||||
}
|
||||
|
||||
pub async fn get_approval_api_key_by_secret_for_agent_slug(
|
||||
&self,
|
||||
workspace_slug: &str,
|
||||
|
||||
@@ -46,6 +46,24 @@ impl PostgresRegistry {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Readiness probe of the mandatory execution-admission state (Story 4.1). A missing or
|
||||
/// unreadable admission schema is a dependency failure, never a degraded-but-ready state.
|
||||
pub async fn execution_admission_health(&self) -> Result<(), crank_core::AdmissionStoreError> {
|
||||
super::admission::admission_health(&self.pool).await
|
||||
}
|
||||
|
||||
/// Readiness probe of the durable Task state (Story 4.2).
|
||||
pub async fn durable_tasks_health(&self) -> Result<(), crank_core::TaskError> {
|
||||
super::tasks::tasks_health(&self.pool).await
|
||||
}
|
||||
|
||||
/// Authoritative admission queue readings for low-cardinality metrics.
|
||||
pub async fn execution_admission_snapshot(
|
||||
&self,
|
||||
) -> Result<crank_core::AdmissionQueueSnapshot, crank_core::AdmissionStoreError> {
|
||||
super::admission::admission_snapshot(&self.pool).await
|
||||
}
|
||||
|
||||
async fn connect_in_schema(
|
||||
database_url: &str,
|
||||
schema: Option<&str>,
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
use super::*;
|
||||
|
||||
const MASTER_KEY_PAGE_LIMIT_MAX: i64 = 10_000;
|
||||
pub(super) const MASTER_KEY_PAGE_LIMIT_MAX: i64 = 10_000;
|
||||
|
||||
impl PostgresRegistry {
|
||||
pub async fn verify_or_register_master_key_identity(
|
||||
@@ -356,12 +356,19 @@ impl PostgresRegistry {
|
||||
return Err(RegistryError::MasterKeyRotationConflict);
|
||||
}
|
||||
|
||||
let total = sqlx::query_scalar::<_, i64>(
|
||||
let secret_total = sqlx::query_scalar::<_, i64>(
|
||||
"select count(*) from secret_versions where master_key_epoch = $1",
|
||||
)
|
||||
.bind(source_epoch)
|
||||
.fetch_one(&mut *tx)
|
||||
.await?;
|
||||
let task_total = sqlx::query_scalar::<_, i64>(
|
||||
"select count(*) from tasks where executable_input_master_key_epoch = $1",
|
||||
)
|
||||
.bind(source_epoch)
|
||||
.fetch_one(&mut *tx)
|
||||
.await?;
|
||||
let total = secret_total + task_total;
|
||||
let rotation_id = format!("master-key-e{source_epoch}-to-e{target_epoch}");
|
||||
let aborted = sqlx::query(
|
||||
"select
|
||||
@@ -403,6 +410,16 @@ impl PostgresRegistry {
|
||||
.bind(target_epoch)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
sqlx::query(
|
||||
"update tasks
|
||||
set target_executable_input_ciphertext = null,
|
||||
target_executable_input_key_version = null,
|
||||
target_executable_input_master_key_epoch = null
|
||||
where target_executable_input_master_key_epoch = $1",
|
||||
)
|
||||
.bind(target_epoch)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
sqlx::query(
|
||||
"update master_key_rotations
|
||||
set state = 'running',
|
||||
@@ -662,9 +679,24 @@ impl PostgresRegistry {
|
||||
.bind(rotation.target_epoch)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
sqlx::query(
|
||||
"update tasks
|
||||
set executable_input_ciphertext = target_executable_input_ciphertext,
|
||||
executable_input_key_version = target_executable_input_key_version,
|
||||
executable_input_master_key_epoch = target_executable_input_master_key_epoch,
|
||||
target_executable_input_ciphertext = null,
|
||||
target_executable_input_key_version = null,
|
||||
target_executable_input_master_key_epoch = null
|
||||
where executable_input_master_key_epoch = $1
|
||||
and target_executable_input_master_key_epoch = $2",
|
||||
)
|
||||
.bind(rotation.source_epoch)
|
||||
.bind(rotation.target_epoch)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
sqlx::query(
|
||||
"update master_key_rotations
|
||||
set state = 'promoted',
|
||||
set state = 'promoted',
|
||||
updated_at = $2::timestamptz
|
||||
where id = $1",
|
||||
)
|
||||
@@ -697,6 +729,16 @@ impl PostgresRegistry {
|
||||
.bind(rotation.target_epoch)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
sqlx::query(
|
||||
"update tasks
|
||||
set target_executable_input_ciphertext = null,
|
||||
target_executable_input_key_version = null,
|
||||
target_executable_input_master_key_epoch = null
|
||||
where target_executable_input_master_key_epoch = $1",
|
||||
)
|
||||
.bind(rotation.target_epoch)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
sqlx::query(
|
||||
"update master_key_rotations
|
||||
set state = 'aborted',
|
||||
@@ -883,7 +925,7 @@ async fn select_active_master_key_identity_for_update(
|
||||
Ok(row.map(map_master_key_identity))
|
||||
}
|
||||
|
||||
async fn select_master_key_rotation_for_update(
|
||||
pub(super) async fn select_master_key_rotation_for_update(
|
||||
transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
|
||||
rotation_id: &str,
|
||||
) -> Result<MasterKeyRotationRecord, RegistryError> {
|
||||
@@ -915,16 +957,19 @@ async fn select_master_key_rotation_for_update(
|
||||
})
|
||||
}
|
||||
|
||||
async fn count_staged_rotation_targets(
|
||||
pub(super) async fn count_staged_rotation_targets(
|
||||
transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
|
||||
source_epoch: i64,
|
||||
target_epoch: i64,
|
||||
) -> Result<i64, RegistryError> {
|
||||
let count = sqlx::query_scalar::<_, i64>(
|
||||
"select count(*)
|
||||
from secret_versions
|
||||
where master_key_epoch = $1
|
||||
and target_master_key_epoch = $2",
|
||||
"select
|
||||
(select count(*) from secret_versions
|
||||
where master_key_epoch = $1
|
||||
and target_master_key_epoch = $2) +
|
||||
(select count(*) from tasks
|
||||
where executable_input_master_key_epoch = $1
|
||||
and target_executable_input_master_key_epoch = $2)",
|
||||
)
|
||||
.bind(source_epoch)
|
||||
.bind(target_epoch)
|
||||
|
||||
@@ -0,0 +1,143 @@
|
||||
//! Task ciphertext paging/staging of the master-key rotation (Story 4.3).
|
||||
//!
|
||||
//! Extracted from `master_key.rs` without logic changes so that module stays within the
|
||||
//! code-health line limit; the operations and their SQL are unchanged.
|
||||
|
||||
use super::master_key::{
|
||||
MASTER_KEY_PAGE_LIMIT_MAX, count_staged_rotation_targets, select_master_key_rotation_for_update,
|
||||
};
|
||||
use super::*;
|
||||
|
||||
fn map_master_key_task_version(
|
||||
row: sqlx::postgres::PgRow,
|
||||
) -> Result<MasterKeyTaskVersion, RegistryError> {
|
||||
Ok(MasterKeyTaskVersion {
|
||||
task_id: row.get::<String, _>("task_id"),
|
||||
ciphertext: row
|
||||
.get::<Option<String>, _>("executable_input_ciphertext")
|
||||
.unwrap_or_default(),
|
||||
key_version: row
|
||||
.get::<Option<String>, _>("executable_input_key_version")
|
||||
.unwrap_or_default(),
|
||||
epoch: row
|
||||
.get::<Option<i64>, _>("executable_input_master_key_epoch")
|
||||
.unwrap_or_default(),
|
||||
target_ciphertext: row.get::<Option<String>, _>("target_executable_input_ciphertext"),
|
||||
target_key_version: row.get::<Option<String>, _>("target_executable_input_key_version"),
|
||||
target_epoch: row.get::<Option<i64>, _>("target_executable_input_master_key_epoch"),
|
||||
})
|
||||
}
|
||||
|
||||
impl PostgresRegistry {
|
||||
pub async fn list_tasks_for_master_key_epoch_page(
|
||||
&self,
|
||||
epoch: i64,
|
||||
after_task_id: Option<&str>,
|
||||
limit: i64,
|
||||
) -> Result<Vec<MasterKeyTaskVersion>, RegistryError> {
|
||||
if epoch < 1 || !(1..=MASTER_KEY_PAGE_LIMIT_MAX).contains(&limit) {
|
||||
return Err(RegistryError::InvalidMasterKeyIdentity);
|
||||
}
|
||||
let rows = sqlx::query(
|
||||
"select task_id::text as task_id, executable_input_ciphertext, executable_input_key_version, executable_input_master_key_epoch, target_executable_input_ciphertext, target_executable_input_key_version, target_executable_input_master_key_epoch from tasks where executable_input_master_key_epoch = $1 and ($2::text is null or task_id::text > $2::text) order by task_id asc limit $3",
|
||||
)
|
||||
.bind(epoch)
|
||||
.bind(after_task_id)
|
||||
.bind(limit)
|
||||
.fetch_all(&self.pool)
|
||||
.await?;
|
||||
rows.into_iter().map(map_master_key_task_version).collect()
|
||||
}
|
||||
|
||||
pub async fn list_target_tasks_for_master_key_rotation_page(
|
||||
&self,
|
||||
target_epoch: i64,
|
||||
after_task_id: Option<&str>,
|
||||
limit: i64,
|
||||
) -> Result<Vec<MasterKeyTaskVersion>, RegistryError> {
|
||||
if target_epoch < 1 || !(1..=MASTER_KEY_PAGE_LIMIT_MAX).contains(&limit) {
|
||||
return Err(RegistryError::InvalidMasterKeyIdentity);
|
||||
}
|
||||
let rows = sqlx::query(
|
||||
"select task_id::text as task_id, executable_input_ciphertext, executable_input_key_version, executable_input_master_key_epoch, target_executable_input_ciphertext, target_executable_input_key_version, target_executable_input_master_key_epoch from tasks where target_executable_input_master_key_epoch = $1 and ($2::text is null or task_id::text > $2::text) order by task_id asc limit $3",
|
||||
)
|
||||
.bind(target_epoch)
|
||||
.bind(after_task_id)
|
||||
.bind(limit)
|
||||
.fetch_all(&self.pool)
|
||||
.await?;
|
||||
rows.into_iter().map(map_master_key_task_version).collect()
|
||||
}
|
||||
|
||||
pub async fn stage_master_key_rotation_task_ciphertext(
|
||||
&self,
|
||||
rotation_id: &str,
|
||||
task_id: &str,
|
||||
source_epoch: i64,
|
||||
target_ciphertext: &str,
|
||||
target_key_version: &str,
|
||||
target_epoch: i64,
|
||||
now: &OffsetDateTime,
|
||||
) -> Result<MasterKeyRotationRecord, RegistryError> {
|
||||
let mut tx = self.pool.begin().await?;
|
||||
let rotation = select_master_key_rotation_for_update(&mut tx, rotation_id).await?;
|
||||
if rotation.state != "running"
|
||||
|| rotation.source_epoch != source_epoch
|
||||
|| rotation.target_epoch != target_epoch
|
||||
{
|
||||
return Err(RegistryError::MasterKeyRotationConflict);
|
||||
}
|
||||
let result = sqlx::query(
|
||||
"update tasks
|
||||
set target_executable_input_ciphertext = $3,
|
||||
target_executable_input_key_version = $4,
|
||||
target_executable_input_master_key_epoch = $5
|
||||
where task_id::text = $1
|
||||
and executable_input_master_key_epoch = $2
|
||||
and (
|
||||
target_executable_input_master_key_epoch is null
|
||||
or target_executable_input_master_key_epoch = $5
|
||||
)
|
||||
and (
|
||||
target_executable_input_ciphertext is null
|
||||
or target_executable_input_ciphertext = $3
|
||||
)",
|
||||
)
|
||||
.bind(task_id)
|
||||
.bind(source_epoch)
|
||||
.bind(target_ciphertext)
|
||||
.bind(target_key_version)
|
||||
.bind(target_epoch)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
if result.rows_affected() != 1 {
|
||||
return Err(RegistryError::MasterKeyRotationConflict);
|
||||
}
|
||||
let processed = count_staged_rotation_targets(&mut tx, source_epoch, target_epoch).await?;
|
||||
sqlx::query(
|
||||
"update master_key_rotations
|
||||
set checkpoint_secret_id = checkpoint_secret_id,
|
||||
processed_secret_versions = $2,
|
||||
updated_at = $3::timestamptz
|
||||
where id = $1",
|
||||
)
|
||||
.bind(rotation_id)
|
||||
.bind(processed)
|
||||
.bind(now)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
let updated = select_master_key_rotation_for_update(&mut tx, rotation_id).await?;
|
||||
tx.commit().await?;
|
||||
Ok(updated)
|
||||
}
|
||||
}
|
||||
|
||||
pub struct MasterKeyTaskVersion {
|
||||
pub task_id: String,
|
||||
pub ciphertext: String,
|
||||
pub key_version: String,
|
||||
pub epoch: i64,
|
||||
pub target_ciphertext: Option<String>,
|
||||
pub target_key_version: Option<String>,
|
||||
pub target_epoch: Option<i64>,
|
||||
}
|
||||
@@ -1,3 +1,4 @@
|
||||
mod admission;
|
||||
mod agent;
|
||||
mod agent_catalog;
|
||||
mod agent_prompt_bindings;
|
||||
@@ -9,6 +10,7 @@ mod auth;
|
||||
mod connection;
|
||||
mod import_job;
|
||||
mod master_key;
|
||||
mod master_key_tasks;
|
||||
mod observability;
|
||||
mod onboarding;
|
||||
mod onboarding_import;
|
||||
@@ -20,6 +22,7 @@ mod product_event;
|
||||
mod prompt;
|
||||
mod resource;
|
||||
mod secret;
|
||||
mod tasks;
|
||||
mod upstream;
|
||||
mod workspace;
|
||||
mod yaml_import;
|
||||
@@ -36,8 +39,13 @@ use serde_json::Value;
|
||||
use sqlx::{PgPool, Postgres, Row, Transaction, postgres::PgRow, types::Json};
|
||||
use time::OffsetDateTime;
|
||||
|
||||
pub use admission::{
|
||||
AdmissionLimits, PostgresExecutionAdmission, admission_health, admission_snapshot,
|
||||
};
|
||||
pub use pool_config::{PostgresPoolConfig, PostgresPoolConfigError};
|
||||
pub use resource::{AuthorizedResourceRead, BoundResourceAdmission};
|
||||
pub use tasks::PostgresTaskStore;
|
||||
pub use tasks::tasks_health;
|
||||
|
||||
use crate::{
|
||||
error::RegistryError,
|
||||
|
||||
@@ -0,0 +1,984 @@
|
||||
//! PostgreSQL implementation of the durable Task store (Story 4.2, FR-22/FR-23).
|
||||
//!
|
||||
//! One PostgreSQL transaction owns the whole acceptance: Task record, dispatch intent
|
||||
//! (`execution_admission_entries.task_id`) and its queue slot commit together, so no Task ID and no
|
||||
//! acknowledgement can exist without the durable record. The transaction reuses the transaction-aware
|
||||
//! primitives of the execution-admission store (`lock_admission_in_tx`, `bounded_queue_len`,
|
||||
//! `insert_admission_entry`) instead of copying capacity SQL or starting a nested transaction.
|
||||
//!
|
||||
//! Replay is resolved before any capacity mutation and never touches the accepted row. An ambiguous
|
||||
//! COMMIT is reported as an unavailable store: it is never treated as a proven rollback, so no
|
||||
//! compensating delete and no synchronous fallback can happen after an uncertain acceptance.
|
||||
|
||||
use async_trait::async_trait;
|
||||
use crank_core::{
|
||||
AdmissionMode, AdmissionRequest, AdmissionScope, ApprovalEvidence, NoTasksFallback,
|
||||
PlatformApiKeyId, TaskAcceptRequest, TaskAcceptance, TaskAccess, TaskEnvelope, TaskError,
|
||||
TaskFinishRequest, TaskId, TaskLease, TaskOwnerKind, TaskPins, TaskPurgeReport, TaskRecord,
|
||||
TaskState, TaskStore, TaskSupportIds, ToolExecutionMode,
|
||||
};
|
||||
use serde_json::Value;
|
||||
use sqlx::{PgPool, Postgres, Row, Transaction};
|
||||
use uuid::Uuid;
|
||||
|
||||
use super::admission::{
|
||||
AdmissionLimits, AttemptError, bounded_queue_len, cleanup_expired_unlinked,
|
||||
insert_admission_entry, lock_admission_in_tx,
|
||||
};
|
||||
|
||||
const TASK_PROJECTION: &str = "task_id, state, workspace_id, owner_kind, owner_id,
|
||||
authorization_scope, platform_api_key_id, operation_id, input_fingerprint, operation_version,
|
||||
policy_mode,
|
||||
approval_reference,
|
||||
request_id, trace_id, traceparent, trace_sampled, input_envelope, progress_envelope,
|
||||
result_envelope, error_envelope, attempts, fence, lease_owner, lease_until,
|
||||
(extract(epoch from lease_until) * 1000)::bigint as lease_until_ms,
|
||||
current_attempt_id, dispatch_started_at,
|
||||
(extract(epoch from dispatch_started_at) * 1000)::bigint as dispatch_started_at_ms, version,
|
||||
(extract(epoch from execution_deadline) * 1000)::bigint as execution_deadline_ms,
|
||||
(extract(epoch from retain_until) * 1000)::bigint as retain_until_ms,
|
||||
(extract(epoch from created_at) * 1000)::bigint as created_ms,
|
||||
(extract(epoch from updated_at) * 1000)::bigint as updated_ms";
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct PostgresTaskStore {
|
||||
pool: PgPool,
|
||||
limits: AdmissionLimits,
|
||||
scheduler: crank_core::AdmissionSchedulerConfig,
|
||||
}
|
||||
|
||||
impl PostgresTaskStore {
|
||||
pub fn new(
|
||||
pool: PgPool,
|
||||
limits: AdmissionLimits,
|
||||
scheduler: crank_core::AdmissionSchedulerConfig,
|
||||
) -> Result<Self, TaskError> {
|
||||
limits
|
||||
.validate()
|
||||
.map_err(|error| TaskError::invalid(error.to_string()))?;
|
||||
scheduler
|
||||
.validate()
|
||||
.map_err(|error| TaskError::invalid(error.to_string()))?;
|
||||
Ok(Self {
|
||||
pool,
|
||||
limits,
|
||||
scheduler,
|
||||
})
|
||||
}
|
||||
|
||||
fn unavailable(error: impl std::fmt::Display) -> TaskError {
|
||||
TaskError::unavailable(format!("durable task store is unavailable: {error}"))
|
||||
}
|
||||
|
||||
async fn start(&self) -> Result<Transaction<'_, Postgres>, TaskError> {
|
||||
let mut transaction = self.pool.begin().await.map_err(Self::unavailable)?;
|
||||
sqlx::query("set local lock_timeout = '3000ms'")
|
||||
.execute(&mut *transaction)
|
||||
.await
|
||||
.map_err(Self::unavailable)?;
|
||||
sqlx::query("set local statement_timeout = '5000ms'")
|
||||
.execute(&mut *transaction)
|
||||
.await
|
||||
.map_err(Self::unavailable)?;
|
||||
Ok(transaction)
|
||||
}
|
||||
|
||||
/// Scoped lookup of an accepted Task. The full owner/authorization/Tool predicate is part of the
|
||||
/// query, so a foreign row is never fetched.
|
||||
async fn stored_acceptance(
|
||||
&self,
|
||||
transaction: &mut Transaction<'_, Postgres>,
|
||||
request: &TaskAcceptRequest,
|
||||
) -> Result<Option<(TaskAcceptance, String)>, AttemptError> {
|
||||
let row = sqlx::query(sqlx::AssertSqlSafe(format!(
|
||||
"select {TASK_PROJECTION} from tasks
|
||||
where workspace_id = $1 and owner_kind = $2 and owner_id = $3
|
||||
and authorization_scope = $4 and operation_id = $5 and scoped_key = $6"
|
||||
)))
|
||||
.bind(&request.workspace_id)
|
||||
.bind(request.owner_kind.as_str())
|
||||
.bind(&request.owner_id)
|
||||
.bind(&request.authorization_scope)
|
||||
.bind(&request.operation_id)
|
||||
.bind(&request.scoped_key)
|
||||
.fetch_optional(&mut **transaction)
|
||||
.await
|
||||
.map_err(AttemptError::from_sql)?;
|
||||
let Some(row) = row else {
|
||||
return Ok(None);
|
||||
};
|
||||
let record = record_from_row(&row).map_err(AttemptError::Failure)?;
|
||||
Ok(Some((
|
||||
acceptance_from_record(&record),
|
||||
record.input_fingerprint,
|
||||
)))
|
||||
}
|
||||
}
|
||||
|
||||
fn acceptance_from_record(record: &TaskRecord) -> TaskAcceptance {
|
||||
TaskAcceptance {
|
||||
task_id: record.task_id,
|
||||
state: record.state,
|
||||
operation_version: record.pins.operation_version,
|
||||
support: record.support.clone(),
|
||||
created_at_unix_ms: record.created_at_unix_ms,
|
||||
retain_until_unix_ms: record.pins.retain_until_unix_ms,
|
||||
replayed: true,
|
||||
}
|
||||
}
|
||||
|
||||
/// Readiness probe of the durable Task state: the table must be reachable and readable. A missing or
|
||||
/// unreadable schema is a dependency failure, never a degraded-but-ready state.
|
||||
pub async fn tasks_health(pool: &PgPool) -> Result<(), TaskError> {
|
||||
sqlx::query("select count(*)::bigint from tasks where false")
|
||||
.fetch_one(pool)
|
||||
.await
|
||||
.map_err(PostgresTaskStore::unavailable)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// One transaction's decision of the acceptance path.
|
||||
enum Accepted {
|
||||
Created(TaskAcceptance),
|
||||
Replayed(TaskAcceptance),
|
||||
Conflict,
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl TaskStore for PostgresTaskStore {
|
||||
async fn health(&self) -> Result<(), TaskError> {
|
||||
sqlx::query("select count(*)::bigint from tasks where false")
|
||||
.fetch_one(&self.pool)
|
||||
.await
|
||||
.map_err(Self::unavailable)?;
|
||||
super::admission::admission_health(&self.pool)
|
||||
.await
|
||||
.map_err(|error| TaskError::unavailable(error.to_string()))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn accept(&self, request: TaskAcceptRequest) -> Result<TaskAcceptance, TaskError> {
|
||||
request.validate()?;
|
||||
let mut transaction = self.start().await?;
|
||||
super::master_key::ensure_no_active_master_key_rotation(&mut transaction)
|
||||
.await
|
||||
.map_err(|error| match error {
|
||||
crate::RegistryError::Storage(_) => TaskError::unavailable(error.to_string()),
|
||||
_ => TaskError::StateConflict,
|
||||
})?;
|
||||
if let Some(epoch) = request.executable_input_master_key_epoch {
|
||||
super::master_key::ensure_active_master_key_epoch(&mut transaction, epoch)
|
||||
.await
|
||||
.map_err(|error| match error {
|
||||
crate::RegistryError::Storage(_) => TaskError::unavailable(error.to_string()),
|
||||
_ => TaskError::StateConflict,
|
||||
})?;
|
||||
}
|
||||
let outcome = self.accept_locked(&mut transaction, &request).await;
|
||||
match outcome {
|
||||
Ok(Accepted::Created(acceptance) | Accepted::Replayed(acceptance)) => {
|
||||
// The acknowledgement of a created Task is only possible after a real COMMIT.
|
||||
transaction.commit().await.map_err(Self::unavailable)?;
|
||||
Ok(TaskAcceptance {
|
||||
replayed: acceptance.replayed,
|
||||
..acceptance
|
||||
})
|
||||
}
|
||||
Ok(Accepted::Conflict) => {
|
||||
transaction.rollback().await.ok();
|
||||
Err(TaskError::FingerprintConflict)
|
||||
}
|
||||
Err(AttemptError::Overloaded) => {
|
||||
transaction.rollback().await.ok();
|
||||
Err(TaskError::Overloaded {
|
||||
retry_after_ms: crank_core::ADMISSION_OVERLOAD_RETRY_AFTER_MS,
|
||||
})
|
||||
}
|
||||
Err(AttemptError::Contended) => {
|
||||
transaction.rollback().await.ok();
|
||||
Err(TaskError::unavailable(
|
||||
"durable task acceptance could not take the admission locks",
|
||||
))
|
||||
}
|
||||
Err(AttemptError::UniqueViolation) => {
|
||||
// Roll back the aborted transaction, then reread the scoped key once outside it.
|
||||
transaction.rollback().await.ok();
|
||||
self.reread_after_unique(&request).await
|
||||
}
|
||||
Err(AttemptError::Failure(error)) => {
|
||||
transaction.rollback().await.ok();
|
||||
Err(error)
|
||||
}
|
||||
Err(AttemptError::AdmissionFailure(error)) => {
|
||||
transaction.rollback().await.ok();
|
||||
Err(TaskError::unavailable(error.to_string()))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn read(&self, access: &TaskAccess, task_id: TaskId) -> Result<TaskRecord, TaskError> {
|
||||
access.validate()?;
|
||||
let row = sqlx::query(sqlx::AssertSqlSafe(format!(
|
||||
"select {TASK_PROJECTION} from tasks
|
||||
where task_id = $1 and workspace_id = $2 and owner_kind = $3
|
||||
and owner_id = $4 and authorization_scope = $5"
|
||||
)))
|
||||
.bind(task_id.as_uuid())
|
||||
.bind(&access.workspace_id)
|
||||
.bind(access.owner_kind.as_str())
|
||||
.bind(&access.owner_id)
|
||||
.bind(&access.authorization_scope)
|
||||
.fetch_optional(&self.pool)
|
||||
.await
|
||||
.map_err(Self::unavailable)?;
|
||||
let Some(row) = row else {
|
||||
return Err(TaskError::NotFound);
|
||||
};
|
||||
record_from_row(&row).map_err(Self::unavailable)
|
||||
}
|
||||
|
||||
async fn find(
|
||||
&self,
|
||||
access: &TaskAccess,
|
||||
operation_id: &str,
|
||||
scoped_key: &str,
|
||||
) -> Result<Option<TaskRecord>, TaskError> {
|
||||
access.validate()?;
|
||||
let row = sqlx::query(sqlx::AssertSqlSafe(format!(
|
||||
"select {TASK_PROJECTION} from tasks
|
||||
where workspace_id = $1 and owner_kind = $2 and owner_id = $3
|
||||
and authorization_scope = $4 and operation_id = $5 and scoped_key = $6"
|
||||
)))
|
||||
.bind(&access.workspace_id)
|
||||
.bind(access.owner_kind.as_str())
|
||||
.bind(&access.owner_id)
|
||||
.bind(&access.authorization_scope)
|
||||
.bind(operation_id)
|
||||
.bind(scoped_key)
|
||||
.fetch_optional(&self.pool)
|
||||
.await
|
||||
.map_err(Self::unavailable)?;
|
||||
row.map(|row| record_from_row(&row)).transpose()
|
||||
}
|
||||
|
||||
async fn finish(&self, request: TaskFinishRequest) -> Result<TaskRecord, TaskError> {
|
||||
request.validate()?;
|
||||
let mut transaction = self.start().await?;
|
||||
let access = &request.access;
|
||||
let update = sqlx::query(sqlx::AssertSqlSafe(format!(
|
||||
"update tasks
|
||||
set state = $1,
|
||||
result_envelope = $2,
|
||||
error_envelope = $3,
|
||||
version = version + 1,
|
||||
updated_at = now()
|
||||
where task_id = $4 and workspace_id = $5 and owner_kind = $6
|
||||
and owner_id = $7 and authorization_scope = $8
|
||||
and state = $9 and version = $10
|
||||
and (lease_owner is null or fence = 0)
|
||||
returning {TASK_PROJECTION}"
|
||||
)))
|
||||
.bind(request.target_state.as_str())
|
||||
.bind(request.result.as_ref().map(|value| value.value().clone()))
|
||||
.bind(request.error.as_ref().map(|value| value.value().clone()))
|
||||
.bind(request.task_id.as_uuid())
|
||||
.bind(&access.workspace_id)
|
||||
.bind(access.owner_kind.as_str())
|
||||
.bind(&access.owner_id)
|
||||
.bind(&access.authorization_scope)
|
||||
.bind(request.expected_state.as_str())
|
||||
.bind(i64::from(request.expected_version))
|
||||
.fetch_optional(&mut *transaction)
|
||||
.await
|
||||
.map_err(Self::unavailable)?;
|
||||
let Some(row) = update else {
|
||||
transaction.rollback().await.ok();
|
||||
return Err(self.classify_missed_finish(&request).await);
|
||||
};
|
||||
let record = record_from_row(&row).map_err(Self::unavailable)?;
|
||||
// Terminal Task and its dispatch intent leave together: a half-done release is rolled back.
|
||||
sqlx::query("delete from execution_admission_entries where task_id = $1")
|
||||
.bind(request.task_id.as_uuid())
|
||||
.execute(&mut *transaction)
|
||||
.await
|
||||
.map_err(Self::unavailable)?;
|
||||
transaction.commit().await.map_err(Self::unavailable)?;
|
||||
Ok(record)
|
||||
}
|
||||
|
||||
async fn purge_expired(&self, batch: u32) -> Result<TaskPurgeReport, TaskError> {
|
||||
let batch = i64::from(batch.clamp(1, crank_core::TASK_PURGE_BATCH_LIMIT));
|
||||
let mut transaction = self.start().await?;
|
||||
super::master_key::ensure_no_active_master_key_rotation(&mut transaction)
|
||||
.await
|
||||
.map_err(|error| match error {
|
||||
crate::RegistryError::Storage(_) => TaskError::unavailable(error.to_string()),
|
||||
_ => TaskError::StateConflict,
|
||||
})?;
|
||||
let expired = sqlx::query(
|
||||
"with expired as (
|
||||
update tasks
|
||||
set state = 'failed',
|
||||
error_envelope = jsonb_build_object('reason', 'execution_deadline_elapsed'),
|
||||
version = version + 1,
|
||||
updated_at = now()
|
||||
where task_id in (
|
||||
select task_id from tasks
|
||||
where state = 'queued' and execution_deadline <= now()
|
||||
and lease_owner is null
|
||||
order by task_id
|
||||
limit $1
|
||||
)
|
||||
returning task_id
|
||||
), released as (
|
||||
delete from execution_admission_entries
|
||||
where task_id in (select task_id from expired)
|
||||
returning task_id
|
||||
)
|
||||
select (select count(*) from expired)::bigint as expired_queued",
|
||||
)
|
||||
.bind(batch)
|
||||
.fetch_one(&mut *transaction)
|
||||
.await
|
||||
.map_err(Self::unavailable)?;
|
||||
let expired_queued: i64 = expired
|
||||
.try_get("expired_queued")
|
||||
.map_err(Self::unavailable)?;
|
||||
let purged = sqlx::query(
|
||||
"delete from tasks
|
||||
where task_id in (
|
||||
select task_id from tasks
|
||||
where state in ('completed', 'failed', 'cancelled') and retain_until <= now()
|
||||
order by task_id
|
||||
limit $1
|
||||
)",
|
||||
)
|
||||
.bind(batch)
|
||||
.execute(&mut *transaction)
|
||||
.await
|
||||
.map_err(Self::unavailable)?;
|
||||
transaction.commit().await.map_err(Self::unavailable)?;
|
||||
Ok(TaskPurgeReport {
|
||||
expired_queued: u64::try_from(expired_queued).unwrap_or_default(),
|
||||
expired_terminal: purged.rows_affected(),
|
||||
})
|
||||
}
|
||||
|
||||
async fn claim_batch(
|
||||
&self,
|
||||
owner: &str,
|
||||
batch_limit: u32,
|
||||
lease_ms: i64,
|
||||
) -> Result<Vec<TaskLease>, TaskError> {
|
||||
let batch = (batch_limit.clamp(1, 64)) as usize;
|
||||
// A checkpointed attempt is never redispatched: once its lease expires the outbound outcome
|
||||
// is uncertain, so it resolves to outcome_unknown and releases its admission slot. Story 4.4
|
||||
// owns any later retry/cancellation of that uncertain outcome.
|
||||
let mut transaction = self.start().await?;
|
||||
sqlx::query(
|
||||
"with candidates as (
|
||||
select task_id from tasks
|
||||
where state = 'working' and lease_owner is not null
|
||||
and current_attempt_id is not null
|
||||
and lease_until < clock_timestamp()
|
||||
order by task_id
|
||||
limit 64
|
||||
), resolved as (
|
||||
update tasks
|
||||
set state = 'outcome_unknown',
|
||||
lease_owner = null,
|
||||
lease_until = null,
|
||||
version = version + 1,
|
||||
updated_at = now()
|
||||
where task_id in (select task_id from candidates)
|
||||
and state = 'working'
|
||||
returning task_id
|
||||
)
|
||||
delete from execution_admission_entries
|
||||
where task_id in (select task_id from resolved)",
|
||||
)
|
||||
.execute(&mut *transaction)
|
||||
.await
|
||||
.map_err(Self::unavailable)?;
|
||||
|
||||
// A crash before the durable dispatch checkpoint left the Task queued for execution: its
|
||||
// admission intent is re-armed as reserved and the Task becomes claimable again. Recovery is
|
||||
// bounded by the <=30s lease expiry, inside the 60s story budget.
|
||||
sqlx::query(
|
||||
"with candidates as (
|
||||
select task_id from tasks
|
||||
where state = 'working' and lease_owner is not null
|
||||
and current_attempt_id is null
|
||||
and lease_until < clock_timestamp()
|
||||
order by task_id
|
||||
limit 64
|
||||
), requeued as (
|
||||
update tasks
|
||||
set state = 'queued',
|
||||
lease_owner = null,
|
||||
lease_until = null,
|
||||
version = version + 1,
|
||||
updated_at = now()
|
||||
where task_id in (select task_id from candidates)
|
||||
and state = 'working'
|
||||
returning task_id
|
||||
)
|
||||
update execution_admission_entries
|
||||
set state = 'reserved', granted_at = null
|
||||
where task_id in (select task_id from requeued) and state = 'executing'",
|
||||
)
|
||||
.execute(&mut *transaction)
|
||||
.await
|
||||
.map_err(Self::unavailable)?;
|
||||
transaction.commit().await.map_err(Self::unavailable)?;
|
||||
|
||||
let mut leases = Vec::new();
|
||||
for _ in 0..batch {
|
||||
let mut transaction = self.start().await?;
|
||||
let workspace_cursor =
|
||||
match super::admission::lock_admission_in_tx(&mut transaction, "*").await {
|
||||
Ok(cursor) => cursor,
|
||||
Err(error) => {
|
||||
transaction.rollback().await.ok();
|
||||
return Err(TaskError::unavailable(format!("{error:?}")));
|
||||
}
|
||||
};
|
||||
let (task_id, _updated_cursor) = match super::admission::grant_next_task(
|
||||
&mut transaction,
|
||||
"*",
|
||||
&workspace_cursor,
|
||||
&self.limits,
|
||||
self.scheduler,
|
||||
)
|
||||
.await
|
||||
{
|
||||
Ok(value) => value,
|
||||
Err(error) => {
|
||||
transaction.rollback().await.ok();
|
||||
return Err(TaskError::unavailable(format!("{error:?}")));
|
||||
}
|
||||
};
|
||||
// Persist the updated controller cursor even when no task is granted.
|
||||
let Some(task_id) = task_id else {
|
||||
transaction.commit().await.map_err(Self::unavailable)?;
|
||||
break;
|
||||
};
|
||||
let row = sqlx::query(sqlx::AssertSqlSafe(format!(
|
||||
"update tasks
|
||||
set state = 'working',
|
||||
lease_owner = $1,
|
||||
lease_until = clock_timestamp() + ($2::bigint || ' milliseconds')::interval,
|
||||
fence = fence + 1,
|
||||
updated_at = now()
|
||||
where task_id = $3
|
||||
and (
|
||||
(state = 'queued' and lease_owner is null)
|
||||
or (state = 'working' and lease_owner is not null
|
||||
and lease_until < clock_timestamp() and current_attempt_id is null)
|
||||
)
|
||||
returning {TASK_PROJECTION}"
|
||||
)))
|
||||
.bind(owner)
|
||||
.bind(lease_ms)
|
||||
.bind(task_id)
|
||||
.fetch_optional(&mut *transaction)
|
||||
.await
|
||||
.map_err(Self::unavailable)?;
|
||||
// Persist cursor update (grant_next_task already did it) regardless.
|
||||
let Some(row) = row else {
|
||||
transaction.rollback().await.ok();
|
||||
break;
|
||||
};
|
||||
let record = record_from_row(&row).map_err(Self::unavailable)?;
|
||||
leases.push(TaskLease {
|
||||
owner: owner.to_owned(),
|
||||
fence: record.fence,
|
||||
lease_until: record.lease_until_unix_ms.unwrap_or_default(),
|
||||
record,
|
||||
});
|
||||
transaction.commit().await.map_err(Self::unavailable)?;
|
||||
}
|
||||
Ok(leases)
|
||||
}
|
||||
|
||||
async fn renew_lease(
|
||||
&self,
|
||||
owner: &str,
|
||||
task_id: TaskId,
|
||||
fence: u64,
|
||||
lease_ms: i64,
|
||||
) -> Result<TaskLease, TaskError> {
|
||||
let mut transaction = self.start().await?;
|
||||
let row = sqlx::query(sqlx::AssertSqlSafe(format!(
|
||||
"update tasks
|
||||
set lease_until = clock_timestamp() + ($1::bigint || ' milliseconds')::interval,
|
||||
updated_at = now()
|
||||
where task_id = $2 and lease_owner = $3 and fence = $4
|
||||
and lease_until > clock_timestamp()
|
||||
returning {TASK_PROJECTION}"
|
||||
)))
|
||||
.bind(lease_ms)
|
||||
.bind(task_id.as_uuid())
|
||||
.bind(owner)
|
||||
.bind(i64::try_from(fence).unwrap_or_default())
|
||||
.fetch_optional(&mut *transaction)
|
||||
.await
|
||||
.map_err(Self::unavailable)?;
|
||||
let Some(row) = row else {
|
||||
transaction.rollback().await.ok();
|
||||
return Err(TaskError::StateConflict);
|
||||
};
|
||||
let record = record_from_row(&row).map_err(Self::unavailable)?;
|
||||
let lease = TaskLease {
|
||||
owner: owner.to_owned(),
|
||||
fence: record.fence,
|
||||
lease_until: record.lease_until_unix_ms.unwrap_or_default(),
|
||||
record,
|
||||
};
|
||||
transaction.commit().await.map_err(Self::unavailable)?;
|
||||
Ok(lease)
|
||||
}
|
||||
|
||||
async fn write_progress(
|
||||
&self,
|
||||
owner: &str,
|
||||
task_id: TaskId,
|
||||
fence: u64,
|
||||
progress: TaskEnvelope,
|
||||
) -> Result<TaskRecord, TaskError> {
|
||||
let mut transaction = self.start().await?;
|
||||
let row = sqlx::query(sqlx::AssertSqlSafe(format!(
|
||||
"update tasks
|
||||
set progress_envelope = $1, updated_at = now()
|
||||
where task_id = $2 and lease_owner = $3 and fence = $4
|
||||
and lease_until > clock_timestamp()
|
||||
returning {TASK_PROJECTION}"
|
||||
)))
|
||||
.bind(progress.value().clone())
|
||||
.bind(task_id.as_uuid())
|
||||
.bind(owner)
|
||||
.bind(i64::try_from(fence).unwrap_or_default())
|
||||
.fetch_optional(&mut *transaction)
|
||||
.await
|
||||
.map_err(Self::unavailable)?;
|
||||
let Some(row) = row else {
|
||||
transaction.rollback().await.ok();
|
||||
return Err(TaskError::StateConflict);
|
||||
};
|
||||
let record = record_from_row(&row).map_err(Self::unavailable)?;
|
||||
transaction.commit().await.map_err(Self::unavailable)?;
|
||||
Ok(record)
|
||||
}
|
||||
|
||||
async fn read_executable_input(
|
||||
&self,
|
||||
owner: &str,
|
||||
task_id: TaskId,
|
||||
fence: u64,
|
||||
) -> Result<(String, String, i64), TaskError> {
|
||||
let row = sqlx::query(
|
||||
"select executable_input_ciphertext, executable_input_key_version, executable_input_master_key_epoch
|
||||
from tasks
|
||||
where task_id = $1 and state = 'working' and lease_owner = $2 and fence = $3
|
||||
and lease_until > clock_timestamp()",
|
||||
)
|
||||
.bind(task_id.as_uuid())
|
||||
.bind(owner)
|
||||
.bind(i64::try_from(fence).unwrap_or_default())
|
||||
.fetch_optional(&self.pool)
|
||||
.await
|
||||
.map_err(Self::unavailable)?;
|
||||
let Some(row) = row else {
|
||||
return Err(TaskError::StateConflict);
|
||||
};
|
||||
let ciphertext: Option<String> = row
|
||||
.try_get("executable_input_ciphertext")
|
||||
.map_err(Self::unavailable)?;
|
||||
let key_version: Option<String> = row
|
||||
.try_get("executable_input_key_version")
|
||||
.map_err(Self::unavailable)?;
|
||||
let epoch: Option<i64> = row
|
||||
.try_get("executable_input_master_key_epoch")
|
||||
.map_err(Self::unavailable)?;
|
||||
if let Some(epoch) = epoch {
|
||||
let active = sqlx::query_scalar::<_, i64>(
|
||||
"select epoch from master_key_identities where status = 'active' order by epoch desc limit 1",
|
||||
)
|
||||
.fetch_optional(&self.pool)
|
||||
.await
|
||||
.map_err(Self::unavailable)?;
|
||||
if let Some(active) = active {
|
||||
if active != epoch {
|
||||
return Err(TaskError::StateConflict);
|
||||
}
|
||||
}
|
||||
}
|
||||
match (ciphertext, key_version, epoch) {
|
||||
(Some(ciphertext), Some(key_version), Some(epoch)) if !ciphertext.is_empty() => {
|
||||
Ok((ciphertext, key_version, epoch))
|
||||
}
|
||||
_ => Err(TaskError::NotFound),
|
||||
}
|
||||
}
|
||||
|
||||
async fn checkpoint_dispatch(
|
||||
&self,
|
||||
owner: &str,
|
||||
task_id: TaskId,
|
||||
fence: u64,
|
||||
attempt_id: String,
|
||||
) -> Result<TaskRecord, TaskError> {
|
||||
let mut transaction = self.start().await?;
|
||||
let row = sqlx::query(sqlx::AssertSqlSafe(format!(
|
||||
"update tasks
|
||||
set current_attempt_id = $1,
|
||||
dispatch_started_at = now(),
|
||||
attempts = attempts + 1,
|
||||
updated_at = now()
|
||||
where task_id = $2 and lease_owner = $3 and fence = $4
|
||||
and lease_until > clock_timestamp() and current_attempt_id is null
|
||||
returning {TASK_PROJECTION}"
|
||||
)))
|
||||
.bind(&attempt_id)
|
||||
.bind(task_id.as_uuid())
|
||||
.bind(owner)
|
||||
.bind(i64::try_from(fence).unwrap_or_default())
|
||||
.fetch_optional(&mut *transaction)
|
||||
.await
|
||||
.map_err(Self::unavailable)?;
|
||||
let Some(row) = row else {
|
||||
transaction.rollback().await.ok();
|
||||
return Err(TaskError::StateConflict);
|
||||
};
|
||||
let record = record_from_row(&row).map_err(Self::unavailable)?;
|
||||
transaction.commit().await.map_err(Self::unavailable)?;
|
||||
Ok(record)
|
||||
}
|
||||
|
||||
async fn finish_leased(
|
||||
&self,
|
||||
request: TaskFinishRequest,
|
||||
owner: &str,
|
||||
fence: u64,
|
||||
) -> Result<TaskRecord, TaskError> {
|
||||
request.validate()?;
|
||||
let mut transaction = self.start().await?;
|
||||
let access = &request.access;
|
||||
let row = sqlx::query(sqlx::AssertSqlSafe(format!(
|
||||
"update tasks
|
||||
set state = $1,
|
||||
result_envelope = $2,
|
||||
error_envelope = $3,
|
||||
version = version + 1,
|
||||
updated_at = now(),
|
||||
lease_owner = null,
|
||||
lease_until = null
|
||||
where task_id = $4 and workspace_id = $5 and owner_kind = $6
|
||||
and owner_id = $7 and authorization_scope = $8
|
||||
and state = $9 and version = $10
|
||||
and lease_owner = $11 and fence = $12
|
||||
and lease_until > clock_timestamp()
|
||||
returning {TASK_PROJECTION}"
|
||||
)))
|
||||
.bind(request.target_state.as_str())
|
||||
.bind(request.result.as_ref().map(|value| value.value().clone()))
|
||||
.bind(request.error.as_ref().map(|value| value.value().clone()))
|
||||
.bind(request.task_id.as_uuid())
|
||||
.bind(&access.workspace_id)
|
||||
.bind(access.owner_kind.as_str())
|
||||
.bind(&access.owner_id)
|
||||
.bind(&access.authorization_scope)
|
||||
.bind(request.expected_state.as_str())
|
||||
.bind(i64::from(request.expected_version))
|
||||
.bind(owner)
|
||||
.bind(i64::try_from(fence).unwrap_or_default())
|
||||
.fetch_optional(&mut *transaction)
|
||||
.await
|
||||
.map_err(Self::unavailable)?;
|
||||
let Some(row) = row else {
|
||||
transaction.rollback().await.ok();
|
||||
return Err(TaskError::StateConflict);
|
||||
};
|
||||
let record = record_from_row(&row).map_err(Self::unavailable)?;
|
||||
sqlx::query("delete from execution_admission_entries where task_id = $1")
|
||||
.bind(request.task_id.as_uuid())
|
||||
.execute(&mut *transaction)
|
||||
.await
|
||||
.map_err(Self::unavailable)?;
|
||||
transaction.commit().await.map_err(Self::unavailable)?;
|
||||
Ok(record)
|
||||
}
|
||||
}
|
||||
|
||||
impl PostgresTaskStore {
|
||||
async fn accept_locked(
|
||||
&self,
|
||||
transaction: &mut Transaction<'_, Postgres>,
|
||||
request: &TaskAcceptRequest,
|
||||
) -> Result<Accepted, AttemptError> {
|
||||
// Replay first: an already accepted Task is returned without capacity mutation, so it works
|
||||
// with a full queue and after the original execution deadline while the record is retained.
|
||||
if let Some((acceptance, fingerprint)) =
|
||||
self.stored_acceptance(transaction, request).await?
|
||||
{
|
||||
return Ok(if fingerprint == request.input_fingerprint {
|
||||
Accepted::Replayed(acceptance)
|
||||
} else {
|
||||
Accepted::Conflict
|
||||
});
|
||||
}
|
||||
|
||||
// Serialize with synchronous admission and any concurrent acceptance of the same scope.
|
||||
lock_admission_in_tx(transaction, &request.workspace_id).await?;
|
||||
|
||||
// The competitor may have committed while this transaction waited for the controller lock.
|
||||
if let Some((acceptance, fingerprint)) =
|
||||
self.stored_acceptance(transaction, request).await?
|
||||
{
|
||||
return Ok(if fingerprint == request.input_fingerprint {
|
||||
Accepted::Replayed(acceptance)
|
||||
} else {
|
||||
Accepted::Conflict
|
||||
});
|
||||
}
|
||||
|
||||
cleanup_expired_unlinked(transaction).await?;
|
||||
let queued = bounded_queue_len(transaction).await?;
|
||||
if queued >= u64::try_from(self.limits.queue_limit).unwrap_or(u64::MAX) {
|
||||
return Err(AttemptError::Overloaded);
|
||||
}
|
||||
|
||||
let created_ms: i64 = sqlx::query(
|
||||
"insert into tasks (
|
||||
task_id, workspace_id, owner_kind, owner_id, authorization_scope, operation_id,
|
||||
operation_version, scoped_key, input_fingerprint, request_id, trace_id, traceparent,
|
||||
trace_sampled, policy_mode, approval_reference, state, input_envelope,
|
||||
execution_deadline, retain_until, executable_input_ciphertext, executable_input_key_version,
|
||||
executable_input_master_key_epoch, platform_api_key_id
|
||||
) values (
|
||||
$1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, 'queued', $16,
|
||||
to_timestamp($17::double precision / 1000.0),
|
||||
to_timestamp($18::double precision / 1000.0), $19, $20, $21, $22
|
||||
)
|
||||
returning (extract(epoch from created_at) * 1000)::bigint as created_ms",
|
||||
)
|
||||
.bind(request.task_id.as_uuid())
|
||||
.bind(&request.workspace_id)
|
||||
.bind(request.owner_kind.as_str())
|
||||
.bind(&request.owner_id)
|
||||
.bind(&request.authorization_scope)
|
||||
.bind(&request.operation_id)
|
||||
.bind(i32::try_from(request.pins.operation_version).unwrap_or(i32::MAX))
|
||||
.bind(&request.scoped_key)
|
||||
.bind(&request.input_fingerprint)
|
||||
.bind(request.support.request_id.as_str())
|
||||
.bind(request.support.trace_id.as_str())
|
||||
.bind(&request.support.traceparent)
|
||||
.bind(request.support.trace_sampled)
|
||||
.bind(policy_mode_str(request.pins.policy_mode))
|
||||
.bind(request.pins.approval_reference.as_deref())
|
||||
.bind(request.input.value().clone())
|
||||
.bind(request.pins.execution_deadline_unix_ms)
|
||||
.bind(request.pins.retain_until_unix_ms)
|
||||
.bind(request.executable_input_ciphertext.as_deref())
|
||||
.bind(request.executable_input_key_version.as_deref())
|
||||
.bind(request.executable_input_master_key_epoch)
|
||||
.bind(
|
||||
request
|
||||
.platform_api_key_id
|
||||
.as_ref()
|
||||
.map(PlatformApiKeyId::as_str),
|
||||
)
|
||||
.fetch_one(&mut **transaction)
|
||||
.await
|
||||
.map_err(task_sql_error)?
|
||||
.try_get("created_ms")
|
||||
.map_err(AttemptError::from_sql)?;
|
||||
|
||||
let admission_request = AdmissionRequest {
|
||||
scope: AdmissionScope {
|
||||
workspace_id: request.workspace_id.clone(),
|
||||
agent_key: request.owner_id.clone(),
|
||||
operation_id: request.operation_id.clone(),
|
||||
operation_version: request.pins.operation_version,
|
||||
},
|
||||
mode: AdmissionMode::Background,
|
||||
policy_mode: request.pins.policy_mode,
|
||||
no_tasks_fallback: NoTasksFallback::Unsupported,
|
||||
// Never reached: the intent row is inserted by this transaction, not by `admit`.
|
||||
approval: ApprovalEvidence::NotRequired,
|
||||
fingerprint: request.input_fingerprint.clone(),
|
||||
expires_at_unix_ms: request.pins.execution_deadline_unix_ms,
|
||||
};
|
||||
let owner_token = format!("task_{}", request.task_id);
|
||||
insert_admission_entry(
|
||||
transaction,
|
||||
&admission_request,
|
||||
&owner_token,
|
||||
"reserved",
|
||||
Some(request.task_id.as_uuid()),
|
||||
)
|
||||
.await?;
|
||||
|
||||
Ok(Accepted::Created(TaskAcceptance {
|
||||
task_id: request.task_id,
|
||||
state: TaskState::Queued,
|
||||
operation_version: request.pins.operation_version,
|
||||
support: request.support.clone(),
|
||||
created_at_unix_ms: created_ms,
|
||||
retain_until_unix_ms: request.pins.retain_until_unix_ms,
|
||||
replayed: false,
|
||||
}))
|
||||
}
|
||||
|
||||
/// Bounded scoped reread after a foreign unique conflict aborted the transaction.
|
||||
async fn reread_after_unique(
|
||||
&self,
|
||||
request: &TaskAcceptRequest,
|
||||
) -> Result<TaskAcceptance, TaskError> {
|
||||
let row = sqlx::query(sqlx::AssertSqlSafe(format!(
|
||||
"select {TASK_PROJECTION} from tasks
|
||||
where workspace_id = $1 and owner_kind = $2 and owner_id = $3
|
||||
and authorization_scope = $4 and operation_id = $5 and scoped_key = $6"
|
||||
)))
|
||||
.bind(&request.workspace_id)
|
||||
.bind(request.owner_kind.as_str())
|
||||
.bind(&request.owner_id)
|
||||
.bind(&request.authorization_scope)
|
||||
.bind(&request.operation_id)
|
||||
.bind(&request.scoped_key)
|
||||
.fetch_optional(&self.pool)
|
||||
.await
|
||||
.map_err(Self::unavailable)?;
|
||||
let Some(row) = row else {
|
||||
return Err(TaskError::unavailable(
|
||||
"durable task acceptance ended with an unresolved unique conflict",
|
||||
));
|
||||
};
|
||||
let record = record_from_row(&row)?;
|
||||
if record.input_fingerprint != request.input_fingerprint {
|
||||
return Err(TaskError::FingerprintConflict);
|
||||
}
|
||||
Ok(acceptance_from_record(&record))
|
||||
}
|
||||
|
||||
/// A rejected conditional update is either a lost CAS race or a foreign/absent Task. Both are
|
||||
/// reported without payload, and a foreign Task is indistinguishable from an absent one.
|
||||
async fn classify_missed_finish(&self, request: &TaskFinishRequest) -> TaskError {
|
||||
let access = &request.access;
|
||||
match sqlx::query(
|
||||
"select state, version from tasks
|
||||
where task_id = $1 and workspace_id = $2 and owner_kind = $3
|
||||
and owner_id = $4 and authorization_scope = $5",
|
||||
)
|
||||
.bind(request.task_id.as_uuid())
|
||||
.bind(&access.workspace_id)
|
||||
.bind(access.owner_kind.as_str())
|
||||
.bind(&access.owner_id)
|
||||
.bind(&access.authorization_scope)
|
||||
.fetch_optional(&self.pool)
|
||||
.await
|
||||
{
|
||||
Ok(Some(_)) => TaskError::StateConflict,
|
||||
Ok(None) => TaskError::NotFound,
|
||||
Err(error) => Self::unavailable(error),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn policy_mode_str(mode: ToolExecutionMode) -> &'static str {
|
||||
match mode {
|
||||
ToolExecutionMode::Synchronous => "synchronous",
|
||||
ToolExecutionMode::Background => "background",
|
||||
ToolExecutionMode::Adaptive => "adaptive",
|
||||
}
|
||||
}
|
||||
|
||||
fn task_sql_error(error: sqlx::Error) -> AttemptError {
|
||||
if error
|
||||
.as_database_error()
|
||||
.and_then(|database| database.code())
|
||||
.as_deref()
|
||||
== Some("23505")
|
||||
{
|
||||
return AttemptError::UniqueViolation;
|
||||
}
|
||||
AttemptError::from_sql(error)
|
||||
}
|
||||
|
||||
fn record_from_row(row: &sqlx::postgres::PgRow) -> Result<TaskRecord, TaskError> {
|
||||
let task_id: Uuid = row.try_get("task_id").map_err(unavailable_row)?;
|
||||
let state: String = row.try_get("state").map_err(unavailable_row)?;
|
||||
let owner_kind: String = row.try_get("owner_kind").map_err(unavailable_row)?;
|
||||
let policy_mode: String = row.try_get("policy_mode").map_err(unavailable_row)?;
|
||||
let trace_id: String = row.try_get("trace_id").map_err(unavailable_row)?;
|
||||
let request_id: String = row.try_get("request_id").map_err(unavailable_row)?;
|
||||
let envelope = |column: &str| -> Result<Option<TaskEnvelope>, TaskError> {
|
||||
let value: Option<Value> = row.try_get(column).map_err(unavailable_row)?;
|
||||
value.map(TaskEnvelope::from_persisted).transpose()
|
||||
};
|
||||
Ok(TaskRecord {
|
||||
task_id: TaskId::parse(&task_id.to_string())?,
|
||||
state: TaskState::parse(&state)?,
|
||||
workspace_id: row.try_get("workspace_id").map_err(unavailable_row)?,
|
||||
owner_kind: TaskOwnerKind::parse(&owner_kind)?,
|
||||
owner_id: row.try_get("owner_id").map_err(unavailable_row)?,
|
||||
authorization_scope: row
|
||||
.try_get("authorization_scope")
|
||||
.map_err(unavailable_row)?,
|
||||
platform_api_key_id: row
|
||||
.try_get::<Option<String>, _>("platform_api_key_id")
|
||||
.map_err(unavailable_row)?
|
||||
.map(PlatformApiKeyId::new),
|
||||
operation_id: row.try_get("operation_id").map_err(unavailable_row)?,
|
||||
input_fingerprint: row.try_get("input_fingerprint").map_err(unavailable_row)?,
|
||||
pins: TaskPins {
|
||||
operation_version: u32::try_from(
|
||||
row.try_get::<i32, _>("operation_version")
|
||||
.map_err(unavailable_row)?,
|
||||
)
|
||||
.unwrap_or_default(),
|
||||
policy_mode: match policy_mode.as_str() {
|
||||
"background" => ToolExecutionMode::Background,
|
||||
"adaptive" => ToolExecutionMode::Adaptive,
|
||||
_ => ToolExecutionMode::Synchronous,
|
||||
},
|
||||
execution_deadline_unix_ms: row
|
||||
.try_get("execution_deadline_ms")
|
||||
.map_err(unavailable_row)?,
|
||||
retain_until_unix_ms: row.try_get("retain_until_ms").map_err(unavailable_row)?,
|
||||
approval_reference: row.try_get("approval_reference").map_err(unavailable_row)?,
|
||||
},
|
||||
support: TaskSupportIds {
|
||||
request_id: crank_core::RequestId::parse(&request_id)
|
||||
.map_err(|_| TaskError::unavailable("stored request id is invalid"))?,
|
||||
trace_id: crank_core::TraceId::parse(&trace_id)
|
||||
.map_err(|_| TaskError::unavailable("stored trace id is invalid"))?,
|
||||
traceparent: row.try_get("traceparent").map_err(unavailable_row)?,
|
||||
trace_sampled: row.try_get("trace_sampled").map_err(unavailable_row)?,
|
||||
},
|
||||
input: envelope("input_envelope")?
|
||||
.ok_or_else(|| TaskError::unavailable("stored task input envelope is missing"))?,
|
||||
progress: envelope("progress_envelope")?,
|
||||
result: envelope("result_envelope")?,
|
||||
error: envelope("error_envelope")?,
|
||||
attempts: u32::try_from(row.try_get::<i32, _>("attempts").map_err(unavailable_row)?)
|
||||
.unwrap_or_default(),
|
||||
fence: u64::try_from(row.try_get::<i64, _>("fence").map_err(unavailable_row)?)
|
||||
.unwrap_or_default(),
|
||||
lease_owner: row.try_get("lease_owner").map_err(unavailable_row)?,
|
||||
lease_until_unix_ms: row.try_get("lease_until_ms").map_err(unavailable_row)?,
|
||||
current_attempt_id: row.try_get("current_attempt_id").map_err(unavailable_row)?,
|
||||
dispatch_started_at_unix_ms: row
|
||||
.try_get("dispatch_started_at_ms")
|
||||
.map_err(unavailable_row)?,
|
||||
version: u32::try_from(row.try_get::<i32, _>("version").map_err(unavailable_row)?)
|
||||
.unwrap_or_default(),
|
||||
created_at_unix_ms: row.try_get("created_ms").map_err(unavailable_row)?,
|
||||
updated_at_unix_ms: row.try_get("updated_ms").map_err(unavailable_row)?,
|
||||
})
|
||||
}
|
||||
|
||||
fn unavailable_row(error: sqlx::Error) -> TaskError {
|
||||
PostgresTaskStore::unavailable(error)
|
||||
}
|
||||
@@ -1,4 +1,5 @@
|
||||
mod integration {
|
||||
mod admission;
|
||||
mod agent_resource_bindings;
|
||||
mod agents_usage;
|
||||
mod approval;
|
||||
@@ -16,5 +17,6 @@ mod integration {
|
||||
mod prompt_drafts;
|
||||
mod prompt_publication;
|
||||
mod resource_drafts;
|
||||
mod tasks;
|
||||
mod workspace_access;
|
||||
}
|
||||
@@ -0,0 +1,496 @@
|
||||
//! ATDD Story 4.1 (FR-21/FR-24): authoritative PostgreSQL execution admission.
|
||||
//!
|
||||
//! These oracles drive the real store against a real PostgreSQL schema: scoped permits, bounded
|
||||
//! queue, typed overload, durable enqueue decisions, deadline propagation, quota keys that ignore
|
||||
//! the operation version, fairness order and fail-closed health.
|
||||
|
||||
use super::common;
|
||||
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use crank_core::{
|
||||
ADMIN_ORIGIN_KEY, AdmissionMode, AdmissionOutcome, AdmissionPermit, AdmissionRequest,
|
||||
AdmissionSchedulerConfig, AdmissionScope, ApprovalEvidence, ExecutionAdmission,
|
||||
NoTasksFallback, ToolExecutionMode, current_unix_ms,
|
||||
};
|
||||
use crank_registry::{AdmissionLimits, PostgresExecutionAdmission};
|
||||
use tokio::sync::mpsc;
|
||||
|
||||
fn limits(global: usize, agent: usize, tool: usize, queue: usize) -> AdmissionLimits {
|
||||
AdmissionLimits {
|
||||
global_limit: global,
|
||||
agent_limit: agent,
|
||||
tool_limit: tool,
|
||||
queue_limit: queue,
|
||||
}
|
||||
}
|
||||
|
||||
fn store(
|
||||
pool: sqlx::PgPool,
|
||||
limits: AdmissionLimits,
|
||||
scheduler: AdmissionSchedulerConfig,
|
||||
) -> PostgresExecutionAdmission {
|
||||
PostgresExecutionAdmission::new(pool, limits, scheduler).expect("valid admission store")
|
||||
}
|
||||
|
||||
fn scope(agent: &str, operation: &str, version: u32) -> AdmissionScope {
|
||||
AdmissionScope {
|
||||
workspace_id: "ws_default".to_owned(),
|
||||
agent_key: agent.to_owned(),
|
||||
operation_id: operation.to_owned(),
|
||||
operation_version: version,
|
||||
}
|
||||
}
|
||||
|
||||
fn request(scope: AdmissionScope, deadline_in_ms: i64) -> AdmissionRequest {
|
||||
AdmissionRequest {
|
||||
scope,
|
||||
mode: AdmissionMode::Synchronous,
|
||||
policy_mode: ToolExecutionMode::Synchronous,
|
||||
no_tasks_fallback: NoTasksFallback::Synchronous,
|
||||
approval: ApprovalEvidence::NotRequired,
|
||||
fingerprint: format!("fp_{}", current_unix_ms()),
|
||||
expires_at_unix_ms: current_unix_ms() + deadline_in_ms,
|
||||
}
|
||||
}
|
||||
|
||||
fn background(scope: AdmissionScope, fallback: NoTasksFallback) -> AdmissionRequest {
|
||||
AdmissionRequest {
|
||||
mode: AdmissionMode::Background,
|
||||
no_tasks_fallback: fallback,
|
||||
..request(scope, 30_000)
|
||||
}
|
||||
}
|
||||
|
||||
fn permit(outcome: AdmissionOutcome) -> AdmissionPermit {
|
||||
match outcome {
|
||||
AdmissionOutcome::Permitted(permit) => permit,
|
||||
other => panic!("expected a scoped permit, got {other:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
async fn wait_for_metric_poll() {
|
||||
tokio::time::sleep(Duration::from_millis(20)).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn permits_are_scoped_released_once_and_respect_the_agent_budget() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
let registry = database.registry().await;
|
||||
let admission = store(
|
||||
registry.pool().clone(),
|
||||
limits(4, 1, 4, 8),
|
||||
Default::default(),
|
||||
);
|
||||
|
||||
let first = permit(
|
||||
admission
|
||||
.admit(request(scope("agent_a", "op_leads", 1), 2_000))
|
||||
.await
|
||||
.expect("admission store is reachable"),
|
||||
);
|
||||
assert_eq!(first.scope.agent_key, "agent_a");
|
||||
|
||||
// The same Agent is already at its scoped budget: the second request waits and expires instead of
|
||||
// over-admitting, and it never dispatches.
|
||||
let waiting = admission
|
||||
.admit(request(scope("agent_a", "op_leads", 2), 120))
|
||||
.await
|
||||
.expect("admission store is reachable");
|
||||
assert_eq!(waiting, AdmissionOutcome::DeadlineElapsed);
|
||||
|
||||
// Another Agent still has the global capacity it is entitled to.
|
||||
let other = permit(
|
||||
admission
|
||||
.admit(request(scope("agent_b", "op_leads", 1), 2_000))
|
||||
.await
|
||||
.expect("admission store is reachable"),
|
||||
);
|
||||
assert_eq!(other.scope.agent_key, "agent_b");
|
||||
assert!(admission.release(&other).await.unwrap());
|
||||
// Repeated release is idempotent and never frees a foreign or already released permit.
|
||||
assert!(!admission.release(&other).await.unwrap());
|
||||
|
||||
assert!(admission.release(&first).await.unwrap());
|
||||
let snapshot = admission.snapshot().await.unwrap();
|
||||
assert_eq!(snapshot.executing, 0);
|
||||
assert_eq!(snapshot.waiting, 0);
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn full_queue_returns_a_typed_overload_with_retry_guidance() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
let registry = database.registry().await;
|
||||
let admission = store(
|
||||
registry.pool().clone(),
|
||||
limits(1, 1, 1, 2),
|
||||
Default::default(),
|
||||
);
|
||||
|
||||
let held = permit(
|
||||
admission
|
||||
.admit(request(scope("agent_a", "op_leads", 1), 5_000))
|
||||
.await
|
||||
.expect("admission store is reachable"),
|
||||
);
|
||||
|
||||
// Two bounded waiting entries fill the queue.
|
||||
let mut waiters = Vec::new();
|
||||
for version in 1..=2 {
|
||||
let admission = admission.clone();
|
||||
waiters.push(tokio::spawn(async move {
|
||||
admission
|
||||
.admit(request(scope("agent_b", "op_leads", version), 5_000))
|
||||
.await
|
||||
}));
|
||||
}
|
||||
while admission.snapshot().await.unwrap().waiting < 2 {
|
||||
wait_for_metric_poll().await;
|
||||
}
|
||||
|
||||
let rejected = admission
|
||||
.admit(request(scope("agent_c", "op_leads", 1), 5_000))
|
||||
.await
|
||||
.expect("admission store is reachable");
|
||||
match rejected {
|
||||
AdmissionOutcome::Overloaded { retry_after_ms } => {
|
||||
assert!((1..=crank_core::MAX_RETRY_AFTER_MS).contains(&retry_after_ms));
|
||||
}
|
||||
other => panic!("expected typed overload, got {other:?}"),
|
||||
}
|
||||
|
||||
// Cancelling the held permit lets the queued waiters make progress instead of leaking capacity.
|
||||
assert!(admission.release(&held).await.unwrap());
|
||||
for waiter in waiters.drain(..) {
|
||||
let outcome = waiter.await.expect("waiter task");
|
||||
if let Ok(AdmissionOutcome::Permitted(permit)) = outcome {
|
||||
let _ = admission.release(&permit).await;
|
||||
}
|
||||
}
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn background_decisions_are_durable_pinned_and_released_once() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
let registry = database.registry().await;
|
||||
let admission = store(
|
||||
registry.pool().clone(),
|
||||
limits(4, 4, 4, 8),
|
||||
Default::default(),
|
||||
);
|
||||
|
||||
let decision = match admission
|
||||
.admit(background(
|
||||
scope("agent_a", "op_report", 3),
|
||||
NoTasksFallback::Synchronous,
|
||||
))
|
||||
.await
|
||||
.expect("admission store is reachable")
|
||||
{
|
||||
AdmissionOutcome::Enqueued(decision) => decision,
|
||||
other => panic!("expected a durable enqueue decision, got {other:?}"),
|
||||
};
|
||||
assert_eq!(decision.scope.operation_version, 3);
|
||||
assert_eq!(decision.policy_mode, ToolExecutionMode::Synchronous);
|
||||
|
||||
// A second process (fresh pool and store over the same schema) must read the committed decision:
|
||||
// it occupies bounded queue capacity and is not a runnable execution.
|
||||
let reconnected = store(
|
||||
database.concurrent_registry(2).await.pool().clone(),
|
||||
limits(4, 4, 4, 8),
|
||||
Default::default(),
|
||||
);
|
||||
let snapshot = reconnected.snapshot().await.unwrap();
|
||||
assert_eq!(snapshot.waiting, 1);
|
||||
assert_eq!(snapshot.executing, 0);
|
||||
|
||||
assert!(
|
||||
reconnected
|
||||
.cancel(decision.ticket_id, "not_the_owner")
|
||||
.await
|
||||
.unwrap()
|
||||
.eq(&false),
|
||||
"a foreign cancel must never release the decision"
|
||||
);
|
||||
assert!(
|
||||
reconnected.snapshot().await.unwrap().waiting.eq(&1),
|
||||
"the foreign cancel must leave the decision intact"
|
||||
);
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn background_without_a_task_transport_is_typed_unsupported() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
let registry = database.registry().await;
|
||||
let admission = store(
|
||||
registry.pool().clone(),
|
||||
limits(4, 4, 4, 8),
|
||||
Default::default(),
|
||||
);
|
||||
|
||||
let outcome = admission
|
||||
.admit(background(
|
||||
scope("agent_a", "op_report", 1),
|
||||
NoTasksFallback::Unsupported,
|
||||
))
|
||||
.await
|
||||
.expect("admission store is reachable");
|
||||
assert_eq!(outcome, AdmissionOutcome::Unsupported);
|
||||
assert_eq!(admission.snapshot().await.unwrap().waiting, 0);
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn unverified_approval_never_produces_a_decision() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
let registry = database.registry().await;
|
||||
let admission = store(
|
||||
registry.pool().clone(),
|
||||
limits(4, 4, 4, 8),
|
||||
Default::default(),
|
||||
);
|
||||
|
||||
let mut denied = background(
|
||||
scope("agent_a", "op_report", 1),
|
||||
NoTasksFallback::Synchronous,
|
||||
);
|
||||
denied.approval = ApprovalEvidence::NotGranted;
|
||||
assert_eq!(
|
||||
admission.admit(denied).await.unwrap(),
|
||||
AdmissionOutcome::ApprovalRequired
|
||||
);
|
||||
|
||||
let mut denied_sync = request(scope("agent_a", "op_report", 1), 1_000);
|
||||
denied_sync.approval = ApprovalEvidence::NotGranted;
|
||||
assert_eq!(
|
||||
admission.admit(denied_sync).await.unwrap(),
|
||||
AdmissionOutcome::ApprovalRequired
|
||||
);
|
||||
assert_eq!(admission.snapshot().await.unwrap().waiting, 0);
|
||||
assert_eq!(admission.snapshot().await.unwrap().executing, 0);
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn quota_keys_ignore_the_operation_version() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
let registry = database.registry().await;
|
||||
let admission = store(
|
||||
registry.pool().clone(),
|
||||
limits(4, 4, 1, 8),
|
||||
Default::default(),
|
||||
);
|
||||
|
||||
let held = permit(
|
||||
admission
|
||||
.admit(request(scope("agent_a", "op_leads", 1), 2_000))
|
||||
.await
|
||||
.expect("admission store is reachable"),
|
||||
);
|
||||
// A different Published Version of the same Tool shares the same per-Tool budget.
|
||||
let outcome = admission
|
||||
.admit(request(scope("agent_a", "op_leads", 2), 120))
|
||||
.await
|
||||
.expect("admission store is reachable");
|
||||
assert_eq!(outcome, AdmissionOutcome::DeadlineElapsed);
|
||||
assert!(admission.release(&held).await.unwrap());
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn weighted_agents_are_served_their_quantum_in_order() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
let registry = database.registry().await;
|
||||
let admission = store(
|
||||
registry.pool().clone(),
|
||||
limits(1, 4, 4, 8),
|
||||
AdmissionSchedulerConfig {
|
||||
agent_weight: 2,
|
||||
tool_weight: 1,
|
||||
},
|
||||
);
|
||||
let held = permit(
|
||||
admission
|
||||
.admit(request(scope("agent_z", "op_leads", 1), 5_000))
|
||||
.await
|
||||
.expect("admission store is reachable"),
|
||||
);
|
||||
|
||||
let (sender, mut receiver) = mpsc::channel(3);
|
||||
let mut tasks = Vec::new();
|
||||
for (agent, version) in [("agent_a", 1), ("agent_a", 2), ("agent_b", 1)] {
|
||||
let admission = admission.clone();
|
||||
let sender = sender.clone();
|
||||
tasks.push(tokio::spawn(async move {
|
||||
let outcome = admission
|
||||
.admit(request(scope(agent, "op_leads", version), 5_000))
|
||||
.await;
|
||||
if let Ok(AdmissionOutcome::Permitted(permit)) = outcome {
|
||||
let _ = sender.send(permit.scope.agent_key.clone()).await;
|
||||
// Hold briefly so the grant order, not task scheduling, decides the sequence.
|
||||
tokio::time::sleep(Duration::from_millis(30)).await;
|
||||
let _ = admission.release(&permit).await;
|
||||
}
|
||||
}));
|
||||
}
|
||||
drop(sender);
|
||||
assert!(admission.release(&held).await.unwrap());
|
||||
|
||||
let mut order = Vec::new();
|
||||
while let Some(agent) = receiver.recv().await {
|
||||
order.push(agent);
|
||||
if order.len() == 3 {
|
||||
break;
|
||||
}
|
||||
}
|
||||
for task in tasks {
|
||||
let _ = tokio::time::timeout(Duration::from_secs(5), task).await;
|
||||
}
|
||||
// agent_a carries weight 2 and therefore receives two consecutive grants before agent_b.
|
||||
assert_eq!(order, vec!["agent_a", "agent_a", "agent_b"]);
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn mandatory_state_failure_fails_closed_and_reports_not_ready() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
// No migration on this schema: the mandatory admission state does not exist yet.
|
||||
let unmigrated = database.raw_pool().await;
|
||||
let admission = store(unmigrated, limits(4, 4, 4, 8), Default::default());
|
||||
assert!(admission.health().await.is_err());
|
||||
assert!(
|
||||
admission
|
||||
.admit(request(scope("agent_a", "op_leads", 1), 1_000))
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn held_permits_survive_a_new_process_view() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
let registry = database.registry().await;
|
||||
let admission = store(
|
||||
registry.pool().clone(),
|
||||
limits(1, 4, 4, 8),
|
||||
Default::default(),
|
||||
);
|
||||
let held = permit(
|
||||
admission
|
||||
.admit(request(scope("agent_a", "op_leads", 1), 2_000))
|
||||
.await
|
||||
.expect("admission store is reachable"),
|
||||
);
|
||||
|
||||
let reconnected = store(
|
||||
database.concurrent_registry(2).await.pool().clone(),
|
||||
limits(1, 4, 4, 8),
|
||||
Default::default(),
|
||||
);
|
||||
assert_eq!(reconnected.snapshot().await.unwrap().executing, 1);
|
||||
let outcome = reconnected
|
||||
.admit(request(scope("agent_b", "op_leads", 1), 120))
|
||||
.await
|
||||
.expect("admission store is reachable");
|
||||
assert_eq!(
|
||||
outcome,
|
||||
AdmissionOutcome::DeadlineElapsed,
|
||||
"a held permit is not silently reused by another process"
|
||||
);
|
||||
assert!(reconnected.release(&held).await.unwrap());
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn published_execution_policy_is_pinned_across_a_new_draft_version() {
|
||||
use crank_core::{NoTasksFallback, OperationStatus, ToolExecutionMode, ToolExecutionPolicy};
|
||||
use crank_registry::{CreateVersionRequest, PublishRequest};
|
||||
use time::{OffsetDateTime, format_description::well_known::Rfc3339};
|
||||
|
||||
let database = common::TestDatabase::new().await;
|
||||
let registry = database.registry().await;
|
||||
let workspace = common::test_workspace_id();
|
||||
let policy = ToolExecutionPolicy {
|
||||
mode: ToolExecutionMode::Background,
|
||||
deadline_ms: 45_000,
|
||||
no_tasks_fallback: NoTasksFallback::Unsupported,
|
||||
};
|
||||
let mut version_one = common::test_operation("op_policy", 1, OperationStatus::Draft);
|
||||
version_one.execution_config.execution_policy = Some(policy);
|
||||
registry
|
||||
.create_operation(&workspace, &version_one, None)
|
||||
.await
|
||||
.unwrap();
|
||||
registry
|
||||
.publish_operation(PublishRequest {
|
||||
workspace_id: &workspace,
|
||||
operation_id: &version_one.id,
|
||||
version: 1,
|
||||
published_at: &OffsetDateTime::parse("2026-03-25T12:10:00Z", &Rfc3339).unwrap(),
|
||||
published_by: Some("alice"),
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let published = registry
|
||||
.get_published_operation(&version_one.id)
|
||||
.await
|
||||
.unwrap()
|
||||
.expect("published operation");
|
||||
assert_eq!(published.execution_config.execution_policy, Some(policy));
|
||||
|
||||
// A later Draft with another policy never rewrites the already accepted publication.
|
||||
let mut version_two = common::test_operation("op_policy", 2, OperationStatus::Draft);
|
||||
version_two.execution_config.execution_policy = Some(ToolExecutionPolicy {
|
||||
mode: ToolExecutionMode::Synchronous,
|
||||
deadline_ms: 1_000,
|
||||
no_tasks_fallback: NoTasksFallback::Synchronous,
|
||||
});
|
||||
registry
|
||||
.create_version(CreateVersionRequest {
|
||||
workspace_id: &workspace,
|
||||
snapshot: &version_two,
|
||||
change_note: Some("next draft"),
|
||||
created_by: Some("alice"),
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
let unchanged = registry
|
||||
.get_published_operation(&version_one.id)
|
||||
.await
|
||||
.unwrap()
|
||||
.expect("published operation");
|
||||
assert_eq!(unchanged.version, 1);
|
||||
assert_eq!(unchanged.execution_config.execution_policy, Some(policy));
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn admin_origin_bucket_is_bounded_together_with_agents() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
let registry = database.registry().await;
|
||||
let admission = store(
|
||||
registry.pool().clone(),
|
||||
limits(1, 1, 1, 4),
|
||||
Default::default(),
|
||||
);
|
||||
let held = permit(
|
||||
admission
|
||||
.admit(request(scope(ADMIN_ORIGIN_KEY, "op_leads", 1), 2_000))
|
||||
.await
|
||||
.expect("admission store is reachable"),
|
||||
);
|
||||
let started = Instant::now();
|
||||
let outcome = admission
|
||||
.admit(request(scope("agent_a", "op_leads", 1), 120))
|
||||
.await
|
||||
.expect("admission store is reachable");
|
||||
assert_eq!(outcome, AdmissionOutcome::DeadlineElapsed);
|
||||
assert!(started.elapsed() >= Duration::from_millis(100));
|
||||
assert!(admission.release(&held).await.unwrap());
|
||||
database.cleanup().await;
|
||||
}
|
||||
@@ -2,6 +2,7 @@ use crank_registry::{MigrationAuthority, MigrationPreflight, PostgresRegistry};
|
||||
use sqlx::Row;
|
||||
|
||||
mod artifact_metadata;
|
||||
mod durable_tasks_guard;
|
||||
mod import_plan;
|
||||
mod legacy_adoption;
|
||||
mod preflight;
|
||||
@@ -70,6 +71,11 @@ async fn controlled_authority_is_versioned_and_safe_under_concurrent_apply() {
|
||||
(21, "prompts-v21"),
|
||||
(22, "prompt-publications-v22"),
|
||||
(23, "prompt-dependencies-v23"),
|
||||
(24, "execution-admission-v24"),
|
||||
(25, "durable-tasks-v25"),
|
||||
(26, "durable-tasks-v26"),
|
||||
(27, "durable-tasks-v27"),
|
||||
(28, "durable-tasks-v28"),
|
||||
];
|
||||
assert_eq!(rows.len(), expected.len());
|
||||
for (row, (version, name)) in rows.iter().zip(expected) {
|
||||
@@ -180,7 +186,7 @@ async fn controlled_authority_is_versioned_and_safe_under_concurrent_apply() {
|
||||
);
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(first.pool()).await.unwrap(),
|
||||
MigrationPreflight::Current { version: 23 }
|
||||
MigrationPreflight::Current { version: 28 }
|
||||
);
|
||||
}
|
||||
#[tokio::test]
|
||||
@@ -228,7 +234,7 @@ async fn v18_guard_rejects_missing_agent_resource_binding_trigger() {
|
||||
.expect("the V18-local guard must be restorable");
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::Current { version: 23 },
|
||||
MigrationPreflight::Current { version: 28 },
|
||||
"restoring the exact V18 contract must return the current verdict"
|
||||
);
|
||||
}
|
||||
@@ -354,7 +360,7 @@ async fn ledgerless_legacy_baseline_is_consolidated_without_data_loss() {
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::MigrationRequired {
|
||||
current: 0,
|
||||
target: 23,
|
||||
target: 28,
|
||||
}
|
||||
);
|
||||
MigrationAuthority::apply(&pool).await.unwrap();
|
||||
@@ -467,13 +473,13 @@ async fn healthy_v2_is_reported_as_migration_required_and_upgrades_to_v3() {
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::MigrationRequired {
|
||||
current: 2,
|
||||
target: 23,
|
||||
target: 28,
|
||||
}
|
||||
);
|
||||
MigrationAuthority::apply(&pool).await.unwrap();
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::Current { version: 23 }
|
||||
MigrationPreflight::Current { version: 28 }
|
||||
);
|
||||
let trace_column: bool = sqlx::query_scalar(
|
||||
"select exists (
|
||||
@@ -516,7 +522,7 @@ async fn healthy_v3_upgrades_to_v4_with_honest_legacy_snapshot_provenance() {
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::MigrationRequired {
|
||||
current: 3,
|
||||
target: 23,
|
||||
target: 28,
|
||||
}
|
||||
);
|
||||
MigrationAuthority::apply(&pool).await.unwrap();
|
||||
@@ -576,7 +582,7 @@ async fn healthy_v4_upgrades_to_v5_without_fabricating_legacy_outcomes() {
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::MigrationRequired {
|
||||
current: 4,
|
||||
target: 23,
|
||||
target: 28,
|
||||
}
|
||||
);
|
||||
MigrationAuthority::apply(&pool).await.unwrap();
|
||||
@@ -830,6 +836,6 @@ async fn v3_upgrade_ignores_oversized_legacy_request_ids_in_partial_index() {
|
||||
MigrationAuthority::apply(&pool).await.unwrap();
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::Current { version: 23 }
|
||||
MigrationPreflight::Current { version: 28 }
|
||||
);
|
||||
}
|
||||
@@ -32,7 +32,7 @@ async fn healthy_v11_upgrades_to_v13_without_rewriting_prior_ledger() {
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::MigrationRequired {
|
||||
current: 11,
|
||||
target: 23,
|
||||
target: 28,
|
||||
}
|
||||
);
|
||||
|
||||
@@ -177,7 +177,7 @@ async fn v12_guard_still_rejects_column_constraint_index_and_relation_drift() {
|
||||
sqlx::raw_sql(restore).execute(&pool).await.unwrap();
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::Current { version: 23 },
|
||||
MigrationPreflight::Current { version: 28 },
|
||||
"restore: {restore}"
|
||||
);
|
||||
}
|
||||
@@ -230,7 +230,7 @@ async fn v13_guard_rejects_wrong_cleanup_index_order_and_predicate() {
|
||||
sqlx::raw_sql(restore).execute(&pool).await.unwrap();
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::Current { version: 23 },
|
||||
MigrationPreflight::Current { version: 28 },
|
||||
"restore: {restore}"
|
||||
);
|
||||
}
|
||||
@@ -507,7 +507,7 @@ async fn assert_v12_drift(pool: &sqlx::PgPool, drift: &str, restore: &str) {
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(pool).await.unwrap(),
|
||||
MigrationPreflight::Current { version: 23 },
|
||||
MigrationPreflight::Current { version: 28 },
|
||||
"restore: {restore}"
|
||||
);
|
||||
}
|
||||
@@ -845,7 +845,7 @@ async fn v17_guard_rejects_publication_schema_drift() {
|
||||
MigrationAuthority::apply(&pool).await.unwrap();
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::Current { version: 23 }
|
||||
MigrationPreflight::Current { version: 28 }
|
||||
);
|
||||
|
||||
for (drift, restore) in [
|
||||
@@ -879,7 +879,7 @@ async fn v17_guard_rejects_publication_schema_drift() {
|
||||
sqlx::raw_sql(restore).execute(&pool).await.unwrap();
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::Current { version: 23 },
|
||||
MigrationPreflight::Current { version: 28 },
|
||||
"restore: {restore}"
|
||||
);
|
||||
}
|
||||
|
||||
+8
-8
@@ -289,7 +289,7 @@ async fn assert_primary_key_nullability(pool: &sqlx::PgPool, table: &str, column
|
||||
);
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(pool).await.unwrap(),
|
||||
MigrationPreflight::Current { version: 23 },
|
||||
MigrationPreflight::Current { version: 28 },
|
||||
"a rejected primary-key nullability change must leave the schema current"
|
||||
);
|
||||
|
||||
@@ -473,7 +473,7 @@ async fn assert_definition_only_drift(
|
||||
assert_eq!(super::catalog_constraint_definitions(pool).await, before);
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(pool).await.unwrap(),
|
||||
MigrationPreflight::Current { version: 23 }
|
||||
MigrationPreflight::Current { version: 28 }
|
||||
);
|
||||
}
|
||||
|
||||
@@ -554,7 +554,7 @@ async fn story36_v16_guard_rejects_constraint_and_created_index_definition_drift
|
||||
MigrationAuthority::apply(&pool).await.unwrap();
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::Current { version: 23 },
|
||||
MigrationPreflight::Current { version: 28 },
|
||||
"the baseline before the drift matrix must be the current V16 schema"
|
||||
);
|
||||
let mut observations: Vec<String> = Vec::new();
|
||||
@@ -773,7 +773,7 @@ async fn story36_v16_guard_rejects_constraint_and_created_index_definition_drift
|
||||
.await
|
||||
.expect("restoring the exact definition must apply");
|
||||
let restored = MigrationAuthority::preflight(&pool).await;
|
||||
let restored_current = matches!(restored, Ok(MigrationPreflight::Current { version: 23 }));
|
||||
let restored_current = matches!(restored, Ok(MigrationPreflight::Current { version: 28 }));
|
||||
// Точное восстановление доказывается сравнением снятого снимка с baseline, а не
|
||||
// мнением того же guard-а, который принимает неправильные определения (F4).
|
||||
let restored_exact = catalog_definition_snapshot(&pool).await == before;
|
||||
@@ -804,7 +804,7 @@ async fn story36_v16_guard_resolves_dependent_source_fk_in_the_current_schema()
|
||||
MigrationAuthority::apply(&pool).await.unwrap();
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::Current { version: 23 },
|
||||
MigrationPreflight::Current { version: 28 },
|
||||
"baseline before inserting the shadow schema"
|
||||
);
|
||||
|
||||
@@ -875,7 +875,7 @@ async fn story36_v16_guard_resolves_dependent_source_fk_in_the_current_schema()
|
||||
// Тень не меняет вердикт guard-а по текущей схеме.
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::Current { version: 23 },
|
||||
MigrationPreflight::Current { version: 28 },
|
||||
"a same-named object in another schema must not change the verdict for the current schema"
|
||||
);
|
||||
|
||||
@@ -947,7 +947,7 @@ async fn story36_v16_guard_resolves_dependent_source_fk_in_the_current_schema()
|
||||
);
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::Current { version: 23 },
|
||||
MigrationPreflight::Current { version: 28 },
|
||||
"the exact restoration must return the current V16 schema"
|
||||
);
|
||||
|
||||
@@ -958,7 +958,7 @@ async fn story36_v16_guard_resolves_dependent_source_fk_in_the_current_schema()
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::Current { version: 23 }
|
||||
MigrationPreflight::Current { version: 28 }
|
||||
);
|
||||
|
||||
assert!(
|
||||
|
||||
@@ -0,0 +1,83 @@
|
||||
use super::*;
|
||||
use crank_registry::MigrationApplyResult;
|
||||
|
||||
#[tokio::test]
|
||||
async fn clean_legacy_ledger_upgrades_to_v28_after_v25_removal() {
|
||||
let database_url = crank_test_support::postgres_schema_url("test_v43_clean_legacy").await;
|
||||
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
|
||||
MigrationAuthority::apply(&pool).await.unwrap();
|
||||
super::remove_v25_schema(&pool).await;
|
||||
// remove_v25_schema drops `tasks` and ledger >= 25, but V25 also added the
|
||||
// nullable dispatch-intent column/index/FK to execution_admission_entries;
|
||||
// restore those to the V24 shape so the legacy ledger is self-consistent.
|
||||
sqlx::raw_sql(
|
||||
"alter table execution_admission_entries drop constraint if exists execution_admission_entries_task_fkey;
|
||||
drop index if exists execution_admission_entries_task_uidx;
|
||||
alter table execution_admission_entries drop column if exists task_id;",
|
||||
)
|
||||
.execute(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::MigrationRequired {
|
||||
current: 24,
|
||||
target: 28,
|
||||
}
|
||||
);
|
||||
assert_eq!(
|
||||
MigrationAuthority::apply(&pool).await.unwrap(),
|
||||
MigrationApplyResult::Applied { from: 24, to: 28 }
|
||||
);
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::Current { version: 28 }
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn partial_v27_on_legacy_ledger_is_rejected_by_preflight() {
|
||||
let database_url = crank_test_support::postgres_schema_url("test_v43_partial_v27").await;
|
||||
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
|
||||
MigrationAuthority::apply(&pool).await.unwrap();
|
||||
super::remove_v25_schema(&pool).await;
|
||||
sqlx::raw_sql(
|
||||
"alter table execution_admission_entries drop constraint if exists execution_admission_entries_task_fkey;
|
||||
drop index if exists execution_admission_entries_task_uidx;
|
||||
alter table execution_admission_entries drop column if exists task_id;",
|
||||
)
|
||||
.execute(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
// Reintroduce a partial V27-shaped `tasks` table on top of the legacy (v24) ledger.
|
||||
sqlx::raw_sql(sqlx::AssertSqlSafe(
|
||||
"create table tasks (
|
||||
task_id uuid primary key,
|
||||
executable_input_ciphertext text,
|
||||
executable_input_key_version text,
|
||||
executable_input_master_key_epoch bigint
|
||||
);",
|
||||
))
|
||||
.execute(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let error = MigrationAuthority::preflight(&pool).await.unwrap_err();
|
||||
assert_eq!(error.code(), "partial_sequence");
|
||||
// The rejection today is attributed to V25's absent-schema guard because the
|
||||
// `tasks` relation already exists, so a behavioral RED pin for the missing
|
||||
// V27 guard line cannot be reached; this test fixes the rejection contract
|
||||
// instead of claiming new behavior.
|
||||
assert_eq!(error.version(), Some(24));
|
||||
assert_eq!(error.stage(), "preflight.schema");
|
||||
|
||||
let count: i64 =
|
||||
sqlx::query_scalar("select count(*)::bigint from __crank_migrations where version >= 25")
|
||||
.fetch_one(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
count, 0,
|
||||
"nothing at or above V25 should have been applied over the partial fixture"
|
||||
);
|
||||
}
|
||||
@@ -71,7 +71,7 @@ async fn fresh_install_exposes_import_plan_objects_with_cascading_job_fk() {
|
||||
MigrationAuthority::apply(&pool).await.unwrap();
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::Current { version: 23 }
|
||||
MigrationPreflight::Current { version: 28 }
|
||||
);
|
||||
let tables = sqlx::query(
|
||||
"select table_name
|
||||
@@ -224,7 +224,7 @@ async fn healthy_v13_upgrades_to_v14_without_changing_prior_ledger() {
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::MigrationRequired {
|
||||
current: 13,
|
||||
target: 23,
|
||||
target: 28,
|
||||
}
|
||||
);
|
||||
MigrationAuthority::apply(&pool).await.unwrap();
|
||||
|
||||
@@ -88,7 +88,7 @@ async fn published_ledgerless_baseline_upgrades_without_data_loss() {
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::MigrationRequired {
|
||||
current: 0,
|
||||
target: 23,
|
||||
target: 28,
|
||||
}
|
||||
);
|
||||
MigrationAuthority::apply(&pool).await.unwrap();
|
||||
@@ -101,7 +101,7 @@ async fn published_ledgerless_baseline_upgrades_without_data_loss() {
|
||||
assert_eq!(operation_count, 1);
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::Current { version: 23 }
|
||||
MigrationPreflight::Current { version: 28 }
|
||||
);
|
||||
}
|
||||
|
||||
@@ -194,7 +194,7 @@ async fn published_ledgerless_historical_column_layout_upgrades_without_data_los
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::MigrationRequired {
|
||||
current: 0,
|
||||
target: 23,
|
||||
target: 28,
|
||||
}
|
||||
);
|
||||
MigrationAuthority::apply(&pool).await.unwrap();
|
||||
@@ -230,7 +230,7 @@ async fn published_ledgerless_historical_column_layout_upgrades_without_data_los
|
||||
);
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::Current { version: 23 }
|
||||
MigrationPreflight::Current { version: 28 }
|
||||
);
|
||||
}
|
||||
|
||||
@@ -262,7 +262,7 @@ async fn published_initial_mcp_layout_is_accepted() {
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::MigrationRequired {
|
||||
current: 0,
|
||||
target: 23,
|
||||
target: 28,
|
||||
}
|
||||
);
|
||||
MigrationAuthority::apply(&pool).await.unwrap();
|
||||
@@ -280,7 +280,7 @@ async fn published_initial_mcp_layout_is_accepted() {
|
||||
assert!(supports_elicitation);
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::Current { version: 23 }
|
||||
MigrationPreflight::Current { version: 28 }
|
||||
);
|
||||
}
|
||||
|
||||
@@ -314,13 +314,13 @@ async fn published_in_place_mcp_upgrade_layout_is_accepted() {
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::MigrationRequired {
|
||||
current: 0,
|
||||
target: 23,
|
||||
target: 28,
|
||||
}
|
||||
);
|
||||
MigrationAuthority::apply(&pool).await.unwrap();
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::Current { version: 23 }
|
||||
MigrationPreflight::Current { version: 28 }
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
+15
-9
@@ -14,7 +14,7 @@ async fn fresh_install_creates_the_empty_revocation_authority() {
|
||||
MigrationAuthority::apply(&pool).await.unwrap();
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::Current { version: 23 }
|
||||
MigrationPreflight::Current { version: 28 }
|
||||
);
|
||||
let rows: i64 = sqlx::query_scalar("select count(*) from resource_security_revocations")
|
||||
.fetch_one(&pool)
|
||||
@@ -42,12 +42,12 @@ async fn v18_upgrades_to_v19_without_rewriting_the_prior_ledger() {
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::MigrationRequired {
|
||||
current: 18,
|
||||
target: 23,
|
||||
target: 28,
|
||||
}
|
||||
);
|
||||
assert_eq!(
|
||||
MigrationAuthority::apply(&pool).await.unwrap(),
|
||||
MigrationApplyResult::Applied { from: 18, to: 23 }
|
||||
MigrationApplyResult::Applied { from: 18, to: 28 }
|
||||
);
|
||||
let after: Vec<(i64, String, String)> =
|
||||
sqlx::query_as("select version, name, checksum from __crank_migrations where version < 19 order by version")
|
||||
@@ -57,7 +57,7 @@ async fn v18_upgrades_to_v19_without_rewriting_the_prior_ledger() {
|
||||
assert_eq!(before, after, "V16–V18 ledger rows must not be rewritten");
|
||||
assert_eq!(
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::Current { version: 23 }
|
||||
MigrationPreflight::Current { version: 28 }
|
||||
);
|
||||
}
|
||||
|
||||
@@ -84,18 +84,24 @@ async fn a_database_newer_than_the_binary_fails_closed_at_startup() {
|
||||
let database_url = crank_test_support::postgres_schema_url("test_v19_future_version").await;
|
||||
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
|
||||
MigrationAuthority::apply(&pool).await.unwrap();
|
||||
// The same `version > CURRENT_VERSION` branch an old V23 binary takes when it
|
||||
// meets a V24 database; a synthetic V24 row exercises it without a second binary.
|
||||
// The same `version > CURRENT_VERSION` branch an older binary takes when it meets a newer
|
||||
// database; a synthetic version above the current one exercises it without a second binary.
|
||||
let current: i64 = sqlx::query_scalar("select max(version) from __crank_migrations")
|
||||
.fetch_one(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
let future = current + 1;
|
||||
sqlx::query(
|
||||
"insert into __crank_migrations (version, name, checksum, phase, compatibility)
|
||||
values (24, 'future-v24', repeat('a', 64), 'expand', 'n-minus-one-readable')",
|
||||
values ($1, 'future-synthetic', repeat('a', 64), 'expand', 'n-minus-one-readable')",
|
||||
)
|
||||
.bind(future)
|
||||
.execute(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
let error = MigrationAuthority::preflight(&pool).await.unwrap_err();
|
||||
assert_eq!(error.code(), "future_version");
|
||||
assert_eq!(error.version(), Some(24));
|
||||
assert_eq!(error.version(), Some(future));
|
||||
assert_eq!(error.recovery(), "install_matching_application");
|
||||
assert!(
|
||||
MigrationAuthority::require_current(&pool).await.is_err(),
|
||||
@@ -155,7 +161,7 @@ async fn failed_v19_migration_rolls_back_schema_and_ledger() {
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::MigrationRequired {
|
||||
current: 18,
|
||||
target: 23,
|
||||
target: 28,
|
||||
}
|
||||
);
|
||||
}
|
||||
@@ -63,7 +63,7 @@ async fn failed_artifact_metadata_migration_rolls_back_schema_and_ledger() {
|
||||
MigrationAuthority::preflight(&pool).await.unwrap(),
|
||||
MigrationPreflight::MigrationRequired {
|
||||
current: 11,
|
||||
target: 23,
|
||||
target: 28,
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
@@ -38,6 +38,7 @@ pub(crate) async fn remove_v4_schema(pool: &sqlx::PgPool) {
|
||||
.unwrap();
|
||||
}
|
||||
pub(crate) async fn remove_v5_schema(pool: &sqlx::PgPool) {
|
||||
remove_v24_schema(pool).await;
|
||||
remove_v6_schema(pool).await;
|
||||
sqlx::raw_sql(
|
||||
"drop index if exists invocation_logs_workspace_operation_version_idx;
|
||||
@@ -154,6 +155,7 @@ pub(crate) async fn remove_v11_schema(pool: &sqlx::PgPool) {
|
||||
.unwrap();
|
||||
}
|
||||
pub(crate) async fn remove_v14_schema(pool: &sqlx::PgPool) {
|
||||
remove_v24_schema(pool).await;
|
||||
remove_v15_schema(pool).await;
|
||||
sqlx::raw_sql(
|
||||
"drop table if exists import_plan_applications;
|
||||
@@ -224,6 +226,7 @@ pub(crate) async fn remove_v18_schema(pool: &sqlx::PgPool) {
|
||||
.unwrap();
|
||||
}
|
||||
pub(crate) async fn remove_v19_schema(pool: &sqlx::PgPool) {
|
||||
remove_v24_schema(pool).await;
|
||||
remove_v20_schema(pool).await;
|
||||
sqlx::raw_sql(
|
||||
"drop table if exists resource_security_revocations;
|
||||
@@ -307,6 +310,7 @@ pub(crate) async fn remove_v20_schema(pool: &sqlx::PgPool) {
|
||||
.unwrap();
|
||||
}
|
||||
pub(crate) async fn remove_v12_schema(pool: &sqlx::PgPool) {
|
||||
remove_v24_schema(pool).await;
|
||||
remove_v14_schema(pool).await;
|
||||
sqlx::raw_sql(
|
||||
"drop index if exists import_jobs_openapi_source_idx;
|
||||
@@ -323,3 +327,28 @@ pub(crate) async fn remove_v12_schema(pool: &sqlx::PgPool) {
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
/// Story 4.2: снять V25 (durable Tasks и Task-linked dispatch intent) перед возвратом к < 25.
|
||||
pub(crate) async fn remove_v25_schema(pool: &sqlx::PgPool) {
|
||||
// V25 created `tasks`; V26–V28 only altered it, so dropping the table removes their schema too.
|
||||
sqlx::raw_sql(
|
||||
"drop table if exists tasks cascade;
|
||||
delete from __crank_migrations where version >= 25;",
|
||||
)
|
||||
.execute(pool)
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
/// Story 4.1: снять V24 (authoritative execution admission) перед возвратом к < 24.
|
||||
pub(crate) async fn remove_v24_schema(pool: &sqlx::PgPool) {
|
||||
remove_v25_schema(pool).await;
|
||||
sqlx::raw_sql(
|
||||
"drop table if exists execution_admission_entries;
|
||||
drop table if exists execution_admission_controllers;
|
||||
delete from __crank_migrations where version = 24;",
|
||||
)
|
||||
.execute(pool)
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
@@ -0,0 +1,905 @@
|
||||
//! ATDD Story 4.2 (FR-22/FR-23): durable Task acceptance on a real PostgreSQL schema.
|
||||
//!
|
||||
//! These oracles drive the real store: Task + dispatch intent + queue slot in one transaction, replay
|
||||
//! and typed conflict before any capacity mutation, bounded shared capacity, the Task-linked intent
|
||||
//! guard of the legacy admission paths, one-winner terminal CAS with an immutable result, bounded
|
||||
//! retention, owner/authorization-scope isolation and fail-closed health.
|
||||
|
||||
use super::common;
|
||||
|
||||
use crank_core::{
|
||||
AdmissionMode, AdmissionOutcome, AdmissionRequest, AdmissionScope, AgentId, ApprovalEvidence,
|
||||
ExecutionAdmission, NoTasksFallback, PlatformApiKey, PlatformApiKeyId, PlatformApiKeyKind,
|
||||
PlatformApiKeyScope, PlatformApiKeyStatus, RequestId, TaskAcceptRequest, TaskAccess,
|
||||
TaskEnvelope, TaskError, TaskFinishRequest, TaskId, TaskOwnerKind, TaskPins, TaskState,
|
||||
TaskStore, TaskSupportIds, ToolExecutionMode, TraceContext, WorkspaceId, current_unix_ms,
|
||||
};
|
||||
use crank_registry::{
|
||||
AdmissionLimits, CreatePlatformApiKeyRequest, PostgresExecutionAdmission, PostgresTaskStore,
|
||||
};
|
||||
use serde_json::json;
|
||||
use sqlx::{PgPool, Row};
|
||||
use time::{Duration as TimeDuration, OffsetDateTime};
|
||||
|
||||
const WORKSPACE: &str = "ws_default";
|
||||
const AGENT: &str = "agent_a";
|
||||
|
||||
fn limits(queue: usize) -> AdmissionLimits {
|
||||
AdmissionLimits {
|
||||
global_limit: 4,
|
||||
agent_limit: 4,
|
||||
tool_limit: 4,
|
||||
queue_limit: queue,
|
||||
}
|
||||
}
|
||||
|
||||
fn store_with(pool: PgPool, queue: usize) -> PostgresTaskStore {
|
||||
PostgresTaskStore::new(pool, limits(queue), Default::default()).expect("valid store config")
|
||||
}
|
||||
|
||||
fn unsampled_support() -> TaskSupportIds {
|
||||
TaskSupportIds::new(
|
||||
RequestId::generate(),
|
||||
&TraceContext::parse("00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-00").unwrap(),
|
||||
)
|
||||
}
|
||||
|
||||
fn request(key: &str, fingerprint: &str, agent: &str, deadline_in_ms: i64) -> TaskAcceptRequest {
|
||||
let deadline = current_unix_ms() + deadline_in_ms;
|
||||
TaskAcceptRequest {
|
||||
task_id: TaskId::generate(),
|
||||
workspace_id: WORKSPACE.to_owned(),
|
||||
owner_kind: TaskOwnerKind::Agent,
|
||||
owner_id: agent.to_owned(),
|
||||
authorization_scope: format!("credential:pk_{agent}"),
|
||||
platform_api_key_id: Some(PlatformApiKeyId::new(format!("pk_{agent}"))),
|
||||
operation_id: "op_report".to_owned(),
|
||||
pins: TaskPins {
|
||||
operation_version: 3,
|
||||
policy_mode: ToolExecutionMode::Background,
|
||||
execution_deadline_unix_ms: deadline,
|
||||
retain_until_unix_ms: deadline + 3_600_000,
|
||||
approval_reference: Some("appr_1".to_owned()),
|
||||
},
|
||||
scoped_key: key.to_owned(),
|
||||
input_fingerprint: fingerprint.to_owned(),
|
||||
input: TaskEnvelope::try_redacted(&json!({"report": "q3", "api_key": "sk_live"})).unwrap(),
|
||||
support: unsampled_support(),
|
||||
executable_input_ciphertext: None,
|
||||
executable_input_key_version: None,
|
||||
executable_input_master_key_epoch: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn access(agent: &str) -> TaskAccess {
|
||||
TaskAccess {
|
||||
workspace_id: WORKSPACE.to_owned(),
|
||||
owner_kind: TaskOwnerKind::Agent,
|
||||
owner_id: agent.to_owned(),
|
||||
authorization_scope: format!("credential:pk_{agent}"),
|
||||
}
|
||||
}
|
||||
|
||||
fn key(seed: &str) -> String {
|
||||
format!("{seed:0<64}").chars().take(64).collect()
|
||||
}
|
||||
|
||||
fn digest(seed: &str) -> String {
|
||||
format!("{seed:0<64}").chars().take(64).collect()
|
||||
}
|
||||
|
||||
async fn row_counts(pool: &PgPool) -> (i64, i64) {
|
||||
let row = sqlx::query(
|
||||
"select
|
||||
(select count(*)::bigint from tasks) as tasks,
|
||||
(select count(*)::bigint from execution_admission_entries where task_id is not null)
|
||||
as intents",
|
||||
)
|
||||
.fetch_one(pool)
|
||||
.await
|
||||
.unwrap();
|
||||
(row.get("tasks"), row.get("intents"))
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn acceptance_commits_task_intent_and_slot_together() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
// Fresh schema: the first connection applies the migration, later pools reuse the same schema.
|
||||
let _migrated = database.registry().await;
|
||||
let registry = database.concurrent_registry(4).await;
|
||||
let store = store_with(registry.pool().clone(), 8);
|
||||
|
||||
let request = request(&key("k1"), &digest("f1"), AGENT, 30_000);
|
||||
let task_id = request.task_id;
|
||||
let support = request.support.clone();
|
||||
|
||||
// Another connection holds both controller rows: the acceptance cannot commit yet.
|
||||
let mut blocker = registry.pool().begin().await.unwrap();
|
||||
sqlx::query(
|
||||
"insert into execution_admission_controllers (workspace_id) values ('*'), ($1)
|
||||
on conflict (workspace_id) do nothing",
|
||||
)
|
||||
.bind(WORKSPACE)
|
||||
.execute(&mut *blocker)
|
||||
.await
|
||||
.unwrap();
|
||||
sqlx::query("update execution_admission_controllers set updated_at = updated_at")
|
||||
.execute(&mut *blocker)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let pool = registry.pool().clone();
|
||||
let acceptance = tokio::spawn(async move { store.accept(request).await });
|
||||
tokio::time::sleep(std::time::Duration::from_millis(150)).await;
|
||||
|
||||
// No partial Task, no intent and no accepted response exist before COMMIT.
|
||||
assert!(!acceptance.is_finished());
|
||||
assert_eq!(row_counts(&pool).await, (0, 0));
|
||||
|
||||
blocker.commit().await.unwrap();
|
||||
let acceptance = acceptance.await.unwrap().expect("acceptance commits");
|
||||
assert_eq!(acceptance.state, TaskState::Queued);
|
||||
assert!(!acceptance.replayed);
|
||||
assert_eq!(acceptance.task_id, task_id);
|
||||
assert_eq!(acceptance.support, support);
|
||||
assert_eq!(row_counts(registry.pool()).await, (1, 1));
|
||||
|
||||
// A fresh connection and store read the committed pins/identities back.
|
||||
let reader = store_with(database.concurrent_registry(2).await.pool().clone(), 8);
|
||||
let record = reader.read(&access(AGENT), task_id).await.unwrap();
|
||||
assert_eq!(record.state, TaskState::Queued);
|
||||
assert_eq!(record.pins.operation_version, 3);
|
||||
assert_eq!(record.pins.policy_mode, ToolExecutionMode::Background);
|
||||
assert_eq!(record.pins.approval_reference.as_deref(), Some("appr_1"));
|
||||
assert_eq!(record.support.request_id, support.request_id);
|
||||
assert_eq!(record.support.trace_id, support.trace_id);
|
||||
assert_eq!(record.support.traceparent, support.traceparent);
|
||||
assert!(!record.support.trace_sampled);
|
||||
// Secret-bearing input is classified before persistence.
|
||||
assert_eq!(record.input.value()["api_key"], json!("[redacted]"));
|
||||
assert_eq!(record.input.value()["report"], json!("q3"));
|
||||
assert!(record.result.is_none());
|
||||
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn replay_returns_the_same_task_and_one_slot() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
// Fresh schema: the first connection applies the migration, later pools reuse the same schema.
|
||||
let _migrated = database.registry().await;
|
||||
let registry = database.concurrent_registry(4).await;
|
||||
let store = store_with(registry.pool().clone(), 8);
|
||||
|
||||
let first = store
|
||||
.accept(request(&key("k1"), &digest("f1"), AGENT, 30_000))
|
||||
.await
|
||||
.expect("first acceptance");
|
||||
let before = store.read(&access(AGENT), first.task_id).await.unwrap();
|
||||
|
||||
let replay = store
|
||||
.accept(request(&key("k1"), &digest("f1"), AGENT, 30_000))
|
||||
.await
|
||||
.expect("replay returns the accepted Task");
|
||||
assert_eq!(replay.task_id, first.task_id);
|
||||
assert!(replay.replayed);
|
||||
assert_eq!(replay.support.request_id, first.support.request_id);
|
||||
assert_eq!(row_counts(registry.pool()).await, (1, 1));
|
||||
|
||||
// Replay never rewrites the accepted row or its audit evidence.
|
||||
let after = store.read(&access(AGENT), first.task_id).await.unwrap();
|
||||
assert_eq!(after.version, before.version);
|
||||
assert_eq!(after.updated_at_unix_ms, before.updated_at_unix_ms);
|
||||
assert_eq!(after.created_at_unix_ms, before.created_at_unix_ms);
|
||||
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn replay_stays_available_with_a_full_queue_and_past_execution_deadline() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
// Fresh schema: the first connection applies the migration, later pools reuse the same schema.
|
||||
let _migrated = database.registry().await;
|
||||
let registry = database.concurrent_registry(4).await;
|
||||
let store = store_with(registry.pool().clone(), 1);
|
||||
|
||||
// A short deadline: the Task is still retained after its execution deadline elapsed.
|
||||
let first = store
|
||||
.accept(request(&key("k1"), &digest("f1"), AGENT, 1))
|
||||
.await
|
||||
.expect("first acceptance");
|
||||
sqlx::query(
|
||||
"update tasks set execution_deadline = now() - interval '1 hour' where task_id = $1",
|
||||
)
|
||||
.bind(first.task_id.as_uuid())
|
||||
.execute(registry.pool())
|
||||
.await
|
||||
.unwrap();
|
||||
tokio::time::sleep(std::time::Duration::from_millis(20)).await;
|
||||
|
||||
let replayed = store
|
||||
.accept(request(&key("k1"), &digest("f1"), AGENT, 1))
|
||||
.await
|
||||
.expect("replay works with a full queue and an elapsed execution deadline");
|
||||
assert_eq!(replayed.task_id, first.task_id);
|
||||
assert!(replayed.replayed);
|
||||
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_different_fingerprint_on_the_same_key_is_a_typed_conflict() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
// Fresh schema: the first connection applies the migration, later pools reuse the same schema.
|
||||
let _migrated = database.registry().await;
|
||||
let registry = database.concurrent_registry(4).await;
|
||||
let store = store_with(registry.pool().clone(), 8);
|
||||
|
||||
let first = store
|
||||
.accept(request(&key("k1"), &digest("f1"), AGENT, 30_000))
|
||||
.await
|
||||
.expect("first acceptance");
|
||||
let before = store.read(&access(AGENT), first.task_id).await.unwrap();
|
||||
|
||||
let conflict = store
|
||||
.accept(request(&key("k1"), &digest("f2"), AGENT, 30_000))
|
||||
.await
|
||||
.expect_err("different input is a conflict");
|
||||
assert_eq!(conflict, TaskError::FingerprintConflict);
|
||||
assert_eq!(row_counts(registry.pool()).await, (1, 1));
|
||||
|
||||
let after = store.read(&access(AGENT), first.task_id).await.unwrap();
|
||||
assert_eq!(after.version, before.version);
|
||||
assert_eq!(after.updated_at_unix_ms, before.updated_at_unix_ms);
|
||||
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn bounded_capacity_is_shared_and_overload_creates_nothing() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
// Fresh schema: the first connection applies the migration, later pools reuse the same schema.
|
||||
let _migrated = database.registry().await;
|
||||
let registry = database.concurrent_registry(4).await;
|
||||
let store = store_with(registry.pool().clone(), 1);
|
||||
let admission =
|
||||
PostgresExecutionAdmission::new(registry.pool().clone(), limits(1), Default::default())
|
||||
.unwrap();
|
||||
|
||||
// A durable enqueue decision and a durable Task share the same bounded queue budget.
|
||||
let waiting = admission
|
||||
.admit(AdmissionRequest {
|
||||
scope: AdmissionScope {
|
||||
workspace_id: WORKSPACE.to_owned(),
|
||||
agent_key: AGENT.to_owned(),
|
||||
operation_id: "op_sync".to_owned(),
|
||||
operation_version: 1,
|
||||
},
|
||||
mode: AdmissionMode::Background,
|
||||
policy_mode: ToolExecutionMode::Background,
|
||||
no_tasks_fallback: NoTasksFallback::Synchronous,
|
||||
approval: ApprovalEvidence::NotRequired,
|
||||
fingerprint: "fp_sync".to_owned(),
|
||||
expires_at_unix_ms: current_unix_ms() + 30_000,
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(matches!(waiting, AdmissionOutcome::Enqueued(_)));
|
||||
|
||||
let overloaded = store
|
||||
.accept(request(&key("k1"), &digest("f1"), AGENT, 30_000))
|
||||
.await
|
||||
.expect_err("queue is full");
|
||||
assert!(matches!(overloaded, TaskError::Overloaded { .. }));
|
||||
assert_eq!(row_counts(registry.pool()).await, (0, 0));
|
||||
assert_eq!(
|
||||
admission.snapshot().await.unwrap().waiting,
|
||||
1,
|
||||
"the durable refusal changed no capacity"
|
||||
);
|
||||
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn legacy_cleanup_and_cancel_never_remove_a_task_linked_intent() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
// Fresh schema: the first connection applies the migration, later pools reuse the same schema.
|
||||
let _migrated = database.registry().await;
|
||||
let registry = database.concurrent_registry(4).await;
|
||||
let store = store_with(registry.pool().clone(), 8);
|
||||
let admission =
|
||||
PostgresExecutionAdmission::new(registry.pool().clone(), limits(8), Default::default())
|
||||
.unwrap();
|
||||
|
||||
let accepted = store
|
||||
.accept(request(&key("k1"), &digest("f1"), AGENT, 1))
|
||||
.await
|
||||
.expect("acceptance");
|
||||
// The linked reserved row looks expired; the legacy TTL cleanup must ignore it.
|
||||
sqlx::query("update execution_admission_entries set expires_at = now() - interval '1 hour'")
|
||||
.execute(registry.pool())
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let ticket: i64 =
|
||||
sqlx::query("select ticket_id from execution_admission_entries where task_id = $1")
|
||||
.bind(accepted.task_id.as_uuid())
|
||||
.fetch_one(registry.pool())
|
||||
.await
|
||||
.unwrap()
|
||||
.get("ticket_id");
|
||||
let owner_token: String =
|
||||
sqlx::query("select owner_token from execution_admission_entries where ticket_id = $1")
|
||||
.bind(ticket)
|
||||
.fetch_one(registry.pool())
|
||||
.await
|
||||
.unwrap()
|
||||
.get("owner_token");
|
||||
|
||||
// A legacy attempt runs the bounded expiry cleanup; a foreign/own legacy cancel is refused.
|
||||
let _ = admission
|
||||
.admit(AdmissionRequest {
|
||||
scope: AdmissionScope {
|
||||
workspace_id: WORKSPACE.to_owned(),
|
||||
agent_key: "agent_b".to_owned(),
|
||||
operation_id: "op_sync".to_owned(),
|
||||
operation_version: 1,
|
||||
},
|
||||
mode: AdmissionMode::Synchronous,
|
||||
policy_mode: ToolExecutionMode::Synchronous,
|
||||
no_tasks_fallback: NoTasksFallback::Synchronous,
|
||||
approval: ApprovalEvidence::NotRequired,
|
||||
fingerprint: "fp_sync".to_owned(),
|
||||
expires_at_unix_ms: current_unix_ms() + 50,
|
||||
})
|
||||
.await;
|
||||
assert!(!admission.cancel(ticket as u64, &owner_token).await.unwrap());
|
||||
assert_eq!(row_counts(registry.pool()).await, (1, 1));
|
||||
assert_eq!(
|
||||
store
|
||||
.read(&access(AGENT), accepted.task_id)
|
||||
.await
|
||||
.unwrap()
|
||||
.state,
|
||||
TaskState::Queued
|
||||
);
|
||||
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn terminal_transition_has_one_winner_and_an_immutable_result() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
// Fresh schema: the first connection applies the migration, later pools reuse the same schema.
|
||||
let _migrated = database.registry().await;
|
||||
let registry = database.concurrent_registry(4).await;
|
||||
let store = store_with(registry.pool().clone(), 8);
|
||||
|
||||
let accepted = store
|
||||
.accept(request(&key("k1"), &digest("f1"), AGENT, 30_000))
|
||||
.await
|
||||
.unwrap();
|
||||
let queued = store.read(&access(AGENT), accepted.task_id).await.unwrap();
|
||||
assert_eq!(queued.version, 1);
|
||||
|
||||
// Moving a queued Task straight to completed is not an allowed transition.
|
||||
let skipped = TaskFinishRequest {
|
||||
access: access(AGENT),
|
||||
task_id: accepted.task_id,
|
||||
expected_state: TaskState::Queued,
|
||||
expected_version: queued.version,
|
||||
target_state: TaskState::Completed,
|
||||
result: Some(TaskEnvelope::try_redacted(&json!({"ok": true})).unwrap()),
|
||||
error: None,
|
||||
};
|
||||
assert_eq!(
|
||||
store
|
||||
.finish(skipped)
|
||||
.await
|
||||
.expect_err("transition rejected"),
|
||||
TaskError::Invalid {
|
||||
message: "task state transition is not allowed".to_owned()
|
||||
}
|
||||
);
|
||||
|
||||
let started = TaskFinishRequest {
|
||||
access: access(AGENT),
|
||||
task_id: accepted.task_id,
|
||||
expected_state: TaskState::Queued,
|
||||
expected_version: queued.version,
|
||||
target_state: TaskState::Working,
|
||||
result: None,
|
||||
error: None,
|
||||
};
|
||||
assert_eq!(
|
||||
store
|
||||
.finish(started)
|
||||
.await
|
||||
.expect_err("working is not terminal"),
|
||||
TaskError::Invalid {
|
||||
message: "task finish target is not terminal".to_owned()
|
||||
}
|
||||
);
|
||||
sqlx::query("update tasks set state = 'working' where task_id = $1")
|
||||
.bind(accepted.task_id.as_uuid())
|
||||
.execute(registry.pool())
|
||||
.await
|
||||
.unwrap();
|
||||
let working = store.read(&access(AGENT), accepted.task_id).await.unwrap();
|
||||
|
||||
let mut finishers = Vec::new();
|
||||
for marker in ["first", "second"] {
|
||||
let store = store.clone();
|
||||
let mut finish = TaskFinishRequest {
|
||||
access: access(AGENT),
|
||||
task_id: accepted.task_id,
|
||||
expected_state: TaskState::Working,
|
||||
expected_version: working.version,
|
||||
target_state: TaskState::Completed,
|
||||
result: Some(TaskEnvelope::try_redacted(&json!({"marker": marker})).unwrap()),
|
||||
error: None,
|
||||
};
|
||||
finish.target_state = TaskState::Completed;
|
||||
finishers.push(tokio::spawn(async move { store.finish(finish).await }));
|
||||
}
|
||||
let first = finishers.remove(0).await.unwrap();
|
||||
let second = finishers.remove(0).await.unwrap();
|
||||
let winners = [&first, &second]
|
||||
.iter()
|
||||
.filter(|result| result.is_ok())
|
||||
.count();
|
||||
assert_eq!(winners, 1, "exactly one concurrent CAS wins");
|
||||
let loser = if first.is_err() { &first } else { &second };
|
||||
assert_eq!(
|
||||
loser.as_ref().err().unwrap(),
|
||||
&TaskError::StateConflict,
|
||||
"the loser observes a rejected transition, not a rewrite"
|
||||
);
|
||||
|
||||
let terminal = store.read(&access(AGENT), accepted.task_id).await.unwrap();
|
||||
assert_eq!(terminal.state, TaskState::Completed);
|
||||
assert_eq!(terminal.version, working.version + 1);
|
||||
let marker = terminal.result.as_ref().unwrap().value()["marker"]
|
||||
.as_str()
|
||||
.unwrap()
|
||||
.to_owned();
|
||||
assert!(marker == "first" || marker == "second");
|
||||
|
||||
// A repeated terminal write and a terminal->terminal move are rejected.
|
||||
let repeated = TaskFinishRequest {
|
||||
access: access(AGENT),
|
||||
task_id: accepted.task_id,
|
||||
expected_state: TaskState::Completed,
|
||||
expected_version: terminal.version,
|
||||
target_state: TaskState::Failed,
|
||||
result: None,
|
||||
error: Some(TaskEnvelope::try_redacted(&json!({"reason": "x"})).unwrap()),
|
||||
};
|
||||
assert!(repeated.validate().is_err());
|
||||
|
||||
// Terminal Task and its dispatch intent left together.
|
||||
assert_eq!(row_counts(registry.pool()).await, (1, 0));
|
||||
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn retention_is_bounded_and_never_deletes_live_work() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
// Fresh schema: the first connection applies the migration, later pools reuse the same schema.
|
||||
let _migrated = database.registry().await;
|
||||
let registry = database.concurrent_registry(4).await;
|
||||
let store = store_with(registry.pool().clone(), 8);
|
||||
|
||||
let queued = store
|
||||
.accept(request(&key("k1"), &digest("f1"), AGENT, 30_000))
|
||||
.await
|
||||
.unwrap();
|
||||
let expired_queued = store
|
||||
.accept(request(&key("k2"), &digest("f2"), AGENT, 1))
|
||||
.await
|
||||
.unwrap();
|
||||
sqlx::query(
|
||||
"update tasks set execution_deadline = now() - interval '1 hour' where task_id = $1",
|
||||
)
|
||||
.bind(expired_queued.task_id.as_uuid())
|
||||
.execute(registry.pool())
|
||||
.await
|
||||
.unwrap();
|
||||
// A retained terminal Task whose retention has not expired yet and one that has.
|
||||
let terminal = store
|
||||
.accept(request(&key("k3"), &digest("f3"), AGENT, 30_000))
|
||||
.await
|
||||
.unwrap();
|
||||
sqlx::query(
|
||||
"update tasks set state = 'completed', result_envelope = '{\"ok\":true}'::jsonb,
|
||||
retain_until = now() + interval '1 hour' where task_id = $1",
|
||||
)
|
||||
.bind(terminal.task_id.as_uuid())
|
||||
.execute(registry.pool())
|
||||
.await
|
||||
.unwrap();
|
||||
sqlx::query("delete from execution_admission_entries where task_id = $1")
|
||||
.bind(terminal.task_id.as_uuid())
|
||||
.execute(registry.pool())
|
||||
.await
|
||||
.unwrap();
|
||||
let expired_terminal = store
|
||||
.accept(request(&key("k4"), &digest("f4"), AGENT, 30_000))
|
||||
.await
|
||||
.unwrap();
|
||||
sqlx::query(
|
||||
"update tasks set state = 'cancelled', execution_deadline = now() - interval '2 hours',
|
||||
retain_until = now() - interval '1 hour'
|
||||
where task_id = $1",
|
||||
)
|
||||
.bind(expired_terminal.task_id.as_uuid())
|
||||
.execute(registry.pool())
|
||||
.await
|
||||
.unwrap();
|
||||
sqlx::query("delete from execution_admission_entries where task_id = $1")
|
||||
.bind(expired_terminal.task_id.as_uuid())
|
||||
.execute(registry.pool())
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let report = store.purge_expired(64).await.unwrap();
|
||||
assert_eq!(report.expired_queued, 1);
|
||||
assert_eq!(report.expired_terminal, 1);
|
||||
|
||||
// Live queued work is never deleted or failed; the expired queued Task released its slot.
|
||||
assert_eq!(
|
||||
store
|
||||
.read(&access(AGENT), queued.task_id)
|
||||
.await
|
||||
.unwrap()
|
||||
.state,
|
||||
TaskState::Queued
|
||||
);
|
||||
assert_eq!(
|
||||
store
|
||||
.read(&access(AGENT), terminal.task_id)
|
||||
.await
|
||||
.unwrap()
|
||||
.state,
|
||||
TaskState::Completed
|
||||
);
|
||||
assert!(matches!(
|
||||
store
|
||||
.read(&access(AGENT), expired_queued.task_id)
|
||||
.await
|
||||
.unwrap()
|
||||
.state,
|
||||
TaskState::Failed
|
||||
));
|
||||
assert!(
|
||||
store
|
||||
.read(&access(AGENT), expired_terminal.task_id)
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
let remaining: i64 = sqlx::query("select count(*)::bigint as count from execution_admission_entries where task_id is not null")
|
||||
.fetch_one(registry.pool())
|
||||
.await
|
||||
.unwrap()
|
||||
.get("count");
|
||||
assert_eq!(remaining, 1, "only the live queued Task keeps its intent");
|
||||
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn foreign_scope_reads_are_not_found_and_never_leak_payload() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
// Fresh schema: the first connection applies the migration, later pools reuse the same schema.
|
||||
let _migrated = database.registry().await;
|
||||
let registry = database.concurrent_registry(4).await;
|
||||
let store = store_with(registry.pool().clone(), 8);
|
||||
|
||||
let accepted = store
|
||||
.accept(request(&key("k1"), &digest("f1"), AGENT, 30_000))
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
// Positive control: the owner reads its Task.
|
||||
assert!(store.read(&access(AGENT), accepted.task_id).await.is_ok());
|
||||
|
||||
// Foreign owner, foreign authorization scope and foreign workspace are all not-found.
|
||||
let mut foreign_owner = access(AGENT);
|
||||
foreign_owner.owner_id = "agent_b".to_owned();
|
||||
assert_eq!(
|
||||
store
|
||||
.read(&foreign_owner, accepted.task_id)
|
||||
.await
|
||||
.unwrap_err(),
|
||||
TaskError::NotFound
|
||||
);
|
||||
let mut foreign_scope = access(AGENT);
|
||||
foreign_scope.authorization_scope = "credential:pk_other".to_owned();
|
||||
assert_eq!(
|
||||
store
|
||||
.read(&foreign_scope, accepted.task_id)
|
||||
.await
|
||||
.unwrap_err(),
|
||||
TaskError::NotFound
|
||||
);
|
||||
let mut foreign_workspace = access(AGENT);
|
||||
foreign_workspace.workspace_id = "ws_other".to_owned();
|
||||
assert_eq!(
|
||||
store
|
||||
.read(&foreign_workspace, accepted.task_id)
|
||||
.await
|
||||
.unwrap_err(),
|
||||
TaskError::NotFound
|
||||
);
|
||||
|
||||
// The same caller key under a foreign owner creates its own Task, never a visible collision.
|
||||
let other = store
|
||||
.accept(request(&key("k1"), &digest("f1"), "agent_b", 30_000))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_ne!(other.task_id, accepted.task_id);
|
||||
assert_eq!(row_counts(registry.pool()).await, (2, 2));
|
||||
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn invalid_bounded_envelope_is_rejected_before_persistence() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
// Fresh schema: the first connection applies the migration, later pools reuse the same schema.
|
||||
let _migrated = database.registry().await;
|
||||
let registry = database.concurrent_registry(4).await;
|
||||
let store = store_with(registry.pool().clone(), 8);
|
||||
|
||||
assert!(
|
||||
TaskEnvelope::try_redacted(&json!({"blob": "x".repeat(64 * 1024)})).is_err(),
|
||||
"an oversized envelope is rejected before any accept"
|
||||
);
|
||||
|
||||
let mut invalid = request(&key("k1"), &digest("f1"), AGENT, 30_000);
|
||||
invalid.scoped_key = "short".to_owned();
|
||||
assert!(matches!(invalid.validate(), Err(TaskError::Invalid { .. })));
|
||||
assert_eq!(
|
||||
store.accept(invalid).await.unwrap_err(),
|
||||
TaskError::Invalid {
|
||||
message: "task scoped key digest is invalid".to_owned()
|
||||
}
|
||||
);
|
||||
assert_eq!(row_counts(registry.pool()).await, (0, 0));
|
||||
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn task_worker_lease_and_fencing_contract() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
let registry = database.registry().await;
|
||||
let store = store_with(registry.pool().clone(), 8);
|
||||
|
||||
let created = store
|
||||
.accept(request(&key("lease1"), &digest("f1"), AGENT, 30_000))
|
||||
.await
|
||||
.unwrap();
|
||||
let leases = store.claim_batch("worker_1", 4, 10_000).await.unwrap();
|
||||
assert_eq!(leases.len(), 1);
|
||||
assert_eq!(leases[0].record.task_id, created.task_id);
|
||||
assert_eq!(leases[0].record.state, TaskState::Working);
|
||||
assert_eq!(leases[0].owner, "worker_1");
|
||||
|
||||
let lease = &leases[0];
|
||||
let fenced_progress = store
|
||||
.write_progress(
|
||||
"worker_1",
|
||||
lease.record.task_id,
|
||||
lease.fence,
|
||||
TaskEnvelope::try_redacted(&json!({"progress": 1})).unwrap(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(fenced_progress.progress.is_some());
|
||||
|
||||
// stale fence rejected
|
||||
let bad = store
|
||||
.renew_lease("worker_1", lease.record.task_id, lease.fence + 1, 10_000)
|
||||
.await;
|
||||
assert!(bad.is_err());
|
||||
|
||||
// checkpoint dispatch once
|
||||
let checkpointed = store
|
||||
.checkpoint_dispatch(
|
||||
"worker_1",
|
||||
lease.record.task_id,
|
||||
lease.fence,
|
||||
"attempt-1".to_owned(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
checkpointed.current_attempt_id.as_deref(),
|
||||
Some("attempt-1")
|
||||
);
|
||||
assert!(checkpointed.dispatch_started_at_unix_ms.is_some());
|
||||
|
||||
// second checkpoint rejected
|
||||
let second = store
|
||||
.checkpoint_dispatch(
|
||||
"worker_1",
|
||||
lease.record.task_id,
|
||||
lease.fence,
|
||||
"attempt-2".to_owned(),
|
||||
)
|
||||
.await;
|
||||
assert!(second.is_err());
|
||||
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn store_failure_fails_closed_without_records() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
// No migration on this schema: the durable Task state does not exist yet.
|
||||
let unmigrated = database.raw_pool().await;
|
||||
let store = store_with(unmigrated, 8);
|
||||
|
||||
assert!(store.health().await.is_err());
|
||||
let error = store
|
||||
.accept(request(&key("k1"), &digest("f1"), AGENT, 30_000))
|
||||
.await
|
||||
.expect_err("acceptance fails closed");
|
||||
assert!(matches!(error, TaskError::Unavailable { .. }));
|
||||
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
/// Story 4.3 ATDD: the typed immutable Platform API key reference of an accepted Task is persisted,
|
||||
/// read back through the lease, and only an active, unexpired, exactly bound key is authoritatively
|
||||
/// revalidated. Revocation, expiry and a foreign workspace/agent binding all close; an administrator
|
||||
/// Task stores no machine key identity at all, so a worker fails closed on it.
|
||||
#[tokio::test]
|
||||
async fn accepted_task_authority_reference_is_persisted_and_revalidated() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
let registry = database.registry().await;
|
||||
let store = store_with(registry.pool().clone(), 8);
|
||||
|
||||
let workspace = WorkspaceId::new(WORKSPACE);
|
||||
let now = OffsetDateTime::now_utc();
|
||||
// `ws_default` is seeded by the baseline migration; the keys only need that workspace row.
|
||||
let agent = AgentId::new(AGENT);
|
||||
|
||||
let active_id = PlatformApiKeyId::new("pk_task_active");
|
||||
for key in [
|
||||
authority_key(
|
||||
"pk_task_active",
|
||||
&workspace,
|
||||
AGENT,
|
||||
PlatformApiKeyStatus::Active,
|
||||
None,
|
||||
),
|
||||
authority_key(
|
||||
"pk_task_revoked",
|
||||
&workspace,
|
||||
AGENT,
|
||||
PlatformApiKeyStatus::Revoked,
|
||||
None,
|
||||
),
|
||||
authority_key(
|
||||
"pk_task_expired",
|
||||
&workspace,
|
||||
AGENT,
|
||||
PlatformApiKeyStatus::Active,
|
||||
Some(now - TimeDuration::hours(1)),
|
||||
),
|
||||
] {
|
||||
let secret_hash = format!("secret-hash-{}", key.id.as_str());
|
||||
registry
|
||||
.create_platform_api_key(CreatePlatformApiKeyRequest {
|
||||
secret_hash: &secret_hash,
|
||||
api_key: &key,
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
// Acceptance persists only the immutable typed reference, never the bearer secret.
|
||||
let mut accepted = request(&key("k_authority"), &digest("fa"), AGENT, 300_000);
|
||||
accepted.platform_api_key_id = Some(active_id.clone());
|
||||
let task_id = accepted.task_id;
|
||||
store.accept(accepted).await.expect("acceptance commits");
|
||||
|
||||
let leases = store
|
||||
.claim_batch("worker_authority", 8, 30_000)
|
||||
.await
|
||||
.expect("claim");
|
||||
let lease = leases
|
||||
.into_iter()
|
||||
.find(|lease| lease.record.task_id == task_id)
|
||||
.expect("accepted task is leased");
|
||||
assert_eq!(lease.record.platform_api_key_id.as_ref(), Some(&active_id));
|
||||
|
||||
// Positive: the exact active key of this workspace/agent is revalidated authoritatively.
|
||||
let revalidated = registry
|
||||
.revalidate_platform_api_key(&workspace, &agent, &active_id)
|
||||
.await
|
||||
.expect("authoritative read")
|
||||
.expect("active key is authoritative");
|
||||
assert!(
|
||||
revalidated
|
||||
.api_key
|
||||
.scopes
|
||||
.contains(&PlatformApiKeyScope::Write)
|
||||
);
|
||||
|
||||
// Negatives: revocation, expiry and a foreign workspace/agent binding all fail closed.
|
||||
let foreign_agent = AgentId::new("agent_b");
|
||||
let foreign_workspace = WorkspaceId::new("ws_elsewhere");
|
||||
for (other_workspace, other_agent, other_key) in [
|
||||
(&workspace, &agent, PlatformApiKeyId::new("pk_task_revoked")),
|
||||
(&workspace, &agent, PlatformApiKeyId::new("pk_task_expired")),
|
||||
(&workspace, &foreign_agent, active_id.clone()),
|
||||
(&foreign_workspace, &agent, active_id.clone()),
|
||||
] {
|
||||
let found = registry
|
||||
.revalidate_platform_api_key(other_workspace, other_agent, &other_key)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(
|
||||
found.is_none(),
|
||||
"authority must fail closed for {}",
|
||||
other_key.as_str()
|
||||
);
|
||||
}
|
||||
|
||||
// An administrator Task carries no machine key identity: the worker has nothing to revalidate.
|
||||
let mut admin_request = request(&key("k_admin"), &digest("fb"), AGENT, 300_000);
|
||||
admin_request.owner_kind = TaskOwnerKind::Admin;
|
||||
admin_request.owner_id = "user_admin".to_owned();
|
||||
admin_request.authorization_scope = "admin:user_admin".to_owned();
|
||||
admin_request.platform_api_key_id = None;
|
||||
let admin_task = admin_request.task_id;
|
||||
store
|
||||
.accept(admin_request)
|
||||
.await
|
||||
.expect("administrator acceptance commits");
|
||||
let admin_record = store
|
||||
.read(
|
||||
&TaskAccess {
|
||||
workspace_id: WORKSPACE.to_owned(),
|
||||
owner_kind: TaskOwnerKind::Admin,
|
||||
owner_id: "user_admin".to_owned(),
|
||||
authorization_scope: "admin:user_admin".to_owned(),
|
||||
},
|
||||
admin_task,
|
||||
)
|
||||
.await
|
||||
.expect("owner read");
|
||||
assert_eq!(admin_record.platform_api_key_id, None);
|
||||
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
fn authority_key(
|
||||
id: &str,
|
||||
workspace_id: &WorkspaceId,
|
||||
agent: &str,
|
||||
status: PlatformApiKeyStatus,
|
||||
expires_at: Option<OffsetDateTime>,
|
||||
) -> PlatformApiKey {
|
||||
PlatformApiKey {
|
||||
id: PlatformApiKeyId::new(id),
|
||||
workspace_id: workspace_id.clone(),
|
||||
agent_id: Some(AgentId::new(agent)),
|
||||
key_kind: PlatformApiKeyKind::McpClient,
|
||||
name: id.to_owned(),
|
||||
prefix: "crk_live".to_owned(),
|
||||
scopes: vec![PlatformApiKeyScope::Write],
|
||||
status,
|
||||
created_at: OffsetDateTime::now_utc(),
|
||||
last_used_at: None,
|
||||
expires_at,
|
||||
allowed_origins: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
mod task_worker;
|
||||
@@ -0,0 +1,163 @@
|
||||
//! Story 4.3 ATDD: durable Task leases, fencing, crash recovery and bounded claim behavior.
|
||||
//!
|
||||
//! Split from `tasks.rs` to keep both integration files inside the code-health limit.
|
||||
|
||||
use super::*;
|
||||
use serde_json::json;
|
||||
|
||||
/// Story 4.3 ATDD: a worker crash before the durable dispatch checkpoint leaves only an expired
|
||||
/// lease. PostgreSQL is authoritative, so another worker recovers the Task and the dead owner can
|
||||
/// never commit a terminal outcome with its old fence.
|
||||
#[tokio::test]
|
||||
async fn task_worker_expired_pre_checkpoint_lease_is_recovered_and_stale_owner_cannot_commit() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
let registry = database.registry().await;
|
||||
let store = store_with(registry.pool().clone(), 8);
|
||||
|
||||
let created = store
|
||||
.accept(request(&key("recover1"), &digest("f2"), AGENT, 30_000))
|
||||
.await
|
||||
.unwrap();
|
||||
let first = store.claim_batch("worker_dead", 1, 150).await.unwrap();
|
||||
assert_eq!(first.len(), 1);
|
||||
assert_eq!(first[0].record.task_id, created.task_id);
|
||||
|
||||
tokio::time::sleep(std::time::Duration::from_millis(250)).await;
|
||||
|
||||
// Recovery on the next bounded authoritative scan, with no Valkey wake-up.
|
||||
let recovered = store.claim_batch("worker_live", 4, 10_000).await.unwrap();
|
||||
let lease = recovered
|
||||
.into_iter()
|
||||
.find(|lease| lease.record.task_id == created.task_id)
|
||||
.expect("expired pre-checkpoint Task is recovered");
|
||||
assert!(lease.fence > first[0].fence, "recovery bumps the fence");
|
||||
|
||||
// The previous owner's terminal CAS is rejected; the live owner wins exactly once.
|
||||
let stale = store
|
||||
.finish_leased(
|
||||
TaskFinishRequest {
|
||||
access: access(AGENT),
|
||||
task_id: created.task_id,
|
||||
expected_state: first[0].record.state,
|
||||
expected_version: first[0].record.version,
|
||||
target_state: TaskState::Completed,
|
||||
result: Some(TaskEnvelope::try_redacted(&json!({"stale": true})).unwrap()),
|
||||
error: None,
|
||||
},
|
||||
"worker_dead",
|
||||
first[0].fence,
|
||||
)
|
||||
.await;
|
||||
assert!(matches!(stale, Err(TaskError::StateConflict)));
|
||||
|
||||
let finished = store
|
||||
.finish_leased(
|
||||
TaskFinishRequest {
|
||||
access: access(AGENT),
|
||||
task_id: created.task_id,
|
||||
expected_state: lease.record.state,
|
||||
expected_version: lease.record.version,
|
||||
target_state: TaskState::Completed,
|
||||
result: Some(TaskEnvelope::try_redacted(&json!({"ok": true})).unwrap()),
|
||||
error: None,
|
||||
},
|
||||
"worker_live",
|
||||
lease.fence,
|
||||
)
|
||||
.await
|
||||
.expect("current lease wins the terminal CAS");
|
||||
assert_eq!(finished.state, TaskState::Completed);
|
||||
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
/// Story 4.3 ATDD: after the dispatch checkpoint the outbound outcome is uncertain. An expired
|
||||
/// attempt resolves to `outcome_unknown`, is never redispatched automatically and releases the
|
||||
/// admission slot it held.
|
||||
#[tokio::test]
|
||||
async fn task_worker_expired_checkpointed_attempt_becomes_outcome_unknown_without_redispatch() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
let registry = database.registry().await;
|
||||
let store = store_with(registry.pool().clone(), 8);
|
||||
|
||||
let created = store
|
||||
.accept(request(&key("uncertain1"), &digest("f3"), AGENT, 30_000))
|
||||
.await
|
||||
.unwrap();
|
||||
let leases = store.claim_batch("worker_dead", 1, 150).await.unwrap();
|
||||
let lease = leases.into_iter().next().expect("claim");
|
||||
store
|
||||
.checkpoint_dispatch(
|
||||
"worker_dead",
|
||||
lease.record.task_id,
|
||||
lease.fence,
|
||||
"attempt-uncertain".to_owned(),
|
||||
)
|
||||
.await
|
||||
.expect("durable dispatch checkpoint");
|
||||
|
||||
tokio::time::sleep(std::time::Duration::from_millis(250)).await;
|
||||
|
||||
// The authority scan resolves uncertainty instead of handing the attempt to another worker.
|
||||
let after = store.claim_batch("worker_live", 4, 10_000).await.unwrap();
|
||||
assert!(
|
||||
after.is_empty(),
|
||||
"a checkpointed attempt must never be redispatched"
|
||||
);
|
||||
let record = store.read(&access(AGENT), created.task_id).await.unwrap();
|
||||
assert_eq!(record.state, TaskState::OutcomeUnknown);
|
||||
assert_eq!(
|
||||
record.current_attempt_id.as_deref(),
|
||||
Some("attempt-uncertain")
|
||||
);
|
||||
let intents: i64 = sqlx::query_scalar(
|
||||
"select count(*)::bigint from execution_admission_entries where task_id = $1",
|
||||
)
|
||||
.bind(created.task_id.as_uuid())
|
||||
.fetch_one(registry.pool())
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(intents, 0, "uncertain terminal outcome releases capacity");
|
||||
|
||||
// Still no automatic retry on the following scans.
|
||||
assert!(
|
||||
store
|
||||
.claim_batch("worker_live", 4, 10_000)
|
||||
.await
|
||||
.unwrap()
|
||||
.is_empty()
|
||||
);
|
||||
|
||||
database.cleanup().await;
|
||||
}
|
||||
|
||||
/// Story 4.3 ATDD: concurrent claimers never hold the same Task at once.
|
||||
#[tokio::test]
|
||||
async fn task_worker_concurrent_claimers_never_double_lease_one_task() {
|
||||
let database = common::TestDatabase::new().await;
|
||||
let registry = database.registry().await;
|
||||
let store = std::sync::Arc::new(store_with(registry.pool().clone(), 8));
|
||||
|
||||
let created = store
|
||||
.accept(request(&key("concurrent1"), &digest("f4"), AGENT, 30_000))
|
||||
.await
|
||||
.unwrap();
|
||||
let mut handles = Vec::new();
|
||||
for index in 0..4 {
|
||||
let store = store.clone();
|
||||
handles.push(tokio::spawn(async move {
|
||||
store
|
||||
.claim_batch(&format!("worker_{index}"), 1, 10_000)
|
||||
.await
|
||||
.unwrap()
|
||||
}));
|
||||
}
|
||||
let mut leased = Vec::new();
|
||||
for handle in handles {
|
||||
leased.extend(handle.await.unwrap());
|
||||
}
|
||||
assert_eq!(leased.len(), 1, "exactly one owner wins the claim");
|
||||
assert_eq!(leased[0].record.task_id, created.task_id);
|
||||
|
||||
database.cleanup().await;
|
||||
}
|
||||
Loaded 100 of 136 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user