Poco:: Net Server & Client TCP Connection Обработчик событий

Я начинаю новый проект и в то же время открыла библиотеку Poco, которую я нахожу абсолютно потрясающей. Однако я немного потерян, поскольку примеров не много.

У меня есть подход ServerApplication- > TCPServer- > ServerSocket + TCPServerConnectionFactory- > TCPServerconnection, как показано в примерах. Я наследую классы PocoNet в соответствии с инструкциями. Сейчас я могу запустить свой сервер в качестве службы и получать входящие соединения.

Я хочу использовать подход обработки событий к следующему: для каждого соединения (или для каждого клиента) обрабатывать такие события, как данные, доступные для чтения в клиентском сокете, ошибка на клиентском сокете (отключен или тайм-аут), отправлять данные без ошибок в клиентский сокет.

Как мне это сделать? Является ли Poco/Foundation/Events тем, что я ищу, или есть какой-то механизм, реализованный в Poco:: Net?

Я видел Poco:: Net:: NetExpections, но они не отображаются в моем производном классе TCPServerConnection, когда соединение netcat закрывается.

Ответ 1

То, что я закончил использовать, - это другой подход, поскольку TCPServer - совсем другой зверь. После примера, представленного здесь, я закончил класс, наследующий от ServerApplication, и класс, который по существу становится обработчиком соединения с помощью SocketReactor.

Заголовок деамонизатора:

class Daemon : public ServerApplication
{
  public:
    Daemon();
    /// @Brief The main loop of the daemon, everything must take place here
    int main();
};

Реализация деамонизатора:

int Daemon::main()
{
  // Server Socket
  ServerSocket svs(2222);
  // Reactor-Notifier
  SocketReactor reactor;
  Poco::Timespan timeout(2000000); // 2Sec
  reactor.setTimeout(timeout);
  // Server-Acceptor
  SocketAcceptor<ConnectionHandler> acceptor(svs, reactor);
  // Threaded Reactor
  Thread thread;
  thread.start(reactor);
  // Wait for CTRL+C
  waitForTerminationRequest();
  // Stop Reactor
  reactor.stop();
  thread.join();
  return Application::EXIT_OK;  
}

Класс обработчика может быть любым, если он имеет соответствующий конструктор (см. документацию Poco:: Net для этого). В моем случае заголовок выглядит следующим образом:

class ConnectionHandler
{
  public:

    /**
     * @Brief Constructor of the Connection Handler
     * @Note Each object is unique to an accepted connection
     * @Param SteamSocket is the socket accepting the connections
     * @See SocketAcceptor http://pocoproject.org/docs/Poco.Net.SocketAcceptor.html
     * @Param SocketReactor is the reacting engine (threaded) which creates notifications about the socket
     */
    ConnectionHandler(StreamSocket &, SocketReactor &);

    /**
     * @Brief Destructor
     */
    ~ConnectionHandler();

    /**
    * @Brief Event Handler when Socket becomes Readable, i.e: there is data waiting to be read
    */
    void onSocketReadable(const AutoPtr<ReadableNotification>& pNf);

    /**
    * @Brief Event Handler when Socket was written, i.e: confirmation of data sent away (not received by client)
    */
    void onSocketWritable(const AutoPtr<WritableNotification>& pNf);

    /**
    * @Brief Event Handler when Socket was shutdown on the remote/peer side
    */
    void onSocketShutdown(const AutoPtr<ShutdownNotification>& pNf);

    /**
    * @Brief Event Handler when Socket throws an error
    */
    void onSocketError(const AutoPtr<ErrorNotification>& pNf);

    /**
    * @Brief Event Handler when Socket times-out
    */
    void onSocketTimeout(const AutoPtr<TimeoutNotification>& pNf);

  private:

    /**
     * @Brief Read bytes from the socket, depending on available bytes on socket
     */
    void readBytes();

    /**
     * @Brief Send message to the socket
     * @Param std::string is the message (null terminated)
     */
    void sendMessage(std::string);

    /// Stream Socket
    StreamSocket _socket;

    /// Socket Reactor-Notifier
    SocketReactor& _reactor;

    /// Received Data Buffer
    std::vector<char *> in_buffer;
};

Как вы реализуете обработчик, зависит от вас, при условии, что вам нужно только зарегистрировать методы класса, которые обрабатывают такие события:

  _reactor.addEventHandler(_socket,NObserver<ConnectionHandler, ReadableNotification>(*this, &ConnectionHandler::onSocketReadable));
  _reactor.addEventHandler(_socket,NObserver<ConnectionHandler, ShutdownNotification>(*this, &ConnectionHandler::onSocketShutdown));
  _reactor.addEventHandler(_socket,NObserver<ConnectionHandler, ErrorNotification>(*this, &ConnectionHandler::onSocketError));
  _reactor.addEventHandler(_socket,NObserver<ConnectionHandler, TimeoutNotification>(*this, &ConnectionHandler::onSocketTimeout));

В целом, два класса, несколько строк кода, простые и чистые. Абсолютно начинаю любить библиотеку Поко!:)

Ответ 2

Попробуйте следующее:

#include <iostream>
#include "Poco/Net/TCPServer.h"
#include "Poco/Net/TCPServerParams.h"
#include "Poco/Net/TCPServerConnectionFactory.h"
#include "Poco/Net/TCPServerConnection.h"
#include "Poco/Net/Socket.h"
using namespace std;

class newConnection: public Poco::Net::TCPServerConnection {
public:
    newConnection(const Poco::Net::StreamSocket& s) :
        Poco::Net::TCPServerConnection(s) {
    }

    void run() {
        cout << "New connection from: " << socket().peerAddress().host().toString() <<  endl << flush;
        bool isOpen = true;
        Poco::Timespan timeOut(10,0);
        unsigned char incommingBuffer[1000];
        while(isOpen){
            if (socket().poll(timeOut,Poco::Net::Socket::SELECT_READ) == false){
                cout << "TIMEOUT!" << endl << flush;
            }
            else{
                cout << "RX EVENT!!! ---> "   << flush;
                int nBytes = -1;

                try {
                    nBytes = socket().receiveBytes(incommingBuffer, sizeof(incommingBuffer));
                }
                catch (Poco::Exception& exc) {
                    //Handle your network errors.
                    cerr << "Network error: " << exc.displayText() << endl;
                    isOpen = false;
                }


                if (nBytes==0){
                    cout << "Client closes connection!" << endl << flush;
                    isOpen = false;
                }
                else{
                    cout << "Receiving nBytes: " << nBytes << endl << flush;
                }
            }
        }
        cout << "Connection finished!" << endl << flush;
    }
};

int main(int argc, char** argv) {

    //Create a server socket to listen.
    Poco::Net::ServerSocket svs(1234);

    //Configure some server params.
    Poco::Net::TCPServerParams* pParams = new Poco::Net::TCPServerParams();
    pParams->setMaxThreads(4);
    pParams->setMaxQueued(4);
    pParams->setThreadIdleTime(100);

    //Create your server
    Poco::Net::TCPServer myServer(new Poco::Net::TCPServerConnectionFactoryImpl<newConnection>(), svs, pParams);
    myServer.start();

    while(1);

    return 0;
}