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