Add authenticated fixed Tech one-shot adapter with bounded transport and admission
Deploy Canina / deploy (push) Successful in 3m10s
Deploy Canina / deploy (push) Successful in 3m10s
This commit is contained in:
1 parent
c523acc9e8
commit
5984242ce4
9 files changed
+406
-1
No files matched your search
@@ -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.
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
@@ -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()
|
||||
@@ -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;});
|
||||
@@ -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')
|
||||
|
||||
@@ -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)
|
||||
@@ -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); '
|
||||
|
||||
@@ -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())
|
||||
@@ -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()
|
||||
Reference in new issue
Block a user