gaspersic/solana
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Delete event.rs

Browse Source
This commit is contained in:
Greg Fitzgerald
2018-05-24 00:29:01 -06:00
parent b43ae748c3
commit 4cdf873f98
15 changed files with 59 additions and 140 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
src/bank.rs
View File

@ -7,7 +7,6 @@ extern crate libc;
use chrono::prelude::*;
use entry::Entry;
use event::Event;
use hash::Hash;
use mint::Mint;
use plan::{Payment, Plan, Witness};
@ -259,34 +258,10 @@ impl Bank {
.collect()
}
fn partition_events(events: Vec<Event>) -> (Vec<Transaction>, Vec<Event>) {
(
events
.into_iter()
.map(|Event::Transaction(tr)| tr)
.collect(),
vec![],
)
}
pub fn process_verified_events(&self, events: Vec<Event>) -> Vec<Result<Event>> {
let (trs, rest) = Self::partition_events(events);
let mut results: Vec<_> = self.process_verified_transactions(trs)
.into_iter()
.map(|x| x.map(Event::Transaction))
.collect();
for event in rest {
results.push(self.process_verified_event(event));
}
results
}
pub fn process_verified_entries(&self, entries: Vec<Entry>) -> Result<()> {
for entry in entries {
self.register_entry_id(&entry.id);
for result in self.process_verified_events(entry.events) {
for result in self.process_verified_transactions(entry.events) {
result?;
}
}
@ -362,14 +337,6 @@ impl Bank {
Ok(())
}
/// Process an Transaction or Witness that has already been verified.
pub fn process_verified_event(&self, event: Event) -> Result<Event> {
match event {
Event::Transaction(ref tr) => self.process_verified_transaction(tr),
}?;
Ok(event)
}
/// Create, sign, and process a Transaction from `keypair` to `to` of
/// `n` tokens where `last_id` is the last Entry ID observed by the client.
pub fn transfer(

32
src/banking_stage.rs
View File

@ -1,8 +1,7 @@
//! The `banking_stage` processes Event messages.
//! The `banking_stage` processes Transaction messages.
use bank::Bank;
use bincode::deserialize;
use event::Event;
use packet;
use packet::SharedPackets;
use rayon::prelude::*;
@ -16,6 +15,7 @@ use std::thread::{spawn, JoinHandle};
use std::time::Duration;
use std::time::Instant;
use timing;
use transaction::Transaction;
pub struct BankingStage {
pub thread_hdl: JoinHandle<()>,
@ -49,7 +49,7 @@ impl BankingStage {
}
}
fn deserialize_events(p: &packet::Packets) -> Vec<Option<(Event, SocketAddr)>> {
fn deserialize_events(p: &packet::Packets) -> Vec<Option<(Transaction, SocketAddr)>> {
p.packets
.par_iter()
.map(|x| {
@ -86,7 +86,7 @@ impl BankingStage {
.zip(vers)
.filter_map(|(event, ver)| match event {
None => None,
Some((event, _addr)) => if event.verify() && ver != 0 {
Some((event, _addr)) => if event.verify_plan() && ver != 0 {
Some(event)
} else {
None
@ -95,7 +95,7 @@ impl BankingStage {
.collect();
debug!("process_events");
let results = bank.process_verified_events(events);
let results = bank.process_verified_transactions(events);
let events = results.into_iter().filter_map(|x| x.ok()).collect();
signal_sender.send(Signal::Events(events))?;
debug!("done process_events");
@ -120,7 +120,6 @@ impl BankingStage {
//use bank::Bank;
//use entry::Entry;
//use event::Event;
//use hash::Hash;
//use record_stage::RecordStage;
//use record_stage::Signal;
@ -128,11 +127,11 @@ impl BankingStage {
//use std::sync::mpsc::{channel, Sender};
//use std::sync::{Arc, Mutex};
//use std::time::Duration;
//use transaction::Transaction;
//
//#[cfg(test)]
//mod tests {
// use bank::Bank;
// use event::Event;
// use event_processor::EventProcessor;
// use mint::Mint;
// use signature::{KeyPair, KeyPairUtil};
@ -152,12 +151,12 @@ impl BankingStage {
// // Process a batch that includes a transaction that receives two tokens.
// let alice = KeyPair::new();
// let tr = Transaction::new(&mint.keypair(), alice.pubkey(), 2, mint.last_id());
// let events = vec![Event::Transaction(tr)];
// let events = vec![tr];
// let entry0 = event_processor.process_events(events).unwrap();
//
// // Process a second batch that spends one of those tokens.
// let tr = Transaction::new(&alice, mint.pubkey(), 1, mint.last_id());
// let events = vec![Event::Transaction(tr)];
// let events = vec![tr];
// let entry1 = event_processor.process_events(events).unwrap();
//
// // Collect the ledger and feed it to a new bank.
@ -170,7 +169,7 @@ impl BankingStage {
// for entry in entries {
// assert!(
// bank
// .process_verified_events(entry.events)
// .process_verified_transactions(entry.events)
// .into_iter()
// .all(|x| x.is_ok())
// );
@ -229,15 +228,10 @@ impl BankingStage {
// })
// .collect();
//
// let events: Vec<_> = transactions
// .into_iter()
// .map(|tr| Event::Transaction(tr))
// .collect();
//
// let event_processor = EventProcessor::new(bank, &mint.last_id(), None);
//
// let now = Instant::now();
// assert!(event_processor.process_events(events).is_ok());
// assert!(event_processor.process_events(transactions).is_ok());
// let duration = now.elapsed();
// let sec = duration.as_secs() as f64 + duration.subsec_nanos() as f64 / 1_000_000_000.0;
// let tps = txs as f64 / sec;
@ -246,7 +240,7 @@ impl BankingStage {
// drop(event_processor.historian_input);
// let entries: Vec<Entry> = event_processor.output.lock().unwrap().iter().collect();
// assert_eq!(entries.len(), 1);
// assert_eq!(entries[0].events.len(), txs as usize);
// assert_eq!(entries[0].transactions.len(), txs as usize);
//
// println!("{} tps", tps);
// }
@ -258,7 +252,6 @@ mod bench {
use self::test::Bencher;
use bank::*;
use banking_stage::BankingStage;
use event::Event;
use mint::Mint;
use packet::{to_packets, PacketRecycler};
use record_stage::Signal;
@ -266,6 +259,7 @@ mod bench {
use std::iter;
use std::sync::Arc;
use std::sync::mpsc::channel;
use transaction::Transaction;
#[bench]
fn stage_bench(bencher: &mut Bencher) {
@ -274,7 +268,7 @@ mod bench {
let pubkey = KeyPair::new().pubkey();
let events: Vec<_> = (0..tx)
.map(|i| Event::new_transaction(&mint.keypair(), pubkey, i as i64, mint.last_id()))
.map(|i| Transaction::new(&mint.keypair(), pubkey, i as i64, mint.last_id()))
.collect();
let (verified_sender, verified_receiver) = channel();

4
src/bin/genesis-demo.rs
View File

@ -7,9 +7,9 @@ use isatty::stdin_isatty;
use rayon::prelude::*;
use solana::bank::MAX_ENTRY_IDS;
use solana::entry::{next_entry, Entry};
use solana::event::Event;
use solana::mint::MintDemo;
use solana::signature::{GenKeys, KeyPairUtil};
use solana::transaction::Transaction;
use std::io::{stdin, Read};
use std::process::exit;
@ -46,7 +46,7 @@ fn main() {
.into_par_iter()
.map(|rando| {
let last_id = demo.mint.last_id();
Event::new_transaction(&mint_keypair, rando.pubkey(), tokens_per_user, last_id)
Transaction::new(&mint_keypair, rando.pubkey(), tokens_per_user, last_id)
})
.collect();

5
src/bin/testnode.rs
View File

@ -11,7 +11,6 @@ use pnet::datalink;
use solana::bank::Bank;
use solana::crdt::ReplicatedData;
use solana::entry::Entry;
use solana::event::Event;
use solana::server::Server;
use solana::signature::{KeyPair, KeyPairUtil};
use solana::transaction::Instruction;
@ -97,7 +96,7 @@ fn main() {
// fields are the same. That entry should be treated as a deposit, not a
// transfer to oneself.
let entry1: Entry = entries.next().unwrap();
let Event::Transaction(ref tr) = entry1.events[0];
let tr = &entry1.events[0];
let deposit = if let Instruction::NewContract(contract) = &tr.instruction {
contract.plan.final_payment()
} else {
@ -115,7 +114,7 @@ fn main() {
let mut last_id = entry1.id;
for entry in entries {
last_id = entry.id;
let results = bank.process_verified_events(entry.events);
let results = bank.process_verified_transactions(entry.events);
for result in results {
if let Err(e) = result {
eprintln!("failed to process event {:?}", e);

7
src/ecdsa.rs
View File

@ -2,7 +2,7 @@ use packet::{Packet, SharedPackets};
use std::mem::size_of;
use transaction::{PUB_KEY_OFFSET, SIGNED_DATA_OFFSET, SIG_OFFSET};
pub const TX_OFFSET: usize = 4;
pub const TX_OFFSET: usize = 0;
#[cfg(feature = "cuda")]
#[repr(C)]
@ -144,7 +144,6 @@ pub fn ed25519_verify(batches: &Vec<SharedPackets>) -> Vec<Vec<u8>> {
mod tests {
use bincode::serialize;
use ecdsa;
use event::Event;
use packet::{Packet, Packets, SharedPackets};
use std::sync::RwLock;
use transaction::Transaction;
@ -154,13 +153,13 @@ mod tests {
fn test_layout() {
let tr = test_tx();
let tx = serialize(&tr).unwrap();
let packet = serialize(&Event::Transaction(tr)).unwrap();
let packet = serialize(&tr).unwrap();
assert_matches!(memfind(&packet, &tx), Some(ecdsa::TX_OFFSET));
assert_matches!(memfind(&packet, &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), None);
}
fn make_packet_from_transaction(tr: Transaction) -> Packet {
let tx = serialize(&Event::Transaction(tr)).unwrap();
let tx = serialize(&tr).unwrap();
let mut packet = Packet::default();
packet.meta.size = tx.len();
packet.data[..packet.meta.size].copy_from_slice(&tx);

37
src/entry.rs
View File

@ -2,9 +2,9 @@
//! unique ID that is the hash of the Entry before it, plus the hash of the
//! transactions within it. Entries cannot be reordered, and its field `num_hashes`
//! represents an approximate amount of time since the last Entry was created.
use event::Event;
use hash::{extend_and_hash, hash, Hash};
use rayon::prelude::*;
use transaction::Transaction;
/// Each Entry contains three pieces of data. The `num_hashes` field is the number
/// of hashes performed since the previous entry. The `id` field is the result
@ -21,12 +21,12 @@ use rayon::prelude::*;
pub struct Entry {
pub num_hashes: u64,
pub id: Hash,
pub events: Vec<Event>,
pub events: Vec<Transaction>,
}
impl Entry {
/// Creates the next Entry `num_hashes` after `start_hash`.
pub fn new(start_hash: &Hash, cur_hashes: u64, events: Vec<Event>) -> Self {
pub fn new(start_hash: &Hash, cur_hashes: u64, events: Vec<Transaction>) -> Self {
let num_hashes = cur_hashes + if events.is_empty() { 0 } else { 1 };
let id = next_hash(start_hash, 0, &events);
Entry {
@ -37,7 +37,7 @@ impl Entry {
}
/// Creates the next Tick Entry `num_hashes` after `start_hash`.
pub fn new_mut(start_hash: &mut Hash, cur_hashes: &mut u64, events: Vec<Event>) -> Self {
pub fn new_mut(start_hash: &mut Hash, cur_hashes: &mut u64, events: Vec<Transaction>) -> Self {
let entry = Self::new(start_hash, *cur_hashes, events);
*start_hash = entry.id;
*cur_hashes = 0;
@ -57,24 +57,20 @@ impl Entry {
/// Verifies self.id is the result of hashing a `start_hash` `self.num_hashes` times.
/// If the event is not a Tick, then hash that as well.
pub fn verify(&self, start_hash: &Hash) -> bool {
self.events.par_iter().all(|event| event.verify())
self.events.par_iter().all(|event| event.verify_plan())
&& self.id == next_hash(start_hash, self.num_hashes, &self.events)
}
}
fn add_event_data(hash_data: &mut Vec<u8>, event: &Event) {
match *event {
Event::Transaction(ref tr) => {
hash_data.push(0u8);
hash_data.extend_from_slice(&tr.sig);
}
}
fn add_event_data(hash_data: &mut Vec<u8>, tr: &Transaction) {
hash_data.push(0u8);
hash_data.extend_from_slice(&tr.sig);
}
/// Creates the hash `num_hashes` after `start_hash`. If the event contains
/// a signature, the final hash will be a hash of both the previous ID and
/// the signature.
pub fn next_hash(start_hash: &Hash, num_hashes: u64, events: &[Event]) -> Hash {
pub fn next_hash(start_hash: &Hash, num_hashes: u64, events: &[Transaction]) -> Hash {
let mut id = *start_hash;
for _ in 1..num_hashes {
id = hash(&id);
@ -96,7 +92,7 @@ pub fn next_hash(start_hash: &Hash, num_hashes: u64, events: &[Event]) -> Hash {
}
/// Creates the next Tick or Event Entry `num_hashes` after `start_hash`.
pub fn next_entry(start_hash: &Hash, num_hashes: u64, events: Vec<Event>) -> Entry {
pub fn next_entry(start_hash: &Hash, num_hashes: u64, events: Vec<Transaction>) -> Entry {
Entry {
num_hashes,
id: next_hash(start_hash, num_hashes, &events),
@ -109,7 +105,6 @@ mod tests {
use super::*;
use chrono::prelude::*;
use entry::Entry;
use event::Event;
use hash::hash;
use signature::{KeyPair, KeyPairUtil};
use transaction::Transaction;
@ -130,8 +125,8 @@ mod tests {
// First, verify entries
let keypair = KeyPair::new();
let tr0 = Event::new_transaction(&keypair, keypair.pubkey(), 0, zero);
let tr1 = Event::new_transaction(&keypair, keypair.pubkey(), 1, zero);
let tr0 = Transaction::new(&keypair, keypair.pubkey(), 0, zero);
let tr1 = Transaction::new(&keypair, keypair.pubkey(), 1, zero);
let mut e0 = Entry::new(&zero, 0, vec![tr0.clone(), tr1.clone()]);
assert!(e0.verify(&zero));
@ -147,12 +142,8 @@ mod tests {
// First, verify entries
let keypair = KeyPair::new();
let tr0 = Event::Transaction(Transaction::new_timestamp(&keypair, Utc::now(), zero));
let tr1 = Event::Transaction(Transaction::new_signature(
&keypair,
Default::default(),
zero,
));
let tr0 = Transaction::new_timestamp(&keypair, Utc::now(), zero);
let tr1 = Transaction::new_signature(&keypair, Default::default(), zero);
let mut e0 = Entry::new(&zero, 0, vec![tr0.clone(), tr1.clone()]);
assert!(e0.verify(&zero));

31
src/event.rs
View File

@ -1,31 +0,0 @@
//! The `event` module handles events, which may be a `Transaction`, or a `Witness` used to process a pending
//! Transaction.
use hash::Hash;
use signature::{KeyPair, PublicKey};
use transaction::Transaction;
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
pub enum Event {
Transaction(Transaction),
}
impl Event {
pub fn new_transaction(
from_keypair: &KeyPair,
to: PublicKey,
tokens: i64,
last_id: Hash,
) -> Self {
let tr = Transaction::new(from_keypair, to, tokens, last_id);
Event::Transaction(tr)
}
/// Verify the Event's signature's are valid and if a transaction, that its
/// spending plan is valid.
pub fn verify(&self) -> bool {
match *self {
Event::Transaction(ref tr) => tr.verify_plan(),
}
}
}

16
src/ledger.rs
View File

@ -3,7 +3,6 @@
use bincode::{deserialize, serialize_into};
use entry::{next_entry, Entry};
use event::Event;
use hash::Hash;
use packet;
use packet::{SharedBlob, BLOB_DATA_SIZE, BLOB_SIZE};
@ -12,6 +11,7 @@ use std::cmp::min;
use std::collections::VecDeque;
use std::io::Cursor;
use std::mem::size_of;
use transaction::Transaction;
pub trait Block {
/// Verifies the hashes and counts of a slice of events are all consistent.
@ -27,7 +27,11 @@ impl Block for [Entry] {
}
/// Create a vector of Entries of length `event_set.len()` from `start_hash` hash, `num_hashes`, and `event_set`.
pub fn next_entries(start_hash: &Hash, num_hashes: u64, event_set: Vec<Vec<Event>>) -> Vec<Entry> {
pub fn next_entries(
start_hash: &Hash,
num_hashes: u64,
event_set: Vec<Vec<Transaction>>,
) -> Vec<Entry> {
let mut id = *start_hash;
let mut entries = vec![];
for event_list in &event_set {
@ -50,7 +54,7 @@ pub fn process_entry_list_into_blobs(
let mut entries: Vec<Vec<Entry>> = Vec::new();
let mut total = 0;
for i in &list[start..] {
total += size_of::<Event>() * i.events.len();
total += size_of::<Transaction>() * i.events.len();
total += size_of::<Entry>();
if total >= BLOB_DATA_SIZE {
break;
@ -60,7 +64,7 @@ pub fn process_entry_list_into_blobs(
// See if we need to split the events
if end <= start {
let mut event_start = 0;
let num_events_per_blob = BLOB_DATA_SIZE / size_of::<Event>();
let num_events_per_blob = BLOB_DATA_SIZE / size_of::<Transaction>();
let total_entry_chunks =
(list[end].events.len() + num_events_per_blob - 1) / num_events_per_blob;
trace!(
@ -147,7 +151,7 @@ mod tests {
let zero = Hash::default();
let one = hash(&zero);
let keypair = KeyPair::new();
let tr0 = Event::Transaction(Transaction::new(&keypair, keypair.pubkey(), 1, one));
let tr0 = Transaction::new(&keypair, keypair.pubkey(), 1, one);
let events = vec![tr0.clone(); 10000];
let e0 = Entry::new(&zero, 0, events);
@ -165,7 +169,7 @@ mod tests {
let mut id = Hash::default();
let next_id = hash(&id);
let keypair = KeyPair::new();
let tr0 = Event::Transaction(Transaction::new(&keypair, keypair.pubkey(), 1, next_id));
let tr0 = Transaction::new(&keypair, keypair.pubkey(), 1, next_id);
let events = vec![tr0.clone(); 5];
let event_set = vec![events.clone(); 5];
let entries0 = next_entries(&id, 0, event_set);

1
src/lib.rs
View File

@ -7,7 +7,6 @@ pub mod entry;
pub mod entry_writer;
#[cfg(feature = "erasure")]
pub mod erasure;
pub mod event;
pub mod hash;
pub mod ledger;
pub mod logger;

7
src/mint.rs
View File

@ -1,7 +1,6 @@
//! The `mint` module is a library for generating the chain's genesis block.
use entry::Entry;
use event::Event;
use hash::{hash, Hash};
use ring::rand::SystemRandom;
use signature::{KeyPair, KeyPairUtil, PublicKey};
@ -47,10 +46,10 @@ impl Mint {
self.pubkey
}
pub fn create_events(&self) -> Vec<Event> {
pub fn create_events(&self) -> Vec<Transaction> {
let keypair = self.keypair();
let tr = Transaction::new(&keypair, self.pubkey(), self.tokens, self.seed());
vec![Event::Transaction(tr)]
vec![tr]
}
pub fn create_entries(&self) -> Vec<Entry> {
@ -76,7 +75,7 @@ mod tests {
#[test]
fn test_create_events() {
let mut events = Mint::new(100).create_events().into_iter();
let Event::Transaction(tr) = events.next().unwrap();
let tr = events.next().unwrap();
if let Instruction::NewContract(contract) = tr.instruction {
if let Plan::Pay(payment) = contract.plan {
assert_eq!(tr.from, payment.to);

8
src/record_stage.rs
View File

@ -6,17 +6,17 @@
//! The resulting stream of entries represents ordered events in time.
use entry::Entry;
use event::Event;
use hash::Hash;
use recorder::Recorder;
use std::sync::mpsc::{channel, Receiver, Sender, TryRecvError};
use std::thread::{spawn, JoinHandle};
use std::time::{Duration, Instant};
use transaction::Transaction;
#[cfg_attr(feature = "cargo-clippy", allow(large_enum_variant))]
pub enum Signal {
Tick,
Events(Vec<Event>),
Events(Vec<Transaction>),
}
pub struct RecordStage {
@ -140,8 +140,8 @@ mod tests {
let record_stage = RecordStage::new(signal_receiver, &zero, None);
let alice_keypair = KeyPair::new();
let bob_pubkey = KeyPair::new().pubkey();
let event0 = Event::new_transaction(&alice_keypair, bob_pubkey, 1, zero);
let event1 = Event::new_transaction(&alice_keypair, bob_pubkey, 2, zero);
let event0 = Transaction::new(&alice_keypair, bob_pubkey, 1, zero);
let event1 = Transaction::new(&alice_keypair, bob_pubkey, 2, zero);
input.send(Signal::Events(vec![event0, event1])).unwrap();
drop(input);
let entries: Vec<_> = record_stage.entry_receiver.iter().collect();

4
src/recorder.rs
View File

@ -2,9 +2,9 @@
//! It records Event items on behalf of its users.
use entry::Entry;
use event::Event;
use hash::{hash, Hash};
use std::time::{Duration, Instant};
use transaction::Transaction;
pub struct Recorder {
last_hash: Hash,
@ -26,7 +26,7 @@ impl Recorder {
self.num_hashes += 1;
}
pub fn record(&mut self, events: Vec<Event>) -> Entry {
pub fn record(&mut self, events: Vec<Transaction>) -> Entry {
Entry::new_mut(&mut self.last_hash, &mut self.num_hashes, events)
}

4
src/request_processor.rs
View File

@ -2,7 +2,6 @@
use bank::Bank;
use bincode::{deserialize, serialize};
use event::Event;
use packet;
use packet::SharedPackets;
use rayon::prelude::*;
@ -15,6 +14,7 @@ use std::sync::mpsc::Receiver;
use std::time::Instant;
use streamer;
use timing;
use transaction::Transaction;
pub struct RequestProcessor {
bank: Arc<Bank>,
@ -76,7 +76,7 @@ impl RequestProcessor {
// Copy-paste of deserialize_requests() because I can't figure out how to
// route the lifetimes in a generic version.
pub fn deserialize_events(p: &packet::Packets) -> Vec<Option<(Event, SocketAddr)>> {
pub fn deserialize_events(p: &packet::Packets) -> Vec<Option<(Transaction, SocketAddr)>> {
p.packets
.par_iter()
.map(|x| {

4
src/thin_client.rs
View File

@ -4,7 +4,6 @@
//! unstable and may change in future releases.
use bincode::{deserialize, serialize};
use event::Event;
use futures::future::{ok, FutureResult};
use hash::Hash;
use request::{Request, Response};
@ -75,8 +74,7 @@ impl ThinClient {
/// Send a signed Transaction to the server for processing. This method
/// does not wait for a response.
pub fn transfer_signed(&self, tr: Transaction) -> io::Result<usize> {
let event = Event::Transaction(tr);
let data = serialize(&event).expect("serialize Transaction in pub fn transfer_signed");
let data = serialize(&tr).expect("serialize Transaction in pub fn transfer_signed");
self.events_socket.send_to(&data, &self.events_addr)
}

4
src/tvu.rs
View File

@ -157,7 +157,6 @@ pub mod tests {
use crdt::Crdt;
use crdt::ReplicatedData;
use entry::Entry;
use event::Event;
use hash::{hash, Hash};
use logger;
use mint::Mint;
@ -170,6 +169,7 @@ pub mod tests {
use std::sync::{Arc, RwLock};
use std::time::Duration;
use streamer;
use transaction::Transaction;
use tvu::Tvu;
/// Test that mesasge sent from leader to target1 and repliated to target2
@ -252,7 +252,7 @@ pub mod tests {
bank.register_entry_id(&cur_hash);
cur_hash = hash(&cur_hash);
let tr1 = Event::new_transaction(
let tr1 = Transaction::new(
&mint.keypair(),
bob_keypair.pubkey(),
transfer_amount,