Files
rust-discovery/deploy/server_build_221.py
T
2026-11-16 17:46:54 +01:00

112 lines
5.5 KiB
Python

#!/usr/bin/env python3
"""Freeze only the approved Windows221 server closure; build without deployment."""
import argparse
import gzip
import inspect
import io
import json
import os
from pathlib import Path
import subprocess
import tarfile
import uuid
import server_build_only as build
def freeze(source, web):
os.umask(0o077)
source = source.resolve()
web = web.resolve()
assert source.is_relative_to(build.ROOT / 'devstate')
assert web.is_relative_to(build.ROOT / 'devstate')
baseline = build.ROOT / 'devstate/server-build-only/a48f78614e2e/package/source'
allowed = {
'crates/domain/src/lib.rs',
'crates/domain/src/windows_system_nonstart.rs',
'crates/server/src/main.rs',
'crates/server/src/job_gateway.rs',
'crates/server/src/synchronization.rs',
'crates/server/src/windows_system_nonstart.rs',
'migrations/0021_windows_system_nonstart.sql',
'web/src/main.tsx',
'web/src/system-nonstart-review.tsx',
'web/src/system-nonstart-review.test.tsx',
'web/src/system-nonstart-review.test.ts',
}
def regular_files(folder):
result = {}
for path in sorted(folder.rglob('*')):
assert not path.is_symlink(), 'Frozen closure must not contain symlinks'
if path.is_file():
assert path.stat().st_size <= 16 * 1024 * 1024
result[str(path.relative_to(folder))] = path.read_bytes()
return result
original = regular_files(baseline)
frozen = regular_files(source)
assert set(original) <= set(frozen), 'No baseline source removal'
changed = {name for name, raw in frozen.items() if original.get(name) != raw}
assert changed <= allowed and 'crates/server/src/windows_system_nonstart.rs' in changed
assert 'migrations/0021_windows_system_nonstart.sql' in changed
assert any(b'windows-system-nonstart-221' in raw for raw in regular_files(web).values())
before = build.ssh(inspect.getsource(build.preflight).replace(
'PARAMETERS', repr({'builder': build.BUILDER})) + '\nprint(__import__("json").dumps(preflight()))\n')
assert before['disk_available_bytes'] > 8 * 1024**3
ident = uuid.uuid4().hex[:12]
folder = build.ROOT / 'devstate/server-build-only' / ident
folder.mkdir(mode=0o700, parents=True)
files = {'source/' + name: raw for name, raw in frozen.items()}
inputs = {name: build.sha(raw) for name, raw in frozen.items()}
assert regular_files(source) == frozen, 'Source closure drift'
files['inputs.sha256'] = ''.join(h + ' ' + n + '\n' for n, h in inputs.items()).encode()
files['Dockerfile'] = (
'FROM ' + build.BUILDER + ' AS build\nWORKDIR /src\n'
'COPY source/ /src/\nCOPY inputs.sha256 /tmp/rmm-build-inputs.sha256\n'
'RUN sha256sum -c /tmp/rmm-build-inputs.sha256 && '
'cargo clippy --offline --locked -p rmm-server -p rmm-time-broker-linux '
'--all-targets -- -D warnings && '
'cargo build --offline --locked --release -p rmm-server -p rmm-time-broker-linux --bins\n'
'FROM ' + before['units']['api']['image'] + '\n'
'COPY --from=build /src/target/release/rmm-server /usr/local/bin/rmm-server\n'
'COPY --from=build /src/target/release/rmm-time-broker-linux /usr/local/bin/rmm-time-broker-linux\n'
).encode()
for name, raw in regular_files(web).items():
files['web/' + name] = raw
manifest = {
'schema_version': 1, 'release': 'server221-' + ident,
'git_base': subprocess.check_output(['git', 'rev-parse', 'HEAD'], text=True).strip(),
'builder': build.BUILDER, 'preflight': before, 'source_files': inputs,
'baseline_source_manifest': 'a48f78614e2e', 'changed_source_files': sorted(changed),
'web': {n[4:]: build.sha(raw) for n, raw in files.items() if n.startswith('web/')},
'file_hashes': {n: build.sha(raw) for n, raw in files.items()},
'build_only': True, 'runtime_deployment': False, 'migration_executed': False,
}
files['manifest.json'] = json.dumps(manifest, sort_keys=True, indent=2).encode()
for name, raw in files.items():
build.write(folder / 'package' / name, raw)
buffer = io.BytesIO()
with tarfile.open(fileobj=buffer, mode='w') as archive:
for name, raw in sorted(files.items()):
member = tarfile.TarInfo(name)
member.size = len(raw)
member.mode = 0o400
archive.addfile(member, io.BytesIO(raw))
raw = gzip.compress(buffer.getvalue(), mtime=0)
build.write(folder / 'package.tar.gz', raw)
sealed = dict(release=manifest['release'], sha256=build.sha(raw),
manifest_sha256=build.sha(files['manifest.json']), bytes=len(raw), source_count=len(inputs))
build.write(folder / 'sealed.json', json.dumps(sealed, sort_keys=True, indent=2).encode())
params = {**sealed, 'worker': inspect.getsource(build.worker).replace('PARAMETERS', repr(sealed)) + '\nworker()\n'}
result = build.ssh(inspect.getsource(build.stage).replace('PARAMETERS', repr(params))
+ '\nprint(__import__("json").dumps(stage()))\n', raw=raw)
build.write(folder / 'stage-result.json', json.dumps(result, sort_keys=True, indent=2).encode())
print(json.dumps(dict(folder=str(folder), sealed=sealed, stage=result)))
if __name__ == '__main__':
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--source', required=True, type=Path)
parser.add_argument('--web', required=True, type=Path)
args = parser.parse_args()
freeze(args.source, args.web)