From d7076f016202bb2bc8a02df0d482d1fb4820ae44 Mon Sep 17 00:00:00 2001 From: Samuel Shuert Date: Mon, 24 Nov 2025 18:30:34 +0000 Subject: [PATCH] feat: function signatures Change-Id: mltmlnyrnvukqllyxkttrlsyrwmkpyyl --- Cargo.toml | 1 + nilla.nix | 20 ++++- npins/sources.json | 13 ++++ src/lib.rs | 1 + src/reftable/basics.rs | 64 ++++++++++++++++ src/reftable/block.rs | 59 ++++++++++++++ src/reftable/blocksource.rs | 21 +++++ src/reftable/error.rs | 34 +++++++++ src/reftable/fsck.rs | 26 +++++++ src/reftable/iter.rs | 0 src/reftable/merged.rs | 0 src/reftable/mod.rs | 14 ++++ src/reftable/pq.rs | 0 src/reftable/record.rs | 148 ++++++++++++++++++++++++++++++++++++ src/reftable/stack.rs | 0 src/reftable/system.rs | 0 src/reftable/table.rs | 0 src/reftable/tree.rs | 0 src/reftable/write.rs | 0 19 files changed, 399 insertions(+), 2 deletions(-) create mode 100644 src/reftable/basics.rs create mode 100644 src/reftable/block.rs create mode 100644 src/reftable/blocksource.rs create mode 100644 src/reftable/error.rs create mode 100644 src/reftable/fsck.rs create mode 100644 src/reftable/iter.rs create mode 100644 src/reftable/merged.rs create mode 100644 src/reftable/mod.rs create mode 100644 src/reftable/pq.rs create mode 100644 src/reftable/record.rs create mode 100644 src/reftable/stack.rs create mode 100644 src/reftable/system.rs create mode 100644 src/reftable/table.rs create mode 100644 src/reftable/tree.rs create mode 100644 src/reftable/write.rs diff --git a/Cargo.toml b/Cargo.toml index 2f51bf5d5f..f3ae0bc5e1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,3 +8,4 @@ rust-version = "1.49.0" crate-type = ["staticlib"] [dependencies] +libz-sys = "1.1.23" diff --git a/nilla.nix b/nilla.nix index 7fe9933de0..2e4d7f604e 100644 --- a/nilla.nix +++ b/nilla.nix @@ -11,15 +11,31 @@ nilla.create ( { config, lib }: { config = { - inputs.nixpkgs.src = pins.nixpkgs; + inputs.nixpkgs = { + src = pins.nixpkgs; + settings.overlays = [ config.inputs.fenix.result.overlays.default ]; + }; + + inputs.fenix.src = pins.fenix; shells.default = { systems = [ "x86_64-linux" ]; shell = - { mkShell, git }: + { mkShell, git, fenix, bacon }: mkShell { inputsFrom = [ git ]; + packages = [ + (fenix.complete.withComponents [ + "cargo" + "clippy" + "rust-src" + "rustc" + "rustfmt" + "rust-analyzer" + ]) + bacon + ]; }; }; }; diff --git a/npins/sources.json b/npins/sources.json index 7f62a28e2a..f559efda2c 100644 --- a/npins/sources.json +++ b/npins/sources.json @@ -1,5 +1,18 @@ { "pins": { + "fenix": { + "type": "Git", + "repository": { + "type": "GitHub", + "owner": "nix-community", + "repo": "fenix" + }, + "branch": "main", + "submodules": false, + "revision": "a563f057979806c59da53070297502eb7af22f62", + "url": "https://github.com/nix-community/fenix/archive/a563f057979806c59da53070297502eb7af22f62.tar.gz", + "hash": "sha256-WfItZn6duisxCxyltbu7Hs7kxzNeylgZGOwCYwHe26g=" + }, "nilla": { "type": "GitRelease", "repository": { diff --git a/src/lib.rs b/src/lib.rs index 9da70d8b57..168c39e2bf 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1 +1,2 @@ +pub mod reftable; pub mod varint; diff --git a/src/reftable/basics.rs b/src/reftable/basics.rs new file mode 100644 index 0000000000..cfca69d5b5 --- /dev/null +++ b/src/reftable/basics.rs @@ -0,0 +1,64 @@ +#[derive(Debug, Clone)] +pub struct ReftableBuf { + pub data: Vec, + pub len: usize, +} + +impl ReftableBuf { + pub fn new() -> Self { + Self { + data: Vec::new(), + len: 0, + } + } + + pub fn with_capacity(capacity: usize) -> Self { + Self { + data: Vec::with_capacity(capacity), + len: 0, + } + } + + pub fn clear(&mut self) { + self.data.clear(); + self.len = 0; + } + + pub fn as_slice(&self) -> &[u8] { + &self.data[..self.len] + } +} + +impl Default for ReftableBuf { + fn default() -> Self { + Self::new() + } +} + +pub fn binsearch(sz: usize, mut f: F) -> usize +where + F: FnMut(usize) -> Result, +{ + todo!() +} + +pub fn names_length(names: &[&str]) -> usize { + todo!() +} + +pub fn parse_names(buf: &str) -> Result, String> { + todo!() +} + +pub fn common_prefix_size(a: &ReftableBuf, b: &ReftableBuf) -> usize { + todo!() +} + +pub enum HashAlgorithm { + Sha1 = 89, + Sha256 = 247, +} + +pub fn hash_size(id: HashAlgorithm) -> u32 { + todo!() +} diff --git a/src/reftable/block.rs b/src/reftable/block.rs new file mode 100644 index 0000000000..45d7148b50 --- /dev/null +++ b/src/reftable/block.rs @@ -0,0 +1,59 @@ +use crate::reftable::{basics::ReftableBuf, blocksource::ReftableBlockData}; +use libz_sys::z_stream; + +pub struct BlockWriter { + pub zstream: Box, + pub compressed: Vec, + + pub block: Vec, + pub block_size: u32, + + pub header_off: u32, + + pub restart_interval: u16, + pub hash_size: u32, + + pub next: u32, + pub restarts: Vec, + pub restart_len: u32, + pub restart_cap: u32, + + pub last_key: ReftableBuf, + + pub scratch: ReftableBuf, + pub entries: i32, +} + +pub struct BlockIter { + pub next_off: u32, + pub block: Vec, + + pub last_key: ReftableBuf, + pub scratch: ReftableBuf, +} + +pub struct ReftableBlock { + pub header_off: u32, + + pub block_data: ReftableBlockData, + pub hash_size: usize, + + pub zstream: Box, + pub uncompressed_data: Vec, + + pub restart_count: u16, + pub restart_off: u32, + + pub full_block_size: u32, + pub block_type: u8, +} + +pub struct BlockReader { + pub zstream: Box, + pub uncompressed: Vec, + pub uncompressed_len: usize, + + pub block: ReftableBlock, + + pub pos: usize, +} diff --git a/src/reftable/blocksource.rs b/src/reftable/blocksource.rs new file mode 100644 index 0000000000..02f4ca617a --- /dev/null +++ b/src/reftable/blocksource.rs @@ -0,0 +1,21 @@ +pub struct ReftableBlockData { + data: Vec, + source: ReftableBlockSource, +} + +impl AsRef<[u8]> for ReftableBlockData { + fn as_ref(&self) -> &[u8] { + &self.data + } +} + +pub trait ReftableBlockSourceOps { + fn size(&self) -> u64; + fn read_block(&self, offset: u64, size: u32) -> Result, String>; + fn release_block(&self, data: &ReftableBlockData) -> Result<(), String>; + fn close(&mut self) -> Result<(), String>; +} + +pub struct ReftableBlockSource { + ops: Box, +} diff --git a/src/reftable/error.rs b/src/reftable/error.rs new file mode 100644 index 0000000000..515fdb7eb9 --- /dev/null +++ b/src/reftable/error.rs @@ -0,0 +1,34 @@ +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum ReftableError { + General(String), + Io, + Format, + NotExist, + Lock, + Api, + Zlib, + EmptyTable, + Refname, + EntryTooBig, + Outdated, + OutOfMemory, +} + +impl std::fmt::Display for ReftableError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + ReftableError::General(msg) => write!(f, "general error: {}", msg), + ReftableError::Io => write!(f, "I/O error"), + ReftableError::Format => write!(f, "corrupt reftable file"), + ReftableError::NotExist => write!(f, "file does not exist"), + ReftableError::Lock => write!(f, "data is locked"), + ReftableError::Api => write!(f, "misuse of the reftable API"), + ReftableError::Zlib => write!(f, "zlib failure"), + ReftableError::EmptyTable => write!(f, "wrote empty table"), + ReftableError::Refname => write!(f, "invalid refname"), + ReftableError::EntryTooBig => write!(f, "entry too large"), + ReftableError::Outdated => write!(f, "data concurrently modified"), + ReftableError::OutOfMemory => write!(f, "out of memory"), + } + } +} diff --git a/src/reftable/fsck.rs b/src/reftable/fsck.rs new file mode 100644 index 0000000000..b53ef9484b --- /dev/null +++ b/src/reftable/fsck.rs @@ -0,0 +1,26 @@ +pub enum ReftableFsckError { + TableName, + MaxValue, +} + +pub struct ReftableFsckInfo { + pub msg: String, + pub path: String, + pub error: ReftableFsckError, +} + +pub fn table_has_valid_name(name: &str) -> bool { + todo!() +} + +pub fn table_check_name(table: &ReftableTable) -> Result<(), String> { + todo!() +} + +pub fn table_checks(table: &ReftableTable) -> Result<(), String> { + todo!() +} + +pub fn reftable_fsck_check(stack: &ReftableStack) -> Result<(), String> { + todo!() +} diff --git a/src/reftable/iter.rs b/src/reftable/iter.rs new file mode 100644 index 0000000000..e69de29bb2 diff --git a/src/reftable/merged.rs b/src/reftable/merged.rs new file mode 100644 index 0000000000..e69de29bb2 diff --git a/src/reftable/mod.rs b/src/reftable/mod.rs new file mode 100644 index 0000000000..e675a3bca3 --- /dev/null +++ b/src/reftable/mod.rs @@ -0,0 +1,14 @@ +pub mod basics; +pub mod block; +pub mod blocksource; +pub mod error; +pub mod fsck; +pub mod iter; +pub mod merged; +pub mod pq; +pub mod record; +pub mod stack; +pub mod system; +pub mod table; +pub mod tree; +pub mod write; diff --git a/src/reftable/pq.rs b/src/reftable/pq.rs new file mode 100644 index 0000000000..e69de29bb2 diff --git a/src/reftable/record.rs b/src/reftable/record.rs new file mode 100644 index 0000000000..a4684d38c7 --- /dev/null +++ b/src/reftable/record.rs @@ -0,0 +1,148 @@ +use crate::reftable::basics::ReftableBuf; + +pub const REFTABLE_HASH_SIZE_MAX: usize = 32; +pub const REFTABLE_HASH_SIZE_SHA1: usize = 20; +pub const REFTABLE_HASH_SIZE_SHA256: usize = 32; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum RefValueType { + Deletion = 0x0, + Val1 = 0x1, + Val2 = 0x2, + SymRef = 0x3, +} + +impl std::convert::TryFrom for RefValueType { + type Error = String; + + fn try_from(value: u8) -> Result { + match value { + 0x0 => Ok(RefValueType::Deletion), + 0x1 => Ok(RefValueType::Val1), + 0x2 => Ok(RefValueType::Val2), + 0x3 => Ok(RefValueType::SymRef), + _ => Err(format!("Unknown ref value type: {value}")), + } + } +} + +#[derive(Debug, Clone)] +pub enum RefValue { + Val1([u8; REFTABLE_HASH_SIZE_MAX]), + Val2 { + value: [u8; REFTABLE_HASH_SIZE_MAX], + target_value: [u8; REFTABLE_HASH_SIZE_MAX], + }, + SymRef(String), +} + +#[derive(Debug, Clone)] +pub struct ReftableRefRecord { + pub refname: String, + pub update_index: u64, + pub value: Option, +} + +impl ReftableRefRecord { + pub fn equals(&self, other: &ReftableRefRecord, hash_size: u32) -> bool { + todo!() + } +} + +impl PartialEq for ReftableRefRecord { + fn eq(&self, other: &ReftableRefRecord) -> bool { + self.equals(other, REFTABLE_HASH_SIZE_MAX as u32) + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum LogValueType { + Deletion = 0x0, + Update = 0x1, +} + +impl std::convert::TryFrom for LogValueType { + type Error = String; + + fn try_from(value: u8) -> Result { + match value { + 0x0 => Ok(LogValueType::Deletion), + 0x1 => Ok(LogValueType::Update), + _ => Err(format!("Unknown log value type: {value}")), + } + } +} + +#[derive(Debug, Clone)] +pub struct LogUpdate { + pub new_hash: [u8; REFTABLE_HASH_SIZE_MAX], + pub old_hash: [u8; REFTABLE_HASH_SIZE_MAX], + pub name: String, + pub email: String, + pub time: u64, + pub tz_offset: i16, + pub message: String, +} + +#[derive(Debug, Clone)] +pub struct ReftableLogRecord { + pub refname: String, + pub update_index: u64, + pub value: Option, +} + +impl ReftableLogRecord { + pub fn equals(&self, other: &ReftableLogRecord, hash_size: u32) -> bool { + todo!() + } +} + +impl PartialEq for ReftableLogRecord { + fn eq(&self, other: &ReftableLogRecord) -> bool { + self.equals(other, REFTABLE_HASH_SIZE_MAX as u32) + } +} + +#[derive(Debug, Clone)] +pub struct ReftableObjRecord { + pub hash_prefix: Vec, + pub offsets: Vec, +} + +impl PartialEq for ReftableObjRecord { + fn eq(&self, other: &Self) -> bool { + self.hash_prefix == other.hash_prefix && self.offsets == other.offsets + } +} + +#[derive(Debug, Clone)] +pub struct ReftableIndexRecord { + pub offset: u64, + pub last_key: ReftableBuf, +} + +impl PartialEq for ReftableIndexRecord { + fn eq(&self, other: &Self) -> bool { + self.offset == other.offset && self.last_key.as_slice() == other.last_key.as_slice() + } +} + +#[derive(Debug, Clone)] +pub enum ReftableRecord { + Ref(ReftableRefRecord), + Log(ReftableLogRecord), + Obj(ReftableObjRecord), + Index(ReftableIndexRecord), +} + +impl PartialEq for ReftableRecord { + fn eq(&self, other: &Self) -> bool { + match (self, other) { + (ReftableRecord::Ref(a), ReftableRecord::Ref(b)) => a == b, + (ReftableRecord::Log(a), ReftableRecord::Log(b)) => a == b, + (ReftableRecord::Obj(a), ReftableRecord::Obj(b)) => a == b, + (ReftableRecord::Index(a), ReftableRecord::Index(b)) => a == b, + _ => false, + } + } +} diff --git a/src/reftable/stack.rs b/src/reftable/stack.rs new file mode 100644 index 0000000000..e69de29bb2 diff --git a/src/reftable/system.rs b/src/reftable/system.rs new file mode 100644 index 0000000000..e69de29bb2 diff --git a/src/reftable/table.rs b/src/reftable/table.rs new file mode 100644 index 0000000000..e69de29bb2 diff --git a/src/reftable/tree.rs b/src/reftable/tree.rs new file mode 100644 index 0000000000..e69de29bb2 diff --git a/src/reftable/write.rs b/src/reftable/write.rs new file mode 100644 index 0000000000..e69de29bb2 -- 2.43.0