Core/grin
0
0
Fork 0
mirror of https://github.com/mimblewimble/grin.git synced 2025-02-01 17:01:09 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove unused code in message handling (#3269)

Browse source
This commit is contained in:
jaspervdm 2020-03-13 12:50:35 +01:00 committed by GitHub
parent 3bbf60ee92
commit 6bdf31f23d
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
5 changed files with 5 additions and 123 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
api/src/handlers.rs
View file

@ -34,7 +34,6 @@ use self::peers_api::PeersConnectedHandler;
use self::pool_api::PoolInfoHandler;
use self::pool_api::PoolPushHandler;
use self::server_api::IndexHandler;
use self::server_api::KernelDownloadHandler;
use self::server_api::StatusHandler;
use self::transactions_api::TxHashSetHandler;
use self::version_api::VersionHandler;
@ -365,9 +364,6 @@ pub fn build_router(
peers: Arc::downgrade(&peers),
sync_state: Arc::downgrade(&sync_state),
};
let kernel_download_handler = KernelDownloadHandler {
peers: Arc::downgrade(&peers),
};
let txhashset_handler = TxHashSetHandler {
chain: Arc::downgrade(&chain),
};
@ -402,7 +398,6 @@ pub fn build_router(
router.add_route("/v1/chain/validate", Arc::new(chain_validation_handler))?;
router.add_route("/v1/txhashset/*", Arc::new(txhashset_handler))?;
router.add_route("/v1/status", Arc::new(status_handler))?;
router.add_route("/v1/kerneldownload", Arc::new(kernel_download_handler))?;
router.add_route("/v1/pool", Arc::new(pool_info_handler))?;
router.add_route("/v1/pool/push_tx", Arc::new(pool_push_handler))?;
router.add_route("/v1/peers/all", Arc::new(peers_all_handler))?;

25
api/src/handlers/server_api.rs
View file

@ -19,7 +19,7 @@ use crate::rest::*;
use crate::router::{Handler, ResponseFuture};
use crate::types::*;
use crate::web::*;
use hyper::{Body, Request, StatusCode};
use hyper::{Body, Request};
use serde_json::json;
use std::sync::Weak;
@ -37,29 +37,6 @@ impl Handler for IndexHandler {
}
}
pub struct KernelDownloadHandler {
pub peers: Weak<p2p::Peers>,
}
impl Handler for KernelDownloadHandler {
fn post(&self, _req: Request<Body>) -> ResponseFuture {
if let Some(peer) = w_fut!(&self.peers).most_work_peer() {
match peer.send_kernel_data_request() {
Ok(_) => response(StatusCode::OK, "{}"),
Err(e) => response(
StatusCode::INTERNAL_SERVER_ERROR,
format!("requesting kernel data from peer failed: {:?}", e),
),
}
} else {
response(
StatusCode::INTERNAL_SERVER_ERROR,
"requesting kernel data from peer failed (no peers)".to_string(),
)
}
}
}
/// Status handler. Post a summary of the server status
/// GET /v1/status
pub struct StatusHandler {

31
p2p/src/msg.rs
View file

@ -65,8 +65,6 @@ enum_from_primitive! {
BanReason = 18,
GetTransaction = 19,
TransactionKernel = 20,
KernelDataRequest = 21,
KernelDataResponse = 22,
}
}
@ -104,8 +102,6 @@ fn max_msg_size(msg_type: Type) -> u64 {
Type::BanReason => 64,
Type::GetTransaction => 32,
Type::TransactionKernel => 32,
Type::KernelDataRequest => 0,
Type::KernelDataResponse => 8,
}
}
@ -708,30 +704,3 @@ impl Readable for TxHashSetArchive {
})
}
}
pub struct KernelDataRequest {}
impl Writeable for KernelDataRequest {
fn write<W: Writer>(&self, _writer: &mut W) -> Result<(), ser::Error> {
Ok(())
}
}
pub struct KernelDataResponse {
/// Size in bytes of the attached kernel data file.
pub bytes: u64,
}
impl Writeable for KernelDataResponse {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ser::Error> {
writer.write_u64(self.bytes)?;
Ok(())
}
}
impl Readable for KernelDataResponse {
fn read(reader: &mut dyn Reader) -> Result<KernelDataResponse, ser::Error> {
let bytes = reader.read_u64()?;
Ok(KernelDataResponse { bytes })
}
}

