Prepare verified laboratory 6 implementation and evidence

This commit is contained in:
rey
2026-11-17 17:32:06 +03:00
parent 470d9d6f1e
commit 7d56e52fd0
335 changed files with 31206 additions and 72 deletions
+8
View File
@@ -0,0 +1,8 @@
import{mkdir,readFile,writeFile}from'node:fs/promises';import{resolve}from'node:path';import{createGrafanaCredentialBootstrap}from'./lib/grafana-credential';
if(process.argv.includes('--check')){console.log('Grafana credential entrypoint validated; no credential reads or mutations');process.exit(0);}
if(process.platform!=='linux')throw new Error('Run the stand credential bootstrap on its owned Linux host');
const root=resolve(import.meta.dir,'..'),local=resolve(root,'.local'),passwordFile=resolve(local,'grafana_password');await mkdir(local,{recursive:true,mode:0o700});
function run(args:string[],input?:Uint8Array){const result=Bun.spawnSync(args,{stdin:input,stdout:'pipe',stderr:'pipe'});if(result.exitCode!==0)throw new Error('Grafana encrypted credential archival failed');return result.stdout;}
let archiveDirectory='';
await createGrafanaCredentialBootstrap({read:async()=>{try{return(await readFile(passwordFile,'utf8')).trim()}catch(e){if(e.code==='ENOENT')return undefined;throw e}},generate:()=> 'Aa1!'+crypto.randomUUID()+crypto.randomUUID(),archive:async value=>{archiveDirectory=resolve(local,'grafana-owner-archive-'+crypto.randomUUID());await mkdir(archiveDirectory,{mode:0o700});const key=resolve(archiveDirectory,'identity.agekey');run(['/home/rey/.local/bin/age-keygen','-o',key]);const plaintext=Buffer.from(value),encrypted=run(['/home/rey/.local/bin/age','--encrypt','-i',key],plaintext);const target=resolve(archiveDirectory,'grafana-owner.age');await writeFile(target,encrypted,{flag:'wx',mode:0o600});const restored=run(['/home/rey/.local/bin/age','--decrypt','-i',key,target]);if(!Buffer.from(restored).equals(plaintext))throw new Error('Grafana archive roundtrip mismatch');await writeFile(resolve(archiveDirectory,'RESULT.json'),JSON.stringify({checkedAt:new Date().toISOString(),encryptedBeforeRuntimePublish:true,roundtripVerified:true,passwordSHA256:new Bun.CryptoHasher('sha256').update(plaintext).digest('hex')})+'\n',{flag:'wx',mode:0o600});},publish:async value=>{await writeFile(passwordFile,value,{flag:'wx',mode:0o644})}})();
console.log(JSON.stringify({grafanaOwnerPreservedOrCreated:true,encryptedArchiveVerified:true,archiveDirectory}));
+5
View File
@@ -0,0 +1,5 @@
import {mkdir,writeFile,access} from 'node:fs/promises';import {resolve} from 'node:path';
const root=resolve(import.meta.dir,'..'),local=resolve(root,'.local');await mkdir(local,{recursive:true,mode:0o700});
const files=['openobserve-v2.env','openobserve_root-v2.json','openobserve_ingest_auth-v2'];const present=await Promise.all(files.map(async f=>{try{await access(resolve(local,f));return true}catch{return false}}));
if(present.some(Boolean)&&!present.every(Boolean))throw new Error('Incomplete own OpenObserve bootstrap; preserve and inspect');
if(!present.some(Boolean)){const email='vp6-owner@example.invalid',password='Aa1!'+crypto.randomUUID()+crypto.randomUUID();const data=[`ZO_ROOT_USER_EMAIL=${email}\nZO_ROOT_USER_PASSWORD=${password}\n`,JSON.stringify({email,password})+'\n','Basic '+Buffer.from(email+':'+password).toString('base64')];for(let i=0;i<files.length;i++)await writeFile(resolve(local,files[i]),data[i],{flag:'wx',mode:files[i]==='openobserve_ingest_auth-v2'?0o644:0o600});console.log('Created isolated synthetic OpenObserve owner and temporary native probe ingest credential; Grafana does not use it.');}else console.log('Existing own OpenObserve bootstrap preserved.');
+36
View File
@@ -0,0 +1,36 @@
import { mkdir, writeFile, chmod, access } from 'node:fs/promises';
import { resolve } from 'node:path';
const root = resolve(import.meta.dir, '..');
const local = resolve(root, '.local');
const files = ['pg_password', 'database_url', 'cache_url', 'valkey.conf'];
const present = await Promise.all(files.map(async name => {try {await access(resolve(local, name));return true;} catch {return false;}}));
if (present.some(Boolean)) {
if (!present.every(Boolean)) throw new Error('Incomplete local configuration; preserve it and investigate before bootstrap');
console.log('Local configuration exists');
} else {
await mkdir(local, { recursive: true, mode: 0o700 });
const pg = crypto.randomUUID().replaceAll('-', '') + crypto.randomUUID().replaceAll('-', '');
const cache = crypto.randomUUID().replaceAll('-', '');
const values = [pg, `postgres://messenger:${pg}@postgres:5432/messenger?sslmode=disable`, `redis://:${cache}@valkey:6379/0`, `bind 0.0.0.0\nprotected-mode yes\nrequirepass ${cache}\nappendonly yes\nappendfsync always\ndir /data\n`];
for (let i = 0; i < files.length; i++) {
const destination = resolve(local, files[i]);
await writeFile(destination, values[i] + '\n', { mode: 0o600, flag: 'wx' });
await chmod(destination, 0o644); // Compose secrets must be readable by nonroot containers; parent is 0700.
}
console.log('Created local synthetic stand credentials');
}
const s3Files=['s3_access','s3_secret','s3_root','s3_credentials'];
const existing=await Promise.all(s3Files.map(async name=>{try{await access(resolve(local,name));return true;}catch{return false;}}));
if(existing.some(Boolean)&&!existing.every(Boolean))throw new Error('Incomplete S3 configuration; preserve it before investigation');
if(!existing.some(Boolean)){
const accessKey='root_'+crypto.randomUUID().replaceAll('-','');
const rootSecret=crypto.randomUUID().replaceAll('-','')+crypto.randomUUID().replaceAll('-','');
const appSecret=crypto.randomUUID().replaceAll('-','')+crypto.randomUUID().replaceAll('-','');
const common={Endpoint:'s3:9000',Bucket:'messenger'};
const values=[accessKey,rootSecret,JSON.stringify({...common,Access:accessKey,Secret:rootSecret}),JSON.stringify({...common,Access:'messenger-api',Secret:appSecret})];
for(let i=0;i<s3Files.length;i++)await writeFile(resolve(local,s3Files[i]),values[i]+'\n',{mode:0o644,flag:'wx'});
console.log('Created separate S3 root and scoped application credentials');
}
+3
View File
@@ -0,0 +1,3 @@
import{readFile,writeFile,mkdir}from'node:fs/promises';import{resolve}from'node:path';
const root=resolve(import.meta.dir,'..'),baselineBytes=await readFile(resolve(root,'BACKEND-READY.json')),baseline=JSON.parse(baselineBytes.toString()),backend=resolve(root,'backend');const changed=[];for(const [path,expected]of Object.entries(baseline.sourceHashes)){const target=resolve(backend,path);if(!target.startsWith(backend+'/'))throw new Error('backend manifest path outside owned source');const actual=new Bun.CryptoHasher('sha256').update(await readFile(target)).digest('hex');if(actual!==expected)changed.push(path);}
const output=resolve(root,'.local/backend-unchanged-'+crypto.randomUUID()+'.json');await mkdir(resolve(root,'.local'),{recursive:true,mode:0o700});const result={checkedAt:new Date().toISOString(),baselineManifestSHA256:new Bun.CryptoHasher('sha256').update(baselineBytes).digest('hex'),sourceFiles:Object.keys(baseline.sourceHashes).length,changed,unchanged:changed.length===0};await writeFile(output,JSON.stringify(result,null,2)+'\n',{flag:'wx',mode:0o600});console.log(JSON.stringify({receipt:output,...result}));if(changed.length)process.exitCode=1;
+12
View File
@@ -0,0 +1,12 @@
import {readFile,writeFile,statfs} from 'node:fs/promises';import {resolve} from 'node:path';
const root=resolve(import.meta.dir,'..'),receipt=process.argv[2];if(!receipt||!resolve(receipt).startsWith(root+'/.local/oci-copy-'))throw new Error('own copy receipt required');
const copy=JSON.parse(await readFile(receipt,'utf8'));const stats=JSON.parse(await readFile(copy.statReceipt,'utf8'));const discovery=JSON.parse(await readFile(stats.discovery,'utf8'));const image=discovery.images.find((i:any)=>i.id==='openobserve');
const missing=stats.blobs.filter((b:any)=>b.images.includes('openobserve')&&!b.present);const cap=10_784_147;if(missing.reduce((s:number,b:any)=>s+b.size,0)!==cap)throw new Error('approved byte set differs');const fs=await statfs(copy.output);if(fs.bavail*fs.bsize<2_000_000_000)throw new Error('insufficient own filesystem space');
async function bounded(response:Response,max:number){if(!response.ok||!response.body)throw new Error('public registry HTTP request failed');const chunks:Uint8Array[]=[];let size=0;for await(const part of response.body){size+=part.length;if(size>max)throw new Error('public response exceeds cap');chunks.push(part);}const output=new Uint8Array(size);let offset=0;for(const c of chunks){output.set(c,offset);offset+=c.length;}return output;}
const tokenResponse=await bounded(await fetch('https://public.ecr.aws/token/?service=public.ecr.aws&scope=repository%3Azinclabs%2Fopenobserve%3Apull',{signal:AbortSignal.timeout(20_000)}),32_768);const token=JSON.parse(new TextDecoder().decode(tokenResponse)).token;if(typeof token!=='string'||token.length<16)throw new Error('public registry pull token missing');
const downloaded=[];let networkBytes=tokenResponse.length;
for(const blob of missing){if(!/^sha256:[a-f0-9]{64}$/.test(blob.digest)||blob.size<=0||blob.size>cap)throw new Error('invalid approved descriptor');const bytes=await bounded(await fetch('https://public.ecr.aws/v2/zinclabs/openobserve/blobs/'+blob.digest,{headers:{Authorization:'Bearer '+token},signal:AbortSignal.timeout(60_000)}),blob.size);if(bytes.length!==blob.size||'sha256:'+new Bun.CryptoHasher('sha256').update(bytes).digest('hex')!==blob.digest)throw new Error('public blob digest/size mismatch');await writeFile(resolve(copy.output,'blobs/sha256',blob.digest.slice(7)),bytes,{flag:'wx',mode:0o600});networkBytes+=bytes.length;downloaded.push({digest:blob.digest,size:bytes.length,shaVerified:true});}
const manifest=await readFile(resolve(discovery.output,'openobserve-manifest.json'));if('sha256:'+new Bun.CryptoHasher('sha256').update(manifest).digest('hex')!==image.manifestDigest)throw new Error('manifest mismatch');await writeFile(resolve(copy.output,'blobs/sha256',image.manifestDigest.slice(7)),manifest,{flag:'wx',mode:0o600});
// Read every descriptor again: a complete local set, not download count, permits import.
for(const d of [image.manifest.config,...image.manifest.layers]){const b=await readFile(resolve(copy.output,'blobs/sha256',d.digest.slice(7)));if(b.length!==d.size||'sha256:'+new Bun.CryptoHasher('sha256').update(b).digest('hex')!==d.digest)throw new Error('complete local descriptor verification failed');}
await writeFile(resolve(copy.output,'OPENOBSERVE-COMPLETE.json'),JSON.stringify({checkedAt:new Date().toISOString(),copyReceipt:receipt,manifestDigest:image.manifestDigest,configDigest:image.manifest.config.digest,compressedDescriptorBytes:image.declaredBytes,downloaded,networkBlobBytes:cap,networkMetadataBytes:tokenResponse.length,networkBytes,complete:true,imported:false},null,2)+'\n',{flag:'wx',mode:0o600});console.log(JSON.stringify({receipt:resolve(copy.output,'OPENOBSERVE-COMPLETE.json'),networkBlobBytes:cap,networkMetadataBytes:tokenResponse.length,complete:true,imported:false}));
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
ROOT=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
exec docker compose --project-directory "$ROOT" -f "$ROOT/compose.yaml" -p mtuci-vp6-medvedev "$@"
+25
View File
@@ -0,0 +1,25 @@
import {mkdir,readFile,writeFile,lstat} from 'node:fs/promises';
import {resolve} from 'node:path';
const root=resolve(import.meta.dir,'..');const receipt=process.argv[2];
if(!receipt||!resolve(receipt).startsWith(root+'/.local/oci-stat-'))throw new Error('own cache stat receipt required');
const stat=JSON.parse(await readFile(receipt,'utf8'));const discovery=JSON.parse(await readFile(stat.discovery,'utf8'));
// The constant below uses the full inspected Docker ID, not a caller-supplied selector.
const exactNode='886f220356cb120754a29494f1e88ef63d95a00f8e588da79ee57d828e7b92a4';
function cmd(args:string[]){const r=Bun.spawnSync(args,{stdout:'pipe',stderr:'pipe'});if(r.exitCode!==0)throw new Error('public cache read/copy failed: '+args.slice(0,2).join(' '));return r.stdout;}
function guard(){const n=JSON.parse(new TextDecoder().decode(cmd(['docker','inspect',exactNode])))[0];if(n.Id!==exactNode||n.State.Running||n.State.Status!=='exited'||n.Config.Labels?.['k3d.cluster']!=='platform'||stat.node!==exactNode)throw new Error('source ownership/stopped guard');}
guard();const output=resolve(root,'.local/oci-copy-'+crypto.randomUUID());const blobs=resolve(output,'blobs/sha256');await mkdir(blobs,{recursive:true,mode:0o700});const copied=[];
const total=stat.blobs.filter((b:any)=>b.present).reduce((s:number,b:any)=>s+b.size,0);if(total>250_000_000)throw new Error('copy exceeds declared cap');
for(const blob of stat.blobs.filter((b:any)=>b.present)){
if(!/^sha256:[a-f0-9]{64}$/.test(blob.digest)||blob.source!=='/var/lib/rancher/k3s/agent/containerd/io.containerd.content.v1.content/blobs/sha256/'+blob.digest.slice(7)||!Number.isSafeInteger(blob.size)||blob.size<=0)throw new Error('unexpected public blob descriptor');
guard();const destination=resolve(blobs,blob.digest.slice(7));cmd(['docker','cp','-q',exactNode+':'+blob.source,destination]);const info=await lstat(destination);if(!info.isFile()||info.isSymbolicLink()||info.size!==blob.size)throw new Error('copied blob type/size mismatch');const bytes=await Bun.file(destination).arrayBuffer();if('sha256:'+new Bun.CryptoHasher('sha256').update(bytes).digest('hex')!==blob.digest)throw new Error('copied blob hash mismatch');copied.push({digest:blob.digest,size:info.size,shaVerified:true});
}
guard();const complete=[];
for(const image of discovery.images.filter((i:any)=>stat.images.find((s:any)=>s.id===i.id)?.complete)){
const raw=await readFile(resolve(discovery.output,image.id+'-manifest.json'));if('sha256:'+new Bun.CryptoHasher('sha256').update(raw).digest('hex')!==image.manifestDigest)throw new Error('manifest bytes mismatch');await writeFile(resolve(blobs,image.manifestDigest.slice(7)),raw,{flag:'wx',mode:0o600});
const ownLayout=resolve(output,image.id+'-layout');await mkdir(resolve(ownLayout,'blobs/sha256'),{recursive:true,mode:0o700});
// OCI load archive references only one checked image and its full content set.
for(const digest of [image.manifestDigest,image.manifest.config.digest,...image.manifest.layers.map((l:any)=>l.digest)])cmd(['cp','--reflink=auto',resolve(blobs,digest.slice(7)),resolve(ownLayout,'blobs/sha256',digest.slice(7))]);
await writeFile(resolve(ownLayout,'oci-layout'),JSON.stringify({imageLayoutVersion:'1.0.0'})+'\n',{flag:'wx'});const alias='docker.io/library/mtuci-vp6-'+image.id+'-cache:'+image.ref.split('@')[0].split(':').at(-1);await writeFile(resolve(ownLayout,'index.json'),JSON.stringify({schemaVersion:2,manifests:[{mediaType:image.manifest.mediaType,digest:image.manifestDigest,size:raw.length,platform:{os:'linux',architecture:'amd64'},annotations:{'io.containerd.image.name':alias,'org.opencontainers.image.ref.name':alias}}]})+'\n',{flag:'wx'});
const archive=resolve(output,image.id+'.oci.tar');cmd(['tar','-C',ownLayout,'-cf',archive,'oci-layout','index.json','blobs']);complete.push({id:image.id,alias,archive,manifestDigest:image.manifestDigest,configDigest:image.manifest.config.digest});
}
const result={checkedAt:new Date().toISOString(),statReceipt:receipt,output,node:exactNode,nodeStopped:true,sourceMutated:false,bytesCopied:total,copied,complete,imported:false};await writeFile(resolve(output,'COPY.json'),JSON.stringify(result,null,2)+'\n',{flag:'wx',mode:0o600});console.log(JSON.stringify({receipt:resolve(output,'COPY.json'),bytesCopied:total,complete,imported:false}));
+9
View File
@@ -0,0 +1,9 @@
import {mkdir,writeFile,readFile} from 'node:fs/promises';import {resolve} from 'node:path';
const root=resolve(import.meta.dir,'..'),output=resolve(root,'.local/oci-discovery-'+crypto.randomUUID());await mkdir(output,{recursive:true,mode:0o700});const config=resolve(output,'docker-config');await mkdir(config,{mode:0o700});await writeFile(resolve(config,'config.json'),'{}\n',{flag:'wx',mode:0o600});
function command(args:string[],env?:Record<string,string>){const r=Bun.spawnSync(args,{stdout:'pipe',stderr:'pipe',env:{...process.env,...env}});if(r.exitCode!==0)throw new Error('read-only image metadata command failed: '+args.slice(0,3).join(' '));return r.stdout}
const host=new TextDecoder().decode(command(['docker','context','inspect','--format','{{.Endpoints.docker.Host}}'])).trim();if(!host.startsWith('unix://'))throw new Error('unexpected Docker endpoint');const env={DOCKER_CONFIG:config,DOCKER_HOST:host};
const refs=[{id:'openobserve',ref:'public.ecr.aws/zinclabs/openobserve:v1.1.2@sha256:4a154849432f75c4fb024de32fe34163c02406c905dab22bf8d213d2e3386392'},{id:'collector',ref:'otel/opentelemetry-collector-k8s:0.163.2@sha256:cce4142919331aa26dd9e2900b0583dac12c44d2f87c270d3a2110912d4785a9'},{id:'grafana',ref:'grafana/grafana:13.3.1@sha256:1c88285f1dd391a62232c010e6c224846e6a73bdc583b3365be2eba614b7919e'}];
function sha(b:Uint8Array){return 'sha256:'+new Bun.CryptoHasher('sha256').update(b).digest('hex')};const images=[];
for(const item of refs){const raw=command(['docker','buildx','imagetools','inspect',item.ref,'--raw'],env);if(raw.length>1048576)throw new Error('registry metadata exceeds cap');const index=JSON.parse(new TextDecoder().decode(raw));const repo=item.ref.split('@')[0].replace(/:[^/]+$/,'');const selected=index.manifests?.find((d:any)=>d.platform?.os==='linux'&&d.platform?.architecture==='amd64');const digest=selected?.digest??item.ref.split('@')[1];if(!/^sha256:[a-f0-9]{64}$/.test(digest))throw new Error('invalid native manifest digest');const leafRaw=selected?command(['docker','buildx','imagetools','inspect',repo+'@'+digest,'--raw'],env):raw;if(leafRaw.length>1048576)throw new Error('leaf metadata exceeds cap');const leaf=JSON.parse(new TextDecoder().decode(leafRaw));if(!leaf.config?.digest||!Array.isArray(leaf.layers))throw new Error('missing OCI image descriptors');const descriptors=[leaf.config,...leaf.layers];for(const d of descriptors)if(!/^sha256:[a-f0-9]{64}$/.test(d.digest)||!Number.isSafeInteger(d.size)||d.size<0)throw new Error('invalid content descriptor');const bytes=descriptors.reduce((s:number,d:any)=>s+d.size,0);if(bytes>1073741824)throw new Error('single image exceeds discovery cap');await writeFile(resolve(output,item.id+'-index.json'),raw,{flag:'wx'});await writeFile(resolve(output,item.id+'-manifest.json'),leafRaw,{flag:'wx'});images.push({...item,repo,manifestDigest:digest,indexDigest:item.ref.split('@')[1],manifestDeclaredSize:selected?.size??null,rawIndexMatchesPinnedDigest:sha(raw)===item.ref.split('@')[1],rawManifestMatchesDigest:sha(leafRaw)===digest,manifest:leaf,declaredBytes:bytes});console.log(JSON.stringify({id:item.id,manifestDigest:digest,declaredBytes:bytes,rawManifestMatchesDigest:sha(leafRaw)===digest}));}
const node=JSON.parse(new TextDecoder().decode(command(['docker','inspect','k3d-platform-server-0'])))[0];if(node.State.Running||node.State.Status!=='exited'||node.Config.Labels?.['k3d.cluster']!=='platform'||!node.Config.Image.startsWith('rancher/k3s:'))throw new Error('stopped node ownership guard failed');
const result={checkedAt:new Date().toISOString(),scope:'public registry metadata only; no layer download, credentials, metadata.db, exec or cluster start',node:{id:node.Id,name:'k3d-platform-server-0',running:false,cluster:'platform'},dockerHost:host,output,images};await writeFile(resolve(output,'DISCOVERY.json'),JSON.stringify(result,null,2)+'\n',{flag:'wx',mode:0o600});console.log(JSON.stringify({discovery:resolve(output,'DISCOVERY.json'),layersDownloaded:0,sourceNodeStopped:true}));
+8
View File
@@ -0,0 +1,8 @@
import{mkdir,writeFile}from'node:fs/promises';import{resolve}from'node:path';
const root=resolve(import.meta.dir,'..'),output=resolve(root,'.local/image-manifests-'+crypto.randomUUID());await mkdir(output,{mode:0o700});const config=resolve(output,'docker-config');await mkdir(config,{mode:0o700});await writeFile(resolve(config,'config.json'),'{}\n',{flag:'wx',mode:0o600});
const hostRun=Bun.spawnSync(['docker','context','inspect','--format','{{.Endpoints.docker.Host}}'],{stdout:'pipe',stderr:'pipe'});if(hostRun.exitCode!==0)throw new Error('Docker endpoint preflight failed');const host=new TextDecoder().decode(hostRun.stdout).trim();if(!host.startsWith('unix://'))throw new Error('expected verified local Unix Docker endpoint');
const refs=[{id:'openobserve',sourceRef:'public.ecr.aws/zinclabs/openobserve:v1.1.2@sha256:4a154849432f75c4fb024de32fe34163c02406c905dab22bf8d213d2e3386392',localAlias:'docker.io/library/mtuci-vp6-openobserve-cache:v1.1.2'},{id:'collector',sourceRef:'otel/opentelemetry-collector-k8s:0.163.2@sha256:cce4142919331aa26dd9e2900b0583dac12c44d2f87c270d3a2110912d4785a9',localAlias:'docker.io/library/mtuci-vp6-collector-cache:0.163.2'},{id:'grafana',sourceRef:'grafana/grafana:13.3.1@sha256:1c88285f1dd391a62232c010e6c224846e6a73bdc583b3365be2eba614b7919e',localAlias:'docker.io/library/mtuci-vp6-grafana-cache:13.3.1'}];
function sha(bytes:Uint8Array){return'sha256:'+new Bun.CryptoHasher('sha256').update(bytes).digest('hex');}
async function inspect(ref:string,stage:string){const run=Bun.spawnSync(['docker','buildx','imagetools','inspect',ref,'--raw'],{stdout:'pipe',stderr:'pipe',env:{...process.env,DOCKER_CONFIG:config,DOCKER_HOST:host}});await writeFile(resolve(output,stage+'.stderr.private'),run.stderr,{flag:'wx',mode:0o600});if(run.exitCode!==0||run.stdout.length>1_048_576)throw new Error('public manifest read failed: '+stage+'; private receipt '+output);return run.stdout;}
const images=[];for(const item of refs){const raw=await inspect(item.sourceRef,item.id+'-index');const index=JSON.parse(new TextDecoder().decode(raw));if(sha(raw)!==item.sourceRef.split('@')[1])throw new Error('pinned source index SHA mismatch');const selected=index.manifests?.find((m:any)=>m.platform?.os==='linux'&&m.platform?.architecture==='amd64');const repo=item.sourceRef.split('@')[0].replace(/:[^/]+$/,'');const digest=selected?.digest??item.sourceRef.split('@')[1];const leafRaw=selected?await inspect(repo+'@'+digest,item.id+'-leaf'):raw;if(sha(leafRaw)!==digest)throw new Error('native manifest SHA mismatch');const leaf=JSON.parse(new TextDecoder().decode(leafRaw));const layers=leaf.layers.reduce((n:number,l:any)=>n+l.size,0);const local=Bun.spawnSync(['docker','image','inspect',item.localAlias,'--format','{{.Id}}'],{stdout:'pipe',stderr:'pipe'});images.push({...item,linuxAmd64Manifest:digest,configDigest:leaf.config.digest,configBytes:leaf.config.size,compressedLayerBytes:layers,compressedDescriptorBytes:layers+leaf.config.size,platform:'linux/amd64',dockerCachePresent:local.exitCode===0,layerDownloadPerformed:false});}
const manifest={checkedAt:new Date().toISOString(),scope:'official immutable public OCI manifest metadata; no new layers',images,plugin:{repository:'Windforce17/openobserve-grafana-plugin',version:'1.0.1',commit:'e10214739827dda9318705d49db262b28d67bcfe',assetBytes:52781711,assetSHA256:'e0c2cbcc7cf6d05bcfaa606db39e52249eb0dd234376e45a3f896353831c2fd5',downloadedByThisCheck:false},metadataReceipt:output};await writeFile(resolve(root,'IMAGE-MANIFEST.json'),JSON.stringify(manifest,null,2)+'\n');console.log(JSON.stringify({images:images.map(i=>({id:i.id,compressedDescriptorBytes:i.compressedDescriptorBytes,dockerCachePresent:i.dockerCachePresent})),layersDownloaded:0,manifest:resolve(root,'IMAGE-MANIFEST.json')}));
+2
View File
@@ -0,0 +1,2 @@
import {writeFile,mkdir} from 'node:fs/promises';import {resolve} from 'node:path';
const root=resolve(import.meta.dir,'..'),output=resolve(root,'.local/openobserve-start-'+crypto.randomUUID());await mkdir(output,{mode:0o700});const name='mtuci-vp6-medvedev-openobserve-1';const r=Bun.spawnSync(['docker','inspect',name],{stdout:'pipe',stderr:'pipe'});if(r.exitCode!==0)throw new Error('own container absent');const n=JSON.parse(new TextDecoder().decode(r.stdout))[0];if(n.Config.Labels['com.docker.compose.project']!=='mtuci-vp6-medvedev'||n.Config.Labels['com.docker.compose.service']!=='openobserve')throw new Error('ownership mismatch');const logs=Bun.spawnSync(['docker','logs','--tail','100',name],{stdout:'pipe',stderr:'pipe'});const content=Buffer.concat([logs.stdout,logs.stderr]);await writeFile(resolve(output,'logs.private'),content,{flag:'wx',mode:0o600});const text=new TextDecoder().decode(content);const categories=['Permission denied','permission denied','Read-only file system','readonly database','No such file or directory','Invalid','panicked','Error','error','sqlite','not found','failed','OOM'].filter(s=>text.includes(s));const safe={checkedAt:new Date().toISOString(),id:n.Id,status:n.State.Status,exitCode:n.State.ExitCode,oom:n.State.OOMKilled,categories,privateLog:resolve(output,'logs.private')};await writeFile(resolve(output,'RESULT.json'),JSON.stringify(safe,null,2)+'\n',{flag:'wx',mode:0o600});console.log(JSON.stringify(safe));
+19
View File
@@ -0,0 +1,19 @@
export type BrowserPrimaryFailure={error:unknown};
export type BrowserLifecyclePorts<C,R>={acquire():Promise<C>;run(context:C):Promise<R>;close(context:C):Promise<void>;reportResult(result:R|undefined,primary?:BrowserPrimaryFailure):Promise<void>;reportSecondaryFailure(kind:'report'|'close',error:unknown):Promise<void>};
// Local adaptation of the sibling acquire/run/close contract. Result reporting
// occurs after close, so a failing writer cannot extend the browser lifetime.
export function createBrowserLifecycle<C,R>(ports:BrowserLifecyclePorts<C,R>){
if(!ports||[ports.acquire,ports.run,ports.close,ports.reportResult,ports.reportSecondaryFailure].some(port=>typeof port!=='function'))throw Error('BROWSER_LIFECYCLE_PORTS_REQUIRED');
const secondary=async(kind:'report'|'close',error:unknown)=>{try{await ports.reportSecondaryFailure(kind,error)}catch{/* Secondary reporting never replaces an owned primary failure. */}};
return async()=>{
let result:R|undefined,primary:unknown,cleanup:unknown,failed=false,cleanupFailed=false;
const context=await ports.acquire();
try{try{result=await ports.run(context)}catch(error){primary=error;failed=true}}
finally{try{await ports.close(context)}catch(error){cleanup=error;cleanupFailed=true}}
if(cleanupFailed)await secondary('close',cleanup);
try{await ports.reportResult(result,failed?{error:primary}:undefined)}catch(error){await secondary('report',error);if(!failed&&!cleanupFailed){primary=error;failed=true}}
if(failed)throw primary;
if(cleanupFailed)throw cleanup;
return result as R;
};
}
+5
View File
@@ -0,0 +1,5 @@
export type GrafanaCredentialPorts={read():Promise<string|undefined>;generate():string;archive(value:string):Promise<void>;publish(value:string):Promise<void>};
export function createGrafanaCredentialBootstrap(ports:GrafanaCredentialPorts){
if(['read','generate','archive','publish'].some(key=>typeof ports?.[key]!=='function'))throw new Error('All Grafana credential ports required');
return async()=>{const existing=await ports.read(),value=existing??ports.generate();if(!/^[!-~]{16,128}$/.test(value))throw new Error('Invalid Grafana owner credential');await ports.archive(value);if(existing===undefined)await ports.publish(value);};
}
+13
View File
@@ -0,0 +1,13 @@
export function dashboardMatches(actual:any,expected:any):boolean{
const panels=actual?.dashboard?.panels,configured=expected?.panels;
if(typeof expected?.uid!=='string'||actual?.dashboard?.uid!==expected.uid||!Array.isArray(panels)||!Array.isArray(configured)||!configured.length||panels.length!==configured.length)return false;
const valid=(p:any)=>Number.isSafeInteger(p?.id)&&p.id>0&&typeof p.title==='string'&&p.title.length>0;
if(!configured.every(valid)||!panels.every(valid))return false;
const wanted=new Map(configured.map(p=>[p.id,p.title]));
return wanted.size===configured.length&&new Set(panels.map(p=>p.id)).size===panels.length&&panels.every(p=>wanted.get(p.id)===p.title);
}
export function rulesMatch(actual:any,expected:string[]):boolean{
if(!Array.isArray(actual)||!Array.isArray(expected)||!expected.length||actual.length!==expected.length||!expected.every(v=>typeof v==='string'&&v.length>0))return false;
const wanted=new Set(expected),got=new Set(actual.map(row=>row?.uid));
return wanted.size===expected.length&&got.size===actual.length&&[...got].every(uid=>wanted.has(uid));
}
+5
View File
@@ -0,0 +1,5 @@
// Native13.3.1 rejects1s groups and accepts10s. Public-tag setting_unified_alerting.go is reference only; the reported deployed commit differs.
export function validateGrafanaRuleIntervals(groups:readonly {interval:string}[],baseSeconds:number):void{
if(!Number.isSafeInteger(baseSeconds)||baseSeconds<=0||!Array.isArray(groups)||!groups.length)throw new Error('Native Grafana scheduler contract missing');
for(const group of groups){const m=/^(\d+)(s|m)$/.exec(group.interval??''),seconds=m?Number(m[1])*(m[2]==='m'?60:1):NaN;if(!Number.isSafeInteger(seconds)||seconds<baseSeconds||seconds%baseSeconds!==0)throw new Error('Grafana rule group interval must be a positive native scheduler multiple');}
}
+12
View File
@@ -0,0 +1,12 @@
export type IncidentSample={at:string;phase:string;rules:{name:string;state:string}[]};
export type AcceptedFact={id:string;status:string;accepted_at:string;first_ready_at:string;ready_seconds:number};
export function readyIncidentObserved(samples:IncidentSample[],facts:AcceptedFact[],ids:string[],stoppedAt:string,restoredAt:string){
const stop=Date.parse(stoppedAt),restart=Date.parse(restoredAt),expected=new Set(ids);
if(!Number.isFinite(stop)||!Number.isFinite(restart)||restart<stop||!expected.size||expected.size!==ids.length||facts.length!==expected.size||new Set(facts.map(f=>f.id)).size!==facts.length)return false;
let firstAccepted=Infinity,lastReady=-Infinity;
for(const f of facts){const accepted=Date.parse(f.accepted_at),ready=Date.parse(f.first_ready_at);if(!expected.has(f.id)||f.status!=='ready'||!Number.isFinite(accepted)||!Number.isFinite(ready)||accepted<stop||accepted>restart||ready<accepted||!Number.isFinite(f.ready_seconds)||f.ready_seconds<=10)return false;firstAccepted=Math.min(firstAccepted,accepted);lastReady=Math.max(lastReady,ready);}
// A process restart does not make its accepted backlog ready. Bound the readback by
// actual immutable job facts plus the configured cohort/evaluation/export budgets.
return samples.some(s=>{const at=Date.parse(s.at);return Number.isFinite(at)&&at>=firstAccepted+10000&&at<=lastReady+44000&&['worker_stopped','worker_recovery'].includes(s.phase)&&s.rules.some(r=>r.name==='MessengerReadyErrorBudgetBurn'&&r.state==='Alerting');});
}
export function drained(values:number[]){return values.length>0&&values.every(v=>Number.isFinite(v)&&v===0);}
+48
View File
@@ -0,0 +1,48 @@
export type AccountResponse = { status: number; chunks: AsyncIterable<Uint8Array> };
export type AccountRequest = { captureId: string; path: string; method: string; body?: unknown; auth: string };
export type AccountCapture = { captureId: string; raw: Uint8Array; status: number | null; outcome: string; complete: boolean };
export type AccountHTTPPorts = {
request(input: AccountRequest): Promise<AccountResponse>;
capture(input: AccountCapture): Promise<void>;
};
export class AccountHTTPError extends Error {
constructor(readonly stage: string, readonly captureFailed = false) {
super('Account HTTP outcome: ' + stage + (captureFailed ? '; private capture failed' : ''));
}
}
export function createAccountHTTP(ports: AccountHTTPPorts, maxBytes: number) {
if (!ports?.request || !ports?.capture || !Number.isSafeInteger(maxBytes) || maxBytes < 1 || maxBytes > 1_048_576) throw new Error('Invalid account HTTP ports or bound');
return async (input: AccountRequest) => {
const chunks: Uint8Array[] = [];
let size = 0, status: number | null = null, stage = 'network_uncertain';
const joined = () => {
const raw = new Uint8Array(size);
let offset = 0;
for (const chunk of chunks) { raw.set(chunk, offset); offset += chunk.length; }
return raw;
};
try {
const response = await ports.request(input);
status = response.status;
stage = 'body_uncertain';
for await (const chunk of response.chunks) {
const available = Math.min(chunk.length, maxBytes - size);
if (available > 0) { chunks.push(chunk.slice(0, available)); size += available; }
if (available < chunk.length) { stage = 'size_exceeded'; throw new AccountHTTPError(stage); }
}
} catch {
let captureFailed = false;
try { await ports.capture({ captureId: input.captureId, raw: joined(), status, outcome: stage, complete: false }); }
catch { captureFailed = true; }
// No retry: the remote POST may already have created the account.
throw new AccountHTTPError(stage, captureFailed);
}
const raw = joined();
try { await ports.capture({ captureId: input.captureId, raw, status, outcome: 'response_complete', complete: true }); }
catch { throw new AccountHTTPError('capture_failed', true); }
let body: unknown;
try { body = size ? JSON.parse(new TextDecoder().decode(raw)) : null; }
catch { throw new AccountHTTPError('invalid_json'); }
return { status: status!, body: body as any };
};
}
+35
View File
@@ -0,0 +1,35 @@
export type AccountKey = 'ingest' | 'query';
export type Account = { email: string; token: string };
export type Intent = { email: string; rawFile: string; captureId: string };
export type Capability = { role: string; searchHTTP: number; searchHasRows: boolean; ingestHTTP: number; adminRotateHTTP: number };
export type CreateResult = { status: number | null; body: any };
export type BootstrapPorts = {
readIndex(): Promise<Record<AccountKey, Account> | undefined>;
readAccount(key: AccountKey): Promise<Account | undefined>;
readIntent(key: AccountKey): Promise<Intent | undefined>;
makeIntent(key: AccountKey): Intent;
claimIntent(key: AccountKey, intent: Intent): Promise<void>;
readCaptured(intent: Intent): Promise<CreateResult | undefined>;
create(key: AccountKey, intent: Intent): Promise<CreateResult>;
saveAccount(key: AccountKey, account: Account): Promise<void>;
verify(key: AccountKey, account: Account): Promise<Capability>;
publishIndex(accounts: Record<AccountKey, Account>): Promise<void>;
publishDerived(accounts: Record<AccountKey, Account>): Promise<void>;
};
export const accountEmail = (key: AccountKey) => 'vp6-' + key + '@lab.invalid';
function candidate(key:AccountKey,response:CreateResult):Account{if(![200,null].includes(response.status)||response.body?.code!==200||response.body?.user!==accountEmail(key)||typeof response.body?.token!=="string"||!/^[A-Za-z0-9_-]{16,256}$/.test(response.body.token))throw new Error("Captured native account response is not recoverable; no POST retry");return{email:response.body.user,token:response.body.token};}
function validateAccount(key:AccountKey,account:Account){if(account?.email!==accountEmail(key)||typeof account?.token!=="string"||!/^[A-Za-z0-9_-]{16,256}$/.test(account.token))throw new Error("Private account checkpoint invalid; no POST retry");}
export function createAccountBootstrap(ports:BootstrapPorts){
const names:(keyof BootstrapPorts)[]=["readIndex","readAccount","readIntent","makeIntent","claimIntent","readCaptured","create","saveAccount","verify","publishIndex","publishDerived"];if(names.some(name=>typeof ports?.[name]!=="function"))throw new Error("All bootstrap ports are required");
return async()=>{const previous=await ports.readIndex(),accounts={} as Record<AccountKey,Account>,proofs=[];
for(const key of ["ingest","query"] as const){let account=await ports.readAccount(key)??previous?.[key];
if(!account){const retained=await ports.readIntent(key);if(retained){if(retained.email!==accountEmail(key))throw new Error("Private account intent identity mismatch");const captured=await ports.readCaptured(retained);if(!captured)throw new Error("Uncertain account creation retained; inspect captured bytes, never repeat POST automatically");account=candidate(key,captured);}else{const intent=ports.makeIntent(key);if(intent.email!==accountEmail(key))throw new Error("New account intent identity mismatch");await ports.claimIntent(key,intent);const created=await ports.create(key,intent);if(created.status!==200)throw new Error("Native account create was not accepted; retained intent prevents automatic retry");account=candidate(key,created);}}
validateAccount(key,account);
// A received credential is durable before the next create, including when its live probe fails.
await ports.saveAccount(key,account);
const proof=await ports.verify(key,account);if(proof.role!=="service_account"||proof.searchHTTP!==200||!proof.searchHasRows||proof.ingestHTTP!==200||proof.adminRotateHTTP!==403)throw new Error("Native account capability verification failed; derived credentials/start are not published");
accounts[key]=account;proofs.push({principal:key,...proof});
}
await ports.publishIndex(accounts);await ports.publishDerived(accounts);return{accounts,proofs};
};
}
+7
View File
@@ -0,0 +1,7 @@
export type FaultPorts<L,T>={acquire():Promise<L>;exercise(lease:L):Promise<T>;restore(lease:L):Promise<void>};
export class OwnedFaultFailure extends Error{constructor(readonly primary:unknown,readonly cleanup:unknown){super('Owned fault execution or restoration failed');}}
// Ownership acquisition is read-only; every mutation belongs in exercise so restoration is already registered.
export function createOwnedFaultRunner<L,T>(ports:FaultPorts<L,T>){
if(!ports?.acquire||!ports?.exercise||!ports?.restore)throw new Error('All owned-fault ports required');
return async()=>{const lease=await ports.acquire();let result:T|undefined,primary:unknown,cleanup:unknown,failed=false,cleanupFailed=false;try{result=await ports.exercise(lease)}catch(error){primary=error;failed=true}try{await ports.restore(lease)}catch(error){cleanup=error;cleanupFailed=true}if(failed||cleanupFailed)throw new OwnedFaultFailure(primary,cleanup);return result as T;};
}
+7
View File
@@ -0,0 +1,7 @@
import{readdir,readFile,mkdir,writeFile,copyFile}from'node:fs/promises';import{resolve,relative,dirname}from'node:path';
if(process.argv.includes('--check')){console.log('Source ZIP packager validated without writes; actual archive CRC/source hashes are checked separately');process.exit(0)}if(!process.argv.includes('--build'))throw Error('Explicit --build required');
const root=resolve(import.meta.dir,'..'),id=crypto.randomUUID(),stage=resolve(root,'.local/package-'+id),destination=resolve(root,'submission/final-'+id),blocked=new Set(['.git','.local','.venv','__pycache__','node_modules','submission','secrets','.DS_Store']),files:string[]=[];
async function walk(directory:string){for(const entry of await readdir(directory,{withFileTypes:true})){if(blocked.has(entry.name))continue;const source=resolve(directory,entry.name),name=relative(root,source);if(entry.isSymbolicLink())throw Error('Unexpected symlink in public source');if(entry.isDirectory()){await walk(source);continue}if(!entry.isFile()||name==='SUBMISSION-MANIFEST.json'||entry.name.endsWith('.test')||entry.name.endsWith('.zip'))continue;if(entry.name==='.env'||(entry.name.startsWith('.env.')&&entry.name!=='.env.example')||/\.private(?:\.|$)|\.(age|agekey|pem|key|p12|pfx|dump)$/.test(name)||/[\r\n\0]/.test(name))throw Error('Private/unsafe artifact path in submission source');files.push(name)}}
await walk(root);files.sort();await mkdir(stage,{recursive:true,mode:0o700});await mkdir(destination,{recursive:true});const fileHashes:Record<string,string>={};for(const name of files){const bytes=await readFile(resolve(root,name));fileHashes[name]=new Bun.CryptoHasher('sha256').update(bytes).digest('hex');await mkdir(dirname(resolve(stage,name)),{recursive:true});await copyFile(resolve(root,name),resolve(stage,name));}
const manifest={createdAt:new Date().toISOString(),assignment:'VP Lab6',student:'Медведев Андрей Михайлович, БПИ2303',target:'5, track2 SLO/incident detection; no awarded grade or instructor acceptance claimed',sourceOfCurrentResults:'REPORT.md',knownBrowserLimit:'Three functional UI scenarios completed; strict aggregate browser command retains one nonblocking canceled static sync.svg fetch, exact trigger unconfirmed; no clean-network PASS claimed',fileHashes};await writeFile(resolve(stage,'SUBMISSION-MANIFEST.json'),JSON.stringify(manifest,null,2)+'\n',{flag:'wx'});files.push('SUBMISSION-MANIFEST.json');
const archive=resolve(destination,'VP_Lab6_Medvedev_BPI2303.zip');if(await Bun.file(archive).exists())throw Error('Archive already exists; preserve historical artifact');const result=Bun.spawnSync(['zip','-q','-X',archive,...files],{cwd:stage,stdout:'pipe',stderr:'pipe'});if(result.exitCode!==0)throw Error('Native ZIP creation failed');const receipt={createdAt:new Date().toISOString(),archive,files:files.length,bytes:Bun.file(archive).size,sha256:new Bun.CryptoHasher('sha256').update(await Bun.file(archive).arrayBuffer()).digest('hex'),sourceManifestSHA256:new Bun.CryptoHasher('sha256').update(await Bun.file(resolve(stage,'SUBMISSION-MANIFEST.json')).arrayBuffer()).digest('hex'),stage,validation:'Pending separate native unzip CRC/path/exact per-file hash verification'};await writeFile(resolve(destination,'DELIVERY.json'),JSON.stringify(receipt,null,2)+'\n',{flag:'wx'});console.log(JSON.stringify(receipt));
+6
View File
@@ -0,0 +1,6 @@
import{validateGrafanaRuleIntervals}from'./lib/grafana-scheduler';
const images=[['docker.io/library/mtuci-vp6-openobserve-cache:v1.1.2','sha256:26618f379c86b253c0d91624c487dd14b71293699845ecbc8457c94dca14819f'],['docker.io/library/mtuci-vp6-collector-cache:0.163.2','sha256:a65df9129a5b3f99ee4434c5e53aee1965ff0129eda6a2da75ea917165b7fa6b']];
if(process.argv.includes('--grafana')){validateGrafanaRuleIntervals((Bun.YAML.parse(await Bun.file(new URL('../config/grafana/provisioning/alerting/rules.yaml',import.meta.url)).text()) as {groups:{interval:string}[]}).groups,10);const root=new URL('../.local/grafana-plugins/openobserve/',import.meta.url);for(const [name,hash]of Object.entries({'plugin.json':'8bec0fc6e3069122c970decc8f62b002cce63441fe8592a1b17349becbea844f','module.js':'7c43a8842a97f722e2de0ff2ff4512d84e5cd91a7d75594b10c2677c7d63fe0c','gpx_openobserve_linux_amd64':'dc91fdfaf25708cb2573c4e533754cb5cc5ecd02d43beb7ee21bee06fbc09c50'})){if(new Bun.CryptoHasher('sha256').update(await Bun.file(new URL(name,root)).arrayBuffer()).digest('hex')!==hash)throw new Error('Required verified plugin bytes missing/mismatched: '+name)}}
if(process.argv.includes('--grafana'))images.push(['docker.io/library/mtuci-vp6-grafana-cache:13.3.1','sha256:1c88285f1dd391a62232c010e6c224846e6a73bdc583b3365be2eba614b7919e']);
for(const [image,expected]of images){const r=Bun.spawnSync(['docker','image','inspect',image,'--format','{{.Id}}|{{.Architecture}}|{{.Os}}'],{stdout:'pipe',stderr:'pipe'});if(r.exitCode!==0||new TextDecoder().decode(r.stdout).trim()!==expected+'|amd64|linux')throw new Error('Required verified cached image missing/mismatched; no automatic pull: '+image);}
console.log(JSON.stringify({verifiedCachedImages:images.length,pulled:false}));
+6
View File
@@ -0,0 +1,6 @@
import {mkdir,readFile,writeFile} from 'node:fs/promises';import {resolve} from 'node:path';
const root=resolve(import.meta.dir,'..'),path=process.argv[2],id=process.argv[3];if(!path||!resolve(path).startsWith(root+'/.local/oci-copy-')||!['openobserve','collector'].includes(id))throw new Error('owned complete cache required');
const copy=JSON.parse(await readFile(path,'utf8')),stats=JSON.parse(await readFile(copy.statReceipt,'utf8')),discovery=JSON.parse(await readFile(stats.discovery,'utf8'));const image=discovery.images.find((i:any)=>i.id===id);const output=resolve(copy.output,id+'-import-'+crypto.randomUUID());await mkdir(resolve(output,'layout/blobs/sha256'),{recursive:true,mode:0o700});
for(const d of [{digest:image.manifestDigest,size:(await readFile(resolve(discovery.output,id+'-manifest.json'))).length},image.manifest.config,...image.manifest.layers]){const bytes=await readFile(resolve(copy.output,'blobs/sha256',d.digest.slice(7)));if(bytes.length!==d.size||'sha256:'+new Bun.CryptoHasher('sha256').update(bytes).digest('hex')!==d.digest)throw new Error('incomplete or corrupted OCI content');await writeFile(resolve(output,'layout/blobs/sha256',d.digest.slice(7)),bytes,{flag:'wx',mode:0o600});}
const alias='docker.io/library/mtuci-vp6-'+id+'-cache:'+image.ref.split('@')[0].split(':').at(-1);await writeFile(resolve(output,'layout/oci-layout'),JSON.stringify({imageLayoutVersion:'1.0.0'})+'\n',{flag:'wx'});await writeFile(resolve(output,'layout/index.json'),JSON.stringify({schemaVersion:2,manifests:[{mediaType:image.manifest.mediaType,digest:image.manifestDigest,size:(await readFile(resolve(discovery.output,id+'-manifest.json'))).length,platform:{os:'linux',architecture:'amd64'},annotations:{'io.containerd.image.name':alias,'org.opencontainers.image.ref.name':alias}}]})+'\n',{flag:'wx'});
const archive=resolve(output,id+'.oci.tar');const r=Bun.spawnSync(['tar','-C',resolve(output,'layout'),'-cf',archive,'oci-layout','index.json','blobs'],{stdout:'pipe',stderr:'pipe'});if(r.exitCode!==0)throw new Error('OCI archive failed');await writeFile(resolve(output,'IMPORT-READY.json'),JSON.stringify({checkedAt:new Date().toISOString(),copyReceipt:path,id,alias,manifestDigest:image.manifestDigest,configDigest:image.manifest.config.digest,completeRehashed:true,archive,imported:false},null,2)+'\n',{flag:'wx',mode:0o600});console.log(JSON.stringify({receipt:resolve(output,'IMPORT-READY.json'),archive,alias,manifestDigest:image.manifestDigest}));
+53
View File
@@ -0,0 +1,53 @@
import {createAccountHTTP} from './lib/openobserve-account-http';
import {createAccountBootstrap,accountEmail,type AccountKey,type Account,type Intent} from './lib/openobserve-bootstrap';
import {mkdir,readFile,writeFile,link,open} from 'node:fs/promises';
import {resolve} from 'node:path';
const root=resolve(import.meta.dir,'..'),local=resolve(root,'.local');
if(process.argv.includes('--dry-run')){console.log('Validated native fixed localhost service-account provisioning invocation; no credential reads or mutations.');process.exit(0);}
const endpoint='http://127.0.0.1:28406';
const inspect=Bun.spawnSync(['docker','inspect','mtuci-vp6-medvedev-openobserve-1'],{stdout:'pipe',stderr:'pipe'});
if(inspect.exitCode!==0)throw new Error('own OpenObserve missing');
const n=JSON.parse(new TextDecoder().decode(inspect.stdout))[0];
if(!n.State.Running||n.Config.Labels['com.docker.compose.project']!=='mtuci-vp6-medvedev'||n.Image!=='sha256:26618f379c86b253c0d91624c487dd14b71293699845ecbc8457c94dca14819f')throw new Error('own OpenObserve identity mismatch');
const output=resolve(local,'openobserve-accounts-'+crypto.randomUUID());
await mkdir(output,{mode:0o700});
await writeFile(resolve(output,'CLAIM.json'),JSON.stringify({claimedAt:new Date().toISOString(),scope:'isolated default organization; owned ingest/query service accounts'})+'\n',{flag:'wx',mode:0o600});
const owner=JSON.parse(await readFile(resolve(local,'openobserve_root-v2.json'),'utf8'));
const ownerAuth='Basic '+Buffer.from(owner.email+':'+owner.password).toString('base64');
let responseSequence=0;
const accountHTTP=createAccountHTTP({request:async input=>{const response=await fetch(endpoint+input.path,{method:input.method,headers:{Authorization:input.auth,'Content-Type':'application/json'},body:input.body===undefined?undefined:JSON.stringify(input.body),signal:AbortSignal.timeout(10_000)});return{status:response.status,chunks:response.body??(async function*(){})()};},capture:async capture=>{
if(!/^(response-[0-9]{3}|create-(ingest|query))$/.test(capture.captureId))throw new Error('Invalid private capture identity');
const prefix=resolve(output,capture.captureId);
const raw=await open(prefix+'.raw.private','wx',0o600);try{await raw.writeFile(capture.raw);await raw.sync();}finally{await raw.close();}
try{await writeFile(prefix+'.meta.json',JSON.stringify({status:capture.status,outcome:capture.outcome,complete:capture.complete,bytes:capture.raw.length})+'\n',{flag:'wx',mode:0o600});}catch{/* Durable raw capture owns the primary outcome. */}
}},1_048_576);
async function call(path:string,method='GET',body?:unknown,auth=ownerAuth,captureId='response-'+String(++responseSequence).padStart(3,'0')){return accountHTTP({path,method,body,auth,captureId});}
async function readPrivate(path:string){try{return JSON.parse(await readFile(path,'utf8'));}catch(error){if((error as any).code==='ENOENT')return undefined;throw new Error('Private bootstrap record is malformed; preserve it and inspect privately');}}
// Fully written and synced bytes become visible atomically; an earlier claim is never overwritten.
async function publish(path:string,value:unknown){const text=JSON.stringify(value)+'\n';const staged=resolve(output,'staged-'+crypto.randomUUID()+'.private');const file=await open(staged,'wx',0o600);try{await file.writeFile(text);await file.sync();}finally{await file.close();}try{await link(staged,path);}catch(error){if((error as any).code!=='EEXIST')throw error;const previous=await readPrivate(path);if(JSON.stringify(previous)!==JSON.stringify(value))throw new Error('Private bootstrap record conflicts; no overwrite or POST retry');}}
const accountsFile=resolve(local,'openobserve-accounts.json');
const checkpoint=(key:AccountKey)=>resolve(local,'openobserve-account-'+key+'.json');
const intentFile=(key:AccountKey)=>resolve(local,'openobserve-account-'+key+'.intent.json');
function members(body:any){const result=body?.data??body?.list??body;if(!Array.isArray(result))throw new Error('Native account list shape unexpected');return result;}
const initial=await call('/api/default/service_accounts');if(initial.status!==200)throw new Error('Native service-account list unavailable');
const initialMembers=members(initial.body);
const users=await call('/api/default/users');if(users.status!==200||!members(users.body).some((u:any)=>u.email===owner.email&&u.role==='root'))throw new Error('Native owner/root role readback required');
const run=createAccountBootstrap({
readIndex:()=>readPrivate(accountsFile),readAccount:key=>readPrivate(checkpoint(key)),readIntent:key=>readPrivate(intentFile(key)),
makeIntent:key=>({email:accountEmail(key),rawFile:resolve(output,'create-'+key+'.raw.private'),captureId:'create-'+key}),
claimIntent:async(key,intent)=>{if(initialMembers.some((u:any)=>u.email===intent.email))throw new Error('Native account exists without an owned credential or creation intent; no POST retry');await publish(intentFile(key),intent);},
readCaptured:async(intent:Intent)=>{if(!intent.rawFile.startsWith(local+'/openobserve-accounts-')||!intent.rawFile.endsWith('/'+intent.captureId+'.raw.private')||!/^create-(ingest|query)$/.test(intent.captureId))throw new Error('Private creation capture path outside owned operation');const body=await readPrivate(intent.rawFile);if(body===undefined)return undefined;const meta=await readPrivate(intent.rawFile.replace('.raw.private','.meta.json'));return{body,status:meta?.status??null};},
create:(key,intent)=>call('/api/default/service_accounts','POST',{email:accountEmail(key),first_name:'VP6 '+key,last_name:'synthetic'},ownerAuth,intent.captureId),
saveAccount:(key,account)=>publish(checkpoint(key),account),
verify:async(key,account:Account)=>{const roles=await call('/api/default/service_accounts');if(roles.status!==200)throw new Error('Native account role readback failed');const role=members(roles.body).find((u:any)=>u.email===account.email)?.role;if(role!=='service_account')throw new Error('Native account role is not service_account; no administrative probe');
const auth='Basic '+Buffer.from(account.email+':'+account.token).toString('base64'),event='owned_'+key+'_positive_control';
const ingest=await call('/api/default/identity_probe/_json','POST',[{event}],auth);
let search:any={status:0,body:null};if(ingest.status===200){for(let attempt=0;attempt<6;attempt++){search=await call('/api/default/_search?type=logs','POST',{query:{sql:'SELECT event FROM "identity_probe" WHERE event=\''+event+'\' LIMIT 1',start_time:(Date.now()-60_000)*1000,end_time:(Date.now()+1000)*1000,size:1}},auth);if(search.status!==200||search.body?.hits?.some((row:any)=>row.event===event))break;if(attempt<5)await Bun.sleep(400);}}
const rotate=await call('/api/default/service_accounts/'+encodeURIComponent(accountEmail('query'))+'?rotateToken=true','PUT',{first_name:'VP6 query',last_name:'synthetic'},auth);
return{role,searchHTTP:search.status,searchHasRows:Array.isArray(search.body?.hits)&&search.body.hits.some((row:any)=>row.event===event),ingestHTTP:ingest.status,adminRotateHTTP:rotate.status};},
publishIndex:accounts=>publish(accountsFile,accounts),
publishDerived:async()=>{const rendered=Bun.spawnSync([process.execPath,resolve(root,'scripts/render-openobserve-credentials.ts')],{cwd:root,stdout:'pipe',stderr:'pipe'});if(rendered.exitCode!==0){await writeFile(resolve(output,'render-stderr.private'),rendered.stderr,{flag:'wx',mode:0o600});throw new Error('Dedicated credential render failed; core startup must stop');}},
});
const {proofs}=await run();const result={checkedAt:new Date().toISOString(),endpoint,organization:'default',createRoute:'POST /api/{org}/service_accounts',createRequestFields:['email','first_name','last_name'],createResponseFields:['code','message','token','user'],probes:proofs,privateCredentials:accountsFile,output,strictCapabilitiesVerified:true,durablePerAccountCheckpoints:true};
await writeFile(resolve(output,'RESULT.json'),JSON.stringify(result,null,2)+'\n',{flag:'wx',mode:0o600});
console.log(JSON.stringify({checkedAt:result.checkedAt,probes:proofs,receipt:resolve(output,'RESULT.json'),credentialsPrinted:false}));
@@ -0,0 +1,5 @@
import {readFile,writeFile} from 'node:fs/promises';import {resolve} from 'node:path';
const root=resolve(import.meta.dir,'..');if(process.argv.includes('--dry-run')){console.log('Validated dedicated native service-account renderer; no credential reads or writes.');process.exit(0);}
const accounts=JSON.parse(await readFile(resolve(root,'.local/openobserve-accounts.json'),'utf8'));for(const label of ['query','ingest']){const a=accounts[label];if(a.email!=='vp6-'+label+'@lab.invalid'||typeof a.token!=='string'||!/^[A-Za-z0-9_-]{16,256}$/.test(a.token))throw new Error('native service-account shape outside supported credentials');}
async function preserveOrCreate(name:string,content:string,mode:number){const path=resolve(root,".local",name);let previous:string|undefined;try{previous=await readFile(path,"utf8")}catch(error){if((error as any).code!=="ENOENT")throw error;}if(previous!==undefined){if(previous!==content)throw new Error("Existing dedicated credential differs; preserve and perform an explicit rotation");return;}await writeFile(path,content,{flag:"wx",mode});}
const ingest='Basic '+Buffer.from(accounts.ingest.email+':'+accounts.ingest.token).toString('base64');await preserveOrCreate('openobserve_sa_ingest_auth',ingest,0o644);await preserveOrCreate('openobserve_query_users.cfg','userlist query_users\n user '+accounts.query.email+' insecure-password '+accounts.query.token+'\n',0o644);await preserveOrCreate("grafana-openobserve.env","O2_QUERY_USER="+accounts.query.email+"\nO2_QUERY_PASSWORD="+accounts.query.token+"\n",0o600);console.log(JSON.stringify({rendered:['openobserve_sa_ingest_auth','openobserve_query_users.cfg'],credentialValuesPrinted:false,ingestHeaderHasCRLF:false,queryRole:'service_account',ownerCredentialUsed:false}));
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
ROOT=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
"$ROOT/scripts/compose.sh" restart postgres valkey s3 api worker lb
+27
View File
@@ -0,0 +1,27 @@
import { mkdir, readFile, writeFile } from 'node:fs/promises';
import { resolve } from 'node:path';
const receipt = process.argv[2];
if (!receipt || !resolve(receipt).startsWith(resolve(import.meta.dir, '../.local') + '/')) throw new Error('own discovery path required');
const discovery = JSON.parse(await readFile(receipt, 'utf8'));
const expectedNode = '886f220356cb120754a29494f1e88ef63d95a00f8e588da79ee57d828e7b92a4';
function command(args: string[]) { const r = Bun.spawnSync(args, {stdout:'pipe',stderr:'pipe'}); if (r.exitCode !== 0) throw new Error('cache read failed: ' + args.slice(0,2).join(' ')); return r.stdout; }
function guard() { const n = JSON.parse(new TextDecoder().decode(command(['docker','inspect',expectedNode])))[0]; if (n.Id !== expectedNode || n.State.Running || n.State.Status !== 'exited' || n.Config.Labels?.['k3d.cluster'] !== 'platform') throw new Error('stopped source ownership mismatch'); }
guard();
const host = new TextDecoder().decode(command(['docker','context','inspect','--format','{{.Endpoints.docker.Host}}'])).trim();
if (host !== discovery.dockerHost || !host.startsWith('unix://')) throw new Error('Docker endpoint mismatch');
const output = resolve(import.meta.dir,'../.local/oci-stat-' + crypto.randomUUID()); await mkdir(output,{mode:0o700});
const blobs = new Map<string,any>();
for (const image of discovery.images) { if (!image.rawIndexMatchesPinnedDigest || !image.rawManifestMatchesDigest) throw new Error('unverified registry manifest'); for (const d of [image.manifest.config,...image.manifest.layers]) { if (!/^sha256:[a-f0-9]{64}$/.test(d.digest) || !Number.isSafeInteger(d.size) || d.size <= 0) throw new Error('descriptor invalid'); const previous = blobs.get(d.digest); if (previous && previous.size !== d.size) throw new Error('descriptor conflict'); blobs.set(d.digest,{digest:d.digest,size:d.size,images:[...(previous?.images??[]),image.id]}); } }
if ([...blobs.values()].reduce((s,d)=>s+d.size,0) > 800_000_000) throw new Error('declared cache copy cap');
const results=[];
for (const blob of blobs.values()) {
const source='/var/lib/rancher/k3s/agent/containerd/io.containerd.content.v1.content/blobs/sha256/' + blob.digest.slice(7);
const raw = new TextDecoder().decode(command(['curl','--silent','--show-error','--max-time','15','--head','--unix-socket',host.slice(7),'http://localhost/containers/'+expectedNode+'/archive?path='+encodeURIComponent(source)]));
const status=Number(raw.match(/^HTTP\/\S+\s+(\d+)/m)?.[1]); if (![200,404].includes(status)) throw new Error('unexpected Docker archive status '+status);
let stat=null; if(status===200){ const encoded=raw.match(/^X-Docker-Container-Path-Stat:\s*(\S+)/im)?.[1]; if(!encoded)throw new Error('archive stat missing'); stat=JSON.parse(Buffer.from(encoded,'base64').toString()); if(stat.size!==blob.size || stat.linkTarget || (!Number.isSafeInteger(stat.mode) || stat.mode < 0 || (stat.mode & ~0o777)!==0))throw new Error('blob stat mismatch'); }
results.push({...blob,source,present:status===200,stat:stat?{size:stat.size,mode:stat.mode}:null});
}
guard();
const images=discovery.images.map((i:any)=>({id:i.id,complete:results.filter(b=>b.images.includes(i.id)).every(b=>b.present),missingBytes:results.filter(b=>b.images.includes(i.id)&&!b.present).reduce((s,b)=>s+b.size,0)}));
const result={checkedAt:new Date().toISOString(),discovery:receipt,node:expectedNode,nodeStopped:true,output,images,blobs:results,layersCopied:0};
await writeFile(resolve(output,'STAT.json'),JSON.stringify(result,null,2)+'\n',{flag:'wx',mode:0o600});console.log(JSON.stringify({images,receipt:resolve(output,'STAT.json'),layersCopied:0}));
+12
View File
@@ -0,0 +1,12 @@
#!/bin/sh
set -eu
ROOT=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
[ -n "${TARGET_INSTANCE_ID:-}" ] || exit 2
for id in $("$ROOT/scripts/compose.sh" ps -q api); do
host=$(docker exec "$id" cat /tmp/messenger-instance-id)
if [ "$host" = "$TARGET_INSTANCE_ID" ]; then
docker stop --time 8 "$id"
exit 0
fi
done
exit 3
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
ROOT=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
"$ROOT/scripts/compose.sh" --profile '*' stop
Executable
+17
View File
@@ -0,0 +1,17 @@
#!/bin/sh
set -eu
ROOT=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
cd "$ROOT"
bun scripts/preflight-openobserve-images.ts --grafana
bun scripts/bootstrap.ts
bun scripts/bootstrap-grafana.ts
bun scripts/bootstrap-openobserve.ts
scripts/compose.sh build api
scripts/compose.sh up -d --pull never postgres valkey s3 init-telemetry openobserve
bun scripts/wait-openobserve.ts
bun scripts/provision-openobserve-accounts.ts
scripts/compose.sh up -d --no-build --pull never api worker lb otel-collector observe-query
bun student-tests/wait.ts
scripts/compose.sh --profile grafana-pending up -d --no-build --pull never grafana
bun scripts/wait-grafana.ts
printf '%s\n' 'Application, Collector, OpenObserve and Grafana started; follow RUNBOOK.md for the local endpoints and acceptance commands.'
+5
View File
@@ -0,0 +1,5 @@
// Empty SQLite on the owned HDD completed641 migrations during the old120s
// deadline without an error. Allow bounded cold initialization, not only warm restart.
const deadline=Date.now()+600000;
while(Date.now()<deadline){try{const response=await fetch('http://127.0.0.1:28306/api/health',{signal:AbortSignal.timeout(2000)}),body=await response.json();if(response.status===200&&body.database==='ok'&&body.version==='13.3.1'){console.log('Grafana13.3.1 database and HTTP server ready');process.exit(0)}}catch{}await Bun.sleep(500);}
throw new Error('Grafana native readiness deadline exceeded');
+3
View File
@@ -0,0 +1,3 @@
const deadline=Date.now()+55_000;
while(Date.now()<deadline){try{const response=await fetch('http://127.0.0.1:28406/healthz',{signal:AbortSignal.timeout(1000)});await response.arrayBuffer();if(response.status===200){console.log('Owned OpenObserve health endpoint ready.');process.exit(0);}}catch{}await Bun.sleep(250);}
throw new Error('Owned OpenObserve readiness exceeded55seconds');