folly/io/async/AsyncServerSocket.h

   1 /*
   2  * Copyright 2014 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #pragma once
  18
  19 #include <folly/io/async/DelayedDestruction.h>
  20 #include <folly/io/async/EventHandler.h>
  21 #include <folly/io/async/EventBase.h>
  22 #include <folly/io/async/NotificationQueue.h>
  23 #include <folly/io/async/AsyncTimeout.h>
  24 #include <folly/io/ShutdownSocketSet.h>
  25 #include <folly/SocketAddress.h>
  26 #include <memory>
  27 #include <exception>
  28 #include <vector>
  29 #include <limits.h>
  30 #include <stddef.h>
  31 #include <sys/socket.h>
  32
  33
  34 // Due to the way kernel headers are included, this may or may not be defined.
  35 // Number pulled from 3.10 kernel headers.
  36 #ifndef SO_REUSEPORT
  37 #define SO_REUSEPORT 15
  38 #endif
  39
  40 namespace folly {
  41
  42 /**
  43  * A listening socket that asynchronously informs a callback whenever a new
  44  * connection has been accepted.
  45  *
  46  * Unlike most async interfaces that always invoke their callback in the same
  47  * EventBase thread, AsyncServerSocket is unusual in that it can distribute
  48  * the callbacks across multiple EventBase threads.
  49  *
  50  * This supports a common use case for network servers to distribute incoming
  51  * connections across a number of EventBase threads.  (Servers typically run
  52  * with one EventBase thread per CPU.)
  53  *
  54  * Despite being able to invoke callbacks in multiple EventBase threads,
  55  * AsyncServerSocket still has one "primary" EventBase.  Operations that
  56  * modify the AsyncServerSocket state may only be performed from the primary
  57  * EventBase thread.
  58  */
  59 class AsyncServerSocket : public DelayedDestruction {
  60  public:
  61   typedef std::unique_ptr<AsyncServerSocket, Destructor> UniquePtr;
  62
  63   class AcceptCallback {
  64    public:
  65     virtual ~AcceptCallback() {}
  66
  67     /**
  68      * connectionAccepted() is called whenever a new client connection is
  69      * received.
  70      *
  71      * The AcceptCallback will remain installed after connectionAccepted()
  72      * returns.
  73      *
  74      * @param fd          The newly accepted client socket.  The AcceptCallback
  75      *                    assumes ownership of this socket, and is responsible
  76      *                    for closing it when done.  The newly accepted file
  77      *                    descriptor will have already been put into
  78      *                    non-blocking mode.
  79      * @param clientAddr  A reference to a TSocketAddress struct containing the
  80      *                    client's address.  This struct is only guaranteed to
  81      *                    remain valid until connectionAccepted() returns.
  82      */
  83     virtual void connectionAccepted(int fd,
  84                                     const SocketAddress& clientAddr)
  85       noexcept = 0;
  86
  87     /**
  88      * acceptError() is called if an error occurs while accepting.
  89      *
  90      * The AcceptCallback will remain installed even after an accept error,
  91      * as the errors are typically somewhat transient, such as being out of
  92      * file descriptors.  The server socket must be explicitly stopped if you
  93      * wish to stop accepting after an error.
  94      *
  95      * @param ex  An exception representing the error.
  96      */
  97     virtual void acceptError(const std::exception& ex) noexcept = 0;
  98
  99     /**
 100      * acceptStarted() will be called in the callback's EventBase thread
 101      * after this callback has been added to the AsyncServerSocket.
 102      *
 103      * acceptStarted() will be called before any calls to connectionAccepted()
 104      * or acceptError() are made on this callback.
 105      *
 106      * acceptStarted() makes it easier for callbacks to perform initialization
 107      * inside the callback thread.  (The call to addAcceptCallback() must
 108      * always be made from the AsyncServerSocket's primary EventBase thread.
 109      * acceptStarted() provides a hook that will always be invoked in the
 110      * callback's thread.)
 111      *
 112      * Note that the call to acceptStarted() is made once the callback is
 113      * added, regardless of whether or not the AsyncServerSocket is actually
 114      * accepting at the moment.  acceptStarted() will be called even if the
 115      * AsyncServerSocket is paused when the callback is added (including if
 116      * the initial call to startAccepting() on the AsyncServerSocket has not
 117      * been made yet).
 118      */
 119     virtual void acceptStarted() noexcept {}
 120
 121     /**
 122      * acceptStopped() will be called when this AcceptCallback is removed from
 123      * the AsyncServerSocket, or when the AsyncServerSocket is destroyed,
 124      * whichever occurs first.
 125      *
 126      * No more calls to connectionAccepted() or acceptError() will be made
 127      * after acceptStopped() is invoked.
 128      */
 129     virtual void acceptStopped() noexcept {}
 130   };
 131
 132   static const uint32_t kDefaultMaxAcceptAtOnce = 30;
 133   static const uint32_t kDefaultCallbackAcceptAtOnce = 5;
 134   static const uint32_t kDefaultMaxMessagesInQueue = 0;
 135   /**
 136    * Create a new AsyncServerSocket with the specified EventBase.
 137    *
 138    * @param eventBase  The EventBase to use for driving the asynchronous I/O.
 139    *                   If this parameter is nullptr, attachEventBase() must be
 140    *                   called before this socket can begin accepting
 141    *                   connections.
 142    */
 143   explicit AsyncServerSocket(EventBase* eventBase = nullptr);
 144
 145   /**
 146    * Helper function to create a shared_ptr<AsyncServerSocket>.
 147    *
 148    * This passes in the correct destructor object, since AsyncServerSocket's
 149    * destructor is protected and cannot be invoked directly.
 150    */
 151   static std::shared_ptr<AsyncServerSocket>
 152   newSocket(EventBase* evb = nullptr) {
 153     return std::shared_ptr<AsyncServerSocket>(new AsyncServerSocket(evb),
 154                                                  Destructor());
 155   }
 156
 157   void setShutdownSocketSet(ShutdownSocketSet* newSS);
 158
 159   /**
 160    * Destroy the socket.
 161    *
 162    * AsyncServerSocket::destroy() must be called to destroy the socket.
 163    * The normal destructor is private, and should not be invoked directly.
 164    * This prevents callers from deleting a AsyncServerSocket while it is
 165    * invoking a callback.
 166    *
 167    * destroy() must be invoked from the socket's primary EventBase thread.
 168    *
 169    * If there are AcceptCallbacks still installed when destroy() is called,
 170    * acceptStopped() will be called on these callbacks to notify them that
 171    * accepting has stopped.  Accept callbacks being driven by other EventBase
 172    * threads may continue to receive new accept callbacks for a brief period of
 173    * time after destroy() returns.  They will not receive any more callback
 174    * invocations once acceptStopped() is invoked.
 175    */
 176   virtual void destroy();
 177
 178   /**
 179    * Attach this AsyncServerSocket to its primary EventBase.
 180    *
 181    * This may only be called if the AsyncServerSocket is not already attached
 182    * to a EventBase.  The AsyncServerSocket must be attached to a EventBase
 183    * before it can begin accepting connections.
 184    */
 185   void attachEventBase(EventBase *eventBase);
 186
 187   /**
 188    * Detach the AsyncServerSocket from its primary EventBase.
 189    *
 190    * detachEventBase() may only be called if the AsyncServerSocket is not
 191    * currently accepting connections.
 192    */
 193   void detachEventBase();
 194
 195   /**
 196    * Get the EventBase used by this socket.
 197    */
 198   EventBase* getEventBase() const {
 199     return eventBase_;
 200   }
 201
 202   /**
 203    * Create a AsyncServerSocket from an existing socket file descriptor.
 204    *
 205    * useExistingSocket() will cause the AsyncServerSocket to take ownership of
 206    * the specified file descriptor, and use it to listen for new connections.
 207    * The AsyncServerSocket will close the file descriptor when it is
 208    * destroyed.
 209    *
 210    * useExistingSocket() must be called before bind() or listen().
 211    *
 212    * The supplied file descriptor will automatically be put into non-blocking
 213    * mode.  The caller may have already directly called bind() and possibly
 214    * listen on the file descriptor.  If so the caller should skip calling the
 215    * corresponding AsyncServerSocket::bind() and listen() methods.
 216    *
 217    * On error a TTransportException will be thrown and the caller will retain
 218    * ownership of the file descriptor.
 219    */
 220   void useExistingSocket(int fd);
 221   void useExistingSockets(const std::vector<int>& fds);
 222
 223   /**
 224    * Return the underlying file descriptor
 225    */
 226   std::vector<int> getSockets() const {
 227     std::vector<int> sockets;
 228     for (auto& handler : sockets_) {
 229       sockets.push_back(handler.socket_);
 230     }
 231     return sockets;
 232   }
 233
 234   /**
 235    * Backwards compatible getSocket, warns if > 1 socket
 236    */
 237   int getSocket() const {
 238     if (sockets_.size() > 1) {
 239       VLOG(2) << "Warning: getSocket can return multiple fds, " <<
 240         "but getSockets was not called, so only returning the first";
 241     }
 242     if (sockets_.size() == 0) {
 243       return -1;
 244     } else {
 245       return sockets_[0].socket_;
 246     }
 247   }
 248
 249   /**
 250    * Bind to the specified address.
 251    *
 252    * This must be called from the primary EventBase thread.
 253    *
 254    * Throws TTransportException on error.
 255    */
 256   virtual void bind(const SocketAddress& address);
 257
 258   /**
 259    * Bind to the specified port.
 260    *
 261    * This must be called from the primary EventBase thread.
 262    *
 263    * Throws TTransportException on error.
 264    */
 265   virtual void bind(uint16_t port);
 266
 267   /**
 268    * Get the local address to which the socket is bound.
 269    *
 270    * Throws TTransportException on error.
 271    */
 272   void getAddress(SocketAddress* addressReturn) const;
 273
 274   /**
 275    * Get all the local addresses to which the socket is bound.
 276    *
 277    * Throws TTransportException on error.
 278    */
 279   std::vector<SocketAddress> getAddresses() const;
 280
 281   /**
 282    * Begin listening for connections.
 283    *
 284    * This calls ::listen() with the specified backlog.
 285    *
 286    * Once listen() is invoked the socket will actually be open so that remote
 287    * clients may establish connections.  (Clients that attempt to connect
 288    * before listen() is called will receive a connection refused error.)
 289    *
 290    * At least one callback must be set and startAccepting() must be called to
 291    * actually begin notifying the accept callbacks of newly accepted
 292    * connections.  The backlog parameter controls how many connections the
 293    * kernel will accept and buffer internally while the accept callbacks are
 294    * paused (or if accepting is enabled but the callbacks cannot keep up).
 295    *
 296    * bind() must be called before calling listen().
 297    * listen() must be called from the primary EventBase thread.
 298    *
 299    * Throws TTransportException on error.
 300    */
 301   virtual void listen(int backlog);
 302
 303   /**
 304    * Add an AcceptCallback.
 305    *
 306    * When a new socket is accepted, one of the AcceptCallbacks will be invoked
 307    * with the new socket.  The AcceptCallbacks are invoked in a round-robin
 308    * fashion.  This allows the accepted sockets to distributed among a pool of
 309    * threads, each running its own EventBase object.  This is a common model,
 310    * since most asynchronous-style servers typically run one EventBase thread
 311    * per CPU.
 312    *
 313    * The EventBase object associated with each AcceptCallback must be running
 314    * its loop.  If the EventBase loop is not running, sockets will still be
 315    * scheduled for the callback, but the callback cannot actually get invoked
 316    * until the loop runs.
 317    *
 318    * This method must be invoked from the AsyncServerSocket's primary
 319    * EventBase thread.
 320    *
 321    * Note that startAccepting() must be called on the AsyncServerSocket to
 322    * cause it to actually start accepting sockets once callbacks have been
 323    * installed.
 324    *
 325    * @param callback   The callback to invoke.
 326    * @param eventBase  The EventBase to use to invoke the callback.  This
 327    *     parameter may be nullptr, in which case the callback will be invoked in
 328    *     the AsyncServerSocket's primary EventBase.
 329    * @param maxAtOnce  The maximum number of connections to accept in this
 330    *                   callback on a single iteration of the event base loop.
 331    *                   This only takes effect when eventBase is non-nullptr.
 332    *                   When using a nullptr eventBase for the callback, the
 333    *                   setMaxAcceptAtOnce() method controls how many
 334    *                   connections the main event base will accept at once.
 335    */
 336   virtual void addAcceptCallback(
 337     AcceptCallback *callback,
 338     EventBase *eventBase,
 339     uint32_t maxAtOnce = kDefaultCallbackAcceptAtOnce);
 340
 341   /**
 342    * Remove an AcceptCallback.
 343    *
 344    * This allows a single AcceptCallback to be removed from the round-robin
 345    * pool.
 346    *
 347    * This method must be invoked from the AsyncServerSocket's primary
 348    * EventBase thread.  Use EventBase::runInEventBaseThread() to schedule the
 349    * operation in the correct EventBase if your code is not in the server
 350    * socket's primary EventBase.
 351    *
 352    * Given that the accept callback is being driven by a different EventBase,
 353    * the AcceptCallback may continue to be invoked for a short period of time
 354    * after removeAcceptCallback() returns in this thread.  Once the other
 355    * EventBase thread receives the notification to stop, it will call
 356    * acceptStopped() on the callback to inform it that it is fully stopped and
 357    * will not receive any new sockets.
 358    *
 359    * If the last accept callback is removed while the socket is accepting,
 360    * the socket will implicitly pause accepting.  If a callback is later added,
 361    * it will resume accepting immediately, without requiring startAccepting()
 362    * to be invoked.
 363    *
 364    * @param callback   The callback to uninstall.
 365    * @param eventBase  The EventBase associated with this callback.  This must
 366    *     be the same EventBase that was used when the callback was installed
 367    *     with addAcceptCallback().
 368    */
 369   void removeAcceptCallback(AcceptCallback *callback, EventBase *eventBase);
 370
 371   /**
 372    * Begin accepting connctions on this socket.
 373    *
 374    * bind() and listen() must be called before calling startAccepting().
 375    *
 376    * When a AsyncServerSocket is initially created, it will not begin
 377    * accepting connections until at least one callback has been added and
 378    * startAccepting() has been called.  startAccepting() can also be used to
 379    * resume accepting connections after a call to pauseAccepting().
 380    *
 381    * If startAccepting() is called when there are no accept callbacks
 382    * installed, the socket will not actually begin accepting until an accept
 383    * callback is added.
 384    *
 385    * This method may only be called from the primary EventBase thread.
 386    */
 387   virtual void startAccepting();
 388
 389   /**
 390    * Pause accepting connections.
 391    *
 392    * startAccepting() may be called to resume accepting.
 393    *
 394    * This method may only be called from the primary EventBase thread.
 395    * If there are AcceptCallbacks being driven by other EventBase threads they
 396    * may continue to receive callbacks for a short period of time after
 397    * pauseAccepting() returns.
 398    *
 399    * Unlike removeAcceptCallback() or destroy(), acceptStopped() will not be
 400    * called on the AcceptCallback objects simply due to a temporary pause.  If
 401    * the server socket is later destroyed while paused, acceptStopped() will be
 402    * called all of the installed AcceptCallbacks.
 403    */
 404   void pauseAccepting();
 405
 406   /**
 407    * Shutdown the listen socket and notify all callbacks that accept has
 408    * stopped, but don't close the socket.  This invokes shutdown(2) with the
 409    * supplied argument.  Passing -1 will close the socket now.  Otherwise, the
 410    * close will be delayed until this object is destroyed.
 411    *
 412    * Only use this if you have reason to pass special flags to shutdown.
 413    * Otherwise just destroy the socket.
 414    *
 415    * This method has no effect when a ShutdownSocketSet option is used.
 416    *
 417    * Returns the result of shutdown on sockets_[n-1]
 418    */
 419   int stopAccepting(int shutdownFlags = -1);
 420
 421   /**
 422    * Get the maximum number of connections that will be accepted each time
 423    * around the event loop.
 424    */
 425   uint32_t getMaxAcceptAtOnce() const {
 426     return maxAcceptAtOnce_;
 427   }
 428
 429   /**
 430    * Set the maximum number of connections that will be accepted each time
 431    * around the event loop.
 432    *
 433    * This provides a very coarse-grained way of controlling how fast the
 434    * AsyncServerSocket will accept connections.  If you find that when your
 435    * server is overloaded AsyncServerSocket accepts connections more quickly
 436    * than your code can process them, you can try lowering this number so that
 437    * fewer connections will be accepted each event loop iteration.
 438    *
 439    * For more explicit control over the accept rate, you can also use
 440    * pauseAccepting() to temporarily pause accepting when your server is
 441    * overloaded, and then use startAccepting() later to resume accepting.
 442    */
 443   void setMaxAcceptAtOnce(uint32_t numConns) {
 444     maxAcceptAtOnce_ = numConns;
 445   }
 446
 447   /**
 448    * Get the maximum number of unprocessed messages which a NotificationQueue
 449    * can hold.
 450    */
 451   uint32_t getMaxNumMessagesInQueue() const {
 452     return maxNumMsgsInQueue_;
 453   }
 454
 455   /**
 456    * Set the maximum number of unprocessed messages in NotificationQueue.
 457    * No new message will be sent to that NotificationQueue if there are more
 458    * than such number of unprocessed messages in that queue.
 459    *
 460    * Only works if called before addAcceptCallback.
 461    */
 462   void setMaxNumMessagesInQueue(uint32_t num) {
 463     maxNumMsgsInQueue_ = num;
 464   }
 465
 466   /**
 467    * Get the speed of adjusting connection accept rate.
 468    */
 469   double getAcceptRateAdjustSpeed() const {
 470     return acceptRateAdjustSpeed_;
 471   }
 472
 473   /**
 474    * Set the speed of adjusting connection accept rate.
 475    */
 476   void setAcceptRateAdjustSpeed(double speed) {
 477     acceptRateAdjustSpeed_ = speed;
 478   }
 479
 480   /**
 481    * Get the number of connections dropped by the AsyncServerSocket
 482    */
 483   uint64_t getNumDroppedConnections() const {
 484     return numDroppedConnections_;
 485   }
 486
 487   /**
 488    * Set whether or not SO_KEEPALIVE should be enabled on the server socket
 489    * (and thus on all subsequently-accepted connections). By default, keepalive
 490    * is enabled.
 491    *
 492    * Note that TCP keepalive usually only kicks in after the connection has
 493    * been idle for several hours. Applications should almost always have their
 494    * own, shorter idle timeout.
 495    */
 496   void setKeepAliveEnabled(bool enabled) {
 497     keepAliveEnabled_ = enabled;
 498
 499     for (auto& handler : sockets_) {
 500       if (handler.socket_ < 0) {
 501         continue;
 502       }
 503
 504       int val = (enabled) ? 1 : 0;
 505       if (setsockopt(handler.socket_, SOL_SOCKET,
 506                      SO_KEEPALIVE, &val, sizeof(val)) != 0) {
 507         LOG(ERROR) << "failed to set SO_KEEPALIVE on async server socket: %s" <<
 508                 strerror(errno);
 509       }
 510     }
 511   }
 512
 513   /**
 514    * Get whether or not SO_KEEPALIVE is enabled on the server socket.
 515    */
 516   bool getKeepAliveEnabled() const {
 517     return keepAliveEnabled_;
 518   }
 519
 520   /**
 521    * Set whether or not SO_REUSEPORT should be enabled on the server socket,
 522    * allowing multiple binds to the same port
 523    */
 524   void setReusePortEnabled(bool enabled) {
 525     reusePortEnabled_ = enabled;
 526
 527     for (auto& handler : sockets_) {
 528       if (handler.socket_ < 0) {
 529         continue;
 530       }
 531
 532       int val = (enabled) ? 1 : 0;
 533       if (setsockopt(handler.socket_, SOL_SOCKET,
 534                      SO_REUSEPORT, &val, sizeof(val)) != 0) {
 535         LOG(ERROR) <<
 536           "failed to set SO_REUSEPORT on async server socket " << errno;
 537         folly::throwSystemError(errno,
 538                                 "failed to bind to async server socket");
 539       }
 540     }
 541   }
 542
 543   /**
 544    * Get whether or not SO_REUSEPORT is enabled on the server socket.
 545    */
 546   bool getReusePortEnabled_() const {
 547     return reusePortEnabled_;
 548   }
 549
 550   /**
 551    * Set whether or not the socket should close during exec() (FD_CLOEXEC). By
 552    * default, this is enabled
 553    */
 554   void setCloseOnExec(bool closeOnExec) {
 555     closeOnExec_ = closeOnExec;
 556   }
 557
 558   /**
 559    * Get whether or not FD_CLOEXEC is enabled on the server socket.
 560    */
 561   bool getCloseOnExec() const {
 562     return closeOnExec_;
 563   }
 564
 565  protected:
 566   /**
 567    * Protected destructor.
 568    *
 569    * Invoke destroy() instead to destroy the AsyncServerSocket.
 570    */
 571   virtual ~AsyncServerSocket();
 572
 573  private:
 574   enum class MessageType {
 575     MSG_NEW_CONN = 0,
 576     MSG_ERROR = 1
 577   };
 578
 579   struct QueueMessage {
 580     MessageType type;
 581     int fd;
 582     int err;
 583     SocketAddress address;
 584     std::string msg;
 585   };
 586
 587   /**
 588    * A class to receive notifications to invoke AcceptCallback objects
 589    * in other EventBase threads.
 590    *
 591    * A RemoteAcceptor object is created for each AcceptCallback that
 592    * is installed in a separate EventBase thread.  The RemoteAcceptor
 593    * receives notification of new sockets via a NotificationQueue,
 594    * and then invokes the AcceptCallback.
 595    */
 596   class RemoteAcceptor
 597       : private NotificationQueue<QueueMessage>::Consumer {
 598   public:
 599     explicit RemoteAcceptor(AcceptCallback *callback)
 600       : callback_(callback) {}
 601
 602     ~RemoteAcceptor() {}
 603
 604     void start(EventBase *eventBase, uint32_t maxAtOnce, uint32_t maxInQueue);
 605     void stop(EventBase* eventBase, AcceptCallback* callback);
 606
 607     virtual void messageAvailable(QueueMessage&& message);
 608
 609     NotificationQueue<QueueMessage>* getQueue() {
 610       return &queue_;
 611     }
 612
 613   private:
 614     AcceptCallback *callback_;
 615
 616     NotificationQueue<QueueMessage> queue_;
 617   };
 618
 619   /**
 620    * A struct to keep track of the callbacks associated with this server
 621    * socket.
 622    */
 623   struct CallbackInfo {
 624     CallbackInfo(AcceptCallback *cb, EventBase *evb)
 625       : callback(cb),
 626         eventBase(evb),
 627         consumer(nullptr) {}
 628
 629     AcceptCallback *callback;
 630     EventBase *eventBase;
 631
 632     RemoteAcceptor* consumer;
 633   };
 634
 635   class BackoffTimeout;
 636
 637   virtual void handlerReady(
 638     uint16_t events, int socket, sa_family_t family) noexcept;
 639
 640   int createSocket(int family);
 641   void setupSocket(int fd);
 642   void dispatchSocket(int socket, SocketAddress&& address);
 643   void dispatchError(const char *msg, int errnoValue);
 644   void enterBackoff();
 645   void backoffTimeoutExpired();
 646
 647   CallbackInfo* nextCallback() {
 648     CallbackInfo* info = &callbacks_[callbackIndex_];
 649
 650     ++callbackIndex_;
 651     if (callbackIndex_ >= callbacks_.size()) {
 652       callbackIndex_ = 0;
 653     }
 654
 655     return info;
 656   }
 657
 658   struct ServerEventHandler : public EventHandler {
 659     ServerEventHandler(EventBase* eventBase, int socket,
 660                        AsyncServerSocket* parent,
 661                       sa_family_t addressFamily)
 662         : EventHandler(eventBase, socket)
 663         , eventBase_(eventBase)
 664         , socket_(socket)
 665         , parent_(parent)
 666         , addressFamily_(addressFamily) {}
 667
 668     ServerEventHandler(const ServerEventHandler& other)
 669     : EventHandler(other.eventBase_, other.socket_)
 670     , eventBase_(other.eventBase_)
 671     , socket_(other.socket_)
 672     , parent_(other.parent_)
 673     , addressFamily_(other.addressFamily_) {}
 674
 675     ServerEventHandler& operator=(
 676         const ServerEventHandler& other) {
 677       if (this != &other) {
 678         eventBase_ = other.eventBase_;
 679         socket_ = other.socket_;
 680         parent_ = other.parent_;
 681         addressFamily_ = other.addressFamily_;
 682
 683         detachEventBase();
 684         attachEventBase(other.eventBase_);
 685         changeHandlerFD(other.socket_);
 686       }
 687       return *this;
 688     }
 689
 690     // Inherited from EventHandler
 691     virtual void handlerReady(uint16_t events) noexcept {
 692       parent_->handlerReady(events, socket_, addressFamily_);
 693     }
 694
 695     EventBase* eventBase_;
 696     int socket_;
 697     AsyncServerSocket* parent_;
 698     sa_family_t addressFamily_;
 699   };
 700
 701   EventBase *eventBase_;
 702   std::vector<ServerEventHandler> sockets_;
 703   std::vector<int> pendingCloseSockets_;
 704   bool accepting_;
 705   uint32_t maxAcceptAtOnce_;
 706   uint32_t maxNumMsgsInQueue_;
 707   double acceptRateAdjustSpeed_;  //0 to disable auto adjust
 708   double acceptRate_;
 709   std::chrono::time_point<std::chrono::steady_clock> lastAccepTimestamp_;
 710   uint64_t numDroppedConnections_;
 711   uint32_t callbackIndex_;
 712   BackoffTimeout *backoffTimeout_;
 713   std::vector<CallbackInfo> callbacks_;
 714   bool keepAliveEnabled_;
 715   bool reusePortEnabled_{false};
 716   bool closeOnExec_;
 717   ShutdownSocketSet* shutdownSocketSet_;
 718 };
 719
 720 } // folly