config: v2 Address resolution using named resolver

include/envoy/network/BUILD

@@ -65,3 +65,11 @@ envoy_cc_library(
     name = "listener_interface",
     hdrs = ["listener.h"],
 )
+
+envoy_cc_library(
+    name = "resolver_interface",
+    hdrs = ["resolver.h"],
+    deps = [
+        ":address_interface",
+    ],
+)

include/envoy/network/address.h

@@ -101,7 +101,8 @@ class Instance {
   bool operator!=(const Instance& rhs) const { return !operator==(rhs); }
 
   /**
-   * @return a human readable string for the address.
+   * @return a human readable string for the address that represents the
+   * physical/resolved address.
    *
    * This string will be in the following format:
    * For IPv4 addresses: "1.2.3.4:80"
@@ -110,6 +111,15 @@ class Instance {
    */
   virtual const std::string& asString() const PURE;
 
+  /**
+   * @return a human readable string for the address that represents the
+   * logical/unresolved name.
+   *
+   * This string has a source-dependent format and should preserve the original
+   * name for Address::Instances resolved by a Network::Address::Resolver.
+   */
+  virtual const std::string& logicalName() const PURE;
+
   /**
    * Bind a socket to this address. The socket should have been created with a call to socket() on
    * an Instance of the same address family.

include/envoy/network/resolver.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <sys/types.h>
+
+#include <cstdint>
+#include <string>
+
+#include "envoy/common/pure.h"
+#include "envoy/network/address.h"
+
+#include "api/address.pb.h"
+
+namespace Envoy {
+namespace Network {
+namespace Address {
+
+/**
+ * Interface for all network address resolvers.
+ */
+class Resolver {
+public:
+  virtual ~Resolver() {}
+
+  /**
+   * Resolve a custom address string and port to an Address::Instance.
+   * @param socket_address supplies the socket address to resolve.
+   * @return InstanceConstSharedPtr appropriate Address::Instance.
+   */
+  virtual InstanceConstSharedPtr resolve(const envoy::api::v2::SocketAddress& socket_address) PURE;
+};
+
+typedef std::unique_ptr<Resolver> ResolverPtr;
+
+/**
+ * A factory for individual network address resolvers.
+ */
+class ResolverFactory {
+public:
+  virtual ~ResolverFactory() {}
+
+  virtual ResolverPtr createResolver() const PURE;
+
+  /**
+   * @return std::string the identifying name for a particular implementation of
+   * a resolver produced by the factory.
+   */
+  virtual std::string name() PURE;
+};
+
+typedef std::shared_ptr<ResolverFactory> ResolverFactorySharedPtr;
+
+} // namespace Address
+} // namespace Network
+} // namespace Envoy

include/envoy/registry/registry.h

@@ -46,6 +46,16 @@ template <class Base> class FactoryRegistry {
     return it->second;
   }
 
+  /**
+   * Remove a factory by name.
+   */
+  static void unregisterFactory(Base& factory) {
+    auto result = factories().erase(factory.name());
+    if (result == 0) {
+      throw EnvoyException(fmt::format("No registration for name: '{}'", factory.name()));
+    }
+  }
+
 private:
   /**
    * Gets the current map of factory implementations.
@@ -73,10 +83,17 @@ template <class T, class Base> class RegisterFactory {
   /**
    * Contructor that registers an instance of the factory with the FactoryRegistry.
    */
-  RegisterFactory() {
-    static T* instance = new T;
-    FactoryRegistry<Base>::registerFactory(*instance);
-  }
+  RegisterFactory() { FactoryRegistry<Base>::registerFactory(instance_); }
+
+  /**
+   * Destructor that removes an instance of the factory from the FactoryRegistry.
+   */
+  ~RegisterFactory() { FactoryRegistry<Base>::unregisterFactory(instance_); }
+
+  T& testGetFactory() { return instance_; }
+
+private:
+  T instance_;
 };
 
 } // namespace Registry

source/common/config/well_known_names.h

@@ -77,6 +77,17 @@ class NetworkFilterNameValues {
 
 typedef ConstSingleton<NetworkFilterNameValues> NetworkFilterNames;
 
+/**
+ * Well-known address resolver names.
+ */
+class AddressResolverNameValues {
+public:
+  // Basic IP resolver
+  const std::string IP = "envoy.ip";
+};
+
+typedef ConstSingleton<AddressResolverNameValues> AddressResolverNames;
+
 /**
  * Well-known http filter names.
  */

source/common/network/BUILD

@@ -132,6 +132,22 @@ envoy_cc_library(
     ],
 )
 
