ClientConnection.hxx

Go to the documentation of this file.

 
#ifndef _UTILS_CLIENTCONNECTION_HXX_
#define _UTILS_CLIENTCONNECTION_HXX_
 
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
 
#include "utils/GridConnectHub.hxx"
#include "utils/DirectHub.hxx"
#include "utils/socket_listener.hxx"
#include "utils/FdUtils.hxx"
 
class ConnectionClient
{
public:
    virtual bool ping() = 0;
 
    virtual int fd() { return -1; }
    
    virtual ~ConnectionClient()
    {
    }
};
 
class DeviceClosedNotify : public Notifiable
{
public:
    DeviceClosedNotify(int *fd, string name)
        : fd_(fd)
        , name_(name)
    {
    }
    void notify() override
    {
        LOG_ERROR("Connection to %s closed.", name_.c_str());
        *fd_ = -1;
    }
 
private:
    int *fd_; 
    string name_; 
};
 
class GCFdConnectionClient : public ConnectionClient
{
public:
    GCFdConnectionClient(const string &name, CanHubFlow *hub)
        : closedNotify_(&fd_, name)
        , hub_(hub)
    {
    }
 
    GCFdConnectionClient(const string &name, ByteDirectHubInterface *direct_hub)
        : closedNotify_(&fd_, name)
        , directHub_(direct_hub)
    {
    }
    
    virtual ~GCFdConnectionClient()
    {
    }
 
    bool ping() OVERRIDE
    {
        if (fd_ < 0)
        {
            try_connect();
        }
        return fd_ >= 0;
    }
 
    int fd() override
    {
        return fd_;
    }
 
protected:
    virtual void try_connect() = 0;
 
    void connection_complete(int fd);
 
private:
    DeviceClosedNotify closedNotify_;
    int fd_{-1};
    CanHubFlow *hub_{nullptr};
    ByteDirectHubInterface *directHub_{nullptr};
};
 
class DeviceConnectionClient : public GCFdConnectionClient
{
public:
    template<typename HubType>
    DeviceConnectionClient(
        const string &name, HubType *hub, const string &dev)
        : GCFdConnectionClient(name, hub)
        , dev_(dev)
    {
    }
 
    virtual ~DeviceConnectionClient()
    {
    }
 
private:
    void try_connect() OVERRIDE
    {
        int fd = ::open(dev_.c_str(), O_RDWR);
        if (fd >= 0)
        {
            FdUtils::optimize_tty_fd(fd);
            LOG(INFO, "Opened device %s.\n", dev_.c_str());
            connection_complete(fd);
        }
        else
        {
            LOG_ERROR("Failed to open device %s: %s\n", dev_.c_str(),
                strerror(errno));
        }
    }
 
    string dev_; 
};
 
class UpstreamConnectionClient : public GCFdConnectionClient
{
public:
    template<typename HubType>
    UpstreamConnectionClient(
        const string &name, HubType *hub, const string &host, int port)
        : GCFdConnectionClient(name, hub)
        , host_(host)
        , port_(port)
    {
    }
 
    virtual ~UpstreamConnectionClient()
    {
    }
 
private:
    void try_connect() OVERRIDE
    {
        int fd = ConnectSocket(host_.c_str(), port_);
        if (fd >= 0)
        {
            LOG_ERROR("Connected to %s:%d\n", host_.c_str(), port_);
            connection_complete(fd);
            // create_gc_port_for_can_hub(&can_hub0, fd, &closedNotify_);
        }
        else
        {
            LOG_ERROR("Failed to connect to %s:%d: (%d) %s\n", host_.c_str(),
                port_, errno, strerror(errno));
        }
    }
 
    string host_;
    int port_;
};
 
#endif // _UTILS_CLIENTCONNECTION_HXX_