5

我使用 mio 在 Rust 中编写了一个多线程异步 HTTP 服务器。当我运行负载测试（使用围攻）时，服务器在第一次负载测试时工作正常，但是当负载测试完成时，对服务器的所有请求都开始失败。

使用一些日志记录，我注意到我获得的每个新连接都会accept()立即收到一个挂断事件。服务器连接本身不会收到任何错误或挂断事件。

我在 OS X 10.11 El Capitan 上运行 Rust 1.12.0 和 mio 0.6

这是我的服务器的主要事件循环：

pub fn run(self) {
    let poll = Poll::new().unwrap();
    let server = TcpListener::bind(&SocketAddr::from_str(&self.host).unwrap()).unwrap();
    poll.register(&server, SERVER, Ready::readable(), PollOpt::edge()).unwrap();
    let mut events = Events::with_capacity(1024);
    let mut next_conn: usize = 1;
    let mut workers = Vec::new();
    // Create worker threads.
    for _ in 0..self.num_workers {
        let (tx, rx) = channel();
        let worker_handler = self.event_handler.duplicate();
        thread::spawn(move || {
            Self::process_events(rx, worker_handler);
        });
        workers.push(tx);
    }
    loop {
        println!("Polling...");
        match poll.poll(&mut events, None) {
            Err(e) => panic!("Error during poll(): {}", e),
            Ok(_) => {}
        }
        for event in events.iter() {
            match event.token() {
                SERVER => {
                    println!("Accepting..");
                    match server.accept() {
                        Ok((stream, _)) => {
                            println!("Registering new connection...");
                            match poll.register(&stream,
                                                Token(next_conn),
                                                Ready::readable(),
                                                PollOpt::edge()) {
                                Err(e) => panic!("Error during register(): {}", e),
                                Ok(_) => {
                                    println!("New connection on worker {} ",
                                             next_conn % self.num_workers);
                                    workers[next_conn % self.num_workers]
                                        .send(Msg::NewConn(next_conn, stream))
                                        .unwrap();
                                    next_conn += 1;
                                }
                            }
                        }
                        Err(e) => panic!("Error during accept() : {}", e),
                    }
                }
                Token(id) => {
                    println!("Sending event on conn {} to worker {}",
                             id,
                             id % self.num_workers);
                    workers[id % self.num_workers]
                        .send(Msg::ConnEvent(id, event.kind()))
                        .unwrap();
                }
            }
        }
    }
}

fn process_events(channel: Receiver<Msg>, mut event_handler: Box<EventHandler>) {
    loop {
        let msg = channel.recv().unwrap();
        match msg {
            Msg::NewConn(id, conn) => {
                event_handler.new_conn(id, conn);
            }
            Msg::ConnEvent(id, event) => {
                event_handler.conn_event(id, event);
            }
        }
    }
}

GitHub 上提供了我正在使用的示例 webapp 的完整代码。

负载测试命令：

siege -b -c10 -d10 -t20S http://localhost:8080
4

1 回答 1

5

我不知道为什么负载测试应用程序没有更好地记录这一点。几个月前我可能遇到了同样的问题。听起来您已经达到了“临时端口限制”。以下是文章中的一些引述，总结了这个想法：

每当在客户端和服务器之间建立连接时，系统都会将该连接绑定到一个临时端口——一组在有效端口范围的高端指定的端口。

OS X 上可用的临时端口总数为 16,383。

请注意，此限制不会影响对实时服务器的实际请求，因为每个 TCP 连接都是由源 IP、源端口、目标 IP 和目标端口的元组定义的——因此临时端口限制仅适用于单个客户端/服务器一对。

换句话说，这是因为您正在从 localhost 到 localhost 运行负载测试，并且在大约 16,383 个连接之后用尽了临时端口。

您可以做几件事来测试这是否是问题所在：

  1. 让您的负载测试器报告建立的连接数。如果它在 16,000 左右，那么这可能是罪魁祸首。

  2. 增加临时端口限制并再次运行负载测试。如果您获得更多连接数，那么这可能就是问题所在。但请记住，如果这是问题所在，那么在野外就不会成为问题。

您可以使用以下命令查看临时端口范围：

$ sysctl net.inet.ip.portrange.first net.inet.ip.portrange.last

您可以使用以下命令增加它：

$ sysctl -w net.inet.ip.portrange.first=32768

运行测试后，您可能应该将端口范围设置回原来的值，因为这种增加代表了非标准范围。

于 2016-10-18T07:22:09.303 回答