From ac9e4183c380dcd7c52e9b8f6e07287982a33aac Mon Sep 17 00:00:00 2001 From: Bryan Newbold Date: Thu, 26 Oct 2017 21:37:06 -0700 Subject: rustfmt --- src/sleep_register.rs | 151 +++++++++++++++++++++++++------------------------- 1 file changed, 76 insertions(+), 75 deletions(-) (limited to 'src/sleep_register.rs') diff --git a/src/sleep_register.rs b/src/sleep_register.rs index e798cad..fa8229d 100644 --- a/src/sleep_register.rs +++ b/src/sleep_register.rs @@ -8,14 +8,13 @@ use std::fs::OpenOptions; use crypto::blake2b::Blake2b; use crypto::digest::Digest; use crypto::ed25519; -use rand::{Rng, OsRng}; +use rand::{OsRng, Rng}; use errors::*; use sleep_file::*; /// Abstract access to Hypercore register pub trait HyperRegister { - /// Whether the register store contains the given (data) entry fn has(&self, index: u64) -> Result; @@ -52,11 +51,9 @@ pub trait HyperRegister { } impl HyperRegister { - fn hash_leaf(data: &[u8]) -> [u8; 40] { let mut buf = [0; 40]; - u64::to_be(data.len() as u64) - .encode_fixed(&mut buf[32..40]); + u64::to_be(data.len() as u64).encode_fixed(&mut buf[32..40]); let mut hash = Blake2b::new(32); hash.input(&[0; 1]); hash.input(&buf[32..40]); @@ -68,10 +65,9 @@ impl HyperRegister { fn hash_parent(lhash: &[u8], rhash: &[u8]) -> [u8; 40] { let mut buf = [0; 40]; // TODO: check overflow - let sum_size = u64::from_be(FixedInt::decode_fixed(&lhash[32..40])) + - u64::from_be(FixedInt::decode_fixed(&rhash[32..40])); - u64::to_be(sum_size as u64) - .encode_fixed(&mut buf[32..40]); + let sum_size = u64::from_be(FixedInt::decode_fixed(&lhash[32..40])) + + u64::from_be(FixedInt::decode_fixed(&rhash[32..40])); + u64::to_be(sum_size as u64).encode_fixed(&mut buf[32..40]); let mut hash = Blake2b::new(32); hash.input(&[1; 1]); @@ -96,7 +92,6 @@ impl HyperRegister { } hash.result(&mut buf[0..32]); Ok(buf.to_vec()) - } fn tree_root_nodes(data_count: u64) -> Vec { @@ -124,7 +119,7 @@ impl HyperRegister { let mut roots = vec![]; for x in components { roots.push(accum + (x - 1)); - accum += 2*x; + accum += 2 * x; } roots } @@ -134,7 +129,7 @@ impl HyperRegister { // log(N) would go up previous parent nodes (eg, use root_nodes()) let mut sum: u64 = 0; for i in 0..index { - let leaf = reg.get_tree_entry(i*2)?; + let leaf = reg.get_tree_entry(i * 2)?; sum += u64::from_be(FixedInt::decode_fixed(&leaf[32..40])); } Ok(sum) @@ -147,14 +142,14 @@ impl HyperRegister { // find lowest-significant zero bit if (index & (1 << i)) == 0 { // set that bit and clear next higher - return ((index | (1 << i))) & !(1 << (i+1)); + return ((index | (1 << i))) & !(1 << (i + 1)); } } panic!("Parent lookup overflowed, huge index!"); } /// Calling this on a leaf node is an error, as is calling very high node numbers (> 2^62) - fn tree_child_indices(index: u64) -> Result<(u64,u64)> { + fn tree_child_indices(index: u64) -> Result<(u64, u64)> { if index % 2 == 0 { bail!("Leaf tree nodes have no children"); } @@ -162,9 +157,9 @@ impl HyperRegister { // find lowest-significant zero bit... if (index & (1 << i)) == 0 { // larger child has this bit high, next lower bit cleared - let right = ((index | (1 << i))) & !(1 << (i-1)); + let right = ((index | (1 << i))) & !(1 << (i - 1)); // smaller child has next lower bit cleared - let left = index & !(1 << (i-1)); + let left = index & !(1 << (i - 1)); return Ok((left, right)); } } @@ -177,11 +172,11 @@ fn test_tree_root_nodes() { assert_eq!(HyperRegister::tree_root_nodes(0), vec![]); assert_eq!(HyperRegister::tree_root_nodes(1), vec![0]); assert_eq!(HyperRegister::tree_root_nodes(2), vec![1]); - assert_eq!(HyperRegister::tree_root_nodes(3), vec![1,4]); + assert_eq!(HyperRegister::tree_root_nodes(3), vec![1, 4]); assert_eq!(HyperRegister::tree_root_nodes(4), vec![3]); - assert_eq!(HyperRegister::tree_root_nodes(5), vec![3,8]); - assert_eq!(HyperRegister::tree_root_nodes(6), vec![3,9]); - assert_eq!(HyperRegister::tree_root_nodes(7), vec![3,9,12]); + assert_eq!(HyperRegister::tree_root_nodes(5), vec![3, 8]); + assert_eq!(HyperRegister::tree_root_nodes(6), vec![3, 9]); + assert_eq!(HyperRegister::tree_root_nodes(7), vec![3, 9, 12]); assert_eq!(HyperRegister::tree_root_nodes(8), vec![7]); } @@ -205,12 +200,12 @@ fn test_tree_parent_index() { fn test_tree_child_indices() { assert!(HyperRegister::tree_child_indices(0).is_err()); assert!(HyperRegister::tree_child_indices(1024).is_err()); - assert_eq!(HyperRegister::tree_child_indices(1).unwrap(), (0, 2)); + assert_eq!(HyperRegister::tree_child_indices(1).unwrap(), (0, 2)); - assert_eq!(HyperRegister::tree_child_indices(3).unwrap(), (1, 5)); - assert_eq!(HyperRegister::tree_child_indices(5).unwrap(), (4, 6)); - assert_eq!(HyperRegister::tree_child_indices(7).unwrap(), (3, 11)); - assert_eq!(HyperRegister::tree_child_indices(9).unwrap(), (8, 10)); + assert_eq!(HyperRegister::tree_child_indices(3).unwrap(), (1, 5)); + assert_eq!(HyperRegister::tree_child_indices(5).unwrap(), (4, 6)); + assert_eq!(HyperRegister::tree_child_indices(7).unwrap(), (3, 11)); + assert_eq!(HyperRegister::tree_child_indices(9).unwrap(), (8, 10)); assert_eq!(HyperRegister::tree_child_indices(11).unwrap(), (9, 13)); assert_eq!(HyperRegister::tree_child_indices(13).unwrap(), (12, 14)); assert_eq!(HyperRegister::tree_child_indices(15).unwrap(), (7, 23)); @@ -230,46 +225,49 @@ pub struct SleepDirRegister { } fn read_key_file(path: &Path, is_secret: bool) -> Result> { - let expected = if is_secret { 64 } else { 32 }; let mut key = vec![]; - let mut key_file = OpenOptions::new() - .read(true) - .write(false) - .open(path)?; + let mut key_file = OpenOptions::new().read(true).write(false).open(path)?; key_file.read_to_end(&mut key)?; if key.len() != expected { - bail!("Bad key file (len {} != {}): {:?}", key.len(), expected, path); + bail!( + "Bad key file (len {} != {}): {:?}", + key.len(), + expected, + path + ); } Ok(key) } fn write_key_file(path: &Path, key: &[u8], is_secret: bool) -> Result<()> { - let expected = if is_secret { 64 } else { 32 }; if key.len() != expected { - bail!("Bad key file (len {} != {}): {:?}", key.len(), expected, path); + bail!( + "Bad key file (len {} != {}): {:?}", + key.len(), + expected, + path + ); } - let mut key_file = OpenOptions::new() - .write(true) - .create_new(true) - .open(path)?; + let mut key_file = OpenOptions::new().write(true).create_new(true).open(path)?; key_file.write_all(&key)?; Ok(()) } impl SleepDirRegister { - pub fn open(directory: &Path, prefix: &str, writable: bool) -> Result { // read public key from disk let pub_key: Vec = read_key_file( &directory.join(Path::new(&(prefix.to_owned() + ".key"))), - false)?; + false, + )?; let mut secret_key = None; if writable { secret_key = Some(read_key_file( &directory.join(Path::new(&(prefix.to_owned() + ".secret_key"))), - true)?); + true, + )?); } let data_path = &(prefix.to_owned() + ".data"); let data_path = Path::new(data_path); @@ -282,11 +280,17 @@ impl SleepDirRegister { None }; let tree_sleep = SleepFile::open( - &directory.join(Path::new(&(prefix.to_owned() + ".tree"))), writable)?; + &directory.join(Path::new(&(prefix.to_owned() + ".tree"))), + writable, + )?; let sign_sleep = SleepFile::open( - &directory.join(Path::new(&(prefix.to_owned() + ".signatures"))), writable)?; + &directory.join(Path::new(&(prefix.to_owned() + ".signatures"))), + writable, + )?; let bitfield_sleep = SleepFile::open( - &directory.join(Path::new(&(prefix.to_owned() + ".bitfield"))), writable)?; + &directory.join(Path::new(&(prefix.to_owned() + ".bitfield"))), + writable, + )?; let mut sf = SleepDirRegister { tree_sleep, sign_sleep, @@ -308,11 +312,13 @@ impl SleepDirRegister { write_key_file( &directory.join(Path::new(&(prefix.to_owned() + ".key"))), &pub_key, - false)?; + false, + )?; write_key_file( &directory.join(Path::new(&(prefix.to_owned() + ".secret_key"))), &secret_key, - true)?; + true, + )?; let data_file = OpenOptions::new() .read(true) .write(true) @@ -322,17 +328,20 @@ impl SleepDirRegister { &directory.join(Path::new(&(prefix.to_owned() + ".tree"))), 0x05025702, 40, - Some("BLAKE2b".to_string()))?; + Some("BLAKE2b".to_string()), + )?; let sign_sleep = SleepFile::create( &directory.join(Path::new(&(prefix.to_owned() + ".signatures"))), 0x05025701, 64, - Some("Ed25519".to_string()))?; + Some("Ed25519".to_string()), + )?; let bitfield_sleep = SleepFile::create( &directory.join(Path::new(&(prefix.to_owned() + ".bitfield"))), 0x05025700, 3328, - None)?; + None, + )?; let mut sf = SleepDirRegister { tree_sleep, sign_sleep, @@ -347,7 +356,6 @@ impl SleepDirRegister { } impl HyperRegister for SleepDirRegister { - /// TODO: this version only works for "dense" registers: it just checks if the index is in the /// total length, instead of using the bitfield. fn has(&self, index: u64) -> Result { @@ -370,7 +378,6 @@ impl HyperRegister for SleepDirRegister { } fn get_data_entry(&mut self, index: u64) -> Result> { - // Get metadata about chunk (offset and length) let offset = HyperRegister::get_data_offset(self, index)?; @@ -384,7 +391,7 @@ impl HyperRegister for SleepDirRegister { } else { bail!("No data file in this register"); }; - let leaf = self.tree_sleep.read(index*2)?; + let leaf = self.tree_sleep.read(index * 2)?; let data_len = u64::from_be(FixedInt::decode_fixed(&leaf[32..40])); // avoid foot-gun in development: cap at ~1 billion bytes assert!(data_len < 2u64.pow(29)); @@ -403,7 +410,6 @@ impl HyperRegister for SleepDirRegister { } fn append(&mut self, data: &[u8]) -> Result { - if !self.data_file.is_some() { bail!("No data file in this register"); }; @@ -420,22 +426,21 @@ impl HyperRegister for SleepDirRegister { } // 3. Add hash to tree file, update merkel tree - self.tree_sleep.write(index*2, &leaf_hash)?; - let mut parent = HyperRegister::tree_parent_index(index*2); - while parent < index*2 { + self.tree_sleep.write(index * 2, &leaf_hash)?; + let mut parent = HyperRegister::tree_parent_index(index * 2); + while parent < index * 2 { let (left, right) = HyperRegister::tree_child_indices(parent)?; - let (left, right) = (self.tree_sleep.read(left)?, - self.tree_sleep.read(right)?); + let (left, right) = (self.tree_sleep.read(left)?, self.tree_sleep.read(right)?); let parent_hash = HyperRegister::hash_parent(&left[0..40], &right[0..40]); self.tree_sleep.write(parent, &parent_hash[0..40])?; parent = HyperRegister::tree_parent_index(parent); } - + // 4. Add signature to signature file - let root_hash = HyperRegister::hash_roots(self, index+1)?; + let root_hash = HyperRegister::hash_roots(self, index + 1)?; let root_sig = ed25519::signature(&root_hash, &self.secret_key.clone().unwrap()); self.sign_sleep.append(&root_sig)?; - + // 5. Update bitfile Ok(index) } @@ -457,7 +462,7 @@ impl HyperRegister for SleepDirRegister { // log(N) would go up previous parent nodes (eg, use tree_root_nodes()) let mut sum: u64 = 0; for i in 0..self.len()? { - let leaf = self.get_tree_entry(i*2)?; + let leaf = self.get_tree_entry(i * 2)?; sum += u64::from_be(FixedInt::decode_fixed(&leaf[32..40])); } Ok(sum) @@ -471,7 +476,7 @@ impl HyperRegister for SleepDirRegister { let sign_len = self.sign_sleep.len()?; let tree_len = self.tree_sleep.len()?; if (tree_len == 0) && (sign_len == 0) { - return Ok(()) + return Ok(()); } if tree_len != (sign_len * 2) - 1 { bail!("Inconsistent SLEEP signature/tree file sizes"); @@ -488,22 +493,21 @@ impl HyperRegister for SleepDirRegister { /// Checks if we have the secret key (such that we can append to this register) fn writable(&self) -> bool { - return self.secret_key.is_some() + return self.secret_key.is_some(); } } #[test] fn test_sdr_open() { - - let mut sdr = SleepDirRegister::open( - Path::new("test-data/dat/simple/.dat/"), "metadata", false).unwrap(); + let mut sdr = + SleepDirRegister::open(Path::new("test-data/dat/simple/.dat/"), "metadata", false).unwrap(); // Values from 'dat log' assert_eq!(sdr.len().unwrap(), 3); assert_eq!(sdr.len_bytes().unwrap(), 145); - let mut sdr = SleepDirRegister::open( - Path::new("test-data/dat/simple/.dat/"), "content", false).unwrap(); + let mut sdr = + SleepDirRegister::open(Path::new("test-data/dat/simple/.dat/"), "content", false).unwrap(); // Values from 'dat log' assert_eq!(sdr.len().unwrap(), 2); @@ -512,7 +516,6 @@ fn test_sdr_open() { #[test] fn test_sdr_create() { - use tempdir::TempDir; let tmp_dir = TempDir::new("geniza-test").unwrap(); let mut sdr = SleepDirRegister::create(tmp_dir.path(), "dummy").unwrap(); @@ -523,7 +526,6 @@ fn test_sdr_create() { #[test] fn test_sdr_append() { - use tempdir::TempDir; let tmp_dir = TempDir::new("geniza-test").unwrap(); let mut sdr = SleepDirRegister::create(tmp_dir.path(), "dummy").unwrap(); @@ -532,18 +534,17 @@ fn test_sdr_append() { sdr.check().unwrap(); assert_eq!(sdr.len().unwrap(), 1); assert_eq!(sdr.len_bytes().unwrap(), 12); - let count = 100; // TODO: make this >1000 when things are faster + let count = 100; // TODO: make this >1000 when things are faster for _ in 0..count { - sdr.append(&[1,2,3,4,5]).unwrap(); + sdr.append(&[1, 2, 3, 4, 5]).unwrap(); } sdr.check().unwrap(); - assert_eq!(sdr.len().unwrap(), 1+count); - assert_eq!(sdr.len_bytes().unwrap(), 12 + (count*5)); + assert_eq!(sdr.len().unwrap(), 1 + count); + assert_eq!(sdr.len_bytes().unwrap(), 12 + (count * 5)); } #[test] fn test_sdr_has() { - use tempdir::TempDir; let tmp_dir = TempDir::new("geniza-test").unwrap(); let mut sdr = SleepDirRegister::create(tmp_dir.path(), "dummy").unwrap(); -- cgit v1.2.3