eiennet_httpserv.hpp

浏览该文件的文档.

#ifndef __HTTPSERV_HPP__
#define __HTTPSERV_HPP__

#pragma once

namespace eiennet
{

class StaticFileMemoryCache
{
public:
    struct CacheItem
    {
        time_t timeStamp;
        winux::String mime;
        winux::Buffer content;
    };

    // map< name, cache_item >
    typedef std::map< winux::String, CacheItem > CacheItemsMap;

    // 构造函数
    StaticFileMemoryCache( time_t lifeTime = 0 ) : _cacheLifeTime(lifeTime), _mtxCache(true)
    {
    }

    bool hasCache( winux::String const & cacheName ) const
    {
        if ( this->_cacheLifeTime < 1 ) //如果未开启缓存功能，直接返回false
        {
            return false;
        }
        if ( true )
        {
            winux::ScopeGuard guard( const_cast<winux::RecursiveMutex &>(_mtxCache) );
            if ( winux::isset( this->_cacheItems, cacheName ) ) // 存在缓存
            {
                time_t cacheFileMTime = this->_cacheItems.at(cacheName).timeStamp; //取得最后修改时间
                if ( cacheFileMTime + this->_cacheLifeTime >= winux::GetUtcTime() ) // 尚未过期
                {
                    return true;
                }
            }
        }
        return false;
    }

    CacheItem const & get( winux::String const & cacheName ) const
    {
        winux::ScopeGuard guard( const_cast<winux::RecursiveMutex &>(_mtxCache) );
        return this->_cacheItems.at(cacheName);
    }

    CacheItem & writeCache( winux::String const & cacheName, winux::String mime, winux::Buffer content )
    {
        CacheItem * item = nullptr;
        if ( true )
        {
            winux::ScopeGuard guard( const_cast<winux::RecursiveMutex &>(_mtxCache) );
            item = &this->_cacheItems[cacheName];
            item->timeStamp = winux::GetUtcTime();
            item->mime = std::move(mime);
            item->content = std::move(content);
        }
        return *item;
    }

    void setLifeTime( winux::uint64 lifeTime = 0 )
    {
        this->_cacheLifeTime = lifeTime;
    }

    winux::uint64 getLifeTime() const
    {
        return this->_cacheLifeTime;
    }
private:
    time_t _cacheLifeTime; // 缓存生命期 0表示不缓存
    CacheItemsMap _cacheItems;
    winux::RecursiveMutex _mtxCache;
};

struct EIENNET_DLL HttpServerConfig
{
    winux::ConfigureSettings const * confSettings;

    winux::String serverName;
    winux::String serverIp;
    winux::ushort serverPort;
    int listenBacklog;
    int threadCount;
    double serverWait;
    double verboseInterval;
    bool verbose;
    int retryCount;
    int sockTimeout;

    winux::String documentRoot;
    winux::StringArray documentIndex;
    winux::StringStringMap errorPages;
    int cacheLifeTime;

    std::map< winux::String, winux::String > mime; // MIME

    HttpServerConfig();

    HttpServerConfig( winux::ConfigureSettings const & settings );

    HttpServerConfig(
        winux::ConfigureSettings const * settings,
        eiennet::ip::EndPoint const & ep,
        int threadCount = 4,
        int backlog = 0,
        double serverWait = 0.002,
        double verboseInterval = 0.01,
        bool verbose = true,
        int cacheLifeTime = 86400
    );

    bool init( winux::ConfigureSettings const & settings );

    bool init(
        winux::ConfigureSettings const * settings,
        eiennet::ip::EndPoint const & ep,
        int threadCount = 4,
        int backlog = 0,
        double serverWait = 0.002,
        double verboseInterval = 0.01,
        bool verbose = true,
        int cacheLifeTime = 86400
    );

    winux::String getMime( winux::String const & extName ) const;

    void initMime();
};


namespace old_v1
{
struct EIENNET_DLL HttpServerConfig
{
    winux::Configure const * constConfObj; // 可能为nullptr
    winux::String serverIp;
    winux::ushort serverPort;
    winux::String documentRoot;
    winux::String documentIndex;
    bool outputVerbose;
    int listenBacklog;
    int threadCount;
    double durationSec;
    int retryCount;
    int cacheLifeTime;

    std::map< winux::String, winux::String > mime; // MIME

    HttpServerConfig( winux::Configure const & confObj );
    HttpServerConfig( winux::String const & serverIp, winux::ushort port, int threadCount, int listenBacklog, double durationSec );

    winux::String getMime( winux::String const & extName ) const;
    void initMimeList();
};

class HttpClientCtx : public ClientCtx
{
public:
    HttpClientCtx( winux::uint64 clientId, winux::String clientEpStr, winux::SharedPointer<ip::tcp::Socket> clientSockPtr )
        : ClientCtx( clientId, clientEpStr, clientSockPtr ), url(http::Url::urlSimple), config(nullptr)
    {
    }
    virtual ~HttpClientCtx()
    {
        if ( !this->config || this->config->outputVerbose )
            ColorOutput( winux::fgPurple, "Client[", clientId, "]客户场景`", clientEpStr, "`析构" );
    }
    DataRecvSendCtx forClient; // 数据收发场景
    winux::AnsiString requestHeaderStr;   // 请求头字符串
    http::Header requestHeader;    // 请求头
    winux::GrowBuffer requestBody; // 请求体数据
    http::Url url; // URL
    HttpServerConfig * config; // 引用配置对象
};

class EIENNET_DLL HttpServer : public Server<HttpClientCtx>
{
public:
    HttpServerConfig config; 

    #define RESPONSE_HANDLER_PARAMS eiennet::old_v1::HttpServer::ClientCtxSharedPointer & clientCtxPtr, http::Header const & reqHdr, http::Url const & url, http::Header & rspHdr, std::ostream & rspOut
    using ResponseHandlerFunction = std::function< void ( RESPONSE_HANDLER_PARAMS ) >;

    HttpServer( HttpServerConfig const & confObj );
    HttpServer( winux::String const & serverIp, winux::ushort port, int threadCount = 4, int listenBacklog = 10, double durationSec = 0.1 );
    void setHandler( winux::String const & urlPath, ResponseHandlerFunction handler ) { _handlers[urlPath] = handler; }

protected:
    // 业务启动函数
    virtual void onStartup( ClientCtxSharedPointer clientCtxPtr ) override;

    // 尝试接收一个请求头的任务
    void _doRecvRequestHeaderTask( ClientCtxSharedPointer clientCtxPtr );

    // 尝试接收一个请求体的任务
    void _doRecvRequestBodyTask( ClientCtxSharedPointer clientCtxPtr );

    // 处理一个请求的任务
    void _doRequestTask( ClientCtxSharedPointer clientCtxPtr );

    // Web逻辑处理
    void _webProcess( ClientCtxSharedPointer & clientCtxPtr, http::Header const & reqHdr, http::Url const & url, http::Header & rspHdr, std::ostream & rspOut );

private:
    std::map< winux::String, ResponseHandlerFunction > _handlers; // 响应处理函数
    StaticFileMemoryCache _cache; // 静态文件内存缓存

    friend class HttpClientCtx;
};

} // namespace old_v1

} // namespace eiennet

#endif // __HTTPSERV_HPP__