Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-pkg-server

Source of release 0.6.0

0.6.0 / tests / refs.lucb

import repositories
from luce_db import db
from luce_auth import auth
from luce_prism import prism
from luce_git import git
import thread
import strings

var zero: u8[20]
var first_id: u8[20]
var second_id: u8[20]
var blob_id: u8[20]
var socket_buffer: u8[512]
var socket_length: usize
let first_commit = b"tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904\nauthor Fixture <test@example.test> 1 +0000\ncommitter Fixture <test@example.test> 1 +0000\n\nfirst\n"
let second_commit = b"tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904\nauthor Fixture <test@example.test> 2 +0000\ncommitter Fixture <test@example.test> 2 +0000\n\nsecond\n"

func identify() -> !:
    _ = try git.hash_object("commit", first_commit, first_id)
    _ = try git.hash_object("commit", second_commit, second_id)
    _ = try git.hash_blob(b"fixture blob", blob_id)

func seed(database: db.Database*, name: str) -> !:
    try repositories.create(database, "alice", name)
    var wire: u8[512]
    var result: u8[20]
    var n = try git.encode_object("tree", b"", wire)
    try repositories.put_object(database, "alice", "alice", name, wire[..<n], result)
    n = try git.encode_object("commit", first_commit, wire)
    try repositories.put_object(database, "alice", "alice", name, wire[..<n], result)
    n = try git.encode_object("commit", second_commit, wire)
    try repositories.put_object(database, "alice", "alice", name, wire[..<n], result)
    n = try git.encode_object("blob", b"fixture blob", wire)
    try repositories.put_object(database, "alice", "alice", name, wire[..<n], result)
    # Ensure the ref directory already exists; prefix race must conflict on the
    # serialization guard, not incidentally on creation of the shared directory.
    try repositories.update_refs(database, "alice", "alice", name,
                                 [repositories.RefUpdate(name = "refs/tags/seed", expected = zero, target = blob_id)])

func change(name: str, expected: const u8[], target: const u8[]) -> repositories.RefUpdate:
    return repositories.RefUpdate(name = name, expected = expected, target = target)

func expect(database: db.Database*, repo: str, name: str, expected: const u8[]) -> !:
    let value = try repositories.get_ref(database, "alice", "alice", repo, name)
    defer value.release()
    let bytes = value.value().bytes()
    assert(bytes.length == 20)
    for i in 0..<(usize)20: assert(bytes[i] == expected[i])

func absent(database: db.Database*, repo: str, name: str) -> !:
    let value = repositories.get_ref(database, "alice", "alice", repo, name) catch failure:
        assert(failure.code == prism.missing)
        return
    value.release()
    assert(false)

func rejected(database: db.Database*, updates: const repositories.RefUpdate[], expected: ErrorCode) -> !:
    repositories.update_refs(database, "alice", "alice", "demo", updates) catch failure:
        assert(failure.code == expected)
        return
    assert(false)

