garage/src/block/block.rs

107 lines
2.3 KiB
Rust
Raw Normal View History

use std::path::PathBuf;
2022-07-18 15:18:47 +00:00
use bytes::Bytes;
2022-03-15 11:12:12 +00:00
use serde::{Deserialize, Serialize};
use zstd::stream::Encoder;
2022-03-15 11:12:12 +00:00
use garage_util::data::*;
use garage_util::error::*;
use garage_net::stream::ByteStream;
2022-07-22 16:20:27 +00:00
#[derive(Debug, Serialize, Deserialize, Copy, Clone)]
pub enum DataBlockHeader {
Plain,
Compressed,
}
#[derive(Debug)]
pub struct DataBlockElem<T> {
header: DataBlockHeader,
elem: T,
2022-03-15 11:12:12 +00:00
}
/// A possibly compressed block of data
pub type DataBlock = DataBlockElem<Bytes>;
/// A path to a possibly compressed block of data
pub type DataBlockPath = DataBlockElem<PathBuf>;
/// A stream of possibly compressed block data
pub type DataBlockStream = DataBlockElem<ByteStream>;
impl DataBlockHeader {
pub fn is_compressed(&self) -> bool {
matches!(self, DataBlockHeader::Compressed)
}
}
impl<T> DataBlockElem<T> {
pub fn from_parts(header: DataBlockHeader, elem: T) -> Self {
Self { header, elem }
}
pub fn plain(elem: T) -> Self {
Self {
header: DataBlockHeader::Plain,
elem,
}
}
pub fn compressed(elem: T) -> Self {
Self {
header: DataBlockHeader::Compressed,
elem,
}
}
pub fn into_parts(self) -> (DataBlockHeader, T) {
(self.header, self.elem)
}
pub fn as_parts_ref(&self) -> (DataBlockHeader, &T) {
(self.header, &self.elem)
}
}
2022-03-15 11:12:12 +00:00
impl DataBlock {
/// Verify data integrity. Does not return the buffer content.
2022-03-15 11:12:12 +00:00
pub fn verify(&self, hash: Hash) -> Result<(), Error> {
match self.header {
DataBlockHeader::Plain => {
if blake2sum(&self.elem) == hash {
2022-03-15 11:12:12 +00:00
Ok(())
} else {
Err(Error::CorruptData(hash))
}
}
DataBlockHeader::Compressed => {
zstd::stream::copy_decode(&self.elem[..], std::io::sink())
.map_err(|_| Error::CorruptData(hash))
}
2022-03-15 11:12:12 +00:00
}
}
2022-07-18 15:18:47 +00:00
pub async fn from_buffer(data: Bytes, level: Option<i32>) -> DataBlock {
tokio::task::spawn_blocking(move || {
if let Some(level) = level {
if let Ok(data_compressed) = zstd_encode(&data[..], level) {
2024-02-23 11:26:35 +00:00
return DataBlock::compressed(data_compressed.into());
2022-07-18 15:18:47 +00:00
}
2022-03-15 11:12:12 +00:00
}
2024-02-23 11:26:35 +00:00
DataBlock::plain(data.into())
2022-07-18 15:18:47 +00:00
})
.await
.unwrap()
2022-03-15 11:12:12 +00:00
}
}
fn zstd_encode<R: std::io::Read>(mut source: R, level: i32) -> std::io::Result<Vec<u8>> {
let mut result = Vec::<u8>::new();
let mut encoder = Encoder::new(&mut result, level)?;
encoder.include_checksum(true)?;
std::io::copy(&mut source, &mut encoder)?;
encoder.finish()?;
Ok(result)
}