Question

我正在尝试开始使用Rust，并尝试将一些部分组合在一起，然后设置一个＆＃34; Server＆＃34;包含Vector＆＃34;客户＆＃34;的实例其中每个人都有一个插座。

据我所知，在Rust中，Socket或TcpStream需要是可变的，并且我需要借用引用以便在主循环中的Client实例化之后保留范围。

但我遇到的问题是我的TcpStream字段在Client结构中可能不可变。所以我不确定我的方法是否正确，但我尝试使用生命周期参数＆lt;＆＃39; a＆gt;来解决这个问题，但是这导致了另一个我的＆＃34;客户端＆＃34;内部＆＃34;服务器＆＃34;没有通过＆lt;＆a;＆gt;终身参数。

有人可以帮我解决这个问题或向我展示解决这个问题/解决方案的正确方法吗？

感谢。

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();
}

更新

当前的错误消息是：

 clients: Vec<Box<Client>>
                  ^^^^^^ expected lifetime parameter

更新2：

现在我认为解决方案更接近目标了。但我仍然遇到线程问题：在静态上下文之外生成。

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();
}

错误[E0477]：类型[closure@src/main.rs:38:23: 40:10 self:&mut Server, client:Client]无法满足所需的生命周期

  --> src/main.rs:38:9
   |
38 |         thread::spawn(move || {
   |         ^^^^^^^^^^^^^
   |
   = note: type must satisfy the static lifetime

Answer 1

我现在能够解决整体问题：

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();
}

Rust struct field for socket

1 个答案: