kernel: use SocketAddr instead of &str

This is easier to copy around and seems to be more informative.

Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2020-07-13 19:39:22 +08:00
parent 8f74159674
commit b388d2e1f4
3 changed files with 49 additions and 43 deletions

View file

@ -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<String> = RefCell::new(DEFAULT_LISTEN_ADDRESS.to_owned()));
use std::net::{SocketAddr, IpAddr, Ipv4Addr};
thread_local!(static NETWORK_LISTEN_ADDRESS: RefCell<SocketAddr> = 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<ThreadMessage>)
}
fn listen_thread(
listen_addr: String,
listen_addr: SocketAddr,
chn: Sender<ThreadMessage>,
backchannel: Receiver<BackchannelMessage>,
) {
@ -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));

View file

@ -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<conn> 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");

View file

@ -6,14 +6,16 @@ use std::thread_local;
use crate::Result;
thread_local!(static NETWORK_CONNECT_ADDRESS: RefCell<String> = RefCell::new("localhost:9687".to_owned()));
use std::net::{SocketAddr, IpAddr, Ipv4Addr};
thread_local!(static NETWORK_CONNECT_ADDRESS: RefCell<SocketAddr> = RefCell::new(SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080)));
thread_local!(static XOUS_SERVER_CONNECTION: RefCell<Option<TcpStream>> = 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);
});
}