···1010pub mod accounts;
1111pub mod chats;
1212pub mod health;
1313+pub mod network;
1314pub mod storage;
1415// Entrypoint of the core
1516pub fn init() -> Result<()> {
+29
tiles/src/core/network.rs
···11+//! The main module for networking
22+33+use anyhow::Result;
44+use iroh::{Endpoint, protocol::Router};
55+use iroh_ping::Ping;
66+77+// Entrypoint of network connection
88+pub async fn init() -> Result<()> {
99+ let endpoint = Endpoint::bind().await?;
1010+ endpoint.online().await;
1111+1212+ let ping = Ping::new();
1313+1414+ let recv_router = Router::builder(endpoint)
1515+ .accept(iroh_ping::ALPN, ping)
1616+ .spawn();
1717+1818+ let addr = recv_router.endpoint().addr();
1919+2020+ println!("{:?}", addr);
2121+2222+ // create a send side & send a ping
2323+ let send_ep = Endpoint::bind().await?;
2424+ let send_pinger = Ping::new();
2525+ let rtt = send_pinger.ping(&send_ep, addr).await?;
2626+2727+ println!("ping took: {:?} to complete", rtt);
2828+ Ok(())
2929+}
+37-14
tiles/src/daemon.rs
···1313use std::sync::Mutex;
1414use tokio::sync::oneshot::{self, Receiver};
15151616-use crate::utils::config::{ConfigProvider, DefaultProvider};
1616+use crate::{
1717+ core::network,
1818+ utils::config::{ConfigProvider, DefaultProvider},
1919+};
17201821struct AppState {
1922 pub shutdown_sender: Mutex<Option<oneshot::Sender<bool>>>,
2023}
21242222-pub async fn start_cmd() -> Result<()> {
2525+const DEFAULT_PORT: u32 = 1729;
2626+pub async fn start_cmd(port: Option<u32>) -> Result<()> {
2327 if cfg!(debug_assertions) {
2424- start_server().await
2828+ start_server(port).await
2529 } else {
2630 start_daemon().await
2731 }
2832}
29333034pub async fn stop_cmd() -> Result<()> {
3131- stop_server().await
3535+ stop_server(None).await
3236}
3337async fn root() -> &'static str {
3438 "Its me luttappi"
···6266 wait_until_server_is_up().await
6367}
64686565-pub async fn start_server() -> Result<()> {
6969+pub async fn start_server(port: Option<u32>) -> Result<()> {
7070+ let dyn_port: u32 = get_port(port);
7171+6672 let (shutdown_tx, shutdown_rx) = oneshot::channel::<bool>();
67736874 let state = AppState {
···7278 let app = Router::new()
7379 .route("/", get(root))
7480 .route("/shutdown", get(shutdown))
8181+ .route("/link/ping", get(send_ping))
7582 .with_state(shared_state);
76837777- let listener = tokio::net::TcpListener::bind("127.0.0.1:1729").await?;
8484+ let addr = format!("127.0.0.1:{}", dyn_port);
8585+ let listener = tokio::net::TcpListener::bind(addr).await?;
78867979- println!("Daemon server started at 1729");
8787+ println!("Daemon server started at {}", dyn_port);
8088 let _ = axum::serve(listener, app)
8189 .with_graceful_shutdown(shutdown_signal(shutdown_rx))
8290 .await;
···95103 let _ = sender_real.send(true);
96104}
971059898-async fn stop_server() -> Result<()> {
106106+async fn send_ping(State(_state): State<Arc<AppState>>) {
107107+ println!("Trying to send ping");
108108+ let _ = network::init().await;
109109+}
110110+111111+async fn stop_server(port: Option<u32>) -> Result<()> {
112112+ let dyn_port = get_port(port);
99113 let client = Client::new();
100100- let res = client.get("http://127.0.0.1:1729/shutdown").send().await;
114114+ let addr = format!("http://127.0.0.1:{}/shutdown", dyn_port);
115115+ let res = client.get(addr).send().await;
101116102117 match res {
103118 Err(err) => Err(anyhow!("Daemon shutdown failed due to {:?}", err)),
···135150 }
136151}
137152153153+fn get_port(port: Option<u32>) -> u32 {
154154+ if let Some(port_number) = port {
155155+ port_number
156156+ } else {
157157+ DEFAULT_PORT
158158+ }
159159+}
160160+138161#[cfg(test)]
139162mod tests {
140163 use anyhow::Result;
···146169 #[serial]
147170 async fn test_sever_process_started_not_server() -> Result<()> {
148171 tokio::spawn(async move {
149149- let _ = start_server().await;
172172+ let _ = start_server(None).await;
150173 });
151174 assert!(ping().await.is_err());
152152- stop_server().await
175175+ stop_server(None).await
153176 }
154177155178 #[tokio::test]
156179 #[serial]
157180 async fn test_sever_process_and_server_started() -> Result<()> {
158181 tokio::spawn(async move {
159159- let _ = start_server().await;
182182+ let _ = start_server(None).await;
160183 });
161184 wait_until_server_is_up().await?;
162185 assert!(ping().await.is_ok());
163186164164- stop_server().await
187187+ stop_server(None).await
165188 }
166189167190 #[tokio::test]
168191 #[serial]
169192 async fn stop_server_but_server_not_up() {
170170- assert!(stop_server().await.is_err())
193193+ assert!(stop_server(None).await.is_err())
171194 }
172195}