publish releases: build every platform before uploading, write the files, the record and releases/latest, and rename kepr.build in migrate (3.0.82)

@@ -0,0 +1,162 @@1+//! Releases: the built files, the record that names them, and their keys in the2+//! bucket.3+//!4+//! A version exists the moment its `release.json` lands (§11.2), so history goes5+//! up first, then every file, then the record, and `releases/latest` moves last.6+//! Kepr reads all of it back field by field, so this record and `ReleaseRecord`7+//! in Kepr's `src/bucket/repo.ts` are one contract: a name here that Kepr8+//! refuses would fail the whole repo's sync.9+10+module release11+12+import crypto.sha25613+import json214+import os15+import time16+import src.build17+import src.exchange18+import src.history19+import src.machine20+import src.remote21+import src.storage22+23+// The version a key is built from is validated where it is read24+// (`build.project_version`), so it cannot carry a path anywhere.25+pub fn release_key(repo string, version string) string {26+	return '${repo}/releases/${version}/release.json'27+}28+29+pub fn file_key(repo string, version string, platform string, name string) string {30+	return '${repo}/releases/${version}/${platform}/${name}'31+}32+33+pub fn latest_key(repo string) string {34+	return '${repo}/releases/latest'35+}36+37+// One built file, as Kepr reads it.38+pub struct File {39+pub:40+	platform string41+	name     string42+	size     i6443+	blake3   string44+	sha256   string45+}46+47+pub struct Record {48+pub:49+	format       int = 150+	repo         string51+	version      string52+	save         string53+	published_at i6454+	machine      string55+	notes        string56+	files        []File57+}58+59+pub struct Published {60+pub:61+	version string62+	files   []File63+}64+65+// publish builds every platform, then uploads the files, the record, and the66+// new latest. Every build runs before the first upload: one platform failing67+// must leave the bucket exactly as it was.68+pub fn publish(store &storage.Store, mut backend remote.Backend, repo string,69+	config build.Config, version string, notes string) !Published {70+	head := history.head(store) or { return error(exchange.no_saves) }71+	mut built := []build.Built{}72+	for platform in config.platforms {73+		built << build.build_one(store.root, config, platform, version)!74+	}75+	mut files := []File{}76+	for artifact in built {77+		// Read once: both hashes come from the same bytes, and a release file78+		// can be tens of megabytes.79+		bytes := os.read_file(os.join_path(store.root, artifact.path))!.bytes()80+		file := describe(artifact, bytes)!81+		upload(mut backend, repo, version, file, bytes)!82+		files << file83+	}84+	record := Record{85+		repo:         repo86+		version:      version87+		save:         head.id88+		published_at: time.now().unix()89+		machine:      machine.name()90+		notes:        notes91+		files:        files92+	}93+	// The record is what makes the version real. `put_if_absent`, so a record94+	// already there stays: published versions never change.95+	backend.put_if_absent(release_key(repo, version), json2.encode(record).bytes())!96+	move_latest(mut backend, repo, version)!97+	return Published{98+		version: version99+		files:   files100+	}101+}102+103+// describe is one file's record, hashed from the bytes the upload sends.104+fn describe(artifact build.Built, bytes []u8) !File {105+	name := os.base(artifact.path)106+	if !good_name(name) {107+		return error('"${name}" cannot name a release file — no slash, backslash, quote or control character, and not "." or ".."')108+	}109+	return File{110+		platform: artifact.platform111+		name:     name112+		size:     i64(bytes.len)113+		blake3:   storage.hash_hex(bytes)114+		sha256:   sha256.sum256(bytes).hex()115+	}116+}117+118+// good_name is Kepr's rule for a release file name: what Kepr refuses to read,119+// Koh must not write.120+fn good_name(name string) bool {121+	if name == '' || name.len > 255 || name == '.' || name == '..' {122+		return false123+	}124+	return !name.bytes().any(it == `/` || it == `\\` || it == `"` || it < 32 || it == 127)125+}126+127+// upload puts one file at its key. A key that is already there is a retry of an128+// interrupted publish when the bytes match, and a refusal when they do not:129+// published versions never change (§11.2).130+fn upload(mut backend remote.Backend, repo string, version string, file File, bytes []u8) ! {131+	key := file_key(repo, version, file.platform, file.name)132+	if backend.put_if_absent(key, bytes)! {133+		return134+	}135+	existing := backend.get(key)!136+	if !existing.found || storage.hash_hex(existing.body) != file.blake3 {137+		return error('version ${version} already has a different ${file.name}')138+	}139+}140+141+// move_latest swaps the version pointer, which is the last step: until it moves,142+// nothing about this version is visible.143+fn move_latest(mut backend remote.Backend, repo string, version string) ! {144+	current := backend.get(latest_key(repo))!145+	if !backend.put_if_match(latest_key(repo), version.bytes(), current.tag)! {146+		return error('${repo}/releases/latest moved while publishing — run it again')147+	}148+}149+150+// check_notes is Koh 2's rule for `--notes`, applied when one is given: a note151+// that says nothing is worse than none, so a short one is refused. No notes at152+// all is ordinary — the release then shows its save's message in Kepr.153+pub fn check_notes(notes string) ! {154+	trimmed := notes.trim_space()155+	if trimmed == '' {156+		return157+	}158+	words := trimmed.split_any(' \t\r\n').filter(it != '').len159+	if trimmed.len < 40 || words < 12 {160+		return error('--notes must be at least 40 characters and at least 12 words; that one is ${trimmed.len} characters and ${words} words')161+	}162+}

