Python
//! Immutable service definitions and durable management intents. Provider I/O is
//! performed by the controller only after the intent commits.
use crate::{
auth::{self, Action, Identity, Scope},
PostgresStore, SubmissionError,
};
use anyhow::{ensure, Result};
use openworker_runtime::{
environment::{Phase, Record, Sharing, Spec},
store::Session,
};
use postgres::Transaction;
use serde::{Deserialize, Serialize};
use serde_json::{json, Value};
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Profile {
pub id: String,
pub provider: String,
pub cpu: u16,
#[serde(rename = "memoryMB")]
pub memory_mb: u32,
pub sharing: Sharing,
#[serde(default)]
pub approval_mode: openworker_runtime::permissions::Mode,
#[serde(default)]
pub auto_skip_questions: bool,
/// Versioned operator-installed grant, never a credential or model input.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub git_access: Option<String>,
/// Trusted host-side repository broker, independent of sandbox CLI access.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub repository_access: Option<String>,
#[serde(default)]
pub allowed_principals: Vec<String>,
}
impl Profile {
pub fn validate(&self) -> Result<()> {
revision(&self.id)?;
for grant in self.git_access.iter().chain(self.repository_access.iter()) {
revision(grant)?;
}
ensure!(
self.provider == "openshell",
SubmissionError::InvalidRequest
);
ensure!(
(1..=16).contains(&self.cpu) && (256..=65536).contains(&self.memory_mb),
SubmissionError::InvalidRequest
);
principals(&self.allowed_principals)
}
pub fn delegated_grants(&self) -> openworker_runtime::team_definition::Grants {
let named = self
.git_access
.iter()
.map(|id| format!("git:{id}"))
.collect::<std::collections::BTreeSet<_>>();
openworker_runtime::team_definition::Grants {
files: Default::default(),
network: named.clone(),
credentials: named,
cpu: self.cpu,
memory_mb: self.memory_mb,
}
}
/// Different credential grants cannot be assumed to be permission subsets.
/// A child may retain this exact grant or choose a credential-free profile.
pub fn require_delegatable_from(&self, lead: &Self) -> Result<()> {
self.validate()?;
lead.validate()?;
ensure!(
self.cpu <= lead.cpu
&& self.memory_mb <= lead.memory_mb
&& self.approval_mode == lead.approval_mode
&& self.auto_skip_questions == lead.auto_skip_questions
&& (self.git_access.is_none() || self.git_access == lead.git_access)
&& (self.repository_access.is_none()
|| self.repository_access == lead.repository_access),
crate::auth::Error::Forbidden
);
Ok(())
}
}
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Release {
pub id: String,
pub instructions: String,
pub tools: Vec<String>,
pub runtime_profiles: Vec<String>,
#[serde(default)]
pub default_runtime_profile: Option<String>,
#[serde(default)]
pub allowed_principals: Vec<String>,
#[serde(default)]
pub default_model: Option<openworker_runtime::connections::Choice>,
#[serde(default)]
pub reviewer_model: Option<openworker_runtime::connections::Choice>,
#[serde(default)]
pub model_overrides: Vec<openworker_runtime::connections::Choice>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub limits: Option<openworker_runtime::budget::Limits>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub subagents: Option<openworker_runtime::subagents::Config>,
}
impl Release {
pub fn validate(&self) -> Result<()> {
revision(&self.id)?;
if let Some(config) = &self.subagents {
config.validate()?;
}
if let Some(l) = &self.limits {
l.validate()?;
}
ensure!(
!self.instructions.trim().is_empty()
&& self.instructions.len() <= 32000
&& (!self.tools.is_empty() || self.subagents.as_ref().is_some_and(|c| c.enabled))
&& self.tools.len() <= 64
&& !self.runtime_profiles.is_empty()
&& self.runtime_profiles.len() <= 16
&& self
.default_runtime_profile
.as_ref()
.is_none_or(|p| self.runtime_profiles.contains(p)),
SubmissionError::InvalidRequest
);
for id in &self.runtime_profiles {
revision(id)?;
}
for model in self
.default_model
.iter()
.chain(self.reviewer_model.iter())
.chain(&self.model_overrides)
{
model.validate()?;
}
ensure!(
self.model_overrides.len() <= 32,
SubmissionError::InvalidRequest
);
principals(&self.allowed_principals)
}
}
fn principals(p: &[String]) -> Result<()> {
ensure!(p.len() <= 100, SubmissionError::InvalidRequest);
for s in p {
crate::submissions::validate_id(s, 128)?;
}
Ok(())
}
fn revision(s: &str) -> Result<()> {
name(s)?;
let (id, version) = s.split_once('@').ok_or(SubmissionError::InvalidRequest)?;
ensure!(
!id.is_empty() && !version.is_empty() && !version.contains('@'),
SubmissionError::InvalidRequest
);
Ok(())
}
pub fn name(s: &str) -> Result<()> {
ensure!(
!s.is_empty()
&& s.len() <= 80
&& s.bytes()
.all(|b| b.is_ascii_alphanumeric() || b"_-@.".contains(&b))
&& s != "."
&& s != "..",
SubmissionError::InvalidRequest
);
Ok(())
}
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Entry {
pub id: String,
pub kind: String,
pub digest: String,
pub definition: Value,
pub installation: String,
pub activated: bool,
}
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Admission {
pub agent: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub initial_message: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub limits: Option<openworker_runtime::budget::Limits>,
#[serde(default)]
pub model: Option<openworker_runtime::connections::Choice>,
#[serde(default)]
pub runtime_profile: Option<String>,
#[serde(default)]
pub environment_id: Option<String>,
#[serde(default = "default_project")]
pub project: String,
#[serde(default)]
pub name: Option<String>,
}
fn default_project() -> String {
"default".into()
}
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Operation {
pub id: String,
#[serde(default)]
pub run_id: Option<String>,
#[serde(default)]
pub submission_id: Option<String>,
pub session_id: String,
pub environment_id: String,
pub release_id: String,
pub profile_id: String,
pub principal: String,
pub project: String,
pub status: String,
pub receipt: Option<Value>,
pub error: Option<String>,
}
fn op(row: &postgres::Row) -> Operation {
let id: String = row.get("id");
let task = row.get::<_, Value>("input")["initialMessage"].is_string();
Operation {
run_id: task.then(|| format!("t_{}", id.trim_start_matches("op_"))),
submission_id: task.then(|| id.clone()),
id,
session_id: row.get("session_id"),
environment_id: row.get("environment_id"),
release_id: row.get("release_id"),
profile_id: row.get("profile_id"),
principal: row.get("principal"),
project: row.get("project"),
status: row.get("status"),
receipt: row.get("receipt"),
error: row.get("error"),
}
}
pub(crate) fn entry(tx: &mut Transaction<'_>, kind: &str, id: &str) -> Result<Entry> {
let r = tx
.query_opt(
"SELECT data,activated FROM service_catalog WHERE kind=$1 AND id=$2 FOR SHARE",
&[&kind, &id],
)?
.ok_or(SubmissionError::NotFound)?;
let mut e: Entry = serde_json::from_value(r.get(0))?;
e.activated = r.get(1);
Ok(e)
}
pub(crate) fn allowed(p: &Identity, list: &[String]) -> Result<()> {
ensure!(
p.role.permits(Action::Admin) || list.contains(&p.principal),
auth::Error::Forbidden
);
Ok(())
}
fn resolve(tx: &mut Transaction<'_>, kind: &str, id: &str) -> Result<Entry> {
let resolved: Option<String> = tx
.query_opt(
"SELECT target FROM service_aliases WHERE kind=$1 AND alias=$2",
&[&kind, &id],
)?
.map(|r| r.get(0));
entry(tx, kind, resolved.as_deref().unwrap_or(id))
}
pub(crate) fn migrate(tx: &mut Transaction<'_>) -> Result<()> {
crate::service_admin::migrate(tx)?;
tx.batch_execute("CREATE TABLE IF NOT EXISTS service_catalog(kind TEXT NOT NULL,id TEXT NOT NULL,data JSONB NOT NULL,activated BOOLEAN NOT NULL DEFAULT FALSE,PRIMARY KEY(kind,id));
CREATE TABLE IF NOT EXISTS service_aliases(kind TEXT NOT NULL,alias TEXT NOT NULL,target TEXT NOT NULL,PRIMARY KEY(kind,alias));
CREATE TABLE IF NOT EXISTS service_management_receipts(id TEXT PRIMARY KEY,payload JSONB NOT NULL,result JSONB NOT NULL);
CREATE TABLE IF NOT EXISTS service_environment_owners(environment_id TEXT PRIMARY KEY REFERENCES environments(id),profile_id TEXT NOT NULL,principal TEXT NOT NULL,project TEXT NOT NULL);
CREATE TABLE IF NOT EXISTS service_deletions(environment_id TEXT PRIMARY KEY REFERENCES environments(id),request_key TEXT NOT NULL,dispatched BOOLEAN NOT NULL DEFAULT FALSE,next_check TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp());
CREATE TABLE IF NOT EXISTS service_operations(id TEXT PRIMARY KEY,request_key TEXT NOT NULL UNIQUE,input JSONB NOT NULL,principal TEXT NOT NULL,credential_id TEXT NOT NULL,release_id TEXT NOT NULL,profile_id TEXT NOT NULL,environment_id TEXT NOT NULL REFERENCES environments(id),session_id TEXT NOT NULL UNIQUE,project TEXT NOT NULL,status TEXT NOT NULL,receipt JSONB,error TEXT,next_check TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp());")?;
tx.batch_execute(
"ALTER TABLE service_operations ADD COLUMN IF NOT EXISTS configuration JSONB",
)?;
tx.execute(
"UPDATE service_operations SET configuration=$1 WHERE configuration IS NULL",
&[&json!(crate::service_admin::Revision {
revision: 1,
configuration: Default::default()
})],
)?;
tx.batch_execute("ALTER TABLE service_operations ALTER COLUMN configuration SET NOT NULL")?;
Ok(())
}
impl PostgresStore {
pub fn catalog_put(
&self,
request: &str,
kind: &str,
definition: Value,
installation: &str,
) -> Result<Entry> {
ensure!(
matches!(kind, "profile" | "release"),
SubmissionError::InvalidRequest
);
let id = definition["id"]
.as_str()
.ok_or(SubmissionError::InvalidRequest)?
.to_owned();
name(&id)?;
if kind == "profile" {
serde_json::from_value::<Profile>(definition.clone())?.validate()?;
} else {
serde_json::from_value::<Release>(definition.clone())?.validate()?;
}
let (request, kind, installation) =
(request.to_owned(), kind.to_owned(), installation.to_owned());
self.call(move |db| db.catalog_put(request, kind, id, definition, installation))
}
pub fn catalog_activate(
&self,
request: &str,
kind: &str,
id: &str,
alias: Option<String>,
) -> Result<Entry> {
name(id)?;
if let Some(a) = &alias {
name(a)?;
ensure!(!a.contains('@'), SubmissionError::InvalidRequest);
}
let (request, kind, id) = (request.to_owned(), kind.to_owned(), id.to_owned());
self.call(move |db| db.catalog_activate(request, kind, id, alias))
}
pub fn catalog_get(&self, kind: &str, id: &str) -> Result<Entry> {
let (kind, id) = (kind.to_owned(), id.to_owned());
self.call(move |db| {
let mut tx = db.client.transaction()?;
let p = auth::guard(&mut tx, db.auth.as_ref(), Action::Read, None, None)?;
let e = resolve(&mut tx, &kind, &id)?;
if let Some(p) = p {
let principals: Vec<String> =
serde_json::from_value(e.definition["allowedPrincipals"].clone())
.unwrap_or_default();
// Deployment authority can inspect definitions to validate references;
// execution admission still enforces the principal allowlist separately.
let manages = p.role.permits(Action::Publish)
|| p.role.permits(Action::Activate)
|| p.role.permits(Action::Configure)
|| p.role.permits(Action::Admin);
if !manages {
allowed(&p, &principals)?;
}
ensure!(
e.activated
|| p.role.permits(Action::Publish)
|| p.role.permits(Action::Activate)
|| p.role.permits(Action::Admin),
auth::Error::Forbidden
);
}
tx.commit()?;
Ok(e)
})
}
/// Bounded public catalog projection. Never expose drafts or principal-restricted
/// definitions to callers who could not read the same entry individually.
pub fn catalog_visible(&self, kind: &str) -> Result<Vec<Entry>> {
ensure!(
matches!(kind, "profile" | "release"),
SubmissionError::InvalidRequest
);
let kind = kind.to_owned();
self.call(move |db| {
let mut tx = db.client.transaction()?;
let p = auth::guard(&mut tx, db.auth.as_ref(), Action::Read, None, None)?;
let mut out = vec![];
// Catalog insertion already enforces a 64-entry bound per kind.
for row in tx.query(
"SELECT data,activated FROM service_catalog WHERE kind=$1 ORDER BY id LIMIT 64",
&[&kind],
)? {
let mut e: Entry = serde_json::from_value(row.get(0))?;
e.activated = row.get(1);
if let Some(p) = &p {
let manages = p.role.permits(Action::Publish)
|| p.role.permits(Action::Activate)
|| p.role.permits(Action::Configure)
|| p.role.permits(Action::Admin);
let principals: Vec<String> =
serde_json::from_value(e.definition["allowedPrincipals"].clone())
.unwrap_or_default();
if !manages && allowed(p, &principals).is_err() {
continue;
}
if !(e.activated
|| p.role.permits(Action::Publish)
|| p.role.permits(Action::Activate)
|| p.role.permits(Action::Admin))
{
continue;
}
}
out.push(e);
}
tx.commit()?;
Ok(out)
})
}
pub fn catalog_list(&self) -> Result<Vec<Entry>> {
self.call(move |db| {
let mut tx = db.client.transaction()?;
auth::guard(&mut tx, db.auth.as_ref(), Action::Admin, None, None)?;
let mut out = vec![];
for r in tx.query(
"SELECT data,activated FROM service_catalog ORDER BY kind,id",
&[],
)? {
let mut e: Entry = serde_json::from_value(r.get(0))?;
e.activated = r.get(1);
out.push(e);
}
tx.commit()?;
Ok(out)
})
}
pub fn service_admit(
&self,
key: &str,
input: Admission,
release: Entry,
profile: Entry,
spec: Spec,
) -> Result<Operation> {
name(&input.project)?;
ensure!(
!(input.runtime_profile.is_some() && input.environment_id.is_some()),
SubmissionError::InvalidRequest
);
spec.validate()?;
ensure!(
input.limits.is_none() || input.initial_message.is_some(),
SubmissionError::InvalidRequest
);
if let Some(l) = &input.limits {
l.validate().map_err(|_| SubmissionError::InvalidRequest)?;
}
if let Some(text) = &input.initial_message {
crate::submissions::validate_id(text, 32000)?;
}
let key = key.to_owned();
self.call(move |db| db.service_admit(key, input, release, profile, spec))
}
pub fn service_session_identity(&self, sid: &str) -> Result<Option<Value>> {
let sid = sid.to_owned();
self.call(move |db| db.service_session_identity(sid))
}
pub fn service_operation(&self, id: &str) -> Result<Operation> {
let id = id.to_owned();
self.call(move |db| {
let mut tx = db.client.transaction()?;
let p = auth::guard(&mut tx, db.auth.as_ref(), Action::Read, None, None)?;
let r = tx
.query_opt("SELECT * FROM service_operations WHERE id=$1", &[&id])?
.ok_or(SubmissionError::NotFound)?;
let o = op(&r);
if let Some(p) = p {
ensure!(
p.principal == o.principal || p.role.permits(Action::Admin),
auth::Error::Forbidden
);
}
tx.commit()?;
Ok(o)
})
}
pub fn service_environment(&self, id: &str) -> Result<Value> {
let id = id.to_owned();
self.call(move |db| db.service_environment(id))
}
/// Resume-safe enqueue: begin_environment_delete already fenced attachments.
pub fn service_queue_delete(&self, id: &str, key: &str) -> Result<()> {
let (id, key) = (id.to_owned(), key.to_owned());
self.call(move|db| {let mut tx=db.client.transaction()?;
auth::guard(&mut tx,db.auth.as_ref(),auth::Action::Admin,None,None)?;
let recorded:Option<String>=tx.query_one("SELECT delete_request_id FROM environments WHERE id=$1",&[&id])?.get(0);
ensure!(recorded.as_deref()==Some(&key),"Deletion identity mismatch");
tx.execute("INSERT INTO service_deletions(environment_id,request_key) VALUES($1,$2) ON CONFLICT DO NOTHING",&[&id,&key])?;tx.commit()?;Ok(())})
}
/// One dispatch authorization. Later claims only inspect the original remote object.
pub fn service_claim_delete(
&self,
installed: &str,
) -> Result<
Option<(
openworker_runtime::environment::Record,
String,
String,
bool,
)>,
> {
ensure!(self.auth.is_none(), "Controller requires private store");
let installed = installed.to_owned();
self.call(move|db|{let mut tx=db.client.transaction()?;
let row=tx.query_opt("SELECT d.environment_id,d.request_key,d.dispatched,o.profile_id,e.data FROM service_deletions d JOIN environments e ON e.id=d.environment_id JOIN service_environment_owners o ON o.environment_id=d.environment_id WHERE e.data->>'phase'='deleting' AND d.next_check<=clock_timestamp() AND (EXISTS(SELECT 1 FROM service_operations a JOIN service_catalog c ON c.kind='release' AND c.id=a.release_id WHERE a.environment_id=d.environment_id AND c.data->>'installation'=$1) OR EXISTS(SELECT 1 FROM service_team_environments a JOIN service_catalog c ON c.kind='release' AND c.id=a.data->>'source_release' WHERE a.environment_id=d.environment_id AND c.data->>'installation'=$1)) ORDER BY d.next_check,d.environment_id LIMIT 1 FOR UPDATE OF d SKIP LOCKED",&[&installed])?;
let Some(row)=row else {return Ok(None)};
let id:String=row.get(0);let key:String=row.get(1);let dispatched:bool=row.get(2);let profile:String=row.get(3);let record=serde_json::from_value(row.get(4))?;
tx.execute("UPDATE service_deletions SET dispatched=TRUE,next_check=clock_timestamp()+interval '180 seconds' WHERE environment_id=$1",&[&id])?;
tx.commit()?;Ok(Some((record,key,profile,!dispatched)))})
}
pub fn service_recheck_delete(&self, id: &str) -> Result<()> {
ensure!(self.auth.is_none(), "Controller requires private store");
let id = id.to_owned();
self.call(move|db|{db.client.execute("UPDATE service_deletions SET next_check=clock_timestamp()+interval '2 seconds' WHERE environment_id=$1",&[&id])?;Ok(())})
}
/// Controller-only claim: a reclaimed dispatch only reconciles, never creates again.
pub fn service_claim(&self) -> Result<Option<(Operation, bool)>> {
ensure!(self.auth.is_none(), auth::Error::Forbidden);
self.service_claim_for(None)
}
pub fn service_claim_for(
&self,
installation: Option<&str>,
) -> Result<Option<(Operation, bool)>> {
ensure!(self.auth.is_none(), auth::Error::Forbidden);
let installation = installation.map(String::from);
self.call(move |db| db.service_claim(installation))
}
pub fn service_update_operation(
&self,
id: &str,
status: &str,
error: Option<String>,
) -> Result<()> {
ensure!(self.auth.is_none(), auth::Error::Forbidden);
ensure!(
matches!(status, "unknown" | "ready" | "failed"),
SubmissionError::InvalidRequest
);
let (id, status) = (id.to_owned(), status.to_owned());
self.call(move |db| {
db.client.execute("UPDATE service_operations SET status=$2,error=$3,next_check=clock_timestamp()+interval '2 seconds' WHERE id=$1 AND status<>'complete'",&[&id,&status,&error])?;
Ok(())}
)
}
pub fn service_input(&self, id: &str) -> Result<Admission> {
ensure!(self.auth.is_none(), auth::Error::Forbidden);
let id = id.to_owned();
self.call(move |db| {
Ok(serde_json::from_value(
db.client
.query_one("SELECT input FROM service_operations WHERE id=$1", &[&id])?
.get(0),
)?)
})
}
pub fn service_finish(
&self,
id: &str,
session: Session,
service_id: &str,
namespace: &str,
) -> Result<()> {
ensure!(self.auth.is_none(), auth::Error::Forbidden);
let (id, service_id, namespace) =
(id.to_owned(), service_id.to_owned(), namespace.to_owned());
self.call(move |db| db.service_finish(id, session, service_id, namespace))
}
}
impl crate::db::Database {
fn catalog_put(
&mut self,
request: String,
kind: String,
id: String,
definition: Value,
installation: String,
) -> Result<Entry> {
let mut tx = self.client.transaction()?;
let action = if kind == "release" {
Action::Publish
} else {
Action::Configure
};
let p = auth::guard(&mut tx, self.auth.as_ref(), action, None, None)?;
tx.query_one(
"SELECT pg_advisory_xact_lock(hashtext(current_schema()),hashtext('service-catalog'))",
&[],
)?;
let digest = openworker_runtime::bundle::digest(&serde_json::to_vec(&json!([
&definition,
&installation
]))?);
let e = Entry {
id: id.clone(),
kind: kind.clone(),
digest,
definition,
installation,
activated: false,
};
let payload = json!({
"put":e}
);
if let Some(r) = tx.query_opt(
"SELECT payload,result FROM service_management_receipts WHERE id=$1",
&[&request],
)? {
ensure!(r.get::<_, Value>(0) == payload, SubmissionError::Conflict);
return Ok(serde_json::from_value(r.get(1))?);
}
if let Some(r) = tx.query_opt(
"SELECT data FROM service_catalog WHERE kind=$1 AND id=$2",
&[&kind, &id],
)? {
let old: Entry = serde_json::from_value(r.get(0))?;
ensure!(old.digest == e.digest, SubmissionError::Conflict);
}
let count: i64 = tx
.query_one("SELECT count(*) FROM service_catalog", &[])?
.get(0);
ensure!(count < 64, SubmissionError::QueueFull);
tx.execute(
"INSERT INTO service_catalog(kind,id,data) VALUES($1,$2,$3) ON CONFLICT DO NOTHING",
&[&kind, &id, &json!(e)],
)?;
tx.execute(
"INSERT INTO service_management_receipts VALUES($1,$2,$3)",
&[&request, &payload, &json!(e)],
)?;
auth::audit_target(&mut tx, p.as_ref(), action, &request, &e.id)?;
tx.commit()?;
Ok(e)
}
fn catalog_activate(
&mut self,
request: String,
kind: String,
id: String,
alias: Option<String>,
) -> Result<Entry> {
let mut tx = self.client.transaction()?;
let action = if kind == "release" {
Action::Activate
} else {
Action::Configure
};
let p = auth::guard(&mut tx, self.auth.as_ref(), action, None, None)?;
tx.query_one(
"SELECT pg_advisory_xact_lock(hashtext(current_schema()),hashtext('service-catalog'))",
&[],
)?;
let payload = json!({
"activate":id,"kind":kind,"alias":alias}
);
if let Some(r) = tx.query_opt(
"SELECT payload,result FROM service_management_receipts WHERE id=$1",
&[&request],
)? {
ensure!(r.get::<_, Value>(0) == payload, SubmissionError::Conflict);
return Ok(serde_json::from_value(r.get(1))?);
}
let mut e = entry(&mut tx, &kind, &id)?;
e.activated = true;
if kind == "release" {
let r: Release = serde_json::from_value(e.definition.clone())?;
for profile in r.runtime_profiles {
let profile = entry(&mut tx, "profile", &profile)?;
ensure!(
profile.activated && profile.installation == e.installation,
SubmissionError::InvalidRequest
);
}
}
tx.execute(
"UPDATE service_catalog SET activated=TRUE WHERE kind=$1 AND id=$2",
&[&kind, &id],
)?;
if let Some(alias) = alias {
ensure!(
tx.query_opt(
"SELECT 1 FROM service_catalog WHERE kind=$1 AND id=$2",
&[&kind, &alias]
)?
.is_none(),
SubmissionError::Conflict
);
tx.execute("INSERT INTO service_aliases VALUES($1,$2,$3) ON CONFLICT(kind,alias) DO UPDATE SET target=EXCLUDED.target",&[&kind,&alias,&id])?;
}
tx.execute(
"INSERT INTO service_management_receipts VALUES($1,$2,$3)",
&[&request, &payload, &json!(e)],
)?;
auth::audit_target(&mut tx, p.as_ref(), action, &request, &e.id)?;
tx.commit()?;
Ok(e)
}
fn service_admit(
&mut self,
key: String,
input: Admission,
release: Entry,
profile: Entry,
spec: Spec,
) -> Result<Operation> {
let mut tx = self.client.transaction()?;
let p = auth::guard(&mut tx, self.auth.as_ref(), Action::Submit, None, None)?
.ok_or(auth::Error::Unauthorized)?;
ensure!(
!matches!(p.scope, Scope::Sessions { .. }),
auth::Error::Forbidden
);
tx.query_one(
"SELECT pg_advisory_xact_lock(hashtext(current_schema()),hashtext($1))",
&[&format!("service-admit:{key}")],
)?;
if let Some(row) = tx.query_opt(
"SELECT * FROM service_operations WHERE request_key=$1",
&[&key],
)? {
ensure!(
row.get::<_, Value>("input") == json!(input)
&& row.get::<_, String>("principal") == p.principal,
SubmissionError::Conflict
);
let o = op(&row);
tx.commit()?;
return Ok(o);
}
let configured = crate::service_admin::current(&mut tx)?;
ensure!(
!configured.configuration.admissions_paused,
SubmissionError::Busy
);
let r = entry(&mut tx, "release", &release.id)?;
let f = entry(&mut tx, "profile", &profile.id)?;
ensure!(
r.digest == release.digest && f.digest == profile.digest && r.activated && f.activated,
SubmissionError::Conflict
);
let rel: Release = serde_json::from_value(r.definition)?;
let prof: Profile = serde_json::from_value(f.definition)?;
allowed(&p, &rel.allowed_principals)?;
allowed(&p, &prof.allowed_principals)?;
ensure!(
rel.runtime_profiles.contains(&prof.id),
auth::Error::Forbidden
);
if let Some(model) = &input.model {
ensure!(
rel.model_overrides.contains(model) || rel.default_model.as_ref() == Some(model),
auth::Error::Forbidden
);
}
ensure!(
prof.approval_mode != openworker_runtime::permissions::Mode::AutoApprove
|| rel.reviewer_model.is_some(),
SubmissionError::InvalidRequest
);
tx.query_one("SELECT pg_advisory_xact_lock(hashtext(current_schema()),hashtext('service-environment-quota'))",&[])?;
let pending: i64 = tx
.query_one(
"SELECT (SELECT count(*) FROM service_operations WHERE status NOT IN ('complete','failed'))+(SELECT count(*) FROM service_team_environments WHERE status NOT IN ('ready','failed'))",
&[],
)?
.get(0);
ensure!(
pending < configured.configuration.max_pending_operations,
SubmissionError::QueueFull
);
if input.environment_id.is_none() {
let owned:i64=tx.query_one("SELECT count(*) FROM service_environment_owners o JOIN environments e ON e.id=o.environment_id WHERE o.principal=$1 AND e.data->>'phase'<>'deleted'",&[&p.principal])?.get(0);
let total:i64=tx.query_one("SELECT count(*) FROM service_environment_owners o JOIN environments e ON e.id=o.environment_id WHERE e.data->>'phase'<>'deleted'",&[])?.get(0);
ensure!(
owned < configured.configuration.max_environments_per_principal
&& total < configured.configuration.max_environments,
SubmissionError::QueueFull
);
}
let operation_id = openworker_runtime::id("op");
let session_id = openworker_runtime::id("s");
let (environment_id, status) = if let Some(eid) = &input.environment_id {
let owner=tx.query_opt("SELECT profile_id,principal,project FROM service_environment_owners WHERE environment_id=$1",&[eid])?.ok_or(auth::Error::Forbidden)?;
ensure!(
(p.role.permits(Action::Admin) || owner.get::<_, String>(1) == p.principal)
&& owner.get::<_, String>(2) == input.project
&& owner.get::<_, String>(0) == prof.id,
auth::Error::Forbidden
);
let row = tx
.query_opt(
"SELECT data FROM environments WHERE id=$1 FOR UPDATE",
&[eid],
)?
.ok_or(SubmissionError::NotFound)?;
let record: Record = serde_json::from_value(row.get(0))?;
ensure!(
record.phase == Phase::Ready && record.spec == spec,
SubmissionError::Conflict
);
ensure!(
record.spec.sharing == Sharing::Shared,
SubmissionError::Conflict
);
(eid.clone(), "ready")
} else {
let record = Record {
id: openworker_runtime::id("env"),
request_id: operation_id.clone(),
actor: p.principal.clone(),
spec,
phase: Phase::Provisioning,
binding: None,
revision: 1,
};
tx.execute(
"INSERT INTO environments(id,request_id,data) VALUES($1,$2,$3)",
&[&record.id, &record.request_id, &json!(record)],
)?;
tx.execute("INSERT INTO environment_events(environment_id,revision,kind,data) VALUES($1,1,'environment_requested',$2)",&[&record.id,&json!({
"operationId":operation_id,"actor":p.principal}
)])?;
tx.execute(
"INSERT INTO service_environment_owners VALUES($1,$2,$3,$4)",
&[&record.id, &prof.id, &p.principal, &input.project],
)?;
(record.id, "queued")
};
let row=tx.query_one("INSERT INTO service_operations(id,request_key,input,principal,credential_id,release_id,profile_id,environment_id,session_id,project,status,configuration) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12) RETURNING *",&[&operation_id,&key,&json!(input),&p.principal,&p.credential_id,&rel.id,&prof.id,&environment_id,&session_id,&input.project,&status,&json!(configured)])?;
auth::audit(&mut tx, Some(&p), Action::Create, None, Some(&key))?;
let result = op(&row);
tx.commit()?;
Ok(result)
}
fn service_environment(&mut self, id: String) -> Result<Value> {
let mut tx = self.client.transaction()?;
let p = auth::guard(&mut tx, self.auth.as_ref(), Action::Read, None, None)?;
let r=tx.query_opt("SELECT profile_id,principal,project FROM service_environment_owners WHERE environment_id=$1",&[&id])?.ok_or(SubmissionError::NotFound)?;
let owner: String = r.get(1);
if let Some(p) = p {
ensure!(
p.principal == owner || p.role.permits(Action::Admin),
auth::Error::Forbidden
);
}
let e = tx
.query_one("SELECT data FROM environments WHERE id=$1", &[&id])?
.get::<_, Value>(0);
let attachments:Vec<Value>=tx.query("SELECT session_id,state FROM attachments WHERE environment_id=$1 AND state<>'released'",&[&id])?.into_iter().map(|r|json!({
"sessionId":r.get::<_,String>(0),"state":r.get::<_,String>(1)}
)).collect();
tx.commit()?;
Ok(json!({
"id":id,"runtimeProfile":r.get::<_,String>(0),"principal":owner,"project":r.get::<_,String>(2),"environment":e,"attachments":attachments}
))
}
fn service_claim(&mut self, installation: Option<String>) -> Result<Option<(Operation, bool)>> {
let mut tx = self.client.transaction()?;
let row=tx.query_opt("SELECT * FROM service_operations WHERE status IN ('queued','dispatching','unknown','ready') AND next_check<=clock_timestamp() AND ($1::text IS NULL OR EXISTS(SELECT 1 FROM service_catalog c WHERE c.kind='release' AND c.id=service_operations.release_id AND c.data->>'installation'=$1)) ORDER BY next_check,id LIMIT 1 FOR UPDATE SKIP LOCKED",&[&installation])?;
let Some(r) = row else { return Ok(None) };
let mut o = op(&r);
let create = o.status == "queued";
if create {
o.status = "dispatching".into();
}
tx.execute("UPDATE service_operations SET status=$2,next_check=clock_timestamp()+interval '180 seconds' WHERE id=$1",&[&o.id,&o.status])?;
tx.commit()?;
Ok(Some((o, create)))
}
fn service_session_identity(&mut self, sid: String) -> Result<Option<Value>> {
let mut tx = self.client.transaction()?;
auth::guard(&mut tx, self.auth.as_ref(), Action::Read, Some(&sid), None)?;
let mut result=tx.query_opt("SELECT release_id,profile_id,project,id,configuration FROM service_operations WHERE session_id=$1 AND status='complete'",&[&sid])?.map(|r|json!({"releaseId":r.get::<_,String>(0),"runtimeProfile":r.get::<_,String>(1),"project":r.get::<_,String>(2),"operationId":r.get::<_,String>(3),"configuration":r.get::<_,Value>(4)}));
if result.is_none() {
// Delegated sessions have a durable creation receipt rather than a
// top-level admission operation. Use its ORIGINAL source release,
// exact roster membership and environment owner, never the legacy
// service agent or a newly resolved mutable type name.
result=tx.query_opt("SELECT cr.parameters->>'release',env.profile_id,o.project,o.id,t.id,cr.parameters->>'instance' FROM creations cr JOIN sessions s ON s.id=cr.session_id JOIN agent_teams t ON t.id=cr.parameters->>'team' JOIN service_operations o ON o.session_id=t.data->'roster'->'instances'->(t.data->>'lead')->>'session_id' AND o.status='complete' JOIN service_environment_owners env ON env.environment_id=s.environment_id WHERE s.id=$1 AND cr.parameters->>'release' IS NOT NULL AND t.data->'roster'->'instances'->(cr.parameters->>'instance')->>'session_id'=s.id AND s.data->'agent_team'->>'team_id'=t.id AND s.data->'agent_team'->>'agent_id'=cr.parameters->>'instance'",&[&sid])?.map(|r|json!({"releaseId":r.get::<_,String>(0),"runtimeProfile":r.get::<_,String>(1),"project":r.get::<_,String>(2),"operationId":r.get::<_,String>(3),"teamId":r.get::<_,String>(4),"agentId":r.get::<_,String>(5),"configuration":Value::Null}));
}
tx.commit()?;
Ok(result)
}
fn service_finish(
&mut self,
id: String,
mut session: Session,
service_id: String,
namespace: String,
) -> Result<()> {
let mut tx = self.client.transaction()?;
let row = tx.query_one(
"SELECT * FROM service_operations WHERE id=$1 FOR UPDATE",
&[&id],
)?;
let o = op(&row);
if o.status == "complete" {
return Ok(());
}
ensure!(o.status == "ready", SubmissionError::Conflict);
let credential: String = row.get("credential_id");
let cred = tx
.query_opt(
"SELECT spec FROM api_credentials WHERE id=$1 AND NOT revoked AND ((spec->>'expires_at') IS NULL OR (spec->>'expires_at')::bigint>extract(epoch FROM clock_timestamp())) FOR SHARE",
&[&credential],
)?
.ok_or(auth::Error::Unauthorized)?;
let spec: auth::Spec = serde_json::from_value(cred.get(0))?;
let p = Identity {
credential_id: credential,
principal: spec.principal,
role: spec.role,
scope: spec.scope,
environments: spec.environments,
expires_at: spec.expires_at,
};
ensure!(
p.principal == o.principal && p.role.permits(Action::Submit),
auth::Error::Forbidden
);
let rel: Release =
serde_json::from_value(entry(&mut tx, "release", &o.release_id)?.definition)?;
let profile: Profile =
serde_json::from_value(entry(&mut tx, "profile", &o.profile_id)?.definition)?;
allowed(&p, &rel.allowed_principals)?;
allowed(&p, &profile.allowed_principals)?;
session.id = o.session_id.clone();
let input: Admission = serde_json::from_value(row.get("input"))?;
let req = crate::SessionCreation {
request_id: o.id.clone(),
actor: o.principal.clone(),
parameters: json!({
"serviceOperation":o.id,"environment_id":o.environment_id,"input":input}
),
};
crate::ingress::create_in_tx(&mut tx, &self.owner, req, session, Some(p.clone()))?;
// The session, first task and completed operation receipt commit together.
// No worker can observe an idle half-submission or execute a second copy.
if let Some(text) = input.initial_message {
let request = crate::TurnSubmission {
session_id: o.session_id.clone(),
submission_id: o.submission_id.clone().expect("initial task identity"),
text,
limits: input.limits.clone(),
};
let receipt = crate::submissions::insert_reserved(
&mut tx,
&request,
"queued",
None,
o.run_id.as_deref().expect("initial run identity"),
)?;
crate::submissions::journal_acceptance(&mut tx, &receipt, Some(&p.principal))?;
auth::audit(
&mut tx,
Some(&p),
Action::Submit,
Some(&o.session_id),
Some(&request.submission_id),
)?;
}
let receipt = json!({
"serviceId":service_id,"namespace":namespace,"sessionId":o.session_id,"agent":o.release_id,"releaseId":o.release_id,"runtimeProfile":o.profile_id,"environmentId":o.environment_id,"operationId":o.id,"runId":o.run_id,"submissionId":o.submission_id}
);
tx.execute(
"UPDATE service_operations SET status='complete',receipt=$2,error=NULL WHERE id=$1",
&[&id, &receipt],
)?;
tx.commit()?;
Ok(())
}
}