Rust struct field mutable for socket - sockets

Question

I am trying to get started with Rust, and was trying to put some pieces together and have a "Server" instance which contains a Vector of "Clients" where each of them have a Socket.
I understand that in Rust the Socket or TcpStream needs to be mutable, and that I need to borrow the reference in order to keep the scope after the Client instantiation in my main loop.
But I faced the issue that my TcpStream field may not be mutable in the Client struct. So I am not sure my approach is correct, but I tried to solve this using the lifetime parameter <'a>, however this leads me to another problem where my "Client" inside "Server" does not pass the <'a> lifetime parameter.
Can someone help me solve this problem or show me the correct approach to this problem / solution?
Thanks.
use std::net::*;
use std::io::Write;
use std::thread;
use std::time::Duration;
struct Client<'a> {
socket: &'a mut TcpStream,
addr: SocketAddr
}
struct Server {
clients: Vec<Box<Client>>
}
impl Server {
pub fn new() -> Server {
Server{clients: Vec::new()}
}
fn write(&self, stream: &mut TcpStream) {
let mut counter: u32 = 0;
counter += 1;
stream.write(counter.to_string().as_bytes()).unwrap();
thread::sleep(Duration::from_secs(1));
}
fn client_thread(&self, client: &mut Client) {
self.write(&mut client.socket);
}
fn add_client(&self, socket: &mut TcpStream, addr: SocketAddr) {
let mut client = Client {
socket: socket,
addr: addr
};
self.clients.push(Box::new(client));
self.client_thread(&mut client);
}
pub fn server_loop(&self) {
let listener = TcpListener::bind("127.0.0.1:5001").unwrap();
loop {
match listener.accept() {
Ok((mut socket, addr)) => {
println!("new client: {:?}", addr);
thread::spawn(move || loop {
self.add_client(&mut socket, addr);
});
},
Err(e) => println!("couldn't get client: {:?}", e),
}
}
}
}
fn main() {
let mut server = Server::new();
server.server_loop();
}
Update:
The current error message is:
clients: Vec<Box<Client>>
^^^^^^ expected lifetime parameter
Update 2:
Now I think the solution is a little bit better / closer to the goal. But I still have a problem with the thread:spawn outside static context.
use std::net::*;
use std::io::Write;
use std::thread;
struct Client {
socket: TcpStream
}
struct Server {
clients: Vec<Box<Client>>
}
impl Server {
fn new() -> Server {
Server{clients: vec![]}
}
fn write(&mut self, stream: &mut TcpStream) {
let mut counter: u32 = 0;
stream.write(counter.to_string().as_bytes()).unwrap();
}
fn client_loop(&mut self, client: &mut Client) {
loop {
self.write(&mut client.socket);
}
}
fn add_client(&mut self, s: TcpStream) {
let mut client = Client{
socket: s
};
self.clients.push(Box::new(client));
println!("New client: {}", client.socket.peer_addr().unwrap());
thread::spawn(move || {
self.client_loop(&mut client);
});
}
pub fn server_loop(&mut self) {
let listener = TcpListener::bind("127.0.0.1:5001").unwrap();
loop {
match listener.accept() {
Ok((socket, _addr)) => {
self.add_client(socket);
},
Err(e) => println!("Couldn't get client: {}", e),
}
}
}
}
fn main() {
let mut server = Server::new();
server.server_loop();
}
error[E0477]: the type [closure#src/main.rs:38:23: 40:10 self:&mut Server, client:Client] does not fulfill the required lifetime
--> src/main.rs:38:9
|
38 | thread::spawn(move || {
| ^^^^^^^^^^^^^
|
= note: type must satisfy the static lifetime

Answer 1

I was able to solve the overall problem now:
use std::net::*;
use std::io::Write;
use std::thread;
struct Client {
socket: TcpStream,
}
impl Client {
pub fn write(&mut self) {
let counter: u32 = 0;
self.socket.write(counter.to_string().as_bytes()).unwrap();
}
}
struct ClientThread {
inner: Client,
}
impl ClientThread {
pub fn client_loop(&mut self) {
let client = &mut self.inner;
client.write();
}
}
struct Server {
_clients: Vec<Box<Client>>,
}
impl Server {
fn new() -> Server {
Server { _clients: vec![] }
}
fn add_client(&mut self, s: TcpStream) {
let client = Client { socket: s };
println!("New client: {}", client.socket.peer_addr().unwrap());
self._clients.push(Box::new(client));
let mut client_thread = ClientThread { inner: client };
thread::spawn(move || loop {
client_thread.client_loop();
});
}
pub fn server_loop(&mut self) {
let listener = TcpListener::bind("127.0.0.1:5001").unwrap();
loop {
match listener.accept() {
Ok((socket, _addr)) => {
self.add_client(socket);
}
Err(e) => println!("Couldn't get client: {}", e),
}
}
}
}
fn main() {
let mut server = Server::new();
server.server_loop();
}