connection handler: support multiple addresses in listener

envoy/network/connection_handler.h

@@ -219,15 +219,17 @@ class ActiveUdpListenerFactory {
    * @param runtime the runtime for this server.
    * @param worker_index The index of the worker this listener is being created on.
    * @param parent is the owner of the created ActiveListener objects.
+   * @param listen_socket_ptr is the UDP socket.
    * @param dispatcher is used to create actual UDP listener.
    * @param config provides information needed to create ActiveUdpListener and
    * UdpListener objects.
    * @return the ActiveUdpListener created.
    */
   virtual ConnectionHandler::ActiveUdpListenerPtr
   createActiveUdpListener(Runtime::Loader& runtime, uint32_t worker_index,
-                          UdpConnectionHandler& parent, Event::Dispatcher& dispatcher,
-                          Network::ListenerConfig& config) PURE;
+                          UdpConnectionHandler& parent,
+                          Network::SocketSharedPtr&& listen_socket_ptr,
+                          Event::Dispatcher& dispatcher, Network::ListenerConfig& config) PURE;
 
   /**
    * @return true if the UDP passing through listener doesn't form stateful connections.

envoy/network/listener.h

@@ -146,10 +146,16 @@ class ListenerConfig {
   virtual FilterChainFactory& filterChainFactory() PURE;
 
   /**
+   * TODO(soulxu): This will be removed when multiple addresses listener implemented.
    * @return ListenSocketFactory& the factory to create listen socket.
    */
   virtual ListenSocketFactory& listenSocketFactory() PURE;
 
