CI / Rust Checks (pull_request) Failing after 13m41s
CI / UI Checks (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Deploy (pull_request) Skipped
Community Release / release (push) Failing after 13m33s
Recovery delivery of the accumulated, TL-accepted Epic 3 work that had never been
committed to Git (stories 3.6-3.17, see the crank board). Story 3.18 is not accepted
yet and is deliberately excluded: its logging surface, its capability registration,
its oracle projections and its tests are not part of this tree.
Accepted scope
- 3.6 typed static Resource Drafts; 3.7 publication and exact binding of static
Resource Versions; 3.8 MCP discovery/read and revocation of static Resources;
- 3.9 Resource import/export in API and UI plus TLS dependency maintenance;
3.10 REST-backed Resource templates; 3.11 shared REST read runtime and the MCP
revision/capability foundation;
- 3.12 parameterised Prompt Drafts with preview; 3.13 Prompt publication and exact
version binding to Agents; 3.14 MCP prompts; 3.15 Prompt import/export;
- 3.16 composite Prompts with published Resources (dependency content scan plus
dynamic read through the accepted 3.11 runtime, admin preview and MCP prompts/get);
- 3.17 bounded MCP completion suggestions from typed published schemas and the
resources/list admission fix for bound template publications.
Accepted evidence being reused (unchanged code paths)
- 3.16 candidate: core 7, admin-api 22, registry 4, mcp-server 4, UI 6; one final
`just verify` run 1651 passed / 0 failed / 2 ignored.
- 3.17 candidate: full run 1672 passed / 0 failed / 2 ignored, QA targeted reruns and
a real MCP Inspector 2.12.0 client smoke.
Delivery engineering in this commit
- CI: one event per change (feature branches are gated by their pull request, push
runs only on main), story events run the changed packages, the full workspace suite
stays the feature/release gate; no cache/sharding without a measured runner check.
- Release: the packaged archives, checksums and SBOM are now uploaded to the Gitea
release entry of the tag instead of dying with the runner workspace.
Not included on purpose: Story 3.18 work, build caches, runtime databases, local
credentials and scratch evidence.
Refs: crank kanban t_e39d7263; baseline 1b6db09bd1.
194 lines
6.4 KiB
Rust
194 lines
6.4 KiB
Rust
use std::time::Duration;
|
|
|
|
use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD};
|
|
use crank_core::{CachedHeader, CachedResponse, HttpMethod, Target};
|
|
use serde_json::{Value, json};
|
|
use sha2::{Digest, Sha256};
|
|
|
|
use crate::{AdapterResponse, PreparedRequest, RuntimeOperation, RuntimeRequestContext};
|
|
|
|
pub(crate) fn response_cache_ttl(
|
|
operation: &RuntimeOperation,
|
|
request_context: Option<&RuntimeRequestContext>,
|
|
) -> Option<Duration> {
|
|
let is_cacheable_protocol =
|
|
matches!(&operation.target, Target::Rest(target) if target.method == HttpMethod::Get);
|
|
if !is_cacheable_protocol {
|
|
return None;
|
|
}
|
|
if let Some(policy) = request_context.and_then(RuntimeRequestContext::resource_response_cache) {
|
|
if policy.ttl_ms == 0 {
|
|
return None;
|
|
}
|
|
return Some(Duration::from_millis(policy.ttl_ms));
|
|
}
|
|
|
|
let policy = operation.execution_config.response_cache.as_ref()?;
|
|
if operation.execution_config.auth_profile_ref.is_some() || policy.ttl_ms == 0 {
|
|
return None;
|
|
}
|
|
Some(Duration::from_millis(policy.ttl_ms))
|
|
}
|
|
|
|
pub(crate) fn response_cache_key(
|
|
operation: &RuntimeOperation,
|
|
prepared_request: &PreparedRequest,
|
|
request_context: Option<&RuntimeRequestContext>,
|
|
) -> Option<String> {
|
|
let _ = response_cache_ttl(operation, request_context)?;
|
|
let scope = request_context?.response_cache_scope()?;
|
|
let fingerprint_hash = prepared_request_fingerprint(prepared_request)?;
|
|
|
|
let auth_scope = operation
|
|
.execution_config
|
|
.auth_profile_ref
|
|
.as_ref()
|
|
.map(|id| id.as_str())
|
|
.unwrap_or("none");
|
|
let resource_scope = request_context.and_then(RuntimeRequestContext::resource_response_cache);
|
|
if resource_scope.is_none() {
|
|
return Some(format!(
|
|
"crank:response:workspace:{}:agent:{}:operation:{}:version:{}:request:{}",
|
|
scope.workspace_key,
|
|
scope.agent_key,
|
|
operation.operation_id.as_str(),
|
|
operation.operation_version,
|
|
fingerprint_hash
|
|
));
|
|
}
|
|
let resource_fingerprint =
|
|
resource_scope.and_then(|resource| resource_cache_identity(resource, auth_scope));
|
|
let resource_key = resource_fingerprint.unwrap_or_default();
|
|
Some(format!(
|
|
"crank:response:workspace:{}:agent:{}:operation:{}:version:{}:resource:{}:request:{}",
|
|
scope.workspace_key,
|
|
scope.agent_key,
|
|
operation.operation_id.as_str(),
|
|
operation.operation_version,
|
|
resource_key,
|
|
fingerprint_hash
|
|
))
|
|
}
|
|
|
|
fn prepared_request_fingerprint(prepared_request: &PreparedRequest) -> Option<String> {
|
|
let fingerprint = json!({
|
|
"path_params": prepared_request.path_params,
|
|
"query_params": prepared_request.query_params,
|
|
"headers": prepared_request.headers,
|
|
"body": prepared_request.body,
|
|
});
|
|
let bytes = serde_json::to_vec(&fingerprint).ok()?;
|
|
Some(URL_SAFE_NO_PAD.encode(Sha256::digest(bytes)))
|
|
}
|
|
|
|
fn resource_cache_identity(
|
|
resource: &crate::request_context::ResourceResponseCache,
|
|
auth_scope: &str,
|
|
) -> Option<String> {
|
|
let identity = serde_json::to_vec(&json!({
|
|
"resource_id": resource.resource_id,
|
|
"version": resource.version,
|
|
"auth_profile": auth_scope,
|
|
}))
|
|
.ok()?;
|
|
Some(URL_SAFE_NO_PAD.encode(Sha256::digest(identity)))
|
|
}
|
|
|
|
pub(crate) fn cached_response_from_adapter(
|
|
adapter_response: &AdapterResponse,
|
|
) -> Option<CachedResponse> {
|
|
let body = serde_json::to_vec(&adapter_response.body).ok()?;
|
|
Some(CachedResponse {
|
|
status: adapter_response.status_code,
|
|
headers: adapter_response
|
|
.headers
|
|
.iter()
|
|
.map(|(name, value)| CachedHeader {
|
|
name: name.clone(),
|
|
value: value.clone(),
|
|
})
|
|
.collect(),
|
|
body,
|
|
data: serde_json::to_vec(&adapter_response.data).ok()?,
|
|
})
|
|
}
|
|
|
|
pub(crate) fn adapter_response_from_cached(
|
|
cached_response: CachedResponse,
|
|
) -> Result<AdapterResponse, String> {
|
|
let body: Value =
|
|
serde_json::from_slice(&cached_response.body).map_err(|error| error.to_string())?;
|
|
let data: Value =
|
|
serde_json::from_slice(&cached_response.data).map_err(|error| error.to_string())?;
|
|
Ok(AdapterResponse {
|
|
status_code: cached_response.status,
|
|
headers: cached_response
|
|
.headers
|
|
.into_iter()
|
|
.map(|header| (header.name, header.value))
|
|
.collect(),
|
|
body,
|
|
data,
|
|
})
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use std::collections::BTreeMap;
|
|
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn resource_cache_identity_separates_resource_version_and_auth_scope_without_disclosing_values()
|
|
{
|
|
let base = crate::request_context::ResourceResponseCache {
|
|
resource_id: "resource-a".to_owned(),
|
|
version: 1,
|
|
ttl_ms: 30_000,
|
|
max_bytes: 1024,
|
|
};
|
|
let base_key = resource_cache_identity(&base, "auth-a").unwrap();
|
|
assert_ne!(base_key, resource_cache_identity(&base, "auth-b").unwrap());
|
|
assert_ne!(
|
|
base_key,
|
|
resource_cache_identity(
|
|
&crate::request_context::ResourceResponseCache {
|
|
version: 2,
|
|
..base.clone()
|
|
},
|
|
"auth-a"
|
|
)
|
|
.unwrap()
|
|
);
|
|
assert_ne!(
|
|
base_key,
|
|
resource_cache_identity(
|
|
&crate::request_context::ResourceResponseCache {
|
|
resource_id: "resource-b".to_owned(),
|
|
..base
|
|
},
|
|
"auth-a"
|
|
)
|
|
.unwrap()
|
|
);
|
|
assert!(!base_key.contains("resource-a"));
|
|
assert!(!base_key.contains("auth-a"));
|
|
}
|
|
|
|
#[test]
|
|
fn prepared_request_fingerprint_separates_canonical_parameter_values_without_disclosure() {
|
|
let first = PreparedRequest {
|
|
path_params: BTreeMap::from([("order_id".to_owned(), "order-a".to_owned())]),
|
|
..PreparedRequest::default()
|
|
};
|
|
let second = PreparedRequest {
|
|
path_params: BTreeMap::from([("order_id".to_owned(), "order-b".to_owned())]),
|
|
..PreparedRequest::default()
|
|
};
|
|
let first_key = prepared_request_fingerprint(&first).unwrap();
|
|
let second_key = prepared_request_fingerprint(&second).unwrap();
|
|
assert_ne!(first_key, second_key);
|
|
assert!(!first_key.contains("order-a"));
|
|
}
|
|
}
|