///|
/// Durable, serializable checksum metadata; no database image or clean page
/// bytes are retained. The caller publishes the next state with the LTX file.
#derive(ToJson, FromJson)
priv struct LtxPageState {
format : String
pageSize : Int32
pageCount : Int32
txid : String
checksum : String
pages : Array[(Int32, String)]
}
///|
#derive(FromJson)
priv struct LtxPageInput {
pageSize : Int32
pageCount : Int32
pages : Array[Int32]
min : String
max : String
timestamp : String
snapshot : Bool
}
///|
fn ltx_json_int(value : Json) -> Int32 raise {
guard value is Number(n, ..) &&
n >= 0 &&
n <= 2147483647 &&
n.to_int().to_double() == n else {
raise Invalid("invalid LTX page integer")
}
n.to_int()
}
///|
fn ltx_page_crc(page : Int32, data : BytesView) -> UInt64 {
let crc = Crc64::{ value: 0xffffffffffffffffUL, }
let head = @buffer.Buffer()
head.write_int_be(page)
crc.write(head.to_bytes())
crc.write(data)
crc.sum()
}
///|
fn encode_ltx_pages_checked(
state : String,
metadata : String,
data : Bytes,
) -> LtxResult raise {
guard state.length() <= 8388608 &&
metadata.length() <= 2097152 &&
data.length() <= MaxImage else {
raise Invalid("LTX page input limit")
}
let json = @json.parse(metadata)
guard json
is { "pageSize": size, "pageCount": count, "pages": Array(raw), .. } else {
raise Invalid("invalid LTX page metadata")
}
let size = ltx_json_int(size)
let count = ltx_json_int(count)
guard size >= 512 &&
size <= 65536 &&
(size & (size - 1)) == 0 &&
count <= MaxImage / size &&
raw.length() <= count else {
raise Invalid("invalid LTX page size/count")
}
for page in raw {
ignore(ltx_json_int(page))
}
let input : LtxPageInput = @json.from_json(json)
guard data.length() == input.pages.length() * size else {
raise Invalid("LTX page payload size mismatch")
}
let min = parse_txid(input.min)
let max = parse_txid(input.max)
let time = @string.parse_int64(input.timestamp)
guard min > 0UL && min <= max && time >= 0L else {
raise Invalid("invalid LTX page transaction/time")
}
let checksums : Map[Int32, UInt64] = Map([])
let mut pre = 0UL
let mut post = ChecksumFlag
let mut before_count = 0
if state != "" {
let json = @json.parse(state)
guard json
is {
"pageSize": old_size,
"pageCount": old_count,
"pages": Array(raw),
..
} else {
raise Invalid("invalid LTX page state")
}
ignore(ltx_json_int(old_size))
before_count = ltx_json_int(old_count)
guard before_count <= MaxImage / size && raw.length() == before_count else {
raise Invalid("incomplete LTX page state")
}
for i, pair in raw {
guard pair is Array([number, String(_)]) && ltx_json_int(number) == i + 1 else {
raise Invalid("invalid LTX page checksum entry")
}
}
let old : LtxPageState = @json.from_json(json)
guard old.format == "ltx-page-state@1" &&
old.pageSize == size &&
parse_txid(old.txid) < 0xffffffffffffffffUL &&
min == parse_txid(old.txid) + 1UL else {
raise Invalid("LTX page state/transaction mismatch")
}
for (page, checksum) in old.pages {
let crc = @string.parse_uint64(checksum, radix=10)
checksums[page] = crc
post = ChecksumFlag | (post ^ crc)
}
pre = @string.parse_uint64(old.checksum, radix=10)
guard post == pre else { raise Invalid("LTX page state checksum mismatch") }
} else {
guard min == 1UL && input.snapshot else {
raise Invalid("initial LTX pages require snapshot")
}
}
let mut previous = 0
for i, page in input.pages {
guard page > previous && page <= count else {
raise Invalid("invalid LTX page order/range")
}
previous = page
let bytes = data[i * size:(i + 1) * size]
if page == 1 {
guard bytes[0:16] == b"SQLite format 3\x00" &&
(
(bytes[28].to_int() << 24) |
(bytes[29].to_int() << 16) |
(bytes[30].to_int() << 8) |
bytes[31].to_int()
) ==
count &&
((bytes[16].to_int() << 8) | bytes[17].to_int()) ==
(if size == 65536 { 1 } else { size }) else {
raise Invalid("LTX page header mismatch")
}
}
let crc = ltx_page_crc(page, bytes)
post = ChecksumFlag | (post ^ checksums.get(page).unwrap_or(0UL) ^ crc)
checksums[page] = crc
}
for page in (before_count + 1)..<=count {
guard checksums.contains(page) else {
raise Invalid("missing grown LTX page")
}
}
if input.snapshot {
guard input.pages.length() == count else {
raise Invalid("incomplete LTX page snapshot")
}
}
if before_count != count && count > 0 {
guard input.pages.contains(1) else {
raise Invalid("missing LTX header page")
}
}
if count < before_count {
for page in (count + 1)..<=before_count {
post = ChecksumFlag | (post ^ checksums[page])
checksums.remove(page)
}
}
let frames = input.pages
.mapi((i, page) => (page, data[i * size:(i + 1) * size]))
.iter()
let result = ltx_write_pages(
size,
count,
input.min,
input.max,
time,
pre,
post,
data.length() / 4,
frames,
)
let next : LtxPageState = {
format: "ltx-page-state@1",
pageSize: size,
pageCount: count,
txid: input.max,
checksum: post.to_string(),
pages: Array::makei(count, i => (i + 1, checksums[i + 1].to_string())),
}
let info = @json.parse(result.metadata)
if info is Object(fields) {
fields["pageState"] = @json.to_json(next)
}
ltx_result(result.data, info.stringify())
}
///|
pub fn encode_ltx_pages(
state : String,
metadata : String,
data : Bytes,
) -> LtxResult {
encode_ltx_pages_checked(state, metadata, data) catch {
e =>
ltx_result(
b"",
(
{
"error": match e {
Invalid(message) => message
_ => e.to_string()
},
} : Json).stringify(),
)
}
}
///|
pub fn encode_ltx_pages_base64(
state : String,
metadata : String,
data : String,
) -> LtxResult {
try {
guard data.length() <= 89478488 else {
raise Invalid("LTX page payload input limit")
}
encode_ltx_pages(state, metadata, @base64.decode(data))
} catch {
e =>
ltx_result(
b"",
(
{
"error": match e {
Invalid(message) => message
_ => e.to_string()
},
} : Json).stringify(),
)
}
}