File size: 11,245 Bytes
caf8059
 
 
 
 
 
5ca3c16
caf8059
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5ca3c16
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
caf8059
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5ca3c16
 
 
 
 
 
 
 
 
 
 
 
 
 
 
caf8059
 
 
 
 
 
5ca3c16
 
 
 
 
 
 
 
 
 
 
 
 
 
 
caf8059
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
import gzip
import hashlib
import json
import stat
import unittest
from pathlib import Path
from src.adapters.sandbox.qemu import QemuSandbox, VM_LAUNCH_V8
from src.modules.execution.contracts import SandboxConfig
from src.modules.skill.domain.models import SkillError, digest
from src.tests.runtime.fixtures import workspace, SOURCE


def unpack_overlay(raw):
    entries = {}
    offset = 0
    while offset < len(raw):
        assert raw[offset:offset + 6] == b'070701'
        fields = [int(raw[offset + 6 + i * 8:offset + 14 + i * 8], 16) for i in range(13)]
        offset += 110
        name = raw[offset:offset + fields[11] - 1].decode()
        offset = (offset + fields[11] + 3) & ~3
        entries[name] = (fields[1], raw[offset:offset + fields[6]])
        offset = (offset + fields[6] + 3) & ~3
        if name == 'TRAILER!!!':
            break
    return entries


