1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105

// Copyright 2015-2020 Parity Technologies (UK) Ltd.
// This file is part of OpenEthereum.

// OpenEthereum 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.

// OpenEthereum 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 OpenEthereum.  If not, see <http://www.gnu.org/licenses/>.

//! Sends HTTP notifications to a list of URLs every time new work is available.

extern crate ethash;
extern crate fetch;
extern crate hyper;
extern crate parity_runtime;
extern crate url;

use self::{
    ethash::SeedHashCompute,
    fetch::{Client as FetchClient, Fetch, Method, Request},
    hyper::header::{self, HeaderValue},
    parity_runtime::Executor,
    url::Url,
};

use ethereum_types::{H256, U256};
use parking_lot::Mutex;

use futures::Future;

/// Trait for notifying about new mining work
pub trait NotifyWork: Send + Sync {
    /// Fired when new mining job available
    fn notify(&self, pow_hash: H256, difficulty: U256, number: u64);
}

/// POSTs info about new work to given urls.
pub struct WorkPoster {
    urls: Vec<Url>,
    client: FetchClient,
    executor: Executor,
    seed_compute: Mutex<SeedHashCompute>,
}

impl WorkPoster {
    /// Create new `WorkPoster`.
    pub fn new(urls: &[String], fetch: FetchClient, executor: Executor) -> 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();
        WorkPoster {
            client: fetch,
            executor: executor,
            urls: urls,
            seed_compute: Mutex::new(SeedHashCompute::default()),
        }
    }
}

impl NotifyWork for WorkPoster {
    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().hash_block_number(number);
        let seed_hash = H256::from_slice(&seed_hash[..]);
        let body = format!(
            r#"{{ "result": ["0x{:x}","0x{:x}","0x{:x}","0x{:x}"] }}"#,
            pow_hash, seed_hash, target, number
        );

        for u in &self.urls {
            let u = u.clone();
            self.executor.spawn(
                self.client
                    .fetch(
                        Request::new(u.clone(), Method::POST)
                            .with_header(
                                header::CONTENT_TYPE,
                                HeaderValue::from_static("application/json"),
                            )
                            .with_body(body.clone()),
                        Default::default(),
                    )
                    .map_err(move |e| {
                        warn!("Error sending HTTP notification to {} : {}, retrying", u, e);
                    })
                    .map(|_| ()),
            );
        }
    }
}