folly/wangle/acceptor/Acceptor.h

   1 /*
   2  *  Copyright (c) 2014, Facebook, Inc.
   3  *  All rights reserved.
   4  *
   5  *  This source code is licensed under the BSD-style license found in the
   6  *  LICENSE file in the root directory of this source tree. An additional grant
   7  *  of patent rights can be found in the PATENTS file in the same directory.
   8  *
   9  */
  10 #pragma once
  11
  12 #include <folly/wangle/acceptor/ServerSocketConfig.h>
  13 #include <folly/wangle/acceptor/ConnectionCounter.h>
  14 #include <folly/wangle/acceptor/ConnectionManager.h>
  15 #include <folly/wangle/acceptor/LoadShedConfiguration.h>
  16 #include <folly/wangle/ssl/SSLCacheProvider.h>
  17 #include <folly/wangle/acceptor/TransportInfo.h>
  18
  19 #include <chrono>
  20 #include <event.h>
  21 #include <folly/io/async/AsyncSSLSocket.h>
  22 #include <folly/io/async/AsyncServerSocket.h>
  23
  24 namespace folly { namespace wangle {
  25 class ManagedConnection;
  26 }}
  27
  28 namespace folly {
  29
  30 class SocketAddress;
  31 class SSLContext;
  32 class AsyncTransport;
  33 class SSLContextManager;
  34
  35 /**
  36  * An abstract acceptor for TCP-based network services.
  37  *
  38  * There is one acceptor object per thread for each listening socket.  When a
  39  * new connection arrives on the listening socket, it is accepted by one of the
  40  * acceptor objects.  From that point on the connection will be processed by
  41  * that acceptor's thread.
  42  *
  43  * The acceptor will call the abstract onNewConnection() method to create
  44  * a new ManagedConnection object for each accepted socket.  The acceptor
  45  * also tracks all outstanding connections that it has accepted.
  46  */
  47 class Acceptor :
  48   public folly::AsyncServerSocket::AcceptCallback,
  49   public folly::wangle::ConnectionManager::Callback {
  50  public:
  51
  52   enum class State : uint32_t {
  53     kInit,  // not yet started
  54     kRunning, // processing requests normally
  55     kDraining, // processing outstanding conns, but not accepting new ones
  56     kDone,  // no longer accepting, and all connections finished
  57   };
  58
  59   explicit Acceptor(const ServerSocketConfig& accConfig);
  60   virtual ~Acceptor();
  61
  62   /**
  63    * Supply an SSL cache provider
  64    * @note Call this before init()
  65    */
  66   virtual void setSSLCacheProvider(
  67       const std::shared_ptr<SSLCacheProvider>& cacheProvider) {
  68     cacheProvider_ = cacheProvider;
  69   }
  70
  71   /**
  72    * Initialize the Acceptor to run in the specified EventBase
  73    * thread, receiving connections from the specified AsyncServerSocket.
  74    *
  75    * This method will be called from the AsyncServerSocket's primary thread,
  76    * not the specified EventBase thread.
  77    */
  78   virtual void init(AsyncServerSocket* serverSocket,
  79                     EventBase* eventBase);
  80
  81   /**
  82    * Dynamically add a new SSLContextConfig
  83    */
  84   void addSSLContextConfig(const SSLContextConfig& sslCtxConfig);
  85
  86   SSLContextManager* getSSLContextManager() const {
  87     return sslCtxManager_.get();
  88   }
  89
  90   /**
  91    * Return the number of outstanding connections in this service instance.
  92    */
  93   uint32_t getNumConnections() const {
  94     return downstreamConnectionManager_ ?
  95         downstreamConnectionManager_->getNumConnections() : 0;
  96   }
  97
  98   /**
  99    * Access the Acceptor's event base.
 100    */
 101   virtual EventBase* getEventBase() const { return base_; }
 102
 103   /**
 104    * Access the Acceptor's downstream (client-side) ConnectionManager
 105    */
 106   virtual folly::wangle::ConnectionManager* getConnectionManager() {
 107     return downstreamConnectionManager_.get();
 108   }
 109
 110   /**
 111    * Invoked when a new ManagedConnection is created.
 112    *
 113    * This allows the Acceptor to track the outstanding connections,
 114    * for tracking timeouts and for ensuring that all connections have been
 115    * drained on shutdown.
 116    */
 117   void addConnection(folly::wangle::ManagedConnection* connection);
 118
 119   /**
 120    * Get this acceptor's current state.
 121    */
 122   State getState() const {
 123     return state_;
 124   }
 125
 126   /**
 127    * Get the current connection timeout.
 128    */
 129   std::chrono::milliseconds getConnTimeout() const;
 130
 131   /**
 132    * Returns the name of this VIP.
 133    *
 134    * Will return an empty string if no name has been configured.
 135    */
 136   const std::string& getName() const {
 137     return accConfig_.name;
 138   }
 139
 140   /**
 141    * Force the acceptor to drop all connections and stop processing.
 142    *
 143    * This function may be called from any thread.  The acceptor will not
 144    * necessarily stop before this function returns: the stop will be scheduled
 145    * to run in the acceptor's thread.
 146    */
 147   virtual void forceStop();
 148
 149   bool isSSL() const { return accConfig_.isSSL(); }
 150
 151   const ServerSocketConfig& getConfig() const { return accConfig_; }
 152
 153   static uint64_t getTotalNumPendingSSLConns() {
 154     return totalNumPendingSSLConns_.load();
 155   }
 156
 157   /**
 158    * Called right when the TCP connection has been accepted, before processing
 159    * the first HTTP bytes (HTTP) or the SSL handshake (HTTPS)
 160    */
 161   virtual void onDoneAcceptingConnection(
 162     int fd,
 163     const SocketAddress& clientAddr,
 164     std::chrono::steady_clock::time_point acceptTime
 165   ) noexcept;
 166
 167   /**
 168    * Begins either processing HTTP bytes (HTTP) or the SSL handshake (HTTPS)
 169    */
 170   void processEstablishedConnection(
 171     int fd,
 172     const SocketAddress& clientAddr,
 173     std::chrono::steady_clock::time_point acceptTime,
 174     TransportInfo& tinfo
 175   ) noexcept;
 176
 177   /**
 178    * Drains all open connections of their outstanding transactions. When
 179    * a connection's transaction count reaches zero, the connection closes.
 180    */
 181   void drainAllConnections();
 182
 183   /**
 184    * Drop all connections.
 185    *
 186    * forceStop() schedules dropAllConnections() to be called in the acceptor's
 187    * thread.
 188    */
 189   void dropAllConnections();
 190
 191  protected:
 192   friend class AcceptorHandshakeHelper;
 193
 194   /**
 195    * Our event loop.
 196    *
 197    * Probably needs to be used to pass to a ManagedConnection
 198    * implementation. Also visible in case a subclass wishes to do additional
 199    * things w/ the event loop (e.g. in attach()).
 200    */
 201   EventBase* base_{nullptr};
 202
 203   virtual uint64_t getConnectionCountForLoadShedding(void) const { return 0; }
 204
 205   /**
 206    * Hook for subclasses to drop newly accepted connections prior
 207    * to handshaking.
 208    */
 209   virtual bool canAccept(const folly::SocketAddress&);
 210
 211   /**
 212    * Invoked when a new connection is created. This is where application starts
 213    * processing a new downstream connection.
 214    *
 215    * NOTE: Application should add the new connection to
 216    *       downstreamConnectionManager so that it can be garbage collected after
 217    *       certain period of idleness.
 218    *
 219    * @param sock              the socket connected to the client
 220    * @param address           the address of the client
 221    * @param nextProtocolName  the name of the L6 or L7 protocol to be
 222    *                            spoken on the connection, if known (e.g.,
 223    *                            from TLS NPN during secure connection setup),
 224    *                            or an empty string if unknown
 225    */
 226   virtual void onNewConnection(
 227       AsyncSocket::UniquePtr sock,
 228       const folly::SocketAddress* address,
 229       const std::string& nextProtocolName,
 230       const TransportInfo& tinfo) = 0;
 231
 232   virtual AsyncSocket::UniquePtr makeNewAsyncSocket(EventBase* base, int fd) {
 233     return AsyncSocket::UniquePtr(new AsyncSocket(base, fd));
 234   }
 235
 236   virtual AsyncSSLSocket::UniquePtr makeNewAsyncSSLSocket(
 237     const std::shared_ptr<SSLContext>& ctx, EventBase* base, int fd) {
 238     return AsyncSSLSocket::UniquePtr(new AsyncSSLSocket(ctx, base, fd));
 239   }
 240
 241   /**
 242    * Hook for subclasses to record stats about SSL connection establishment.
 243    */
 244   virtual void updateSSLStats(
 245       const AsyncSSLSocket* sock,
 246       std::chrono::milliseconds acceptLatency,
 247       SSLErrorEnum error) noexcept {}
 248
 249  protected:
 250
 251   /**
 252    * onConnectionsDrained() will be called once all connections have been
 253    * drained while the acceptor is stopping.
 254    *
 255    * Subclasses can override this method to perform any subclass-specific
 256    * cleanup.
 257    */
 258   virtual void onConnectionsDrained() {}
 259
 260   // AsyncServerSocket::AcceptCallback methods
 261   void connectionAccepted(int fd,
 262       const folly::SocketAddress& clientAddr)
 263       noexcept;
 264   void acceptError(const std::exception& ex) noexcept;
 265   void acceptStopped() noexcept;
 266
 267   // ConnectionManager::Callback methods
 268   void onEmpty(const folly::wangle::ConnectionManager& cm);
 269   void onConnectionAdded(const folly::wangle::ConnectionManager& cm) {}
 270   void onConnectionRemoved(const folly::wangle::ConnectionManager& cm) {}
 271
 272   /**
 273    * Process a connection that is to ready to receive L7 traffic.
 274    * This method is called immediately upon accept for plaintext
 275    * connections and upon completion of SSL handshaking or resumption
 276    * for SSL connections.
 277    */
 278    void connectionReady(
 279       AsyncSocket::UniquePtr sock,
 280       const folly::SocketAddress& clientAddr,
 281       const std::string& nextProtocolName,
 282       TransportInfo& tinfo);
 283
 284   const LoadShedConfiguration& getLoadShedConfiguration() const {
 285     return loadShedConfig_;
 286   }
 287
 288  protected:
 289   const ServerSocketConfig accConfig_;
 290   void setLoadShedConfig(const LoadShedConfiguration& from,
 291                          IConnectionCounter* counter);
 292
 293   /**
 294    * Socket options to apply to the client socket
 295    */
 296   AsyncSocket::OptionMap socketOptions_;
 297
 298   std::unique_ptr<SSLContextManager> sslCtxManager_;
 299
 300   /**
 301    * Whether we want to enable client hello parsing in the handshake helper
 302    * to get list of supported client ciphers.
 303    */
 304   bool parseClientHello_{false};
 305
 306   folly::wangle::ConnectionManager::UniquePtr downstreamConnectionManager_;
 307
 308  private:
 309
 310   // Forbidden copy constructor and assignment opererator
 311   Acceptor(Acceptor const &) = delete;
 312   Acceptor& operator=(Acceptor const &) = delete;
 313
 314   /**
 315    * Wrapper for connectionReady() that decrements the count of
 316    * pending SSL connections.
 317    */
 318   void sslConnectionReady(AsyncSocket::UniquePtr sock,
 319       const folly::SocketAddress& clientAddr,
 320       const std::string& nextProtocol,
 321       TransportInfo& tinfo);
 322
 323   /**
 324    * Notification callback for SSL handshake failures.
 325    */
 326   void sslConnectionError();
 327
 328   void checkDrained();
 329
 330   State state_{State::kInit};
 331   uint64_t numPendingSSLConns_{0};
 332
 333   static std::atomic<uint64_t> totalNumPendingSSLConns_;
 334
 335   bool forceShutdownInProgress_{false};
 336   LoadShedConfiguration loadShedConfig_;
 337   IConnectionCounter* connectionCounter_{nullptr};
 338   std::shared_ptr<SSLCacheProvider> cacheProvider_;
 339 };
 340
 341 class AcceptorFactory {
 342  public:
 343   virtual std::shared_ptr<Acceptor> newAcceptor(folly::EventBase*) = 0;
 344   virtual ~AcceptorFactory() = default;
 345 };
 346
 347 } // namespace