From cb43facd9e8dafe039731f26a7009ff743721a5b Mon Sep 17 00:00:00 2001 From: Victor Vobis Date: Wed, 27 Aug 2025 23:47:23 +0200 Subject: [PATCH] bless --- out | 4 ++ src/args.rs | 1 + src/main.rs | 1 + src/native_node/message.rs | 6 ++- src/native_node/node.rs | 84 +++++++++++++++----------------------- src/watcher/watcher.rs | 37 ++++++++++++----- 6 files changed, 69 insertions(+), 64 deletions(-) create mode 100644 out diff --git a/out b/out new file mode 100644 index 0000000..52d8fd9 --- /dev/null +++ b/out @@ -0,0 +1,4 @@ +[?1049h┏InputPane━━━━━━━━━━━━━━━━━┓┏OutputPane━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓┃>┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛[?25l[INFO]21:14:03|StartedRenderer[?25l[INFO]21:14:03|StartedParser[?25l[INFO]21:14:03|StartedExecutor[?25l[INFO]21:14:03|StartedNode[?25l[INFO]21:14:03|BuildingChain[?25l[?25l[?25l[?25l[?25l[?25l[?25lc[?25l[?25l[?25l[?25lc[?25l[?25l[?25l [?25l [?25l[?25l[?25l>[?25l[INFO]21:14:08|Exec:Recievedechocommand[?25l[INFO]21:14:08|Parser:Receivedmessagefromwatcher[?25lUsage:Commands:nodeAblockchainnodeCLItoolclearhelpPrintthismessageorthehelpofthegivensubcommand(s)Options:-h,--helpPrinthelp[?25lc[?25l[?25l[?25la[?25l[?25l[?25l[?1049lHello, world! +[DEBUG] [src/watcher/renderer.rs:125] 21:14:11 | Renderer Exit + +[?25h \ No newline at end of file diff --git a/src/args.rs b/src/args.rs index 04da0b7..2b87fee 100644 --- a/src/args.rs +++ b/src/args.rs @@ -4,6 +4,7 @@ use clap::{Parser, Subcommand}; use crate::core; use crate::watcher::RenderPane; + use clap::*; #[derive(Parser)] diff --git a/src/main.rs b/src/main.rs index 9ca76d5..c86badb 100644 --- a/src/main.rs +++ b/src/main.rs @@ -22,6 +22,7 @@ async fn main() { let mut watcher = Watcher::build() .file(args.seed_file) .addr(args.addr) + .seed(args.seed) .bootstrap(args.bootstrap) .start().await; diff --git a/src/native_node/message.rs b/src/native_node/message.rs index 98d552c..6ef85f0 100644 --- a/src/native_node/message.rs +++ b/src/native_node/message.rs @@ -76,7 +76,7 @@ impl node::NativeNode { match message { ProtocolMessage::BootstrapRequest { .. } => { - log!(INFO, "Received BootstrapRequest from {peer_id}"); + self.log(msg!(INFO, "Received BootstrapRequest from {peer_id}")).await; let peer = &self.tcp_peers[&peer_id]; let resp = ProtocolMessage::BootstrapResponse { blocks: self.chain.blocks().to_vec() @@ -84,6 +84,10 @@ impl node::NativeNode { peer.sender.send(resp).await.unwrap(); log!(INFO, "Send BootstrapResponse to {peer_id}"); }, + ProtocolMessage::BootstrapResponse { blocks } => { + self.log(msg!(INFO, "Received BootstrapResponse from seed")).await; + self.chain = core::Blockchain::build(blocks.to_vec()).unwrap(); + }, ProtocolMessage::Ping {peer_id} => { log!(INFO, "Received Ping from {peer_id}"); let resp = ProtocolMessage::Pong { peer_id: self.id.clone() }; diff --git a/src/native_node/node.rs b/src/native_node/node.rs index b46f6f5..c0d9803 100644 --- a/src/native_node/node.rs +++ b/src/native_node/node.rs @@ -55,31 +55,31 @@ impl NativeNode { addr } - pub fn list_peers(&self) { - println!("Peer List\n-----------"); + pub fn list_peers(&self) -> String { + let mut ret = String::from("Peer List\n-----------"); for (i, p) in self.tcp_peers.iter().enumerate() { - println!("Peer #{i}: {}", p.1.id) + ret.push_str(format!("Peer #{i}: {}", p.1.id).as_str()) } + ret } - pub fn show_id(&self) { - println!("Node Id: {}", self.id) + pub async fn show_id(&self) { + self.log(msg!(INFO, "Node Id: {}", self.id)).await } - fn remove_tcp_peer(&mut self, peer_id: Uuid) { - log!(INFO, "Removing Peer {peer_id}"); + async fn remove_tcp_peer(&mut self, peer_id: Uuid) { + self.log(msg!(INFO, "Removing Peer {peer_id}")).await; self.tcp_peers.remove_entry(&peer_id); } - fn add_tcp_peer(&mut self, id: Uuid, addr: SocketAddr, sender: tokio::sync::mpsc::Sender) { + async fn add_tcp_peer(&mut self, id: Uuid, addr: SocketAddr, sender: tokio::sync::mpsc::Sender) { let peer = TcpPeer { id, addr, sender }; - log!(INFO, "Adding Peer {}", peer.id); - + self.log(msg!(INFO, "Added Peer from address: {addr}")).await; self.tcp_peers.insert(id, peer); } @@ -134,53 +134,32 @@ impl NativeNode { } } - pub async fn send_handshake(id: uuid::Uuid, stream: &mut tokio::net::TcpStream) -> Result { - let handshake = ProtocolMessage::Handshake { peer_id: id.clone(), version: "".to_string() }; - NativeNode::send_message(stream, &handshake).await.unwrap(); - if let Ok(response) = NativeNode::receive_message(stream).await { - match response { - message::ProtocolMessage::Handshake { peer_id, version: _ } => { - Ok(peer_id) - }, - _ => { - log!(ERROR, "Invalid response on Handshake"); - Err(ValidationError::InvalidBlockHash) - } + pub async fn send_message_to_peer_addr(&self, addr: SocketAddr, msg: ProtocolMessage) { + if let Some((_, peer)) = self.tcp_peers.iter().find(|(_, v)| v.addr == addr) { + if let Err(e) = peer.sender.send(msg).await { + self.log(msg!(ERROR, "Error Sending message to peer: {e}")).await; + } + } + } + + pub async fn send_message_to_peer_id(&self, id: Uuid, msg: ProtocolMessage) { + if let Some(peer) = self.tcp_peers.get(&id) { + if let Err(e) = peer.sender.send(msg).await { + self.log(msg!(ERROR, "Error Sending message to peer: {e}")).await; } - } else { - Err(ValidationError::InvalidBlockHash) } } pub async fn bootstrap(&mut self) -> Result<(), ValidationError> { self.log(msg!(INFO, "Running As Native Node")).await; - let mut stream = tokio::net::TcpStream::connect(SEED_NODES[0]).await.unwrap(); + self.connect_to_peer(SEED_NODES[0]).await; - let id = uuid::Uuid::new_v4(); + let message = ProtocolMessage::BootstrapRequest{peer_id: self.id, version: "".to_string()}; + self.send_message_to_peer_addr(SEED_NODES[0], message).await; - if let Ok(_) = NativeNode::send_handshake(id, &mut stream).await { - let message = message::ProtocolMessage::BootstrapRequest { peer_id: id.clone(), version: "".to_string() }; - NativeNode::send_message(&mut stream, &message).await.unwrap(); - self.log(msg!(INFO, "Sent BootstrapRequest to seed")).await; - if let Ok(response) = NativeNode::receive_message(&mut stream).await { - match response { - ProtocolMessage::BootstrapResponse { blocks } => { - self.log(msg!(INFO, "Received BootstrapResponse from seed")).await; - self.chain = core::Blockchain::build(blocks).unwrap(); - Ok(()) - }, - _ => { - self.log(msg!(ERROR, "Invalid Response from BootstrapRequest: {:?}", &response)).await; - Err(ValidationError::InvalidBlockHash) - } - } - } else { - Err(ValidationError::InvalidBlockHash) - } - } else { - Err(ValidationError::InvalidBlockHash) - } + self.log(msg!(INFO, "Sent BootstrapRequest to seed")).await; + Ok(()) } pub async fn broadcast_transaction(&self, tx: &core::Tx) { @@ -212,6 +191,7 @@ impl NativeNode { self.listner_handle.as_ref().unwrap().abort(); self.listner_handle = None; } + self.log(msg!(INFO, "Listening on address: {}", addr)).await; if let Ok(tcp_listner) = tokio::net::TcpListener::bind(addr).await { let id = self.id.clone(); @@ -223,7 +203,7 @@ impl NativeNode { }; } - async fn log(&self, msg: String) { + pub async fn log(&self, msg: String) { let _ = self.exec_tx.send(ExecutorCommand::Print(msg)).await; } @@ -254,10 +234,10 @@ impl NativeNode { } } NodeCommand::AddPeer { peer_id, addr, sender } => { - self.add_tcp_peer(peer_id, addr, sender); + self.add_tcp_peer(peer_id, addr, sender).await; }, NodeCommand::RemovePeer { peer_id } => { - self.remove_tcp_peer(peer_id); + self.remove_tcp_peer(peer_id).await; } NodeCommand::ProcessMessage { peer_id, message } => { self.process_message(peer_id, &message).await; @@ -281,7 +261,7 @@ impl NativeNode { }, NodeCommand::ShowId => { self.log(msg!(INFO, "Received DebugListBlocks command")).await; - self.show_id(); + self.show_id().await; }, NodeCommand::DumpBlocks(s) => { self.chain.dump_blocks(s); diff --git a/src/watcher/watcher.rs b/src/watcher/watcher.rs index 40ea6ab..9c7cacb 100644 --- a/src/watcher/watcher.rs +++ b/src/watcher/watcher.rs @@ -17,13 +17,6 @@ pub struct Watcher { handles: Vec> } -#[derive(Default)] -pub struct WatcherBuilder { - addr: Option, - seed_file: Option, - bootstrap: bool -} - impl Watcher { pub fn build() -> WatcherBuilder { WatcherBuilder::new() @@ -97,6 +90,14 @@ impl Watcher { } } +#[derive(Default)] +pub struct WatcherBuilder { + addr: Option, + seed_file: Option, + bootstrap: bool, + seed: bool, +} + impl WatcherBuilder { fn new() -> Self { Self::default() @@ -109,6 +110,7 @@ impl WatcherBuilder { pub fn file(mut self, seed_file: Option) -> Self { self.seed_file = seed_file; + self.seed = true; self } @@ -117,13 +119,18 @@ impl WatcherBuilder { self } + pub fn seed(mut self, seed: bool) -> Self { + self.seed = seed; + self + } + pub async fn log(render_tx: &mpsc::Sender, msg: String) { let rendermsg = RenderCommand::RenderStringToPane { str: msg, pane: RenderPane::CliOutput }; let _ = render_tx.send(rendermsg).await; } - pub async fn start(self) -> Watcher { + pub async fn start(mut self) -> Watcher { let (render_tx, render_rx) = mpsc::channel::(100); let (parser_tx, parser_rx) = mpsc::channel::(100); let (exec_tx, exec_rx) = mpsc::channel::(100); @@ -137,14 +144,22 @@ impl WatcherBuilder { let _ = Self::log(&render_tx, msg!(INFO, "Started Renderer")).await; let blocks = self.seed_file - .as_ref() - .and_then(|path| std::fs::read_to_string(path).ok()) - .and_then(|content| serde_json::from_str(&content).ok()); + .as_ref() + .and_then(|path| std::fs::read_to_string(path).ok()) + .and_then(|content| serde_json::from_str(&content).ok()); + + if self.seed { + self.addr = Some(crate::seeds_constants::SEED_NODES[0]); + } + + let _ = Self::log(&render_tx, msg!(INFO, "Addr: {:?}", self.addr)).await; let mut node = NativeNode::new(self.addr.clone(), blocks, exec_tx.clone()).await; + if self.bootstrap { let _ = node.bootstrap().await; } + let _ = Self::log(&render_tx, msg!(INFO, "Build Node")); let parser_handle = tokio::spawn({