tcp_connector_timeout.hpp

Go to the documentation of this file.

 
#ifndef TCP_CONNECTOR_TIMEOUT_HPP_INCLUDED
#define TCP_CONNECTOR_TIMEOUT_HPP_INCLUDED
 
#include <cstddef> // std::size_t
#include <cmath> // std::pow
#include <chrono>
#include <optional>
#include <functional> // std::function
 
namespace chops {
namespace net {
 
/*
 * @brief A using declaration for @c std::optional of @c std::chrono::milliseconds.
 */
using optional_millis = std::optional<std::chrono::milliseconds>;
/*
 * @brief Signature of TCP connector timeout function objects.
 *
 * Within the TCP connector the timeout function object is stored within a @c std::function.
 * The function object must be copy constructible.
 */
using tcp_connector_timeout_func = std::function< optional_millis (std::size_t) >;
 
/*
 * @brief A @c simple_timeout always returns the same timeout value.
 *
 */
struct simple_timeout {
 
  const std::chrono::milliseconds m_timeout;
 
/*
 * @brief Construct a @c simple_timeout.
 *
 * @param timeout Milliseconds to wait between unsuccessful connect attempts.
 */
  simple_timeout(std::chrono::milliseconds timeout = std::chrono::milliseconds(1000)) : m_timeout(timeout) {}
 
/*
 *  @brief Function call interface, for use by TCP connector functionality.
 *
 *  This method is not directly called by application code. It is called by the TCP connector
 *  internal functionality. See file documentation for documentation on parameters and return
 *  value.
 */
  optional_millis operator()(std::size_t) const noexcept {
    return optional_millis { m_timeout };
  }
};
 
/*
 * @brief A @c counted_timeout limits the number of connect attempts.
 *
 */
struct counted_timeout {
 
  const std::chrono::milliseconds m_timeout;
  const std::size_t m_max_attempts;
 
/*
 * @brief Construct a @c counted_timeout.
 *
 * @param timeout Milliseconds to wait between unsuccessful connect attempts.
 *
 * @param max_conn_attempts Maximum number of connect attempts.
 */
  counted_timeout (std::chrono::milliseconds timeout, std::size_t max_conn_attempts) :
    m_timeout(timeout), m_max_attempts(max_conn_attempts) {}
 
/*
 *  @brief Function call interface, for use by TCP connector functionality.
 *
 *  This method is not directly called by application code. It is called by the TCP connector
 *  internal functionality. See file documentation for documentation on parameters and return
 *  value.
 */
  optional_millis operator()(std::size_t attempts) const noexcept {
    return (attempts > m_max_attempts) ? optional_millis { } : optional_millis { m_timeout };
  }
};
 
/*
 *  @brief Increase the timeout value by a scaling factor up to a maximum value.
 *
 *  Increase the timeout value for each unsuccessful connect attempt. This decreases network
 *  traffic where there are multiple connectors all trying to connect to an unreachable host.
 *
 */
struct backoff_timeout {
 
  using tick_type = typename std::chrono::milliseconds::rep;
  const tick_type m_initial_ticks;
  const tick_type m_max_ticks;
  const int m_scale_factor;
 
/*
 * @brief Construct a @c backoff_timeout.
 *
 * @param initial_timeout Milliseconds to wait for the first connect attempt.
 *
 * @param max_timeout Maximum timeout value.
 *
 * @param scale_factor The timeout value is multiplied by this number for each connect attempt.
 */
  backoff_timeout(std::chrono::milliseconds initial_timeout, std::chrono::milliseconds max_timeout,
                  int scale_factor = 2) :
    m_initial_ticks(initial_timeout.count()), m_max_ticks(max_timeout.count()),
    m_scale_factor(scale_factor) { }
 
/*
 *  @brief Function call interface, for use by TCP connector functionality.
 *
 *  This method is not directly called by application code. It is called by the TCP connector
 *  internal functionality. See file documentation for documentation on parameters and return
 *  value.
 */
  optional_millis operator()(std::size_t attempts) const noexcept {
    auto tmp = static_cast<tick_type>((attempts-1u) * m_scale_factor * m_initial_ticks);
    tmp = (tmp == 0u ? m_initial_ticks : ((tmp > m_max_ticks) ? m_max_ticks : tmp));
    return optional_millis { std::chrono::milliseconds { tmp } };
  }
};
 
/*
 *  @brief Exponentially increase the timeout value up to a maximum.
 *
 *  Increase the timeout value similar to @c backoff_timeout, except using an exponential
 *  @c std::pow calculation instead of a scaled backoff.
 *
 */
struct exponential_backoff_timeout {
 
  using tick_type = typename std::chrono::milliseconds::rep;
  const tick_type m_initial_ticks;
  const tick_type m_max_ticks;
 
/*
 * @brief Construct a @c exponential_backoff_timeout.
 *
 * @param initial_timeout Milliseconds to wait for the first connect attempt.
 *
 * @param max_timeout Maximum timeout value.
 *
 */
  exponential_backoff_timeout(std::chrono::milliseconds initial_timeout, 
                              std::chrono::milliseconds max_timeout) :
    m_initial_ticks(initial_timeout.count()), m_max_ticks(max_timeout.count()) { }
 
/*
 *  @brief Function call interface, for use by TCP connector functionality.
 *
 *  This method is not directly called by application code. It is called by the TCP connector
 *  internal functionality. See file documentation for documentation on parameters and return
 *  value.
 */
  optional_millis operator()(std::size_t attempts) const noexcept {
 
    auto tmp = static_cast<tick_type>(std::pow(m_initial_ticks, attempts));
    std::chrono::milliseconds tout { (tmp > m_max_ticks) ? m_max_ticks : tmp };
    return optional_millis { tout };
  } //end operator()
 
};
 
} // end net namespace
} // end chops namespace
 
#endif