Python
use crate::db::{locked, Database};
use anyhow::{ensure, Result};
use openworker_artifacts::{Artifact, Binding, Error, Proof, Registration, Status};
use postgres::Transaction;
use serde_json::{json, Value};
pub(crate) fn migrate(tx: &mut Transaction<'_>) -> Result<()> {
let exists: bool = tx
.query_one("SELECT to_regclass('artifact_version') IS NOT NULL", &[])?
.get(0);
if exists {
check(tx)?;
} else {
for table in ["artifacts", "artifact_requests", "artifact_totals"] {
let exists: bool = tx
.query_one("SELECT to_regclass($1) IS NOT NULL", &[&table])?
.get(0);
ensure!(!exists, Error::Conflict);
}
tx.batch_execute("CREATE TABLE artifact_version(singleton BOOLEAN PRIMARY KEY CHECK(singleton),version INTEGER NOT NULL);INSERT INTO artifact_version VALUES(TRUE,1);
CREATE TABLE artifact_totals(session_id TEXT PRIMARY KEY REFERENCES sessions(id),total BIGINT NOT NULL);
CREATE TABLE artifacts(id TEXT PRIMARY KEY,session_id TEXT NOT NULL REFERENCES sessions(id),data JSONB NOT NULL,UNIQUE(session_id,id));
CREATE TABLE artifact_requests(session_id TEXT NOT NULL,request_id TEXT NOT NULL,artifact_id TEXT NOT NULL UNIQUE,actor TEXT NOT NULL,request JSONB NOT NULL,binding JSONB NOT NULL,PRIMARY KEY(session_id,request_id),FOREIGN KEY(session_id,artifact_id) REFERENCES artifacts(session_id,id));")?;
}
Ok(())
}
fn check(tx: &mut Transaction<'_>) -> Result<()> {
let exists: bool = tx
.query_one("SELECT to_regclass('artifact_version') IS NOT NULL", &[])?
.get(0);
ensure!(exists, Error::Unconfigured);
let rows = tx.query("SELECT version FROM artifact_version WHERE singleton", &[])?;
ensure!(
rows.len() == 1 && rows[0].get::<_, i32>(0) == 1,
Error::Conflict
);
Ok(())
}
fn verify(tx: &mut Transaction<'_>, sid: &str) -> Result<()> {
check(tx)?;
let row=tx.query_one("SELECT (SELECT count(*) FROM artifacts WHERE session_id=$1),(SELECT count(*) FROM artifact_requests WHERE session_id=$1),(SELECT total FROM artifact_totals WHERE session_id=$1),EXISTS(SELECT 1 FROM events WHERE session_id=$1 AND kind='artifact_pending')",&[&sid])?;
let count: i64 = row.get(0);
let requests: i64 = row.get(1);
let saved: Option<i64> = row.get(2);
let had: bool = row.get(3);
ensure!(
count == requests && saved.unwrap_or(0) == count && (!had || saved.is_some()),
Error::Conflict
);
Ok(())
}
pub(crate) fn load(tx: &mut Transaction<'_>, sid: &str, id: &str) -> Result<Artifact> {
let row = tx
.query_opt(
"SELECT data FROM artifacts WHERE session_id=$1 AND id=$2",
&[&sid, &id],
)?
.ok_or(Error::NotFound)?;
let a: Artifact = serde_json::from_value(row.get(0))?;
a.validate()?;
ensure!(
a.id == id && a.registration.session_id == sid,
Error::Conflict
);
let row=tx.query_opt("SELECT request,binding FROM artifact_requests WHERE session_id=$1 AND request_id=$2 AND artifact_id=$3",&[&sid,&a.registration.request_id,&id])?.ok_or(Error::Conflict)?;
ensure!(
row.get::<_, Value>(0) == serde_json::to_value(&a.registration)?
&& row.get::<_, Value>(1) == serde_json::to_value(&a.binding)?,
Error::Conflict
);
Ok(a)
}
fn event(tx: &mut Transaction<'_>, a: &Artifact, kind: &str, actor: &str) -> Result<()> {
let sid = &a.registration.session_id;
let tid = a
.registration
.origin
.is_turn()
.then_some(a.registration.turn_id.as_str());
let row = tx.query_one(
"UPDATE sessions SET cursor=cursor+1 WHERE id=$1 RETURNING cursor,epoch",
&[sid],
)?;
let cursor: i64 = row.get(0);
let epoch: i64 = row.get(1);
let data = json!({"artifact_id":a.id,"request_id":a.registration.request_id,"status":a.status});
tx.execute(
"INSERT INTO events(session_id,cursor,turn_id,kind,data) VALUES($1,$2,$3,$4,$5)",
&[sid, &cursor, &tid, &kind, &data],
)?;
tx.execute("INSERT INTO audit(session_id,cursor,turn_id,kind,owner_epoch,actor) VALUES($1,$2,$3,$4,$5,$6)",&[sid,&cursor,&tid,&kind,&epoch,&actor])?;
Ok(())
}
impl Database {
pub(crate) fn register_artifact(
&mut self,
request: Registration,
binding: Binding,
actor: &str,
) -> Result<Artifact> {
self.register_artifact_inner(request, binding, actor, None)
}
pub(crate) fn register_artifact_inner(
&mut self,
request: Registration,
binding: Binding,
actor: &str,
source_claim: Option<&str>,
) -> Result<Artifact> {
let mut tx = self.client.transaction()?;
let p = crate::auth::guard(
&mut tx,
self.auth.as_ref(),
crate::auth::Action::Artifact,
Some(&request.session_id),
None,
)?;
crate::auth::actor(p.as_ref(), actor)?;
// Public/generic registration cannot grant setup authority. Only the
// private controller supplies its live original source-intent claim.
ensure!(
request.origin.is_turn() || (self.auth.is_none() && source_claim.is_some()),
Error::Invalid
);
let s = locked(&mut tx, &request.session_id, None)?;
if !request.origin.is_turn() {
authorize_team_artifact(&mut tx, &s, &request, &binding, actor, source_claim)?;
}
verify(&mut tx, &s.id)?;
if let Some(row)=tx.query_opt("SELECT artifact_id,actor,request,binding FROM artifact_requests WHERE session_id=$1 AND request_id=$2",&[&s.id,&request.request_id])? {
ensure!(row.get::<_,String>(1)==actor && row.get::<_,Value>(2)==serde_json::to_value(&request)? && row.get::<_,Value>(3)==serde_json::to_value(&binding)?,Error::Conflict);
let a=load(&mut tx,&s.id,&row.get::<_,String>(0))?;
crate::auth::audit(&mut tx,p.as_ref(),crate::auth::Action::Artifact,Some(&request.session_id),Some(&request.request_id))?;
tx.commit()?;
return Ok(a);
}
ensure!(!s.closed, Error::Conflict);
let known = s.turn.as_ref().is_some_and(|t| t.id == request.turn_id)
|| tx
.query_one(
"SELECT EXISTS(SELECT 1 FROM events WHERE session_id=$1 AND turn_id=$2)",
&[&s.id, &request.turn_id],
)?
.get::<_, bool>(0);
ensure!(!request.origin.is_turn() || known, Error::NotFound);
let used:bool=tx.query_one("SELECT EXISTS(SELECT 1 FROM events WHERE session_id=$1 AND kind='artifact_pending' AND data->>'request_id'=$2)",&[&s.id,&request.request_id])?.get(0);
ensure!(!used, Error::Conflict);
let count: i64 = tx
.query_one(
"SELECT count(*) FROM artifacts WHERE session_id=$1",
&[&s.id],
)?
.get(0);
ensure!(count < 256, Error::TooLarge);
let id = format!("a_{}", uuid::Uuid::new_v4().simple());
let key = format!("{}/{}/{}", binding.deployment, s.id, id);
let a = Artifact {
id,
registration: request,
binding,
key,
status: Status::Pending,
proof: None,
};
a.validate()?;
tx.execute(
"INSERT INTO artifacts VALUES($1,$2,$3)",
&[&a.id, &s.id, &serde_json::to_value(&a)?],
)?;
tx.execute(
"INSERT INTO artifact_requests VALUES($1,$2,$3,$4,$5,$6)",
&[
&s.id,
&a.registration.request_id,
&a.id,
&actor,
&serde_json::to_value(&a.registration)?,
&serde_json::to_value(&a.binding)?,
],
)?;
tx.execute("INSERT INTO artifact_totals VALUES($1,1) ON CONFLICT(session_id) DO UPDATE SET total=artifact_totals.total+1",&[&s.id])?;
event(&mut tx, &a, "artifact_pending", actor)?;
crate::auth::audit(
&mut tx,
p.as_ref(),
crate::auth::Action::Artifact,
Some(&a.registration.session_id),
Some(&a.registration.request_id),
)?;
tx.commit()?;
Ok(a)
}
pub(crate) fn artifact(&mut self, sid: &str, id: &str) -> Result<Artifact> {
let mut tx = self.client.transaction()?;
crate::auth::guard(
&mut tx,
self.auth.as_ref(),
crate::auth::Action::Read,
Some(sid),
None,
)?;
locked(&mut tx, sid, None)?;
verify(&mut tx, sid)?;
let a = load(&mut tx, sid, id)?;
tx.commit()?;
Ok(a)
}
pub(crate) fn artifacts(&mut self, sid: &str) -> Result<Vec<Artifact>> {
let mut tx = self.client.transaction()?;
crate::auth::guard(
&mut tx,
self.auth.as_ref(),
crate::auth::Action::Read,
Some(sid),
None,
)?;
locked(&mut tx, sid, None)?;
verify(&mut tx, sid)?;
let ids: Vec<String> = tx
.query(
"SELECT id FROM artifacts WHERE session_id=$1 ORDER BY id",
&[&sid],
)?
.iter()
.map(|r| r.get(0))
.collect();
ensure!(ids.len() <= 256, Error::TooLarge);
let mut result = vec![];
for id in ids {
result.push(load(&mut tx, sid, &id)?);
}
tx.commit()?;
Ok(result)
}
pub(crate) fn publish_artifact(
&mut self,
sid: &str,
id: &str,
proof: Proof,
actor: &str,
) -> Result<Artifact> {
self.publish_artifact_inner(sid, id, proof, actor, None)
}
pub(crate) fn publish_artifact_inner(
&mut self,
sid: &str,
id: &str,
proof: Proof,
actor: &str,
source_claim: Option<&str>,
) -> Result<Artifact> {
let mut tx = self.client.transaction()?;
let p = crate::auth::guard(
&mut tx,
self.auth.as_ref(),
crate::auth::Action::Artifact,
Some(sid),
None,
)?;
crate::auth::actor(p.as_ref(), actor)?;
let s = locked(&mut tx, sid, None)?;
verify(&mut tx, sid)?;
let mut a = load(&mut tx, sid, id)?;
if !a.registration.origin.is_turn() {
ensure!(
self.auth.is_none() && source_claim.is_some(),
Error::Invalid
);
authorize_team_artifact(
&mut tx,
&s,
&a.registration,
&a.binding,
actor,
source_claim,
)?;
}
ensure!(proof.expected == a.registration.expected, Error::Conflict);
if a.status == Status::Ready {
ensure!(a.proof.as_ref() == Some(&proof), Error::Conflict);
crate::auth::audit(
&mut tx,
p.as_ref(),
crate::auth::Action::Artifact,
Some(sid),
Some(id),
)?;
tx.commit()?;
return Ok(a);
}
a.status = Status::Ready;
a.proof = Some(proof);
a.validate()?;
tx.execute(
"UPDATE artifacts SET data=$2 WHERE id=$1",
&[&id, &serde_json::to_value(&a)?],
)?;
event(&mut tx, &a, "artifact_ready", actor)?;
crate::auth::audit(
&mut tx,
p.as_ref(),
crate::auth::Action::Artifact,
Some(sid),
Some(id),
)?;
tx.commit()?;
Ok(a)
}
}
fn authorize_team_artifact(
tx: &mut postgres::Transaction<'_>,
s: &openworker_runtime::store::Session,
r: &Registration,
binding: &Binding,
actor: &str,
claim: Option<&str>,
) -> Result<()> {
match &r.origin {
openworker_artifacts::Origin::TeamSetup { .. } => {
crate::service_team_sources::authorize_artifact(tx, s, r, binding, actor, claim)
}
openworker_artifacts::Origin::TeamSubmission { .. } => {
crate::service_team_submissions::authorize_artifact(tx, s, r, binding, actor, claim)
}
openworker_artifacts::Origin::Turn => anyhow::bail!("Expected private team provenance"),
}
}