257 lines
8.5 KiB
Rust
257 lines
8.5 KiB
Rust
// Copyright 2015, 2016 Parity Technologies (UK) Ltd.
|
|
// This file is part of Parity.
|
|
|
|
// Parity is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
|
|
// Parity is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
//! On-demand chain requests over LES. This is a major building block for RPCs.
|
|
//! The request service is implemented using Futures. Higher level request handlers
|
|
//! will take the raw data received here and extract meaningful results from it.
|
|
|
|
use std::collections::HashMap;
|
|
|
|
use ethcore::encoded;
|
|
use ethcore::receipt::Receipt;
|
|
|
|
use futures::{Async, Poll, Future};
|
|
use futures::sync::oneshot;
|
|
use network::PeerId;
|
|
|
|
use client::Client;
|
|
use net::{Handler, Status, Capabilities, Announcement, EventContext, BasicContext, ReqId};
|
|
use util::{Address, H256, U256, RwLock};
|
|
use request as les_request;
|
|
|
|
/// Basic account data.
|
|
// TODO: [rob] unify with similar struct in `snapshot`.
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct Account {
|
|
/// Balance in Wei
|
|
pub balance: U256,
|
|
/// Storage trie root.
|
|
pub storage_root: H256,
|
|
/// Code hash
|
|
pub code_hash: H256,
|
|
/// Nonce
|
|
pub nonce: U256,
|
|
}
|
|
|
|
/// Errors which can occur while trying to fulfill a request.
|
|
pub enum Error {
|
|
/// Request was canceled.
|
|
Canceled,
|
|
/// No suitable peers available to serve the request.
|
|
NoPeersAvailable,
|
|
/// Request timed out.
|
|
TimedOut,
|
|
}
|
|
|
|
impl From<oneshot::Canceled> for Error {
|
|
fn from(_: oneshot::Canceled) -> Self {
|
|
Error::Canceled
|
|
}
|
|
}
|
|
|
|
/// Future which awaits a response to an on-demand request.
|
|
pub struct Response<T>(oneshot::Receiver<Result<T, Error>>);
|
|
|
|
impl<T> Future for Response<T> {
|
|
type Item = T;
|
|
type Error = Error;
|
|
|
|
fn poll(&mut self) -> Poll<T, Error> {
|
|
match self.0.poll().map_err(Into::into) {
|
|
Ok(Async::Ready(val)) => val.map(Async::Ready),
|
|
Ok(Async::NotReady) => Ok(Async::NotReady),
|
|
Err(e) => Err(e),
|
|
}
|
|
}
|
|
}
|
|
|
|
type Sender<T> = oneshot::Sender<Result<T, Error>>;
|
|
|
|
// relevant peer info.
|
|
struct Peer {
|
|
status: Status,
|
|
capabilities: Capabilities,
|
|
}
|
|
|
|
// request info and where to send the result.
|
|
enum Request {
|
|
HeaderByNumber(u64, H256, Sender<encoded::Header>), // num + CHT root
|
|
HeaderByHash(H256, Sender<encoded::Header>),
|
|
Block(encoded::Header, Sender<encoded::Block>),
|
|
BlockReceipts(encoded::Header, Sender<Vec<Receipt>>),
|
|
Account(encoded::Header, Address, Sender<Account>),
|
|
Storage(encoded::Header, Address, H256, Sender<H256>),
|
|
}
|
|
|
|
/// On demand request service. See module docs for more details.
|
|
/// Accumulates info about all peers' capabilities and dispatches
|
|
/// requests to them accordingly.
|
|
pub struct OnDemand {
|
|
peers: RwLock<HashMap<PeerId, Peer>>,
|
|
pending_requests: RwLock<HashMap<ReqId, Request>>,
|
|
}
|
|
|
|
impl Handler for OnDemand {
|
|
fn on_connect(&self, ctx: &EventContext, status: &Status, capabilities: &Capabilities) {
|
|
self.peers.write().insert(ctx.peer(), Peer { status: status.clone(), capabilities: capabilities.clone() });
|
|
}
|
|
|
|
fn on_disconnect(&self, ctx: &EventContext, unfulfilled: &[ReqId]) {
|
|
self.peers.write().remove(&ctx.peer());
|
|
|
|
for unfulfilled in unfulfilled {
|
|
if let Some(pending) = self.pending_requests.write().remove(unfulfilled) {
|
|
trace!(target: "on_demand", "Attempting to reassign dropped request");
|
|
self.dispatch_request(ctx.as_basic(), pending);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn on_announcement(&self, ctx: &EventContext, announcement: &Announcement) {
|
|
let mut peers = self.peers.write();
|
|
if let Some(ref mut peer) = peers.get_mut(&ctx.peer()) {
|
|
peer.status.update_from(&announcement);
|
|
peer.capabilities.update_from(&announcement);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl OnDemand {
|
|
/// Request a header by block number and CHT root hash.
|
|
pub fn header_by_number(&self, ctx: &BasicContext, num: u64, cht_root: H256) -> Response<encoded::Header> {
|
|
let (sender, receiver) = oneshot::channel();
|
|
self.dispatch_request(ctx, Request::HeaderByNumber(num, cht_root, sender));
|
|
Response(receiver)
|
|
}
|
|
|
|
/// Request a header by hash. This is less accurate than by-number because we don't know
|
|
/// where in the chain this header lies, and therefore can't find a peer who is supposed to have
|
|
/// it as easily.
|
|
pub fn header_by_hash(&self, ctx: &BasicContext, hash: H256) -> Response<encoded::Header> {
|
|
let (sender, receiver) = oneshot::channel();
|
|
self.dispatch_request(ctx, Request::HeaderByHash(hash, sender));
|
|
Response(receiver)
|
|
}
|
|
|
|
/// Request a block, given its header. Block bodies are requestable by hash only,
|
|
/// and the header is required anyway to verify and complete the block body
|
|
/// -- this just doesn't obscure the network query.
|
|
pub fn block(&self, ctx: &BasicContext, header: encoded::Header) -> Response<encoded::Block> {
|
|
let (sender, receiver) = oneshot::channel();
|
|
self.dispatch_request(ctx, Request::Block(header, sender));
|
|
Response(receiver)
|
|
}
|
|
|
|
/// Request the receipts for a block. The header serves two purposes:
|
|
/// provide the block hash to fetch receipts for, and for verification of the receipts root.
|
|
pub fn block_receipts(&self, ctx: &BasicContext, header: encoded::Header) -> Response<Vec<Receipt>> {
|
|
let (sender, receiver) = oneshot::channel();
|
|
self.dispatch_request(ctx, Request::BlockReceipts(header, sender));
|
|
Response(receiver)
|
|
}
|
|
|
|
/// Request an account by address and block header -- which gives a hash to query and a state root
|
|
/// to verify against.
|
|
pub fn account(&self, ctx: &BasicContext, header: encoded::Header, address: Address) -> Response<Account> {
|
|
let (sender, receiver) = oneshot::channel();
|
|
self.dispatch_request(ctx, Request::Account(header, address, sender));
|
|
Response(receiver)
|
|
}
|
|
|
|
/// Request account storage value by block header, address, and key.
|
|
pub fn storage(&self, ctx: &BasicContext, header: encoded::Header, address: Address, key: H256) -> Response<H256> {
|
|
let (sender, receiver) = oneshot::channel();
|
|
self.dispatch_request(ctx, Request::Storage(header, address, key, sender));
|
|
Response(receiver)
|
|
}
|
|
|
|
// dispatch a request to a suitable peer.
|
|
fn dispatch_request(&self, ctx: &BasicContext, request: Request) {
|
|
match request {
|
|
Request::HeaderByNumber(num, cht_hash, sender) => {
|
|
let cht_num = ::client::cht::block_to_cht_number(num);
|
|
let req = les_request::Request::HeaderProofs(les_request::HeaderProofs {
|
|
requests: vec![les_request::HeaderProof {
|
|
cht_number: cht_num,
|
|
block_number: num,
|
|
from_level: 0,
|
|
}],
|
|
});
|
|
|
|
// we're looking for a peer with serveHeaders who's far enough along in the
|
|
// chain.
|
|
for (id, peer) in self.peers.read().iter() {
|
|
if peer.capabilities.serve_headers && peer.status.head_num >= num {
|
|
match ctx.request_from(*id, req.clone()) {
|
|
Ok(req_id) => {
|
|
trace!(target: "on_demand", "Assigning request to peer {}", id);
|
|
self.pending_requests.write().insert(
|
|
req_id,
|
|
Request::HeaderByNumber(num, cht_hash, sender)
|
|
);
|
|
return;
|
|
},
|
|
Err(e) =>
|
|
trace!(target: "on_demand", "Failed to make request of peer {}: {:?}", id, e),
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO: retrying.
|
|
trace!(target: "on_demand", "No suitable peer for request");
|
|
sender.complete(Err(Error::NoPeersAvailable));
|
|
}
|
|
Request::HeaderByHash(hash, sender) => {
|
|
let req = les_request::Request::Headers(les_request::Headers {
|
|
start: hash.into(),
|
|
max: 1,
|
|
skip: 0,
|
|
reverse: false,
|
|
});
|
|
|
|
// all we've got is a hash, so we'll just guess at peers who might have
|
|
// it randomly.
|
|
let mut potential_peers = self.peers.read().iter()
|
|
.filter(|&(_, peer)| peer.capabilities.serve_headers)
|
|
.map(|(id, _)| *id)
|
|
.collect::<Vec<_>>();
|
|
|
|
let mut rng = ::rand::thread_rng();
|
|
|
|
::rand::Rng::shuffle(&mut rng, &mut potential_peers);
|
|
|
|
for id in potential_peers {
|
|
match ctx.request_from(id, req.clone()) {
|
|
Ok(req_id) => {
|
|
trace!(target: "on_demand", "Assigning request to peer {}", id);
|
|
self.pending_requests.write().insert(
|
|
req_id,
|
|
Request::HeaderByHash(hash, sender),
|
|
);
|
|
return;
|
|
}
|
|
Err(e) =>
|
|
trace!(target: "on_demand", "Failed to make request of peer {}: {:?}", id, e),
|
|
}
|
|
}
|
|
|
|
sender.complete(Err(Error::NoPeersAvailable));
|
|
}
|
|
_ => unimplemented!()
|
|
}
|
|
}
|
|
}
|