Spaces:
Sleeping
Sleeping
Download src/adapters/sandbox/preview.py from dellweb3/VibeCoding: direct link, hf CLI and curl.
- Browser
- Download file 18.3 kB
-
https://huggingface.co/spaces/dellweb3/VibeCoding/resolve/main/src/adapters/sandbox/preview.py
- Command line
-
hf download hf://spaces/dellweb3/VibeCoding/src/adapters/sandbox/preview.py
-
curl -L -o preview.py https://huggingface.co/spaces/dellweb3/VibeCoding/resolve/main/src/adapters/sandbox/preview.py
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 | |