provide ability to configure sentinel timeout #132

Author: Cylix

includes/cpp_redis/core/client.hpp

@@ -300,7 +300,7 @@ class client {
   //! \param host sentinel host
   //! \param port sentinel port
   //!
-  void add_sentinel(const std::string& host, std::size_t port);
+  void add_sentinel(const std::string& host, std::size_t port, std::uint32_t timeout_msecs = 0);
 
   //!
   //! retrieve sentinel for current client

includes/cpp_redis/core/sentinel.hpp

@@ -124,7 +124,7 @@ class sentinel {
   //! \param port sentinel port
   //! \return current instance
   //!
-  sentinel& add_sentinel(const std::string& host, std::size_t port);
+  sentinel& add_sentinel(const std::string& host, std::size_t port, std::uint32_t timeout_msecs = 0);
 
   //!
   //! clear all existing sentinels.
@@ -152,13 +152,11 @@ class sentinel {
 
   //!
   //! Connect to 1st active sentinel we find. Requires add_sentinel() to be called first
+  //! will use timeout set for each added sentinel independently
   //!
-  //! \param timeout_msecs maximum time to connect
   //! \param disconnect_handler handler to be called whenever disconnection occurs
   //!
-  void connect_sentinel(
-    std::uint32_t timeout_msecs                             = 0,
-    const sentinel_disconnect_handler_t& disconnect_handler = nullptr);
+  void connect_sentinel(const sentinel_disconnect_handler_t& disconnect_handler = nullptr);
 
   //!
   //! Connect to named sentinel
@@ -207,12 +205,12 @@ class sentinel {
   sentinel& set(const std::string& name, const std::string& option, const std::string& value, const reply_callback_t& reply_callback = nullptr);
   sentinel& slaves(const std::string& name, const reply_callback_t& reply_callback = nullptr);
 
-private:
+public:
   class sentinel_def {
   public:
     //! ctor
-    sentinel_def(const std::string& host, std::size_t port)
-    : m_host(host), m_port(port) {}
+    sentinel_def(const std::string& host, std::size_t port, std::uint32_t timeout_msecs)
+    : m_host(host), m_port(port), m_timeout_msecs(timeout_msecs) {}
 
     //! dtor
     ~sentinel_def(void) = default;
@@ -230,6 +228,19 @@ class sentinel {
     size_t
     get_port(void) const { return m_port; }
 
+    //!
+    //! \return timeout for sentinel
+    //!
+    std::uint32_t
+    get_timeout_msecs(void) const { return m_timeout_msecs; }
+
+    //!
+    //! set connect timeout for sentinel in msecs
+    //! \param timeout_msecs new value
+    //!
+    void
+    set_timeout_msecs(std::uint32_t timeout_msecs) { m_timeout_msecs = timeout_msecs; }
+
   private:
     //!
     //! sentinel host
@@ -240,8 +251,24 @@ class sentinel {
     //! sentinel port
     //!
     std::size_t m_port;
+
+    //!
+    //! connect timeout config
+    //!
+    std::uint32_t m_timeout_msecs;
   };
 
+public:
+  //!
+  //! \return sentinels
+  //!
+  const std::vector<sentinel_def>& get_sentinels(void) const;
+
+  //!
+  //! \return sentinels (non-const version)
+  //!
+  std::vector<sentinel_def>& get_sentinels(void);
+
 private:
   //!
   //! redis connection receive handler, triggered whenever a reply has been read by the redis connection

includes/cpp_redis/core/subscriber.hpp

@@ -233,7 +233,7 @@ class subscriber {
   //! \param host sentinel host
   //! \param port sentinel port
   //!
-  void add_sentinel(const std::string& host, std::size_t port);
+  void add_sentinel(const std::string& host, std::size_t port, std::uint32_t timeout_msecs = 0);
 
   //!
   //! retrieve sentinel for current client

sources/core/client.cpp

@@ -144,8 +144,8 @@ client::is_reconnecting(void) const {
 }
 
 void
-client::add_sentinel(const std::string& host, std::size_t port) {
-  m_sentinel.add_sentinel(host, port);
+client::add_sentinel(const std::string& host, std::size_t port, std::uint32_t timeout_msecs) {
+  m_sentinel.add_sentinel(host, port, timeout_msecs);
 }
 
 const sentinel&

sources/core/sentinel.cpp

@@ -49,8 +49,8 @@ sentinel::~sentinel(void) {
 }
 
 sentinel&
-sentinel::add_sentinel(const std::string& host, std::size_t port) {
-  m_sentinels.push_back({host, port});
+sentinel::add_sentinel(const std::string& host, std::size_t port, std::uint32_t timeout_msecs) {
+  m_sentinels.push_back({host, port, timeout_msecs});
   return *this;
 }
 
@@ -62,9 +62,8 @@ sentinel::clear_sentinels() {
 bool
 sentinel::get_master_addr_by_name(const std::string& name, std::string& host, std::size_t& port, bool autoconnect) {
   //! reset connection settings
-  host.clear();
-  port                          = 0;
-  std::uint32_t connect_timeout = 2000;
+  host = "";
+  port = 0;
 
   //! we must have some sentinels to connect to if we are in autoconnect mode
   if (autoconnect && m_sentinels.size() == 0) {
@@ -79,7 +78,7 @@ sentinel::get_master_addr_by_name(const std::string& name, std::string& host, st
   if (autoconnect) {
     try {
       //! Will round robin all attached sentinels until it finds one that is online.
-      connect_sentinel(connect_timeout, nullptr);
+      connect_sentinel(nullptr);
     }
     catch (const redis_error&) {
     }
@@ -95,8 +94,8 @@ sentinel::get_master_addr_by_name(const std::string& name, std::string& host, st
   send({"SENTINEL", "get-master-addr-by-name", name}, [&](cpp_redis::reply& reply) {
     if (reply.is_array()) {
       auto arr = reply.as_array();
-      host     = arr[0].as_string();                         //host
-      port     = std::stoi(arr[1].as_string(), nullptr, 10); //port
+      host     = arr[0].as_string();
+      port     = std::stoi(arr[1].as_string(), nullptr, 10);
     }
   });
   sync_commit();
@@ -111,7 +110,7 @@ sentinel::get_master_addr_by_name(const std::string& name, std::string& host, st
 }
 
 void
-sentinel::connect_sentinel(std::uint32_t timeout_msecs, const sentinel_disconnect_handler_t& sentinel_disconnect_handler) {
+sentinel::connect_sentinel(const sentinel_disconnect_handler_t& sentinel_disconnect_handler) {
   if (m_sentinels.size() == 0) {
     throw redis_error("No sentinels available. Call add_sentinel() before connect_sentinel()");
   }
@@ -126,10 +125,10 @@ sentinel::connect_sentinel(std::uint32_t timeout_msecs, const sentinel_disconnec
   while (not_connected && it != m_sentinels.end()) {
     try {
       __CPP_REDIS_LOG(debug, std::string("cpp_redis::sentinel attempting to connect to host ") + it->get_host());
-      m_client.connect(it->get_host(), it->get_port(), disconnect_handler, receive_handler, timeout_msecs);
+      m_client.connect(it->get_host(), it->get_port(), disconnect_handler, receive_handler, it->get_timeout_msecs());
     }
     catch (const redis_error&) {
-      not_connected = true; //Connection failed.
+      not_connected = true; //! Connection failed.
       __CPP_REDIS_LOG(info, std::string("cpp_redis::sentinel unable to connect to sentinel host ") + it->get_host());
     }
 
@@ -232,6 +231,16 @@ sentinel::is_connected(void) {
   return m_client.is_connected();
 }
 
+const std::vector<sentinel::sentinel_def>&
+sentinel::get_sentinels(void) const {
+  return m_sentinels;
+}
+
+std::vector<sentinel::sentinel_def>&
+sentinel::get_sentinels(void) {
+  return m_sentinels;
+}
+
 sentinel&
 sentinel::send(const std::vector<std::string>& redis_cmd, const reply_callback_t& callback) {
   std::lock_guard<std::mutex> lock_callback(m_callbacks_mutex);

sources/core/subscriber.cpp

@@ -117,8 +117,8 @@ subscriber::connect(
 }
 
 void
-subscriber::add_sentinel(const std::string& host, std::size_t port) {
-  m_sentinel.add_sentinel(host, port);
+subscriber::add_sentinel(const std::string& host, std::size_t port, std::uint32_t timeout_msecs) {
+  m_sentinel.add_sentinel(host, port, timeout_msecs);
 }
 
 const sentinel&