2018-02-28 09:07:54 -08:00
|
|
|
use accountant::Accountant;
|
2018-03-06 11:48:26 -08:00
|
|
|
use transaction::Transaction;
|
|
|
|
use signature::PublicKey;
|
2018-03-06 16:36:45 -08:00
|
|
|
use hash::Hash;
|
2018-03-06 16:31:17 -08:00
|
|
|
use entry::Entry;
|
2018-03-04 06:28:51 -08:00
|
|
|
use std::net::UdpSocket;
|
|
|
|
use bincode::{deserialize, serialize};
|
2018-03-10 20:09:17 -08:00
|
|
|
use result::Result;
|
|
|
|
use streamer;
|
|
|
|
use std::sync::{Arc, Mutex};
|
|
|
|
use std::time::Duration;
|
|
|
|
use std::sync::mpsc::channel;
|
|
|
|
use std::thread::{spawn, JoinHandle};
|
|
|
|
use std::default::Default;
|
2018-02-28 09:07:54 -08:00
|
|
|
|
|
|
|
pub struct AccountantSkel {
|
2018-03-05 11:48:09 -08:00
|
|
|
pub acc: Accountant,
|
2018-02-28 09:07:54 -08:00
|
|
|
}
|
|
|
|
|
2018-02-28 13:16:50 -08:00
|
|
|
#[derive(Serialize, Deserialize, Debug)]
|
2018-02-28 09:07:54 -08:00
|
|
|
pub enum Request {
|
2018-03-17 13:42:50 -07:00
|
|
|
Transaction(Transaction),
|
2018-03-06 10:03:41 -08:00
|
|
|
GetBalance { key: PublicKey },
|
2018-03-06 16:36:45 -08:00
|
|
|
GetEntries { last_id: Hash },
|
2018-03-06 10:03:41 -08:00
|
|
|
GetId { is_last: bool },
|
2018-02-28 09:07:54 -08:00
|
|
|
}
|
|
|
|
|
2018-02-28 13:16:50 -08:00
|
|
|
#[derive(Serialize, Deserialize, Debug)]
|
2018-02-28 09:07:54 -08:00
|
|
|
pub enum Response {
|
2018-03-05 16:29:32 -08:00
|
|
|
Balance { key: PublicKey, val: Option<i64> },
|
2018-03-06 19:22:30 -08:00
|
|
|
Entries { entries: Vec<Entry> },
|
2018-03-06 16:36:45 -08:00
|
|
|
Id { id: Hash, is_last: bool },
|
2018-02-28 09:07:54 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
impl AccountantSkel {
|
2018-03-05 11:48:09 -08:00
|
|
|
pub fn new(acc: Accountant) -> Self {
|
|
|
|
AccountantSkel { acc }
|
2018-02-28 13:16:50 -08:00
|
|
|
}
|
|
|
|
|
2018-02-28 17:04:35 -08:00
|
|
|
pub fn process_request(self: &mut Self, msg: Request) -> Option<Response> {
|
2018-02-28 09:07:54 -08:00
|
|
|
match msg {
|
2018-03-06 10:43:53 -08:00
|
|
|
Request::Transaction(tr) => {
|
2018-03-06 10:54:45 -08:00
|
|
|
if let Err(err) = self.acc.process_transaction(tr) {
|
|
|
|
eprintln!("Transaction error: {:?}", err);
|
2018-03-03 09:23:31 -08:00
|
|
|
}
|
2018-02-28 09:07:54 -08:00
|
|
|
None
|
|
|
|
}
|
|
|
|
Request::GetBalance { key } => {
|
2018-03-05 14:34:15 -08:00
|
|
|
let val = self.acc.get_balance(&key);
|
2018-02-28 09:07:54 -08:00
|
|
|
Some(Response::Balance { key, val })
|
|
|
|
}
|
2018-03-05 10:11:00 -08:00
|
|
|
Request::GetEntries { .. } => Some(Response::Entries { entries: vec![] }),
|
2018-03-05 11:48:09 -08:00
|
|
|
Request::GetId { is_last } => Some(Response::Id {
|
|
|
|
id: if is_last {
|
|
|
|
self.acc.sync();
|
|
|
|
self.acc.last_id
|
|
|
|
} else {
|
|
|
|
self.acc.first_id
|
|
|
|
},
|
|
|
|
is_last,
|
|
|
|
}),
|
2018-02-28 09:07:54 -08:00
|
|
|
}
|
|
|
|
}
|
2018-03-10 20:09:17 -08:00
|
|
|
fn process(
|
|
|
|
&mut self,
|
|
|
|
r_reader: &streamer::Receiver,
|
|
|
|
s_sender: &streamer::Sender,
|
|
|
|
recycler: streamer::Recycler,
|
|
|
|
) -> Result<()> {
|
|
|
|
let timer = Duration::new(1, 0);
|
|
|
|
let msgs = r_reader.recv_timeout(timer)?;
|
|
|
|
let msgs_ = msgs.clone();
|
|
|
|
let msgs__ = msgs.clone();
|
|
|
|
let rsps = streamer::allocate(recycler.clone());
|
|
|
|
let rsps_ = rsps.clone();
|
|
|
|
let l = msgs__.read().unwrap().packets.len();
|
|
|
|
rsps.write()
|
|
|
|
.unwrap()
|
|
|
|
.packets
|
|
|
|
.resize(l, streamer::Packet::default());
|
|
|
|
{
|
|
|
|
let mut num = 0;
|
|
|
|
let mut ursps = rsps.write().unwrap();
|
|
|
|
for packet in msgs.read().unwrap().packets.iter() {
|
|
|
|
let sz = packet.size;
|
|
|
|
let req = deserialize(&packet.data[0..sz])?;
|
|
|
|
if let Some(resp) = self.process_request(req) {
|
|
|
|
let rsp = ursps.packets.get_mut(num).unwrap();
|
|
|
|
let v = serialize(&resp)?;
|
|
|
|
let len = v.len();
|
|
|
|
rsp.data[0..len].copy_from_slice(&v);
|
|
|
|
rsp.size = len;
|
|
|
|
rsp.set_addr(&packet.get_addr());
|
|
|
|
num += 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ursps.packets.resize(num, streamer::Packet::default());
|
|
|
|
}
|
|
|
|
s_sender.send(rsps_)?;
|
|
|
|
streamer::recycle(recycler, msgs_);
|
|
|
|
Ok(())
|
|
|
|
}
|
2018-02-28 09:07:54 -08:00
|
|
|
|
2018-03-01 11:23:27 -08:00
|
|
|
/// UDP Server that forwards messages to Accountant methods.
|
2018-03-10 20:09:17 -08:00
|
|
|
pub fn serve(
|
|
|
|
obj: Arc<Mutex<AccountantSkel>>,
|
|
|
|
addr: &str,
|
|
|
|
exit: Arc<Mutex<bool>>,
|
|
|
|
) -> Result<[Arc<JoinHandle<()>>; 3]> {
|
|
|
|
let read = UdpSocket::bind(addr)?;
|
|
|
|
// make sure we are on the same interface
|
|
|
|
let mut local = read.local_addr()?;
|
|
|
|
local.set_port(0);
|
|
|
|
let write = UdpSocket::bind(local)?;
|
2018-02-28 09:07:54 -08:00
|
|
|
|
2018-03-10 20:09:17 -08:00
|
|
|
let recycler = Arc::new(Mutex::new(Vec::new()));
|
|
|
|
let (s_reader, r_reader) = channel();
|
|
|
|
let t_receiver = streamer::receiver(read, exit.clone(), recycler.clone(), s_reader)?;
|
2018-02-28 13:16:50 -08:00
|
|
|
|
2018-03-10 20:09:17 -08:00
|
|
|
let (s_sender, r_sender) = channel();
|
|
|
|
let t_sender = streamer::sender(write, exit.clone(), recycler.clone(), r_sender);
|
|
|
|
|
|
|
|
let t_server = spawn(move || {
|
|
|
|
match Arc::try_unwrap(obj) {
|
|
|
|
Ok(me) => loop {
|
|
|
|
let e = me.lock()
|
|
|
|
.unwrap()
|
|
|
|
.process(&r_reader, &s_sender, recycler.clone());
|
|
|
|
if e.is_err() && *exit.lock().unwrap() {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
},
|
|
|
|
_ => (),
|
|
|
|
};
|
|
|
|
});
|
|
|
|
Ok([Arc::new(t_receiver), Arc::new(t_sender), Arc::new(t_server)])
|
2018-02-28 09:07:54 -08:00
|
|
|
}
|
|
|
|
}
|