Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-pkg-server

Source of release 0.6.0

0.6.0 / tests / repositories.lucb

import repositories
from luce_db import db
from luce_auth import auth
from luce_prism import prism
from luce_git import git
import memory
import thread
from luce_std import files
import c
import strings

func setup(database: db.Database*) -> !:
    let authority = try auth.Authority.attach(try database.store())
    defer authority.release()
    try authority.value().bootstrap("alice", "disposable-test-password")
    try repositories.initialize(database)
    try repositories.initialize(database)

func wire_for(kind: str, output: u8[]) -> usize!:
    return try git.encode_object(kind, b"binary\0payload\n", output)

func boundaries(database: db.Database*, write: bool) -> !:
    var name: u8[64]
    for i in 0..<(usize)64: name[i] = 'a'
    if write: try repositories.create(database, "alice", (str)name)
    # One MiB: the largest object the former in-database layout kept in one value.
    let payload = try new u8[1048576 - 13] --- in memory.heap
    defer free(payload) in memory.heap
    for i in 0..<payload.length: payload[i] = (u8)(i % 256)
    let wire = try new u8[1048576] --- in memory.heap
    defer free(wire) in memory.heap
    let count = try git.encode_object("blob", payload, wire)
    assert(count == 1048576)
    var id: u8[20]
    _ = try git.hash_blob(payload, id)
    if write:
        var result: u8[20]
        try repositories.put_object(database, "alice", "alice", (str)name, wire, result)
        for i in 0..<(usize)20: assert(result[i] == id[i])
    let value = try repositories.get_object(database, "alice", "alice", (str)name, id)
    defer value.release()
    assert(value.value().bytes().length == wire.length)
    for i in 0..<wire.length: assert(value.value().bytes()[i] == wire[i])

func check(database: db.Database*, write: bool) -> !:
    if write:
        try repositories.create(database, "alice", "test-package")
        try repositories.create(database, "alice", "empty")
    for kind in ["blob", "tree", "commit", "tag"]:
        var wire: u8[128]
        let n = try wire_for(kind, wire)
        var id: u8[20]
        _ = try git.hash_object(kind, b"binary\0payload\n", id)
        if write:
            var result: u8[20]
            try repositories.put_object(database, "alice", "alice", "test-package", wire[..<n], result)
            let before = try database.snapshot()
            defer before.release()
            for i in 0..<(usize)20: assert(result[i] == id[i])
            try repositories.put_object(database, "alice", "alice", "test-package", wire[..<n], result)
            let after = try database.snapshot()
            defer after.release()
            assert(try before.value().revision() == try after.value().revision())
        let value = try repositories.get_object(database, "alice", "alice", "test-package", id)
        defer value.release()
        let bytes = value.value().bytes()
        assert(bytes.length == n)
        for i in 0..<n: assert(bytes[i] == wire[i])
        var missing = false
        let absent = repositories.get_object(database, "alice", "alice", "empty", id) catch failure:
            assert(failure.code == prism.missing)
            missing = true
            continue
        absent.release()
        assert(missing)
    try boundaries(database, write)

func reject_create(database: db.Database*, owner: str, name: str, expected: ErrorCode) -> !:
    var rejected = false
    repositories.create(database, owner, name) catch failure:
        assert(failure.code == expected)
        rejected = true
    assert(rejected)

func negative(database: db.Database*) -> !:
    try reject_create(database, "alice", "test-package", prism.conflict)
    try reject_create(database, "nobody", "test-package", prism.invalid)
    for name in ["", ".", "..", "../escape", "bad/name", "UPPER", "-leading", "x.git", "x y", "x\\y", "x\0y"]:
        assert(not repositories.valid_name(name))
        try reject_create(database, "alice", name, prism.invalid)
    for owner in ["", "../alice", "Alice", "alice/other"]:
        try reject_create(database, owner, "safe", prism.invalid)
    var long: u8[65]
    for i in 0..<(usize)65: long[i] = 'a'
    assert(repositories.valid_name((str)long[..<64]))
    try reject_create(database, "alice", (str)long, prism.invalid)
    var id: u8[20]
    for i in 0..<(usize)20: id[i] = 0x5a
    for wire in [b"", b"blob 01\0x", b"bad 1\0x", b"blob 2\0x", b"blob 1\0xx"]:
        var rejected = false
        repositories.put_object(database, "alice", "alice", "test-package", wire, id) catch failure:
            rejected = true
        assert(rejected)
        for byte in id: assert(byte == 0x5a)
    var denied = false
    repositories.put_object(database, "mallory", "alice", "test-package", b"blob 1\0x", id) catch failure:
        assert(failure.code == prism.invalid)
        denied = true
    assert(denied)
    var missing = false
    repositories.put_object(database, "alice", "alice", "missing", b"blob 1\0x", id) catch failure:
        assert(failure.code == prism.missing)
        missing = true
    assert(missing)
    let oversize = try new u8[repositories.max_object_bytes + 1] --- in memory.heap
    defer free(oversize) in memory.heap
    var bounded = false
    repositories.put_object(database, "alice", "alice", "test-package", oversize, id) catch failure:
        assert(failure.code == prism.invalid)
        bounded = true
    assert(bounded)
    var short_id: u8[19]
    var short_rejected = false
    repositories.put_object(database, "alice", "alice", "test-package", b"blob 1\0x", short_id) catch failure:
        assert(failure.code == prism.invalid)
        short_rejected = true
    assert(short_rejected)
    _ = try git.hash_object("blob", b"binary\0payload\n", id)
    var read_denied = false
    let wrong = repositories.get_object(database, "mallory", "alice", "test-package", id) catch failure:
        assert(failure.code == prism.invalid)
        read_denied = true
        return
    wrong.release()
    assert(read_denied)

