Compare commits

...
9 changed files with 406 additions and 1 deletions

No files matched your search

+24
View File
@@ -0,0 +1,24 @@
# Authenticated one-shot Tech adapter (not deployed)
`tech_adapter.py` is trusted host-side orchestration, not a web endpoint. It takes an explicit task UUID, service origin, private artifact root and reviewed admission JSON file. Credential is read exclusively from `/run/secrets/prepare_worker_credential`, with descriptor-relative no-symlink traversal, private file permissions, ownership, regular-file/one-link and bounded-read checks. No token is emitted. HTTPS only in CLI; loopback HTTP exists only in the Python disposable-test interface. Redirects are never followed.
Contract frozen with parent:
- POST `/internal/prepare-worker/tech-claim` `{taskId}` -> `{lease}` or `{lease:null}`. Backend owns stored task admission, READY and independent Gate1. Lease must include exact `pilotKind:tech-dev-clamp-quantity-v1`; removing that sole extension must yield the existing strict staging/first-attempt/20-cent/30-second lease. Task ID must match explicit caller UUID. No arbitrary task text enters inference.
- POST existing `heartbeat` with only taskId/runId/leaseToken -> `{leaseUntil}`. No retries. Entire DNS/connect/response-body operation is isolated in a spawned process, killed after 4.5s plus <=.2s reap. This avoids socket timeout slow-drip gaps. Existing LeaseGuard aborts cancellable inference on denial; no local lease extension.
- POST `tech-complete` with binding plus <=2048-byte generated `source`, only after independent local QA9 and final heartbeat. Acknowledge only exact matching task/run, VERIFYING, 64hex artifactSha256 and `upper-bound-reserved`. Backend's independent validator, artifact registration and reservation retention remain separate authority. Never call existing deterministic tracer `complete` with model output.
Admission file must exactly contain:
{"maxCalls":1,"maxTokens":160,"reservationCents":20,"monetaryCapVerified":false,"acceptUnverifiedMonetaryCap":true}
This is explicit conservative acceptance, **not a hard monetary cap**. Provider authenticated GET `/v1/models` on 2026-10-23 returned `[{"id":"Free"}]` after filtering to id/pricing/cost/limits: no price or cap fields. Anonymous GET returned401. Therefore neither zero price nor independently enforced20c spend cap was verified. Retain the complete20c server reservation; no cost-zero/release/reconcile claim.
Installed pinned Hermes source inspection revealed default API retries3 and automatic recovery5. `inference_budget.SingleCall` now gates the OpenAI-compatible `Completions.create` resource class across client rebuilds, forces nonstreaming/max_tokens160 and denies second invocation. `infer.py` sets app attempts1, recovery0 and checks SDK retries0 before calling the fixed prompt. `runtime.py` injects that trusted gate from source into the isolated pinned process. This bounds requests/output, not provider accounting/input token cost. No new real provider inference was run or represented as authorized by this discovery.
## Verification (remote worktree only)
`python3 -m unittest discover -s infra/hermes-pilot -v`:19 tests passed, including adapter process fixture through independent QA9/Git fixture; real TCP Bearer transmission and403 rejection; total slow-drip body deadline<5s; admission rejection before network; exact pilot denial before runner construction; second provider-call prevention; existing real child/descendant cancellation regressions. Source fixture is deterministic and is **not actual model output**. TDD observed missing module, missing end-to-end behavior, missing credential validation and missing SingleCall failures before implementation.
`disposable_backend.ts` is an isolated Nest/PostgreSQL harness importing sibling's backend module read-only. It is never AppModule code. It records separate author/reviewer Gate1, checks pre-Gate1 denial and VERIFYING/persisted reservation/artifact retrieval. Combined execution PASSED against sibling ingestion source snapshot: task d4e88f7c-3772-47ab-a6fd-dbe00ff8bd2e, run b93a5dbf-3185-4f29-a69d-be8ad85e720c, VERIFYING, artifact b9382f575e9f27f7ad54e0cfb61ba91bc66536fa0e5df5be955563a03c285e17, retrievable with QA9, full20c reservation and zero reconciliations. Evidence: /opt/services/canina/validation/v4-tech-adapter/{adapter-proof,backend-proof}.json. Initial Docker host networking/mounts and stale generated Prisma client failed; corrected with loopback-only disposable backend, copied source and privately generated Prisma client (shared dependencies read-only). Dedicated disposable PostgreSQL had no published ports. No actual authenticated Gate1/model run, Stage change, Production, push/deploy or RELEASE_AUTHORIZE.
Created/changed files are confined to infra/hermes-pilot. Original dirty core/Stage remain untouched. Parent must combine sibling ingestion commit, run disposable integration and decide whether conservative admission suffices for any later model proof.
+22
View File
@@ -0,0 +1,22 @@
{
"adapter-proof": {
"taskId": "d4e88f7c-3772-47ab-a6fd-dbe00ff8bd2e",
"runId": "b93a5dbf-3185-4f29-a69d-be8ad85e720c",
"state": "VERIFYING",
"costStatus": "upper-bound-reserved",
"artifactSha256": "b9382f575e9f27f7ad54e0cfb61ba91bc66536fa0e5df5be955563a03c285e17",
"modelInference": false,
"disposable": true,
"preGate1Denied": true
},
"backend-proof": {
"state": "VERIFYING",
"taskId": "d4e88f7c-3772-47ab-a6fd-dbe00ff8bd2e",
"artifactSha256": "b9382f575e9f27f7ad54e0cfb61ba91bc66536fa0e5df5be955563a03c285e17",
"reservedCents": 20,
"reconciliations": 0,
"qaCases": 9,
"modelInference": false,
"disposable": true
}
}
+20
View File
@@ -0,0 +1,20 @@
"""Deterministic process fixture against actual disposable Nest/PostgreSQL. Not a model proof."""
import json, pathlib, sys, time
sys.path.insert(0,str(pathlib.Path(__file__).parent))
import tech_adapter as a
def main():
evidence=pathlib.Path('/opt/services/canina/validation/v4-tech-adapter')
until=time.monotonic()+15
while not (evidence/'ready.json').exists():
if time.monotonic()>until: raise TimeoutError('Backend not ready')
time.sleep(.1)
ready=json.loads((evidence/'ready.json').read_text())
source='def clamp_quantity(quantity):\n return min(99, max(0, quantity))\n'
runner=lambda:a.executor.ProcessInference([sys.executable,'-c','print('+repr(json.dumps({'source':source,'tools':0,'model':'Free'}))+')'])
transport=a.Transport(ready['baseUrl'],'DISPOSABLE-ONLY-TECH-ADAPTER-SECRET-1234567890',allow_loopback_http=True)
result=a.run_once(transport,ready['taskId'],str(evidence),a.ADMISSION,runner)
(evidence/'adapter-proof.json').write_text(json.dumps({**result,'modelInference':False,'disposable':True,'preGate1Denied':ready['preGate1Denied']}))
(evidence/'done').touch()
print(json.dumps(result))
if __name__=='__main__': main()
+41
View File
@@ -0,0 +1,41 @@
/** Disposable-only integration harness: never import into AppModule. */
import { Test } from '@nestjs/testing';
import { PrismaClient } from '@prisma/client';
import { createHash, randomUUID } from 'crypto';
import { mkdir, writeFile, readFile } from 'fs/promises';
import { WorkerTransportModule } from '/backend/src/orchestration-worker/worker-transport.module';
import { PrismaService } from '/backend/src/prisma/prisma.service';
import { PrepareWorkflowService } from '/backend/src/orchestration/prepare-workflow.service';
async function main() {
if(process.env.DISPOSABLE_TECH_ADAPTER !== 'yes') throw Error('Disposable flag required');
const db = new PrismaClient();
const token = 'DISPOSABLE-ONLY-TECH-ADAPTER-SECRET-1234567890';
const directory = '/evidence/artifacts'; await mkdir(directory,{mode:0o700,recursive:true});
const mod = await Test.createTestingModule({imports:[WorkerTransportModule.register({enabled:true,grants:[{id:'adapter-fixture',role:'WORKFLOW_WORKER',credentialSha256:createHash('sha256').update(token).digest('hex')}],workerIds:['adapter-fixture'],stageCiIds:[],artifactDirectory:directory,artifactBaseUrl:'https://isolated.invalid/internal/prepare-worker/artifacts'})]}).overrideProvider(PrismaService).useValue(db).compile();
const workflow = mod.get(PrepareWorkflowService);
const app=mod.createNestApplication(); await app.listen(31987,'0.0.0.0');
const owner={id:'fixture-author',role:'Admin'}, reviewer={id:'fixture-reviewer',role:'SUPER_ADMIN'};
await db.orchestrationTask.updateMany({where:{key:'tech-dev-clamp-quantity-v1'},data:{key:'previous-'+randomUUID()}});
let t=await workflow.create({key:'tech-dev-clamp-quantity-v1',title:'Disposable clamp fixture',department:'TECH',operationMode:'PREPARE',budgetLimitCents:20,metadata:{commitSha:'a'.repeat(40),scope:'tech-dev-clamp-quantity-v1',acceptanceCriteria:['Independent clamp fixture QA only']}},owner);
// Server admission must reject before the independently recorded Gate1.
let response=await fetch(('http://127.0.0.1:31987')+'/internal/prepare-worker/tech-claim',{method:'POST',headers:{authorization:'Bearer '+token,'content-type':'application/json'},body:JSON.stringify({taskId:t.id})});
if(response.status!==403 && (await response.json()).lease!==null) throw Error('Pre-Gate1 claim accepted');
t=await workflow.transition(t.id,{toState:'GATE1_PENDING',expectedVersion:t.version,idempotencyKey:randomUUID()},owner);
t=await workflow.decide(t.id,1,{decision:'APPROVED',expiresAt:new Date(Date.now()+60000).toISOString(),expectedVersion:t.version,idempotencyKey:randomUUID()},reviewer);
t=await workflow.transition(t.id,{toState:'READY',expectedVersion:t.version,idempotencyKey:randomUUID()},owner);
await writeFile('/evidence/ready.json',JSON.stringify({baseUrl:'http://127.0.0.1:31987',taskId:t.id,preGate1Denied:true}));
try {
const until=Date.now()+45000;
while(Date.now()<until) {try {await readFile('/evidence/done');break;}catch{} await new Promise(r=>setTimeout(r,100));}
const task=await db.orchestrationTask.findUniqueOrThrow({where:{id:t.id}});
const ledger=await db.orchestrationBudgetLedger.findMany({where:{taskId:t.id}});
const artifacts=await db.orchestrationArtifact.findMany({where:{run:{taskId:t.id}}});
if(task.state!=='VERIFYING' || ledger.length!==1 || ledger[0].kind!=='RESERVE' || ledger[0].amountCents!==20 || artifacts.length!==1) throw Error('Persistence/reservation invariant failed');
const get=await fetch(('http://127.0.0.1:31987')+'/internal/prepare-worker/artifacts/'+artifacts[0].sha256,{headers:{authorization:'Bearer '+token}});
const artifact=await get.json();
if(get.status!==200 || artifact.qa.cases!==9 || artifact.applicationQa!==false) throw Error('Artifact retrieval failed');
await writeFile('/evidence/backend-proof.json',JSON.stringify({state:task.state,taskId:t.id,artifactSha256:artifacts[0].sha256,reservedCents:20,reconciliations:0,qaCases:artifact.qa.cases,modelInference:false,disposable:true}));
} finally {await app.close(); await db.$disconnect();}
}
main().catch((e)=>{console.error('Disposable integration failed',e?.message);process.exitCode=1;});
+12
View File
@@ -9,11 +9,23 @@ os.environ.clear()
os.environ.update({'PATH':'/usr/bin:/bin','HOME':home.name,'HERMES_HOME':home.name,'OPENAI_API_KEY':key,'OPENAI_BASE_URL':'https://nr.parsaaghayi.ir/v1','HERMES_DISABLE_PLUGINS':'1'})
# Installed API verified by inspect.signature at pinned image commit 818c13be.
with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()):
from openai.resources.chat.completions import Completions
# Patch the SDK resource class, so client rebuilds/fallback cannot reset admission.
original_create=Completions.create
budget=SingleCall() # injected by pinned runner, never imported from runtime disk
def bounded_create(self, *args, **kwargs):
if args: raise RuntimeError('Unexpected positional completion call')
return budget.call(lambda **kw: original_create(self, **kw),kwargs)
Completions.create=bounded_create
from run_agent import AIAgent
agent=AIAgent(model='Free',provider='custom',base_url='https://nr.parsaaghayi.ir/v1',api_key=key,
enabled_toolsets=[],max_iterations=1,max_tokens=160,run_budget_seconds=80,
skip_context_files=True,skip_memory=True,skip_background_review=True,load_soul_identity=False,
quiet_mode=True,fallback_model={},cwd=home.name)
agent._api_max_retries=1
agent._auto_recovery_cycles=0
if getattr(agent.client,'max_retries',None) != 0:
raise RuntimeError('SDK retries must be disabled')
if agent.tools: raise RuntimeError('Tool-less invariant failed')
result=agent.run_conversation('Write only Python source, no markdown: define clamp_quantity(quantity) returning integer quantity clamped to inclusive 0..99. Use one return with nested min/max calls only. No annotations, comments, imports, decorators, docstrings or other statements.')
final=result.get('final_response')
+18
View File
@@ -0,0 +1,18 @@
"""Pinned OpenAI-compatible completion boundary; not a monetary spending cap."""
import threading
class SingleCall:
def __init__(self):
self.used = False
self.lock = threading.Lock()
def call(self, create, kwargs):
with self.lock:
if self.used:
raise RuntimeError('One provider call only; no retries')
self.used = True
kwargs = dict(kwargs)
kwargs['max_tokens'] = 160
kwargs['stream'] = False
kwargs.pop('max_completion_tokens',None)
return create(**kwargs)
+2 -1
View File
@@ -111,7 +111,8 @@ def pinned_inference(image):
raise RuntimeError('Pinned installed image mismatch')
token = uuid.uuid4().hex
pidfile = '/tmp/canina-pilot-' + token + '.pid'
script = pathlib.Path(__file__).with_name('infer.py').read_text()
script = (pathlib.Path(__file__).with_name('inference_budget.py').read_text() + '\n' +
pathlib.Path(__file__).with_name('infer.py').read_text())
# Session leader is created INSIDE the container. Inner kill is independent of client.
wrapper = ('import os,signal,subprocess,sys; '
'p=subprocess.Popen(["timeout","--signal=KILL","85","/opt/hermes/.venv/bin/python","-"],stdin=sys.stdin,start_new_session=True); '
+165
View File
@@ -0,0 +1,165 @@
"""Trusted one-shot adapter; fixed task, no arbitrary prompt/command input."""
import argparse
import http.client
import json
import multiprocessing
import os
import pathlib
import re
import stat
import time
import urllib.parse
import executor
PILOT_KIND = executor.TASK
SECRET_PATH = '/run/secrets/prepare_worker_credential'
ADMISSION = {'maxCalls':1, 'maxTokens':160, 'reservationCents':20,
'monetaryCapVerified':False, 'acceptUnverifiedMonetaryCap':True}
def read_credential():
"""Fixed mount only; pin every directory and never log a secret."""
directory = os.open('/', os.O_RDONLY | os.O_DIRECTORY)
fd = None
try:
parts = SECRET_PATH.strip('/').split('/')
for part in parts[:-1]:
next_dir = os.open(part, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW, dir_fd=directory)
os.close(directory)
directory = next_dir
if os.fstat(directory).st_mode & 0o022:
raise ValueError('Private secret directory required')
fd = os.open(parts[-1], os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK, dir_fd=directory)
s = os.fstat(fd)
if (not stat.S_ISREG(s.st_mode) or s.st_nlink != 1 or s.st_mode & 0o077
or s.st_uid not in (0, os.getuid()) or s.st_size > 513):
raise ValueError('Private credential required')
token = os.read(fd, 514).decode('ascii').strip()
if not re.fullmatch(r'[\x21-\x7e]{32,512}', token):
raise ValueError('Private credential required')
return token
finally:
if fd is not None:
os.close(fd)
os.close(directory)
def _request(pipe, origin, token, route, body):
try:
u = urllib.parse.urlsplit(origin)
connection = (http.client.HTTPSConnection if u.scheme == 'https' else http.client.HTTPConnection)(u.hostname, u.port, timeout=4)
connection.request('POST', '/internal/prepare-worker/'+route, json.dumps(body),
{'Authorization':'Bearer '+token, 'Content-Type':'application/json'})
response = connection.getresponse()
raw = response.read(8193)
if not 200 <= response.status < 300 or len(raw) > 8192:
raise ValueError('Denied or oversized response')
result = json.loads(raw)
if not isinstance(result, dict):
raise ValueError('Invalid response')
pipe.send((True,result))
except BaseException:
pipe.send((False,None))
finally:
pipe.close()
class Transport:
"""Entire network operation (including DNS/body) killed before 5s, no retries."""
def __init__(self, origin, credential, *, allow_loopback_http=False):
u = urllib.parse.urlsplit(origin)
if (u.username or u.password or u.query or u.fragment or u.path not in ('','/')
or not u.hostname or (u.scheme != 'https' and not
(allow_loopback_http and u.scheme=='http' and u.hostname in ('127.0.0.1','::1')))):
raise ValueError('Fixed HTTPS service origin required')
if not isinstance(credential,str) or not re.fullmatch(r'[\x21-\x7e]{32,512}',credential):
raise ValueError('Service credential required')
self.origin, self._credential = origin, credential
def post(self, route, body):
if route not in ('tech-claim','heartbeat','tech-complete'):
raise ValueError('Route not admitted')
ctx = multiprocessing.get_context('spawn')
receive, send = ctx.Pipe(duplex=False)
worker = ctx.Process(target=_request, args=(send,self.origin,self._credential,route,body), daemon=True)
worker.start()
send.close()
try:
if not receive.poll(4.5):
raise TimeoutError('Worker transport deadline')
try:
ok, result = receive.recv()
except EOFError:
raise PermissionError('Worker transport failed') from None
if not ok:
raise PermissionError('Worker request denied or malformed')
return result
finally:
if worker.is_alive():
worker.kill()
worker.join(timeout=.2)
receive.close()
def validate_admission(admission):
if (admission != ADMISSION or type(admission.get('maxCalls')) is not int
or type(admission.get('maxTokens')) is not int or type(admission.get('reservationCents')) is not int):
raise ValueError('Explicit conservative admission required; monetary cap unverified')
def run_once(transport, task_id, artifact_root, admission, runner_factory=None):
validate_admission(admission)
if not isinstance(task_id,str) or not re.fullmatch('[a-f0-9-]{36}',task_id):
raise ValueError('Explicit task UUID required')
response = transport.post('tech-claim', {'taskId':task_id})
lease = response.get('lease')
if lease is None:
return {'state':'IDLE'}
if not isinstance(lease,dict) or lease.get('pilotKind') != PILOT_KIND or lease.get('taskId') != task_id:
raise ValueError('Fixed Tech admission required')
lease = dict(lease)
del lease['pilotKind']
executor.validate_lease(lease)
binding = {k:lease[k] for k in ('taskId','runId','leaseToken')}
def heartbeat(_):
result = transport.post('heartbeat',dict(binding))
if set(result) != {'leaseUntil'} or not isinstance(result['leaseUntil'],str):
raise PermissionError('Malformed heartbeat acknowledgment')
import datetime
expiry = datetime.datetime.fromisoformat(result['leaseUntil'].replace('Z','+00:00')).timestamp()
if not 0 < expiry-time.time() <= 31:
raise PermissionError('Invalid heartbeat acknowledgment')
runner = (runner_factory or (lambda:executor.pinned_inference(executor.IMAGE)))()
root, report = executor.execute(lease,artifact_root,runner,heartbeat)
source = (root/'quantity.py').read_text()
heartbeat(lease)
result = transport.post('tech-complete',{**binding,'source':source})
if (result.get('taskId') != task_id or result.get('runId') != lease['runId']
or result.get('state') != 'VERIFYING' or result.get('costStatus') != 'upper-bound-reserved'
or not isinstance(result.get('artifactSha256'),str)
or not re.fullmatch('[a-f0-9]{64}',result['artifactSha256'])):
raise ValueError('Invalid completion acknowledgment; no success assumed')
return {k:result[k] for k in ('taskId','runId','state','costStatus','artifactSha256')}
def main():
parser = argparse.ArgumentParser(description='Explicit one-shot Tech pilot; no release')
parser.add_argument('--base-url', required=True)
parser.add_argument('--task-id', required=True)
parser.add_argument('--artifact-root', required=True)
parser.add_argument('--admission-file', required=True)
args = parser.parse_args()
try:
admission = json.loads(pathlib.Path(args.admission_file).read_text())
validate_admission(admission)
transport = Transport(args.base_url,read_credential())
result = run_once(transport,args.task_id,args.artifact_root,admission)
print(json.dumps(result))
except BaseException:
print('Tech pilot failed closed; reservation retained; no completion assumed',file=__import__('sys').stderr)
return 1
return 0
if __name__ == '__main__':
raise SystemExit(main())
+102
View File
@@ -0,0 +1,102 @@
import datetime, json, pathlib, sys, tempfile, unittest
from unittest.mock import patch
sys.path.insert(0,str(pathlib.Path(__file__).parent))
from test_contract import lease
import tech_adapter as a
class Adapter(unittest.TestCase):
def test_wrong_pilot_never_constructs_inference(self):
calls=[]
class Transport:
def post(self, route, body):
calls.append(route)
return {'lease':dict(lease(),pilotKind='arbitrary')}
with tempfile.TemporaryDirectory() as root:
with self.assertRaises(ValueError):
a.run_once(Transport(),lease()['taskId'],root,{'maxCalls':1,'maxTokens':160,'reservationCents':20,'monetaryCapVerified':False,'acceptUnverifiedMonetaryCap':True},lambda: self.fail('inference constructed'))
self.assertEqual(calls,['tech-claim'])
def test_end_to_end_process_fixture(self):
source='def clamp_quantity(quantity):\n return min(99, max(0, quantity))\n'
d=dict(lease(),pilotKind=a.PILOT_KIND); calls=[]
class Transport:
def post(self,route,body):
calls.append((route,body))
if route=='tech-claim': return {'lease':d}
if route=='heartbeat': return {'leaseUntil':d['leaseUntil']}
return {'taskId':d['taskId'],'runId':d['runId'],'state':'VERIFYING','artifactSha256':'b'*64,'costStatus':'upper-bound-reserved'}
policy={'maxCalls':1,'maxTokens':160,'reservationCents':20,'monetaryCapVerified':False,'acceptUnverifiedMonetaryCap':True}
with tempfile.TemporaryDirectory() as root:
runner=lambda: a.executor.ProcessInference([sys.executable,'-c','print('+repr(json.dumps({'source':source,'tools':0,'model':'Free'}))+')'])
result=a.run_once(Transport(),d['taskId'],root,policy,runner)
self.assertEqual(result['state'],'VERIFYING')
self.assertEqual(calls[-1][0],'tech-complete')
self.assertEqual(calls[-1][1]['source'],source)
self.assertNotIn('leaseToken',result)
class BudgetTests(unittest.TestCase):
def test_second_provider_call_blocked_and_tokens_forced(self):
from inference_budget import SingleCall
seen=[]
gate=SingleCall()
def create(**kwargs): seen.append(kwargs); return 'ok'
self.assertEqual(gate.call(create,{'max_tokens':999,'stream':True}),'ok')
self.assertEqual(seen,[{'max_tokens':160,'stream':False}])
with self.assertRaises(RuntimeError): gate.call(create,{})
self.assertEqual(len(seen),1)
class TransportTests(unittest.TestCase):
def test_invalid_credential_rejected(self):
with self.assertRaises(ValueError): a.Transport('https://stage.invalid','short')
def test_real_http_auth_and_denial(self):
import http.server, threading
seen=[]
class Handler(http.server.BaseHTTPRequestHandler):
def log_message(self,*args): pass
def do_POST(self):
seen.append((self.path,self.headers.get('Authorization'),json.loads(self.rfile.read(int(self.headers['Content-Length'])))))
self.send_response(403 if self.path.endswith('heartbeat') else 200)
self.end_headers(); self.wfile.write(b'{"lease":null}')
server=http.server.ThreadingHTTPServer(('127.0.0.1',0),Handler)
thread=threading.Thread(target=server.serve_forever,daemon=True); thread.start()
try:
t=a.Transport('http://127.0.0.1:'+str(server.server_port),'x'*48,allow_loopback_http=True)
self.assertEqual(t.post('tech-claim',{'taskId':'explicit'}),{'lease':None})
with self.assertRaises(PermissionError): t.post('heartbeat',{})
self.assertEqual(seen[0],('/internal/prepare-worker/tech-claim','Bearer '+'x'*48,{'taskId':'explicit'}))
finally: server.shutdown(); server.server_close(); thread.join()
def test_total_deadline_includes_slow_response_body(self):
import http.server, threading, time
class Handler(http.server.BaseHTTPRequestHandler):
def log_message(self,*args): pass
def do_POST(self):
self.send_response(200); self.end_headers()
try:
for _ in range(30): self.wfile.write(b' '); self.wfile.flush(); time.sleep(.3)
except (BrokenPipeError,ConnectionResetError): pass
server=http.server.ThreadingHTTPServer(('127.0.0.1',0),Handler)
thread=threading.Thread(target=server.serve_forever,daemon=True); thread.start()
try:
t=a.Transport('http://127.0.0.1:'+str(server.server_port),'x'*48,allow_loopback_http=True)
started=time.monotonic()
with self.assertRaises(TimeoutError): t.post('heartbeat',{})
self.assertLess(time.monotonic()-started,5)
finally: server.shutdown(); server.server_close(); thread.join()
def test_secret_mount_rejects_unsafe_files(self):
import os
with tempfile.TemporaryDirectory() as root:
path=pathlib.Path(root,'credential'); path.write_text('x'*48); path.chmod(0o400)
# /tmp may be writable; use descriptor traversal rooted in a private fixture.
with patch.object(a,'SECRET_PATH',str(path)):
with self.assertRaises(ValueError): a.read_credential()
def test_admission_fails_before_network(self):
class Transport:
def post(self,*args): raise AssertionError('network forbidden')
for policy in [{},dict(a.ADMISSION,maxCalls=2),dict(a.ADMISSION,maxTokens=161),dict(a.ADMISSION,monetaryCapVerified=True),dict(a.ADMISSION,maxCalls=True)]:
with self.assertRaises(ValueError): a.run_once(Transport(),lease()['taskId'],'/',policy)
if __name__=='__main__': unittest.main()