transceiver.hpp

Go to the documentation of this file.

/*******************************************************************************
* Copyright (C) 2017 Eddie Carle [eddie@isatec.ca]                             *
*                                                                              *
* This file is part of fastcgi++.                                              *
*                                                                              *
* fastcgi++ is free software: you can redistribute it and/or modify it under   *
* the terms of the GNU Lesser General Public License as  published by the Free *
* Software Foundation, either version 3 of the License, or (at your option)    *
* any later version.                                                           *
*                                                                              *
* fastcgi++ is distributed in the hope that it will be useful, but WITHOUT ANY *
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS    *
* FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for     *
* more details.                                                                *
*                                                                              *
* You should have received a copy of the GNU Lesser General Public License     *
* along with fastcgi++.  If not, see <http://www.gnu.org/licenses/>.           *
*******************************************************************************/

#ifndef FASTCGIPP_TRANSCEIVER_HPP
#define FASTCGIPP_TRANSCEIVER_HPP

#include <map>
#include <list>
#include <queue>
#include <algorithm>
#include <map>
#include <functional>
#include <memory>
#include <atomic>
#include <mutex>
#include <thread>

#include <fastcgi++/protocol.hpp>
#include "fastcgi++/block.hpp"

namespace Fastcgipp
{

    class Transceiver
    {
    public:

        void handler();


        void stop();


        void terminate();


        void start();

        void join();


        void send(const Socket& socket, Block&& data, bool kill);


        Transceiver(
                const std::function<void(Protocol::RequestId, Message&&)>
                sendMessage);

        ~Transceiver();


        bool listen()
        {
            return m_sockets.listen();
        }


        bool listen(
                const char* name,
                uint32_t permissions = 0xffffffffUL,
                const char* owner = nullptr,
                const char* group = nullptr)
        {
            return m_sockets.listen(name, permissions, owner, group);
        }


        bool listen(
                const char* interface,
                const char* service)
        {
            return m_sockets.listen(interface, service);
        }

    private:
        std::map<Socket, Block> m_receiveBuffers;

        struct Record
        {
            const Socket socket;
            const Block data;
            const char* read;
            const bool kill;

            Record(
                    const Socket& socket_,
                    Block&& data_,
                    bool kill_):
                socket(socket_),
                data(std::move(data_)),
                read(data.begin()),
                kill(kill_)
            {}
        };

        std::deque<std::unique_ptr<Record>> m_sendBuffer;

        std::mutex m_sendBufferMutex;

        const std::function<void(Protocol::RequestId, Message&&)> m_sendMessage;

        SocketGroup m_sockets;


        inline bool transmit();

        inline void receive(Socket& socket);

        std::atomic_bool m_terminate;

        std::atomic_bool m_stop;

        std::thread m_thread;

        void cleanupSocket(const Socket& socket);

#if FASTCGIPP_LOG_LEVEL > 3
        std::atomic_ullong m_connectionKillCount;

        std::atomic_ullong m_connectionRDHupCount;

        std::atomic_ullong m_recordsSent;

        std::atomic_ullong m_recordsQueued;

        std::atomic_ullong m_recordsReceived;
#endif
    };
}

#endif