mirror of
https://github.com/worldforge/cyphesis
synced 2026-08-13 12:26:04 -04:00
142 lines
4.2 KiB
C++
142 lines
4.2 KiB
C++
/*
|
|
Copyright (C) 2014 Erik Ogenvik
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program 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 General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*/
|
|
|
|
#ifndef COMMASIOCLIENT_H_
|
|
#define COMMASIOCLIENT_H_
|
|
|
|
#include "common/Link.h"
|
|
#include "common/CommSocket.h"
|
|
|
|
#include <Atlas/Objects/Decoder.h>
|
|
#include <Atlas/Objects/ObjectsFwd.h>
|
|
#include <Atlas/Codec.h>
|
|
#include <Atlas/Negotiate.h>
|
|
|
|
#include <boost/asio.hpp>
|
|
#include <boost/asio/buffer.hpp>
|
|
#include <boost/asio/deadline_timer.hpp>
|
|
|
|
#include <memory>
|
|
#include <sstream>
|
|
#include <deque>
|
|
|
|
template<typename ProtocolT>
|
|
class CommAsioClient: public Atlas::Objects::ObjectsDecoder,
|
|
public CommSocket,
|
|
public std::enable_shared_from_this<CommAsioClient<ProtocolT> >
|
|
{
|
|
public:
|
|
CommAsioClient(const std::string & name,
|
|
boost::asio::io_service& io_service);
|
|
virtual ~CommAsioClient();
|
|
|
|
typename ProtocolT::socket& getSocket();
|
|
|
|
void startAccept(Link * connection);
|
|
void startConnect(Link * connection);
|
|
int send(const Atlas::Objects::Operation::RootOperation &);
|
|
|
|
/// \brief STL deque of pointers to operation objects.
|
|
typedef std::deque<Atlas::Objects::Operation::RootOperation> DispatchQueue;
|
|
|
|
void disconnect() override;
|
|
|
|
int flush() override;
|
|
|
|
protected:
|
|
typename ProtocolT::socket mSocket;
|
|
|
|
boost::asio::streambuf mReadBuffer;
|
|
/**
|
|
* A buffer into which any outgoing data is written. This is always attached to mOutStream,
|
|
* which basically means that any Atlas op being serialized for outgoing data is written to
|
|
* this buffer.
|
|
*/
|
|
boost::asio::streambuf* mWriteBuffer;
|
|
|
|
/**
|
|
* A buffer which is used when data is being sent asynchronously.
|
|
*/
|
|
boost::asio::streambuf* mSendBuffer;
|
|
|
|
/**
|
|
* The stream onto which data is received.
|
|
*/
|
|
std::istream mInStream;
|
|
|
|
/**
|
|
* The stream onto which data is written when it's to be sent.
|
|
* Note that the actual data is accessed through mWriteBuffer.
|
|
*/
|
|
std::ostream mOutStream;
|
|
|
|
boost::asio::deadline_timer mNegotiateTimer;
|
|
|
|
/**
|
|
* True if we're currently are sending/writing. No other write operations to the socket is allowed.
|
|
*/
|
|
bool mIsSending;
|
|
|
|
/**
|
|
* True if we have pending data which we should send as soon as a pending async write operation has
|
|
* completed.
|
|
*/
|
|
bool mShouldSend;
|
|
|
|
enum
|
|
{
|
|
/**
|
|
* Arbitrary size of the read buffer.
|
|
*/
|
|
read_buffer_size = 16384
|
|
};
|
|
|
|
/// \brief Queue of operations that have been decoded by not dispatched.
|
|
DispatchQueue m_opQueue;
|
|
/// \brief Atlas codec that handles encoding and decoding traffic.
|
|
Atlas::Codec * m_codec;
|
|
/// \brief high level encoder passes data to the codec for transmission.
|
|
Atlas::Objects::ObjectsEncoder * m_encoder;
|
|
/// \brief Atlas negotiator for handling codec negotiation.
|
|
Atlas::Negotiate * m_negotiate;
|
|
/// \brief Server side object for handling connection level operations.
|
|
Link * m_link;
|
|
|
|
const std::string mName;
|
|
|
|
void do_read();
|
|
|
|
void write();
|
|
|
|
void dispatch();
|
|
|
|
void startNegotiation();
|
|
|
|
/// \brief Handle socket data related to codec negotiation.
|
|
int negotiate();
|
|
|
|
void negotiate_read();
|
|
|
|
void negotiate_write();
|
|
|
|
int operation(const Atlas::Objects::Operation::RootOperation &);
|
|
|
|
void objectArrived(const Atlas::Objects::Root & obj) override;
|
|
};
|
|
|
|
#endif /* COMMASIOCLIENT_H_ */
|