ClientSettings.hpp

//
// Copyright (c) 2004-2019 Cloud Software Group, Inc. All rights reserved.
//
#ifndef CLIENT_SETTINGS_H
#define CLIENT_SETTINGS_H

#include "StreamBase.hpp"

#include "NMSTL/ntime.hpp"

#include <string>

SB_NAMESPACE_BEGIN;

///
/// This class loads all the environment variables
/// used by the C++ client API. It uses a global
/// static object to do the work.
///
class ClientSettings {
  public:

    ///
    /// Loads all the client settings
    ///
    ClientSettings(bool haModeOn);

    ///
    /// Set the timeout used when opening a binary connection
    ///
    /// @param tupleOpenTimeout new value (in milliseconds) for the tuple open timeout
    ///
    void setOpenTimeout(const NMSTL::Time &tupleOpenTimeout) {
        _openTimeout = tupleOpenTimeout;
    }

    ///
    /// Get the timeout used when opening a connection
    ///
    /// @return Time (in milliseconds) that the tuple i/o will wait before
    /// assuming the server is down.
    ///
    NMSTL::Time getOpenTimeout() {
        return _openTimeout;
    }

    ///
    /// Get the timeout used when writing to a connection
    ///
    /// @return Time (in milliseconds) that the tuple i/o will wait before
    /// assuming the server is down.
    ///
    NMSTL::Time getWriteTimeout() {
        return _writeTimeout;
    }

    ///
    /// Set the timeout used when writing to a connection
    ///
    /// @param tupleWriteTimeout new value (in milliseconds) for the tuple write timeout
    ///
    void setWriteTimeout(const NMSTL::Time &tupleWriteTimeout) {
        _writeTimeout = tupleWriteTimeout;
    }

    ///
    /// Get the timeout used when making an xmlrpc request
    ///
    /// @return Time (in milliseconds) that the tuple i/o will wait before
    /// assuming the server is down.
    ///
    NMSTL::Time getXmlRpcTimeout() {
        return _xmlrpcTimeout;
    }

    ///
    /// Set the timeout used when making an xmlrpc request
    ///
    /// @param xmlrpcTimeout new value (in milliseconds) for the xmlrpc request timeout
    ///
    void setXmlRpcTimeout(const NMSTL::Time &xmlrpcTimeout) {
        _xmlrpcTimeout = xmlrpcTimeout;
    }

    ///
    /// Get the amount of time to sleep between reconnect requests
    ///
    /// @return Time (in milliseconds) to sleep between reconnect
    /// timeouts in the event that the TupleConnection is disconnected
    /// from its server.
    ///
    NMSTL::Time getReconnectSleep() {
        return _reconnectSleep;
    }

    ///
    /// Set the amount of time to sleep between reconnect requests
    ///
    /// @param reconnectSleep new value (in milliseconds) for reconnect sleep
    ///
    void setReconnectSleep(const NMSTL::Time &reconnectSleep) {
        _reconnectSleep = reconnectSleep;
    }

    ///
    /// Get the heart beat timeout
    ///
    /// @return Time (in milliseconds) the tuple quiesent timeout
    ///
    NMSTL::Time getHeartbeatTimeout() {
        return _heartbeatTimeout;
    }

    ///
    /// Set the heart beat timeout
    ///
    /// @param heartbeatTimeout new value (in milliseconds) for the heartbeat timeout
    ///
    void setHeartbeatTimeout(const NMSTL::Time &heartbeatTimeout) {
        _heartbeatTimeout = heartbeatTimeout;
    }

    ///
    /// Get the timeout used when sending a request to the server to get the clients
    /// exit status.
    ///
    /// @return Time (in milliseconds) of the time to wait for the clients exit status
    ///
    NMSTL::Time getExitStatusTimeout() {
        return _exitStatusTimeout;
    }

    ///
    /// Set the timeout used when sending a request to the server to get the clients
    /// exit status.
    ///
    /// @param exitStatusTimeout new value (in milliseconds) for the exit status timeout
    ///
    void setExitStatusTimeout(const NMSTL::Time &exitStatusTimeout) {
        _exitStatusTimeout = exitStatusTimeout;
    }

    ///
    /// Get the maximum size of the input tuple in binary mode
    ///
    /// @return max size of the input tuple (in bytes)
    ///
    unsigned int getMaxInputPacketSize() {
        return _maxInputPacketSize;
    }

    ///
    /// Set the maximum size of the input tuple in binary mode
    ///
    /// @param maxInputPacketSize new value (in milliseconds) for the maxInputPacket size
    ///
    void setMaxInputPacketSize(unsigned int maxInputPacketSize) {
        _maxInputPacketSize = maxInputPacketSize;
    }

    ///
    /// Should we check the client exit status
    ///
    /// @return if we should check the client exit status
    bool checkClientExitStatus() {
        return _checkClientExitStatus;
    }

    ///
    /// Set the maximum number of tuples to be kept in the Dequeuer Thread's internal queue
    /// before applying back-pressure to the server.
    ///
    /// @param maxDequeuerQueueSize maximum number of tuples to allow to wait in the
    ///  Dequeuer Thread's internal queue before blocking dequeues from the server.
    ///
    void setMaxDequeuerQueueSize(unsigned int maxDequeuerQueueSize) {
        _maxDequeuerQueueSize = maxDequeuerQueueSize;
    }


    ///
    /// Enable/disable TCP_NO_DELAY
    ///
    /// @param tcpNoDelay enable/disable TCP_NO_DELAY
    ///
    void setTcpNoDelay(bool tcpNoDelay) {
        _tcpNoDelay = tcpNoDelay;
    }

    ///
    /// Is TCP_NODELAY set
    ///
    /// @return if tcpNoDealy set
    bool tcpNoDelay() {
        return _tcpNoDelay;
    }

    unsigned int getMaxTupleBufferCacheSize() {
        return _maxTupleBufferCacheSize;
    }

    unsigned int getMaxDequeuerQueueSize() {
        return _maxDequeuerQueueSize;
    }

  private:
    NMSTL::Time _reconnectSleep;
    NMSTL::Time _openTimeout;
    NMSTL::Time _writeTimeout;
    NMSTL::Time _xmlrpcTimeout;
    NMSTL::Time _heartbeatTimeout;
    NMSTL::Time _exitStatusTimeout;
    unsigned int _maxInputPacketSize;
    bool _checkClientExitStatus;
    bool _tcpNoDelay;
    unsigned int _maxTupleBufferCacheSize;
    unsigned int _maxDequeuerQueueSize;
};

SB_NAMESPACE_END;
#endif