HTTPConnector.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 <wangle/acceptor/TransportInfo.h>
#include <folly/io/async/SSLContext.h>
#include <folly/io/async/HHWheelTimer.h>
#include <proxygen/lib/utils/Time.h>
#include <folly/io/async/AsyncSocket.h>
#include <proxygen/lib/utils/WheelTimerInstance.h>
#include <proxygen/lib/http/codec/HTTPCodec.h>
#include <proxygen/lib/http/codec/DefaultHTTPCodecFactory.h>

namespace proxygen {

class HTTPUpstreamSession;
extern const std::string empty_string;

class HTTPConnector:
      protected folly::AsyncSocket::ConnectCallback {
 public:
  class Callback {
   public:
    virtual ~Callback() {}
    virtual void connectSuccess(HTTPUpstreamSession* session) = 0;
    virtual void connectError(
      const folly::AsyncSocketException& ex) = 0;
  };

  HTTPConnector(Callback* callback, folly::HHWheelTimer* timeoutSet);

  HTTPConnector(Callback* callback, const WheelTimerInstance& timeout);

  ~HTTPConnector() override;

  void reset();

  void setPlaintextProtocol(const std::string& plaintextProto);

  void setHTTPVersionOverride(bool enabled);

  void connect(
    folly::EventBase* eventBase,
    const folly::SocketAddress& connectAddr,
    std::chrono::milliseconds timeoutMs = std::chrono::milliseconds(0),
    const folly::AsyncSocket::OptionMap& socketOptions =
      folly::AsyncSocket::emptyOptionMap,
    const folly::SocketAddress& bindAddr =
      folly::AsyncSocket::anyAddress());

  void connectSSL(
    folly::EventBase* eventBase,
    const folly::SocketAddress& connectAddr,
    const std::shared_ptr<folly::SSLContext>& ctx,
    SSL_SESSION* session = nullptr,
    std::chrono::milliseconds timeoutMs = std::chrono::milliseconds(0),
    const folly::AsyncSocket::OptionMap& socketOptions =
      folly::AsyncSocket::emptyOptionMap,
    const folly::SocketAddress& bindAddr =
    folly::AsyncSocket::anyAddress(),
    const std::string& serverName = empty_string);

  std::chrono::milliseconds timeElapsed();

  bool isBusy() const { return socket_.get(); }

  void setHTTPCodecFactory(std::unique_ptr<DefaultHTTPCodecFactory> factory) {
    httpCodecFactory_ = std::move(factory);
  }

 protected:
  void connectSuccess() noexcept override;
  void connectErr(const folly::AsyncSocketException& ex)
    noexcept override;


  Callback* cb_;
  WheelTimerInstance timeout_;
  folly::AsyncTransportWrapper::UniquePtr socket_;
  wangle::TransportInfo transportInfo_;
  std::string plaintextProtocol_;
  TimePoint connectStart_;
  std::unique_ptr<DefaultHTTPCodecFactory> httpCodecFactory_;
};

}