#![deny(missing_docs)]
use smallvec::SmallVec;
mod file;
pub use file::FileBlockStore;
const LEVEL_MASK: u64 = 0x0f;
const SEGMENT_VERSION_MASK: u64 = 0x0fff_ffff;
const LARGE_LEVEL: u8 = 15;
const MAX_LARGE_BLOCK_ID: u64 = (1_u64 << 60) - 1;
const SLOT_SIZES: [u64; 15] = [4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192, 256, 384, 512];
#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct RecordSeq(pub(crate) u32);
impl RecordSeq {
pub(crate) const NULL: Self = Self(u32::MAX);
pub(crate) fn new(value: u32) -> std::io::Result<Self> {
if value == 0 || value == u32::MAX {
Err(std::io::Error::new(
std::io::ErrorKind::InvalidData,
"invalid record sequence",
))
} else {
Ok(Self(value))
}
}
pub(crate) fn try_from_u64(value: u64) -> std::io::Result<Self> {
let value = u32::try_from(value).map_err(|_| {
std::io::Error::new(
std::io::ErrorKind::InvalidData,
"record sequence exceeds V1 range",
)
})?;
Self::new(value)
}
pub fn get(self) -> u32 {
self.0
}
pub fn is_null(self) -> bool {
self == Self::NULL
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct CommitResult {
business_record_seq: RecordSeq,
maintenance: MaintenanceResult,
}
impl CommitResult {
pub(crate) fn new(business_record_seq: RecordSeq, maintenance: MaintenanceResult) -> Self {
Self {
business_record_seq,
maintenance,
}
}
pub fn business_record_seq(&self) -> RecordSeq {
self.business_record_seq
}
pub fn maintenance(&self) -> &MaintenanceResult {
&self.maintenance
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum MaintenanceResult {
NotNeeded,
Completed {
record_seq: RecordSeq,
},
Failed {
error: MaintenanceError,
store_status: MaintenanceStoreStatus,
},
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum MaintenanceError {
PreparationFailed,
AppendFailed,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum MaintenanceStoreStatus {
Ready,
RecoveryRequired,
}
#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct SegmentVersion(pub(crate) u32);
impl SegmentVersion {
pub(crate) fn new(value: u32) -> std::io::Result<Self> {
if value == 0 || value > SEGMENT_VERSION_MASK as u32 {
Err(std::io::Error::new(
std::io::ErrorKind::InvalidData,
"invalid segment version",
))
} else {
Ok(Self(value))
}
}
pub fn get(self) -> u32 {
self.0
}
}
#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct LargeBlockId(pub(crate) u64);
impl LargeBlockId {
pub(crate) fn new(value: u64) -> std::io::Result<Self> {
if value == 0 || value >= MAX_LARGE_BLOCK_ID {
Err(std::io::Error::new(
std::io::ErrorKind::InvalidData,
"invalid large block id",
))
} else {
Ok(Self(value))
}
}
pub fn get(self) -> u64 {
self.0
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct BlockId(
u64,
);
pub struct DeviceId(
[u8; 16],
);
impl DeviceId {
pub fn as_bytes(&self) -> &[u8; 16] {
&self.0
}
}
pub struct BlockDeviceCapabilities {
compression: bool,
encryption: bool,
data_checksums: bool,
}
impl BlockDeviceCapabilities {
pub fn compression(&self) -> bool {
self.compression
}
pub fn encryption(&self) -> bool {
self.encryption
}
pub fn data_checksums(&self) -> bool {
self.data_checksums
}
}
pub struct BlockDeviceMetricsSnapshot {
used_bytes: u64,
free_bytes: u64,
available_bytes: Option<u64>,
read_ops: u64,
read_bytes: u64,
write_ops: u64,
write_bytes: u64,
commit_ok: u64,
commit_failed: u64,
recovery_count: u64,
reclaimed_bytes: u64,
}
impl BlockDeviceMetricsSnapshot {
pub fn used_bytes(&self) -> u64 {
self.used_bytes
}
pub fn free_bytes(&self) -> u64 {
self.free_bytes
}
pub fn available_bytes(&self) -> Option<u64> {
self.available_bytes
}
pub fn read_ops(&self) -> u64 {
self.read_ops
}
pub fn read_bytes(&self) -> u64 {
self.read_bytes
}
pub fn write_ops(&self) -> u64 {
self.write_ops
}
pub fn write_bytes(&self) -> u64 {
self.write_bytes
}
pub fn commit_ok(&self) -> u64 {
self.commit_ok
}
pub fn commit_failed(&self) -> u64 {
self.commit_failed
}
pub fn recovery_count(&self) -> u64 {
self.recovery_count
}
pub fn reclaimed_bytes(&self) -> u64 {
self.reclaimed_bytes
}
}
pub struct WriteInput {
pub data: Vec<u8>,
}
pub struct AllocatedBlock {
block: BlockId,
_input: WriteInput,
_store_identity: u64,
_transaction_identity: u64,
}
impl AllocatedBlock {
pub fn block_id(&self) -> BlockId {
self.block
}
pub(crate) fn new(
block: BlockId,
input: WriteInput,
store_identity: u64,
transaction_identity: u64,
) -> Self {
Self {
block,
_input: input,
_store_identity: store_identity,
_transaction_identity: transaction_identity,
}
}
pub(crate) fn into_parts(self) -> (BlockId, WriteInput, u64, u64) {
(
self.block,
self._input,
self._store_identity,
self._transaction_identity,
)
}
}
pub struct RootName(
String,
);
impl RootName {
pub fn new(value: String) -> Result<Self, BlockStoreError> {
if value.is_empty() {
Err(BlockStoreError::RootNameEmpty)
} else {
Ok(Self(value))
}
}
pub fn as_str(&self) -> &str {
&self.0
}
pub(crate) fn from_validated(value: String) -> Self {
Self(value)
}
}
pub struct RootVersion {
block: BlockId,
}
impl RootVersion {
pub(crate) fn new(block: BlockId) -> Self {
Self { block }
}
pub fn block(&self) -> BlockId {
self.block
}
}
pub struct NamedRoot {
name: RootName,
root: RootVersion,
}
impl NamedRoot {
pub(crate) fn new(name: RootName, block: BlockId) -> Self {
Self {
name,
root: RootVersion::new(block),
}
}
pub fn name(&self) -> &RootName {
&self.name
}
pub fn root(&self) -> &RootVersion {
&self.root
}
}
pub struct AnonymousRoot {
root: RootVersion,
}
impl AnonymousRoot {
pub(crate) fn new(block: BlockId) -> Self {
Self {
root: RootVersion::new(block),
}
}
pub fn root(&self) -> &RootVersion {
&self.root
}
}
pub enum SegmentState {
Active,
Sealed,
}
pub struct SegmentId {
store_identity: u64,
snapshot_identity: u64,
segment_key: u64,
}
impl SegmentId {
pub(crate) fn new(store_identity: u64, snapshot_identity: u64, segment_key: u64) -> Self {
Self {
store_identity,
snapshot_identity,
segment_key,
}
}
pub(crate) fn store_identity(&self) -> u64 {
self.store_identity
}
pub(crate) fn snapshot_identity(&self) -> u64 {
self.snapshot_identity
}
pub(crate) fn segment_key(&self) -> u64 {
self.segment_key
}
}
pub struct SegmentInfo {
segment: SegmentId,
level: u8,
slot_size: u64,
frontier: u64,
live_count: u64,
state: SegmentState,
}
impl SegmentInfo {
pub(crate) fn new(
segment: SegmentId,
level: u8,
slot_size: u64,
frontier: u64,
live_count: u64,
state: SegmentState,
) -> Self {
Self {
segment,
level,
slot_size,
frontier,
live_count,
state,
}
}
pub fn segment(&self) -> SegmentId {
SegmentId {
store_identity: self.segment.store_identity,
snapshot_identity: self.segment.snapshot_identity,
segment_key: self.segment.segment_key,
}
}
pub fn level(&self) -> u8 {
self.level
}
pub fn slot_size(&self) -> u64 {
self.slot_size
}
pub fn frontier(&self) -> u64 {
self.frontier
}
pub fn live_count(&self) -> u64 {
self.live_count
}
pub fn state(&self) -> SegmentState {
match &self.state {
SegmentState::Active => SegmentState::Active,
SegmentState::Sealed => SegmentState::Sealed,
}
}
}
pub trait BlockDeviceInfo {
fn device_id(&self) -> DeviceId;
fn base_block_size(&self) -> u64;
fn supported_block_sizes(&self) -> &'static [u64];
fn capabilities(&self) -> BlockDeviceCapabilities;
}
pub trait BlockDeviceMetrics {
fn metrics(&self) -> BlockDeviceMetricsSnapshot;
}
#[allow(async_fn_in_trait)]
pub trait AsyncBlockDevice: BlockDeviceInfo + BlockDeviceMetrics + Send + Sync + 'static {
type ReadBuf: AsRef<[u8]> + Send + 'static;
async fn read(&self, block: BlockId) -> Result<Self::ReadBuf, BlockStoreError>;
}
#[allow(async_fn_in_trait)]
pub trait BlockStore {
type Snapshot: ReadSnapshot;
type Transaction: WriteTransaction;
fn open_snapshot(&self) -> Result<Self::Snapshot, BlockStoreError>;
async fn begin_write(&self) -> Result<Self::Transaction, BlockStoreError>;
}
pub trait ReadSnapshot: Send + Sync + 'static {
type NamedRoots<'a>: Iterator<Item = &'a NamedRoot>
where
Self: 'a;
type AnonymousRoots<'a>: Iterator<Item = &'a AnonymousRoot>
where
Self: 'a;
type SegmentInfos<'a>: Iterator<Item = &'a SegmentInfo>
where
Self: 'a;
type LiveBlocks<'a>: Iterator<Item = BlockId>
where
Self: 'a;
fn list_named_roots(&self) -> Self::NamedRoots<'_>;
fn list_anonymous_roots(&self) -> Self::AnonymousRoots<'_>;
fn get_named_root(&self, name: &RootName) -> Option<&NamedRoot>;
fn get_root(&self, block: BlockId) -> Option<&RootVersion>;
fn segment_infos(&self) -> Self::SegmentInfos<'_>;
fn live_blocks(&self, segment: SegmentId) -> Result<Self::LiveBlocks<'_>, BlockStoreError>;
}
#[allow(async_fn_in_trait)]
pub trait WriteTransaction {
fn alloc(&mut self, input: WriteInput) -> Result<AllocatedBlock, BlockStoreError>;
async fn write_batch(
&mut self,
blocks: SmallVec<[AllocatedBlock; 8]>,
) -> Result<(), BlockStoreError>;
fn add_root_version(&mut self, block: BlockId) -> Result<(), BlockStoreError>;
fn create_named_binding(
&mut self,
name: RootName,
target: BlockId,
) -> Result<(), BlockStoreError>;
fn remove_named_binding(&mut self, name: &RootName) -> Result<(), BlockStoreError>;
fn delete_root_version(&mut self, target: BlockId) -> Result<(), BlockStoreError>;
fn release_blocks(&mut self, blocks: Vec<BlockId>) -> Result<(), BlockStoreError>;
async fn commit(&mut self) -> Result<CommitResult, BlockStoreError>;
}
#[derive(Debug)]
pub enum BlockStoreError {
Io(
std::io::Error,
),
InvalidBlockId,
BlockNotFound,
BlockNotCommitted,
BlockCorrupted,
InvalidWriteInput,
AllocatedBlockNotOwned,
AllocatedBlockAlreadyWritten,
AllocatedBlockNotWritten,
BlockAlreadyReleased,
SegmentNotFound,
RootNotFound,
RootAlreadyDeleted,
RootStillNamed,
RootNameEmpty,
RootNameAlreadyBound,
NamedBindingNotFound,
NamedBindingTargetNotFound,
WriteTransactionBusy,
WriteTransactionClosed,
NoSpace,
SegmentVersionExhausted,
LargeBlockIdExhausted,
CommitFailed,
CommitStatusUnknown,
RecoveryRequired,
RecoveryFailed,
RecordTooLarge,
UnsupportedFormat,
}
impl PartialEq for BlockStoreError {
fn eq(&self, other: &Self) -> bool {
match (self, other) {
(Self::Io(left), Self::Io(right)) => {
left.kind() == right.kind() && left.to_string() == right.to_string()
}
(Self::Io(_), _) | (_, Self::Io(_)) => false,
_ => std::mem::discriminant(self) == std::mem::discriminant(other),
}
}
}
impl Eq for BlockStoreError {}
impl std::fmt::Display for BlockStoreError {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Io(source) => write!(formatter, "I/O error: {source}"),
_ => write!(formatter, "{self:?}"),
}
}
}
impl std::error::Error for BlockStoreError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Self::Io(source) => Some(source),
_ => None,
}
}
}
impl TryFrom<u64> for BlockId {
type Error = BlockStoreError;
fn try_from(raw: u64) -> Result<Self, Self::Error> {
let level = (raw & LEVEL_MASK) as u8;
let high_bits = raw >> 4;
let valid = if level == LARGE_LEVEL {
high_bits != 0 && high_bits != MAX_LARGE_BLOCK_ID
} else {
high_bits & SEGMENT_VERSION_MASK != 0
};
valid
.then_some(Self(raw))
.ok_or(BlockStoreError::InvalidBlockId)
}
}
impl From<BlockId> for u64 {
fn from(block_id: BlockId) -> Self {
block_id.0
}
}
impl BlockId {
pub(crate) fn from_raw_unchecked(raw: u64) -> Self {
Self(raw)
}
pub fn level(self) -> u8 {
(self.0 & LEVEL_MASK) as u8
}
pub fn segment_version(self) -> Option<u32> {
(self.level() != LARGE_LEVEL).then_some(((self.0 >> 4) & SEGMENT_VERSION_MASK) as u32)
}
pub fn block_index(self) -> Option<u32> {
(self.level() != LARGE_LEVEL).then_some((self.0 >> 32) as u32)
}
pub fn large_block_id(self) -> Option<u64> {
(self.level() == LARGE_LEVEL).then_some(self.0 >> 4)
}
pub fn slot_size(self) -> Option<u64> {
SLOT_SIZES
.get(usize::from(self.level()))
.map(|size_kib| size_kib * 1024)
}
}