2018-06-06 10:24:24 -07:00
|
|
|
//! The `entry_writer` module helps implement the TPU's write stage. It
|
|
|
|
//! writes entries to the given writer, which is typically a file or
|
|
|
|
//! stdout, and then sends the Entry to its output channel.
|
2018-05-11 21:36:16 -07:00
|
|
|
|
2018-05-14 14:33:11 -07:00
|
|
|
use bank::Bank;
|
2018-07-28 10:45:10 -07:00
|
|
|
use bincode;
|
2018-05-11 21:36:16 -07:00
|
|
|
use entry::Entry;
|
2018-07-28 10:45:10 -07:00
|
|
|
use std::io::{self, BufRead, Error, ErrorKind, Write};
|
2018-07-30 16:43:48 -07:00
|
|
|
use std::mem::size_of;
|
2018-05-11 21:36:16 -07:00
|
|
|
|
2018-07-01 13:25:21 -07:00
|
|
|
pub struct EntryWriter<'a, W> {
|
2018-05-14 14:33:11 -07:00
|
|
|
bank: &'a Bank,
|
2018-07-01 13:31:13 -07:00
|
|
|
writer: W,
|
2018-05-11 21:36:16 -07:00
|
|
|
}
|
|
|
|
|
2018-07-01 13:25:21 -07:00
|
|
|
impl<'a, W: Write> EntryWriter<'a, W> {
|
2018-05-14 14:33:11 -07:00
|
|
|
/// Create a new Tpu that wraps the given Bank.
|
2018-07-01 13:31:13 -07:00
|
|
|
pub fn new(bank: &'a Bank, writer: W) -> Self {
|
2018-07-01 13:25:21 -07:00
|
|
|
EntryWriter { bank, writer }
|
2018-05-11 21:36:16 -07:00
|
|
|
}
|
|
|
|
|
2018-07-01 13:31:13 -07:00
|
|
|
fn write_entry(writer: &mut W, entry: &Entry) -> io::Result<()> {
|
2018-07-28 11:32:44 -07:00
|
|
|
let entry_bytes =
|
2018-07-28 10:45:10 -07:00
|
|
|
bincode::serialize(&entry).map_err(|e| Error::new(ErrorKind::Other, e.to_string()))?;
|
|
|
|
|
2018-07-28 11:32:44 -07:00
|
|
|
let len = entry_bytes.len();
|
2018-07-30 11:22:10 -07:00
|
|
|
let len_bytes =
|
|
|
|
bincode::serialize(&len).map_err(|e| Error::new(ErrorKind::Other, e.to_string()))?;
|
2018-07-28 10:45:10 -07:00
|
|
|
|
2018-07-30 11:22:10 -07:00
|
|
|
writer.write_all(&len_bytes[..])?;
|
2018-07-28 11:32:44 -07:00
|
|
|
writer.write_all(&entry_bytes[..])?;
|
2018-07-18 22:30:49 -07:00
|
|
|
writer.flush()
|
2018-07-01 08:34:56 -07:00
|
|
|
}
|
|
|
|
|
2018-07-02 00:04:19 -07:00
|
|
|
pub fn write_entries<I>(writer: &mut W, entries: I) -> io::Result<()>
|
|
|
|
where
|
|
|
|
I: IntoIterator<Item = Entry>,
|
|
|
|
{
|
2018-07-01 08:34:56 -07:00
|
|
|
for entry in entries {
|
2018-07-02 00:04:19 -07:00
|
|
|
Self::write_entry(writer, &entry)?;
|
2018-07-01 08:34:56 -07:00
|
|
|
}
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2018-07-01 13:31:13 -07:00
|
|
|
fn write_and_register_entry(&mut self, entry: &Entry) -> io::Result<()> {
|
2018-07-01 08:10:41 -07:00
|
|
|
trace!("write_and_register_entry entry");
|
2018-06-28 15:18:10 -07:00
|
|
|
if !entry.has_more {
|
|
|
|
self.bank.register_entry_id(&entry.id);
|
|
|
|
}
|
2018-07-01 13:31:13 -07:00
|
|
|
Self::write_entry(&mut self.writer, entry)
|
2018-05-11 21:36:16 -07:00
|
|
|
}
|
|
|
|
|
2018-07-01 13:31:13 -07:00
|
|
|
pub fn write_and_register_entries(&mut self, entries: &[Entry]) -> io::Result<()> {
|
2018-07-01 08:34:56 -07:00
|
|
|
for entry in entries {
|
2018-07-01 13:25:21 -07:00
|
|
|
self.write_and_register_entry(&entry)?;
|
2018-07-01 08:34:56 -07:00
|
|
|
}
|
|
|
|
Ok(())
|
|
|
|
}
|
2018-05-11 21:36:16 -07:00
|
|
|
}
|
2018-06-28 15:18:10 -07:00
|
|
|
|
2018-07-28 15:53:17 -07:00
|
|
|
struct EntryReader<R: BufRead> {
|
|
|
|
reader: R,
|
|
|
|
entry_bytes: Vec<u8>,
|
|
|
|
}
|
|
|
|
|
2018-07-30 10:22:35 -07:00
|
|
|
impl<R: BufRead> Iterator for EntryReader<R> {
|
2018-07-28 15:53:17 -07:00
|
|
|
type Item = io::Result<Entry>;
|
|
|
|
|
|
|
|
fn next(&mut self) -> Option<io::Result<Entry>> {
|
2018-07-30 16:43:48 -07:00
|
|
|
let mut entry_len_bytes = [0u8; size_of::<usize>()];
|
2018-07-28 15:53:17 -07:00
|
|
|
|
2018-07-30 16:43:48 -07:00
|
|
|
if self.reader.read_exact(&mut entry_len_bytes[..]).is_ok() {
|
2018-07-30 11:22:10 -07:00
|
|
|
let entry_len = bincode::deserialize(&entry_len_bytes).unwrap();
|
2018-07-01 23:09:41 -07:00
|
|
|
|
2018-07-28 15:53:17 -07:00
|
|
|
if entry_len > self.entry_bytes.len() {
|
2018-07-30 10:22:35 -07:00
|
|
|
self.entry_bytes.resize(entry_len, 0);
|
2018-07-28 15:53:17 -07:00
|
|
|
}
|
2018-07-01 23:09:41 -07:00
|
|
|
|
2018-07-28 15:53:17 -07:00
|
|
|
if let Err(e) = self.reader.read_exact(&mut self.entry_bytes[..entry_len]) {
|
2018-07-30 11:22:10 -07:00
|
|
|
Some(Err(e))
|
2018-07-28 15:53:17 -07:00
|
|
|
} else {
|
|
|
|
Some(
|
|
|
|
bincode::deserialize(&self.entry_bytes)
|
|
|
|
.map_err(|e| Error::new(ErrorKind::Other, e.to_string())),
|
|
|
|
)
|
|
|
|
}
|
2018-07-30 11:22:10 -07:00
|
|
|
} else {
|
|
|
|
None // EOF (probably)
|
2018-07-28 15:53:17 -07:00
|
|
|
}
|
|
|
|
}
|
2018-07-03 15:47:37 -07:00
|
|
|
}
|
|
|
|
|
2018-07-28 10:45:10 -07:00
|
|
|
/// Return an iterator for all the entries in the given file.
|
|
|
|
pub fn read_entries<R: BufRead>(reader: R) -> impl Iterator<Item = io::Result<Entry>> {
|
2018-07-28 15:53:17 -07:00
|
|
|
EntryReader {
|
|
|
|
reader,
|
|
|
|
entry_bytes: Vec::new(),
|
2018-07-28 11:32:44 -07:00
|
|
|
}
|
2018-07-03 15:47:37 -07:00
|
|
|
}
|
|
|
|
|
2018-06-28 15:18:10 -07:00
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::*;
|
2018-09-07 20:18:36 -07:00
|
|
|
use bincode::serialize;
|
2018-06-28 15:18:10 -07:00
|
|
|
use ledger;
|
|
|
|
use mint::Mint;
|
|
|
|
use packet::BLOB_DATA_SIZE;
|
2018-09-07 20:18:36 -07:00
|
|
|
use packet::PACKET_DATA_SIZE;
|
2018-08-09 07:56:04 -07:00
|
|
|
use signature::{Keypair, KeypairUtil};
|
2018-07-28 10:45:10 -07:00
|
|
|
use std::io::Cursor;
|
2018-06-28 15:18:10 -07:00
|
|
|
use transaction::Transaction;
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_dont_register_partial_entries() {
|
|
|
|
let mint = Mint::new(1);
|
|
|
|
let bank = Bank::new(&mint);
|
|
|
|
|
2018-07-01 13:31:13 -07:00
|
|
|
let writer = io::sink();
|
|
|
|
let mut entry_writer = EntryWriter::new(&bank, writer);
|
2018-08-09 07:56:04 -07:00
|
|
|
let keypair = Keypair::new();
|
2018-06-28 15:18:10 -07:00
|
|
|
let tx = Transaction::new(&mint.keypair(), keypair.pubkey(), 1, mint.last_id());
|
2018-09-07 20:18:36 -07:00
|
|
|
let tx_size = serialize(&tx).unwrap().len();
|
2018-06-28 15:18:10 -07:00
|
|
|
|
2018-09-07 20:18:36 -07:00
|
|
|
assert!(tx_size <= PACKET_DATA_SIZE);
|
|
|
|
assert!(BLOB_DATA_SIZE >= PACKET_DATA_SIZE);
|
|
|
|
let threshold = (BLOB_DATA_SIZE / tx_size) - 1; // PACKET_DATA_SIZE is transaction size
|
2018-06-28 15:18:10 -07:00
|
|
|
|
|
|
|
// Verify large entries are split up and the first sets has_more.
|
|
|
|
let txs = vec![tx.clone(); threshold * 2];
|
|
|
|
let entries = ledger::next_entries(&mint.last_id(), 0, txs);
|
|
|
|
assert_eq!(entries.len(), 2);
|
|
|
|
assert!(entries[0].has_more);
|
|
|
|
assert!(!entries[1].has_more);
|
|
|
|
|
2018-07-01 08:10:41 -07:00
|
|
|
// Verify that write_and_register_entry doesn't register the first entries after a split.
|
2018-06-28 15:18:10 -07:00
|
|
|
assert_eq!(bank.last_id(), mint.last_id());
|
2018-07-01 13:25:21 -07:00
|
|
|
entry_writer.write_and_register_entry(&entries[0]).unwrap();
|
2018-06-28 15:18:10 -07:00
|
|
|
assert_eq!(bank.last_id(), mint.last_id());
|
|
|
|
|
2018-07-01 08:10:41 -07:00
|
|
|
// Verify that write_and_register_entry registers the final entry after a split.
|
2018-07-01 13:25:21 -07:00
|
|
|
entry_writer.write_and_register_entry(&entries[1]).unwrap();
|
2018-06-28 15:18:10 -07:00
|
|
|
assert_eq!(bank.last_id(), entries[1].id);
|
|
|
|
}
|
2018-07-03 15:47:37 -07:00
|
|
|
|
2018-07-28 10:45:10 -07:00
|
|
|
/// Same as read_entries() but parsing a buffer and returning a vector.
|
|
|
|
fn read_entries_from_buf(s: &[u8]) -> io::Result<Vec<Entry>> {
|
|
|
|
let mut result = vec![];
|
|
|
|
let reader = Cursor::new(s);
|
|
|
|
for x in read_entries(reader) {
|
|
|
|
trace!("entry... {:?}", x);
|
|
|
|
result.push(x?);
|
|
|
|
}
|
|
|
|
Ok(result)
|
|
|
|
}
|
|
|
|
|
2018-07-03 15:47:37 -07:00
|
|
|
#[test]
|
2018-07-28 10:45:10 -07:00
|
|
|
fn test_read_entries_from_buf() {
|
2018-07-30 11:22:10 -07:00
|
|
|
let mint = Mint::new(1);
|
2018-07-03 15:47:37 -07:00
|
|
|
let mut buf = vec![];
|
|
|
|
EntryWriter::write_entries(&mut buf, mint.create_entries()).unwrap();
|
2018-07-28 10:45:10 -07:00
|
|
|
let entries = read_entries_from_buf(&buf).unwrap();
|
2018-07-03 15:47:37 -07:00
|
|
|
assert_eq!(entries, mint.create_entries());
|
|
|
|
}
|
2018-06-28 15:18:10 -07:00
|
|
|
}
|