io_service.run() blockiert nicht. Der Server wird erstellt und dann sofort geschlossen.

Question

Alle Boost-Beispiele funktionieren, bis ich versuche, genau dasselbe zu implementieren. Ich fange an zu denken, dass es eine Reihenfolge der Erstellung oder des io_service Besitzes geben muss, damit Dinge richtig blockiert werden.

Mein Server-Struktur ist wie folgt:

class Server { 
    public: 
    Server(unsigned short port) 
    : ioService_(), acceptor_(ioService_), socket_(ioService_) { 
     acceptClient(); // begin async accept 
    } 

    void start(); // runs ioService_.run(); 

    private: 

    void acceptClient(); 

    asio::io_service ioService_; 
    tcp::acceptor acceptor_; 
    tcp::socket socket_; 
    Cluster cluster_; // essentially just a connection manager 
}; 

Die acceptClient() Funktion funktioniert wie folgt:

void Server::acceptClient() { 
    acceptor_.async_accept(socket_, [this](const system::error_code& e){ 
    if(!acceptor_.is_open()) return; 
    if(!e) { 
     cluster_.add(std::make_shared<Client>(std::move(socket_), cluster_)); 
    } 

    acceptClient(); 
    }); 
} 

Ich bin mir nicht sicher, ob Sie einen Überblick über die Client-Klasse benötigen, da die Server sollte ausgeführt und blockiert werden, auch ohne Clients.

Die Schaffung des Servers geht wie folgt:

try { 
    Server server(port); 
    server.start(); // this calls the server's member io_service's run(); 
} catch (const std::exception& e) { 
    std::cerr << e.what(); << std::endl; 
} 

Das Problem ist der Server nach dem Anruf sofort schließt. Das Programm startet und beendet sich dann ohne Fehler. Gibt es etwas, auf das io_service.run() angewiesen ist? z.B. irgendeine Form von asynchroner Verbindung, die ich vergessen habe? Ich habe dieses Design von Boost asios http-Serverdesign gelernt, aber ich habe es so entwickelt, dass es zu meinen grundlegenden Zwecken passt. Das Problem ist, dass einige Boost-Beispiele einen neuen Member-Boost tcp :: socket im Client selbst etablieren, anstatt den Server auf den Client zu verschieben, so dass ich ziemlich verwirrt bin. Sie neigen auch dazu, Boost-Versionen von std :: bind anstelle von lambdas usw. zu verwenden.

So kann mir jemand einen kurzen Überblick darüber geben, wie man einen einfachen, stripped, async Server erstellt, da die Boost-Beispiele wirklich verwirrend sind Die Code-Konventionen unterscheiden sich pro Beispiel. Ich habe mich gefragt, ob irgendjemand irgendetwas sofort bemerkt hat, dass mein Server sofort schließen würde.

Danke.

Answer 1

Ich testete async_accept mit dem folgenden Code, der sendet Hallo an Clients, die an den Anschluss anschließen. Zumindest gibt es die Erstellung von endpoint Objekt, acceptor.open(endpoint.protocol()), acceptor.bind(endpoint) und acceptor.listen() Aufrufe, die in Ihrem Code fehlen scheinen.

#include <boost/bind.hpp> 
#include <boost/asio.hpp> 
#include <string> 

using namespace boost::asio; 

void handle_accept(
    io_service * ios, 
    ip::tcp::acceptor * acceptor, 
    ip::tcp::socket * socket, 
    const boost::system::error_code & error) 
{ 
    if (!error) { 
     std::string msg("Hello\n"); 
     socket->send(buffer(msg, msg.length())); 

     ip::tcp::socket * temp = new ip::tcp::socket(*ios); 
     acceptor->async_accept(*temp, 
           boost::bind(handle_accept, 
              ios, acceptor, temp, 
              placeholders::error)); 
    } 
} 

int main(void) 
{ 
    io_service ios; 
    ip::tcp::socket socket(ios); 
    ip::tcp::acceptor acceptor(ios); 
    ip::tcp::endpoint endpoint(ip::tcp::v4(), 1500); 
    acceptor.open(endpoint.protocol()); 
    acceptor.set_option(ip::tcp::acceptor::reuse_address(true)); 
    acceptor.bind(endpoint); 
    acceptor.listen(); 

    acceptor.async_accept(socket, 
          boost::bind(handle_accept, 
             &ios, &acceptor, &socket, 
             placeholders::error)); 
    ios.run(); 

    /* 
    acceptor.accept(socket); 
    std::string msg("Hello\n"); 
    socket.send(buffer(msg, msg.length())); 
    */ 
} 

Eine Version mit einer Server Klasse und eine Lambda als Argument für async_accept:

#include <boost/asio.hpp> 
#include <functional> 
#include <string> 

using namespace boost::asio; 

class Server { 
public: 
    Server(unsigned short port) : ios(), acceptor(ios), socket(ios), 
            endpoint(ip::tcp::v4(), port) { 
     acceptor.open(endpoint.protocol()); 
     acceptor.set_option(ip::tcp::acceptor::reuse_address(true)); 
     acceptor.bind(endpoint); 
     acceptor.listen(); 
     nsocket = &socket; 
    } 

    void run() { 
     std::function<void (const boost::system::error_code &)> f; 
     f = [&f, this] (const boost::system::error_code & error) { 
      if (!error) { 
       std::string msg("Hello\n"); 
       nsocket->send(buffer(msg, msg.length())); 

       nsocket = new ip::tcp::socket(ios); 
       acceptor.async_accept(*nsocket, f); 
      } 
     }; 

     acceptor.async_accept(socket, f); 
     ios.run(); 
    } 

protected: 
    io_service ios; 
    ip::tcp::acceptor acceptor; 
    ip::tcp::socket socket; 
    ip::tcp::endpoint endpoint; 

    ip::tcp::socket * nsocket; 
}; 


int main(void) 
{ 
    Server srv(1500); 
    srv.run(); 
}