dymokomi/luce-pkg-server
Source of release 0.6.0
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 strings
let first = b"tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904\nauthor A\ncommitter A\n\nfirst\n"
var zero: u8[20]
func append(wire: u8[], at: usize, old: const u8[], target: const u8[], name: str, caps: str, initial: bool) -> usize!:
var old_text: u8[40]
var new_text: u8[40]
_ = try git.hex_id(old, old_text)
_ = try git.hex_id(target, new_text)
var buffer: u8[1024]
let separator = "\0" if initial else ""
let line = try strings.format(buffer, f"{(str)old_text} {(str)new_text} {name}{separator}{caps}")
return at + try git.encode_packet(git.PacketKind.data, line.bytes, wire[at..])
func expect(database: db.Database*, name: str, id: const u8[]) -> !:
let ref = try repositories.get_ref(database, "alice", "alice", "push", name)
defer ref.release()
let bytes = ref.value().bytes()
for i in 0..<(usize)20: assert(bytes[i] == id[i])
func absent(database: db.Database*, name: str) -> !:
let ref = repositories.get_ref(database, "alice", "alice", "push", name) catch failure:
assert(failure.code == prism.missing)
return
ref.release()
assert(false)
func no_writes(database: db.Database*, wire: const u8[]) -> !:
let before = try database.snapshot()
defer before.release()
var failed = false
_ = repositories.receive_pack(database, "alice", "alice", "push", wire) catch:
failed = true
recover 0
assert(failed)
let after = try database.snapshot()
defer after.release()
assert(try before.value().revision() == try after.value().revision())
func fetch_wire(target: const u8[], base: const u8[], done: bool, wire: u8[], caps: str = "ofs-delta no-progress") -> usize!:
var encoded: u8[40]
_ = try git.hex_id(target, encoded)
var line: u8[128]
let separator = " " if caps.length > 0 else ""
var text = try strings.format(line, f"want {(str)encoded}{separator}{caps}\n")
var used = try git.encode_packet(git.PacketKind.data, text.bytes, wire)
used += try git.encode_packet(git.PacketKind.flush, b"", wire[used..])
if base.length > 0:
_ = try git.hex_id(base, encoded)
text = try strings.format(line, f"have {(str)encoded}\n")
used += try git.encode_packet(git.PacketKind.data, text.bytes, wire[used..])
used += try git.encode_packet(git.PacketKind.data if done else git.PacketKind.flush, b"done\n" if done else b"", wire[used..])
return used
func fetch_cases(database: db.Database*, target: const u8[], parent: const u8[]) -> !:
var wire: u8[512]
var output: u8[16384]
var empty: const u8[]
var encoded: u8[40]
_ = try git.hex_id(target, encoded)
var tag_buffer: u8[256]
let tag = try strings.format(tag_buffer, f"object {(str)encoded}\ntype commit\ntag annotated\n\nfetch tag\n")
let tag_size = try git.encode_object("tag", tag.bytes, output)
var tag_id: u8[20]
try repositories.put_object(database, "alice", "alice", "push", output[..<tag_size], tag_id)
var updates: repositories.RefUpdate[1]
updates[0] = repositories.RefUpdate(name = "refs/tags/annotated", expected = zero, target = tag_id)
try repositories.update_refs(database, "alice", "alice", "push", updates)
let before = try database.snapshot()
defer before.release()
let discovery = try repositories.advertise_upload(database, "alice", "alice", "push", output)
assert(strings.contains((str)output[..<discovery], "symref=HEAD:refs/heads/main"))
assert(strings.contains((str)output[..<discovery], "refs/tags/annotated^{}"))
var n = try fetch_wire(target, empty, true, wire)
var used = try repositories.upload_pack(database, "alice", "alice", "push", wire[..<n], output)
var response = try git.decode_packet(output[..<used])
assert((str)response.payload == "NAK\n")
var pack = try git.decode_pack(output[response.consumed..<used])
defer pack.close()
assert(pack.items.length == 3)
n = try fetch_wire(target, parent, true, wire)
used = try repositories.upload_pack(database, "alice", "alice", "push", wire[..<n], output)
response = try git.decode_packet(output[..<used])
assert(strings.starts_with((str)response.payload, "ACK "))
pack.close()
pack = try git.decode_pack(output[response.consumed..<used])
assert(pack.items.length == 1 and pack.items[0].kind == "commit")
for i in 0..<(usize)20: assert(pack.items[0].id[i] == target[i])
n = try fetch_wire(target, target, true, wire)
used = try repositories.upload_pack(database, "alice", "alice", "push", wire[..<n], output)
response = try git.decode_packet(output[..<used])
pack.close()
pack = try git.decode_pack(output[response.consumed..<used])
assert(pack.items.length == 0)
n = try fetch_wire(target, parent, false, wire)
used = try repositories.upload_pack(database, "alice", "alice", "push", wire[..<n], output)
response = try git.decode_packet(output[..<used])
assert(response.consumed == used and strings.starts_with((str)response.payload, "ACK "))
var unknown: u8[20]
for i in 0..<(usize)20: unknown[i] = 17
n = try fetch_wire(target, unknown, false, wire)
used = try repositories.upload_pack(database, "alice", "alice", "push", wire[..<n], output)
assert((str)(try git.decode_packet(output[..<used])).payload == "NAK\n")
var failed = false
_ = repositories.upload_pack(database, "bob", "alice", "push", wire[..<n], output) catch:
failed = true
recover 0
assert(failed)
n = try fetch_wire(unknown, empty, true, wire)
failed = false
_ = repositories.upload_pack(database, "alice", "alice", "push", wire[..<n], output) catch:
failed = true
recover 0
assert(failed)
n = try fetch_wire(target, empty, true, wire)
failed = false
_ = repositories.upload_pack(database, "alice", "alice", "push", wire[..<n], output[..<16]) catch:
failed = true
recover 0
assert(failed)
n = try fetch_wire(target, empty, true, wire, "")
used = try repositories.upload_pack(database, "alice", "alice", "push", wire[..<n], output)
assert((str)(try git.decode_packet(output[..<used])).payload == "NAK\n")
n = try fetch_wire(target, empty, true, wire, "side-band-64k")
failed = false
_ = repositories.upload_pack(database, "alice", "alice", "push", wire[..<n], output) catch:
failed = true
recover 0
assert(failed)
let after = try database.snapshot()
defer after.release()
assert(try before.value().revision() == try after.value().revision())
func cases(database: db.Database*) -> !:
let advertisement = try new u8[2097152] --- in memory.heap
defer free(advertisement) in memory.heap
let empty_advertisement = try repositories.advertise_receive(database, "alice", "alice", "push", advertisement)
assert(strings.contains((str)advertisement[..<empty_advertisement], "capabilities^{}"))
var id: u8[20]
_ = try git.hash_object("commit", first, id)
var objects: git.Object[2]
objects[0] = git.Object(kind = "tree", payload = b"")
objects[1] = git.Object(kind = "commit", payload = first)
var wire: u8[16384]
var n = try append(wire, 0, zero, id, "refs/heads/main", "report-status atomic ofs-delta", true)
n = try append(wire, n, zero, id, "refs/tags/keep", "", false)
n += try git.encode_packet(git.PacketKind.flush, b"", wire[n..])
n += try git.encode_pack(objects, wire[n..])
wire[n - 1] ^= 1
try no_writes(database, wire[..<n])
wire[n - 1] ^= 1
var denied = false
_ = repositories.receive_pack(database, "bob", "alice", "push", wire[..<n]) catch:
denied = true
recover 0
assert(denied)
assert(try repositories.receive_pack(database, "alice", "alice", "push", wire[..<n]) == 2)
try expect(database, "refs/heads/main", id)
try expect(database, "refs/tags/keep", id)
let advertised = try repositories.advertise_receive(database, "alice", "alice", "push", advertisement)
assert(strings.contains((str)advertisement[..<advertised], "refs/heads/main"))
var too_small = false
_ = repositories.advertise_receive(database, "alice", "alice", "push", advertisement[..<4]) catch:
too_small = true
recover 0
assert(too_small)
# A stale create fails without changing either ref or adding duplicate objects.
try no_writes(database, wire[..<n])
n = try append(wire, 0, zero, id, "refs/tags/unsupported", "side-band-64k", true)
n += try git.encode_packet(git.PacketKind.flush, b"", wire[n..])
n += try git.encode_pack(objects[..<0], wire[n..])
try no_writes(database, wire[..<n])
var parent: u8[40]
_ = try git.hex_id(id, parent)
var commit_buffer: u8[512]
let second = try strings.format(commit_buffer, f"tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904\nparent {(str)parent}\nauthor A\ncommitter A\n\nsecond\n")
var next: u8[20]
_ = try git.hash_object("commit", second.bytes, next)
objects[0] = git.Object(kind = "commit", payload = second.bytes)
n = try append(wire, 0, id, next, "refs/heads/main", "report-status atomic", true)
n = try append(wire, n, zero, id, "refs/tags/v1", "", false)
n += try git.encode_packet(git.PacketKind.flush, b"", wire[n..])
n += try git.encode_pack(objects[..<1], wire[n..])
assert(try repositories.receive_pack(database, "alice", "alice", "push", wire[..<n]) == 2)
try expect(database, "refs/heads/main", next)
try fetch_cases(database, next, id)
# New ref to existing data still carries a valid empty pack.
n = try append(wire, 0, zero, id, "refs/tags/existing", "report-status", true)
n += try git.encode_packet(git.PacketKind.flush, b"", wire[n..])
n += try git.encode_pack(objects[..<0], wire[n..])
assert(try repositories.receive_pack(database, "alice", "alice", "push", wire[..<n]) == 1)
n = try append(wire, 0, next, zero, "refs/heads/main", "report-status delete-refs atomic", true)
n = try append(wire, n, id, zero, "refs/tags/v1", "", false)
n += try git.encode_packet(git.PacketKind.flush, b"", wire[n..])
assert(try repositories.receive_pack(database, "alice", "alice", "push", wire[..<n]) == 2)
try absent(database, "refs/heads/main")
try absent(database, "refs/tags/v1")
# Structurally valid but disconnected commit: staging may persist it, refs may not.
let broken = b"tree 1111111111111111111111111111111111111111\nauthor A\ncommitter A\n\nbroken\n"
_ = try git.hash_object("commit", broken, next)
objects[0] = git.Object(kind = "commit", payload = broken)
n = try append(wire, 0, zero, id, "refs/tags/good", "report-status atomic", true)
n = try append(wire, n, zero, next, "refs/heads/bad", "", false)
n += try git.encode_packet(git.PacketKind.flush, b"", wire[n..])
n += try git.encode_pack(objects[..<1], wire[n..])
denied = false
_ = repositories.receive_pack(database, "alice", "alice", "push", wire[..<n]) catch:
denied = true
recover 0
assert(denied)
try absent(database, "refs/tags/good")
try absent(database, "refs/heads/bad")
try expect(database, "refs/tags/keep", id)
pub func main(arguments: str[]) -> i32!:
assert(arguments.length == 3)
let database = try db.Database.open(arguments[1], "receive-test")
try repositories.use_objects(arguments[1])
defer database.release()
if arguments[2] == "read":
var id: u8[20]
_ = try git.hash_object("commit", first, id)
try expect(database.value(), "refs/tags/keep", id)
try absent(database.value(), "refs/heads/main")
else:
let authority = try auth.Authority.attach(try database.value().store())
defer authority.release()
try authority.value().bootstrap("alice", "receive-fixture-password")
try repositories.initialize(database.value())
try repositories.create(database.value(), "alice", "push")
if arguments[2] == "ipc":
try database.value().listen()
var socket_buffer: u8[512]
let socket = try strings.format(socket_buffer, f"{arguments[1]}.sock")
let client = try db.Database.connect(socket, "receive-test")
defer client.release()
try cases(client.value())
else: try cases(database.value())
print("PASS repository receive pack validation, CAS, graph atomicity, deletion and reopen")
return 0