From 88b5fabd56ec0f9d46eed2dbf7fbc08b84b1f216 Mon Sep 17 00:00:00 2001 From: Determinant Date: Tue, 16 Jun 2020 14:50:05 -0400 Subject: prepare for publish --- Cargo.toml | 4 ++++ src/lib.rs | 44 ++++++++++++++++++++++++++++++++++++++++++++ src/wal.rs | 2 +- 3 files changed, 49 insertions(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index f84b995..ca270ef 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -3,6 +3,10 @@ name = "growth-ring" version = "0.1.0" authors = ["Determinant "] edition = "2018" +homepage = "https://github.com/Determinant/growth-ring" +keywords = ["wal", "db", "futures"] +license = "MIT" +description = "Simple and modular write-ahead-logging implementation." # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html diff --git a/src/lib.rs b/src/lib.rs index 906ec41..6e3109d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,3 +1,47 @@ +//! Simple and modular write-ahead-logging implementation. +//! +//! # Examples +//! +//! ``` +//! use growthring::{WALStoreAIO, wal::WALLoader}; +//! use futures::executor::block_on; +//! // start from empty WAL (trucate = true) +//! let store = WALStoreAIO::new("./walfiles", true, |_, _| {Ok(())}); +//! let mut wal = WALLoader::new(9, 8, 1000).recover(store).unwrap(); +//! // write a vector of records to WAL +//! for f in wal.grow(vec!["record1(foo)", "record2(bar)", "record3(foobar)"]).into_iter() { +//! let ring_id = block_on(f).unwrap().1; +//! println!("WAL recorded record to {:?}", ring_id); +//! } +//! +//! +//! // load from WAL if exists (trucate = false) +//! let store = WALStoreAIO::new("./walfiles", false, |payload, ringid| { +//! // redo the operations in your application +//! println!("recover(payload={}, ringid={:?})", +//! std::str::from_utf8(&payload).unwrap(), +//! ringid); +//! Ok(()) +//! }); +//! let mut wal = WALLoader::new(9, 8, 1000).recover(store).unwrap(); +//! // We'll see the playback of the log even if there is no failure. Let's remove the old log +//! // entries by assuming they are already persistent in your application. +//! let ring_ids = wal.grow((0..100).into_iter().map(|i| "a".repeat(i)).collect::>()) +//! .into_iter().map(|f| block_on(f).unwrap().1).collect::>(); +//! +//! +//! // Let's assume all these records are not longer needed. There will only be one remaining file +//! // in ./walfiles +//! block_on(wal.peel(ring_ids)).unwrap(); +//! +//! let store = WALStoreAIO::new("./walfiles", false, |payload, _| { +//! println!("payload.len() = {}", payload.len()); +//! Ok(()) +//! }); +//! let wal = WALLoader::new(9, 8, 1000).recover(store).unwrap(); +//! // The ./walfiles is empty now as all records are played back. +//! ``` + #[macro_use] extern crate scan_fmt; pub mod wal; diff --git a/src/wal.rs b/src/wal.rs index c378e0a..aefec36 100644 --- a/src/wal.rs +++ b/src/wal.rs @@ -73,7 +73,7 @@ impl Record for String { fn serialize(&self) -> WALBytes { self.as_bytes().into() } } -impl Record for str { +impl Record for &str { fn serialize(&self) -> WALBytes { self.as_bytes().into() } } -- cgit v1.2.3