class QemuContractTests(unittest.TestCase):
    def latest(self, command):
        original=(self.image/'manifest.json').read_bytes()
        manifest=json.loads(original)
        control=Path(__file__).resolve().parents[2]/'modules/execution/container'
        manifest.update(worker=hashlib.sha256((control/'vm_worker_v6.py').read_bytes()).hexdigest(),
                        probe=hashlib.sha256((control/'probe_v3.py').read_bytes()).hexdigest(),launch=VM_LAUNCH_V8)
        (self.image/'manifest-v8.json').write_text(json.dumps(manifest))
        config=self.sandbox.config.model_copy(update={'image':'zkcoding-qemu@sha256:'+digest(manifest)})
        sandbox=QemuSandbox(self.root/'v8',config,executable=self.sandbox.executable,image_root=self.image,command=command)
        sandbox.preflight();self.sandbox.preflight()
        self.assertEqual((self.image/'manifest.json').read_bytes(),original)
        return sandbox

    def test_pre_worker_kernel_panic_restarts_same_input_once(self):
        original=self.sandbox.command;attempts=[]
        def command(argv,**options):
            attempts.append((list(argv),Path(argv[argv.index('-initrd')+1]).read_bytes()))
            return (1,"Kernel panic - not syncing: IO-APIC + timer doesn't work!") if len(attempts)==1 else original(argv,**options)
        sandbox=self.latest(command)
        result=sandbox.build(self.run_id,self.source,lambda:False)
        self.assertTrue(result['passed'])
        self.assertEqual(len(attempts),2)
        self.assertEqual(attempts[0],attempts[1])
        self.assertIn('noapic',attempts[0][0][-1])

    def test_repeated_pre_worker_panic_is_bounded_and_classified(self):
        attempts=[]
        def command(argv,**options):
            attempts.append(argv)
            return 1,"Kernel panic - not syncing: IO-APIC + timer doesn't work!"
        sandbox=self.latest(command)
        with self.assertRaises(SkillError) as error:sandbox.build(self.run_id,self.source,lambda:False)
        self.assertEqual(error.exception.code,'SANDBOX_BOOT_FAILED')
        self.assertFalse(error.exception.details['generated_code_started'])
        self.assertEqual(len(attempts),2)

    def test_cancellation_wins_over_boot_recovery(self):
        attempts=[];stopped=[False]
        def command(argv,**options):
            attempts.append(argv);stopped[0]=True
            return 1,"Kernel panic - not syncing: IO-APIC + timer doesn't work!"
        sandbox=self.latest(command)
        with self.assertRaises(SkillError) as error:sandbox.build(self.run_id,self.source,lambda:stopped[0])
        self.assertEqual(error.exception.code,'RUN_CANCELLED')
        self.assertEqual(len(attempts),1)

    def test_post_worker_panic_and_unknown_exit_are_never_replayed(self):
        for text in ('ZKCODING_VM_STAGE=compile\nKernel panic - not syncing: IO-APIC + timer doesn\'t work!','unexpected exit'):
            with self.subTest(text=text):
                attempts=[]
                def command(argv,**options):attempts.append(argv);return 1,text
                sandbox=self.latest(command)
                with self.assertRaises(SkillError) as error:sandbox.build(self.run_id,self.source,lambda:False)
                self.assertEqual(error.exception.code,'VM_RESULT_UNKNOWN')
                self.assertEqual(len(attempts),1)

    def setUp(self):
        self.root = Path(self.enterContext(workspace()))
        self.image = self.root / 'image'
        self.image.mkdir()
        (self.image / 'qemu.exe').write_bytes(b'synthetic-executable')
        (self.image / 'kernel').write_bytes(b'synthetic-kernel')
        (self.image / 'rootfs.cpio.gz').write_bytes(gzip.compress(b''))
        control = Path(__file__).resolve().parents[2] / 'modules/execution/container'
        paths = {'qemu': self.image / 'qemu.exe', 'kernel': self.image / 'kernel', 'rootfs': self.image / 'rootfs.cpio.gz',
                 'worker': control / 'vm_worker.py', 'probe': control / 'probe.py'}
        manifest = {k: hashlib.sha256(p.read_bytes()).hexdigest() for k, p in paths.items()}
        (self.image / 'manifest.json').write_text(json.dumps(manifest))
        config = SandboxConfig(image='zkcoding-qemu@sha256:' + digest(manifest), skill_ids=['erp-java-development'],
             api_contract='public contract', tests=[{'path': '/health', 'status': 200, 'expected_json': {'status': 'ok'}}],
             health={'path': '/health', 'status': 200, 'expected_json': {'status': 'ok'}})
        self.calls = []
        self.nonce_wrong = False
        self.build_fail = False
        def command(argv, **options):
            self.calls.append(argv)
            entries = unpack_overlay(gzip.decompress(Path(argv[argv.index('-initrd') + 1]).read_bytes()))
            self.entries = entries
            job = json.loads(entries['root/job.json'][1])
            report = {'passed': True, 'classes_digest': '1' * 64, 'cases': 1, 'passed_cases': 1}
            result = {'nonce': 'wrong' if self.nonce_wrong else job['nonce'],
                      'build': {'passed': False, 'diagnostics': 'untrusted compile error'} if self.build_fail else report,
                      'test': report, 'preview': report}
            return 0, 'ZKCODING_VM_RESULT=' + json.dumps(result)
        self.sandbox = QemuSandbox(self.root / 'runs', config, executable=str(self.image / 'qemu.exe'),
                                  image_root=self.image, command=command)
        self.run_id = 'run-' + '1' * 32
        self.source = {'files': SOURCE, 'source_digest': digest(SOURCE)}

    def test_vm_has_no_network_disk_share_or_model_selected_command(self):
        candidate = self.sandbox.build(self.run_id, self.source, lambda: False)
        args = self.calls[0]
        self.assertEqual(args[args.index('-nic') + 1], 'none')
        self.assertEqual(args[args.index('-m') + 1], '1024')
        self.assertEqual(args[args.index('-machine') + 1], 'q35,accel=tcg')
        for forbidden in ['-drive', '-fsdev', '-virtfs', '-netdev', '-enable-kvm']:
            self.assertNotIn(forbidden, args)
        self.assertEqual(stat.S_IMODE(self.entries['root/job.json'][0]), 0o600)
        self.assertEqual(stat.S_IMODE(self.entries['root'][0]), 0o700)
        self.assertFalse(Path(args[args.index('-initrd') + 1]).exists())
        self.assertTrue(self.sandbox.probe(self.run_id, candidate, 'test', lambda: False)['passed'])

    def test_image_tamper_prevents_launch(self):
        (self.image / 'kernel').write_bytes(b'mutated')
        with self.assertRaises(SkillError) as err:
            self.sandbox.build(self.run_id, self.source, lambda: False)
        self.assertEqual(err.exception.code, 'ISOLATION_IMAGE_MISMATCH')
        self.assertEqual(self.calls, [])

    def test_v6_controller_is_pinned_without_changing_historical_manifest(self):
        old=(self.image/'manifest.json').read_bytes()
        control=Path(__file__).resolve().parents[2]/'modules/execution/container'
        manifest=json.loads(old)
        manifest['worker']=hashlib.sha256((control/'vm_worker_v5.py').read_bytes()).hexdigest()
        manifest['probe']=hashlib.sha256((control/'probe_v2.py').read_bytes()).hexdigest()
        (self.image/'manifest-v6.json').write_text(json.dumps(manifest))
        config=self.sandbox.config.model_copy(update={'image':'zkcoding-qemu@sha256:'+digest(manifest)})
        latest=QemuSandbox(self.root/'v6',config,executable=self.sandbox.executable,image_root=self.image)
        latest.preflight()
        self.sandbox.preflight()
        self.assertEqual(latest.worker.name,'vm_worker_v5.py')
        self.assertEqual(self.sandbox.worker.name,'vm_worker.py')
        self.assertEqual((self.image/'manifest.json').read_bytes(),old)

    def test_nonce_mismatch_is_unknown_and_not_success(self):
        self.nonce_wrong = True
        with self.assertRaises(SkillError) as err:
            self.sandbox.build(self.run_id, self.source, lambda: False)
        self.assertEqual(err.exception.code, 'VM_RESULT_UNKNOWN')

    def test_v7_cold_start_limits_are_bounded_and_historical_image_stays_pinned(self):
        old=(self.image/'manifest.json').read_bytes()
        control=Path(__file__).resolve().parents[2]/'modules/execution/container'
        manifest=json.loads(old)
        manifest['worker']=hashlib.sha256((control/'vm_worker_v6.py').read_bytes()).hexdigest()
        manifest['probe']=hashlib.sha256((control/'probe_v3.py').read_bytes()).hexdigest()
        (self.image/'manifest-v7.json').write_text(json.dumps(manifest))
        config=self.sandbox.config.model_copy(update={'image':'zkcoding-qemu@sha256:'+digest(manifest)})
        latest=QemuSandbox(self.root/'v7',config,executable=self.sandbox.executable,image_root=self.image)
        latest.preflight();self.sandbox.preflight()
        self.assertEqual(latest.worker.name,'vm_worker_v6.py')
        self.assertEqual(latest.command_timeout,300)
        self.assertEqual(self.sandbox.command_timeout,150)
        self.assertEqual((self.image/'manifest.json').read_bytes(),old)

    def test_repairable_compilation_failure_contains_diagnostic(self):
        self.build_fail = True
        with self.assertRaises(SkillError) as err:
            self.sandbox.build(self.run_id, self.source, lambda: False)
        self.assertEqual(err.exception.code, 'JAVA_BUILD_FAILED')
        self.assertIn('diagnostics', err.exception.details)

    def test_receipt_cannot_move_between_runs_or_be_rewritten(self):
        candidate = self.sandbox.build(self.run_id, self.source, lambda: False)
        with self.assertRaises(SkillError):
            self.sandbox.probe('run-' + '2' * 32, candidate, 'test', lambda: False)
        path = self.sandbox.root / candidate['receipt_ref'] / 'receipt.json'
        body = json.loads(path.read_text())
        body['test']['passed_cases'] = 999
        path.write_text(json.dumps(body))
        with self.assertRaises(SkillError) as err:
            self.sandbox.probe(self.run_id, candidate, 'test', lambda: False)
        self.assertEqual(err.exception.code, 'EVIDENCE_BINDING_MISMATCH')

    def test_source_paths_never_escape_archive_namespace(self):
        files = {'../root/job.json': 'malicious'}
        with self.assertRaises(SkillError):
            self.sandbox.build(self.run_id, {'files': files, 'source_digest': digest(files)}, lambda: False)
        self.assertEqual(self.calls, [])