func write(database: db.Database*) -> !:
    try seed(database, "demo")
    try repositories.update_refs(database, "alice", "alice", "demo", [change("refs/heads/main", zero, first_id), change("refs/tags/v1", zero, blob_id)])
    try rejected(database, [change("refs/heads/main", zero, second_id)], prism.conflict)
    # Validate the entire batch before publishing any updates.
    try rejected(database, [change("refs/heads/main", first_id, second_id), change("refs/tags/v1", first_id, second_id)], prism.conflict)
    try expect(database, "demo", "refs/heads/main", first_id)
    try expect(database, "demo", "refs/tags/v1", blob_id)
    try repositories.update_refs(database, "alice", "alice", "demo", [change("refs/heads/main", first_id, second_id)])
    try rejected(database, [change("refs/heads/main", first_id, zero)], prism.conflict)
    try rejected(database, [change("refs/heads/main/child", zero, first_id)], prism.conflict)
    try repositories.update_refs(database, "alice", "alice", "demo", [change("refs/heads/main", second_id, zero), change("refs/heads/main/child", zero, first_id)])
    try absent(database, "demo", "refs/heads/main")
    try expect(database, "demo", "refs/heads/main/child", first_id)
    try rejected(database, [change("refs/heads/main", zero, first_id)], prism.conflict)
    try repositories.update_refs(database, "alice", "alice", "demo", [change("refs/heads/main/child", first_id, zero), change("refs/heads/main", zero, second_id)])
    for name in ["HEAD", "refs/replace/id", "refs/remotes/main", "refs/heads/../x", "refs/heads/a.lock", "refs/heads/a\0b"]:
        try rejected(database, [change(name, zero, first_id)], prism.invalid)
    try rejected(database, [change("refs/heads/blob", zero, blob_id)], prism.invalid)
    try rejected(database, [change("refs/heads/empty", zero, zero)], prism.invalid)
    try rejected(database, [change("refs/tags/x", zero, first_id), change("refs/tags/x/y", zero, first_id)], prism.conflict)
    try rejected(database, [change("refs/tags/x", zero, first_id), change("refs/tags/x", zero, first_id)], prism.invalid)
    var missing: u8[20]
    for i in 0..<(usize)20: missing[i] = 0x77
    try rejected(database, [change("refs/heads/main", second_id, first_id), change("refs/tags/missing", zero, missing)], prism.missing)
    try expect(database, "demo", "refs/heads/main", second_id)
    try absent(database, "demo", "refs/tags/missing")
    var empty: repositories.RefUpdate[]
    try rejected(database, empty, prism.invalid)
    var short_id: u8[19]
    try rejected(database, [change("refs/tags/short", short_id, first_id)], prism.invalid)
    try rejected(database, [change("refs/tags/short", zero, short_id)], prism.invalid)
    var large: repositories.RefUpdate[65]
    for i in 0..<(usize)65: large[i] = change("refs/tags/x", zero, first_id)
    try rejected(database, large, prism.invalid)
    var long_name: u8[1025]
    let prefix = b"refs/tags/"
    for i in 0..<prefix.length: long_name[i] = prefix[i]
    for i in prefix.length..<long_name.length: long_name[i] = 'a'
    try rejected(database, [change((str)long_name, zero, blob_id)], prism.invalid)
    try repositories.update_refs(database, "alice", "alice", "demo", [change((str)long_name[..<1024], zero, blob_id)])
    try expect(database, "demo", (str)long_name[..<1024], blob_id)
    try repositories.update_refs(database, "alice", "alice", "demo", [change((str)long_name[..<1024], blob_id, zero)])
    var denied = false
    repositories.update_refs(database, "mallory", "alice", "demo", [change("refs/tags/stolen", zero, blob_id)]) catch failure:
        assert(failure.code == prism.invalid)
        denied = true
    assert(denied)
    let stolen = repositories.get_ref(database, "mallory", "alice", "demo", "refs/heads/main") catch failure:
        assert(failure.code == prism.invalid)
        return
    stolen.release()
    assert(false)

func read(database: db.Database*) -> !:
    try expect(database, "demo", "refs/heads/main", second_id)
    try expect(database, "demo", "refs/tags/v1", blob_id)
    try absent(database, "demo", "refs/heads/main/child")
    try absent(database, "demo", "refs/tags/stolen")

func limits(database: db.Database*) -> !:
    try seed(database, "demo")
    # Fill the entire advertised bound, including the preexisting seed tag.
    var names: u8[64][64]
    var updates: repositories.RefUpdate[64]
    var made: usize = 1
    while made < repositories.max_refs:
        let remaining = repositories.max_refs - made
        let count = repositories.max_ref_updates if remaining > repositories.max_ref_updates else remaining
        for i in 0..<count:
            let label = try strings.format(names[i], f"refs/tags/t{made + i}")
            updates[i] = change(label, zero, blob_id)
        try repositories.update_refs(database, "alice", "alice", "demo", updates[..<count])
        made += count
    try expect(database, "demo", "refs/tags/t1023", blob_id)
    try rejected(database, [change("refs/tags/overflow", zero, blob_id)], prism.invalid)
    try absent(database, "demo", "refs/tags/overflow")
    # Net-zero cardinality at the bound is legal, regardless of operation order.
    try repositories.update_refs(database, "alice", "alice", "demo", [change("refs/tags/replacement", zero, blob_id), change("refs/tags/seed", blob_id, zero)])
    try expect(database, "demo", "refs/tags/replacement", blob_id)
    try absent(database, "demo", "refs/tags/seed")

