ManagedConnection.h

Go to the documentation of this file.

/*
 * Copyright 2017-present Facebook, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#pragma once

#include <folly/IntrusiveList.h>
#include <ostream>
#include <folly/io/async/HHWheelTimer.h>
#include <folly/io/async/DelayedDestruction.h>

namespace wangle {

class ConnectionManager;

class ManagedConnection:
    public folly::HHWheelTimer::Callback,
    public folly::DelayedDestruction {
 public:

  ManagedConnection();

  class Callback {
  public:
    virtual ~Callback() = default;

    /* Invoked when this connection becomes busy */
    virtual void onActivated(ManagedConnection& conn) = 0;

    /* Invoked when a connection becomes idle */
    virtual void onDeactivated(ManagedConnection& conn) = 0;
  };

  // HHWheelTimer::Callback API (left for subclasses to implement).
  void timeoutExpired() noexcept override = 0;

  virtual void describe(std::ostream& os) const = 0;

  virtual bool isBusy() const = 0;

  virtual std::chrono::milliseconds getIdleTime() const {
    return std::chrono::milliseconds(0);
  }

  virtual void notifyPendingShutdown() = 0;

  void fireNotifyPendingShutdown() {
    if (state_ == DrainState::NONE) {
      state_ = DrainState::SENT_NOTIFY_PENDING_SHUTDOWN;
      notifyPendingShutdown();
    }
  }

  virtual void closeWhenIdle() = 0;

  void fireCloseWhenIdle(bool force_to_close = false) {
    if (force_to_close || state_ == DrainState::SENT_NOTIFY_PENDING_SHUTDOWN) {
      state_ = DrainState::SENT_CLOSE_WHEN_IDLE;
      closeWhenIdle();
    }
  }

  virtual void dropConnection() = 0;

  virtual void dumpConnectionState(uint8_t loglevel) = 0;

  virtual void resetTimeout();

  void resetTimeoutTo(std::chrono::milliseconds);

  // Schedule an arbitrary timeout on the HHWheelTimer
  virtual void scheduleTimeout(
    folly::HHWheelTimer::Callback* callback,
    std::chrono::milliseconds timeout);

  ConnectionManager* getConnectionManager() {
    return connectionManager_;
  }

 protected:
  ~ManagedConnection() override;

 private:
  enum class DrainState {
    NONE,
    SENT_NOTIFY_PENDING_SHUTDOWN,
    SENT_CLOSE_WHEN_IDLE,
  };

  DrainState state_{DrainState::NONE};

  friend class ConnectionManager;

  void setConnectionManager(ConnectionManager* mgr) {
    connectionManager_ = mgr;
  }

  ConnectionManager* connectionManager_;

  folly::SafeIntrusiveListHook listHook_;

};

std::ostream& operator<<(std::ostream& os, const ManagedConnection& conn);

} // wangle