AsyncTimeoutSet.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2015-present, Facebook, Inc.
 *  All rights reserved.
 *
 *  This source code is licensed under the BSD-style license found in the
 *  LICENSE file in the root directory of this source tree. An additional grant
 *  of patent rights can be found in the PATENTS file in the same directory.
 *
 */
#pragma once

#include <chrono>
#include <cstddef>
#include <folly/io/async/AsyncTimeout.h>
#include <folly/io/async/DelayedDestruction.h>
#include <folly/io/async/TimeoutManager.h>
#include <memory>
#include <proxygen/lib/utils/Time.h>

namespace proxygen {

class AsyncTimeoutSet : private folly::AsyncTimeout,
                        public folly::DelayedDestruction {
 public:
  using UniquePtr = std::unique_ptr<AsyncTimeoutSet, Destructor>;

  class Callback {
   public:
    Callback() {}

    virtual ~Callback();

    virtual void timeoutExpired() noexcept = 0;

    void cancelTimeout() {
      if (timeoutSet_ == nullptr) {
        // We're not scheduled, so there's nothing to do.
        return;
      }
      cancelTimeoutImpl();
    }

    bool isScheduled() const {
      return timeoutSet_ != nullptr;
    }

   private:
    // Get the time remaining until this timeout expires
    std::chrono::milliseconds getTimeRemaining(
      std::chrono::milliseconds now) const {
      if (now >= expiration_) {
        return std::chrono::milliseconds(0);
      }
      return expiration_ - now;
    }

    void setScheduled(AsyncTimeoutSet* timeoutSet, Callback* prev);
    void cancelTimeoutImpl();

    std::shared_ptr<folly::RequestContext> context_;

    AsyncTimeoutSet* timeoutSet_{nullptr};
    Callback* prev_{nullptr};
    Callback* next_{nullptr};
    std::chrono::milliseconds expiration_{0};

    // Give AsyncTimeoutSet direct access to our members so it can take care
    // of scheduling/cancelling.
    friend class AsyncTimeoutSet;
  };

  class TimeoutClock {
   public:
    TimeoutClock() {}

    virtual ~TimeoutClock() {}

    virtual std::chrono::milliseconds millisecondsSinceEpoch() = 0;
  };

  AsyncTimeoutSet(folly::TimeoutManager* timeoutManager,
                  std::chrono::milliseconds intervalMS,
                  std::chrono::milliseconds atMostEveryN =
                      std::chrono::milliseconds(0),
                  TimeoutClock* timeoutClock = nullptr);

  AsyncTimeoutSet(folly::TimeoutManager* timeoutManager,
                  InternalEnum internal,
                  std::chrono::milliseconds intervalMS,
                  std::chrono::milliseconds atMostEveryN =
                      std::chrono::milliseconds(0));

  void destroy() override;

  std::chrono::milliseconds getInterval() const {
    return interval_;
  }

  void scheduleTimeout(Callback* callback);

  void fireAtMostEvery(const std::chrono::milliseconds& ms) {
    atMostEveryN_ = ms;
  }

  Callback* front() { return head_; }
  const Callback* front() const { return head_; }

 protected:
  ~AsyncTimeoutSet() override;

 private:
  // Forbidden copy constructor and assignment operator
  AsyncTimeoutSet(AsyncTimeoutSet const &) = delete;
  AsyncTimeoutSet& operator=(AsyncTimeoutSet const &) = delete;

  // Private methods to be invoked by AsyncTimeoutSet::Callback
  void headChanged();

  // Methods inherited from AsyncTimeout
  void timeoutExpired() noexcept override;

  TimeoutClock& timeoutClock_;
  Callback* head_;
  Callback* tail_;
  std::chrono::milliseconds interval_;
  std::chrono::milliseconds atMostEveryN_;
  bool inTimeoutExpired_{false};
};

} // proxygen