ESPComm.h

Go to the documentation of this file.

#ifndef ESPCOMM_H_
#define ESPCOMM_H_

#include "logger/Logger.h"
#include "utils/Str.h"
#include "io/LineReader.h"
#include "io/SocketServer.h"
#include "io/SocketClient.h"

#include <fstream>      // std::ofstream


class ESPComm
{
public:

    typedef enum { OK = 0,
                   CANNOT_OPEN_SOCKET_PORT,
                   TIMEOUT_ACCEPT_CLIENT,
                   CANNOT_ACCEPT_CLIENT,
                   PORT_NOT_OPEN,
                   TIMEOUT_CONNECTING,
                   CANNOT_CONNECT
                 } Error;

    ESPComm( Str name,
             const int serverSocketPort,
             Logger& logger,
             size_t readBufferSize = 1024 );

    ESPComm( Str name,
             const char* espServerAddr,
             const int espServerPort,
             Logger& logger,
             size_t readBufferSize = 1024 );

    ~ESPComm();

    ESPComm& open() ;

    ESPComm& acceptClient( int timeoutMillis = 0 ) ;

    Str getPeerAddress();

    ESPComm& connectAsClient();

    ESPComm& connectAsClient( int timeoutMillis );

    ESPComm& setEspServerAddressAndPort( Str espServerAddr, const int espServerPort );

    bool hasEspServerAddressAndPort()
    {
        return espServerAddr_.length() > 0 && espServerPort_ > 0;
    }

    Str showEspServerAddressAndPort()
    {
        Str str = espServerAddr_;
        str += ":";
        str += espServerPort_;
        return str;
    }

    ESPComm& submitAbort();

    inline bool isClientConnected()
    {
        return socketClient_ != 0;
    }

    ESPComm& close();

    virtual bool isReadable()
    {
        return socketClient_ != 0;
    }

    virtual bool eof()
    {
        return isReadable();
    }

    virtual bool isWritable()
    {
        return socketClient_ != 0;
    }

    enum EspStream
    {
        UNKNOWN = 0,
        RESULT     = 0201,  // the ruby eval return value stream
        OUTPUT     = 0202,  // the ruby eval output stream  (puts, etc.)
        EXCEPTION  = 0203,  // synchronous exceptions resulting from ruby cmd eval
        LOG        = 0204,  // asynchronous logging stream (messages not directly related to cmds)
        SET_PROMPT = 0205,  // set prompt string (only last line is used)
        STATE_VEC  = 0206,  // the state vector update stream (not yet implemented)
        STATUS     = 0207,  // status (state) updates
        PROMPT     = 0200,  // used like a stream identifier, but not really one. It merely causes the client to prompt for input when received
    };

    const char* streamName( EspStream stream )
    {
        switch( stream )
        {
        case UNKNOWN:
            return "unknown";
        case RESULT:
            return "result";
        case OUTPUT:
            return "output";
        case EXCEPTION:
            return "exception";
        case LOG:
            return "log";
        case SET_PROMPT:
            return "set_prompt";
        case STATUS:
            return "status";
        case PROMPT:
            return "prompt";
        default:
            return "unrecognized-esp-stream";
        }
    }

    // Operating ESP states:
    enum EspState
    {
        ES_UNKNOWN,
        ES_IDLE,
        ES_LOADING,
        ES_READY,
        ES_FILTERING,
        ES_PAUSED,
        ES_FILTERING_ERR,
        ES_PROCESSING,
        ES_PROCESS_FAILED,
        ES_PROCESSED,
        ES_UNLOADING
    };

    const char* espStateName( EspState espState )
    {
        switch( espState )
        {
        case ES_UNKNOWN:
            return "ES_UNKNOWN";
        case ES_IDLE:
            return "ES_IDLE";
        case ES_LOADING:
            return "ES_LOADING";
        case ES_READY:
            return "ES_READY";
        case ES_FILTERING:
            return "ES_FILTERING";
        case ES_PAUSED:
            return "ES_PAUSED";
        case ES_FILTERING_ERR:
            return "ES_FILTERING_ERR";
        case ES_PROCESSING:
            return "ES_PROCESSING";
        case ES_PROCESS_FAILED:
            return "ES_PROCESS_FAILED";
        case ES_PROCESSED:
            return "ES_PROCESSED";
        case ES_UNLOADING:
            return "ES_UNLOADING";
        default:
            return "(invalid EspState)";
        }
    };

    EspState espStateFromReportedString( const char* str )
    {
        if( strcmp( "IDLE", str ) == 0 ) return ES_IDLE;
        if( strcmp( "LOADING", str ) == 0 ) return ES_LOADING;
        if( strcmp( "READY", str ) == 0 ) return ES_READY;
        if( strcmp( "FILTERING", str ) == 0 ) return ES_FILTERING;
        if( strcmp( "PAUSED", str ) == 0 ) return ES_PAUSED;
        if( strcmp( "FILTERING_ERR", str ) == 0 ) return ES_FILTERING_ERR;
        if( strcmp( "PROCESSING", str ) == 0 ) return ES_PROCESSING;
        if( strcmp( "PROCESS_FAILED", str ) == 0 ) return ES_PROCESS_FAILED;
        if( strcmp( "PROCESSED", str ) == 0 ) return ES_PROCESSED;
        if( strcmp( "UNLOADING", str ) == 0 ) return ES_UNLOADING;

        logger_.syslog( Str( "Unrecognized string for ESP state: '" ) + str + "'",
                        Syslog::ERROR );
        return ES_UNKNOWN;
    };

    void setEspLogFile( const char* path, bool onlyLog = true );

    int readLine( char* buffer, size_t bufferSize, EspStream *stream = 0 ) ;

    EspState getEspState()
    {
        return espState_;
    }

    EspStream getCurrentStream()
    {
        return currentStream_;
    }

    Str* getLastResult() ;

    Str* getLastException() ;

    int sendLine( const char* buffer, size_t bufferSize = 0xFFFFFFFF );

    Str escape( const char* buffer, size_t bufferSize = 0xFFFFFFFF );

    inline ESPComm::Error getError()
    {
        return lastError_;
    }

    inline bool hasError()
    {
        return lastError_ != OK;
    }

    const char* errorString();

    void setDebug( bool debugOn )
    {
        debug_ = debugOn;
    }

private:

    // disallow copy constructor
    ESPComm( const ESPComm& old );

    Str name_;

    int serverSocketPort_;         // for LRAUV acting as server in socket communication
    SocketServer* socketServer_;   // the corresponding LRAUV server socket

    Str espServerAddr_;            // for ESP acting as server in socket communication
    int espServerPort_;

    Socket* socketClient_;         // the ESP client connection socket

    LineReader* lineReader_;
    size_t readBufferSize_;

    EspStream currentStream_;

    Str lastResult_;              // ongoing last result
    bool lastResultComplete_;     // is the last result now complete?

    Str lastException_;           // ongoing last exception if any
    bool lastExceptionComplete_;  // is the last exception now complete?

    EspState espState_;           // current ESP operating state

    ESPComm::Error lastError_;

    Logger logger_;

    std::ofstream* espLogFile_;
    bool onlyLog_;

    bool debug_;

    int sendLineAux( Socket* socket, const char* buffer, size_t bufferSize = 0xFFFFFFFF );

    // convenience methods to facilitate testing outside of the regular LRAUV framework
    void logDebug( Str msg );
    void logError( Str msg );

};

#endif /*ESPCOMM_H_*/