remote_client.hh

#ifndef VTESTBED_SERVER_REMOTE_CLIENT_HH
#define VTESTBED_SERVER_REMOTE_CLIENT_HH

#include <unistdx/base/log_message>
#include <unistdx/base/websocketbuf>
#include <unistdx/io/fildesbuf>
#include <unistdx/net/pstream>
#include <unistdx/net/socket>

#include <vtestbed/core/testbed.hh>
#include <vtestbed/server/remote_client_state.hh>

namespace vtb {

    namespace srv {

        class websocketbuf:
            public sys::basic_websocketbuf<char,std::char_traits<char>>,
            public sys::basic_fildesbuf<char,std::char_traits<char>,sys::socket>
        {

        public:

            inline explicit
            websocketbuf(sys::socket&& s):
            sys::basic_websocketbuf<char,std::char_traits<char>>(),
            sys::basic_fildesbuf<char,std::char_traits<char>,sys::socket>(std::move(s))
            {}

        };

        template <class T>
        class Remote_client {

        private:
            typedef vtb::core::Testbed<T,3> testbed_type;
            typedef sys::pstream stream_type;
            typedef stream_type::ipacket_guard ipacket_guard;
            typedef sys::opacket_guard<stream_type> opacket_guard;

        private:
            websocketbuf _buffer;
            sys::socket_address _address;
            Remote_client_state _state = Remote_client_state::Initial;
            bool _verbose = false;

        public:

            Remote_client(
                sys::socket&& socket,
                const sys::socket_address& address,
                bool is_server
            ):
            _buffer(std::move(socket)),
            _address(address) {
                _buffer.role(
                    is_server
                    ? websocketbuf::role_type::server
                    : websocketbuf::role_type::client
                );
            }

            Remote_client(Remote_client&& rhs):
            _buffer(std::move(rhs._buffer.fd())),
            _address(rhs._address),
            _state(rhs._state),
            _verbose(rhs._verbose) {}

            ~Remote_client() {
                _buffer.fd().shutdown(sys::shutdown_flag::read_write);
                _buffer.fd().close();
            }

            bool
            handshake() {
                if (_state != Remote_client_state::Initial) {
                    return handshake_succeded();
                }
                if (_buffer.handshake()) {
                    state(Remote_client_state::Handshake_succeeded);
                }
                return handshake_succeded();
            }

            void
            process(const sys::epoll_event& ev, testbed_type& testbed) {
                fill();
                if (handshake_succeded()) {
                    if (_buffer.read_packet()) {
                        pull(testbed);
                    }
                }
            }

            void
            pull(testbed_type& testbed) {
                if (!handshake_succeded()) {
                    return;
                }
                try {
                    stream_type s(&_buffer);
                    ipacket_guard guard(s.rdbuf());
                    s >> testbed;
                } catch (const std::exception& err) {
                    this->error("Unable to receive packet: _", err.what());
                }
            }

            void
            push(const testbed_type& testbed) {
                if (!handshake_succeded()) {
                    return;
                }
                try {
                    stream_type s(&_buffer);
                    opacket_guard guard(s);
                    s.begin_packet();
                    s << testbed;
                    s.end_packet();
                } catch (const std::exception& err) {
                    this->error("Unable to send packet: _", err.what());
                }
            }

            void
            fill() {
                auto n1 = _buffer.available();
                _buffer.pubfill();
                auto n2 = _buffer.available();
                this->info("_ received _ bytes", _address, n2-n1);
            }

            void
            flush() {
                if (!_buffer.dirty()) {
                    return;
                }
                try {
                    auto n1 = _buffer.remaining();
                    _buffer.pubflush();
                    auto n2 = _buffer.remaining();
                    this->info("_ sent _ bytes", _address, n1-n2);
                } catch (const sys::bad_call& err) {
                    if (err.errc() != std::errc::broken_pipe) {
                        throw;
                    }
                }
            }

            inline sys::socket&
            socket() noexcept {
                return _buffer.fd();
            }

            inline const sys::socket&
            socket() const noexcept {
                return _buffer.fd();
            }

            inline const sys::socket_address&
            address() const noexcept {
                return _address;
            }

            inline bool
            is_server() const noexcept {
                return _buffer.role() == websocketbuf::role_type::server;
            }

            inline bool
            is_client() const noexcept {
                return _buffer.role() == websocketbuf::role_type::client;
            }

            inline bool
            handshake_succeded() const noexcept {
                return _state == Remote_client_state::Handshake_succeeded;
            }

            inline bool
            handshake_failed() const noexcept {
                return _state == Remote_client_state::Handshake_failed;
            }

            inline void
            verbose(bool rhs) noexcept {
                _verbose = rhs;
            }

        private:

            inline void
            state(Remote_client_state rhs) {
                _state = rhs;
                this->info("_ _", _address, _state);
            }

            template <class ... Args>
            inline void
            info(const Args& ... args) {
                if (_verbose) {
                    sys::log_message("client", args ...);
                }
            }

            template <class ... Args>
            inline void
            error(const Args& ... args) {
                sys::log_message("client", args ...);
            }

        };

    }

}

#endif // vim:filetype=cpp