From 49281b24e53f9c1c1ca9faece045f4100df129f4 Mon Sep 17 00:00:00 2001 From: Greg Fitzgerald Date: Fri, 9 Mar 2018 17:22:14 -0700 Subject: [PATCH] Move Tick out of Event Every Entry is now a Tick and the entries contain events. --- src/accountant.rs | 7 +++++-- src/bin/historian-demo.rs | 7 ++++--- src/event.rs | 8 -------- src/historian.rs | 18 ++++++++---------- src/logger.rs | 18 ++++++++++++------ 5 files changed, 29 insertions(+), 29 deletions(-) diff --git a/src/accountant.rs b/src/accountant.rs index efb80f3499..3113cf9200 100644 --- a/src/accountant.rs +++ b/src/accountant.rs @@ -9,6 +9,7 @@ use transaction::{Condition, Transaction}; use signature::{KeyPair, PublicKey, Signature}; use mint::Mint; use historian::{reserve_signature, Historian}; +use logger::Signal; use std::sync::mpsc::SendError; use std::collections::{HashMap, HashSet}; use std::result; @@ -96,7 +97,10 @@ impl Accountant { } self.process_verified_transaction(&tr, false)?; - if let Err(SendError(_)) = self.historian.sender.send(Event::Transaction(tr)) { + if let Err(SendError(_)) = self.historian + .sender + .send(Signal::Event(Event::Transaction(tr))) + { return Err(AccountingError::SendError); } @@ -243,7 +247,6 @@ impl Accountant { fn process_verified_event(self: &mut Self, event: &Event, allow_deposits: bool) -> Result<()> { match *event { - Event::Tick => Ok(()), Event::Transaction(ref tr) => self.process_verified_transaction(tr, allow_deposits), Event::Signature { from, tx_sig, .. } => self.process_verified_sig(from, tx_sig), Event::Timestamp { from, dt, .. } => self.process_verified_timestamp(from, dt), diff --git a/src/bin/historian-demo.rs b/src/bin/historian-demo.rs index a421a1348f..1ac5ae2314 100644 --- a/src/bin/historian-demo.rs +++ b/src/bin/historian-demo.rs @@ -4,6 +4,7 @@ use silk::historian::Historian; use silk::hash::Hash; use silk::entry::Entry; use silk::log::verify_slice; +use silk::logger::Signal; use silk::signature::{KeyPair, KeyPairUtil}; use silk::transaction::Transaction; use silk::event::Event; @@ -11,12 +12,12 @@ use std::thread::sleep; use std::time::Duration; use std::sync::mpsc::SendError; -fn create_log(hist: &Historian, seed: &Hash) -> Result<(), SendError> { +fn create_log(hist: &Historian, seed: &Hash) -> Result<(), SendError> { sleep(Duration::from_millis(15)); let keypair = KeyPair::new(); let tr = Transaction::new(&keypair, keypair.pubkey(), 42, *seed); - let event0 = Event::Transaction(tr); - hist.sender.send(event0)?; + let signal0 = Signal::Event(Event::Transaction(tr)); + hist.sender.send(signal0)?; sleep(Duration::from_millis(10)); Ok(()) } diff --git a/src/event.rs b/src/event.rs index 0d6642b3f3..51a71fba90 100644 --- a/src/event.rs +++ b/src/event.rs @@ -5,14 +5,8 @@ use transaction::Transaction; use chrono::prelude::*; use bincode::serialize; -/// When 'event' is Tick, the event represents a simple clock tick, and exists for the -/// sole purpose of improving the performance of event log verification. A tick can -/// be generated in 'num_hashes' hashes and verified in 'num_hashes' hashes. By logging -/// a hash alongside the tick, each tick and be verified in parallel using the 'id' -/// of the preceding tick to seed its hashing. #[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)] pub enum Event { - Tick, Transaction(Transaction), Signature { from: PublicKey, @@ -40,7 +34,6 @@ impl Event { // TODO: Rename this to transaction_signature(). pub fn get_signature(&self) -> Option { match *self { - Event::Tick => None, Event::Transaction(ref tr) => Some(tr.sig), Event::Signature { .. } => None, Event::Timestamp { .. } => None, @@ -49,7 +42,6 @@ impl Event { pub fn verify(&self) -> bool { match *self { - Event::Tick => true, Event::Transaction(ref tr) => tr.verify(), Event::Signature { from, tx_sig, sig } => sig.verify(&from, &tx_sig), Event::Timestamp { from, dt, sig } => sig.verify(&from, &serialize(&dt).unwrap()), diff --git a/src/historian.rs b/src/historian.rs index 6b6e02e934..77e9f35a5b 100644 --- a/src/historian.rs +++ b/src/historian.rs @@ -7,12 +7,11 @@ use std::sync::mpsc::{sync_channel, Receiver, SyncSender}; use std::time::Instant; use hash::{hash, Hash}; use entry::Entry; -use logger::{ExitReason, Logger}; +use logger::{ExitReason, Logger, Signal}; use signature::Signature; -use event::Event; pub struct Historian { - pub sender: SyncSender, + pub sender: SyncSender, pub receiver: Receiver, pub thread_hdl: JoinHandle, pub signatures: HashSet, @@ -38,7 +37,7 @@ impl Historian { fn create_logger( start_hash: Hash, ms_per_tick: Option, - receiver: Receiver, + receiver: Receiver, sender: SyncSender, ) -> JoinHandle { spawn(move || { @@ -69,7 +68,6 @@ pub fn reserve_signature(sigs: &mut HashSet, sig: &Signature) -> bool mod tests { use super::*; use log::*; - use event::*; use std::thread::sleep; use std::time::Duration; @@ -78,11 +76,11 @@ mod tests { let zero = Hash::default(); let hist = Historian::new(&zero, None); - hist.sender.send(Event::Tick).unwrap(); + hist.sender.send(Signal::Tick).unwrap(); sleep(Duration::new(0, 1_000_000)); - hist.sender.send(Event::Tick).unwrap(); + hist.sender.send(Signal::Tick).unwrap(); sleep(Duration::new(0, 1_000_000)); - hist.sender.send(Event::Tick).unwrap(); + hist.sender.send(Signal::Tick).unwrap(); let entry0 = hist.receiver.recv().unwrap(); let entry1 = hist.receiver.recv().unwrap(); @@ -106,7 +104,7 @@ mod tests { let zero = Hash::default(); let hist = Historian::new(&zero, None); drop(hist.receiver); - hist.sender.send(Event::Tick).unwrap(); + hist.sender.send(Signal::Tick).unwrap(); assert_eq!( hist.thread_hdl.join().unwrap(), ExitReason::SendDisconnected @@ -126,7 +124,7 @@ mod tests { let zero = Hash::default(); let hist = Historian::new(&zero, Some(20)); sleep(Duration::from_millis(30)); - hist.sender.send(Event::Tick).unwrap(); + hist.sender.send(Signal::Tick).unwrap(); drop(hist.sender); let entries: Vec = hist.receiver.iter().collect(); diff --git a/src/logger.rs b/src/logger.rs index 6a90c340c8..89f4a8d08e 100644 --- a/src/logger.rs +++ b/src/logger.rs @@ -13,6 +13,11 @@ use entry::{create_entry_mut, Entry}; use event::Event; use serde_json; +pub enum Signal { + Tick, + Event(Event), +} + #[derive(Debug, PartialEq, Eq)] pub enum ExitReason { RecvDisconnected, @@ -21,7 +26,7 @@ pub enum ExitReason { pub struct Logger { pub sender: SyncSender, - pub receiver: Receiver, + pub receiver: Receiver, pub last_id: Hash, pub events: Vec, pub num_hashes: u64, @@ -29,7 +34,7 @@ pub struct Logger { } impl Logger { - pub fn new(receiver: Receiver, sender: SyncSender, start_hash: Hash) -> Self { + pub fn new(receiver: Receiver, sender: SyncSender, start_hash: Hash) -> Self { Logger { receiver, sender, @@ -61,16 +66,17 @@ impl Logger { } match self.receiver.try_recv() { - Ok(event) => { - if let Event::Tick = event { + Ok(signal) => match signal { + Signal::Tick => { let entry = self.log_entry()?; self.sender .send(entry) .or(Err(ExitReason::SendDisconnected))?; - } else { + } + Signal::Event(event) => { self.events.push(event); } - } + }, Err(TryRecvError::Empty) => return Ok(()), Err(TryRecvError::Disconnected) => return Err(ExitReason::RecvDisconnected), };