115 lines
3.4 KiB
Rust
115 lines
3.4 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/>.
|
|
|
|
//! Hash-addressed content resolver & fetcher.
|
|
|
|
use std::{io, fs};
|
|
use std::sync::Arc;
|
|
use std::path::PathBuf;
|
|
|
|
use util::{Mutex, H256, sha3};
|
|
use fetch::{Fetch, FetchError, Client as FetchClient};
|
|
|
|
use urlhint::{ContractClient, URLHintContract, URLHint, URLHintResult};
|
|
|
|
/// API for fetching by hash.
|
|
pub trait HashFetch {
|
|
/// Fetch hash-addressed content.
|
|
/// Parameters:
|
|
/// 1. `hash` - content hash
|
|
/// 2. `on_done` - callback function invoked when the content is ready (or there was error during fetch)
|
|
///
|
|
/// This function may fail immediately when fetch cannot be initialized or content cannot be resolved.
|
|
fn fetch(&self, hash: H256, on_done: Box<Fn(Result<PathBuf, Error>) + Send>) -> Result<(), Error>;
|
|
}
|
|
|
|
/// Hash-fetching error.
|
|
#[derive(Debug)]
|
|
pub enum Error {
|
|
/// Hash could not be resolved to a valid content address.
|
|
NoResolution,
|
|
/// Downloaded content hash does not match.
|
|
HashMismatch { expected: H256, got: H256 },
|
|
/// IO Error while validating hash.
|
|
IO(io::Error),
|
|
/// Error during fetch.
|
|
Fetch(FetchError),
|
|
}
|
|
|
|
impl From<FetchError> for Error {
|
|
fn from(error: FetchError) -> Self {
|
|
Error::Fetch(error)
|
|
}
|
|
}
|
|
|
|
impl From<io::Error> for Error {
|
|
fn from(error: io::Error) -> Self {
|
|
Error::IO(error)
|
|
}
|
|
}
|
|
|
|
/// Default Hash-fetching client using on-chain contract to resolve hashes to URLs.
|
|
pub struct Client {
|
|
contract: URLHintContract,
|
|
fetch: Mutex<FetchClient>,
|
|
}
|
|
|
|
impl Client {
|
|
/// Creates new instance of the `Client` given on-chain contract client.
|
|
pub fn new(contract: Arc<ContractClient>) -> Self {
|
|
Client {
|
|
contract: URLHintContract::new(contract),
|
|
fetch: Mutex::new(FetchClient::default()),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl HashFetch for Client {
|
|
fn fetch(&self, hash: H256, on_done: Box<Fn(Result<PathBuf, Error>) + Send>) -> Result<(), Error> {
|
|
debug!(target: "dapps", "Fetching: {:?}", hash);
|
|
|
|
let url = try!(
|
|
self.contract.resolve(hash.to_vec()).map(|content| match content {
|
|
URLHintResult::Dapp(dapp) => {
|
|
dapp.url()
|
|
},
|
|
URLHintResult::Content(content) => {
|
|
content.url
|
|
},
|
|
}).ok_or_else(|| Error::NoResolution)
|
|
);
|
|
|
|
debug!(target: "dapps", "Resolved {:?} to {:?}. Fetching...", hash, url);
|
|
|
|
self.fetch.lock().request_async(&url, Default::default(), Box::new(move |result| {
|
|
fn validate_hash(hash: H256, result: Result<PathBuf, FetchError>) -> Result<PathBuf, Error> {
|
|
let path = try!(result);
|
|
let mut file_reader = io::BufReader::new(try!(fs::File::open(&path)));
|
|
let content_hash = try!(sha3(&mut file_reader));
|
|
|
|
if content_hash != hash {
|
|
Err(Error::HashMismatch{ got: content_hash, expected: hash })
|
|
} else {
|
|
Ok(path)
|
|
}
|
|
}
|
|
|
|
debug!(target: "dapps", "Content fetched, validating hash ({:?})", hash);
|
|
on_done(validate_hash(hash, result))
|
|
})).map_err(Into::into)
|
|
}
|
|
}
|