2017-01-25 18:51:41 +01:00
|
|
|
// Copyright 2015-2017 Parity Technologies (UK) Ltd.
|
2016-12-27 16:43:28 +01:00
|
|
|
// 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;
|
|
|
|
|
2017-01-05 13:26:14 +01:00
|
|
|
use ethcore::basic_account::BasicAccount;
|
2016-12-28 14:00:33 +01:00
|
|
|
use ethcore::encoded;
|
2016-12-27 16:43:28 +01:00
|
|
|
use ethcore::receipt::Receipt;
|
|
|
|
|
2016-12-28 16:20:46 +01:00
|
|
|
use futures::{Async, Poll, Future};
|
|
|
|
use futures::sync::oneshot;
|
2016-12-27 16:43:28 +01:00
|
|
|
use network::PeerId;
|
2017-02-06 18:28:13 +01:00
|
|
|
use rlp::{RlpStream, Stream};
|
|
|
|
use util::{Bytes, RwLock, U256};
|
|
|
|
use util::sha3::{SHA3_NULL_RLP, SHA3_EMPTY_LIST_RLP};
|
2016-12-27 16:43:28 +01:00
|
|
|
|
|
|
|
use net::{Handler, Status, Capabilities, Announcement, EventContext, BasicContext, ReqId};
|
2017-01-03 16:18:46 +01:00
|
|
|
use types::les_request::{self as les_request, Request as LesRequest};
|
|
|
|
|
|
|
|
pub mod request;
|
2016-12-27 16:43:28 +01:00
|
|
|
|
2016-12-28 16:20:46 +01:00
|
|
|
/// Errors which can occur while trying to fulfill a request.
|
2017-01-04 14:54:50 +01:00
|
|
|
#[derive(Debug, Clone, Copy, PartialEq)]
|
2016-12-28 16:20:46 +01:00
|
|
|
pub enum Error {
|
|
|
|
/// Request was canceled.
|
|
|
|
Canceled,
|
|
|
|
/// No suitable peers available to serve the request.
|
|
|
|
NoPeersAvailable,
|
2017-01-16 17:42:39 +01:00
|
|
|
/// Invalid request.
|
|
|
|
InvalidRequest,
|
2016-12-28 16:20:46 +01:00
|
|
|
/// 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>>;
|
2016-12-27 16:43:28 +01:00
|
|
|
|
|
|
|
// relevant peer info.
|
|
|
|
struct Peer {
|
|
|
|
status: Status,
|
|
|
|
capabilities: Capabilities,
|
|
|
|
}
|
|
|
|
|
2017-01-03 16:18:46 +01:00
|
|
|
// Attempted request info and sender to put received value.
|
2017-01-03 19:13:40 +01:00
|
|
|
enum Pending {
|
2017-02-04 17:47:06 +01:00
|
|
|
HeaderByNumber(request::HeaderByNumber, Sender<(encoded::Header, U256)>), // num + CHT root
|
2017-01-03 16:18:46 +01:00
|
|
|
HeaderByHash(request::HeaderByHash, Sender<encoded::Header>),
|
2017-01-03 19:13:40 +01:00
|
|
|
Block(request::Body, Sender<encoded::Block>),
|
2017-01-03 16:18:46 +01:00
|
|
|
BlockReceipts(request::BlockReceipts, Sender<Vec<Receipt>>),
|
2017-01-05 13:26:14 +01:00
|
|
|
Account(request::Account, Sender<BasicAccount>),
|
2016-12-27 16:43:28 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// 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>>,
|
2017-01-03 19:13:40 +01:00
|
|
|
pending_requests: RwLock<HashMap<ReqId, Pending>>,
|
2016-12-27 16:43:28 +01:00
|
|
|
}
|
|
|
|
|
2017-01-04 14:54:50 +01:00
|
|
|
impl Default for OnDemand {
|
|
|
|
fn default() -> Self {
|
|
|
|
OnDemand {
|
|
|
|
peers: RwLock::new(HashMap::new()),
|
|
|
|
pending_requests: RwLock::new(HashMap::new()),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-27 16:43:28 +01:00
|
|
|
impl OnDemand {
|
|
|
|
/// Request a header by block number and CHT root hash.
|
2017-02-04 17:47:06 +01:00
|
|
|
/// Returns the header and the total difficulty.
|
|
|
|
pub fn header_by_number(&self, ctx: &BasicContext, req: request::HeaderByNumber) -> Response<(encoded::Header, U256)> {
|
2016-12-27 16:43:28 +01:00
|
|
|
let (sender, receiver) = oneshot::channel();
|
2017-01-04 13:58:26 +01:00
|
|
|
self.dispatch_header_by_number(ctx, req, sender);
|
|
|
|
Response(receiver)
|
|
|
|
}
|
|
|
|
|
|
|
|
// dispatch the request, completing the request if no peers available.
|
2017-02-04 17:47:06 +01:00
|
|
|
fn dispatch_header_by_number(&self, ctx: &BasicContext, req: request::HeaderByNumber, sender: Sender<(encoded::Header, U256)>) {
|
2017-01-03 19:13:40 +01:00
|
|
|
let num = req.num;
|
2017-01-16 17:42:39 +01:00
|
|
|
let cht_num = match ::cht::block_to_cht_number(req.num) {
|
|
|
|
Some(cht_num) => cht_num,
|
|
|
|
None => {
|
|
|
|
warn!(target: "on_demand", "Attempted to dispatch invalid header proof: req.num == 0");
|
|
|
|
sender.complete(Err(Error::InvalidRequest));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2017-01-03 19:13:40 +01:00
|
|
|
let les_req = LesRequest::HeaderProofs(les_request::HeaderProofs {
|
|
|
|
requests: vec![les_request::HeaderProof {
|
|
|
|
cht_number: cht_num,
|
|
|
|
block_number: req.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, les_req.clone()) {
|
|
|
|
Ok(req_id) => {
|
|
|
|
trace!(target: "on_demand", "Assigning request to peer {}", id);
|
|
|
|
self.pending_requests.write().insert(
|
|
|
|
req_id,
|
|
|
|
Pending::HeaderByNumber(req, sender)
|
|
|
|
);
|
2017-01-04 13:58:26 +01:00
|
|
|
return
|
2017-01-03 19:13:40 +01:00
|
|
|
},
|
|
|
|
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));
|
2016-12-27 16:43:28 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// 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.
|
2017-01-03 19:13:40 +01:00
|
|
|
pub fn header_by_hash(&self, ctx: &BasicContext, req: request::HeaderByHash) -> Response<encoded::Header> {
|
2016-12-27 16:43:28 +01:00
|
|
|
let (sender, receiver) = oneshot::channel();
|
2017-01-04 13:58:26 +01:00
|
|
|
self.dispatch_header_by_hash(ctx, req, sender);
|
|
|
|
Response(receiver)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn dispatch_header_by_hash(&self, ctx: &BasicContext, req: request::HeaderByHash, sender: Sender<encoded::Header>) {
|
2017-01-03 19:13:40 +01:00
|
|
|
let les_req = LesRequest::Headers(les_request::Headers {
|
|
|
|
start: req.0.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, les_req.clone()) {
|
|
|
|
Ok(req_id) => {
|
|
|
|
trace!(target: "on_demand", "Assigning request to peer {}", id);
|
|
|
|
self.pending_requests.write().insert(
|
|
|
|
req_id,
|
|
|
|
Pending::HeaderByHash(req, sender),
|
|
|
|
);
|
2017-01-04 13:58:26 +01:00
|
|
|
return
|
2017-01-03 19:13:40 +01:00
|
|
|
}
|
|
|
|
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));
|
2016-12-27 16:43:28 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// 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.
|
2017-01-03 19:13:40 +01:00
|
|
|
pub fn block(&self, ctx: &BasicContext, req: request::Body) -> Response<encoded::Block> {
|
2016-12-27 16:43:28 +01:00
|
|
|
let (sender, receiver) = oneshot::channel();
|
2017-02-06 18:28:13 +01:00
|
|
|
|
|
|
|
// fast path for empty body.
|
|
|
|
if req.header.transactions_root() == SHA3_NULL_RLP && req.header.uncles_hash() == SHA3_EMPTY_LIST_RLP {
|
|
|
|
let mut stream = RlpStream::new_list(3);
|
|
|
|
stream.append_raw(&req.header.into_inner(), 1);
|
|
|
|
stream.begin_list(0);
|
|
|
|
stream.begin_list(0);
|
|
|
|
|
|
|
|
sender.complete(Ok(encoded::Block::new(stream.out())))
|
|
|
|
} else {
|
|
|
|
self.dispatch_block(ctx, req, sender);
|
|
|
|
}
|
2017-01-04 13:58:26 +01:00
|
|
|
Response(receiver)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn dispatch_block(&self, ctx: &BasicContext, req: request::Body, sender: Sender<encoded::Block>) {
|
2017-01-03 19:13:40 +01:00
|
|
|
let num = req.header.number();
|
|
|
|
let les_req = LesRequest::Bodies(les_request::Bodies {
|
|
|
|
block_hashes: vec![req.hash],
|
|
|
|
});
|
|
|
|
|
|
|
|
// we're looking for a peer with serveChainSince(num)
|
|
|
|
for (id, peer) in self.peers.read().iter() {
|
|
|
|
if peer.capabilities.serve_chain_since.as_ref().map_or(false, |x| *x >= num) {
|
|
|
|
match ctx.request_from(*id, les_req.clone()) {
|
|
|
|
Ok(req_id) => {
|
|
|
|
trace!(target: "on_demand", "Assigning request to peer {}", id);
|
|
|
|
self.pending_requests.write().insert(
|
|
|
|
req_id,
|
|
|
|
Pending::Block(req, sender)
|
|
|
|
);
|
2017-01-04 13:58:26 +01:00
|
|
|
return
|
2017-01-03 19:13:40 +01:00
|
|
|
}
|
|
|
|
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));
|
2016-12-27 16:43:28 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// 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.
|
2017-01-03 19:13:40 +01:00
|
|
|
pub fn block_receipts(&self, ctx: &BasicContext, req: request::BlockReceipts) -> Response<Vec<Receipt>> {
|
2016-12-27 16:43:28 +01:00
|
|
|
let (sender, receiver) = oneshot::channel();
|
2017-02-06 18:28:13 +01:00
|
|
|
|
|
|
|
// fast path for empty receipts.
|
|
|
|
if req.0.receipts_root() == SHA3_NULL_RLP {
|
|
|
|
sender.complete(Ok(Vec::new()))
|
|
|
|
} else {
|
|
|
|
self.dispatch_block_receipts(ctx, req, sender);
|
|
|
|
}
|
|
|
|
|
2017-01-04 13:58:26 +01:00
|
|
|
Response(receiver)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn dispatch_block_receipts(&self, ctx: &BasicContext, req: request::BlockReceipts, sender: Sender<Vec<Receipt>>) {
|
2017-01-03 19:13:40 +01:00
|
|
|
let num = req.0.number();
|
|
|
|
let les_req = LesRequest::Receipts(les_request::Receipts {
|
|
|
|
block_hashes: vec![req.0.hash()],
|
|
|
|
});
|
|
|
|
|
|
|
|
// we're looking for a peer with serveChainSince(num)
|
|
|
|
for (id, peer) in self.peers.read().iter() {
|
|
|
|
if peer.capabilities.serve_chain_since.as_ref().map_or(false, |x| *x >= num) {
|
|
|
|
match ctx.request_from(*id, les_req.clone()) {
|
|
|
|
Ok(req_id) => {
|
|
|
|
trace!(target: "on_demand", "Assigning request to peer {}", id);
|
|
|
|
self.pending_requests.write().insert(
|
|
|
|
req_id,
|
|
|
|
Pending::BlockReceipts(req, sender)
|
|
|
|
);
|
2017-01-04 13:58:26 +01:00
|
|
|
return
|
2017-01-03 19:13:40 +01:00
|
|
|
}
|
|
|
|
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));
|
2016-12-27 16:43:28 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Request an account by address and block header -- which gives a hash to query and a state root
|
|
|
|
/// to verify against.
|
2017-01-05 13:26:14 +01:00
|
|
|
pub fn account(&self, ctx: &BasicContext, req: request::Account) -> Response<BasicAccount> {
|
2016-12-27 16:43:28 +01:00
|
|
|
let (sender, receiver) = oneshot::channel();
|
2017-01-04 13:58:26 +01:00
|
|
|
self.dispatch_account(ctx, req, sender);
|
|
|
|
Response(receiver)
|
|
|
|
}
|
|
|
|
|
2017-01-05 13:26:14 +01:00
|
|
|
fn dispatch_account(&self, ctx: &BasicContext, req: request::Account, sender: Sender<BasicAccount>) {
|
2017-01-03 19:13:40 +01:00
|
|
|
let num = req.header.number();
|
|
|
|
let les_req = LesRequest::StateProofs(les_request::StateProofs {
|
|
|
|
requests: vec![les_request::StateProof {
|
|
|
|
block: req.header.hash(),
|
|
|
|
key1: ::util::Hashable::sha3(&req.address),
|
|
|
|
key2: None,
|
|
|
|
from_level: 0,
|
|
|
|
}],
|
|
|
|
});
|
|
|
|
|
|
|
|
// we're looking for a peer with serveStateSince(num)
|
|
|
|
for (id, peer) in self.peers.read().iter() {
|
|
|
|
if peer.capabilities.serve_state_since.as_ref().map_or(false, |x| *x >= num) {
|
|
|
|
match ctx.request_from(*id, les_req.clone()) {
|
|
|
|
Ok(req_id) => {
|
|
|
|
trace!(target: "on_demand", "Assigning request to peer {}", id);
|
|
|
|
self.pending_requests.write().insert(
|
|
|
|
req_id,
|
|
|
|
Pending::Account(req, sender)
|
|
|
|
);
|
2017-01-04 13:58:26 +01:00
|
|
|
return
|
2016-12-28 21:46:55 +01:00
|
|
|
}
|
2017-01-03 19:13:40 +01:00
|
|
|
Err(e) =>
|
|
|
|
trace!(target: "on_demand", "Failed to make request of peer {}: {:?}", id, e),
|
2016-12-28 21:46:55 +01:00
|
|
|
}
|
2016-12-28 16:20:46 +01:00
|
|
|
}
|
|
|
|
}
|
2017-01-03 19:13:40 +01:00
|
|
|
|
|
|
|
// TODO: retrying
|
|
|
|
trace!(target: "on_demand", "No suitable peer for request");
|
|
|
|
sender.complete(Err(Error::NoPeersAvailable));
|
2016-12-27 16:43:28 +01:00
|
|
|
}
|
|
|
|
}
|
2017-01-03 16:18:46 +01:00
|
|
|
|
|
|
|
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());
|
2017-01-04 13:58:26 +01:00
|
|
|
let ctx = ctx.as_basic();
|
2017-01-03 16:18:46 +01:00
|
|
|
|
|
|
|
for unfulfilled in unfulfilled {
|
|
|
|
if let Some(pending) = self.pending_requests.write().remove(unfulfilled) {
|
|
|
|
trace!(target: "on_demand", "Attempting to reassign dropped request");
|
2017-01-04 13:58:26 +01:00
|
|
|
match pending {
|
|
|
|
Pending::HeaderByNumber(req, sender)
|
|
|
|
=> self.dispatch_header_by_number(ctx, req, sender),
|
|
|
|
Pending::HeaderByHash(req, sender)
|
|
|
|
=> self.dispatch_header_by_hash(ctx, req, sender),
|
|
|
|
Pending::Block(req, sender)
|
|
|
|
=> self.dispatch_block(ctx, req, sender),
|
|
|
|
Pending::BlockReceipts(req, sender)
|
|
|
|
=> self.dispatch_block_receipts(ctx, req, sender),
|
|
|
|
Pending::Account(req, sender)
|
|
|
|
=> self.dispatch_account(ctx, req, sender),
|
|
|
|
}
|
2017-01-03 16:18:46 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn on_header_proofs(&self, ctx: &EventContext, req_id: ReqId, proofs: &[(Bytes, Vec<Bytes>)]) {
|
|
|
|
let peer = ctx.peer();
|
|
|
|
let req = match self.pending_requests.write().remove(&req_id) {
|
|
|
|
Some(req) => req,
|
|
|
|
None => return,
|
|
|
|
};
|
|
|
|
|
|
|
|
match req {
|
2017-01-03 19:13:40 +01:00
|
|
|
Pending::HeaderByNumber(req, sender) => {
|
2017-01-04 13:34:50 +01:00
|
|
|
if let Some(&(ref header, ref proof)) = proofs.get(0) {
|
|
|
|
match req.check_response(header, proof) {
|
|
|
|
Ok(header) => {
|
|
|
|
sender.complete(Ok(header));
|
|
|
|
return
|
|
|
|
}
|
|
|
|
Err(e) => {
|
|
|
|
warn!("Error handling response for header request: {:?}", e);
|
|
|
|
ctx.disable_peer(peer);
|
|
|
|
}
|
2017-01-03 16:18:46 +01:00
|
|
|
}
|
2017-01-04 13:34:50 +01:00
|
|
|
}
|
|
|
|
|
2017-01-04 14:33:32 +01:00
|
|
|
self.dispatch_header_by_number(ctx.as_basic(), req, sender);
|
2017-01-03 16:18:46 +01:00
|
|
|
}
|
|
|
|
_ => panic!("Only header by number request fetches header proofs; qed"),
|
|
|
|
}
|
|
|
|
}
|
2017-01-04 13:34:50 +01:00
|
|
|
|
|
|
|
fn on_block_headers(&self, ctx: &EventContext, req_id: ReqId, headers: &[Bytes]) {
|
|
|
|
let peer = ctx.peer();
|
|
|
|
let req = match self.pending_requests.write().remove(&req_id) {
|
|
|
|
Some(req) => req,
|
|
|
|
None => return,
|
|
|
|
};
|
|
|
|
|
|
|
|
match req {
|
|
|
|
Pending::HeaderByHash(req, sender) => {
|
|
|
|
if let Some(ref header) = headers.get(0) {
|
|
|
|
match req.check_response(header) {
|
|
|
|
Ok(header) => {
|
|
|
|
sender.complete(Ok(header));
|
|
|
|
return
|
|
|
|
}
|
|
|
|
Err(e) => {
|
|
|
|
warn!("Error handling response for header request: {:?}", e);
|
|
|
|
ctx.disable_peer(peer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-04 14:33:32 +01:00
|
|
|
self.dispatch_header_by_hash(ctx.as_basic(), req, sender);
|
2017-01-04 13:34:50 +01:00
|
|
|
}
|
|
|
|
_ => panic!("Only header by hash request fetches headers; qed"),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn on_block_bodies(&self, ctx: &EventContext, req_id: ReqId, bodies: &[Bytes]) {
|
|
|
|
let peer = ctx.peer();
|
|
|
|
let req = match self.pending_requests.write().remove(&req_id) {
|
|
|
|
Some(req) => req,
|
|
|
|
None => return,
|
|
|
|
};
|
|
|
|
|
|
|
|
match req {
|
|
|
|
Pending::Block(req, sender) => {
|
|
|
|
if let Some(ref block) = bodies.get(0) {
|
|
|
|
match req.check_response(block) {
|
|
|
|
Ok(block) => {
|
|
|
|
sender.complete(Ok(block));
|
|
|
|
return
|
|
|
|
}
|
|
|
|
Err(e) => {
|
|
|
|
warn!("Error handling response for block request: {:?}", e);
|
|
|
|
ctx.disable_peer(peer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-04 14:33:32 +01:00
|
|
|
self.dispatch_block(ctx.as_basic(), req, sender);
|
2017-01-04 13:34:50 +01:00
|
|
|
}
|
|
|
|
_ => panic!("Only block request fetches bodies; qed"),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn on_receipts(&self, ctx: &EventContext, req_id: ReqId, receipts: &[Vec<Receipt>]) {
|
|
|
|
let peer = ctx.peer();
|
|
|
|
let req = match self.pending_requests.write().remove(&req_id) {
|
|
|
|
Some(req) => req,
|
|
|
|
None => return,
|
|
|
|
};
|
|
|
|
|
|
|
|
match req {
|
|
|
|
Pending::BlockReceipts(req, sender) => {
|
|
|
|
if let Some(ref receipts) = receipts.get(0) {
|
|
|
|
match req.check_response(receipts) {
|
|
|
|
Ok(receipts) => {
|
|
|
|
sender.complete(Ok(receipts));
|
|
|
|
return
|
|
|
|
}
|
|
|
|
Err(e) => {
|
|
|
|
warn!("Error handling response for receipts request: {:?}", e);
|
|
|
|
ctx.disable_peer(peer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-04 14:33:32 +01:00
|
|
|
self.dispatch_block_receipts(ctx.as_basic(), req, sender);
|
2017-01-04 13:34:50 +01:00
|
|
|
}
|
|
|
|
_ => panic!("Only receipts request fetches receipts; qed"),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn on_state_proofs(&self, ctx: &EventContext, req_id: ReqId, proofs: &[Vec<Bytes>]) {
|
|
|
|
let peer = ctx.peer();
|
|
|
|
let req = match self.pending_requests.write().remove(&req_id) {
|
|
|
|
Some(req) => req,
|
|
|
|
None => return,
|
|
|
|
};
|
|
|
|
|
|
|
|
match req {
|
|
|
|
Pending::Account(req, sender) => {
|
|
|
|
if let Some(ref proof) = proofs.get(0) {
|
|
|
|
match req.check_response(proof) {
|
|
|
|
Ok(proof) => {
|
|
|
|
sender.complete(Ok(proof));
|
|
|
|
return
|
|
|
|
}
|
|
|
|
Err(e) => {
|
|
|
|
warn!("Error handling response for state request: {:?}", e);
|
|
|
|
ctx.disable_peer(peer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-04 14:33:32 +01:00
|
|
|
self.dispatch_account(ctx.as_basic(), req, sender);
|
2017-01-04 13:34:50 +01:00
|
|
|
}
|
|
|
|
_ => panic!("Only account request fetches state proof; qed"),
|
|
|
|
}
|
|
|
|
}
|
2017-01-03 16:18:46 +01:00
|
|
|
}
|
2017-01-04 14:54:50 +01:00
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::*;
|
2017-01-04 16:12:58 +01:00
|
|
|
use net::{Announcement, BasicContext, ReqId, Error as LesError};
|
2017-01-04 14:54:50 +01:00
|
|
|
use request::{Request as LesRequest, Kind as LesRequestKind};
|
|
|
|
use network::{PeerId, NodeId};
|
|
|
|
use futures::Future;
|
|
|
|
use util::H256;
|
|
|
|
|
|
|
|
struct FakeContext;
|
|
|
|
|
|
|
|
impl BasicContext for FakeContext {
|
|
|
|
fn persistent_peer_id(&self, _: PeerId) -> Option<NodeId> { None }
|
|
|
|
fn request_from(&self, _: PeerId, _: LesRequest) -> Result<ReqId, LesError> {
|
|
|
|
unimplemented!()
|
|
|
|
}
|
|
|
|
fn make_announcement(&self, _: Announcement) { }
|
|
|
|
fn max_requests(&self, _: PeerId, _: LesRequestKind) -> usize { 0 }
|
|
|
|
fn disconnect_peer(&self, _: PeerId) { }
|
|
|
|
fn disable_peer(&self, _: PeerId) { }
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn no_peers() {
|
|
|
|
let on_demand = OnDemand::default();
|
|
|
|
let result = on_demand.header_by_hash(&FakeContext, request::HeaderByHash(H256::default()));
|
|
|
|
|
|
|
|
assert_eq!(result.wait().unwrap_err(), Error::NoPeersAvailable);
|
|
|
|
}
|
|
|
|
}
|