+  /**
+   * @return std::vector<ListenSocketFactoryPtr>& the factories to create listen sockets.
+   */
+  virtual std::vector<ListenSocketFactoryPtr>& listenSocketFactories() PURE;
+
   /**
    * @return bool specifies whether the listener should actually listen on the port.
    *         A listener that doesn't listen on a port can only receive connections

source/common/quic/active_quic_listener.cc

@@ -26,21 +26,7 @@ bool ActiveQuicListenerFactory::disable_kernel_bpf_packet_routing_for_test_ = fa
 ActiveQuicListener::ActiveQuicListener(
     Runtime::Loader& runtime, uint32_t worker_index, uint32_t concurrency,
     Event::Dispatcher& dispatcher, Network::UdpConnectionHandler& parent,
-    Network::ListenerConfig& listener_config, const quic::QuicConfig& quic_config,
-    bool kernel_worker_routing, const envoy::config::core::v3::RuntimeFeatureFlag& enabled,
-    QuicStatNames& quic_stat_names, uint32_t packets_received_to_connection_count_ratio,
-    EnvoyQuicCryptoServerStreamFactoryInterface& crypto_server_stream_factory,
-    EnvoyQuicProofSourceFactoryInterface& proof_source_factory)
-    : ActiveQuicListener(runtime, worker_index, concurrency, dispatcher, parent,
-                         listener_config.listenSocketFactory().getListenSocket(worker_index),
-                         listener_config, quic_config, kernel_worker_routing, enabled,
-                         quic_stat_names, packets_received_to_connection_count_ratio,
-                         crypto_server_stream_factory, proof_source_factory) {}
-
-ActiveQuicListener::ActiveQuicListener(
-    Runtime::Loader& runtime, uint32_t worker_index, uint32_t concurrency,
-    Event::Dispatcher& dispatcher, Network::UdpConnectionHandler& parent,
-    Network::SocketSharedPtr listen_socket, Network::ListenerConfig& listener_config,
+    Network::SocketSharedPtr&& listen_socket, Network::ListenerConfig& listener_config,
     const quic::QuicConfig& quic_config, bool kernel_worker_routing,
     const envoy::config::core::v3::RuntimeFeatureFlag& enabled, QuicStatNames& quic_stat_names,
     uint32_t packets_to_read_to_connection_count_ratio,
@@ -338,11 +324,12 @@ ActiveQuicListenerFactory::ActiveQuicListenerFactory(
 
 Network::ConnectionHandler::ActiveUdpListenerPtr ActiveQuicListenerFactory::createActiveUdpListener(
     Runtime::Loader& runtime, uint32_t worker_index, Network::UdpConnectionHandler& parent,
-    Event::Dispatcher& disptacher, Network::ListenerConfig& config) {
+    Network::SocketSharedPtr&& listen_socket_ptr, Event::Dispatcher& disptacher,
+    Network::ListenerConfig& config) {
   ASSERT(crypto_server_stream_factory_.has_value());
   return std::make_unique<ActiveQuicListener>(
-      runtime, worker_index, concurrency_, disptacher, parent, config, quic_config_,
-      kernel_worker_routing_, enabled_, quic_stat_names_,
+      runtime, worker_index, concurrency_, disptacher, parent, std::move(listen_socket_ptr), config,
+      quic_config_, kernel_worker_routing_, enabled_, quic_stat_names_,
       packets_to_read_to_connection_count_ratio_, crypto_server_stream_factory_.value(),
       proof_source_factory_.value());
 }

source/common/quic/active_quic_listener.h

@@ -30,17 +30,7 @@ class ActiveQuicListener : public Envoy::Server::ActiveUdpListenerBase,
 
   ActiveQuicListener(Runtime::Loader& runtime, uint32_t worker_index, uint32_t concurrency,
                      Event::Dispatcher& dispatcher, Network::UdpConnectionHandler& parent,
-                     Network::ListenerConfig& listener_config, const quic::QuicConfig& quic_config,
-                     bool kernel_worker_routing,
-                     const envoy::config::core::v3::RuntimeFeatureFlag& enabled,
-                     QuicStatNames& quic_stat_names,
-                     uint32_t packets_to_read_to_connection_count_ratio,
-                     EnvoyQuicCryptoServerStreamFactoryInterface& crypto_server_stream_factory,
-                     EnvoyQuicProofSourceFactoryInterface& proof_source_factory);
-
-  ActiveQuicListener(Runtime::Loader& runtime, uint32_t worker_index, uint32_t concurrency,
-                     Event::Dispatcher& dispatcher, Network::UdpConnectionHandler& parent,
-                     Network::SocketSharedPtr listen_socket,
+                     Network::SocketSharedPtr&& listen_socket,
                      Network::ListenerConfig& listener_config, const quic::QuicConfig& quic_config,
                      bool kernel_worker_routing,
                      const envoy::config::core::v3::RuntimeFeatureFlag& enabled,
@@ -108,8 +98,9 @@ class ActiveQuicListenerFactory : public Network::ActiveUdpListenerFactory,
   // Network::ActiveUdpListenerFactory.
   Network::ConnectionHandler::ActiveUdpListenerPtr
   createActiveUdpListener(Runtime::Loader& runtime, uint32_t worker_index,
-                          Network::UdpConnectionHandler& parent, Event::Dispatcher& disptacher,
-                          Network::ListenerConfig& config) override;
+                          Network::UdpConnectionHandler& parent,
+                          Network::SocketSharedPtr&& listen_socket_ptr,
+                          Event::Dispatcher& disptacher, Network::ListenerConfig& config) override;
   bool isTransportConnectionless() const override { return false; }
   const Network::Socket::OptionsSharedPtr& socketOptions() const override { return options_; }
 

source/server/active_raw_udp_listener_config.cc

@@ -15,10 +15,11 @@ ActiveRawUdpListenerFactory::ActiveRawUdpListenerFactory(uint32_t concurrency)
 Network::ConnectionHandler::ActiveUdpListenerPtr
 ActiveRawUdpListenerFactory::createActiveUdpListener(Runtime::Loader&, uint32_t worker_index,
                                                      Network::UdpConnectionHandler& parent,
+                                                     Network::SocketSharedPtr&& listen_socket_ptr,
                                                      Event::Dispatcher& dispatcher,
                                                      Network::ListenerConfig& config) {
-  return std::make_unique<ActiveRawUdpListener>(worker_index, concurrency_, parent, dispatcher,
-                                                config);
+  return std::make_unique<ActiveRawUdpListener>(worker_index, concurrency_, parent,
+                                                std::move(listen_socket_ptr), dispatcher, config);
 }
 
 } // namespace Server

source/server/active_raw_udp_listener_config.h

@@ -11,8 +11,9 @@ class ActiveRawUdpListenerFactory : public Network::ActiveUdpListenerFactory {
 
   Network::ConnectionHandler::ActiveUdpListenerPtr
   createActiveUdpListener(Runtime::Loader&, uint32_t worker_index,
-                          Network::UdpConnectionHandler& parent, Event::Dispatcher& disptacher,
-                          Network::ListenerConfig& config) override;
+                          Network::UdpConnectionHandler& parent,
+                          Network::SocketSharedPtr&& listen_socket_ptr,
+                          Event::Dispatcher& disptacher, Network::ListenerConfig& config) override;
   bool isTransportConnectionless() const override { return true; }
   const Network::Socket::OptionsSharedPtr& socketOptions() const override { return options_; }
 

source/server/active_tcp_listener.cc

@@ -14,13 +14,12 @@ namespace Server {
 
 ActiveTcpListener::ActiveTcpListener(Network::TcpConnectionHandler& parent,
                                      Network::ListenerConfig& config, Runtime::Loader& runtime,
-                                     uint32_t worker_index)
-    : OwnedActiveStreamListenerBase(parent, parent.dispatcher(),
-                                    parent.dispatcher().createListener(
-                                        config.listenSocketFactory().getListenSocket(worker_index),
-                                        *this, runtime, config.bindToPort(),
-                                        config.ignoreGlobalConnLimit()),
-                                    config),
+                                     Network::SocketSharedPtr&& socket)
+    : OwnedActiveStreamListenerBase(
+          parent, parent.dispatcher(),
+          parent.dispatcher().createListener(std::move(socket), *this, runtime, config.bindToPort(),
+                                             config.ignoreGlobalConnLimit()),
+          config),
       tcp_conn_handler_(parent) {
   config.connectionBalancer().registerHandler(*this);
 }

source/server/active_tcp_listener.h

@@ -27,7 +27,7 @@ class ActiveTcpListener final : public Network::TcpListenerCallbacks,
                                 public Network::BalancedConnectionHandler {
 public:
   ActiveTcpListener(Network::TcpConnectionHandler& parent, Network::ListenerConfig& config,
-                    Runtime::Loader& runtime, uint32_t worker_index);
+                    Runtime::Loader& runtime, Network::SocketSharedPtr&& socket);
   ActiveTcpListener(Network::TcpConnectionHandler& parent, Network::ListenerPtr&& listener,
                     Network::ListenerConfig& config, Runtime::Loader& runtime);
   ~ActiveTcpListener() override;

source/server/active_udp_listener.cc

@@ -63,14 +63,6 @@ void ActiveUdpListenerBase::onData(Network::UdpRecvData&& data) {
   }
 }
 
-ActiveRawUdpListener::ActiveRawUdpListener(uint32_t worker_index, uint32_t concurrency,
-                                           Network::UdpConnectionHandler& parent,
-                                           Event::Dispatcher& dispatcher,
-                                           Network::ListenerConfig& config)
-    : ActiveRawUdpListener(worker_index, concurrency, parent,
-                           config.listenSocketFactory().getListenSocket(worker_index), dispatcher,
-                           config) {}
-
 ActiveRawUdpListener::ActiveRawUdpListener(uint32_t worker_index, uint32_t concurrency,
                                            Network::UdpConnectionHandler& parent,
                                            Network::SocketSharedPtr listen_socket_ptr,

source/server/active_udp_listener.h

@@ -65,9 +65,6 @@ class ActiveRawUdpListener : public ActiveUdpListenerBase,
                              public Network::UdpReadFilterCallbacks,
                              Logger::Loggable<Logger::Id::conn_handler> {
 public:
-  ActiveRawUdpListener(uint32_t worker_index, uint32_t concurrency,
-                       Network::UdpConnectionHandler& parent, Event::Dispatcher& dispatcher,
-                       Network::ListenerConfig& config);
   ActiveRawUdpListener(uint32_t worker_index, uint32_t concurrency,
                        Network::UdpConnectionHandler& parent,
                        Network::SocketSharedPtr listen_socket_ptr, Event::Dispatcher& dispatcher,

source/server/admin/admin.cc

@@ -128,7 +128,7 @@ void AdminImpl::startHttpListener(const std::list<AccessLog::InstanceSharedPtr>&
   socket_ = std::make_shared<Network::TcpListenSocket>(address, socket_options, true);
   RELEASE_ASSERT(0 == socket_->ioHandle().listen(ENVOY_TCP_BACKLOG_SIZE).return_value_,
                  "listen() failed on admin listener");
-  socket_factory_ = std::make_unique<AdminListenSocketFactory>(socket_);
+  socket_factories_.emplace_back(std::make_unique<AdminListenSocketFactory>(socket_));
   listener_ = std::make_unique<AdminListener>(*this, std::move(listener_scope));
   ENVOY_LOG(info, "admin address: {}",
             socket().connectionInfoProvider().localAddress()->asString());

source/server/admin/admin.h

@@ -390,7 +390,11 @@ class AdminImpl : public Admin,
     Network::FilterChainManager& filterChainManager() override { return parent_; }
     Network::FilterChainFactory& filterChainFactory() override { return parent_; }
     Network::ListenSocketFactory& listenSocketFactory() override {
-      return *parent_.socket_factory_;
+      ASSERT(parent_.socket_factories_.size() == 1);
+      return *parent_.socket_factories_[0];
+    }
+    std::vector<Network::ListenSocketFactoryPtr>& listenSocketFactories() override {
+      return parent_.socket_factories_;
     }
     bool bindToPort() override { return true; }
     bool handOffRestoredDestinationConnections() const override { return false; }
@@ -495,7 +499,7 @@ class AdminImpl : public Admin,
   ConfigTrackerImpl config_tracker_;
   const Network::FilterChainSharedPtr admin_filter_chain_;
   Network::SocketSharedPtr socket_;
-  Network::ListenSocketFactoryPtr socket_factory_;
+  std::vector<Network::ListenSocketFactoryPtr> socket_factories_;
   AdminListenerPtr listener_;
   const AdminInternalAddressConfig internal_address_config_;
   const LocalReply::LocalReplyPtr local_reply_;