187 lines
21 KiB
TypeScript
187 lines
21 KiB
TypeScript
import {createHash} from 'node:crypto'
|
|
import {assertRestoreProfileQuarantine} from './database-restore-quarantine-profile.js'
|
|
|
|
export interface PartitionGuardSql {query(sql:string,values?:unknown[]):Promise<{rows:Record<string,unknown>[];command?:string}>}
|
|
const KEY=8723110
|
|
const MANAGED=new Set(['flow_buckets','flow_minute_stats','flow_minute_dims','flow_daily_dims','flow_hour_facts','flow_daily_facts','traffic_samples','servers_rest_ping_samples','uptime_probe_samples','uptime_resource_samples','server_snapshots','internet_path_snapshots'])
|
|
const ROW='server_partition_writer_guard',STATEMENT='candidate_application_statement_guard',TRUNCATE='candidate_truncate_preadmitted'
|
|
// Fixed reviewed SQL bodies. Operator provisioning must reuse these exact
|
|
// definitions; this component cannot issue/enroll any trusted profile/state.
|
|
const BODIES:Readonly<Record<string,string>>={
|
|
'public.server_partition_writer_guard':" BEGIN PERFORM pg_advisory_xact_lock_shared(8723110::bigint); IF TG_OP='DELETE' THEN RETURN OLD; END IF; RETURN NEW; END; ",
|
|
'mmapp_control.candidate_truncate_preadmitted':'\nBEGIN PERFORM mmapp_control.candidate_require_preadmission(); RETURN NULL; END ',
|
|
'mmapp_control.candidate_require_preadmission':"\nBEGIN\n IF NOT EXISTS(SELECT 1 FROM pg_catalog.pg_locks WHERE pid=pg_catalog.pg_backend_pid()\n AND locktype='advisory' AND classid=0 AND objid=8723110 AND objsubid=1\n AND granted AND mode IN ('ShareLock','ExclusiveLock')) THEN\n RAISE EXCEPTION 'operator SQL requires preheld writer admission' USING ERRCODE='55000';\n END IF;\n PERFORM pg_catalog.pg_advisory_xact_lock_shared(8723110::bigint);\nEND ",
|
|
}
|
|
type Acl={grantee:string;grantor:string;privilege:string;grantable:boolean}
|
|
type Relation={oid:string;name:string;kind:string;partition:boolean;persistence:string;rls:boolean;force_rls:boolean;owner:string;schema_owner:string;acl:Acl[];parents:string[]}
|
|
type Trigger={oid:string;name:string;type:number;enabled:string;function_oid:string;function_namespace:string;function_name:string;parent_trigger:string;args:number;arg_bytes:number;unconditional:boolean;constraint_oid:string;deferrable:boolean;deferred:boolean;old_table:string|null;new_table:string|null}
|
|
type Context={pid:number;xid:string|null;actor:string;login:string;role_oid:string;database_oid:string;read_only:string;isolation:string;version:number;admitted:boolean}
|
|
type FunctionRow={oid:string;namespace:string;name:string;owner:string;schema_owner:string;language:string;return_type:string;return_namespace:string;kind:string;source:string;security_definer:boolean;configuration:string[]|null;strict:boolean;leakproof:boolean;volatility:string;parallel:string;arguments:number;returns_set:boolean;library:string|null;acl:Acl[]}
|
|
type Policy={parent:Relation;triggers:Trigger[];functions:FunctionRow[];runtime:{oid:string;name:string};capture:{oid:string;name:string};controlOwner:string}
|
|
function refuse(message:string):never{throw Error('Reviewed partition guard inheritance refused: '+message)}
|
|
const identifier=(value:string)=>{if(!/^[a-z_][a-z0-9_]{0,62}$/.test(value))refuse('identifier');return '"'+value+'"'}
|
|
const canonical=(value:unknown):string=>JSON.stringify(value,(_key,item:unknown)=>item&&typeof item==='object'&&!Array.isArray(item)?Object.fromEntries(Object.entries(item).sort(([a],[b])=>a.localeCompare(b))):item)
|
|
const digest=(value:unknown)=>createHash('sha256').update(canonical(value)).digest('hex')
|
|
async function rows<T>(client:PartitionGuardSql,sql:string,values:unknown[]=[],bound=32):Promise<T[]>{const result=await client.query(sql,values);if(!Array.isArray(result.rows)||result.rows.length>bound)refuse('catalog bound');return result.rows as unknown as T[]}
|
|
async function context(client:PartitionGuardSql):Promise<Context>{
|
|
const result=await rows<Context>(client,`SELECT pg_catalog.pg_backend_pid() AS pid,pg_catalog.pg_current_xact_id_if_assigned()::pg_catalog.text AS xid,
|
|
CURRENT_USER::pg_catalog.text AS actor,SESSION_USER::pg_catalog.text AS login,r.oid::pg_catalog.text AS role_oid,d.oid::pg_catalog.text AS database_oid,
|
|
pg_catalog.current_setting('transaction_read_only') AS read_only,pg_catalog.current_setting('transaction_isolation') AS isolation,pg_catalog.current_setting('server_version_num')::pg_catalog.int4 AS version,
|
|
EXISTS(SELECT 1 FROM pg_catalog.pg_locks WHERE locktype='advisory' AND pid=pg_catalog.pg_backend_pid() AND classid=0 AND objid=$1::pg_catalog.oid AND objsubid=1 AND granted AND mode IN('ShareLock','ExclusiveLock')) AS admitted
|
|
FROM pg_catalog.pg_roles r CROSS JOIN pg_catalog.pg_database d WHERE r.rolname=CURRENT_USER AND d.datname=pg_catalog.current_database()`,[KEY],1)
|
|
const value=result[0]
|
|
if(!value||!Number.isSafeInteger(value.pid)||value.pid<=0||value.actor!==value.login||value.read_only!=='off'||!value.admitted)refuse('owned writable preheld admission')
|
|
return value
|
|
}
|
|
const ACL_SQL=`SELECT a.grantee::pg_catalog.text AS grantee,a.grantor::pg_catalog.text AS grantor,a.privilege_type AS privilege,a.is_grantable AS grantable FROM pg_catalog.aclexplode(COALESCE(c.relacl,pg_catalog.acldefault('r',c.relowner))) a ORDER BY a.grantee,a.privilege_type LIMIT 33`
|
|
async function relation(client:PartitionGuardSql,name:string):Promise<Relation|undefined>{
|
|
const result=await rows<Relation>(client,`SELECT c.oid::pg_catalog.text AS oid,c.relname AS name,c.relkind::pg_catalog.text AS kind,c.relispartition AS partition,c.relpersistence::pg_catalog.text AS persistence,c.relrowsecurity AS rls,c.relforcerowsecurity AS force_rls,
|
|
c.relowner::pg_catalog.text AS owner,n.nspowner::pg_catalog.text AS schema_owner,
|
|
COALESCE((SELECT pg_catalog.jsonb_agg(x) FROM (${ACL_SQL}) x),'[]'::pg_catalog.jsonb) AS acl,
|
|
ARRAY(SELECT i.inhparent::pg_catalog.text FROM pg_catalog.pg_inherits i WHERE i.inhrelid=c.oid ORDER BY i.inhseqno) AS parents
|
|
FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid=c.relnamespace WHERE n.nspname='public' AND c.relname=$1`,[name],1)
|
|
return result[0]
|
|
}
|
|
async function triggers(client:PartitionGuardSql,oid:string):Promise<Trigger[]>{return rows<Trigger>(client,`SELECT t.oid::pg_catalog.text AS oid,t.tgname AS name,t.tgtype::pg_catalog.int4 AS type,t.tgenabled::pg_catalog.text AS enabled,
|
|
t.tgfoid::pg_catalog.text AS function_oid,fn.nspname AS function_namespace,p.proname AS function_name,t.tgparentid::pg_catalog.text AS parent_trigger,t.tgnargs::pg_catalog.int4 AS args,pg_catalog.octet_length(t.tgargs)::pg_catalog.int4 AS arg_bytes,
|
|
t.tgqual IS NULL AS unconditional,t.tgconstraint::pg_catalog.text AS constraint_oid,t.tgdeferrable AS deferrable,t.tginitdeferred AS deferred,t.tgoldtable AS old_table,t.tgnewtable AS new_table
|
|
FROM pg_catalog.pg_trigger t JOIN pg_catalog.pg_proc p ON p.oid=t.tgfoid JOIN pg_catalog.pg_namespace fn ON fn.oid=p.pronamespace WHERE t.tgrelid=$1::pg_catalog.oid AND NOT t.tgisinternal ORDER BY t.tgname LIMIT 9`,[oid],8)}
|
|
function aclShape(acl:Acl[],owner:string,kind:'table'|'function'='table'):Acl[]{
|
|
if(!Array.isArray(acl)||acl.length>32||acl.some(item=>!item||item.grantor!==owner||item.grantable!==false||typeof item.grantee!=='string'||typeof item.privilege!=='string'))refuse('ACL/grantor/grant option')
|
|
if(canonical(acl.filter(item=>item.grantee===owner).map(item=>item.privilege).sort())!==canonical(kind==='function'?['EXECUTE']:['DELETE','INSERT','MAINTAIN','REFERENCES','SELECT','TRIGGER','TRUNCATE','UPDATE']))refuse('owner ACL structure')
|
|
return acl.filter(item=>item.grantee!==owner).sort((a,b)=>(a.grantee+':'+a.privilege).localeCompare(b.grantee+':'+b.privilege))
|
|
}
|
|
function guard(trigger:Trigger|undefined,name:string,type:number,fn:string,parentTrigger='0'){
|
|
if(!trigger||trigger.name!==name||trigger.type!==type||trigger.function_oid!==fn||trigger.enabled!=='A'||trigger.parent_trigger!==parentTrigger||trigger.args!==0||trigger.arg_bytes!==0||!trigger.unconditional||trigger.constraint_oid!=='0'||trigger.deferrable||trigger.deferred||trigger.old_table!==null||trigger.new_table!==null)refuse('trigger identity/shape')
|
|
}
|
|
async function functions(client:PartitionGuardSql):Promise<FunctionRow[]>{return rows<FunctionRow>(client,`SELECT p.oid::pg_catalog.text AS oid,n.nspname AS namespace,p.proname AS name,p.proowner::pg_catalog.text AS owner,n.nspowner::pg_catalog.text AS schema_owner,
|
|
l.lanname AS language,t.typname AS return_type,tn.nspname AS return_namespace,p.prokind::pg_catalog.text AS kind,p.prosrc AS source,p.prosecdef AS security_definer,p.proconfig AS configuration,p.proisstrict AS strict,p.proleakproof AS leakproof,
|
|
p.provolatile::pg_catalog.text AS volatility,p.proparallel::pg_catalog.text AS parallel,p.pronargs::pg_catalog.int4 AS arguments,p.proretset AS returns_set,p.probin AS library,
|
|
COALESCE((SELECT pg_catalog.jsonb_agg(x) FROM (SELECT a.grantee::pg_catalog.text AS grantee,a.grantor::pg_catalog.text AS grantor,a.privilege_type AS privilege,a.is_grantable AS grantable FROM pg_catalog.aclexplode(COALESCE(p.proacl,pg_catalog.acldefault('f',p.proowner))) a ORDER BY a.grantee,a.privilege_type LIMIT 33) x),'[]'::pg_catalog.jsonb) AS acl
|
|
FROM pg_catalog.pg_proc p JOIN pg_catalog.pg_namespace n ON n.oid=p.pronamespace JOIN pg_catalog.pg_language l ON l.oid=p.prolang JOIN pg_catalog.pg_type t ON t.oid=p.prorettype JOIN pg_catalog.pg_namespace tn ON tn.oid=t.typnamespace
|
|
WHERE(n.nspname='public' AND p.proname='server_partition_writer_guard')OR(n.nspname='mmapp_control' AND p.proname IN('candidate_require_preadmission','candidate_truncate_preadmitted')) ORDER BY n.nspname,p.proname LIMIT 5`,[],4)}
|
|
async function reviewedFunctions(client:PartitionGuardSql,owner:string):Promise<FunctionRow[]> {
|
|
const fns=await functions(client);if(fns.length!==3)refuse('fixed guard function set')
|
|
for(const fn of fns){
|
|
const identity=fn.namespace+'.'+fn.name,body=BODIES[identity]
|
|
if(!body||fn.source!==body||fn.arguments!==0||fn.kind!=='f'||fn.language!=='plpgsql'||fn.strict||fn.leakproof||fn.volatility!=='v'||fn.parallel!=='u'||fn.returns_set||fn.library!==null||canonical(fn.configuration)!==canonical(['search_path=pg_catalog'])||fn.return_namespace!=='pg_catalog'||fn.return_type!==(fn.name==='candidate_require_preadmission'?'void':'trigger')||fn.security_definer!==(fn.namespace==='mmapp_control')||fn.owner!==fn.schema_owner||fn.namespace==='public'&&fn.owner!==owner||fn.namespace==='mmapp_control'&&fn.owner===owner)refuse('fixed guard function body/security/owner')
|
|
const other=aclShape(fn.acl,fn.owner,'function'),expected=fn.namespace==='public'?[{grantee:'0',grantor:fn.owner,privilege:'EXECUTE',grantable:false}]:fn.name===TRUNCATE?[{grantee:owner,grantor:fn.owner,privilege:'EXECUTE',grantable:false}]:[]
|
|
if(canonical(other)!==canonical(expected))refuse('guard function ACL')
|
|
}
|
|
return fns
|
|
}
|
|
async function policy(client:PartitionGuardSql,parent:Relation,all:Trigger[],ctx:Context):Promise<Policy>{
|
|
if(!MANAGED.has(parent.name)||ctx.version<180000||ctx.version>=190000||parent.kind!=='p'||parent.partition||parent.persistence!=='p'||parent.rls||parent.force_rls||parent.owner!==ctx.role_oid||parent.schema_owner!==ctx.role_oid||all.length!==3)refuse('managed parent/owner/scope')
|
|
const fns=await reviewedFunctions(client,parent.owner)
|
|
const rowFn=fns.find(fn=>fn.namespace==='public')!,truncateFn=fns.find(fn=>fn.name===TRUNCATE)!,controlOwner=truncateFn.owner
|
|
guard(all.find(t=>t.name===ROW),ROW,31,rowFn.oid);guard(all.find(t=>t.name===STATEMENT),STATEMENT,30,rowFn.oid);guard(all.find(t=>t.name===TRUNCATE),TRUNCATE,34,truncateFn.oid)
|
|
const acl=aclShape(parent.acl,parent.owner),grantees=[...new Set(acl.map(item=>item.grantee))]
|
|
if(grantees.length!==2||grantees.includes('0'))refuse('exact two parent grantees')
|
|
const runtimeId=grantees.find(oid=>canonical(acl.filter(item=>item.grantee===oid).map(item=>item.privilege).sort())===canonical(['DELETE','INSERT','SELECT','UPDATE']))
|
|
const captureId=grantees.find(oid=>canonical(acl.filter(item=>item.grantee===oid).map(item=>item.privilege))===canonical(['SELECT']))
|
|
if(!runtimeId||!captureId||runtimeId===captureId)refuse('exact runtime/capture ACL')
|
|
const roles=await rows<{oid:string;name:string;control_name:string;unsafe:boolean;owner_member:boolean;control_member:boolean;has_membership:boolean;public_usage:boolean;public_create:boolean;control_usage:boolean;control_create:boolean;db_create:boolean;db_temp:boolean;set_replication:boolean;set_event:boolean}>(client,`SELECT r.oid::pg_catalog.text AS oid,r.rolname AS name,pg_catalog.pg_get_userbyid($2::pg_catalog.oid) AS control_name,
|
|
(r.rolsuper OR r.rolcreatedb OR r.rolcreaterole OR r.rolreplication OR r.rolbypassrls) AS unsafe,
|
|
pg_catalog.pg_has_role(r.oid,$1::pg_catalog.oid,'MEMBER') AS owner_member,pg_catalog.pg_has_role(r.oid,$2::pg_catalog.oid,'MEMBER') AS control_member,
|
|
EXISTS(SELECT 1 FROM pg_catalog.pg_auth_members m WHERE m.member=r.oid OR m.roleid=r.oid) AS has_membership,
|
|
pg_catalog.has_schema_privilege(r.oid,('public'::pg_catalog.regnamespace)::pg_catalog.oid,'USAGE') AS public_usage,pg_catalog.has_schema_privilege(r.oid,('public'::pg_catalog.regnamespace)::pg_catalog.oid,'CREATE') AS public_create,
|
|
pg_catalog.has_schema_privilege(r.oid,('mmapp_control'::pg_catalog.regnamespace)::pg_catalog.oid,'USAGE') AS control_usage,pg_catalog.has_schema_privilege(r.oid,('mmapp_control'::pg_catalog.regnamespace)::pg_catalog.oid,'CREATE') AS control_create,
|
|
pg_catalog.has_database_privilege(r.oid,$4::pg_catalog.oid,'CREATE') AS db_create,pg_catalog.has_database_privilege(r.oid,$4::pg_catalog.oid,'TEMP') AS db_temp,
|
|
pg_catalog.has_parameter_privilege(r.oid,'session_replication_role','SET') AS set_replication,pg_catalog.has_parameter_privilege(r.oid,'event_triggers','SET') AS set_event
|
|
FROM pg_catalog.pg_roles r WHERE r.oid=ANY($3::pg_catalog.oid[]) ORDER BY r.oid`,[parent.owner,controlOwner,[parent.owner,runtimeId,captureId],ctx.database_oid],3)
|
|
if(roles.length!==3)refuse('actor roles')
|
|
for(const role of roles){identifier(role.name);if(role.unsafe||role.control_member||role.has_membership||role.db_create||role.db_temp||role.set_replication||role.set_event||role.control_create)refuse('role/membership/DDL parameter escape');if(role.oid!==parent.owner&&(role.owner_member||!role.public_usage||role.public_create||role.oid!==runtimeId&&role.control_usage))refuse('limited actor schema/ownership')}
|
|
const runtime=roles.find(role=>role.oid===runtimeId)!
|
|
if(runtime.control_usage)await assertRestoreProfileQuarantine(client,runtime.name,ctx.actor,runtime.control_name)
|
|
return {parent,triggers:all,functions:fns,runtime:roles.find(role=>role.oid===runtimeId)!,capture:roles.find(role=>role.oid===captureId)!,controlOwner}
|
|
}
|
|
|
|
/** Fixed marker-table guard validation under the migration owner's held admission. */
|
|
export async function assertReviewedMigrationMarkerGuard(client:PartitionGuardSql,state:'installed'|'unenrolled'='installed'):Promise<void>{
|
|
const ctx=await context(client), marker=await relation(client,'schema_migrations')
|
|
if(!marker||ctx.version<180000||ctx.version>=190000||marker.kind!=='r'||marker.partition||marker.persistence!=='p'||
|
|
marker.rls||marker.force_rls||marker.parents.length||marker.owner!==ctx.role_oid||marker.schema_owner!==ctx.role_oid)refuse('marker table/owner/scope')
|
|
const acl=aclShape(marker.acl,marker.owner)
|
|
if(acl.length!==3||new Set(acl.map(entry=>entry.grantee)).size!==3||
|
|
acl.some(entry=>entry.grantee==='0'||entry.privilege!=='SELECT'))refuse('marker table ACL')
|
|
const extra=await rows<{unsafe:boolean}>(client,`SELECT (
|
|
c.relhasrules OR EXISTS (SELECT 1 FROM pg_catalog.pg_inherits i WHERE i.inhparent=c.oid)
|
|
OR EXISTS (SELECT 1 FROM pg_catalog.pg_attribute a WHERE a.attrelid=c.oid AND a.attnum>0 AND a.attacl IS NOT NULL)
|
|
OR EXISTS (SELECT 1 FROM pg_catalog.pg_trigger t WHERE t.tgrelid=c.oid
|
|
AND (t.tgisinternal OR t.tgattr::text<>'' OR t.tgconstrrelid<>0 OR t.tgconstrindid<>0))
|
|
) AS unsafe FROM pg_catalog.pg_class c WHERE c.oid=$1::pg_catalog.oid`,[marker.oid],1)
|
|
if(extra.length!==1||extra[0].unsafe!==false)refuse('marker table rules, column ACL or trigger scope')
|
|
const all=await triggers(client,marker.oid)
|
|
if(all.length!==(state==='unenrolled'?0:3))refuse('exact marker trigger set')
|
|
const fns=await reviewedFunctions(client,marker.owner)
|
|
if(state==='unenrolled')return
|
|
const rowFn=fns.find(fn=>fn.namespace==='public')!,truncateFn=fns.find(fn=>fn.name===TRUNCATE)!
|
|
guard(all.find(t=>t.name===ROW),ROW,31,rowFn.oid)
|
|
guard(all.find(t=>t.name===STATEMENT),STATEMENT,30,rowFn.oid)
|
|
guard(all.find(t=>t.name===TRUNCATE),TRUNCATE,34,truncateFn.oid)
|
|
}
|
|
async function validateLeaf(client:PartitionGuardSql,leaf:Relation,parent:Policy,complete:boolean){
|
|
if(leaf.kind!=='r'||!leaf.partition||leaf.persistence!=='p'||leaf.rls||leaf.force_rls||leaf.owner!==parent.parent.owner||canonical(leaf.parents)!==canonical([parent.parent.oid]))refuse('direct owned ordinary leaf')
|
|
const all=await triggers(client,leaf.oid),row=parent.triggers.find(t=>t.name===ROW)!,statement=parent.triggers.find(t=>t.name===STATEMENT)!,truncate=parent.triggers.find(t=>t.name===TRUNCATE)!
|
|
if(all.length!==(complete?3:1))refuse('leaf foreign/partial guards')
|
|
guard(all.find(t=>t.name===ROW),ROW,31,row.function_oid,row.oid)
|
|
if(complete){guard(all.find(t=>t.name===STATEMENT),STATEMENT,30,statement.function_oid);guard(all.find(t=>t.name===TRUNCATE),TRUNCATE,34,truncate.function_oid)}
|
|
const extra=aclShape(leaf.acl,leaf.owner),wanted=aclShape(parent.parent.acl,parent.parent.owner)
|
|
if(canonical(extra)!==canonical(wanted)&&!(complete===false&&extra.length===0))refuse('leaf foreign/partial ACL')
|
|
}
|
|
/** Mechanical inheritance only. Parent SQL is NOT trusted profile issuance.
|
|
* Protected enabled-host admission remains independently required. */
|
|
export async function prepareReviewedPartitionGuardInheritance(client:PartitionGuardSql,parentName:string,leafName:string):Promise<()=>Promise<void>>{
|
|
identifier(parentName);identifier(leafName)
|
|
const first=await context(client)
|
|
// This is reentrant ONLY after confirming a preheld same-backend lease; never
|
|
// first wait for a global admission key while owning relation DDL locks.
|
|
await client.query('SELECT pg_catalog.pg_advisory_xact_lock_shared($1::pg_catalog.int8)',[KEY])
|
|
const assigned=await rows<{xid:string}>(client,'SELECT pg_catalog.pg_current_xact_id()::pg_catalog.text AS xid',[],1)
|
|
const bound={...first,xid:assigned[0]?.xid};if(!bound.xid||!/^[1-9][0-9]*$/.test(bound.xid))refuse('owned full transaction identity')
|
|
const check=async()=>{if(canonical(await context(client))!==canonical(bound))refuse('backend/transaction/admission changed')}
|
|
await check()
|
|
const parent=await relation(client,parentName);if(!parent)refuse('missing parent')
|
|
const all=await triggers(client,parent.oid)
|
|
const guarded=all.some(t=>t.name===STATEMENT||t.name===TRUNCATE)
|
|
let used=false
|
|
if(!guarded){
|
|
if(all.length>1||all.length===1&&(all[0].name!==ROW||all[0].type!==31||all[0].enabled!=='A'||all[0].function_namespace!=='public'||all[0].function_name!==ROW||all[0].args!==0||all[0].arg_bytes!==0||!all[0].unconditional))refuse('foreign/partial legacy parent')
|
|
return async()=>{if(used)refuse('finished continuation');used=true;await check()}
|
|
}
|
|
if(bound.isolation!=='read committed')refuse('guarded DDL requires fresh READ COMMITTED metadata')
|
|
let template=await policy(client,parent,all,bound),existing=await relation(client,leafName)
|
|
if(existing)await validateLeaf(client,existing,template,true)
|
|
else{
|
|
// Only a potentially missing leaf needs CREATE's parent lock. Known full
|
|
// leaves retain a read-only verification fast path, without a new strong
|
|
// parent lock on every normal flow flush. Re-read after a racing creator.
|
|
await client.query('LOCK TABLE public.'+identifier(parentName)+' IN ACCESS EXCLUSIVE MODE')
|
|
await check()
|
|
const lockedParent=await relation(client,parentName);if(!lockedParent||lockedParent.oid!==parent.oid)refuse('locked parent changed')
|
|
template=await policy(client,lockedParent,await triggers(client,lockedParent.oid),bound)
|
|
existing=await relation(client,leafName)
|
|
if(existing)await validateLeaf(client,existing,template,true)
|
|
}
|
|
const fingerprint=digest(template)
|
|
return async()=>{
|
|
if(used)refuse('finished continuation');used=true;await check()
|
|
const currentParent=await relation(client,parentName);if(!currentParent)refuse('parent disappeared')
|
|
if(digest(await policy(client,currentParent,await triggers(client,currentParent.oid),bound))!==fingerprint)refuse('parent policy changed')
|
|
const leaf=await relation(client,leafName);if(!leaf)refuse('missing created leaf')
|
|
await validateLeaf(client,leaf,template,Boolean(existing))
|
|
if(!existing){
|
|
const table='public.'+identifier(leafName)
|
|
await client.query(`CREATE TRIGGER ${STATEMENT} BEFORE INSERT OR UPDATE OR DELETE ON ${table} FOR EACH STATEMENT EXECUTE FUNCTION public.server_partition_writer_guard()`)
|
|
await client.query(`ALTER TABLE ${table} ENABLE ALWAYS TRIGGER ${STATEMENT}`)
|
|
await client.query(`CREATE TRIGGER ${TRUNCATE} BEFORE TRUNCATE ON ${table} FOR EACH STATEMENT EXECUTE FUNCTION mmapp_control.candidate_truncate_preadmitted()`)
|
|
await client.query(`ALTER TABLE ${table} ENABLE ALWAYS TRIGGER ${TRUNCATE}`)
|
|
await client.query(`GRANT SELECT,INSERT,UPDATE,DELETE ON TABLE ${table} TO ${identifier(template.runtime.name)}`)
|
|
await client.query(`GRANT SELECT ON TABLE ${table} TO ${identifier(template.capture.name)}`)
|
|
}
|
|
await validateLeaf(client,(await relation(client,leafName))!,template,true);await check()
|
|
const finalParent=(await relation(client,parentName))!
|
|
if(digest(await policy(client,finalParent,await triggers(client,finalParent.oid),bound))!==fingerprint)refuse('final parent policy changed')
|
|
}
|
|
}
|