A Key Remembers Its Answer

# Coop's engine: what counts as a write, and the keyed command (trimmed excerpt)

# Domain operations that mutate the ledger. Every other operation is a read,
# answered without an idempotency receipt: a read result kept for ever was
# the store's largest single growth (one list_history answer was 236 KB).
WRITES = frozenset({'add_todo', 'take_todo', 'take_scope', 'release_todo', 'abandon_todo', 'assign', 'edit_todo', 'done_todo', 'ack_todo_replies',
                    'send_request', 'assign_request', 'take_request', 'release_request', 'reply', 'close_request',
                    'write_letter', 'read_latest_letter', 'start_letter', 'ack_letter', 'abandon_letter',
                    'add_history_entry', 'edit_history_entry', 'add_learning_entry', 'supersede_learning', 'edit_learning_entry'})

RETENTION = {'engine_commands': 7 * 86400, 'engine_changes': 30 * 86400, ...}


def command(self, key, action, payload, metadata, operation):
    if not key or len(key) > 200:
        raise ValueError('A bounded idempotency key is required')
    fingerprint = hashlib.sha256(dump([action, payload, metadata]).encode()).hexdigest()
    with self._mutex, self.connection() as conn:
        conn.execute('BEGIN IMMEDIATE')
        try:
            previous = conn.execute('SELECT * FROM engine_commands WHERE id=?', (key,)).fetchone()
            if previous:
                if previous['fingerprint'] != fingerprint:
                    raise Conflict('Idempotency key was already used for different input')
                result = json.loads(previous['result'], object_hook=decode)
            else:
                with context.request(conn, {**metadata, "causation":key}):
                    result = operation(conn)
                conn.execute('INSERT INTO engine_commands VALUES (?,?,?,?)', (key, fingerprint, dump(result), time.time()))
            conn.commit()
            return result
        except BaseException:
            conn.rollback()
            raise

"""A minimal sketch of Coop's idempotent command: a bounded key, a fingerprint
of the input and a stored answer, decided inside one BEGIN IMMEDIATE."""
import hashlib
import json
import sqlite3
import time

conn = sqlite3.connect(":memory:", isolation_level=None)
conn.execute("CREATE TABLE todos (id INTEGER PRIMARY KEY, title TEXT)")
conn.execute("CREATE TABLE commands (id TEXT PRIMARY KEY, fingerprint TEXT, result TEXT, created REAL)")


class Conflict(Exception):
    pass


def add_todo(title):
    return conn.execute("INSERT INTO todos(title) VALUES (?)", (title,)).lastrowid


def list_todos():
    return [row[0] for row in conn.execute("SELECT title FROM todos ORDER BY id")]


OPERATIONS = {"add_todo": add_todo, "list_todos": list_todos}
WRITES = frozenset({"add_todo"})


def call(key, action, *args, metadata=None):
    if action not in WRITES:
        return OPERATIONS[action](*args)  # a read is answered, never remembered
    if not key or len(key) > 200:
        raise ValueError("A bounded idempotency key is required")
    fingerprint = hashlib.sha256(json.dumps([action, args, metadata or {}]).encode()).hexdigest()
    conn.execute("BEGIN IMMEDIATE")
    try:
        previous = conn.execute("SELECT fingerprint, result FROM commands WHERE id=?", (key,)).fetchone()
        if previous:
            if previous[0] != fingerprint:
                raise Conflict("Idempotency key was already used for different input")
            result = json.loads(previous[1])  # replay the stored answer
        else:
            result = OPERATIONS[action](*args)
            conn.execute("INSERT INTO commands VALUES (?,?,?,?)",
                         (key, fingerprint, json.dumps(result), time.time()))
        conn.execute("COMMIT")
        return result
    except BaseException:
        conn.execute("ROLLBACK")
        raise


print("first call  ->", call("k-1", "add_todo", "Only once"))
print("same again  ->", call("k-1", "add_todo", "Only once"))
try:
    call("k-1", "add_todo", "Changed")
except Conflict as exc:
    print("changed     ->", exc)
print("todos       ->", call(None, "list_todos"))
print("receipts    ->", conn.execute("SELECT COUNT(*) FROM commands").fetchone()[0])

# Expected output:
# first call  -> 1
# same again  -> 1
# changed     -> Idempotency key was already used for different input
# todos       -> ['Only once']
# receipts    -> 1