///|
pub(all) enum RegistryCheckpointError {
RegistryHeader
RegistryFrame(Int32)
RegistryName(Int32)
RegistryQuota(Int32)
ServiceCheckpoint(Int32, CheckpointError)
}
///|
/// MLR1 serializes each configured service in name order.
pub fn Registry::checkpoint(self : Registry) -> Bytes {
let buffer = @buffer.Buffer::Buffer()
buffer.write_bytes(b"MLR1"[:])
buffer.write_uint16_be(self.capacity.to_uint16())
let names = self.names()
buffer.write_uint16_be(names.length().to_uint16())
for name in names {
buffer.write_byte(name.length().to_byte())
for ch in name {
buffer.write_byte(ch.to_int().to_byte())
}
let bytes = self.services.get(name).unwrap().checkpoint()
append_dword(buffer, bytes.length().reinterpret_as_uint())
buffer.write_bytes(bytes[:])
}
buffer.to_bytes()
}
///|
fn ascii_name(bytes : BytesView) -> String? {
let result = StringBuilder()
for byte in bytes {
if byte.to_int() > 127 {
return None
}
result.write_char(byte.to_int().unsafe_to_char())
}
let name = result.to_string()
if valid_service_name(name) {
Some(name)
} else {
None
}
}
///|
pub fn Registry::restore(
bytes : Bytes,
) -> Result[Registry, RegistryCheckpointError] {
let length = bytes.length()
if length < 8 || length > 80000000 || bytes[:4].to_owned() != b"MLR1" {
return Err(RegistryHeader)
}
let capacity = bytes.unsafe_read_uint16_be(4).to_int()
let count = bytes.unsafe_read_uint16_be(6).to_int()
if capacity < 1 || capacity > 256 || count > capacity {
return Err(RegistryHeader)
}
let registry = Registry::new(capacity~).unwrap()
let mut offset = 8
let mut previous = ""
for index in 0.. 64 || name_length > length - offset - 4 {
return Err(RegistryName(index))
}
let name = match ascii_name(bytes[offset:offset + name_length]) {
Some(name) if name > previous => name
_ => return Err(RegistryName(index))
}
previous = name
offset += name_length
let size = bytes.unsafe_read_uint32_be(offset)
offset += 4
if size < 27U || size > (length - offset).reinterpret_as_uint() {
return Err(RegistryFrame(index))
}
let end = offset + size.reinterpret_as_int()
let slots = bytes.unsafe_read_uint16_be(offset + 21).to_int()
let identities = bytes.unsafe_read_uint16_be(offset + 23).to_int()
if registry.reserved_slots + slots > 4096 ||
registry.reserved_identities + identities > 8192 {
return Err(RegistryQuota(index))
}
let collector = match Collector::restore(bytes[offset:end].to_owned()) {
Ok(value) => value
Err(error) => return Err(ServiceCheckpoint(index, error))
}
registry.services[name] = collector
registry.reserved_slots += slots
registry.reserved_identities += identities
offset = end
}
if offset != length {
return Err(RegistryFrame(count))
}
Ok(registry)
}