## Deliberately corrupt only a disposable fixture's object file on disk.
func corruption(database: db.Database*, database_path: str) -> !:
    var id: u8[20]
    try repositories.put_object(database, "alice", "alice", "test-package", b"blob 1\0x", id)
    var encoded_id: u8[40]
    _ = try git.hex_id(id, encoded_id)
    var path: u8[1024]
    let file = try strings.copy(try strings.format(path, f"{database_path}.objects/{(str)encoded_id[..<2]}/{(str)encoded_id[2..]}"))
    defer strings.release(file)
    try files.write((c.str)file, b"blob 1\0y")
    var conflict = false
    repositories.put_object(database, "alice", "alice", "test-package", b"blob 1\0x", id) catch failure:
        assert(failure.code == prism.conflict)
        conflict = true
    assert(conflict)
    var rejected = false
    let value = repositories.get_object(database, "alice", "alice", "test-package", id) catch failure:
        assert(failure.code == prism.invalid)
        rejected = true
        return
    value.release()
    assert(rejected)

var socket_buffer: u8[512]
var socket_length: usize
var ready: @u64
var start: @u64
var successes: @u64
var conflicts: @u64
var unexpected: @u64

func race_attempt() -> !:
    let database = try db.Database.connect((str)socket_buffer[..<socket_length], "test-store-token")
    defer database.release()
    while start.load(.acquire) == 0: thread.sleep(1)
    repositories.create(database.value(), "alice", "race") catch failure:
        if failure.code == prism.conflict: _ = conflicts.add(1, .relaxed)
        else:
            print(failure.message)
            _ = unexpected.add(1, .relaxed)
        return
    _ = successes.add(1, .relaxed)

func race_worker(raw: void*?):
    _ = raw
    _ = ready.add(1, .release)
    race_attempt() catch failure:
        print(failure.message)
        _ = unexpected.add(1, .relaxed)

func race(database: db.Database*) -> !:
    try database.listen()
    var first = try thread.spawn(race_worker, none, name = "repo-one")
    var second = try thread.spawn(race_worker, none, name = "repo-two")
    while ready.load(.acquire) != 2: thread.sleep(1)
    start.store(1, .release)
    try first.join()
    try second.join()
    assert(successes.load(.acquire) == 1)
    assert(conflicts.load(.acquire) == 1 and unexpected.load(.acquire) == 0)

pub func main(arguments: str[]) -> i32!:
    assert(arguments.length == 3)
    let database = try db.Database.open(arguments[1], "test-store-token")
    try repositories.use_objects(arguments[1])
    defer database.release()
    let path = arguments[1]
    assert(path.length + 5 <= socket_buffer.length)
    for i in 0..<path.length: socket_buffer[i] = path.bytes[i]
    for i in 0..<(usize)5: socket_buffer[path.length + i] = b".sock"[i]
    socket_length = path.length + 5
    if arguments[2] == "read":
        try check(database.value(), false)
    else:
        try setup(database.value())
        if arguments[2] == "race":
            try race(database.value())
        elif arguments[2] == "ipc":
            try database.value().listen()
            let client = try db.Database.connect((str)socket_buffer[..<socket_length], "test-store-token")
            defer client.release()
            try check(client.value(), true)
            try negative(client.value())
            try corruption(client.value(), path)
        else:
            try check(database.value(), true)
            try negative(database.value())
            try corruption(database.value(), path)
    print("PASS repository storage")
    return 0