+envoy_cc_library(
+    name = "resolver_lib",
+    srcs = ["resolver_impl.cc"],
+    hdrs = ["resolver_impl.h"],
+    external_deps = ["envoy_base"],
+    deps = [
+        ":utility_lib",
+        "//include/envoy/network:address_interface",
+        "//include/envoy/network:resolver_interface",
+        "//include/envoy/registry",
+        "//source/common/config:well_known_names",
+        "//source/common/network:address_lib",
+        "//source/common/protobuf",
+    ],
+)
+
 envoy_cc_library(
     name = "utility_lib",
     srcs = ["utility.cc"],

source/common/network/address_impl.h

@@ -48,6 +48,8 @@ class InstanceBase : public Instance {
   // Network::Address::Instance
   bool operator==(const Instance& rhs) const override { return asString() == rhs.asString(); }
   const std::string& asString() const override { return friendly_name_; }
+  // Default logical name is the human-readable name.
+  const std::string& logicalName() const override { return asString(); }
   Type type() const override { return type_; }
 
 protected:

source/common/network/resolver_impl.cc

@@ -0,0 +1,84 @@
+#include "common/network/resolver_impl.h"
+
+#include "envoy/common/exception.h"
+#include "envoy/network/address.h"
+#include "envoy/network/resolver.h"
+#include "envoy/registry/registry.h"
+
+#include "common/config/well_known_names.h"
+#include "common/network/address_impl.h"
+#include "common/network/utility.h"
+
+#include "api/address.pb.h"
+
+namespace Envoy {
+namespace Network {
+namespace Address {
+
+/**
+ * Implementation of a resolver for IP addresses.
+ */
+class IpResolver : public Resolver {
+
+public:
+  InstanceConstSharedPtr resolve(const envoy::api::v2::SocketAddress& socket_address) {
+    switch (socket_address.port_specifier_case()) {
+    case envoy::api::v2::SocketAddress::kPortValue:
+    // Default to port 0 if no port value is specified.
+    case envoy::api::v2::SocketAddress::PORT_SPECIFIER_NOT_SET:
+      return Network::Utility::parseInternetAddress(socket_address.address(),
+                                                    socket_address.port_value());
+
+    default:
+      throw EnvoyException(fmt::format("IP resolver can't handle port specifier type {}",
+                                       socket_address.port_specifier_case()));
+    }
+  }
+};
+
+/**
+ * Implementation of an IP address resolver factory.
+ */
+class IpResolverFactory : public ResolverFactory {
+public:
+  ResolverPtr createResolver() const override { return ResolverPtr{new IpResolver()}; }
+
+  std::string name() override { return Config::AddressResolverNames::get().IP; }
+};
+
+/**
+ * Static registration for the IP resolver. @see RegisterFactory.
+ */
+static Registry::RegisterFactory<IpResolverFactory, ResolverFactory> ip_registered_;
+
+InstanceConstSharedPtr resolveProtoAddress(const envoy::api::v2::Address& address) {
+  switch (address.address_case()) {
+  case envoy::api::v2::Address::kSocketAddress:
+    return resolveProtoSocketAddress(address.socket_address());
+  case envoy::api::v2::Address::kPipe:
+    return InstanceConstSharedPtr{new PipeInstance(address.pipe().path())};
+  default:
+    throw EnvoyException("Address must be a socket or pipe: " + address.DebugString());
+  }
+}
+
+InstanceConstSharedPtr
+resolveProtoSocketAddress(const envoy::api::v2::SocketAddress& socket_address) {
+  const ResolverFactory* resolver_factory = nullptr;
+  const std::string& resolver_name = socket_address.resolver_name();
+  if (resolver_name.empty()) {
+    resolver_factory = Registry::FactoryRegistry<ResolverFactory>::getFactory(
+        Config::AddressResolverNames::get().IP);
+  } else {
+    resolver_factory = Registry::FactoryRegistry<ResolverFactory>::getFactory(resolver_name);
+  }
+  if (resolver_factory == nullptr) {
+    throw EnvoyException(fmt::format("Unknown address resolver: {}", resolver_name));
+  }
+  ResolverPtr resolver(resolver_factory->createResolver());
+  return resolver->resolve(socket_address);
+}
+
+} // namespace Address
+} // namespace Network
+} // namespace Envoy

source/common/network/resolver_impl.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "envoy/network/address.h"
+#include "envoy/network/connection.h"
+#include "envoy/network/resolver.h"
+
+#include "common/network/address_impl.h"
+
+#include "api/address.pb.h"
+
+namespace Envoy {
+namespace Network {
+namespace Address {
+/**
+ * Create an Instance from a envoy::api::v2::Address.
+ * @param address supplies the address proto to resolve.
+ * @return pointer to the Instance.
+ */
+Address::InstanceConstSharedPtr resolveProtoAddress(const envoy::api::v2::Address& address);
+
+/**
+ * Create an Instance from a envoy::api::v2::SocketAddress.
+ * @param address supplies the socket address proto to resolve.
+ * @return pointer to the Instance.
+ */
+Address::InstanceConstSharedPtr
+resolveProtoSocketAddress(const envoy::api::v2::SocketAddress& address);
+} // namespace Address
+} // namespace Network
+} // namespace Envoy

source/common/network/utility.cc

@@ -146,25 +146,6 @@ Address::InstanceConstSharedPtr Utility::copyInternetAddressAndPort(const Addres
   return std::make_shared<Address::Ipv6Instance>(ip.addressAsString(), ip.port());
 }
 
-Address::InstanceConstSharedPtr Utility::fromProtoAddress(const envoy::api::v2::Address& address) {
-  switch (address.address_case()) {
-  case envoy::api::v2::Address::kSocketAddress:
-    return Utility::fromProtoSocketAddress(address.socket_address());
-  case envoy::api::v2::Address::kPipe:
-    return Address::InstanceConstSharedPtr{new Address::PipeInstance(address.pipe().path())};
-  default:
-    throw EnvoyException("Address must be a socket or pipe: " + address.DebugString());
-  }
-}
-
-Address::InstanceConstSharedPtr
-Utility::fromProtoSocketAddress(const envoy::api::v2::SocketAddress& socket_address) {
-  // TODO(htuch): Support custom resolvers #1477.
-  ASSERT(socket_address.resolver_name().empty());
-  ASSERT(socket_address.named_port().empty());
-  return parseInternetAddress(socket_address.address(), socket_address.port_value());
-}
-
 void Utility::throwWithMalformedIp(const std::string& ip_address) {
   throw EnvoyException(fmt::format("malformed IP address: {}", ip_address));
 }

source/common/network/utility.h

@@ -85,21 +85,6 @@ class Utility {
    */
   static Address::InstanceConstSharedPtr parseInternetAddressAndPort(const std::string& ip_address);
 
-  /**
-   * Create an Instance from a envoy::api::v2::Address.
-   * @param address message.
-   * @return pointer to the Instance.
-   */
-  static Address::InstanceConstSharedPtr fromProtoAddress(const envoy::api::v2::Address& address);
-
-  /**
-   * Create an Instance from a envoy::api::v2::SocketAddress.
-   * @param socket address message.
-   * @return pointer to the Instance.
-   */
-  static Address::InstanceConstSharedPtr
-  fromProtoSocketAddress(const envoy::api::v2::SocketAddress& address);
-
   /**
    * Get the local address of the first interface address that is of type
    * version and is not a loopback address. If no matches are found, return the

source/common/upstream/BUILD

@@ -70,6 +70,7 @@ envoy_cc_library(
         "//source/common/http:async_client_lib",
         "//source/common/http/http1:conn_pool_lib",
         "//source/common/http/http2:conn_pool_lib",
+        "//source/common/network:resolver_lib",
         "//source/common/network:utility_lib",
         "//source/common/protobuf:utility_lib",
         "//source/common/router:shadow_writer_lib",
@@ -218,6 +219,7 @@ envoy_cc_library(
         "//source/common/config:utility_lib",
         "//source/common/config:well_known_names",
         "//source/common/network:address_lib",
+        "//source/common/network:resolver_lib",
         "//source/common/network:utility_lib",
     ],
 )
@@ -265,6 +267,7 @@ envoy_cc_library(
         "//source/common/config:tls_context_json_lib",
         "//source/common/http:utility_lib",
         "//source/common/network:address_lib",
+        "//source/common/network:resolver_lib",
         "//source/common/network:utility_lib",
         "//source/common/protobuf",
         "//source/common/protobuf:utility_lib",

source/common/upstream/cluster_manager_impl.cc

@@ -19,6 +19,7 @@
 #include "common/http/http1/conn_pool.h"
 #include "common/http/http2/conn_pool.h"
 #include "common/json/config_schemas.h"
+#include "common/network/resolver_impl.h"
 #include "common/network/utility.h"
 #include "common/protobuf/utility.h"
 #include "common/router/shadow_writer_impl.h"
@@ -196,7 +197,7 @@ ClusterManagerImpl::ClusterManagerImpl(const envoy::api::v2::Bootstrap& bootstra
   }
 
   if (bootstrap.cluster_manager().upstream_bind_config().has_source_address()) {
-    source_address_ = Network::Utility::fromProtoSocketAddress(
+    source_address_ = Network::Address::resolveProtoSocketAddress(
         bootstrap.cluster_manager().upstream_bind_config().source_address());
   }