1  //! Network command implementations.
  2  
  3  use acdc_core::Result;
  4  use acdc_network::{default_ports, NetworkManager};
  5  
  6  /// Run network diagnostics.
  7  pub async fn diagnostics(port: Option<u16>, json: bool) -> Result<()> {
  8      let api_port = port.unwrap_or(default_ports::ALPHA_REST);
  9      let manager = NetworkManager::local(api_port);
 10  
 11      println!("Running network diagnostics...\n");
 12      let diag = manager.diagnostics().await?;
 13  
 14      if json {
 15          let output = serde_json::to_string_pretty(&diag)
 16              .map_err(|e| acdc_core::Error::Network(format!("JSON serialization failed: {}", e)))?;
 17          println!("{}", output);
 18      } else {
 19          println!("{}", diag.format());
 20      }
 21  
 22      Ok(())
 23  }
 24  
 25  /// List connected peers.
 26  pub async fn peers_list(port: Option<u16>, json: bool) -> Result<()> {
 27      let api_port = port.unwrap_or(default_ports::ALPHA_REST);
 28      let manager = NetworkManager::local(api_port);
 29  
 30      let peers = manager.peers().list().await?;
 31  
 32      if json {
 33          let output = serde_json::to_string_pretty(&peers)
 34              .map_err(|e| acdc_core::Error::Network(format!("JSON serialization failed: {}", e)))?;
 35          println!("{}", output);
 36      } else {
 37          println!("{}", acdc_network::peers::format_peer_list(&peers));
 38      }
 39  
 40      Ok(())
 41  }
 42  
 43  /// Get peer count.
 44  pub async fn peers_count(port: Option<u16>) -> Result<()> {
 45      let api_port = port.unwrap_or(default_ports::ALPHA_REST);
 46      let manager = NetworkManager::local(api_port);
 47  
 48      let count = manager.peers().count().await?;
 49      println!("Connected peers: {}", count);
 50  
 51      Ok(())
 52  }
 53  
 54  /// Connect to a peer.
 55  pub async fn peers_connect(address: String, port: Option<u16>) -> Result<()> {
 56      let api_port = port.unwrap_or(default_ports::ALPHA_REST);
 57      let manager = NetworkManager::local(api_port);
 58  
 59      println!("Connecting to {}...", address);
 60      manager.peers().connect(&address).await?;
 61      println!("Connected to {}", address);
 62  
 63      Ok(())
 64  }
 65  
 66  /// Disconnect from a peer.
 67  pub async fn peers_disconnect(address: String, port: Option<u16>) -> Result<()> {
 68      let api_port = port.unwrap_or(default_ports::ALPHA_REST);
 69      let manager = NetworkManager::local(api_port);
 70  
 71      println!("Disconnecting from {}...", address);
 72      manager.peers().disconnect(&address).await?;
 73      println!("Disconnected from {}", address);
 74  
 75      Ok(())
 76  }
 77  
 78  /// Ping a peer.
 79  pub async fn ping(address: String) -> Result<()> {
 80      println!("Pinging {}...", address);
 81  
 82      let manager = NetworkManager::local(default_ports::ALPHA_REST);
 83      let latency = manager.ping(&address).await?;
 84  
 85      println!(
 86          "Reply from {}: time={:.2}ms",
 87          address,
 88          latency.as_secs_f64() * 1000.0
 89      );
 90  
 91      Ok(())
 92  }
 93  
 94  /// Check port status.
 95  pub async fn ports(role: Option<String>, json: bool) -> Result<()> {
 96      let checks = if let Some(role) = role {
 97          acdc_network::ports::check_role_ports(&role)
 98      } else {
 99          // Check all standard ports
100          acdc_network::ports::check_role_ports("validator")
101      };
102  
103      if json {
104          let output = serde_json::to_string_pretty(&checks)
105              .map_err(|e| acdc_core::Error::Network(format!("JSON serialization failed: {}", e)))?;
106          println!("{}", output);
107      } else {
108          println!("{}", acdc_network::ports::format_port_checks(&checks));
109      }
110  
111      Ok(())
112  }
113  
114  /// Get sync status.
115  pub async fn sync_status(port: Option<u16>, json: bool) -> Result<()> {
116      let api_port = port.unwrap_or(default_ports::ALPHA_REST);
117      let manager = NetworkManager::local(api_port);
118  
119      let status = manager.sync_status().await?;
120  
121      if json {
122          let output = serde_json::to_string_pretty(&status)
123              .map_err(|e| acdc_core::Error::Network(format!("JSON serialization failed: {}", e)))?;
124          println!("{}", output);
125      } else {
126          println!("{}", status.format());
127      }
128  
129      Ok(())
130  }
131  
132  /// Get external IP.
133  pub async fn external_ip() -> Result<()> {
134      let manager = NetworkManager::local(default_ports::ALPHA_REST);
135      let ip = manager.external_ip().await?;
136      println!("External IP: {}", ip);
137      Ok(())
138  }
139  
140  /// Get local IP.
141  pub async fn local_ip() -> Result<()> {
142      let manager = NetworkManager::local(default_ports::ALPHA_REST);
143      let ip = manager.local_ip()?;
144      println!("Local IP: {}", ip);
145      Ok(())
146  }