Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-db

Source of release 0.5.1

0.5.1 / src / db.lucb

## Database server over prism.Store. Process, listen/connect, token auth. Storage is Prism.
import interop
import memory
from luce_prism import prism

pub struct Database:
    var backing: interop.Reference[prism.Store]
    var alive: bool

    pub func init():
        return

    pub static func open(path: str, token: str) -> interop.Reference[Database]!:
        if token.length == 0:
            error(prism.invalid, "database token is required")
        return try own_store(try prism.Store.open(path, token = token))

    pub func snapshot() -> interop.Reference[prism.Session]!:
        if not self.alive:
            error(prism.closed, "database is closed")
        return try self.backing.value().snapshot()

    pub func begin() -> interop.Reference[prism.Session]!:
        if not self.alive:
            error(prism.closed, "database is closed")
        return try self.backing.value().begin()

    pub func listen() -> !:
        if not self.alive:
            error(prism.closed, "database is closed")
        try self.backing.value().listen()

    pub func listen_tls(host: str, port: u16) -> u16!:
        if not self.alive:
            error(prism.closed, "database is closed")
        return try self.backing.value().listen_tls(host, port)

    pub func tls_issuer_x() -> const u8[]!:
        if not self.alive:
            error(prism.closed, "database is closed")
        return try self.backing.value().tls_issuer_x()

    pub func tls_issuer_y() -> const u8[]!:
        if not self.alive:
            error(prism.closed, "database is closed")
        return try self.backing.value().tls_issuer_y()

    pub func serve() -> !:
        if not self.alive:
            error(prism.closed, "database is closed")
        try self.backing.value().serve()

    ## Borrowed until this Database closes. Do not transfer managed owners across workers.
    pub func store() -> prism.Store*!:
        if not self.alive:
            error(prism.closed, "database is closed")
        return self.backing.value()

    pub func bake(wait_ms: i64 = 0) -> i64!:
        if not self.alive:
            error(prism.closed, "database is closed")
        return try self.backing.value().bake(wait_ms)

    pub func close():
        if not self.alive:
            return
        self.alive = false
        self.backing.release()

    pub static func connect(socket_path: str, token: str) -> interop.Reference[Database]!:
        if token.length == 0:
            error(prism.invalid, "database token is required")
        return try own_store(try prism.Store.connect(socket_path, token))

    pub static func connect_tls(host: str, port: u16, token: str, issuer_x: const u8[], issuer_y: const u8[]) -> interop.Reference[Database]!:
        if token.length == 0:
            error(prism.invalid, "database token is required")
        return try own_store(try prism.Store.connect_tls(host, port, token, issuer_x, issuer_y))

## Consumes the Store reference on success and failure. adopt disposes/frees its
## native argument on failure; an additional errdefer would double-dispose it.
func own_store(store: interop.Reference[prism.Store]) -> interop.Reference[Database]!:
    let native = new Database() in memory.heap catch failure:
        store.release()
        error(failure.code, failure.message)
    native.backing = store
    native.alive = true
    return try interop.Reference[Database].adopt(native, database_type, memory.heap)

pub let database_type = interop.Type[Database]("Prism database", Database.close, closeable = true)