/builddir/build/BUILD/libutil++-1.4.0/src/sella/server/HTTP.h

/*
** libutil++
** $Id: HTTP.h 1197 2014-10-14 22:26:11Z sella $
** Copyright (c) 2011-2014 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

#ifndef __libutilxx__sella__server__HTTP_H__
#define __libutilxx__sella__server__HTTP_H__

#include "../../common.h"
#include "ServerException.h"
#include "HTTPConnection.h"
#include "../util/Log.h"
#include "../util/ThreadPool.h"
#include "../net/IPAddressPort.h"
#include "../net/SocketMux.h"
#include "../net/SocketTrigger.h"

#include <set>
#include <mutex>
#include <memory>
#include <queue>
#include <vector>
#include <functional>
#include <unordered_set>

namespace sella {
        namespace server {
                class HTTP;
        }

        namespace util {
                class ThreadPool;
        }
}

class sella::server::HTTP {
        public:
                typedef std::shared_ptr<HTTP> shared;
                typedef HTTP *ptr;

                typedef std::function<bool(HTTPConnection::shared)> acl_callback;
                typedef std::function<bool(HTTPConnection::shared)> request_callback;
                typedef std::function<bool(HTTPConnection::shared)> authentication_callback;
                typedef std::function<bool(HTTPConnection::shared, int, const std::string&)> error_callback;

        public:
                static const sella::net::IPAddressPort::vector ListenersDefault; /* 0.0.0.0:80, [::]:80 */
                static const size_t RequestBodyLimitDefault = 25 * 102400;
                static const size_t ConnectionLimitDefault = 256;
                static const size_t DelaySecondsDefault = 7200;
                static const std::string RootDefault; /* "." */
                static const std::vector<std::string> DirectoryIndexesDefault; /* "index.html", "index.htm" */
                static const std::string BannerDefault;
                static const std::set<HTTPRequest::Method> AllowDefault;

        public:
                static const size_t MaximumWorkersDefault = 0; /* 0 to auto assign available core count */
                static const size_t MinimumWorkersDefault = 2;
                static const size_t SpareWorkersDefault = 2; /* Number of non-active workers. */

        public:
                HTTP() throw (ServerException);
                HTTP(sella::util::Log::shared log) throw (ServerException);
                virtual ~HTTP() throw ();

                /* Async */
                virtual bool receive(void) throw (ServerException); /* Process incoming packets return. */
                virtual bool receive(timeval *tv) throw (ServerException); /* Process incoming packets and return. */

                /* Threaded */
                virtual bool run(size_t workers = MaximumWorkersDefault) throw (ServerException); /* Simple blocking non-scaling internal pool */
                virtual void start(size_t workers = MaximumWorkersDefault) throw (ServerException); /* Simple non-blocking non-scaling internal pool */
                virtual void start(size_t maximumWorkers, size_t minimumWorkers, size_t spareWorkers = SpareWorkersDefault) throw (ServerException); /* Auto-scaling non-blocking internal pool */
                virtual void start(sella::util::ThreadPool::shared pool) throw (ServerException); /* Custom non-blocking pool */
                virtual bool stop(void) throw ();

                void setListeners(const sella::net::IPAddressPort::vector &listeners) throw ();
                void setListeners(const std::string &listeners) throw ();
                void setRequestBodyLimit(size_t requestBodyLimit) throw ();
                void setConnectionLimit(size_t connectionLimit) throw ();
                void setRoot(const std::string &root) throw (ServerException);
                void setDirectoryIndex(const std::vector<std::string> &indexes) throw ();
                void addDirectoryIndex(const std::string &index) throw ();
                void setBanner(const std::string &banner) throw ();
                void setCustomHeaders(const std::vector<std::string> &headers) throw ();
                void setAllow(HTTPRequest::Method method) throw ();
                void setACLCallback(const acl_callback &callback) throw ();
                void setAuthenticationCallback(const authentication_callback &callback) throw ();
                void setRequestCallback(const request_callback &callback) throw ();
                void setErrorCallback(const error_callback &callback) throw ();

                sella::net::IPAddressPort::vector getListeners(void) const throw ();
                std::string getListenersString(void) const throw ();
                size_t getRequestBodyLimit(void) const throw ();
                size_t getConnectionLimit(void) const throw ();
                const std::string& getRoot(void) const throw ();
                const std::vector<std::string>& getDirectoryIndexes(void) const throw ();
                const std::string& getBanner(void) const throw ();
                const std::vector<std::string>& getCustomHeaders(void) const throw ();
                std::set<HTTPRequest::Method> getAllow(void) const throw ();
                void clearAllow(HTTPRequest::Method method) throw ();

                bool isRunning(void) const throw ();

        public:
                virtual void clear(void);
                virtual void print(void);

                static const HTTP::shared shared_ptr() throw (ServerException);
                static const HTTP::shared shared_ptr(sella::util::Log::shared log) throw (ServerException);

        protected:
                void startup(void) throw (ServerException);
                void shutdown(void) throw ();
                int select(timeval *tv) throw (ServerException);
                HTTPConnection::shared accept(const sella::net::Socket::shared &socket) throw (ServerException);
                void process(HTTPConnection::shared &connection) throw ();
                void server(void) throw ();
                void worker(HTTPConnection::shared &connection) throw ();

        private:
                sella::util::Log::shared libutilxx__log;
                sella::util::ThreadPool::shared pool;
                sella::net::SocketMux mux;
                std::unordered_set<int> servers;
                std::queue<HTTPConnection::shared> pending;
                bool running;
                std::mutex mutex;
                std::thread manager;
                sella::net::SocketTrigger trigger;

                sella::net::IPAddressPort::vector listeners;
                size_t requestBodyLimit;
                size_t connectionLimit;
                std::string root;
                std::vector<std::string> indexes;
                std::string banner;
                std::vector<std::string> headers;
                std::set<HTTPRequest::Method> allow;

                acl_callback aclCallback;
                authentication_callback authCallback;
                request_callback reqCallback;
                error_callback errorCallback;
};

#endif

/*
** vim: noet ts=3 sw=3
*/

---