events.v

1//! Events: what Koh learns about saves that already exist.2//!3//! Save records are write-once, so a flag is not stored on the save. It is4//! appended as a small event that syncs alongside saves, and a save's flag5//! state is always derived from the newest event about it — never stored twice.6//! A strip event is what makes `strip` visible to other machines.78module events910import strings11import time12import src.machine13import src.storage1415pub const kind_flag = 'flag'16pub const kind_clear = 'clear'17pub const kind_strip = 'strip'1819// An event about one save.20pub struct Event {21pub mut:22	id         string23	kind       string24	save_id    string25	path       string26	reason     string27	created_at i6428	machine    string29}3031// Flag is the derived answer to "is this save flagged, and why".32pub struct Flag {33pub:34	save_id string35	flagged bool36	reason  string37	at      i6438}3940const select_event = 'SELECT id, kind, save_id, path, reason, created_at, machine FROM events'4142fn read_event(stmt &storage.Stmt) Event {43	return Event{44		id:         stmt.text(0)45		kind:       stmt.text(1)46		save_id:    stmt.text_or_none(2) or { '' }47		path:       stmt.text_or_none(3) or { '' }48		reason:     stmt.text_or_none(4) or { '' }49		created_at: stmt.int(5)50		machine:    stmt.text(6)51	}52}5354// write appends an event. The ID is the first 12 hex characters of the Blake355// hash of the record, so two machines that record the same fact agree.56pub fn write(store &storage.Store, event Event) !Event {57	mut record := event58	if record.created_at == 0 {59		// Events are ordered by time, and flag/clear can land in the same60		// second. Bumping past the newest event keeps "newest wins" true, and61		// keeps the ordering the same on every machine.62		record.created_at = next_timestamp(store)!63	}64	if record.machine == '' {65		record.machine = machine.name()66	}67	record.id = event_id(record)68	insert(store, record)!69	return record70}7172// receive stores an event exactly as another machine recorded it, ID and all.73// An ID re-derived here that disagreed with the sender's would make the event74// look new on every steal. Reports whether it was new.75pub fn receive(store &storage.Store, event Event) !bool {76	insert(store, event)!77	return store.db.changes() > 078}7980// next_timestamp is now, or one second past the newest event when that is not earlier.81fn next_timestamp(store &storage.Store) !i64 {82	now := time.now().unix()83	mut stmt := store.db.prepare('SELECT MAX(created_at) FROM events')!84	defer {85		stmt.finalize()86	}87	if !stmt.step()! {88		return now89	}90	newest := stmt.int_or_none(0) or { return now }91	if newest >= now {92		return newest + 193	}94	return now95}9697// insert ignores an ID already stored, which is how receive tells a repeat from a new event.98fn insert(store &storage.Store, record Event) ! {99	mut stmt := store.db.prepare('INSERT OR IGNORE INTO events100		(id, kind, save_id, path, reason, created_at, machine) VALUES (?, ?, ?, ?, ?, ?, ?)')!101	defer {102		stmt.finalize()103	}104	stmt.bind_text(1, record.id)!105	stmt.bind_text(2, record.kind)!106	bind_optional(stmt, 3, record.save_id)!107	bind_optional(stmt, 4, record.path)!108	bind_optional(stmt, 5, record.reason)!109	stmt.bind_int(6, record.created_at)!110	stmt.bind_text(7, record.machine)!111	stmt.step()!112}113114pub fn flag(store &storage.Store, save_id string, reason string) !Event {115	return write(store, Event{116		kind:    kind_flag117		save_id: save_id118		reason:  reason119	})!120}121122pub fn clear_flag(store &storage.Store, save_id string) !Event {123	return write(store, Event{124		kind:    kind_clear125		save_id: save_id126	})!127}128129// strip records that a path was removed from a save (or from every save, when130// save_id is empty). Each strip is its own event, even of a path stripped131// before: a machine that applied the first must still hear about the second.132pub fn strip(store &storage.Store, save_id string, path string) !Event {133	return write(store, Event{134		kind:    kind_strip135		save_id: save_id136		path:    path137	})!138}139140// event_id hashes each field with its length, so two different facts cannot spell the same input.141pub fn event_id(event Event) string {142	mut sb := strings.Builder{}143	put(mut sb, 'kind', event.kind)144	put(mut sb, 'save', event.save_id)145	put(mut sb, 'path', event.path)146	put(mut sb, 'reason', event.reason)147	put(mut sb, 'created', event.created_at.str())148	put(mut sb, 'machine', event.machine)149	return storage.hash_hex(sb.str().bytes())[..12]150}151152fn put(mut sb strings.Builder, name string, value string) {153	sb.write_string('${name}:${value.len}:')154	sb.write_string(value)155	sb.write_string('\n')156}157158fn bind_optional(stmt &storage.Stmt, index int, value string) ! {159	if value == '' {160		stmt.bind_null(index)!161	} else {162		stmt.bind_text(index, value)!163	}164}165166// all returns every event, oldest first.167pub fn all(store &storage.Store) ![]Event {168	mut stmt := store.db.prepare('${select_event} ORDER BY created_at, id')!169	defer {170		stmt.finalize()171	}172	mut out := []Event{}173	for stmt.step()! {174		out << read_event(stmt)175	}176	return out177}178179// latest_flags derives the flag state of every save that has ever been flagged180// or cleared. Newest wins, ties broken by ID so the answer is the same on every181// machine.182pub fn latest_flags(store &storage.Store) !map[string]Flag {183	mut stmt := store.db.prepare('${select_event} WHERE kind IN (?, ?) AND save_id IS NOT NULL184		ORDER BY created_at, id')!185	defer {186		stmt.finalize()187	}188	stmt.bind_text(1, kind_flag)!189	stmt.bind_text(2, kind_clear)!190	mut flags := map[string]Flag{}191	for stmt.step()! {192		event := read_event(stmt)193		flags[event.save_id] = Flag{194			save_id: event.save_id195			flagged: event.kind == kind_flag196			reason:  event.reason197			at:      event.created_at198		}199	}200	return flags201}202203// flag_state is latest_flags for one save; a save never flagged reads as not flagged.204pub fn flag_state(store &storage.Store, save_id string) !Flag {205	flags := latest_flags(store)!206	return flags[save_id] or {207		Flag{208			save_id: save_id209		}210	}211}212213// strip_events lists every strip event, whole-history or one save, oldest first.214pub fn strip_events(store &storage.Store) ![]Event {215	mut stmt := store.db.prepare('${select_event} WHERE kind = ? ORDER BY created_at, id')!216	defer {217		stmt.finalize()218	}219	stmt.bind_text(1, kind_strip)!220	mut out := []Event{}221	for stmt.step()! {222		out << read_event(stmt)223	}224	return out225}