@@ -0,0 +1,208 @@1+//! Folder-backend tests for publishing: what lands in the bucket, what a retry2+//! does, what a second build of the same version does, and the notes rule.3+4+module release5+6+import json27+import os8+import time9+import src.build10+import src.history11+import src.machine12+import src.remote13+import src.snapshot14+import src.storage15+16+fn scratch(name string) !string {17+	dir := os.join_path(os.temp_dir(), 'koh3_release_${os.getpid()}_${name}')18+	os.rmdir_all(dir) or {}19+	os.mkdir_all(dir, os.MkdirParams{})!20+	return dir21+}22+23+fn write(root string, rel string, text string) ! {24+	full := os.join_path(root, rel)25+	os.mkdir_all(os.dir(full), os.MkdirParams{})!26+	os.write_file(full, text)!27+}28+29+fn open_repo(name string) !storage.Store {30+	dir := os.join_path(os.temp_dir(), 'koh3_release_proj_${os.getpid()}_${name}')31+	os.rmdir_all(dir) or {}32+	os.mkdir_all(dir, os.MkdirParams{})!33+	mut store := storage.create(dir)!34+	write(dir, '.kohignore', '*.log\n')!35+	return store36+}37+38+fn make_save(store &storage.Store, message string) !history.Save {39+	return history.save_worktree(store, store.root, snapshot.load(store.root), history.SaveInput{40+		message: message41+	})!42+}43+44+// The build writes the file `output` names, by hand: only `output` takes the45+// {version} and {platform} tokens.46+fn demo_config(store &storage.Store, platforms string) !build.Config {47+	write(store.root, 'VERSION', '1.2.3\n')!48+	mut command := 'mkdir -p out'49+	for platform in platforms.split(',') {50+		trimmed := platform.trim_space()51+		command += ' && printf koh > out/demo-1.2.3-${trimmed}'52+	}53+	write(store.root, 'koh.build', 'command = ${command}54+output = out/demo-{version}-{platform}55+platforms = ${platforms}56+')!57+	return build.read_config(store.root)!58+}59+60+fn test_publishing_writes_the_files_the_record_and_latest() {61+	base := scratch('publish')!62+	defer {63+		os.rmdir_all(base) or {}64+	}65+	mut store := open_repo('publish')!66+	defer {67+		store.close()68+	}69+	config := demo_config(store, 'macos-aarch64')!70+	head := make_save(store, 'first')!71+	mut backend := remote.new_folder(os.join_path(base, 'remote'))!72+73+	published := publish(store, mut backend, 'proj', config, '1.2.3', '')!74+	assert published.version == '1.2.3'75+	assert published.files.len == 176+77+	name := 'demo-1.2.3-macos-aarch64'78+	artifact := backend.get(file_key('proj', '1.2.3', 'macos-aarch64', name))!79+	assert artifact.found80+	assert artifact.body.bytestr() == 'koh'81+82+	record := json2.decode[Record](backend.get(release_key('proj', '1.2.3'))!.body.bytestr())!83+	assert record.format == 184+	assert record.repo == 'proj'85+	assert record.version == '1.2.3'86+	assert record.save == head.id87+	assert record.machine == machine.name()88+	assert record.notes == ''89+	assert record.files.len == 190+	assert record.files[0].platform == 'macos-aarch64'91+	assert record.files[0].name == name92+	assert record.files[0].size == 393+	assert record.files[0].blake3 == storage.hash_hex('koh'.bytes())94+	assert record.files[0].sha256.len == 6495+	// The record is what makes the version exist, and latest moves last.96+	assert backend.get(latest_key('proj'))!.body.bytestr() == '1.2.3'97+}98+99+// An interrupted publish leaves files behind; running it again finishes it,100+// because the same bytes are the same release.101+fn test_a_publish_retries_after_a_partial_upload() {102+	base := scratch('retry')!103+	defer {104+		os.rmdir_all(base) or {}105+	}106+	mut store := open_repo('retry')!107+	defer {108+		store.close()109+	}110+	config := demo_config(store, 'macos-aarch64, linux-aarch64')!111+	make_save(store, 'first')!112+	mut backend := remote.new_folder(os.join_path(base, 'remote'))!113+114+	publish(store, mut backend, 'proj', config, '1.2.3', '')!115+	// Stand in for a run that stopped before the record and the pointer: both116+	// are removed, the uploaded files stay.117+	backend.delete(release_key('proj', '1.2.3'))!118+	backend.delete(latest_key('proj'))!119+	again := publish(store, mut backend, 'proj', config, '1.2.3', '')!120+	assert again.files.len == 2121+	assert backend.get(release_key('proj', '1.2.3'))!.found122+	assert backend.get(latest_key('proj'))!.body.bytestr() == '1.2.3'123+	assert backend.get(file_key('proj', '1.2.3', 'macos-aarch64', 'demo-1.2.3-macos-aarch64'))!.found124+	assert backend.get(file_key('proj', '1.2.3', 'linux-aarch64', 'demo-1.2.3-linux-aarch64'))!.found125+}126+127+// A published version never changes: a second build with different bytes for128+// the same platform is refused before anything is uploaded.129+fn test_a_different_file_for_a_published_version_is_refused() {130+	base := scratch('changed')!131+	defer {132+		os.rmdir_all(base) or {}133+	}134+	mut store := open_repo('changed')!135+	defer {136+		store.close()137+	}138+	config := demo_config(store, 'macos-aarch64')!139+	make_save(store, 'first')!140+	mut backend := remote.new_folder(os.join_path(base, 'remote'))!141+	name := 'demo-1.2.3-macos-aarch64'142+	backend.put_if_absent(file_key('proj', '1.2.3', 'macos-aarch64', name), 'other'.bytes())!143+144+	if _ := publish(store, mut backend, 'proj', config, '1.2.3', '') {145+		assert false, 'a different file for a published version must be refused'146+	} else {147+		assert err.msg().contains('already has a different ${name}')148+	}149+	// Nothing else was written: no record, and latest never moved.150+	assert !backend.get(release_key('proj', '1.2.3'))!.found151+	assert !backend.get(latest_key('proj'))!.found152+}153+154+// One platform failing stops the release before the first upload.155+fn test_a_failed_build_uploads_nothing() {156+	base := scratch('failed')!157+	defer {158+		os.rmdir_all(base) or {}159+	}160+	mut store := open_repo('failed')!161+	defer {162+		store.close()163+	}164+	// The command writes only the macos file, so the linux build produces165+	// nothing and the whole release stops there.166+	write(store.root, 'VERSION', '1.2.3\n')!167+	write(store.root, 'koh.build', 'command = mkdir -p out && printf koh > out/demo-1.2.3-macos-aarch64168+output = out/demo-{version}-{platform}169+platforms = macos-aarch64, linux-aarch64170+')!171+	config := build.read_config(store.root)!172+	make_save(store, 'first')!173+	mut backend := remote.new_folder(os.join_path(base, 'remote'))!174+175+	if _ := publish(store, mut backend, 'proj', config, '1.2.3', '') {176+		assert false, 'a build that produced nothing must stop the release'177+	} else {178+		assert err.msg().contains('did not create')179+	}180+	assert backend.list('proj/releases')!.len == 0181+}182+183+// A folder where a file belongs, or a name Kepr would refuse to read, is184+// refused here: Kepr refuses the whole repo's sync over one bad record.185+fn test_a_release_file_name_kepr_would_refuse_is_refused() {186+	assert good_name('demo-1.2.3-android-arm64.apk')187+	assert good_name('Haven.app.zip')188+	assert !good_name('')189+	assert !good_name('.')190+	assert !good_name('..')191+	assert !good_name('a/b')192+	assert !good_name('a\\b')193+	assert !good_name('a"b')194+	assert !good_name('a\x07b')195+	assert !good_name('x'.repeat(256))196+}197+198+fn test_the_notes_rule_is_koh_2s() {199+	check_notes('')!200+	check_notes('   ')!201+	check_notes('fixed the crash on startup when the config file was missing entirely')!202+	if _ := check_notes('too short to say anything at all') {203+		assert false, 'notes under 40 characters must be refused'204+	}205+	if _ := check_notes('this note is long enough in characters but few words') {206+		assert false, 'notes under 12 words must be refused'207+	}208+}