ZmqClient.h

Go to the documentation of this file.

 
#ifndef __ROGUE_ZMQ_CLIENT_H__
#define __ROGUE_ZMQ_CLIENT_H__
#include "rogue/Directives.h"
 
#include <atomic>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
 
#include "rogue/Logging.h"
 
#ifndef NO_PYTHON
    #include <boost/python.hpp>
#endif
 
namespace rogue {
namespace interfaces {
 
class ZmqClient {
    void* zmqCtx_ = nullptr;
    void* zmqSub_ = nullptr;
    void* zmqReq_ = nullptr;
 
    // Logger instance.
    std::shared_ptr<rogue::Logging> log_;
 
    // Warn/poll period in milliseconds (drives ZMQ_RCVTIMEO). Each time it
    // trips, the recv loop logs a "still waiting" warning and keeps waiting.
    uint32_t timeout_;
 
    // Absolute wait deadline in milliseconds. Once the accumulated wait reaches
    // failTime_ the recv loop throws. 0 means no deadline (retry forever),
    // preserving the pre-#1236 contract that pysmurf and other downstream
    // callers rely on.
    uint32_t failTime_;
 
    // Shutdown sentinel. stop() sets this so an in-flight forever loop
    // (failTime_ == 0) throws out of send()/sendString() instead of blocking
    // teardown.
    std::atomic<bool> stopping_{false};
 
  protected:
    std::thread* thread_ = nullptr;
    std::atomic<bool> threadEn_{false};
 
  private:
    bool running_ = false;
 
    // True when operating in string request mode.
    bool doString_;
 
    // Mutex serializing the ZMQ_REQ socket's send/recv cycle.
    std::mutex reqLock_;
 
    void runThread();
 
  public:
    static std::shared_ptr<rogue::interfaces::ZmqClient> create(const std::string& addr, uint16_t port, bool doString);
 
    static void setup_python();
 
    ZmqClient(const std::string& addr, uint16_t port, bool doString);
 
    virtual ~ZmqClient();
 
    void setTimeout(uint32_t warnTime, uint32_t failTime = 0);
 
    // Reject legacy (msecs, waitRetry[, maxRetries]) calls at compile time: a
    // bool argument would otherwise implicitly convert to uint32_t and silently
    // set failTime = 1 ms. Stale C++ callers get a compile error instead. The
    // Python binding rejects bools at runtime via the setTimeoutPy wrapper.
    void setTimeout(uint32_t warnTime, bool failTime) = delete;
    void setTimeout(uint32_t warnTime, bool waitRetry, uint32_t maxRetries) = delete;
 
    std::string sendString(const std::string& path, const std::string& attr, const std::string& arg);
 
    std::string getDisp(const std::string& path);
 
    void setDisp(const std::string& path, const std::string& value);
 
    std::string exec(const std::string& path, const std::string& arg = "");
 
    std::string valueDisp(const std::string& path);
 
#ifndef NO_PYTHON
    boost::python::object send(boost::python::object data);
 
    virtual void doUpdate(boost::python::object data);
#endif
 
    void stop();
};
typedef std::shared_ptr<rogue::interfaces::ZmqClient> ZmqClientPtr;
 
#ifndef NO_PYTHON
 
class ZmqClientWrap : public rogue::interfaces::ZmqClient, public boost::python::wrapper<rogue::interfaces::ZmqClient> {
  public:
    ZmqClientWrap(const std::string& addr, uint16_t port, bool doString);
 
    void doUpdate(boost::python::object data);
 
    void defDoUpdate(boost::python::object data);
};
 
typedef std::shared_ptr<rogue::interfaces::ZmqClientWrap> ZmqClientWrapPtr;
#endif
}  // namespace interfaces
}  // namespace rogue
 
#endif