Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-prism

Source of release 0.6.1

0.6.1 / src / wal / engine.lucb

## Native shared state. Only this layer crosses application-worker boundaries.
import memory
import sync
import wal.tree
import wal.journal
import wal.writers
import wal.storage_io
from wal.bytes import Buffer, valid_key, max_value, max_frame, invalid, limit, closed, conflict, uncertain

pub struct Store:
    var references: @u64
    var views: @u64
    var head_lock: sync.Mutex
    var writer: writers.Queue
    var root: tree.Node*?
    var generation: u64
    var published_bytes: i64
    var conflicted_commits: @u64
    var poisoned: bool
    var log: journal.Journal

pub func open(path: str, controls: storage_io.Controls = storage_io.Controls()) -> Store*!:
    var log = try journal.open(path, controls)
    errdefer log.close()
    var root: tree.Node*?
    errdefer tree.drop(root)
    var generation: u64
    try journal.replay(&log, &root, &generation)
    let store = try new Store(root = root, generation = generation, published_bytes = log.position, log = log) in memory.heap
    store.references.store(1, .relaxed)
    return store

pub func hold(store: Store*):
    _ = store.references.add(1, .relaxed)

pub func drop(store: Store*):
    if store.references.sub(1, .acq_rel) == 1:
        tree.drop(store.root)
        store.log.close()
        free(store) in memory.heap

pub struct Statistics:
    pub let generation: i64
    pub let records: i64
    pub let journal_bytes: i64
    pub let needs_reopen: bool
    pub let active_views: i64
    pub let waiting_writers: i64
    pub let peak_waiting_writers: i64
    pub let queued_attempts: i64
    pub let busy_returns: i64
    pub let timed_out_attempts: i64
    pub let conflicted_commits: i64

pub func statistics(store: Store*) -> Statistics:
    store.head_lock.lock()
    let generation = (i64)store.generation
    let records = (i64)tree.count(store.root)
    let position = store.published_bytes
    let poisoned = store.poisoned
    store.head_lock.unlock()
    let admission = store.writer.statistics()
    return Statistics(generation, records, position, poisoned, (i64)store.views.load(.acquire),
        admission.waiting, admission.peak, admission.enqueued, admission.busy_returns,
        admission.timeouts, (i64)store.conflicted_commits.load(.acquire))

pub struct View:
    pub var store: Store*?
    pub var root: tree.Node*?
    pub var generation: u64

    pub func close():
        let store = self.store else return
        tree.drop(self.root)
        self.root = none
        self.store = none
        _ = store.views.sub(1, .acq_rel)
        drop(store)

    pub func ensure_open() -> !:
        if self.store == none: error(closed, "database view is closed")

    ## Borrowed until this view is changed/closed. Facades retain returned values.
    pub func get(key: str) -> tree.Entry*?!:
        try self.ensure_open()
        try valid_key(key)
        return tree.find(self.root, key.bytes)

pub func snapshot(store: Store*) -> View!:
    if store.views.add(1, .acq_rel) >= 1024:
        _ = store.views.sub(1, .acq_rel)
        error(limit, "database has 1024 active snapshots/transactions")
    store.head_lock.lock()
    defer store.head_lock.unlock()
    if store.poisoned:
        _ = store.views.sub(1, .acq_rel)
        error(uncertain, "database needs reopen after uncertain I/O")
    hold(store)
    return View(store = store, root = tree.hold(store.root), generation = store.generation)

pub struct Transaction:
    pub var view: View
    var payload: Buffer
    var operations: usize

    pub func close():
        self.payload.close()
        self.view.close()

    pub func put(key: str, value: const u8[], only_new: bool = false) -> !:
        try self.view.ensure_open()
        try valid_key(key)
        if value.length > max_value: error(limit, "value exceeds 1 MiB")
        if only_new and tree.find(self.view.root, key.bytes) != none:
            error(conflict, "key already exists")
        if self.operations >= 65536 or self.payload.count + 9 + key.length + value.length > max_frame - 32:
            error(limit, "transaction is full")
        let item = try tree.entry(key.bytes, value)
        defer tree.drop_entry(item)
        let root = try tree.put(self.view.root, item)
        errdefer tree.drop(root)
        try journal.operation(&self.payload, key, value, false)
        tree.drop(self.view.root)
        self.view.root = root
        self.operations += 1

    pub func remove(key: str) -> !:
        try self.view.ensure_open()
        try valid_key(key)
        if self.operations >= 65536 or self.payload.count + 9 + key.length > max_frame - 32:
            error(limit, "transaction is full")
        let root = try tree.remove(self.view.root, key.bytes)
        errdefer tree.drop(root)
        try journal.operation(&self.payload, key, b"", true)
        tree.drop(self.view.root)
        self.view.root = root
        self.operations += 1

    pub func commit(wait_ms: i64 = 0) -> u64!:
        let store = self.view.store else error(closed, "transaction is closed")
        ## Retain through queue release, even after closing the last view.
        hold(store)
        defer drop(store)
        try store.writer.enter(wait_ms)
        defer store.writer.leave()
        store.head_lock.lock()
        let poisoned = store.poisoned
        let current = store.generation
        store.head_lock.unlock()
        if poisoned: error(uncertain, "database needs reopen after uncertain I/O")
        if current != self.view.generation:
            _ = store.conflicted_commits.add(1, .relaxed)
            error(conflict, "snapshot changed; restart the transaction")
        if self.operations == 0:
            self.close()
            return current
        if current >= 9223372036854775807: error(limit, "database generation exhausted")
        var frame = try journal.encode_frame(self.payload.span(), current + 1, self.operations)
        defer frame.close()
        if (i64)frame.count > journal.max_journal - store.log.position:
            error(limit, "journal reached 256 MiB; export to a fresh database")
        store.log.append(frame.span()) catch failure:
            store.head_lock.lock()
            store.poisoned = true
            store.head_lock.unlock()
            error(uncertain, "commit I/O failed; outcome uncertain, close all handles and reopen")
        store.head_lock.lock()
        let old = store.root
        store.root = tree.hold(self.view.root)
        store.generation = current + 1
        store.published_bytes = store.log.position
        store.head_lock.unlock()
        tree.drop(old)
        self.close()
        return current + 1

pub func transaction(store: Store*) -> Transaction!:
    return Transaction(view = try snapshot(store))

pub func checkpoint(store: Store*, wait_ms: i64 = 0) -> u64!:
    hold(store)
    defer drop(store)
    try store.writer.enter(wait_ms)
    defer store.writer.leave()
    store.head_lock.lock()
    let poisoned = store.poisoned
    let generation = store.generation
    let root = tree.hold(store.root)
    store.head_lock.unlock()
    defer tree.drop(root)
    if poisoned: error(uncertain, "database needs reopen after uncertain I/O")
    store.log.compact(root, generation) catch failure:
        if failure.code == uncertain:
            store.head_lock.lock()
            store.poisoned = true
            store.head_lock.unlock()
        error(failure.code, failure.message)
    store.head_lock.lock()
    store.published_bytes = store.log.position
    store.head_lock.unlock()
    return generation