Question

我正在设计一个客户端 - 服务器应用程序，我需要在它们之间使用三个不同的通道。在架构下面，客户端打开与服务器的连接（1），然后服务器在其他端口（2）上打开与客户端的两个连接。

|-----------|                  |-----------|
|           |  (1) port: 8000  |           |
|           |<-----------------|           |
|           |                  |           |
|           |                  |           |
|  Server   |  (2) port: 8001  |  Client   |
|           |----------------->|           |
|           |                  |           |
|           |  (2) port: 8002  |           |
|           |----------------->|           |
|-----------|                  |-----------|

一个简单的频道服务器示例：http://www.boost.org/doc/libs/1_55_0/doc/html/boost_asio/example/cpp11/echo/async_tcp_echo_server.cpp

我的问题是如何基于boost.asio框架实现这一点？或者，如何从服务器打开新连接（2）？

P.S。也许一个更好的协议可能是在第一个建立时从客户端打开另外两个连接？但是在这种情况下asio中可能使用的结构是什么？

提前多多感谢！

Answer 1

正如已经指出的那样，任何需要健壮的系统都不应该假设路由/防火墙可以使连接从服务器返回到客户端。

我们如何解决这个问题？

客户端连接到服务器：8000
服务器以会话UID响应
客户端负责连接另外两个＆＃34;频道＆＃34;，使用会话UID作为相关ID

这很简单，但需要一个有线协议来协调会话和频道＆＃34;角色＆＃34;用于连接。我最初选择不将其作为演示来实现。相反，我认为学习Boost Asio是一个很好的练习，并且在原始绘图中实现了反向通道（从服务器端启动）。

完整代码在github上：https://gist.github.com/sehe/9946161

注意：

有一个＆＃39;将军＆＃39;监听器实现，用于服务器（端口8000）和＆＃34;反向通道＆＃34; （港口8001,8002）。请参阅listener.hpp
我选择 stackless coroutine 方法。这需要Boost Asio 1.54
至少在我看来，这种方法导致shared_ptr<>的相对滥用。原因是如果协程（也是完成仿函数）可以复制而没有任何问题，这是非常有益的。我可以通过使类本身enable_shared_from_this并将其绑定到shared_from_this来清理它。现在的好处是（几乎）没有bind - 表达式。

创建＆＃39;反向频道＆＃39;在服务器类which overrides on_accept中完成：

virtual bool on_accept(tcp::socket& socket) override
{
    auto host = socket.remote_endpoint().address().to_string();
    // for now setting up the back-connections is all synchronous -
    // that might not work well in practice (scaling, latency) but...
    try
    {
        tcp::resolver resolver(socket.get_io_service());
        auto ep1 = resolver.resolve(tcp::resolver::query(host, "8001"));
        auto ep2 = resolver.resolve(tcp::resolver::query(host, "8002"));

        backsock1 = make_shared<tcp::socket>(socket.get_io_service());
        backsock2 = make_shared<tcp::socket>(socket.get_io_service());

        backsock1->connect(*ep1);
        backsock2->connect(*ep2);

        std::cerr << "on_accept: back channels connected for " << host << "\n";
    } catch(std::exception const& e)
    {
        std::cerr << "on_accept: '" << e.what() << "' for " << host << "\n";
        return false;
    }

    return base_type::on_accept(socket);
}

如果on_accept失败（例如，我们的服务器无法连接反向通道），则会在＆＃34; main＆＃34;上返回错误。套接字（初始连接）和会话中止

有三个程序：

run_server（侦听端口8000）
run_client（连接到端口8000并侦听8001,8002），并发送1条消息。您可以通过连接反向通道并在所有三个插槽上发送不同的消息来观察服务器如何响应。

test（结合了两者）：

#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include "server.hpp"
#include "client.hpp"

int main()
{
    boost::asio::io_service svc;

    // start service on a separate thread
    boost::thread th([&svc] { 
            svc.post(demo::server(svc));
            svc.run(); 
            });

    boost::this_thread::sleep_for(boost::chrono::milliseconds(500)); // allow server to start accepting

    // post client traffic to the service
    std::cerr << "Starting a test client that sends a message...\n";
    demo::client client(svc, "localhost", "8000");

    // await interrupt (or new connections)
    th.join();
}

最后一个程序的输出如下：

Starting a test client that sends a message...
on_accept: back channels connected for 127.0.0.1
listener 127.0.0.1:8000: accepting connection from 127.0.0.1:40999
listener 127.0.0.1:8000: 'hello world from demo client' received from 127.0.0.1:40999
listener 127.0.0.1:8001: accepting connection from 127.0.0.1:40132
listener 127.0.0.1:8002: accepting connection from 127.0.0.1:37970
listener 127.0.0.1:8001: 'We've received a request of length 29' received from 127.0.0.1:40132
listener 127.0.0.1:8002: 'We're handling it in void demo::server::do_back_chatter(const string&)' received from 127.0.0.1:37970
listener 127.0.0.1:40999: 'ECHO hello world from demo client' received from 127.0.0.1:8000

boost.asio：多端口应用层协议

1 个答案: