| """Evaluate one submitted multi-repository candidate against frozen batch06 tests. |
| |
| No gold selection, endpoint expectations, model calls, baseline/score writes, |
| or publication. Help/import/check-only do not access Docker or create outputs. |
| """ |
| import argparse |
| import collections |
| import datetime |
| import hashlib |
| import importlib.util |
| import json |
| import os |
| from pathlib import Path, PurePosixPath |
| import re |
| import shlex |
| import shutil |
| import subprocess |
| import sys |
| from types import SimpleNamespace |
| import uuid |
|
|
| sys.dont_write_bytecode = True |
| from batch06_candidate_case_reports_v1 import parse_report |
|
|
| HERE = Path(__file__).resolve().parent |
| DEFAULT_SUPPORT = HERE if (HERE / 'evaluate_reusable_batch06_image.py').is_file() else HERE.parents[1] / 'batch06/publication' |
| OWNER = 'native-candidate-batch06-v1' |
| SUPPORT_SHA256 = { |
| 'evaluate_reusable_batch06_image.py': '99bfbe785ff03efa19a02c1755839847dfda57e9e5e93f52d7ff19381798a523', |
| 'reusable_support/batch06_case_reports.py': '71be1b571260f84a250dd6c1e4689bde8d80a4f71f6926d0103e18272145f675', |
| 'reusable_support/batch06_git_state.py': '87b2720ada6307f55e8550661ffff21267c69b547e89d254e0b82d5f2935af32', |
| 'reusable_support/batch06_runtime_resources.py': 'f68535cdf3feeb9435129649c04020ca5361a2d86aa08359ca2dccf957ecb486', |
| 'reusable_support/batch06_source_audit.py': 'fe8dcb35ca7d9fb28d4ddf484e17fa02a706d13aa928d392be708e6d499c12fd', |
| 'reusable_support/batch06_source_files.py': 'a9ccfb607e04ade3d165cf14e2fc2579326d220f93539c1e09e9ce4fbe7dab95', |
| 'reusable_support/execution_io.py': 'fca4f9c2a2fe83af2203257c1155af2db45bb065080ae47fb23378affd3cf407', |
| 'reusable_support/image_identity.py': '82764a71a677364e7dbbe40023885ca3f15bf8f307a98dd8378bfb80966decf0', |
| 'reusable_support/validation_policy.py': '42dee62ae6ac69fd6fecfa1e04530ad598e1b230fe3fd67e81047d9c44f067ea', |
| } |
| |
| |
| |
| PROFILES = { |
| 'buildpkg-conda-14674': { |
| 'task_sha256': 'daf906a285d6990dd6c378ec5f3a376814c11ad4362ce620326da132ea07fe83', |
| 'contract_sha256': '2aeef1122c363c444dd6569b5b714b12cdbe8a1059da15108fe04ab599df05f9', |
| 'registry_digest': 'sha256:d2745804b21528b350187e18ac32ffb773faef87e28b7d6327df18d6fbc91d00', |
| 'config_digest': 'sha256:ad74c088d5215e3dbbb9e25b2010192d1dfcbee09b4af2dc561a7e72a75a46bc'}, |
| 'buildpkg-conda-16510': { |
| 'task_sha256': 'b30fcf076b486b203a8c4b8c22107f00f4dbdb37a812e152a9b7cfe7c6658b9f', |
| 'contract_sha256': '3ec3d42e43282535358d0dd65693f0d2af99cc3f996316b23ea644b02e62416c', |
| 'registry_digest': 'sha256:26d1b76d1f0c27ebd3cafb61a2d58e466f73dce534057681f46725f4e74d078d', |
| 'config_digest': 'sha256:06eecf1a7bf9fb40a201c9a48a09a6046cbbdb93c4cc3933e88750ba700cbc94'}, |
| 'buildpkg-conda-16555': { |
| 'task_sha256': 'c26374c00e6c0631b58ecad2f4f138a6f46c9ba5386cb255481db35b6b353d72', |
| 'contract_sha256': '96153bfb8fb68b9392dd84e1e3aa2da614ddd0b90b2209675e41594b8907006b', |
| 'registry_digest': 'sha256:f9442940872ee8ff677cab6e19a548a8bb1e5f7a6447b4dcc8f443e6aa03fb0b', |
| 'config_digest': 'sha256:3137b95a0d6e3e466e5b08b8fc826db7c1dcad598b611459e6c151b3bdd0b2da'}, |
| 'buildpkg-meson-15997': { |
| 'task_sha256': 'dbd9f3daf089cc222ffe04837a733ce08193079ed83a8aeccdfc1dd91a8bfcf0', |
| 'contract_sha256': 'cc25cf2c67a01f65e92f91734c79dac67480e0c00479c1ea06985918a7bab5d5', |
| 'registry_digest': 'sha256:749c9f2969287b45357c2497f8e3390fb3daa40266ed263b79319c97d03c0626', |
| 'config_digest': 'sha256:9db08b84b4903472b10cd4d43b9c81d86dd4e3d6bae51d01a524cd3cd98da21c'}, |
| 'buildpkg-pnpm-11330': { |
| 'task_sha256': '0043628f0223fe1d4312e94db372d2342dc2c1978591ecabde672f250ab6471b', |
| 'contract_sha256': '425db49bef334d759f5f2c7825966042ddc0fd9d53350bcafb781f49784d4bf0', |
| 'registry_digest': 'sha256:e6c20a1727d4eb758737a9c2710a2e0a805bc534fc056929d7ddb2279b55437c', |
| 'config_digest': 'sha256:e3812fc8855ddd21aa20648162571a834da9c2e776157decd0a07aa7c350601c'}, |
| } |
| PNPM_RESOURCE_IMAGE = 'silinchen0617/crossrepo-bench@sha256:1563086d39cbdf087f748c0e845fb33921e307e605bf639393fe552c9a271372' |
| PNPM_RESOURCE_MANIFEST_SHA256 = '292b80ad4a806df8e425a7ad92545534a4a7c782514e18353a2504c6e1375931' |
| ENVIRONMENT = {'PIP_NO_INDEX': '1', 'PIP_DISABLE_PIP_VERSION_CHECK': '1', |
| 'PYTHONDONTWRITEBYTECODE': '1', 'PIP_NO_DEPS': '1', 'PIP_NO_BUILD_ISOLATION': '0', |
| 'npm_config_offline': 'true', 'FORCE_COLOR': '0'} |
|
|
|
|
| def require(value, message): |
| if not value: |
| raise ValueError(message) |
|
|
|
|
| def digest(path): |
| h = hashlib.sha256() |
| with Path(path).open('rb') as stream: |
| for block in iter(lambda: stream.read(1024 * 1024), b''): |
| h.update(block) |
| return h.hexdigest() |
|
|
|
|
| def regular(path): |
| path = Path(path).absolute() |
| require(path.is_file() and not path.is_symlink() and path == path.resolve(), 'Missing or symlinked input: ' + str(path)) |
| return path |
|
|
|
|
| def read_json(path): |
| def unique(pairs): |
| result = {} |
| for key, value in pairs: |
| require(key not in result, 'Duplicate JSON key: ' + key) |
| result[key] = value |
| return result |
| return json.loads(regular(path).read_text(), object_pairs_hook=unique, |
| parse_constant=lambda value: (_ for _ in ()).throw(ValueError('Invalid JSON constant: ' + value))) |
|
|
|
|
| def import_file(name, path): |
| spec = importlib.util.spec_from_file_location(name, path) |
| module = importlib.util.module_from_spec(spec) |
| spec.loader.exec_module(module) |
| return module |
|
|
|
|
| def load_support(directory): |
| """Load exact reviewed portable support, without running its endpoint main.""" |
| directory = Path(directory).resolve() |
| for name, expected in SUPPORT_SHA256.items(): |
| require(digest(regular(directory / name)) == expected, 'Frozen support SHA drift: ' + name) |
| names = ('batch06_case_reports', 'batch06_runtime_resources', 'image_identity', 'validation_policy', 'execution_io') |
| modules = {name: import_file('_candidate_frozen_' + name, directory / 'reusable_support' / (name + '.py')) for name in names} |
| previous = {name: sys.modules.get(name) for name in names} |
| old_path = sys.path[:] |
| try: |
| sys.modules.update(modules) |
| baseline = import_file('_candidate_frozen_batch06', directory / 'evaluate_reusable_batch06_image.py') |
| finally: |
| sys.path[:] = old_path |
| for name, module in previous.items(): |
| if module is None: |
| sys.modules.pop(name, None) |
| else: |
| sys.modules[name] = module |
| return SimpleNamespace(root=directory, code=directory / 'reusable_support', baseline=baseline, |
| reports=modules['batch06_case_reports'], runtime=modules['batch06_runtime_resources'], |
| identity=modules['image_identity'], io=modules['execution_io']) |
|
|
|
|
| def safe_patch_path(name): |
| rel = PurePosixPath(name) |
| require(name and not rel.is_absolute() and '..' not in rel.parts and '.git' not in rel.parts and '\x00' not in name, |
| 'Candidate patch escapes repository: ' + name) |
| return name |
|
|
|
|
| def git_quoted_token(data): |
| """Decode Git's C-quoted path bytes, including octal UTF-8, without shlex.""" |
| require(data.startswith(b'"'), 'Expected Git quoted path') |
| result = bytearray(); index = 1 |
| escapes = {ord('a'): 7, ord('b'): 8, ord('t'): 9, ord('n'): 10, |
| ord('v'): 11, ord('f'): 12, ord('r'): 13, ord('\\'): 92, ord('"'): 34} |
| while index < len(data): |
| value = data[index]; index += 1 |
| if value == 34: |
| return bytes(result), index |
| if value == 92: |
| require(index < len(data), 'Unterminated Git path escape') |
| value = data[index]; index += 1 |
| if value in escapes: |
| result.append(escapes[value]) |
| elif 48 <= value <= 55: |
| octal = bytes([value]) |
| while index < len(data) and len(octal) < 3 and 48 <= data[index] <= 55: |
| octal += bytes([data[index]]); index += 1 |
| number = int(octal, 8); require(number <= 255, 'Invalid Git octal path escape') |
| result.append(number) |
| else: |
| raise ValueError('Unsupported Git path escape') |
| else: |
| result.append(value) |
| raise ValueError('Unterminated Git quoted path') |
|
|
|
|
| def git_single_path(data, *, unified=False): |
| |
| if unified and data.endswith(b'\t'): |
| data = data[:-1] |
| if data.startswith(b'"'): |
| path, end = git_quoted_token(data) |
| require(end == len(data), 'Extra data after Git quoted path') |
| else: |
| require(b'\t' not in data, 'Unsupported timestamp/tab in unquoted Git header path') |
| path = data |
| return path.decode('utf-8', errors='surrogateescape') |
|
|
|
|
| def git_header_pairs(data): |
| if data.startswith(b'"'): |
| old, end = git_quoted_token(data) |
| require(data[end:end + 1] == b' ', 'Missing Git path separator') |
| return [(old.decode('utf-8', errors='surrogateescape'), git_single_path(data[end + 1:]))] |
| pairs = [] |
| for index, value in enumerate(data): |
| if value == 32 and (data[index + 1:].startswith(b'b/') or data[index + 1:].startswith(b'"b/')): |
| try: |
| pairs.append((git_single_path(data[:index]), git_single_path(data[index + 1:]))) |
| except ValueError: |
| continue |
| require(pairs, 'Cannot decode both Git diff header paths') |
| return pairs |
|
|
|
|
| def validate_patch_headers(data, numstat_paths): |
| """Bind BOTH sides of every Git/rename/copy/unified header to Git numstat. |
| |
| Supported input is standard `git diff` (including binary, rename/copy, |
| mode-only and C-quoted paths). Bare traditional/combined/ambiguous formats |
| are explicitly unsupported rather than guessing their path semantics. |
| """ |
| lines = data.split(b'\n') |
| require(not any(line.startswith((b'diff --cc ', b'diff --combined ')) for line in lines), 'Combined Git diffs are unsupported') |
| starts = [index for index, line in enumerate(lines) if line.startswith(b'diff --git ')] |
| require(starts, 'Only standard git diff patches are supported; bare unified diffs are unsupported') |
| require(not any(line.startswith((b'--- ', b'+++ ', b'rename from ', b'copy from ')) for line in lines[:starts[0]]), |
| 'Path header outside a Git diff block') |
| expected_numstat = []; inventory = [] |
| for position, start in enumerate(starts): |
| end = starts[position + 1] if position + 1 < len(starts) else len(lines) |
| metadata = {}; operation = 'change' |
| for line in lines[start + 1:end]: |
| if line.startswith((b'@@', b'GIT binary patch')): |
| break |
| require(not line.startswith(b'Binary files '), 'Binary diffs require git diff --binary') |
| for prefix, key in ((b'--- ', 'old'), (b'+++ ', 'new'), (b'rename from ', 'rename_old'), |
| (b'rename to ', 'rename_new'), (b'copy from ', 'copy_old'), (b'copy to ', 'copy_new')): |
| if line.startswith(prefix): |
| require(key not in metadata, 'Duplicate Git path header: ' + key) |
| value = git_single_path(line[len(prefix):], unified=key in ('old', 'new')) |
| if key in ('old', 'new'): |
| if value == '/dev/null': |
| value = None |
| else: |
| side = 'a/' if key == 'old' else 'b/' |
| require(value.startswith(side), 'Unsupported Git unified path prefix') |
| value = safe_patch_path(value[2:]) |
| else: |
| value = safe_patch_path(value) |
| metadata[key] = value |
| break |
| bound = None |
| for kind in ('rename', 'copy'): |
| if kind + '_old' in metadata or kind + '_new' in metadata: |
| require(bound is None and kind + '_old' in metadata and kind + '_new' in metadata, |
| 'Incomplete/conflicting Git rename/copy headers') |
| bound = (metadata[kind + '_old'], metadata[kind + '_new']); operation = kind |
| if 'old' in metadata or 'new' in metadata: |
| require('old' in metadata and 'new' in metadata, 'Incomplete Git unified path headers') |
| old, new = metadata['old'], metadata['new'] |
| require(old is not None or new is not None, 'Two null Git paths') |
| marker_pair = (old if old is not None else new, new if new is not None else old) |
| require(bound is None or marker_pair == bound, 'Git rename/copy and unified headers disagree') |
| bound = marker_pair |
| if old is None: operation = 'create' |
| elif new is None: operation = 'delete' |
| candidates = [] |
| for old, new in git_header_pairs(lines[start][len(b'diff --git '):]): |
| if old.startswith('a/') and new.startswith('b/'): |
| pair = (old[2:], new[2:]) |
| if (bound is not None and pair == bound) or (bound is None and pair[0] == pair[1]): |
| candidates.append(pair) |
| require(len(candidates) == 1, 'Ambiguous or inconsistent Git diff header paths') |
| old, new = (safe_patch_path(value) for value in candidates[0]) |
| expected_numstat.append(old if operation == 'delete' else new) |
| inventory.append({'old_path': old, 'new_path': new, 'operation': operation}) |
| require(collections.Counter(expected_numstat) == collections.Counter(numstat_paths), |
| 'Git numstat and full path-header inventories disagree') |
| return inventory |
|
|
|
|
| def validate_candidate_patches(task, mapping_file): |
| """Read patch paths and use Git's read-only numstat parser for decoded paths.""" |
| mapping_file = regular(mapping_file) |
| mapping = read_json(mapping_file) |
| require(isinstance(mapping, dict), 'Candidate mapping must be a JSON object') |
| keys = {repo['key'] for repo in task['repositories']} |
| require(set(mapping).issubset(keys), 'Unknown candidate repository key') |
| result = {} |
| for key, value in mapping.items(): |
| require(isinstance(value, str) and value, 'Candidate patch path must be a nonempty string') |
| supplied = Path(value) |
| path = regular(supplied if supplied.is_absolute() else mapping_file.parent / supplied) |
| data = path.read_bytes() |
| require(data, 'Empty candidate patch file; omit an unchanged repository') |
| argv = ['git', 'apply', '--numstat', '-z', '--'] |
| parsed = subprocess.run(argv, input=data, capture_output=True, timeout=30, |
| env={**os.environ, 'GIT_CONFIG_NOSYSTEM': '1', 'GIT_CONFIG_GLOBAL': os.devnull}) |
| require(parsed.returncode == 0 and parsed.stdout, 'Invalid candidate patch: ' + parsed.stderr.decode(errors='replace')) |
| paths = [] |
| for row in parsed.stdout.split(b'\0'): |
| if not row: |
| continue |
| fields = row.split(b'\t', 2) |
| require(len(fields) == 3, 'Malformed Git patch path inventory') |
| name = fields[2].decode('utf-8', errors='surrogateescape') |
| paths.append(safe_patch_path(name)) |
| require(paths, 'Candidate patch has no changed repository paths') |
| header_paths = validate_patch_headers(data, paths) |
| result[key] = {'path': str(path), 'sha256': hashlib.sha256(data).hexdigest(), 'bytes': len(data), |
| 'changed_paths': paths, 'validated_header_paths': header_paths, 'validation': {'argv': argv, 'returncode': parsed.returncode, |
| 'stdout_sha256': hashlib.sha256(parsed.stdout).hexdigest(), |
| 'stderr_sha256': hashlib.sha256(parsed.stderr).hexdigest()}} |
| return result |
|
|
|
|
| def prepare_inputs(bench_root, iid, mapping_file, output_dir, support_dir=DEFAULT_SUPPORT, evaluator_resource_dir=None): |
| require(iid in PROFILES, 'Unsupported candidate instance') |
| bench_root = Path(bench_root).resolve() |
| out = Path(output_dir).absolute() |
| require(out == out.resolve() and not out.exists(), 'Output must be a new non-symlink path') |
| require(not out.is_relative_to(bench_root), 'Output must be outside the release checkout') |
| support = load_support(support_dir) |
| support.baseline.ROOT = bench_root |
| inp = bench_root / 'instances' / iid |
| profile = PROFILES[iid] |
| require(digest(regular(inp / 'task.json')) == profile['task_sha256'], 'Frozen task SHA drift') |
| task = read_json(inp / 'task.json') |
| contract_path = support.baseline.checked_reference(inp, task['evaluation']) |
| require(digest(contract_path) == profile['contract_sha256'], 'Frozen contract SHA drift') |
| |
| inp, task, contract, image, resource = support.baseline.load_inputs(iid) |
| regular(bench_root / 'environments' / iid / 'image.json') |
| if iid == 'buildpkg-pnpm-11330': |
| require(resource['image_ref'] == PNPM_RESOURCE_IMAGE and |
| resource['manifest_sha256'] == PNPM_RESOURCE_MANIFEST_SHA256, 'Original PNPM runtime image/manifest binding changed') |
| for key, expected in profile.items(): |
| require(image.get(key) == expected, 'Unsupported image/input profile: ' + key) |
| require(image.get('amd64_manifest_digest') == profile['registry_digest'], 'Unreviewed image manifest') |
| require(image['image_ref'] == 'silinchen0617/crossrepo-bench@' + profile['registry_digest'], 'Unapproved image reference') |
| repositories = {repo['key']: repo for repo in task['repositories']} |
| require(len(repositories) == len(task['repositories']) == 2, 'Expected two distinct repositories') |
| require(collections.Counter(command['repository'] for command in contract['commands']) == collections.Counter(repositories.keys()), |
| 'Frozen command repository inventory mismatch') |
| for command in contract['commands']: |
| require(command['container_path'] == repositories[command['repository']]['container_path'], 'Command source path mismatch') |
| require(all(isinstance(command[kind], str) and command[kind] for kind in ('pass_to_pass', 'fail_to_pass')), 'Missing frozen command') |
| for artifact in contract.get('test_files', []): |
| support.baseline.checked_reference(inp, artifact) |
| rel = PurePosixPath(artifact.get('original_path', Path(artifact['path']).name)) |
| require(not rel.is_absolute() and '..' not in rel.parts, 'Escaping evaluator injection path') |
| for repo in repositories.values(): |
| for ref in repo['test_patches']: |
| support.baseline.checked_reference(inp, ref) |
| provided = Path(evaluator_resource_dir).absolute() if evaluator_resource_dir is not None else None |
| if provided is not None: |
| require(provided == provided.resolve() and not provided.is_symlink(), 'Symlinked evaluator resource directory') |
| if resource is None: |
| require(provided is None, 'This instance has no evaluator resource') |
| elif provided is not None: |
| support.runtime.verify_runtime_files(provided, resource) |
| patches = validate_candidate_patches(task, mapping_file) |
| source = support.baseline.checked_reference(bench_root / 'environments' / iid, image['source_manifest'], read_json=True) |
| input_files = {'task': inp / 'task.json', 'contract': inp / task['evaluation']['path'], |
| 'image': bench_root / 'environments' / iid / 'image.json', |
| 'source_manifest': support.baseline.checked_reference(bench_root / 'environments' / iid, image['source_manifest'])} |
| provenance = {'bench_root': str(bench_root), 'output_dir': str(out), |
| **{key: {'path': str(regular(path)), 'bytes': path.stat().st_size, 'sha256': digest(path)} |
| for key, path in input_files.items()}} |
| return {'iid': iid, 'bench_root': bench_root, 'inp': inp, 'task': task, 'contract': contract, 'image': image, |
| 'resource': resource, 'provided_resource': provided, 'source': source, 'support': support, |
| 'patches': patches, 'mapping_file': regular(mapping_file), 'out': out, |
| 'image_json_sha256': digest(bench_root / 'environments' / iid / 'image.json'), |
| 'mapping_sha256': digest(mapping_file), 'input_provenance': provenance} |
|
|
|
|
| def validate_git_state(task, state, label, *, expected=None, clean=False): |
| """Validate the unchanged helper's tracked HEAD/diff report for both roots. |
| |
| The staged report includes candidate + frozen test patch changes. Frozen |
| setup may create ignored/untracked build/install outputs; those are not in |
| git diff HEAD. No equality of staged/pre-test source-file inventories is |
| imposed. The tracked diff and base HEAD must remain unchanged by setup/tests. |
| """ |
| roots = {repo['container_path']: repo['base_commit'] for repo in task['repositories']} |
| require(isinstance(state, dict) and set(state) == set(roots), 'Git ' + label + ': paired root inventory mismatch') |
| for root, base in roots.items(): |
| row = state[root] |
| require(isinstance(row, dict) and set(row) == {'head', 'diff_sha256'}, 'Git ' + label + ': malformed state schema') |
| require(isinstance(row['head'], str) and re.fullmatch('[0-9a-f]{40}', row['head']) and row['head'] == base, |
| 'Git ' + label + ': HEAD differs from frozen base: ' + root) |
| require(isinstance(row['diff_sha256'], str) and re.fullmatch('[0-9a-f]{64}', row['diff_sha256']), |
| 'Git ' + label + ': malformed tracked diff SHA: ' + root) |
| if clean: |
| require(row['diff_sha256'] == hashlib.sha256(b'').hexdigest(), 'Git ' + label + ': base tracked diff is not empty') |
| if expected is not None: |
| require(state == expected, 'Git ' + label + ': tracked candidate/test source state changed') |
| return state |
|
|
|
|
| def classify(commands, repository_keys): |
| expected = {(repo, kind) for repo in repository_keys for kind in ('pass_to_pass', 'fail_to_pass')} |
| actual = [(row['repository'], row['kind']) for row in commands] |
| issues = [str(issue) for row in commands for issue in row.get('issues', [])] |
| if len(actual) != len(expected) or set(actual) != expected or any(not row.get('cases') for row in commands): |
| issues.append('Incomplete candidate command/case inventory') |
| regressions = [] |
| p2p_total = f2p_total = f2p_passed = 0 |
| for command in commands: |
| cases = command.get('cases', []) |
| if command['kind'] == 'pass_to_pass': |
| p2p_total += len(cases) |
| regressions.extend({'repository': command['repository'], 'kind': command['kind'], **row} |
| for row in cases if not row['passed']) |
| else: |
| f2p_total += len(cases); f2p_passed += sum(row['passed'] for row in cases) |
| state = ('EVALUATION_ERROR' if issues else 'P2P_REGRESSION' if regressions else |
| 'RESOLVED' if f2p_total and f2p_passed == f2p_total else 'UNRESOLVED') |
| return {'state': state, 'resolved': state == 'RESOLVED', 'issues': issues, 'p2p_total': p2p_total, |
| 'p2p_regressions': regressions, 'f2p_total': f2p_total, 'f2p_passed': f2p_passed, |
| 'f2p_failed': f2p_total - f2p_passed} |
|
|
|
|
| class Runner: |
| """Execute first; remember raw results before best-effort receipt writes.""" |
| def invoke(self, argv, *, input_bytes, timeout, target): |
| return subprocess.run(argv, input=input_bytes, capture_output=True, timeout=timeout) |
|
|
| def run(self, argv, target, timeout=180, check=True, input_bytes=None, on_result=None): |
| started = datetime.datetime.now(datetime.timezone.utc).isoformat() |
| timed_out = False |
| try: |
| result = self.invoke(argv, input_bytes=input_bytes, timeout=timeout, target=Path(target)) |
| stdout, stderr, rc = result.stdout, result.stderr, result.returncode |
| timed_out = bool(getattr(result, 'timed_out', False)) |
| except subprocess.TimeoutExpired as exc: |
| stdout, stderr, rc = exc.stdout or b'', exc.stderr or b'', -9 |
| timed_out = True |
| except OSError as exc: |
| stdout, stderr, rc = b'', (type(exc).__name__ + ': ' + str(exc)).encode(), 127 |
| target = Path(target) |
| record = {'argv': argv, 'returncode': rc, 'timed_out': timed_out, 'timeout_seconds': timeout, |
| 'started_utc': started, 'ended_utc': datetime.datetime.now(datetime.timezone.utc).isoformat(), |
| 'stdout_sha256': hashlib.sha256(stdout).hexdigest(), 'stderr_sha256': hashlib.sha256(stderr).hexdigest(), |
| 'persistence_errors': []} |
| if input_bytes is not None: |
| record['stdin_sha256'] = hashlib.sha256(input_bytes).hexdigest() |
| |
| if on_result is not None: |
| on_result(record, stdout, stderr) |
| for suffix, data in (('.stdout.log', stdout), ('.stderr.log', stderr)): |
| try: |
| target.with_suffix(suffix).write_bytes(data) |
| except Exception as exc: |
| record['persistence_errors'].append(suffix + ': ' + type(exc).__name__ + ': ' + str(exc)) |
| try: |
| atomic_write(target.with_suffix('.execution.json'), record) |
| except Exception as exc: |
| record['persistence_errors'].append('.execution.json: ' + type(exc).__name__ + ': ' + str(exc)) |
| if check and (rc or timed_out or record['persistence_errors']): |
| raise RuntimeError(target.name + ': ' + ('timeout' if timed_out else 'exit ' + str(rc)) + |
| ('; receipt persistence failed' if record['persistence_errors'] else '')) |
| return record |
|
|
|
|
| def atomic_write(path, value): |
| path = Path(path) |
| temporary = path.with_suffix(path.suffix + '.tmp') |
| with temporary.open('w') as stream: |
| json.dump(value, stream, indent=2, sort_keys=True); stream.write('\n'); stream.flush(); os.fsync(stream.fileno()) |
| temporary.replace(path) |
|
|
|
|
| def observe_host_resources(output_directory): |
| """Read Linux host availability; an unreadable/ambiguous observation fails closed.""" |
| raw = Path('/proc/meminfo').read_bytes() |
| available = [re.fullmatch(rb'MemAvailable:[ \t]+([0-9]+)[ \t]+kB', line) |
| for line in raw.splitlines() if line.startswith(b'MemAvailable:')] |
| require(len(available) == 1 and available[0] is not None, 'Expected exactly one Linux MemAvailable kB value') |
| free = shutil.disk_usage(output_directory).free |
| require(type(free) is int and free >= 0, 'Invalid host disk free bytes') |
| return {'meminfo_raw': raw, 'memory_available_bytes': int(available[0].group(1)) * 1024, |
| 'disk_free_bytes': free} |
|
|
|
|
| def record_pnpm_host_admission(cell): |
| """Persist actual host evidence immediately before the PNPM candidate create.""" |
| observed = observe_host_resources(cell) |
| minimum_memory = 80_000_000_000 |
| disk_floor = 35_000_000_000 |
| disk_margin = 256 * 1024**2 |
| admitted = (observed['memory_available_bytes'] >= minimum_memory and |
| observed['disk_free_bytes'] >= disk_floor + disk_margin) |
| raw = observed['meminfo_raw'] |
| (cell / 'host-meminfo.txt').write_bytes(raw) |
| receipt = {'schema_version': 1, 'resource_only_revision': 'pnpm11330-mem64-a01', |
| 'state': 'ADMITTED' if admitted else 'INSUFFICIENT_HOST_RESOURCES', 'admitted': admitted, |
| 'observed_utc': datetime.datetime.now(datetime.timezone.utc).isoformat(), |
| 'meminfo': {'source': '/proc/meminfo', 'path': 'candidate/host-meminfo.txt', |
| 'bytes': len(raw), 'sha256': hashlib.sha256(raw).hexdigest()}, |
| 'disk_path': str(cell.resolve()), |
| 'observed': {key: observed[key] for key in ('memory_available_bytes', 'disk_free_bytes')}, |
| 'required': {'memory_available_bytes': minimum_memory, 'disk_free_bytes': disk_floor + disk_margin, |
| 'disk_floor_bytes': disk_floor, 'disk_margin_bytes': disk_margin}, |
| 'container_profile': {'cpus': '8', 'memory': '64g', 'memory_swap': '64g'}} |
| atomic_write(cell / 'host-resource-admission.json', receipt) |
| return receipt |
|
|
|
|
| def evaluate(prepared, runner=None): |
| """One fresh candidate container; dependency injection is for offline traces.""" |
| p = prepared; runner = runner or Runner(); out = p['out']; out.mkdir(parents=True, exist_ok=False) |
| support = p['support']; task = p['task']; contract = p['contract']; image = p['image']; iid = p['iid'] |
| cell = out / 'candidate'; cell.mkdir() |
| nonce = uuid.uuid4().hex |
| name = 'crossswe-candidate-' + iid + '-' + nonce |
| status = {'schema_version': 1, 'adapter': OWNER, 'instance_id': iid, 'world': 'candidate', 'repeat': 1, |
| 'state': 'RUNNING', 'complete_case_inventory': False, |
| 'image_digest': image['registry_digest'], 'config_digest': image['config_digest'], |
| 'task_sha256': image['task_sha256'], 'contract_sha256': image['contract_sha256'], |
| 'started_utc': datetime.datetime.now(datetime.timezone.utc).isoformat(), |
| 'image': image, 'image_json_sha256': p['image_json_sha256'], 'source_manifest': p['source'], |
| 'support_sha256': SUPPORT_SHA256, |
| 'operator_sha256': {name: digest(HERE / name) for name in |
| ('evaluate_candidate_batch06_v1.py', 'batch06_candidate_case_reports_v1.py')}, |
| 'input_provenance': p['input_provenance'], 'model_calls': 0, 'score_writes': 0, 'baseline_writes': 0, |
| 'candidate_inputs': p['patches'], |
| 'candidate_mapping': {'path': str(p['mapping_file']), 'sha256': p['mapping_sha256']}, |
| 'patches': [], 'commands': [], 'git_captures': {}, 'issues': [], 'logging_errors': [], 'ownership_errors': [], 'cleanup': {'attempted': False, 'removed': False}, |
| 'container_name': name, 'ownership_nonce': nonce} |
| cid = None; identity = None; environments = {}; setup_started = False; create_attempted = False |
| memory = {}; owner_confirmed = False |
|
|
| def fail(message): |
| status.setdefault('primary_error', message) |
| if message not in status['issues']: |
| status['issues'].append(message) |
| status['state'] = 'EVALUATION_ERROR'; status['resolved'] = False; status['complete_case_inventory'] = False |
|
|
| def logging_error(message): |
| status['logging_errors'].append(message) |
| fail('Receipt persistence: ' + message) |
|
|
| def persist_status(label, strict=True): |
| try: |
| atomic_write(out / 'status.json', status) |
| return True |
| except Exception as exc: |
| logging_error(label + ': ' + type(exc).__name__ + ': ' + str(exc)) |
| if strict: |
| raise RuntimeError(label + ': status receipt persistence failed') from exc |
| return False |
|
|
| def observe(label, argv, record, stdout, stderr): |
| nonlocal cid, identity, owner_confirmed |
| memory[label] = {'record': record, 'stdout': stdout, 'stderr': stderr} |
| if record['returncode'] or record.get('timed_out'): |
| return |
| try: |
| if argv[:3] == ['docker', 'image', 'inspect']: |
| actual = json.loads(stdout)[0] |
| support.identity.validate_image(actual, image) |
| identity = actual; status['engine_image_identity'] = actual |
| elif argv[:2] == ['docker', 'create']: |
| value = stdout.decode().strip() |
| require(re.fullmatch('[0-9a-f]{64}', value), 'Docker create did not return a full immutable container ID') |
| cid = value; status['container_id'] = cid |
| elif argv[:2] == ['docker', 'inspect'] and label != 'removed-container-inspect': |
| actual = json.loads(stdout)[0] |
| labels = actual['Config'].get('Labels') or {} |
| require(identity is not None and re.fullmatch('[0-9a-f]{64}', actual['Id']) and |
| (cid is None or actual['Id'] == cid) and actual['Image'] == identity['Id'] and |
| labels.get('crossswe.owner') == OWNER and labels.get('crossswe.attempt') == nonce and |
| labels.get('crossswe.instance') == iid, 'Container ownership mismatch; refusing to operate/clean up') |
| cid = actual['Id']; status['container_id'] = cid; owner_confirmed = True |
| status['last_ownership_proof'] = {'label': label, 'container_id': cid, 'image_id': actual['Image'], |
| 'labels': labels, 'stdout_sha256': record['stdout_sha256']} |
| except Exception as exc: |
| record['observation_error'] = type(exc).__name__ + ': ' + str(exc) |
| if argv[:2] == ['docker', 'inspect']: |
| status['ownership_errors'].append(record['observation_error']) |
| owner_confirmed = False |
| fail(label + ': ' + record['observation_error']) |
|
|
| def run(argv, label, check=True, tolerate_logging=False, **kwargs): |
| nonlocal owner_confirmed |
| if argv[:2] == ['docker', 'inspect'] and label != 'removed-container-inspect': |
| owner_confirmed = False |
| record = runner.run(argv, cell / label, check=False, |
| on_result=lambda row, stdout, stderr: observe(label, argv, row, stdout, stderr), **kwargs) |
| for error in record.get('persistence_errors', []): |
| logging_error(label + ': ' + error) |
| if record.get('observation_error'): |
| if not tolerate_logging: |
| raise RuntimeError(label + ': ' + record['observation_error']) |
| if record.get('persistence_errors') and not tolerate_logging: |
| raise RuntimeError(label + ': receipt persistence failed') |
| if check and (record['returncode'] or record.get('timed_out')): |
| raise RuntimeError(label + ': ' + ('timeout' if record.get('timed_out') else 'exit ' + str(record['returncode']))) |
| return record |
|
|
| def read_output(label): |
| return memory[label]['stdout'] |
|
|
| def execute(command, label, cwd='/testbed', env=None, check=True, timeout=14400, tolerate_logging=False): |
| argv = ['docker', 'exec', '-w', cwd] |
| for key, value in (env or {}).items(): |
| argv += ['-e', key + '=' + value] |
| return run(argv + [cid, 'bash', '-lc', command], label, check=check, timeout=timeout, tolerate_logging=tolerate_logging) |
|
|
| def capture(script, label, filename): |
| data = (support.code / script).read_bytes() |
| require(hashlib.sha256(data).hexdigest() == SUPPORT_SHA256['reusable_support/' + script], 'Support changed during execution') |
| result = run(['docker', 'exec', '-i', cid, 'python3', '-'], label, input_bytes=data, timeout=300) |
| if script == 'batch06_git_state.py': |
| try: |
| state = support.reports.decode(read_output(label).decode('utf-8', errors='strict')) |
| expected = None |
| if label == 'git-before': |
| expected = status['git_captures']['staged-git-state']['state'] |
| elif label.endswith('-git-after'): |
| expected = status['git_captures']['git-before']['state'] |
| validate_git_state(task, state, label, expected=expected, clean=label == 'base-git-state') |
| status['git_captures'][label] = {'state': state, 'stdout_sha256': result['stdout_sha256']} |
| except Exception as exc: |
| raise ValueError('Git capture ' + label + ': ' + str(exc)) from exc |
| try: |
| (cell / filename).write_bytes(read_output(label)) |
| except Exception as exc: |
| logging_error(label + ': ' + filename + ': ' + type(exc).__name__ + ': ' + str(exc)) |
| raise |
|
|
| def inspect(label, tolerate_logging=False): |
| record = run(['docker', 'inspect', cid], label, check=False, tolerate_logging=tolerate_logging) |
| require(record['returncode'] == 0 and not record.get('timed_out') and owner_confirmed and |
| not status['ownership_errors'], 'Owned container inspection failed or ownership is blocked') |
| return json.loads(read_output(label))[0] |
|
|
| try: |
| persist_status('initial') |
| |
| |
| require(digest(regular(p['bench_root'] / 'environments' / iid / 'image.json')) == p['image_json_sha256'], 'Image descriptor SHA drift after preparation') |
| require(digest(regular(p['inp'] / 'task.json')) == image['task_sha256'], 'Frozen task SHA drift after preparation') |
| require(digest(regular(p['inp'] / task['evaluation']['path'])) == image['contract_sha256'], 'Frozen contract SHA drift after preparation') |
| require(digest(regular(p['mapping_file'])) == p['mapping_sha256'], 'Candidate mapping SHA drift after preparation') |
| snapshots = out / 'candidate-inputs'; snapshots.mkdir() |
| (snapshots / 'patches.json').write_bytes(p['mapping_file'].read_bytes()) |
| for key, patch in p['patches'].items(): |
| require(digest(regular(patch['path'])) == patch['sha256'], 'Candidate patch SHA drift') |
| snapshot = snapshots / (key + '.patch'); snapshot.write_bytes(Path(patch['path']).read_bytes()) |
| require(digest(snapshot) == patch['sha256'], 'Candidate patch changed while snapshotting') |
| run(['docker', 'pull', '--platform', 'linux/amd64', image['image_ref']], 'image-pull', timeout=1800) |
| run(['docker', 'image', 'inspect', image['image_ref']], 'image-inspect') |
| identity = json.loads(read_output('image-inspect'))[0]; support.identity.validate_image(identity, image) |
| status['engine_image_identity'] = identity |
| assets = support.runtime.materialize_runtime(p['resource'], out / 'evaluator-resources', p['provided_resource']) |
| if p['resource'] is not None: |
| status['resource_materialization'] = { |
| 'mode': 'provided-verified-directory' if p['provided_resource'] is not None else 'pinned-helper-managed-private-image', |
| 'provided_dir': str(p['provided_resource']) if p['provided_resource'] is not None else None, |
| 'helper_sha256': SUPPORT_SHA256['reusable_support/batch06_runtime_resources.py'], |
| 'default_resource_container_commands_logged': False, |
| 'verified_files': [{'path': str(path.relative_to(out)), 'bytes': path.stat().st_size, 'sha256': digest(path)} |
| for path in sorted(assets.rglob('*')) if path.is_file()]} |
| persist_status('resource-materialization') |
| cpus, memory_limit = ('8', '64g') if iid == 'buildpkg-pnpm-11330' else ('2', '3g') |
| if iid == 'buildpkg-pnpm-11330': |
| status['host_resource_admission'] = record_pnpm_host_admission(cell) |
| persist_status('host-resource-admission') |
| require(status['host_resource_admission']['admitted'], 'Insufficient host resources for PNPM 64GiB candidate') |
| create_attempted = True |
| run(['docker', 'create', '--name', name, '--network', 'none', '--cpus', cpus, '--memory', memory_limit, |
| '--memory-swap', memory_limit, '--label', 'crossswe.owner=' + OWNER, '--label', 'crossswe.attempt=' + nonce, |
| '--label', 'crossswe.instance=' + iid, image['image_ref'], 'sleep', 'infinity'], 'create') |
| cid = read_output('create').decode().strip() |
| require(re.fullmatch('[0-9a-f]{64}', cid), 'Docker create did not return a full immutable container ID') |
| status['container_id'] = cid |
| run(['docker', 'start', cid], 'start') |
| info = inspect('initial-container-inspect') |
| require(not info['Mounts'] and info['HostConfig']['NetworkMode'] == 'none', 'Container isolation mismatch') |
| require(info['HostConfig']['NanoCpus'] == int(cpus) * 10**9 and |
| info['HostConfig']['Memory'] == int(memory_limit[:-1]) * 1024**3 and |
| info['HostConfig']['MemorySwap'] == info['HostConfig']['Memory'], 'Container resource budget mismatch') |
| status['container_isolation'] = {'mounts': info['Mounts'], 'network': info['HostConfig']['NetworkMode'], |
| 'cpus': cpus, 'memory': memory_limit} |
| capture('batch06_source_audit.py', 'base-source-audit', 'agent-source-audit.json') |
| audited = json.loads((cell / 'agent-source-audit.json').read_text())['manifest'] |
| support.baseline.validate_source_manifest(audited, task) |
| require(audited == p['source'], 'Agent source manifest differs from published image binding') |
| capture('batch06_git_state.py', 'base-git-state', 'git-state-base.json') |
| |
| for repo in task['repositories']: |
| execute('git diff --exit-code HEAD && test -z "$(git status --porcelain)"', repo['key'] + '-clean', repo['container_path']) |
| for repo in task['repositories']: |
| key = repo['key']; patch = p['patches'].get(key) |
| if patch is None: |
| continue |
| snapshot = snapshots / (key + '.patch'); dst = '/tmp/crossswe-candidate-' + key + '.patch' |
| run(['docker', 'cp', str(snapshot), cid + ':' + dst], key + '-candidate-copy') |
| execution = execute('git apply --check ' + shlex.quote(dst) + ' && git apply ' + shlex.quote(dst), key + '-candidate-apply', repo['container_path']) |
| status['patches'].append({'repository': key, 'kind': 'candidate', **patch, 'snapshot': str(snapshot.relative_to(out)), |
| 'container_path': dst, 'application': execution}) |
| for repo in task['repositories']: |
| for index, patch in enumerate(repo['test_patches'], 1): |
| source = support.baseline.checked_reference(p['inp'], patch) |
| dst = '/tmp/crossswe-frozen-test-' + repo['key'] + '-' + str(index) + '.patch' |
| label = repo['key'] + '-frozen-test-' + str(index) |
| run(['docker', 'cp', str(source), cid + ':' + dst], label + '-copy') |
| execution = execute('git apply --check ' + shlex.quote(dst) + ' && git apply ' + shlex.quote(dst), label + '-apply', repo['container_path']) |
| status['patches'].append({'repository': repo['key'], 'kind': 'frozen_test', **patch, 'application': execution}) |
| capture('batch06_source_files.py', 'staged-source', 'source-files-staged.json') |
| capture('batch06_git_state.py', 'staged-git-state', 'git-state-staged.json') |
| execute('mkdir -p /crossrepo-patches /artifacts', 'evaluator-dirs') |
| for number, artifact in enumerate(contract.get('test_files', [])): |
| source = support.baseline.checked_reference(p['inp'], artifact) |
| rel = PurePosixPath(artifact.get('original_path', source.name)) |
| execute('mkdir -p ' + shlex.quote('/crossrepo-patches/' + str(rel.parent)), 'evaluator-parent-' + str(number)) |
| run(['docker', 'cp', str(source), cid + ':/crossrepo-patches/' + str(rel)], 'inject-' + str(number)) |
| if p['resource'] is not None: |
| support.runtime.verify_runtime_files(assets, p['resource']) |
| for number, mapping in enumerate(p['resource']['injections']): |
| source = assets / mapping['source']; require(source.is_dir() and not source.is_symlink(), 'Missing runtime injection') |
| execute('mkdir -p ' + shlex.quote(str(PurePosixPath(mapping['destination']).parent)), 'runtime-parent-' + str(number)) |
| run(['docker', 'cp', str(source), cid + ':' + mapping['destination']], 'runtime-copy-' + str(number)) |
| status['evaluator_resource'] = p['resource'] |
| commands = contract['commands'] |
| environments = {command['repository']: {**ENVIRONMENT, **command.get('environment', {})} for command in commands} |
| setup_started = True |
| for command in sorted(commands, key=lambda row: row.get('setup_order') or 0): |
| if command.get('setup_command'): |
| execute(command['setup_command'], command['repository'] + '-source-setup', command['container_path'], environments[command['repository']]) |
| for command in sorted(commands, key=lambda row: row.get('evaluation_setup_order') or 0): |
| if command.get('evaluation_setup_command'): |
| execute(command['evaluation_setup_command'], command['repository'] + '-evaluator-setup', |
| command.get('evaluation_setup_cwd') or command['container_path'], environments[command['repository']]) |
| for command in commands: |
| if command.get('evaluation_ready_command'): |
| execute(command['evaluation_ready_command'], command['repository'] + '-ready', command['container_path'], environments[command['repository']]) |
| capture('batch06_source_files.py', 'source-before', 'source-files.json') |
| capture('batch06_git_state.py', 'git-before', 'git-state.json') |
| for command in commands: |
| for kind in ('pass_to_pass', 'fail_to_pass'): |
| label = command['repository'] + '-' + kind |
| execution = execute(command[kind], label, command.get('test_cwd') or command['container_path'], |
| environments[command['repository']], check=False) |
| native = cell / 'native-artifacts'; native.mkdir(exist_ok=True) |
| run(['docker', 'cp', cid + ':/artifacts/.', str(native)], label + '-capture-native-artifacts') |
| capture('batch06_source_files.py', label + '-source-after', 'source-files-after.json') |
| capture('batch06_git_state.py', label + '-git-after', 'git-state-after.json') |
| stdout = read_output(label).decode('utf-8', errors='strict') |
| stderr = memory[label]['stderr'].decode('utf-8', errors='strict') |
| rows, issues, metadata = parse_report(iid, command['repository'], kind, stdout, stderr, |
| execution['returncode'], cell, frozen=support.reports) |
| if execution.get('timed_out'): |
| issues.append('Native command timed out') |
| status['commands'].append({'repository': command['repository'], 'kind': kind, 'command': command[kind], |
| 'cwd': command.get('test_cwd') or command['container_path'], 'environment': environments[command['repository']], |
| 'returncode': execution['returncode'], 'passed': sum(row['passed'] for row in rows), |
| 'failed': sum(not row['passed'] for row in rows), 'cases': rows, 'issues': issues, |
| 'report_metadata': metadata, 'raw_receipt': str((cell / (label + '.execution.json')).relative_to(out))}) |
| persist_status(label) |
| if execution.get('timed_out'): |
| raise RuntimeError('Native command timed out; stop before dispatching another command') |
| outcome = classify(status['commands'], [repo['key'] for repo in task['repositories']]) |
| status.update({key: value for key, value in outcome.items() if key != 'state'}) |
| if outcome['issues']: |
| status.setdefault('primary_error', outcome['issues'][0]) |
| status['candidate_outcome'] = outcome['state'] |
| status['complete_case_inventory'] = outcome['state'] != 'EVALUATION_ERROR' |
| status['state'] = 'VALID_CANDIDATE_EVALUATION' if status['complete_case_inventory'] else 'EVALUATION_ERROR' |
| status['p2p'] = {'total': outcome['p2p_total'], 'passed': outcome['p2p_total'] - len(outcome['p2p_regressions']), |
| 'failed': len(outcome['p2p_regressions']), 'regressions': outcome['p2p_regressions']} |
| status['f2p'] = {'total': outcome['f2p_total'], 'passed': outcome['f2p_passed'], 'failed': outcome['f2p_failed']} |
| except Exception as exc: |
| fail(type(exc).__name__ + ': ' + str(exc)) |
| finally: |
| if create_attempted and cid is None and identity and not status['ownership_errors']: |
| try: |
| run(['docker', 'inspect', name], 'recover-owned-container', check=False, tolerate_logging=True) |
| except Exception as exc: |
| fail('Failed-create ownership recovery: ' + type(exc).__name__ + ': ' + str(exc)) |
| if cid and identity and not status['ownership_errors']: |
| try: |
| info = inspect('final-container-inspect', tolerate_logging=True) |
| status['final_container_state'] = info.get('State', {}) |
| if info.get('State', {}).get('OOMKilled'): |
| fail('Container OOMKilled') |
| except Exception as exc: |
| fail('Owned container cleanup inspection: ' + type(exc).__name__ + ': ' + str(exc)) |
| if owner_confirmed and not status['ownership_errors']: |
| |
| |
| if setup_started: |
| for command in reversed(contract['commands']): |
| if command.get('evaluation_teardown_command'): |
| try: |
| execute(command['evaluation_teardown_command'], command['repository'] + '-teardown', |
| command['container_path'], environments[command['repository']], tolerate_logging=True) |
| except Exception as exc: |
| fail('Teardown: ' + type(exc).__name__ + ': ' + str(exc)) |
| steps = [(['docker', 'cp', cid + ':/artifacts', str(cell / 'native-artifacts-final')], 'final-native-artifacts', 180), |
| (['docker', 'stop', '--time', '1', cid], 'stop', 30), |
| (['docker', 'rm', cid], 'remove', 30), |
| (['docker', 'inspect', cid], 'removed-container-inspect', 180)] |
| status['cleanup'].update(attempted=True, container_id=cid) |
| for argv, label, timeout in steps: |
| try: |
| result = run(argv, label, check=False, timeout=timeout, tolerate_logging=True) |
| if label != 'removed-container-inspect' and (result['returncode'] or result.get('timed_out')): |
| fail(label + ': ' + ('timeout' if result.get('timed_out') else 'exit ' + str(result['returncode']))) |
| except Exception as exc: |
| fail(label + ': ' + type(exc).__name__ + ': ' + str(exc)) |
| removed = memory.get('remove', {}).get('record', {}) |
| absent = memory.get('removed-container-inspect', {}).get('record', {}) |
| missing_message = memory.get('removed-container-inspect', {}).get('stderr', b'').decode(errors='replace') |
| status['cleanup']['removed'] = (removed.get('returncode') == 0 and not removed.get('timed_out') and |
| absent.get('returncode') == 1 and not absent.get('timed_out') and |
| re.search(r'No such (?:object|container)', missing_message, re.I) is not None) |
| if not status['cleanup']['removed']: |
| fail('Owned container cleanup was not verified') |
| if status['ownership_errors']: |
| fail('Sticky ownership errors prohibit cleanup of a foreign/unverified container') |
| if status['issues']: |
| status['state'] = 'EVALUATION_ERROR'; status['resolved'] = False; status['complete_case_inventory'] = False |
| status['ended_utc'] = datetime.datetime.now(datetime.timezone.utc).isoformat() |
| status['receipt_persisted'] = True |
| if not persist_status('final', strict=False): |
| status['receipt_persisted'] = False |
|
|
| return status |
|
|
|
|
| def main(argv=None): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument('--bench-root', type=Path, required=True, help='Portable Bench checkout with instances/ and published environments/') |
| parser.add_argument('--support-dir', type=Path, default=DEFAULT_SUPPORT, help='Pinned batch06 publication runner and reusable_support/') |
| parser.add_argument('--instance-id', required=True, choices=sorted(PROFILES)) |
| parser.add_argument('--candidate-patches', type=Path, required=True, help='JSON repository-key to patch-path object; omitted key leaves its base unchanged') |
| parser.add_argument('--output-dir', type=Path, required=True) |
| parser.add_argument('--evaluator-resource-dir', type=Path) |
| parser.add_argument('--check-only', action='store_true') |
| args = parser.parse_args(argv) |
| try: |
| prepared = prepare_inputs(args.bench_root, args.instance_id, args.candidate_patches, args.output_dir, |
| args.support_dir, args.evaluator_resource_dir) |
| if args.check_only: |
| print(json.dumps({'instance_id': args.instance_id, 'state': 'INPUTS_VERIFIED', 'world': 'candidate', |
| 'image': prepared['image']['image_ref'], 'patches': prepared['patches'], |
| 'evaluator_resources': prepared['resource'], 'model_calls': 0, 'score_writes': 0, |
| 'runtime_validation': 'NOT_RUN'})) |
| return 0 |
| status = evaluate(prepared) |
| print(json.dumps({'instance_id': args.instance_id, 'state': status['state'], 'resolved': status.get('resolved', False), |
| 'receipt': str(prepared['out'] / 'status.json'), 'receipt_persisted': status.get('receipt_persisted', False), |
| 'issues': status['issues'], 'logging_errors': status['logging_errors']})) |
| return 2 if status['state'] == 'EVALUATION_ERROR' else 0 |
| except (ValueError, OSError, KeyError, TypeError) as exc: |
| print(type(exc).__name__ + ': ' + str(exc), file=sys.stderr) |
| return 2 |
|
|
|
|
| if __name__ == '__main__': |
| raise SystemExit(main()) |
|
|
