From b388d2e1f4a90cb1f3c2b1e7c87a840984065daf Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Mon, 13 Jul 2020 19:39:22 +0800 Subject: [PATCH] kernel: use SocketAddr instead of &str This is easier to copy around and seems to be more informative. Signed-off-by: Sean Cross --- kernel/src/arch/hosted/mod.rs | 21 +++++++----- kernel/src/test/mod.rs | 61 +++++++++++++++++------------------ xous-rs/src/hosted/mod.rs | 10 +++--- 3 files changed, 49 insertions(+), 43 deletions(-) diff --git a/kernel/src/arch/hosted/mod.rs b/kernel/src/arch/hosted/mod.rs index 6cb8ee51c..e0b26ddec 100644 --- a/kernel/src/arch/hosted/mod.rs +++ b/kernel/src/arch/hosted/mod.rs @@ -7,7 +7,7 @@ use std::cell::RefCell; use std::env; use std::io::Read; use std::mem::size_of; -use std::net::{TcpListener, TcpStream}; +use std::net::{TcpListener, TcpStream, ToSocketAddrs}; use std::sync::mpsc::{channel, Receiver, Sender}; use std::thread::spawn; use std::thread_local; @@ -29,15 +29,15 @@ enum BackchannelMessage { NewPid(PID), } -const DEFAULT_LISTEN_ADDRESS: &str = "localhost:9687"; -thread_local!(static NETWORK_LISTEN_ADDRESS: RefCell = RefCell::new(DEFAULT_LISTEN_ADDRESS.to_owned())); +use std::net::{SocketAddr, IpAddr, Ipv4Addr}; +thread_local!(static NETWORK_LISTEN_ADDRESS: RefCell = RefCell::new(SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080))); /// Set the network address for this particular thread. #[cfg(test)] -pub fn set_listen_address(new_address: &str) { +pub fn set_listen_address(new_address: &SocketAddr) { NETWORK_LISTEN_ADDRESS.with(|nla| { let mut address = nla.borrow_mut(); - *address = new_address.to_owned(); + *address = *new_address; }); } @@ -125,7 +125,7 @@ fn handle_connection(mut conn: TcpStream, pid: PID, chn: Sender) } fn listen_thread( - listen_addr: String, + listen_addr: SocketAddr, chn: Sender, backchannel: Receiver, ) { @@ -216,8 +216,13 @@ pub fn idle() -> bool { let (sender, receiver) = channel(); let (backchannel_sender, backchannel_receiver) = channel(); - let listen_addr = env::var("XOUS_LISTEN_ADDR") - .unwrap_or_else(|_| NETWORK_LISTEN_ADDRESS.with(|nla| nla.borrow().clone())); + let listen_addr = env::var("XOUS_LISTEN_ADDR").map(|s| + s + .to_socket_addrs() + .expect("invalid server address") + .next() + .expect("unable to resolve server address")) + .unwrap_or_else(|_| NETWORK_LISTEN_ADDRESS.with(|nla| *nla.borrow())); let listen_thread_handle = spawn(move || listen_thread(listen_addr, sender, backchannel_receiver)); diff --git a/kernel/src/test/mod.rs b/kernel/src/test/mod.rs index 1d5193e3b..6dea9a91e 100644 --- a/kernel/src/test/mod.rs +++ b/kernel/src/test/mod.rs @@ -1,23 +1,27 @@ use crate::kmain; use std::thread::{spawn, JoinHandle}; -use std::net::{TcpStream, ToSocketAddrs}; +use std::net::{SocketAddr, TcpListener, TcpStream, ToSocketAddrs}; use std::sync::mpsc::channel; use std::time::Duration; use xous::{rsyscall, SysCall}; mod shutdown; -fn start_kernel(server_spec: &str) -> JoinHandle<()> { - xous::hosted::set_xous_address(server_spec); +fn start_kernel(server_spec: &str) -> (JoinHandle<()>, SocketAddr) { let server_addr = server_spec .to_socket_addrs() .expect("invalid server address") .next() .expect("unable to resolve server address"); + let temp_server = TcpListener::bind(server_addr).unwrap(); + let server_addr = temp_server.local_addr().unwrap(); + drop(temp_server); + + xous::hosted::set_xous_address(server_addr); // Launch the main thread - let server_spec_server = server_spec.to_owned(); + let server_spec_server = server_addr.clone(); let main_thread = spawn(move || { crate::arch::set_listen_address(&server_spec_server); kmain() @@ -36,7 +40,7 @@ fn start_kernel(server_spec: &str) -> JoinHandle<()> { } // Convert the Option into conn assert!(connected, "unable to connect to server"); - main_thread + (main_thread, server_addr) } #[test] @@ -44,10 +48,10 @@ fn shutdown() { let server_spec = "localhost:9999"; // Start the server in another thread. - let main_thread = start_kernel(server_spec); + let (main_thread, server_spec) = start_kernel(server_spec); // This is now the client. - xous::hosted::set_xous_address(&server_spec); + xous::hosted::set_xous_address(server_spec); // Send a raw `Shutdown` message to terminate the kernel. let call_result = rsyscall(SysCall::Shutdown); @@ -61,13 +65,10 @@ fn shutdown() { fn send_scalar_message() { let server_spec = "localhost:9998"; // Start the server in another thread - let main_thread = start_kernel(server_spec); + let (main_thread, server_spec) = start_kernel(server_spec); xous::hosted::set_xous_address(server_spec); - let xous_client_spec = server_spec.to_owned(); - let xous_server_spec = server_spec.to_owned(); - let (server_addr_send, server_addr_recv) = channel(); // Spawn the server "process" (which just lives in a separate thread) @@ -75,7 +76,7 @@ fn send_scalar_message() { // "Client" what our server ID is. Normally this would be done via // an external nameserver. let xous_server = spawn(move || { - xous::hosted::set_xous_address(&xous_client_spec); + xous::hosted::set_xous_address(server_spec); let sid = xous::create_server(0x7884_3123).expect("couldn't create test server"); server_addr_send.send(sid).unwrap(); let envelope = xous::receive_message(sid).expect("couldn't receive messages"); @@ -93,7 +94,7 @@ fn send_scalar_message() { // Spawn the client "process" and wait for the server address. let xous_client = spawn(move || { - xous::hosted::set_xous_address(&xous_server_spec); + xous::hosted::set_xous_address(server_spec); let sid = server_addr_recv.recv().unwrap(); let conn = xous::connect(sid).expect("couldn't connect to server"); xous::send_message( @@ -123,15 +124,12 @@ fn send_scalar_message() { fn send_move_message() { let server_spec = "localhost:9997"; - let main_thread = start_kernel(server_spec); - - let xous_client_spec = server_spec.to_owned(); - let xous_server_spec = server_spec.to_owned(); + let (main_thread, server_spec) = start_kernel(server_spec); let (server_addr_send, server_addr_recv) = channel(); let xous_server = spawn(move || { - xous::hosted::set_xous_address(&xous_client_spec); + xous::hosted::set_xous_address(server_spec); let sid = xous::create_server(0x7884_3123).expect("couldn't create test server"); server_addr_send.send(sid).unwrap(); let envelope = xous::receive_message(sid).expect("couldn't receive messages"); @@ -152,7 +150,7 @@ fn send_move_message() { }); let xous_client = spawn(move || { - xous::hosted::set_xous_address(&xous_server_spec); + xous::hosted::set_xous_address(server_spec); // println!("CLIENT: Waiting for server address..."); let sid = server_addr_recv.recv().unwrap(); // println!("CLIENT: Connecting to server {:?}", sid); @@ -174,16 +172,11 @@ fn send_move_message() { #[test] fn send_borrow_message() { let server_spec = "localhost:9997"; - - let main_thread = start_kernel(server_spec); - - let xous_client_spec = server_spec.to_owned(); - let xous_server_spec = server_spec.to_owned(); - + let (main_thread, server_spec) = start_kernel(server_spec); let (server_addr_send, server_addr_recv) = channel(); let xous_server = spawn(move || { - xous::hosted::set_xous_address(&xous_client_spec); + xous::hosted::set_xous_address(server_spec); let sid = xous::create_server(0x7884_3123).expect("couldn't create test server"); server_addr_send.send(sid).unwrap(); let envelope = xous::receive_message(sid).expect("couldn't receive messages"); @@ -199,19 +192,25 @@ fn send_borrow_message() { } else { panic!("unexpected message type"); } - - // println!("SERVER: Received message: {:?}", msg); }); let xous_client = spawn(move || { - xous::hosted::set_xous_address(&xous_server_spec); - // println!("CLIENT: Waiting for server address..."); + xous::hosted::set_xous_address(server_spec); + + // Get the server address (out of band) so we know what to connect to let sid = server_addr_recv.recv().unwrap(); - // println!("CLIENT: Connecting to server {:?}", sid); + + // Perform a connection to the server let conn = xous::connect(sid).expect("couldn't connect to server"); + + // Convert the message into a "Carton" that can be shipped as a message let msg = xous::carton::Carton::from_bytes(format!("Hello, world!").as_bytes()); + + // Send the message to the server xous::send_message(conn, xous::Message::Borrow(msg.into_message(0))) .expect("couldn't send a message"); + + // TODO: Assert that we wait for the server to process the message before returning }); xous_server.join().expect("couldn't join server process"); diff --git a/xous-rs/src/hosted/mod.rs b/xous-rs/src/hosted/mod.rs index 3d92b3c9a..12f7004e0 100644 --- a/xous-rs/src/hosted/mod.rs +++ b/xous-rs/src/hosted/mod.rs @@ -6,14 +6,16 @@ use std::thread_local; use crate::Result; -thread_local!(static NETWORK_CONNECT_ADDRESS: RefCell = RefCell::new("localhost:9687".to_owned())); +use std::net::{SocketAddr, IpAddr, Ipv4Addr}; + +thread_local!(static NETWORK_CONNECT_ADDRESS: RefCell = RefCell::new(SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080))); thread_local!(static XOUS_SERVER_CONNECTION: RefCell> = RefCell::new(None)); /// Set the network address for this particular thread. -pub fn set_xous_address(new_address: &str) { +pub fn set_xous_address(new_address: SocketAddr) { NETWORK_CONNECT_ADDRESS.with(|nca| { let mut address = nca.borrow_mut(); - *address = new_address.to_owned(); + *address = new_address; XOUS_SERVER_CONNECTION.with(|xsc| *xsc.borrow_mut() = None); }); } @@ -35,7 +37,7 @@ pub fn _xous_syscall( if xsc.borrow().is_none() { NETWORK_CONNECT_ADDRESS.with(|nca| { println!("Opening connection to Xous server @ {}...", nca.borrow()); - let conn = TcpStream::connect(nca.borrow().as_str()).unwrap(); + let conn = TcpStream::connect(*nca.borrow()).unwrap(); *xsc.borrow_mut() = Some(conn); }); }