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_;
 
    // Request timeout in milliseconds.
    uint32_t timeout_;
 
    // Continue retrying after timeout when true.
    bool waitRetry_;
 
    // Maximum recv retries when waitRetry_ is true. 0 means unbounded (the
    // default, preserving the pre-#1236 forever-retry contract that pysmurf
    // and other downstream callers rely on).
    uint32_t maxRetries_;
 
  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 msecs, bool waitRetry, uint32_t maxRetries = 0);
 
    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