Spaces:
Sleeping
Sleeping
File size: 18,306 Bytes
5ca3c16 115b94d 5ca3c16 115b94d 5ca3c16 115b94d 5ca3c16 115b94d 5ca3c16 115b94d 5ca3c16 115b94d 5ca3c16 115b94d 5ca3c16 115b94d 5ca3c16 115b94d 5ca3c16 115b94d 5ca3c16 115b94d 5ca3c16 115b94d 5ca3c16 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 | """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
|