use crate::checksum::crc32c;
use crate::codec::get_u16;
use crate::codec::get_u32;
use crate::codec::get_u64;
use crate::codec::put_u16;
use crate::codec::put_u32;
use crate::codec::put_u64;
pub mod codec;
pub const RECORD_FORMAT_VERSION: u16 = 1;
pub const RECORD_HEADER_SIZE: usize = 48;
pub const RECORD_ALIGNMENT: u32 = 32;
pub const MAX_KEY_SIZE: usize = 4 * 1024;
const RECORD_HEADER_MAGIC: [u8; 4] = *b"CRCD";
const RECORD_HEADER_CRC_OFFSET: usize = RECORD_HEADER_SIZE - size_of::<u32>();
const RECORD_VERSION_OFFSET: usize = 4;
const RECORD_KEY_LEN_OFFSET: usize = 6;
const RECORD_VALUE_LEN_OFFSET: usize = 8;
const RECORD_SEQNO_OFFSET: usize = 12;
const RECORD_KEY_HASH_OFFSET: usize = 20;
const RECORD_PAYLOAD_CRC_OFFSET: usize = 28;
const RECORD_REGION_GENERATION_OFFSET: usize = 32;
const RECORD_LEN_OFFSET: usize = 40;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct RecordHeader {
pub key_len: u16,
pub value_len: u32,
pub seqno: u64,
pub key_hash: u64,
pub payload_crc: u32,
pub region_generation: u64,
pub record_len: u32,
}
impl RecordHeader {
pub fn aligned_len(key_len: usize, value_len: usize) -> Option<u32> {
let unaligned = RECORD_HEADER_SIZE
.checked_add(key_len)?
.checked_add(value_len)?;
let aligned = checked_align_up(unaligned, RECORD_ALIGNMENT as usize)?;
u32::try_from(aligned).ok()
}
pub fn encode(&self) -> [u8; RECORD_HEADER_SIZE] {
let mut output = [0_u8; RECORD_HEADER_SIZE];
output[..RECORD_HEADER_MAGIC.len()].copy_from_slice(&RECORD_HEADER_MAGIC);
put_u16(&mut output, RECORD_VERSION_OFFSET, RECORD_FORMAT_VERSION);
put_u16(&mut output, RECORD_KEY_LEN_OFFSET, self.key_len);
put_u32(&mut output, RECORD_VALUE_LEN_OFFSET, self.value_len);
put_u64(&mut output, RECORD_SEQNO_OFFSET, self.seqno);
put_u64(&mut output, RECORD_KEY_HASH_OFFSET, self.key_hash);
put_u32(&mut output, RECORD_PAYLOAD_CRC_OFFSET, self.payload_crc);
put_u64(
&mut output,
RECORD_REGION_GENERATION_OFFSET,
self.region_generation,
);
put_u32(&mut output, RECORD_LEN_OFFSET, self.record_len);
let checksum = header_crc(&output);
put_u32(&mut output, RECORD_HEADER_CRC_OFFSET, checksum);
output
}
pub fn decode(input: &[u8]) -> Option<Self> {
if input.len() != RECORD_HEADER_SIZE
|| input.get(..RECORD_HEADER_MAGIC.len())? != RECORD_HEADER_MAGIC
|| get_u16(input, RECORD_VERSION_OFFSET)? != RECORD_FORMAT_VERSION
|| get_u32(input, RECORD_HEADER_CRC_OFFSET)? != header_crc(input)
{
return None;
}
let header = Self {
key_len: get_u16(input, RECORD_KEY_LEN_OFFSET)?,
value_len: get_u32(input, RECORD_VALUE_LEN_OFFSET)?,
seqno: get_u64(input, RECORD_SEQNO_OFFSET)?,
key_hash: get_u64(input, RECORD_KEY_HASH_OFFSET)?,
payload_crc: get_u32(input, RECORD_PAYLOAD_CRC_OFFSET)?,
region_generation: get_u64(input, RECORD_REGION_GENERATION_OFFSET)?,
record_len: get_u32(input, RECORD_LEN_OFFSET)?,
};
if !header.has_valid_lengths() {
return None;
}
Some(header)
}
fn has_valid_lengths(&self) -> bool {
let key_len = usize::from(self.key_len);
let Ok(value_len) = usize::try_from(self.value_len) else {
return false;
};
if key_len > MAX_KEY_SIZE || self.region_generation == 0 || self.seqno == 0 {
return false;
}
Self::aligned_len(key_len, value_len).is_some_and(|minimum| {
self.record_len >= minimum
&& self.record_len != 0
&& self.record_len.is_multiple_of(RECORD_ALIGNMENT)
})
}
}
fn header_crc(header: &[u8]) -> u32 {
crc32c(&[&header[..RECORD_HEADER_CRC_OFFSET], &[0; 4]])
}
fn checked_align_up(value: usize, alignment: usize) -> Option<usize> {
if !alignment.is_power_of_two() {
return None;
}
value
.checked_add(alignment.checked_sub(1)?)
.map(|rounded| rounded & !(alignment - 1))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::fixtures::assert_golden;
#[test]
fn value_record_matches_committed_golden_bytes() {
let key = b"key";
let value = b"value";
let mut payload = key.to_vec();
payload.extend_from_slice(value);
let header = RecordHeader {
key_len: key.len() as u16,
value_len: value.len() as u32,
seqno: 34,
key_hash: 0x1122_3344_5566_7788,
payload_crc: crc32c(&[&payload]),
region_generation: 17,
record_len: RecordHeader::aligned_len(key.len(), value.len()).unwrap(),
};
let record_len = RecordHeader::aligned_len(key.len(), value.len()).unwrap();
let mut encoded = vec![0_u8; record_len as usize];
encoded[..RECORD_HEADER_SIZE].copy_from_slice(&header.encode());
encoded[RECORD_HEADER_SIZE..RECORD_HEADER_SIZE + payload.len()].copy_from_slice(&payload);
let golden = assert_golden(&encoded, include_str!("format_v1/value_record.golden"));
assert_eq!(
RecordHeader::decode(&golden[..RECORD_HEADER_SIZE]),
Some(header)
);
}
#[test]
fn record_decode_rejects_bad_crc_and_lengths() {
let header = RecordHeader {
key_len: 8,
value_len: 1,
seqno: 2,
key_hash: 3,
payload_crc: 4,
region_generation: 1,
record_len: 64,
};
let mut encoded = header.encode();
encoded[RECORD_SEQNO_OFFSET] ^= 0x80;
assert_eq!(RecordHeader::decode(&encoded), None);
let oversized_key = RecordHeader {
key_len: MAX_KEY_SIZE as u16 + 1,
..header
};
assert_eq!(RecordHeader::decode(&oversized_key.encode()), None);
let mut wrong_version = header.encode();
put_u16(
&mut wrong_version,
RECORD_VERSION_OFFSET,
RECORD_FORMAT_VERSION + 1,
);
let checksum = header_crc(&wrong_version);
put_u32(&mut wrong_version, RECORD_HEADER_CRC_OFFSET, checksum);
assert_eq!(RecordHeader::decode(&wrong_version), None);
assert_eq!(RecordHeader::aligned_len(usize::MAX, 1), None);
}
}