127 lines
4.3 KiB
C++
127 lines
4.3 KiB
C++
#pragma once
|
|
|
|
#include "../common/adc_utils.h"
|
|
#include "adc_device_netmsg.h"
|
|
#include "adc_netclient.h"
|
|
|
|
namespace adc
|
|
{
|
|
|
|
template <typename IdentT = std::string, interfaces::adc_logger_c LoggerT = utils::AdcOstreamLogger<char>>
|
|
class AdcDeviceNetClient : public AdcGenericNetClient<IdentT, LoggerT>
|
|
{
|
|
typedef AdcGenericNetClient<IdentT, LoggerT> base_t;
|
|
|
|
public:
|
|
template <interfaces::adc_netservice_c NetServiceT, traits::adc_hashable_c SessionIdentT = std::string>
|
|
class Session : public std::enable_shared_from_this<Session<NetServiceT, SessionIdentT>>
|
|
{
|
|
public:
|
|
typedef SessionIdentT netsession_ident_t;
|
|
typedef NetServiceT netservice_t;
|
|
|
|
struct netsession_ctx_t {
|
|
AdcDeviceNetClient* clientPtr;
|
|
std::chrono::milliseconds recvTimeout;
|
|
std::chrono::milliseconds sendTimeout;
|
|
};
|
|
|
|
typedef std::vector<char> message_t;
|
|
|
|
// Session(const netsession_ident_t& id, netservice_t srv, AdcDeviceNetServer* srv_ptr)
|
|
Session(const netsession_ident_t& id, netservice_t srv, netsession_ctx_t ctx)
|
|
: _ident(id),
|
|
_netService(std::move(srv)),
|
|
_clientPtr(ctx.clientPtr),
|
|
_recvTimeout(ctx.recvTimeout),
|
|
_sendTimeout(ctx.sendTimeout)
|
|
{
|
|
_clientPtr->logInfo("Create client-to-server session with ID = {} (addr = {}, thread = {})", _ident,
|
|
(void*)this, utils::AdcThisThreadId());
|
|
}
|
|
|
|
|
|
virtual ~Session()
|
|
{
|
|
_clientPtr->logInfo("Delete client-to-server session with ID = {} (addr = {}, thread = {})", _ident,
|
|
(void*)this, utils::AdcThisThreadId());
|
|
}
|
|
|
|
netsession_ident_t ident() const
|
|
{
|
|
return _ident;
|
|
}
|
|
|
|
void start()
|
|
{
|
|
_clientPtr->logInfo("Start client-to-server session with ID = {} (addr = {}, thread = {})", _ident,
|
|
(void*)this, utils::AdcThisThreadId());
|
|
}
|
|
|
|
void stop()
|
|
{
|
|
_clientPtr->logInfo("Stop client-to-server session with ID = {} (addr = {}, thread = {})", _ident,
|
|
(void*)this, utils::AdcThisThreadId());
|
|
|
|
_netService.close();
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
netsession_ident_t _ident;
|
|
netservice_t _netService;
|
|
AdcDeviceNetClient* _clientPtr;
|
|
|
|
std::chrono::milliseconds _recvTimeout = std::chrono::seconds(5);
|
|
std::chrono::milliseconds _sendTimeout = std::chrono::seconds(5);
|
|
|
|
|
|
// helper methods
|
|
std::function<void(typename netservice_t::async_callback_err_t,
|
|
typename netservice_t::async_receive_callback_t)>
|
|
_defaultRecvCallback = [this](auto err, auto msg) {
|
|
if (err) {
|
|
_clientPtr->logError("An error occured while receiving server respond: {}",
|
|
netservice_t::formattableError(err));
|
|
} else {
|
|
AdcDeviceProtoMessage dev_msg(msg);
|
|
|
|
if (!dev_msg.isValid()) {
|
|
_clientPtr->logError("Invalid server respond");
|
|
return;
|
|
}
|
|
|
|
if (dev_msg.isACK()) {
|
|
} else if (dev_msg.isERROR()) {
|
|
} else {
|
|
_clientPtr->logError("Unexpectable server respond");
|
|
}
|
|
}
|
|
};
|
|
|
|
template <traits::adc_input_char_range SendMsgT, typename TokenT>
|
|
auto asyncSendRecv(const SendMsgT& send_msg, TokenT&& token)
|
|
{
|
|
return _netService.asyncSend(
|
|
send_msg,
|
|
[wrapper = traits::adc_pf_wrapper(std::forward<TokenT>(token)), this](auto err) {
|
|
if (err) {
|
|
this->logError("An error occured while sending the message: {}",
|
|
netservice_t::formattableError(err));
|
|
} else {
|
|
_netService.asyncReceive(std::get<0>(wrapper), _recvTimeout);
|
|
}
|
|
},
|
|
_sendTimeout);
|
|
}
|
|
}; // end of 'Session' class declaration
|
|
|
|
using base_t::base_t;
|
|
|
|
virtual ~AdcDeviceNetClient() {}
|
|
};
|
|
|
|
|
|
} // namespace adc
|