VibeCoding / src /adapters /sandbox /preview.py
dellweb3's picture
sol6.1 ERP稳定版本
115b94d verified
Raw History Blame Contribute Delete
18.3 kB
"""Authenticated server-side serial proxy into one networkless disposable VM."""
import gzip
import base64
import hashlib
import json
import os
import queue
import shutil
import stat
import subprocess
import socket
import threading
import time
import uuid
from pathlib import Path
from src.adapters.sandbox.qemu import cpio
from src.modules.skill.domain.models import canonical, digest, SkillError
from src.modules.execution.pdf_dependency import overlay as dependency_overlay
from src.adapters.sandbox.process_lifecycle import spawn_owned, release_owned
class PreviewSession:
def __init__(self, sandbox, source):
self.sandbox, self.source = sandbox, source
self.id = uuid.uuid4().hex
self.status, self.error = 'starting', None
self.expires = time.time() + 900
self.process = None
self.transport = None
self.listener = None
self.messages = queue.Queue(maxsize=64)
self.lock = threading.Lock()
self.lifecycle = threading.RLock()
self.stop_event = threading.Event()
self.receipt = None
self.diagnostics = None
self.tested_candidate = None
self.tested_evidence = None
self.folder = None
self.started_at = time.time()
self.events = []
self.cancel_requested = False
self.boot_attempt = 0
self.reader_thread = None
self.note('created', '已接收预览请求,准备独立沙箱。')
def note(self, phase, detail):
self.events.append({'at':time.time(),'phase':phase,'detail':detail})
if self.folder:
try:
(self.folder/'progress.json').write_text(json.dumps(self.events,ensure_ascii=False,indent=2),encoding='utf-8')
except OSError: pass
def record_diagnostic(self, phase, category, exc=None):
# Deliberately omit exception messages, request paths, bodies and credentials.
import re
safe=lambda value:re.sub(r'[^A-Za-z0-9_.-]','_',str(value))[:100]
event={'at':time.time(),'phase':safe(phase),'category':safe(category),
'exception_type':safe(type(exc).__name__) if exc else None}
if isinstance(exc,SkillError) and isinstance(exc.details.get('startup'),dict):
event['startup']={k:exc.details['startup'].get(k) for k in ('process_running','exit_code','exception_type','trust')}
self.diagnostics={'event':event,'previous':self.diagnostics}
if self.folder:
try:(self.folder/'diagnostics.json').write_text(json.dumps(self.diagnostics,ensure_ascii=False,indent=2),encoding='utf8')
except OSError:pass
def progress(self):
return {'started_at':self.started_at,'server_time':time.time(),
'elapsed_seconds':max(0,time.time()-self.started_at),'events':list(self.events),
'process_alive':bool(self.process and self.process.poll() is None)}
def start(self):
for attempt in range(2 if getattr(self.sandbox,'allow_boot_retry',True) else 1):
self.boot_attempt=attempt
self._start()
if self.error!='SANDBOX_BOOT_FAILED' or attempt or self.cancel_requested or self.folder is None:return
reader=self.reader_thread
if reader and reader.is_alive():return
with self.lifecycle:
if self.cancel_requested:return
self.stop_event=threading.Event();self.messages=queue.Queue(maxsize=64)
self.transport=self.listener=self.process=None
self.status='starting';self.error=None
self.note('recovering','内核尚未运行生成代码,同一租约重新启动一次;不调用模型。')
def _start(self):
root=getattr(self.sandbox,'resource_root',None)
if root:
from src.modules.governance.resource_limits import serial_slot
try:
with serial_slot(root,'heavy',cancelled=self.stop_event.is_set,timeout=900,
on_wait=lambda:self.note('queued','等待实例重型执行位;尚未启动新的隔离环境。')):
return self._start_unlocked()
except SkillError as exc:
self.status='failed';self.error=exc.code;self.note('failed',exc.code);return
return self._start_unlocked()
def _start_unlocked(self):
try:
self.note('checking', '正在校验固定镜像、执行器与源码摘要。')
self.sandbox.preflight()
if digest(self.source['files']) != self.source['source_digest']:
raise SkillError('SOURCE_DIGEST_MISMATCH', '源码摘要不符。')
if self.sandbox.worker.name not in {'vm_worker_v3.py','vm_worker_v4.py','vm_worker_v5.py','vm_worker_v6.py','vm_worker_v7.py'}:
raise SkillError('PREVIEW_ISOLATION_VERSION_REQUIRED','当前控制器不支持测试和预览隔离。',503)
candidate=self.tested_candidate;test=self.tested_evidence
if not candidate or not test:
self.note('independent-test', '正在独立虚拟机中验证源码;预览使用另一实例。')
test_run='run-'+self.id
candidate=self.sandbox.build(test_run,self.source,self.stop_event.is_set)
test=self.sandbox.probe(test_run,candidate,'test',self.stop_event.is_set)
if not self.sandbox.cleanup(test_run):raise SkillError('SANDBOX_CLEANUP_UNKNOWN','测试实例回收待确认。',503)
if (candidate.get('source_digest')!=self.source['source_digest'] or candidate.get('config_digest')!=digest(self.sandbox.config)
or candidate.get('image')!=self.sandbox.config.image or candidate.get('suite_digest')!=self.sandbox.suite_digest
or test.get('stage')!='test' or test.get('passed') is not True
or test.get('classes_digest')!=candidate.get('classes_digest') or test.get('suite_digest')!=self.sandbox.suite_digest):
raise SkillError('EVIDENCE_BINDING_MISMATCH','独立测试证据不符。',409)
self.folder = self.sandbox.root / ('preview-' + self.id + (f'-boot{self.boot_attempt+1}' if self.boot_attempt else ''))
self.folder.mkdir()
self.note('packaging', '校验通过,正在装配源码、固定依赖和独立测试。')
self.nonce = uuid.uuid4().hex
files = []
dirs = {'root','runner','input'}
for name, content in self.source['files'].items():
path = Path('input') / name
if path.is_absolute() or '..' in path.parts:
raise SkillError('PATH_NOT_ALLOWED','非法路径。')
dirs.update(p.as_posix() for p in path.parents if p.as_posix() != '.')
files.append((path.as_posix(),content.encode(),stat.S_IFREG|0o644))
files += [('runner/probe.py',self.sandbox.probe_file.read_bytes(),stat.S_IFREG|0o644),
('runner/vm_worker.py',self.sandbox.worker.read_bytes(),stat.S_IFREG|0o600),
('root/job.json',canonical({'nonce':self.nonce,'config':self.sandbox.config.model_dump(),'interactive':True,'tested_classes_digest':candidate['classes_digest'],'tested_cases':test['passed_cases']}).encode(),stat.S_IFREG|0o600)]
entries = [(d,b'',stat.S_IFDIR|(0o700 if d=='root' else 0o755)) for d in sorted(dirs,key=lambda x:(x.count('/'),x))] + files + dependency_overlay(self.sandbox.config)
initrd = self.folder/'session.cpio.gz'
with initrd.open('wb') as f:
with (self.sandbox.image_root/'rootfs.cpio.gz').open('rb') as base:
shutil.copyfileobj(base,f)
f.write(gzip.compress(cpio(entries),mtime=0))
# Windows QEMU stdio does not reliably consume redirected stdin pipes.
# A host-loopback character device carries UART bytes, NOT guest networking.
self.listener=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
self.listener.bind(('127.0.0.1',0));self.listener.listen(1);self.listener.settimeout(10)
serial_port=self.listener.getsockname()[1]
args=[self.sandbox.executable,'-machine','q35,accel=tcg','-cpu','max','-m','1024','-smp','1',
'-nodefaults','-no-user-config','-nic','none','-display','none','-monitor','none',
'-chardev',f'socket,id=control,host=127.0.0.1,port={serial_port},server=off',
'-serial','chardev:control','-no-reboot',
'-kernel',str(self.sandbox.image_root/'kernel'),'-initrd',str(initrd),'-append',self.sandbox.kernel_arguments]
with self.lifecycle:
if self.stop_event.is_set():
return
self.process=spawn_owned(args,stdin=subprocess.DEVNULL,stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL,
creationflags=subprocess.CREATE_NO_WINDOW if os.name=='nt' else 0)
self.note('booting', '隔离虚拟机进程已启动,正在连接控制通道。')
self.transport,_=self.listener.accept()
self.note('validating', '控制通道已连接;等待Java编译、独立HTTP测试和健康检查回执。')
self.listener.close();self.listener=None
# Startup and RPC queues have their own deadlines. Idle UART must stay
# open until the lease expires; closing the socket interrupts this read.
self.transport.settimeout(None)
serial_reader=self.transport.makefile('rb')
def read():
try:
log_size=0;entered_worker=False
while line:=serial_reader.readline(131073):
if log_size<65536:
with (self.folder/'boot.log').open('ab') as log: log.write(line[:65536-log_size])
log_size+=len(line)
if len(line)>131072:
self.error='PREVIEW_OUTPUT_LIMIT'; self.stop_event.set(); return
text=line.decode('utf-8',errors='replace').strip()
if text.startswith(('ZKCODING_VM_STAGE=','ZKCODING_VM_READY=','ZKCODING_VM_RESULT=')):entered_worker=True
if (not entered_worker and self.sandbox.manifest_path.name in {'manifest-v8.json','manifest-v9.json'}
and self.sandbox.known_boot_failure(text)):
self.messages.put_nowait(('ZKCODING_VM_BOOT_FAILED=',{'error':'SANDBOX_BOOT_FAILED','generated_code_started':False}))
for prefix in ['ZKCODING_VM_READY=','ZKCODING_RPC=','ZKCODING_RPC_ACK=','ZKCODING_VM_RESULT=']:
if text.startswith(prefix):
data=json.loads(text[len(prefix):])
if data.get('nonce') != self.nonce:
self.error='PREVIEW_RECEIPT_INVALID';self.stop_event.set();return
self.messages.put_nowait((prefix,data))
except Exception as exc:
if not self.stop_event.is_set():self.record_diagnostic('serial-read','reader_error',exc)
self.stop_event.set()
finally:
serial_reader.close()
self.reader_thread=threading.Thread(target=read,daemon=True);self.reader_thread.start()
prefix,ready=self.messages.get(timeout=self.sandbox.command_timeout)
if prefix=='ZKCODING_VM_BOOT_FAILED=':
raise SkillError('SANDBOX_BOOT_FAILED','独立虚拟机内核启动失败,尚未运行生成代码。',503,details=ready)
if prefix!='ZKCODING_VM_READY=' or not all(ready.get(k,{}).get('passed') for k in ('build','test','preview')):
# Keep the actual failed receipt for authenticated diagnosis.
# A generic failure code alone is insufficient for recovery.
self.diagnostics=json.loads(json.dumps(ready))
raise SkillError('PREVIEW_VALIDATION_FAILED','新预览未通过独立检查。')
if len({ready[k]['classes_digest'] for k in ('build','test','preview')})!=1:
raise SkillError('EVIDENCE_BINDING_MISMATCH','预览产物不一致。')
self.receipt={'source_digest':self.source['source_digest'],'image':self.sandbox.config.image,
'config_digest':digest(self.sandbox.config),'classes_digest':ready['build']['classes_digest'],
'tests':ready['test']['passed_cases'],'tests_origin':'separate-disposable-vm','suite_digest':self.sandbox.suite_digest,'network':'none','host_mounts':[]}
self.status='ready'
self.note('ready', '编译、独立测试和健康检查通过,网站已就绪。')
while not self.stop_event.wait(0.25) and time.time()<self.expires and self.process.poll() is None:
pass
except Exception as exc:
self.record_diagnostic('startup',exc.code if isinstance(exc,SkillError) else 'PREVIEW_START_FAILED',exc)
self.error=exc.code if isinstance(exc,SkillError) else 'PREVIEW_START_FAILED'
self.status='failed'
self.note('failed', '预览未能完成:'+self.error)
finally:
self.close(internal=True)
def request(self, method, path, authorization, body=None):
encoded = None
if body is not None:
if (self.sandbox.config.dependency_profile != 'pdfbox-3.0.8' or method != 'POST'
or path != '/api/pdf/analyze' or not isinstance(body, dict)):
raise SkillError('PREVIEW_BODY_NOT_ALLOWED', '此接口不接受上传内容。', 422)
encoded = json.dumps(body, ensure_ascii=False, separators=(',', ':')).encode('utf-8')
if len(encoded) > 180000:
raise SkillError('PDF_TOO_LARGE', 'PDF 请求超过上传上限。', 413)
with self.lock:
if self.status!='ready' or time.time()>=self.expires:
raise SkillError('PREVIEW_NOT_READY','预览尚未就绪或已到期。',409)
key=uuid.uuid4().hex
category='transport_error'
try:
request = {'id':key,'method':method,'path':path,'authorization':authorization}
deadline = time.monotonic() + (30 if encoded is not None else 15)
def send(frame):
data = (json.dumps(frame, separators=(',', ':'))+'\n').encode()
if len(data) > 4096 or time.monotonic() >= deadline:
raise ValueError()
self.transport.sendall(data)
def receive():
remaining = deadline - time.monotonic()
if remaining <= 0: raise ValueError()
return self.messages.get(timeout=remaining)
if encoded is not None:
chunks = [encoded[i:i+2048] for i in range(0, len(encoded), 2048)]
if not 1 <= len(chunks) <= 100: raise ValueError()
send(dict(request, type='begin', body_bytes=len(encoded), body_sha256=hashlib.sha256(encoded).hexdigest(), chunks=len(chunks)))
prefix, ack = receive()
if prefix != 'ZKCODING_RPC_ACK=' or ack.get('id') != key or ack.get('index') != -1: raise ValueError()
for index, chunk in enumerate(chunks):
send({'type':'chunk','id':key,'index':index,'data':base64.b64encode(chunk).decode()})
prefix, ack = receive()
if prefix != 'ZKCODING_RPC_ACK=' or ack.get('id') != key or ack.get('index') != index: raise ValueError()
send({'type':'commit','id':key})
else:
send(request)
prefix,result=receive()
if prefix!='ZKCODING_RPC=' or result.get('id')!=key:
category='invalid_reply';raise ValueError()
if result.get('error'):
category='guest_http_timeout' if result.get('category')=='http_timeout' else 'guest_reported_error'
raise ValueError()
return {'status':result['status'],'body':result['body'],'source_digest':self.source['source_digest']}
except Exception as exc:
self.record_diagnostic('rpc',category,exc)
self.close()
raise SkillError('PREVIEW_REQUEST_UNKNOWN','请求结果未知,预览已关闭;不会自动重放。',503) from None
def close(self, *, internal=False):
with self.lifecycle:
if not internal:self.cancel_requested=True
self.stop_event.set()
if self.transport:
try: self.transport.shutdown(socket.SHUT_RDWR)
except OSError: pass
self.transport.close()
if self.listener:
self.listener.close()
if self.process and self.process.poll() is None:
self.process.kill()
self.process.wait(timeout=5)
if self.process:
release_owned(self.process)
if self.reader_thread and self.reader_thread is not threading.current_thread():
self.reader_thread.join(timeout=2)
if self.status!='failed':
self.status='closed'
if not self.events or self.events[-1]['phase'] not in {'closed','failed'}:
self.note('closed', '本次预览租约已关闭,不能继续调用。')
if self.folder:
try:
(self.folder/'session.cpio.gz').unlink(missing_ok=True)
except PermissionError:
# The start thread may still be writing; its finally closes and retries.
pass