118 lines
3.3 KiB
Rust
118 lines
3.3 KiB
Rust
// Copyright 2015, 2016 Ethcore (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/>.
|
|
|
|
extern crate hyper;
|
|
|
|
use hyper::header::ContentType;
|
|
use hyper::method::Method;
|
|
use hyper::client::{Request, Response, Client};
|
|
use hyper::{Next};
|
|
use hyper::net::HttpStream;
|
|
use ethash::SeedHashCompute;
|
|
use hyper::Url;
|
|
use util::*;
|
|
use ethereum::ethash::Ethash;
|
|
|
|
pub struct WorkPoster {
|
|
urls: Vec<Url>,
|
|
client: Mutex<Client<PostHandler>>,
|
|
seed_compute: Mutex<SeedHashCompute>,
|
|
}
|
|
|
|
impl WorkPoster {
|
|
pub fn new(urls: &[String]) -> Self {
|
|
let urls = urls.into_iter().filter_map(|u| {
|
|
match Url::parse(u) {
|
|
Ok(url) => Some(url),
|
|
Err(e) => {
|
|
warn!("Error parsing URL {} : {}", u, e);
|
|
None
|
|
}
|
|
}
|
|
}).collect();
|
|
let client = WorkPoster::create_client();
|
|
WorkPoster {
|
|
client: Mutex::new(client),
|
|
urls: urls,
|
|
seed_compute: Mutex::new(SeedHashCompute::new()),
|
|
}
|
|
}
|
|
|
|
fn create_client() -> Client<PostHandler> {
|
|
Client::<PostHandler>::configure()
|
|
.keep_alive(true)
|
|
.build()
|
|
.expect("Error creating HTTP client")
|
|
}
|
|
|
|
pub fn notify(&self, pow_hash: H256, difficulty: U256, number: u64) {
|
|
// TODO: move this to engine
|
|
let target = Ethash::difficulty_to_boundary(&difficulty);
|
|
let seed_hash = &self.seed_compute.lock().get_seedhash(number);
|
|
let seed_hash = H256::from_slice(&seed_hash[..]);
|
|
let body = format!(
|
|
r#"{{ "result": ["0x{}","0x{}","0x{}","0x{:x}"] }}"#,
|
|
pow_hash.hex(), seed_hash.hex(), target.hex(), number
|
|
);
|
|
let mut client = self.client.lock();
|
|
for u in &self.urls {
|
|
if let Err(e) = client.request(u.clone(), PostHandler { body: body.clone() }) {
|
|
warn!("Error sending HTTP notification to {} : {}, retrying", u, e);
|
|
// TODO: remove this once https://github.com/hyperium/hyper/issues/848 is fixed
|
|
*client = WorkPoster::create_client();
|
|
if let Err(e) = client.request(u.clone(), PostHandler { body: body.clone() }) {
|
|
warn!("Error sending HTTP notification to {} : {}", u, e);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
struct PostHandler {
|
|
body: String,
|
|
}
|
|
|
|
impl hyper::client::Handler<HttpStream> for PostHandler {
|
|
fn on_request(&mut self, request: &mut Request) -> Next {
|
|
request.set_method(Method::Post);
|
|
request.headers_mut().set(ContentType::json());
|
|
Next::write()
|
|
}
|
|
|
|
fn on_request_writable(&mut self, encoder: &mut hyper::Encoder<HttpStream>) -> Next {
|
|
if let Err(e) = encoder.write_all(self.body.as_bytes()) {
|
|
trace!("Error posting work data: {}", e);
|
|
}
|
|
encoder.close();
|
|
Next::read()
|
|
|
|
}
|
|
|
|
fn on_response(&mut self, _response: Response) -> Next {
|
|
Next::end()
|
|
}
|
|
|
|
fn on_response_readable(&mut self, _decoder: &mut hyper::Decoder<HttpStream>) -> Next {
|
|
Next::end()
|
|
}
|
|
|
|
fn on_error(&mut self, err: hyper::Error) -> Next {
|
|
trace!("Error posting work data: {}", err);
|
|
Next::end()
|
|
}
|
|
}
|
|
|