SocketComponentHelper.hpp

Go to the documentation of this file.

// ======================================================================
// \title  SocketComponentHelper.hpp
// \author mstarch
// \brief  hpp file for SocketComponentHelper implementation class
//
// \copyright
// Copyright 2009-2020, by the California Institute of Technology.
// ALL RIGHTS RESERVED.  United States Government Sponsorship
// acknowledged.
//
// ======================================================================
#ifndef DRV_SocketComponentHelper_HPP
#define DRV_SocketComponentHelper_HPP

#include <Drv/Ip/IpSocket.hpp>
#include <Fw/Buffer/Buffer.hpp>
#include <Os/Condition.hpp>
#include <Os/Mutex.hpp>
#include <Os/Task.hpp>

namespace Drv {
class SocketComponentHelper {
  public:
    enum OpenState { NOT_OPEN, OPENING, OPEN, SKIP };
    enum ReconnectState { NOT_RECONNECTING, REQUEST_RECONNECT, RECONNECT_IN_PROGRESS };
    SocketComponentHelper();

    virtual ~SocketComponentHelper();

    void start(const Fw::ConstStringBase& name,
               const FwTaskPriorityType priority = Os::Task::TASK_PRIORITY_DEFAULT,
               const Os::Task::ParamType stack = Os::Task::TASK_DEFAULT,
               const Os::Task::ParamType cpuAffinity = Os::Task::TASK_DEFAULT,
               const FwTaskPriorityType priorityReconnect = Os::Task::TASK_PRIORITY_DEFAULT,
               const Os::Task::ParamType stackReconnect = Os::Task::TASK_DEFAULT,
               const Os::Task::ParamType cpuAffinityReconnect = Os::Task::TASK_DEFAULT);

    SocketIpStatus open();

    bool isOpened();

    void setAutomaticOpen(bool auto_open);

    bool getAutomaticOpen();

    SocketIpStatus send(const U8* const data, const FwSizeType size);

    SocketIpStatus recv(U8* data, FwSizeType& size);

    void close();

    void shutdown();

    bool running();
    bool runningReconnect();

    void stop();

    void stopReconnect();

    Os::Task::Status join();

    Os::Task::Status joinReconnect();

  protected:
    virtual void readLoop();

    virtual void reconnectLoop();

    virtual IpSocket& getSocketHandler() = 0;

    virtual Fw::Buffer getBuffer() = 0;

    virtual void sendBuffer(Fw::Buffer buffer, SocketIpStatus status) = 0;

    virtual void connected() = 0;

    static void readTask(void* pointer);

    static void reconnectTask(void* pointer);

    void requestReconnect();

    SocketIpStatus waitForReconnect(Fw::TimeInterval timeout = Fw::TimeInterval(1, 0));

  private:
    SocketIpStatus reopen();

  protected:
    bool m_reopen = true;  
    SocketDescriptor m_descriptor;

    // Read/recv
    Os::Task m_task;
    Os::Mutex m_lock;
    bool m_stop = true;                      
    OpenState m_open = OpenState::NOT_OPEN;  

    // Reconnect
    Os::Task m_reconnectTask;
    Os::Mutex m_reconnectLock;
    bool m_reconnectStop = true;
    ReconnectState m_reconnectState = ReconnectState::NOT_RECONNECTING;
    Fw::TimeInterval m_reconnectCheckInterval =
        Fw::TimeInterval(0, 50000);  // 50 ms, Interval at which reconnect task loop checks for requests
    Fw::TimeInterval m_reconnectWaitInterval =
        Fw::TimeInterval(0, 10000);  // 10 ms, Interval at which reconnect requesters wait for response
};
}  // namespace Drv
#endif  // DRV_SocketComponentHelper_HPP