var ready: @u64
var start: @u64
var wins: @u64
var conflicts: @u64
var unexpected: @u64
var race_case: usize

func attempt(first: bool) -> !:
    let database = try db.Database.connect((str)socket_buffer[..<socket_length], "ref-test-token")
    defer database.release()
    while start.load(.acquire) == 0: thread.sleep(1)
    var updates: repositories.RefUpdate[2]
    var count: usize = 1
    let repo = "batch" if race_case == 1 else "prefix"
    if race_case == 0:
        updates[0] = change("refs/heads/topic" if first else "refs/heads/topic/child", zero, first_id)
    elif race_case == 2:
        # Disjoint refs of one repository: both batches must land, whichever commits first.
        updates[0] = change("refs/heads/alpha" if first else "refs/heads/beta", zero, first_id)
    else:
        updates[0] = change("refs/heads/shared", zero, first_id if first else second_id)
        updates[1] = change("refs/heads/left" if first else "refs/heads/right", zero, first_id)
        count = 2
    repositories.update_refs(database.value(), "alice", "alice", repo, updates[..<count]) catch failure:
        if failure.code == prism.conflict: _ = conflicts.add(1, .relaxed)
        else:
            print(failure.message)
            _ = unexpected.add(1, .relaxed)
        return
    _ = wins.add(1, .relaxed)

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

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

func has_ref(database: db.Database*, repo: str, name: str) -> bool!:
    let value = repositories.get_ref(database, "alice", "alice", repo, name) catch failure:
        if failure.code == prism.missing: return false
        error(failure.code, failure.message)
    value.release()
    return true

func race(database: db.Database*) -> !:
    try seed(database, "prefix")
    try seed(database, "batch")
    try database.listen()
    for round in 0..<(usize)3:
        race_case = round
        ready.store(0, .relaxed)
        start.store(0, .relaxed)
        wins.store(0, .relaxed)
        conflicts.store(0, .relaxed)
        unexpected.store(0, .relaxed)
        var one = try thread.spawn(worker_one, none, name = "ref-one")
        var two = try thread.spawn(worker_two, none, name = "ref-two")
        while ready.load(.acquire) != 2: thread.sleep(1)
        start.store(1, .release)
        try one.join()
        try two.join()
        let expected_wins: u64 = 2 if round == 2 else 1
        assert(wins.load(.acquire) == expected_wins and conflicts.load(.acquire) == 2 - expected_wins and unexpected.load(.acquire) == 0)
    assert(try has_ref(database, "prefix", "refs/heads/topic") != try has_ref(database, "prefix", "refs/heads/topic/child"))
    assert(try has_ref(database, "prefix", "refs/heads/alpha") and try has_ref(database, "prefix", "refs/heads/beta"))
    let left = try has_ref(database, "batch", "refs/heads/left")
    let right = try has_ref(database, "batch", "refs/heads/right")
    assert(left != right)
    try expect(database, "batch", "refs/heads/shared", first_id if left else second_id)

pub func main(arguments: str[]) -> i32!:
    assert(arguments.length == 3)
    try identify()
    let database = try db.Database.open(arguments[1], "ref-test-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 read(database.value())
    else:
        let authority = try auth.Authority.attach(try database.value().store())
        defer authority.release()
        try authority.value().bootstrap("alice", "disposable-ref-test-password")
        try repositories.initialize(database.value())
        if arguments[2] == "race":
            try race(database.value())
        elif arguments[2] == "limits":
            try limits(database.value())
        elif arguments[2] == "ipc":
            try database.value().listen()
            let client = try db.Database.connect((str)socket_buffer[..<socket_length], "ref-test-token")
            defer client.release()
            try write(client.value())
            try read(client.value())
        else:
            try write(database.value())
            try read(database.value())
    print("PASS repository refs")
    return 0