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