9
p2p/src/peer.rs
View file

@ -30,9 +30,7 @@ use crate::core::pow::Difficulty;
use crate::core::ser::Writeable;
use crate::core::{core, global};
use crate::handshake::Handshake;
use crate::msg::{
self, BanReason, GetPeerAddrs, KernelDataRequest, Locator, Msg, Ping, TxHashSetRequest, Type,
};
use crate::msg::{self, BanReason, GetPeerAddrs, Locator, Msg, Ping, TxHashSetRequest, Type};
use crate::protocol::Protocol;
use crate::types::{
Capabilities, ChainAdapter, Error, NetAdapter, P2PConfig, PeerAddr, PeerInfo, ReasonForBan,
@ -402,11 +400,6 @@ impl Peer {
)
}
pub fn send_kernel_data_request(&self) -> Result<(), Error> {
debug!("Asking {} for kernel data.", self.info.addr);
self.send(&KernelDataRequest {}, msg::Type::KernelDataRequest)
}
/// Stops the peer
pub fn stop(&self) {
debug!("Stopping peer {:?}", self.info.addr);

58
p2p/src/protocol.rs
View file

@ -17,19 +17,18 @@ use crate::conn::{Message, MessageHandler, Tracker};
use crate::core::core::{self, hash::Hash, hash::Hashed, CompactBlock};
use crate::msg::{
BanReason, GetPeerAddrs, Headers, KernelDataResponse, Locator, Msg, PeerAddrs, Ping, Pong,
TxHashSetArchive, TxHashSetRequest, Type,
BanReason, GetPeerAddrs, Headers, Locator, Msg, PeerAddrs, Ping, Pong, TxHashSetArchive,
TxHashSetRequest, Type,
};
use crate::types::{Error, NetAdapter, PeerInfo};
use chrono::prelude::Utc;
use rand::{thread_rng, Rng};
use std::cmp;
use std::fs::{self, File, OpenOptions};
use std::io::{BufWriter, Seek, SeekFrom};
use std::io::BufWriter;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::time::Instant;
use tempfile::tempfile;
pub struct Protocol {
adapter: Arc<dyn NetAdapter>,
@ -266,57 +265,6 @@ impl MessageHandler for Protocol {
Ok(None)
}
Type::KernelDataRequest => {
debug!("handle_payload: kernel_data_request");
let kernel_data = self.adapter.kernel_data_read()?;
let bytes = kernel_data.metadata()?.len();
let kernel_data_response = KernelDataResponse { bytes };
let mut response = Msg::new(
Type::KernelDataResponse,
&kernel_data_response,
self.peer_info.version,
)?;
response.add_attachment(kernel_data);
Ok(Some(response))
}
Type::KernelDataResponse => {
let response: KernelDataResponse = msg.body()?;
debug!(
"handle_payload: kernel_data_response: bytes: {}",
response.bytes
);
let mut writer = BufWriter::new(tempfile()?);
let total_size = response.bytes as usize;
let mut remaining_size = total_size;
while remaining_size > 0 {
let size = msg.copy_attachment(remaining_size, &mut writer)?;
remaining_size = remaining_size.saturating_sub(size);
// Increase received bytes quietly (without affecting the counters).
// Otherwise we risk banning a peer as "abusive".
tracker.inc_quiet_received(size as u64);
}
// Remember to seek back to start of the file as the caller is likely
// to read this file directly without reopening it.
writer.seek(SeekFrom::Start(0))?;
let mut file = writer.into_inner().map_err(|_| Error::Internal)?;
debug!(
"handle_payload: kernel_data_response: file size: {}",
file.metadata().unwrap().len()
);
self.adapter.kernel_data_write(&mut file)?;
Ok(None)
}
Type::TxHashSetRequest => {
let sm_req: TxHashSetRequest = msg.body()?;
debug!(