GatewayClient.cpp

Go to the documentation of this file.

#include "GatewayClient.h"
#include "ConfigServerHandlerCollection.h"
#include "HdlcdClientHandlerCollection.h"
#include "GatewayFrameData.h"
#include <assert.h>

GatewayClient::GatewayClient(boost::asio::io_service& a_IOService, boost::asio::ip::tcp::resolver::iterator a_EndpointIterator, std::shared_ptr<ConfigServerHandlerCollection>
                             a_ConfigServerHandlerCollection, std::shared_ptr<HdlcdClientHandlerCollection> a_HdlcdClientHandlerCollection, GatewayClientConnectGuard& a_GatewayClientConnectGuard, uint16_t a_ReferenceNbr):
                             m_IOService(a_IOService), m_ConfigServerHandlerCollection(a_ConfigServerHandlerCollection), m_HdlcdClientHandlerCollection(a_HdlcdClientHandlerCollection),
                             m_GatewayClientConnectGuard(a_GatewayClientConnectGuard), m_TcpSocket(a_IOService), m_ReferenceNbr(a_ReferenceNbr), m_bClosed(false) {
    // Checks
    assert(m_ConfigServerHandlerCollection);
    assert(m_HdlcdClientHandlerCollection);

    // Connect the TCP socket
    boost::asio::async_connect(m_TcpSocket, a_EndpointIterator, [this, &a_IOService](boost::system::error_code a_ErrorCode, boost::asio::ip::tcp::resolver::iterator) {
        if (a_ErrorCode == boost::asio::error::operation_aborted) return;
        if (a_ErrorCode) {
            Close();
        } else {
            // Configure the frame end point
            m_GatewayClientConnectGuard.IsConnected();
            m_FrameEndpoint = std::make_shared<FrameEndpoint>(a_IOService, m_TcpSocket, 0x00); // 0x00: unset the filter mask as there is no preceeding type byte
            m_FrameEndpoint->RegisterFrameFactory(GATEWAY_FRAME_DATA, []()->std::shared_ptr<Frame>{ return GatewayFrameData::CreateDeserializedFrame (); });
            m_FrameEndpoint->SetOnFrameCallback  ([this](std::shared_ptr<Frame> a_Frame)->bool{ return OnFrame(a_Frame); });
            m_FrameEndpoint->SetOnClosedCallback ([this](){ OnClosed(); });
            m_FrameEndpoint->Start();
        } // else
    }); // async_connect
}

GatewayClient::~GatewayClient() {
    Close();
}

void GatewayClient::Shutdown() {
    if (m_FrameEndpoint) {
        m_FrameEndpoint->Shutdown();
    } // if
}

void GatewayClient::Close() {
    if (m_bClosed == false) {
        m_bClosed = true;
        if (m_ConfigServerHandlerCollection) {
            m_GatewayClientConnectGuard.IsDisconnected();
        } // if

        if (m_FrameEndpoint) {
            m_FrameEndpoint->Close();
        } // if

        if (m_OnClosedCallback) {
            m_OnClosedCallback();
        } // if
    } // if
    
    // Drop all shared pointers
    m_ConfigServerHandlerCollection.reset();
    m_HdlcdClientHandlerCollection.reset();
}

void GatewayClient::SendPacket(uint16_t a_SerialPortNbr, const std::vector<unsigned char> &a_Payload) {
    // Deliver the packet to the gateway client entity
    if (m_FrameEndpoint) {
        m_FrameEndpoint->SendFrame(GatewayFrameData::Create(a_SerialPortNbr, a_Payload));
    } // if
}

void GatewayClient::SetOnClosedCallback(std::function<void()> a_OnClosedCallback) {
    m_OnClosedCallback = a_OnClosedCallback;
}

bool GatewayClient::OnFrame(std::shared_ptr<Frame> a_Frame) {
    // Dispatch
    assert(a_Frame);
    auto l_GatewayFrameData = std::dynamic_pointer_cast<GatewayFrameData>(a_Frame);
    assert(l_GatewayFrameData);
    m_HdlcdClientHandlerCollection->SendPacket(l_GatewayFrameData->GetSerialPortNbr(), l_GatewayFrameData->GetPayload());
    return true;
}

void GatewayClient::OnClosed() {
    Close();
}