Hare/yoi
1
1
Fork 0
Code Actions Packages Releases Activity

feat: bind memory language to workspace settings

Browse Source
This commit is contained in:
Hare
2026-08-21 21:50:12 +09:00
parent 19f506f8bc
commit c4814115de
14 changed files with 927 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/workspace-server/src/hosts.rs
+17
View File
@@ -518,6 +518,9 @@ pub struct WorkerSpawnRequest {
pub resolved_config_bundle: Option<ConfigBundle>,
#[serde(skip, default)]
pub resolved_workspace_api: Option<WorkspaceApiRef>,
/// Backend-authored immutable Workspace Memory settings snapshot.
#[serde(skip, default)]
pub resolved_memory_settings: Option<manifest::WorkspaceMemorySettingsSnapshot>,
/// Backend-owned feature enablement; client input cannot set it.
#[serde(skip, default)]
pub resolved_worker_observation_enabled: bool,
@@ -2184,6 +2187,7 @@ impl WorkspaceWorkerRuntime for EmbeddedWorkerRuntime {
worker_observation_enabled: request.resolved_worker_observation_enabled,
worker_observation_grants: request.resolved_worker_observation_grants.clone(),
workspace_api: Some(workspace_api),
memory_settings: request.resolved_memory_settings.clone(),
};
let workspace_scope = RuntimeWorkspaceScope::new(workspace_id, "embedded-backend");
match self
@@ -3331,6 +3335,7 @@ impl WorkspaceWorkerRuntime for RemoteWorkerRuntime {
worker_observation_enabled: request.resolved_worker_observation_enabled,
worker_observation_grants: request.resolved_worker_observation_grants.clone(),
workspace_api: Some(workspace_api),
memory_settings: request.resolved_memory_settings.clone(),
};
match self.post_json::<_, RuntimeHttpWorkerResponse>("/v1/workers", &create) {
Ok(response) => WorkerSpawnResult {
@@ -4408,6 +4413,14 @@ mod tests {
}
}
fn test_memory_settings() -> manifest::WorkspaceMemorySettingsSnapshot {
manifest::WorkspaceMemorySettingsSnapshot {
workspace_id: "workspace-test".to_string(),
settings_revision: 1,
language: "English".to_string(),
}
}
#[test]
fn worker_summary_keeps_flat_wire_identity_while_using_structured_internal_identity() {
let summary = placeholder_worker("placeholder");
@@ -5007,6 +5020,7 @@ mod tests {
resolved_worker_observation_grants: Vec::new(),
resolved_control_operation: None,
resolved_workspace_api: Some(test_workspace_api()),
resolved_memory_settings: Some(test_memory_settings()),
}
}
@@ -5246,6 +5260,7 @@ mod tests {
resolved_worker_observation_grants: Vec::new(),
resolved_control_operation: None,
resolved_workspace_api: Some(test_workspace_api()),
resolved_memory_settings: Some(test_memory_settings()),
},
)
.unwrap();
@@ -5345,6 +5360,7 @@ mod tests {
resolved_worker_observation_grants: Vec::new(),
resolved_control_operation: None,
resolved_workspace_api: Some(test_workspace_api()),
resolved_memory_settings: Some(test_memory_settings()),
},
)
.unwrap();
@@ -5383,6 +5399,7 @@ mod tests {
resolved_worker_observation_grants: Vec::new(),
resolved_control_operation: None,
resolved_workspace_api: Some(test_workspace_api()),
resolved_memory_settings: Some(test_memory_settings()),
},
)
.unwrap();
crates/workspace-server/src/runtime_subscription_tests.rs
+5
View File
@@ -86,6 +86,11 @@ fn create_request(name: &str) -> CreateWorkerRequest {
worker_observation_enabled: false,
worker_observation_grants: Vec::new(),
workspace_api: None,
memory_settings: Some(manifest::WorkspaceMemorySettingsSnapshot {
workspace_id: "local".to_string(),
settings_revision: 1,
language: "English".to_string(),
}),
}
}
crates/workspace-server/src/server.rs
+99 -7
View File
@@ -1182,8 +1182,11 @@ impl WorkspaceApi {
&now_registry_timestamp(),
)?;
}
let create_fingerprint = worker_spawn_create_fingerprint(&request)
let request_fingerprint = worker_spawn_create_fingerprint(&request)
.map_err(|message| Error::Config(message.to_string()))?;
let current_memory_settings = self
.config_store
.get_workspace_memory_settings(&self.config.workspace_id)?;
let allocation_key = request
.resolved_control_operation
.as_ref()
@@ -1195,22 +1198,25 @@ impl WorkspaceApi {
.map(|assignment| assignment.operation_id.clone())
})
.unwrap_or_else(|| format!("manual:{}", WorkerId::now_v7()));
let worker_id = self
let reservation = self
.config_store
.reserve_worker_create(
&self.config.workspace_id,
runtime_id,
&allocation_key,
&create_fingerprint,
&request_fingerprint,
&current_memory_settings,
)
.map_err(|error| Error::RuntimeOperationFailed {
runtime_id: runtime_id.to_string(),
code: "workspace_worker_allocation_conflict".to_string(),
message: error.to_string(),
})?;
let worker_id = reservation.worker_id;
request.resolved_memory_settings = Some(reservation.memory_settings);
let create_binding = WorkerCreateBinding {
worker_id,
create_fingerprint,
create_fingerprint: reservation.create_fingerprint,
};
let result = match self
.runtime
@@ -1601,6 +1607,11 @@ pub fn build_router(api: WorkspaceApi) -> Router {
"/api/w/{workspace_id}/settings/workspace",
get(scoped_get_workspace_settings).put(scoped_update_workspace_settings),
)
.route(
"/api/w/{workspace_id}/settings/memory",
get(scoped_get_workspace_memory_settings)
.put(scoped_update_workspace_memory_settings),
)
.route(
"/api/w/{workspace_id}/config/source-tree",
get(scoped_get_workspace_config_tree),
@@ -2998,6 +3009,57 @@ struct WorkspaceConfigTreeResponse {
projection_digest: String,
}
async fn scoped_get_workspace_memory_settings(
State(api): State<WorkspaceApi>,
AxumPath(workspace_id): AxumPath<String>,
) -> ApiResult<Json<workspace_api::WorkspaceMemorySettings>> {
if api
.config_store
.get_workspace(&workspace_id)
.await?
.is_none()
{
return Err(ApiError::from(Error::WorkspaceIdMismatch));
}
let settings = api
.config_store
.get_workspace_memory_settings(&workspace_id)
.map_err(ApiError::from)?;
Ok(Json(workspace_api::WorkspaceMemorySettings {
workspace_id: settings.workspace_id,
settings_revision: settings.settings_revision,
language: settings.language,
}))
}
async fn scoped_update_workspace_memory_settings(
State(api): State<WorkspaceApi>,
AxumPath(workspace_id): AxumPath<String>,
Json(request): Json<workspace_api::UpdateWorkspaceMemorySettingsRequest>,
) -> ApiResult<Json<workspace_api::WorkspaceMemorySettings>> {
if api
.config_store
.get_workspace(&workspace_id)
.await?
.is_none()
{
return Err(ApiError::from(Error::WorkspaceIdMismatch));
}
let settings = api
.config_store
.update_workspace_memory_settings(
&workspace_id,
request.expected_revision,
&request.language,
)
.map_err(ApiError::from)?;
Ok(Json(workspace_api::WorkspaceMemorySettings {
workspace_id: settings.workspace_id,
settings_revision: settings.settings_revision,
language: settings.language,
}))
}
async fn scoped_get_workspace_config_tree(
State(api): State<WorkspaceApi>,
AxumPath(path): AxumPath<ScopedWorkspacePath>,
@@ -6126,6 +6188,7 @@ fn start_memory_staging_consolidation(
resolved_worker_observation_grants: Vec::new(),
resolved_control_operation: None,
resolved_workspace_api: None,
resolved_memory_settings: None,
},
)?;
if result.state != WorkerOperationState::Accepted {
@@ -7192,6 +7255,7 @@ async fn scoped_start_workspace_orchestrator(
resolved_worker_observation_grants: Vec::new(),
resolved_control_operation: None,
resolved_workspace_api: None,
resolved_memory_settings: None,
},
)?;
if result.state != WorkerOperationState::Accepted || result.worker.is_none() {
@@ -9736,6 +9800,7 @@ async fn create_workspace_worker(
resolved_worker_observation_grants: Vec::new(),
resolved_control_operation,
resolved_workspace_api: None,
resolved_memory_settings: None,
};
validate_ticket_assignment_spawn(&api, &runtime_id, &request)?;
let assignment = request.ticket_assignment.clone();
@@ -13164,6 +13229,14 @@ mod tests {
}
}
fn test_worker_memory_settings() -> manifest::WorkspaceMemorySettingsSnapshot {
manifest::WorkspaceMemorySettingsSnapshot {
workspace_id: TEST_WORKSPACE_ID.to_string(),
settings_revision: 1,
language: "English".to_string(),
}
}
#[test]
fn ticket_api_errors_preserve_http_status() {
let not_found = ApiError::from(Error::Ticket(ticket::TicketError::NotFound(
@@ -13432,6 +13505,7 @@ mod tests {
resolved_worker_observation_grants: Vec::new(),
resolved_control_operation: None,
resolved_workspace_api: None,
resolved_memory_settings: None,
};
assert!(
api.validate_worker_spawn_repository_scope(&workdir_flow_launch)
@@ -13604,6 +13678,7 @@ mod tests {
resolved_worker_observation_grants: Vec::new(),
resolved_control_operation: None,
resolved_workspace_api: None,
resolved_memory_settings: None,
};
assert!(
@@ -15069,6 +15144,7 @@ mod tests {
resolved_workspace_api: Some(test_worker_workspace_api(
EMBEDDED_WORKER_RUNTIME_ID,
)),
resolved_memory_settings: Some(test_worker_memory_settings()),
resolved_control_operation: None,
},
)
@@ -15282,6 +15358,7 @@ mod tests {
resolved_workspace_api: Some(test_worker_workspace_api(
EMBEDDED_WORKER_RUNTIME_ID,
)),
resolved_memory_settings: Some(test_worker_memory_settings()),
resolved_control_operation: None,
},
)
@@ -15492,6 +15569,7 @@ mod tests {
resolved_worker_observation_enabled: false,
resolved_worker_observation_grants: Vec::new(),
resolved_workspace_api: Some(test_worker_workspace_api(EMBEDDED_WORKER_RUNTIME_ID)),
resolved_memory_settings: Some(test_worker_memory_settings()),
resolved_control_operation: None,
};
let source_worker = api
@@ -15756,6 +15834,7 @@ mod tests {
resolved_workspace_api: Some(test_worker_workspace_api(
EMBEDDED_WORKER_RUNTIME_ID,
)),
resolved_memory_settings: Some(test_worker_memory_settings()),
resolved_control_operation: None,
},
)
@@ -15881,6 +15960,7 @@ mod tests {
resolved_worker_observation_grants: Vec::new(),
resolved_control_operation: None,
resolved_workspace_api: None,
resolved_memory_settings: None,
};
let Json(first) = scoped_create_runtime_worker(
State(api.clone()),
@@ -16045,22 +16125,28 @@ mod tests {
TEST_CREATED_AT,
)
.unwrap();
let reserved_worker_id = api
let current_memory_settings = api
.config_store
.get_workspace_memory_settings(TEST_WORKSPACE_ID)
.unwrap();
let reservation = api
.config_store
.reserve_worker_create(
TEST_WORKSPACE_ID,
EMBEDDED_WORKER_RUNTIME_ID,
"pending-spawn-operation",
&pending_fingerprint,
&current_memory_settings,
)
.unwrap();
pending_request.resolved_memory_settings = Some(reservation.memory_settings.clone());
let spawned_before_backend_failure = api
.runtime
.spawn_worker(
EMBEDDED_WORKER_RUNTIME_ID,
WorkerCreateBinding {
worker_id: reserved_worker_id,
create_fingerprint: pending_fingerprint.clone(),
worker_id: reservation.worker_id,
create_fingerprint: reservation.create_fingerprint,
},
pending_request.clone(),
)
@@ -16139,6 +16225,7 @@ mod tests {
resolved_worker_observation_grants: Vec::new(),
resolved_control_operation: None,
resolved_workspace_api: None,
resolved_memory_settings: None,
};
let Json(created) = scoped_create_runtime_worker(
State(api.clone()),
@@ -16699,6 +16786,7 @@ mod tests {
resolved_worker_observation_enabled: false,
resolved_worker_observation_grants: Vec::new(),
resolved_workspace_api: None,
resolved_memory_settings: None,
resolved_control_operation: None,
},
)
@@ -16755,6 +16843,7 @@ mod tests {
resolved_worker_observation_enabled: false,
resolved_worker_observation_grants: Vec::new(),
resolved_workspace_api: None,
resolved_memory_settings: None,
resolved_control_operation: None,
},
)
@@ -17680,6 +17769,7 @@ mod tests {
worker_observation_enabled: false,
worker_observation_grants: Vec::new(),
workspace_api: None,
memory_settings: None,
}
}
@@ -18974,6 +19064,7 @@ mod tests {
resolved_workspace_api: Some(test_worker_workspace_api(
"embedded-worker-runtime",
)),
resolved_memory_settings: Some(test_worker_memory_settings()),
resolved_control_operation: None,
},
)
@@ -19493,6 +19584,7 @@ mod tests {
resolved_worker_observation_grants: Vec::new(),
resolved_control_operation: None,
resolved_workspace_api: None,
resolved_memory_settings: None,
};
let spawned = api
.spawn_workspace_worker(EMBEDDED_WORKER_RUNTIME_ID, spawn_request)
crates/workspace-server/src/store.rs
+356 -43
View File
@@ -8,6 +8,7 @@ use rusqlite::{
Connection, OpenFlags, OptionalExtension, TransactionBehavior, backup::Backup, params,
};
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use uuid::Uuid;
use worker_runtime::identity::{
@@ -230,6 +231,11 @@ const MIGRATIONS: &[Migration] = &[
name: "rename Workspace resource keys",
apply: verify_workspace_resource_key_schema,
},
Migration {
version: 42,
name: "create Workspace Memory settings authority",
apply: create_workspace_memory_settings_authority,
},
];
struct Migration {
@@ -261,6 +267,22 @@ pub struct WorkspaceRecord {
pub updated_at: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct WorkspaceMemorySettingsRecord {
pub workspace_id: String,
pub settings_revision: u64,
pub language: String,
pub created_at: String,
pub updated_at: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct WorkerCreateReservation {
pub worker_id: WorkerId,
pub create_fingerprint: String,
pub memory_settings: manifest::WorkspaceMemorySettingsSnapshot,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct RepositoryRecord {
pub workspace_id: String,
@@ -1140,14 +1162,97 @@ impl SqliteWorkspaceStore {
f(&mut conn)
}
pub(crate) fn get_workspace_memory_settings(
&self,
workspace_id: &str,
) -> Result<WorkspaceMemorySettingsRecord> {
self.with_conn(|conn| {
conn.query_row(
"SELECT workspace_id, settings_revision, language, created_at, updated_at \
FROM workspace_memory_settings WHERE workspace_id = ?1",
params![workspace_id],
|row| {
let revision = row.get::<_, i64>(1)?;
Ok(WorkspaceMemorySettingsRecord {
workspace_id: row.get(0)?,
settings_revision: revision
.try_into()
.map_err(|_| rusqlite::Error::IntegralValueOutOfRange(1, revision))?,
language: row.get(2)?,
created_at: row.get(3)?,
updated_at: row.get(4)?,
})
},
)
.optional()?
.ok_or_else(|| Error::Store("Workspace Memory settings are missing".to_string()))
})
}
pub(crate) fn update_workspace_memory_settings(
&self,
workspace_id: &str,
expected_revision: u64,
language: &str,
) -> Result<WorkspaceMemorySettingsRecord> {
let language = normalize_workspace_memory_language(language)?;
self.with_conn_mut(|conn| {
let tx = conn.transaction_with_behavior(TransactionBehavior::Immediate)?;
let current_revision = tx
.query_row(
"SELECT settings_revision FROM workspace_memory_settings WHERE workspace_id = ?1",
params![workspace_id],
|row| row.get::<_, i64>(0),
)
.optional()?
.ok_or_else(|| Error::Store("Workspace Memory settings are missing".to_string()))?;
let current_revision: u64 = current_revision.try_into().map_err(|_| {
rusqlite::Error::IntegralValueOutOfRange(0, current_revision)
})?;
if current_revision != expected_revision {
return Err(Error::WorkspaceConfigConflict(format!(
"Workspace Memory settings revision changed: expected {expected_revision}, current {current_revision}"
)));
}
let next_revision = current_revision.checked_add(1).ok_or_else(|| {
Error::InvalidInput("Workspace Memory settings revision overflow".to_string())
})?;
let now = chrono::Utc::now().to_rfc3339();
tx.execute(
"UPDATE workspace_memory_settings \
SET settings_revision = ?2, language = ?3, updated_at = ?4 \
WHERE workspace_id = ?1",
params![workspace_id, next_revision as i64, language, now],
)?;
let record = tx.query_row(
"SELECT workspace_id, settings_revision, language, created_at, updated_at \
FROM workspace_memory_settings WHERE workspace_id = ?1",
params![workspace_id],
|row| {
let revision = row.get::<_, i64>(1)?;
Ok(WorkspaceMemorySettingsRecord {
workspace_id: row.get(0)?,
settings_revision: revision as u64,
language: row.get(2)?,
created_at: row.get(3)?,
updated_at: row.get(4)?,
})
},
)?;
tx.commit()?;
Ok(record)
})
}
pub(crate) fn reserve_worker_create(
&self,
workspace_id: &str,
runtime_id: &str,
allocation_key: &str,
create_fingerprint: &str,
) -> Result<WorkerId> {
if allocation_key.trim().is_empty() || create_fingerprint.trim().is_empty() {
request_fingerprint: &str,
current_memory_settings: &WorkspaceMemorySettingsRecord,
) -> Result<WorkerCreateReservation> {
if allocation_key.trim().is_empty() || request_fingerprint.trim().is_empty() {
return Err(Error::InvalidInput(
"Worker create allocation key and fingerprint must be non-empty".to_string(),
));
@@ -1156,7 +1261,8 @@ impl SqliteWorkspaceStore {
let tx = conn.transaction_with_behavior(TransactionBehavior::Immediate)?;
let existing = tx
.query_row(
"SELECT worker_id, runtime_id, create_fingerprint \
"SELECT worker_id, runtime_id, request_fingerprint, create_fingerprint, \
memory_settings_revision, memory_language \
FROM worker_create_reservations \
WHERE workspace_id = ?1 AND allocation_key = ?2",
params![workspace_id, allocation_key],
@@ -1164,24 +1270,77 @@ impl SqliteWorkspaceStore {
Ok((
row.get::<_, String>(0)?,
row.get::<_, String>(1)?,
row.get::<_, String>(2)?,
row.get::<_, Option<String>>(2)?,
row.get::<_, String>(3)?,
row.get::<_, Option<i64>>(4)?,
row.get::<_, Option<String>>(5)?,
))
},
)
.optional()?;
if let Some((worker_id, reserved_runtime_id, reserved_fingerprint)) = existing {
if reserved_runtime_id != runtime_id || reserved_fingerprint != create_fingerprint {
if let Some((worker_id, reserved_runtime_id, stored_request_fingerprint, create_fingerprint, revision, language)) = existing {
if reserved_runtime_id != runtime_id
|| stored_request_fingerprint.as_deref() != Some(request_fingerprint)
{
return Err(Error::InvalidInput(format!(
"Worker create allocation `{allocation_key}` was already used with different input"
"Worker create allocation {allocation_key} was already used with different input"
)));
}
return worker_id.parse::<WorkerId>().map_err(|_| {
Error::Store(format!(
"Worker create allocation `{allocation_key}` has a non-UUIDv7 worker id"
let revision = revision.ok_or_else(|| {
Error::InvalidInput(format!(
"Worker create allocation {allocation_key} has no persisted Memory settings snapshot"
))
})?;
let language = language.ok_or_else(|| {
Error::InvalidInput(format!(
"Worker create allocation {allocation_key} has no persisted Memory language"
))
})?;
let worker_id = worker_id.parse::<WorkerId>().map_err(|_| {
Error::Store(format!(
"Worker create allocation {allocation_key} has a non-UUIDv7 worker id"
))
})?;
return Ok(WorkerCreateReservation {
worker_id,
create_fingerprint,
memory_settings: manifest::WorkspaceMemorySettingsSnapshot {
workspace_id: workspace_id.to_string(),
settings_revision: revision.try_into().map_err(|_| {
rusqlite::Error::IntegralValueOutOfRange(4, revision)
})?,
language,
},
});
}
let (authoritative_revision, authoritative_language) = tx
.query_row(
"SELECT settings_revision, language FROM workspace_memory_settings WHERE workspace_id = ?1",
params![workspace_id],
|row| Ok((row.get::<_, i64>(0)?, row.get::<_, String>(1)?)),
)
.optional()?
.ok_or_else(|| Error::Store("Workspace Memory settings are missing".to_string()))?;
let authoritative_revision: u64 = authoritative_revision.try_into().map_err(|_| {
rusqlite::Error::IntegralValueOutOfRange(0, authoritative_revision)
})?;
if authoritative_revision != current_memory_settings.settings_revision
|| authoritative_language != current_memory_settings.language
{
return Err(Error::WorkspaceConfigConflict(
"Workspace Memory settings changed while the Worker create reservation was being accepted"
.to_string(),
));
}
let snapshot = manifest::WorkspaceMemorySettingsSnapshot {
workspace_id: workspace_id.to_string(),
settings_revision: authoritative_revision,
language: authoritative_language,
};
let create_fingerprint =
bound_worker_create_fingerprint(request_fingerprint, &snapshot);
let worker_id = WorkerId::now_v7();
let now = chrono::Utc::now().to_rfc3339();
allocate_resource_key(
@@ -1194,19 +1353,27 @@ impl SqliteWorkspaceStore {
tx.execute(
"INSERT INTO worker_create_reservations(\
workspace_id, allocation_key, worker_id, runtime_id, create_fingerprint,\
state, created_at, updated_at\
) VALUES (?1, ?2, ?3, ?4, ?5, 'reserved', ?6, ?6)",
state, created_at, updated_at, request_fingerprint,\
memory_settings_revision, memory_language\
) VALUES (?1, ?2, ?3, ?4, ?5, 'reserved', ?6, ?6, ?7, ?8, ?9)",
params![
workspace_id,
allocation_key,
worker_id.to_string(),
runtime_id,
create_fingerprint,
now
now,
request_fingerprint,
snapshot.settings_revision as i64,
snapshot.language,
],
)?;
tx.commit()?;
Ok(worker_id)
Ok(WorkerCreateReservation {
worker_id,
create_fingerprint,
memory_settings: snapshot,
})
})
}
@@ -1375,8 +1542,9 @@ impl ControlPlaneStore for SqliteWorkspaceStore {
}
async fn upsert_workspace(&self, record: &WorkspaceRecord) -> Result<()> {
self.with_conn(|conn| {
conn.execute(
self.with_conn_mut(|conn| {
let tx = conn.transaction_with_behavior(TransactionBehavior::Immediate)?;
tx.execute(
r#"INSERT INTO workspaces (
workspace_id, owner_account_id, display_name, state, created_at, updated_at
) VALUES (?1, ?2, ?3, ?4, ?5, ?6)
@@ -1394,6 +1562,13 @@ impl ControlPlaneStore for SqliteWorkspaceStore {
record.updated_at,
],
)?;
tx.execute(
r#"INSERT OR IGNORE INTO workspace_memory_settings (
workspace_id, settings_revision, language, created_at, updated_at
) VALUES (?1, 1, 'English', ?2, ?3)"#,
params![record.workspace_id, record.created_at, record.updated_at],
)?;
tx.commit()?;
Ok(())
})?;
self.materialize_workspace_config(&record.workspace_id, &record.created_at)
@@ -1518,6 +1693,16 @@ impl ControlPlaneStore for SqliteWorkspaceStore {
record.workspace.updated_at,
],
)?;
tx.execute(
r#"INSERT INTO workspace_memory_settings (
workspace_id, settings_revision, language, created_at, updated_at
) VALUES (?1, 1, 'English', ?2, ?3)"#,
params![
record.workspace.workspace_id,
record.workspace.created_at,
record.workspace.updated_at,
],
)?;
tx.execute(
r#"INSERT INTO repositories (
workspace_id, repository_id, name, kind, provider, uri, default_ref,
@@ -5730,6 +5915,37 @@ fn collect_reference_diagnostics(
Ok(())
}
fn normalize_workspace_memory_language(language: &str) -> Result<String> {
match language.trim().to_ascii_lowercase().as_str() {
"english" | "en" => Ok("English".to_string()),
"japanese" | "ja" => Ok("Japanese".to_string()),
_ => Err(Error::InvalidInput(
"Workspace Memory language must be one of: English, Japanese".to_string(),
)),
}
}
fn bound_worker_create_fingerprint(
request_fingerprint: &str,
snapshot: &manifest::WorkspaceMemorySettingsSnapshot,
) -> String {
let mut digest = Sha256::new();
digest.update(b"workspace-worker-create-v2\0");
digest.update(request_fingerprint.as_bytes());
digest.update(b"\0");
digest.update(snapshot.workspace_id.as_bytes());
digest.update(b"\0");
digest.update(snapshot.settings_revision.to_be_bytes());
digest.update(b"\0");
digest.update(snapshot.language.as_bytes());
let encoded = digest
.finalize()
.iter()
.map(|byte| format!("{byte:02x}"))
.collect::<String>();
format!("sha256:{encoded}")
}
fn current_schema_version(conn: &Connection) -> Result<i64> {
conn.query_row(
"SELECT COALESCE(MAX(version), 0) FROM __yoi_schema_migrations",
@@ -6373,6 +6589,42 @@ fn add_workspace_resource_human_keys(conn: &Connection) -> Result<()> {
Ok(())
}
fn create_workspace_memory_settings_authority(conn: &Connection) -> Result<()> {
conn.execute_batch(
r#"
CREATE TABLE workspace_memory_settings (
workspace_id TEXT PRIMARY KEY NOT NULL,
settings_revision INTEGER NOT NULL CHECK(settings_revision >= 1),
language TEXT NOT NULL CHECK(length(trim(language)) > 0),
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL,
FOREIGN KEY (workspace_id) REFERENCES workspaces(workspace_id) ON DELETE CASCADE
);
INSERT INTO workspace_memory_settings (
workspace_id,
settings_revision,
language,
created_at,
updated_at
)
SELECT workspace_id, 1, 'English', created_at, updated_at
FROM workspaces;
ALTER TABLE worker_create_reservations
ADD COLUMN request_fingerprint TEXT;
ALTER TABLE worker_create_reservations
ADD COLUMN memory_settings_revision INTEGER;
ALTER TABLE worker_create_reservations
ADD COLUMN memory_language TEXT;
UPDATE worker_create_reservations
SET request_fingerprint = create_fingerprint;
"#,
)?;
Ok(())
}
fn verify_workspace_resource_key_schema(conn: &Connection) -> Result<()> {
ticket::migrate_sqlite_ticket_resource_key_schema_in_transaction(conn).map_err(|error| {
Error::Store(format!(
@@ -7682,7 +7934,7 @@ mod tests {
let before = std::fs::read(&path).unwrap();
let plan = SqliteWorkspaceStore::migration_plan(&path).unwrap();
assert_eq!(plan.current_schema_version, 36);
assert_eq!(plan.target_schema_version, 41);
assert_eq!(plan.target_schema_version, 42);
assert!(plan.migration_required);
assert_eq!(plan.worker_count, 1);
assert_eq!(plan.mappings[0].legacy_worker_id, 7);
@@ -7696,7 +7948,7 @@ mod tests {
store
.with_conn(|conn| {
assert!(table_exists(conn, "worker_diagnostics_archives")?);
assert_eq!(current_schema_version(conn)?, 41);
assert_eq!(current_schema_version(conn)?, 42);
Ok(())
})
.unwrap();
@@ -7775,7 +8027,7 @@ mod tests {
),
]
);
assert_eq!(current_schema_version(&conn).unwrap(), 41);
assert_eq!(current_schema_version(&conn).unwrap(), 42);
let foreign_key_error: Option<String> = conn
.query_row("PRAGMA foreign_key_check", [], |row| row.get(0))
.optional()
@@ -7904,7 +8156,7 @@ INSERT INTO worker_orphan_diagnostics (
apply_migrations(&conn).unwrap();
assert_eq!(current_schema_version(&conn).unwrap(), 41);
assert_eq!(current_schema_version(&conn).unwrap(), 42);
assert!(!table_exists(&conn, "worker_control_delegation_operations").unwrap());
let controller_worker_id: String = conn
.query_row(
@@ -8022,10 +8274,36 @@ INSERT INTO worker_orphan_diagnostics (
apply_migrations(&conn).unwrap();
assert_eq!(current_schema_version(&conn).unwrap(), 41);
assert_eq!(current_schema_version(&conn).unwrap(), 42);
assert!(table_exists(&conn, "worker_workdir_attachment_reservations").unwrap());
}
#[test]
fn schema_v42_initializes_existing_workspaces_with_explicit_english_memory_settings() {
let conn = Connection::open_in_memory().unwrap();
configure_sqlite(&conn).unwrap();
apply_migrations_through(&conn, 41).unwrap();
conn.execute(
"INSERT INTO workspaces (workspace_id, display_name, state, created_at, updated_at) \
VALUES ('workspace-existing', 'Existing', 'active', '1', '1')",
[],
)
.unwrap();
apply_migrations(&conn).unwrap();
assert_eq!(current_schema_version(&conn).unwrap(), 42);
let settings = conn
.query_row(
"SELECT settings_revision, language FROM workspace_memory_settings \
WHERE workspace_id = 'workspace-existing'",
[],
|row| Ok((row.get::<_, i64>(0)?, row.get::<_, String>(1)?)),
)
.unwrap();
assert_eq!(settings, (1, "English".to_string()));
}
#[test]
fn schema_v26_removes_legacy_backend_flow_runtime_tables() {
let conn = Connection::open_in_memory().unwrap();
@@ -8055,7 +8333,7 @@ CREATE TABLE flow_events (event_id TEXT PRIMARY KEY);
apply_migrations(&conn).unwrap();
assert_eq!(current_schema_version(&conn).unwrap(), 41);
assert_eq!(current_schema_version(&conn).unwrap(), 42);
assert!(table_exists(&conn, "flow_sources").unwrap());
assert!(table_exists(&conn, "flow_source_revisions").unwrap());
assert!(!table_exists(&conn, "flow_instances").unwrap());
@@ -8122,7 +8400,7 @@ INSERT INTO worker_workdir_attachment_reservations (
apply_migrations(&conn).unwrap();
assert_eq!(current_schema_version(&conn).unwrap(), 41);
assert_eq!(current_schema_version(&conn).unwrap(), 42);
let repositories_sql: String = conn
.query_row(
"SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'repositories'",
@@ -8300,7 +8578,7 @@ INSERT INTO workdir_registry (
let db = dir.path().join("control-plane.sqlite");
let store = SqliteWorkspaceStore::open(&db).unwrap();
assert_eq!(store.schema_version().await.unwrap(), 41);
assert_eq!(store.schema_version().await.unwrap(), 42);
assert!(
!store
.with_conn(|conn| table_exists(conn, "worker_workspace_credentials"))
@@ -8317,7 +8595,7 @@ INSERT INTO workdir_registry (
store.upsert_workspace(&record).await.unwrap();
let reopened = SqliteWorkspaceStore::open(&db).unwrap();
assert_eq!(reopened.schema_version().await.unwrap(), 41);
assert_eq!(reopened.schema_version().await.unwrap(), 42);
assert_eq!(
reopened.get_workspace("local-dev").await.unwrap(),
Some(record)
@@ -8386,22 +8664,50 @@ INSERT INTO workdir_registry (
.await
.unwrap();
let memory_settings = store.get_workspace_memory_settings("workspace-a").unwrap();
assert_eq!(memory_settings.settings_revision, 1);
assert_eq!(memory_settings.language, "English");
let reserved = store
.reserve_worker_create("workspace-a", "arcadia", "operation-1", "sha256:one")
.reserve_worker_create(
"workspace-a",
"arcadia",
"operation-1",
"sha256:one",
&memory_settings,
)
.unwrap();
assert_eq!(
reserved.as_uuid().get_version(),
reserved.worker_id.as_uuid().get_version(),
Some(uuid::Version::SortRand)
);
assert_eq!(reserved.memory_settings.settings_revision, 1);
assert_eq!(reserved.memory_settings.language, "English");
let updated_memory_settings = store
.update_workspace_memory_settings("workspace-a", 1, "ja")
.unwrap();
assert_eq!(updated_memory_settings.settings_revision, 2);
assert_eq!(updated_memory_settings.language, "Japanese");
assert_eq!(
store
.reserve_worker_create("workspace-a", "arcadia", "operation-1", "sha256:one")
.reserve_worker_create(
"workspace-a",
"arcadia",
"operation-1",
"sha256:one",
&updated_memory_settings,
)
.unwrap(),
reserved
);
assert!(
store
.reserve_worker_create("workspace-a", "arcadia", "operation-1", "sha256:different")
.reserve_worker_create(
"workspace-a",
"arcadia",
"operation-1",
"sha256:different",
&updated_memory_settings,
)
.is_err()
);
assert_eq!(
@@ -8409,7 +8715,7 @@ INSERT INTO workdir_registry (
.resource_key(
"workspace-a",
WorkspaceResourceKind::Worker,
&reserved.to_string()
&reserved.worker_id.to_string()
)
.unwrap()
.as_deref(),
@@ -8419,31 +8725,38 @@ INSERT INTO workdir_registry (
store
.resolve_resource_reference("workspace-a", WorkspaceResourceKind::Worker, "W-1")
.unwrap(),
Some(reserved.to_string())
Some(reserved.worker_id.to_string())
);
let second = store
.reserve_worker_create("workspace-a", "arcadia", "operation-2", "sha256:two")
.reserve_worker_create(
"workspace-a",
"arcadia",
"operation-2",
"sha256:two",
&updated_memory_settings,
)
.unwrap();
assert_eq!(second.memory_settings.settings_revision, 2);
assert_eq!(
store
.resource_key(
"workspace-a",
WorkspaceResourceKind::Worker,
&second.to_string()
&second.worker_id.to_string()
)
.unwrap()
.as_deref(),
Some("W-2")
);
store
.complete_worker_create_reservation("workspace-a", reserved)
.complete_worker_create_reservation("workspace-a", reserved.worker_id)
.unwrap();
let state: String = store
.with_conn(|conn| {
conn.query_row(
"SELECT state FROM worker_create_reservations \
WHERE workspace_id = 'workspace-a' AND worker_id = ?1",
[reserved.to_string()],
[reserved.worker_id.to_string()],
|row| row.get(0),
)
.map_err(Error::from)
@@ -8816,13 +9129,13 @@ INSERT INTO worker_registry (
configure_sqlite(&conn).unwrap();
apply_migrations(&conn).unwrap();
conn.execute(
"INSERT INTO __yoi_schema_migrations (version, name) VALUES (42, 'future')",
"INSERT INTO __yoi_schema_migrations (version, name) VALUES (43, 'future')",
[],
)
.unwrap();
let error = apply_migrations(&conn).unwrap_err().to_string();
assert!(error.contains("schema version 42 is newer"), "{error}");
assert!(error.contains("schema version 43 is newer"), "{error}");
assert!(error.contains("refusing to serve"), "{error}");
}
@@ -9043,7 +9356,7 @@ VALUES ('workspace-b', 'ticket-b', 'related', 'ticket-a', NULL, 'tester', '2026-
apply_migrations(&mut conn).unwrap();
assert_eq!(current_schema_version(&conn).unwrap(), 41);
assert_eq!(current_schema_version(&conn).unwrap(), 42);
let workspace_id: Option<String> = conn
.query_row(
"SELECT workspace_id FROM trusted_runtime_records WHERE runtime_id = 'runtime-a'",
@@ -9660,7 +9973,7 @@ WHERE workspace_id = 'workspace-a'
.unwrap();
let store = SqliteWorkspaceStore::from_connection(conn).unwrap();
assert_eq!(store.schema_version().await.unwrap(), 41);
assert_eq!(store.schema_version().await.unwrap(), 42);
store
.with_conn(|conn| {
@@ -9849,7 +10162,7 @@ CREATE TABLE ticket_assignment_operations (
#[tokio::test]
async fn repository_records_round_trip() {
let store = SqliteWorkspaceStore::in_memory().unwrap();
assert_eq!(store.schema_version().await.unwrap(), 41);
assert_eq!(store.schema_version().await.unwrap(), 42);
let workspace = WorkspaceRecord {
workspace_id: "local-dev".to_string(),
owner_account_id: None,
@@ -9915,7 +10228,7 @@ CREATE TABLE ticket_assignment_operations (
#[tokio::test]
async fn memory_authority_records_round_trip_and_close_staging() {
let store = SqliteWorkspaceStore::in_memory().unwrap();
assert_eq!(store.schema_version().await.unwrap(), 41);
assert_eq!(store.schema_version().await.unwrap(), 42);
let workspace = WorkspaceRecord {
workspace_id: "local-dev".to_string(),
owner_account_id: None,
@@ -10317,7 +10630,7 @@ CREATE TABLE ticket_assignment_operations (
#[tokio::test]
async fn account_and_login_records_round_trip() {
let store = SqliteWorkspaceStore::in_memory().unwrap();
assert_eq!(store.schema_version().await.unwrap(), 41);
assert_eq!(store.schema_version().await.unwrap(), 42);
let now = "2026-07-22T00:00:00Z".to_string();
let account = AccountRecord {
account_id: "acct-user-alice".to_string(),