class Poco::Net::HTTPServer

Overview

A subclass of TCPServer that implements a full-featured multithreaded HTTP server. More…

#include <HTTPServer.h>

class HTTPServer: public Poco::Net::TCPServer
{
public:
    // construction

    HTTPServer(
        HTTPRequestHandlerFactory::Ptr pFactory,
        Poco::UInt16 portNumber = 80,
        HTTPServerParams::Ptr pParams = new HTTPServerParams
        );

    HTTPServer(
        HTTPRequestHandlerFactory::Ptr pFactory,
        const ServerSocket& socket,
        HTTPServerParams::Ptr pParams
        );

    HTTPServer(
        HTTPRequestHandlerFactory::Ptr pFactory,
        Poco::ThreadPool& threadPool,
        const ServerSocket& socket,
        HTTPServerParams::Ptr pParams
        );

    // methods

    void
    stopAll(bool abortCurrent = false);
};

Inherited Members

public:
    // methods

    virtual
    void
    run() = 0;

    const TCPServerParams&
    params() const;

    void
    start();

    void
    stop();

    int
    currentThreads() const;

    int
    maxThreads() const;

    int
    totalConnections() const;

    int
    currentConnections() const;

    int
    maxConcurrentConnections() const;

    int
    queuedConnections() const;

    int
    refusedConnections() const;

    const ServerSocket&
    socket() const;

    Poco::UInt16
    port() const;

protected:
    // methods

    virtual
    void
    run();

    static
    std::string
    threadName(const ServerSocket& socket);

Detailed Documentation

A subclass of TCPServer that implements a full-featured multithreaded HTTP server.

A HTTPRequestHandlerFactory must be supplied. The ServerSocket must be bound and in listening state.

To configure various aspects of the server, a HTTPServerParams object can be passed to the constructor.

The server supports:

- HTTP/1.0 and HTTP/1.1
- automatic handling of persistent connections.
- automatic decoding/encoding of request/response message bodies
  using chunked transfer encoding.

Please see the TCPServer class for information about connection and thread handling.

See RFC 2616 http://www.faqs.org/rfcs/rfc2616.html for more information about the HTTP protocol.

Construction

HTTPServer(
    HTTPRequestHandlerFactory::Ptr pFactory,
    Poco::UInt16 portNumber = 80,
    HTTPServerParams::Ptr pParams = new HTTPServerParams
    )

Creates HTTPServer listening on the given port (default 80).

The server takes ownership of the HTTPRequstHandlerFactory and deletes it when it’s no longer needed.

New threads are taken from the default thread pool.

HTTPServer(
    HTTPRequestHandlerFactory::Ptr pFactory,
    const ServerSocket& socket,
    HTTPServerParams::Ptr pParams
    )

Creates the HTTPServer, using the given ServerSocket.

The server takes ownership of the HTTPRequstHandlerFactory and deletes it when it’s no longer needed.

The server also takes ownership of the HTTPServerParams object.

New threads are taken from the default thread pool.

HTTPServer(
    HTTPRequestHandlerFactory::Ptr pFactory,
    Poco::ThreadPool& threadPool,
    const ServerSocket& socket,
    HTTPServerParams::Ptr pParams
    )

Creates the HTTPServer, using the given ServerSocket.

The server takes ownership of the HTTPRequstHandlerFactory and deletes it when it’s no longer needed.

The server also takes ownership of the HTTPServerParams object.

New threads are taken from the given thread pool.

Methods

void
stopAll(bool abortCurrent = false)

Stops the server.

In contrast to TCPServer::stop(), which also stops the server, but allows all client connections to finish at their pace, this allows finer control over client connections.

If abortCurrent is false, all current requests are allowed to complete. If abortCurrent is true, the underlying sockets of all client connections are shut down, causing all requests to abort.