validation: Add config validation mode. (#499)

include/envoy/server/instance.h

@@ -187,6 +187,11 @@ class Instance {
    * @return information about the local environment the server is running in.
    */
   virtual const LocalInfo::LocalInfo& localInfo() PURE;
+
+  /**
+   * @return the server-wide cluster manager factory.
+   */
+  virtual Upstream::ClusterManagerFactory& clusterManagerFactory() PURE;
 };
 
 } // Server

include/envoy/server/options.h

@@ -10,6 +10,31 @@
 
 namespace Server {
 
+/**
+ * Whether to run Envoy in serving mode, or in config validation mode at one of two levels (in which
+ * case we'll verify the configuration file is valid, print any errors, and exit without serving.)
+ */
+enum class Mode {
+  /**
+   * Default mode: Regular Envoy serving process. Configs are validated in the normal course of
+   * initialization, but if all is well we proceed to serve traffic.
+   */
+  Serve,
+
+  /**
+   * Validate as much as possible without opening network connections upstream or downstream.
+   */
+  Validate,
+
+  /**
+   * Mock out access to the filesystem. Perform no validation of files referenced in the config,
+   * such as runtime configs, SSL certs, etc. Validation will pass even if those files are malformed
+   * or don't exist, allowing the config to be validated in a non-prod environment.
+   * TODO(rlazarus): This isn't yet implemented.
+   */
+  ValidateLight,
+};
+
 /**
  * General options for the server.
  */
@@ -61,6 +86,12 @@ class Options {
    */
   virtual uint64_t restartEpoch() PURE;
 
+  /**
+   * @return whether to verify the configuration file is valid, print any errors, and exit
+   *         without serving.
+   */
+  virtual Mode mode() PURE;
+
   /**
     * @return std::chrono::milliseconds the duration in msec between log flushes.
     */

include/envoy/upstream/BUILD

@@ -15,9 +15,12 @@ envoy_cc_library(
         ":load_balancer_interface",
         ":thread_local_cluster_interface",
         ":upstream_interface",
+        "//include/envoy/access_log:access_log_interface",
         "//include/envoy/http:async_client_interface",
         "//include/envoy/http:conn_pool_interface",
         "//include/envoy/json:json_object_interface",
+        "//include/envoy/local_info:local_info_interface",
+        "//include/envoy/runtime:runtime_interface",
     ],
 )
 

include/envoy/upstream/cluster_manager.h

@@ -6,9 +6,12 @@
 #include <string>
 #include <unordered_map>
 
+#include "envoy/access_log/access_log.h"
 #include "envoy/http/async_client.h"
 #include "envoy/http/conn_pool.h"
 #include "envoy/json/json_object.h"
+#include "envoy/local_info/local_info.h"
+#include "envoy/runtime/runtime.h"
 #include "envoy/upstream/load_balancer.h"
 #include "envoy/upstream/thread_local_cluster.h"
 #include "envoy/upstream/upstream.h"
@@ -103,6 +106,8 @@ class ClusterManager {
   virtual void shutdown() PURE;
 };
 
+typedef std::unique_ptr<ClusterManager> ClusterManagerPtr;
+
 /**
  * Global configuration for any SDS clusters.
  */
@@ -139,6 +144,16 @@ class ClusterManagerFactory {
 public:
   virtual ~ClusterManagerFactory() {}
 
+  /**
+   * Allocate a cluster manager from configuration JSON.
+   */
+  virtual ClusterManagerPtr clusterManagerFromJson(const Json::Object& config, Stats::Store& stats,
+                                                   ThreadLocal::Instance& tls,
+                                                   Runtime::Loader& runtime,
+                                                   Runtime::RandomGenerator& random,
+                                                   const LocalInfo::LocalInfo& local_info,
+                                                   AccessLog::AccessLogManager& log_manager) PURE;
+
   /**
    * Allocate an HTTP connection pool.
    */

source/common/http/async_client_impl.cc

@@ -39,6 +39,7 @@ AsyncClient::Request* AsyncClientImpl::send(MessagePtr&& request, AsyncClient::C
                                             const Optional<std::chrono::milliseconds>& timeout) {
   AsyncRequestImpl* async_request =
       new AsyncRequestImpl(std::move(request), *this, callbacks, timeout);
+  async_request->initialize();
   std::unique_ptr<AsyncStreamImpl> new_request{async_request};
 
   // The request may get immediately failed. If so, we will return nullptr.
@@ -158,7 +159,9 @@ AsyncRequestImpl::AsyncRequestImpl(MessagePtr&& request, AsyncClientImpl& parent
                                    AsyncClient::Callbacks& callbacks,
                                    const Optional<std::chrono::milliseconds>& timeout)
     : AsyncStreamImpl(parent, *this, timeout), request_(std::move(request)), callbacks_(callbacks) {
+}
 
+void AsyncRequestImpl::initialize() {
   sendHeaders(request_->headers(), !request_->body());
   if (!remoteClosed() && request_->body()) {
     sendData(*request_->body(), true);

source/common/http/async_client_impl.h

@@ -216,6 +216,7 @@ class AsyncRequestImpl final : public AsyncClient::Request,
   virtual void cancel() override;
 
 private:
+  void initialize();
   void onComplete();
 
   // AsyncClient::StreamCallbacks

source/common/upstream/cluster_manager_impl.cc

@@ -546,6 +546,14 @@ ClusterManagerImpl::ThreadLocalClusterManagerImpl::ClusterEntry::connPool(
   return container.pools_[enumToInt(priority)].get();
 }
 
+ClusterManagerPtr ProdClusterManagerFactory::clusterManagerFromJson(
+    const Json::Object& config, Stats::Store& stats, ThreadLocal::Instance& tls,
+    Runtime::Loader& runtime, Runtime::RandomGenerator& random,
+    const LocalInfo::LocalInfo& local_info, AccessLog::AccessLogManager& log_manager) {
+  return ClusterManagerPtr{
+      new ClusterManagerImpl(config, *this, stats, tls, runtime, random, local_info, log_manager)};
+}
+
 Http::ConnectionPool::InstancePtr
 ProdClusterManagerFactory::allocateConnPool(Event::Dispatcher& dispatcher, HostConstSharedPtr host,
                                             ResourcePriority priority) {

source/common/upstream/cluster_manager_impl.h

@@ -37,6 +37,11 @@ class ProdClusterManagerFactory : public ClusterManagerFactory {
         local_info_(local_info) {}
 
   // Upstream::ClusterManagerFactory
+  ClusterManagerPtr clusterManagerFromJson(const Json::Object& config, Stats::Store& stats,
+                                           ThreadLocal::Instance& tls, Runtime::Loader& runtime,
+                                           Runtime::RandomGenerator& random,
+                                           const LocalInfo::LocalInfo& local_info,
+                                           AccessLog::AccessLogManager& log_manager) override;
   Http::ConnectionPool::InstancePtr allocateConnPool(Event::Dispatcher& dispatcher,
                                                      HostConstSharedPtr host,
                                                      ResourcePriority priority) override;

source/exe/BUILD

@@ -54,6 +54,8 @@ envoy_cc_library(
     deps = [
         ":envoy_common_lib",
         ":hot_restart_lib",
+        "//source/server/config_validation:hot_restart_lib",
+        "//source/server/config_validation:server_lib",
     ],
 )
 

source/exe/main.cc

@@ -8,6 +8,8 @@
 
 #include "exe/hot_restart.h"
 
+#include "server/config_validation/hot_restart.h"
+#include "server/config_validation/server.h"
 #include "server/drain_manager_impl.h"
 #include "server/options_impl.h"
 #include "server/server.h"
@@ -33,10 +35,36 @@ class ProdComponentFactory : public ComponentFactory {
 
 } // Server
 
+namespace {
+
+int validateConfig(OptionsImpl& options, Server::ProdComponentFactory& component_factory,
+                   const LocalInfo::LocalInfoImpl& local_info) {
+  Server::ValidationHotRestart restarter;
+  Logger::Registry::initialize(options.logLevel(), restarter.logLock());
+  Stats::HeapRawStatDataAllocator alloc;
+  Stats::ThreadLocalStoreImpl stats_store(alloc);
+
+  Server::ValidationInstance server(options, restarter, stats_store, restarter.accessLogLock(),
+                                    component_factory, local_info);
+  std::cout << "configuration '" << options.configPath() << "' OK" << std::endl;
+  server.shutdown();
+  return 0;
+}
+
+} // namespace
+
 int main(int argc, char** argv) {
-  ares_library_init(ARES_LIB_INIT_ALL);
   Event::Libevent::Global::initialize();
   OptionsImpl options(argc, argv, Server::SharedMemory::version(), spdlog::level::warn);
+  Server::ProdComponentFactory component_factory;
+  LocalInfo::LocalInfoImpl local_info(Network::Utility::getLocalAddress(), options.serviceZone(),
+                                      options.serviceClusterName(), options.serviceNodeName());
+
+  if (options.mode() != Server::Mode::Serve) {
+    return validateConfig(options, component_factory, local_info);
+  }
+
+  ares_library_init(ARES_LIB_INIT_ALL);
 
   std::unique_ptr<Server::HotRestartImpl> restarter;
   try {
@@ -49,9 +77,7 @@ int main(int argc, char** argv) {
   Logger::Registry::initialize(options.logLevel(), restarter->logLock());
   DefaultTestHooks default_test_hooks;
   Stats::ThreadLocalStoreImpl stats_store(*restarter);
-  Server::ProdComponentFactory component_factory;
-  LocalInfo::LocalInfoImpl local_info(Network::Utility::getLocalAddress(), options.serviceZone(),
-                                      options.serviceClusterName(), options.serviceNodeName());
+
   Server::InstanceImpl server(options, default_test_hooks, *restarter, stats_store,
                               restarter->accessLogLock(), component_factory, local_info);
   server.run();

source/server/BUILD

@@ -141,6 +141,7 @@ envoy_cc_library(
         "//source/common/ssl:context_lib",
         "//source/common/stats:statsd_lib",
         "//source/common/thread_local:thread_local_lib",
+        "//source/common/upstream:cluster_manager_lib",
         "//source/server/http:admin_lib",
     ],
 )

source/server/config_validation/BUILD

@@ -0,0 +1,104 @@
+licenses(["notice"])  # Apache 2
+
+package(default_visibility = ["//visibility:public"])
+
+load("//bazel:envoy_build_system.bzl", "envoy_cc_library")
+
+envoy_cc_library(
+    name = "api_lib",
+    srcs = ["api.cc"],
+    hdrs = ["api.h"],
+    deps = [
+        ":dispatcher_lib",
+        "//include/envoy/api:api_interface",
+        "//include/envoy/filesystem:filesystem_interface",
+        "//source/common/api:api_lib",
+    ],
+)
+
+envoy_cc_library(
+    name = "async_client_lib",
+    srcs = ["async_client.cc"],
+    hdrs = ["async_client.h"],
+    deps = [
+        "//include/envoy/http:async_client_interface",
+        "//include/envoy/http:message_interface",
+    ],
+)
+
+envoy_cc_library(
+    name = "cluster_manager_lib",
+    srcs = ["cluster_manager.cc"],
+    hdrs = ["cluster_manager.h"],
+    deps = [
+        ":async_client_lib",
+        "//include/envoy/upstream:cluster_manager_interface",
+        "//source/common/upstream:cluster_manager_lib",
+    ],
+)
+
+envoy_cc_library(
+    name = "connection_handler_lib",
+    srcs = ["connection_handler.cc"],
+    hdrs = ["connection_handler.h"],
+    deps = [
+        "//include/envoy/api:api_interface",
+        "//include/envoy/network:connection_handler_interface",
+        "//include/envoy/network:filter_interface",
+        "//include/envoy/network:listen_socket_interface",
+    ],
+)
+
+envoy_cc_library(
+    name = "dispatcher_lib",
+    srcs = ["dispatcher.cc"],
+    hdrs = ["dispatcher.h"],
+    deps = [
+        "//include/envoy/event:dispatcher_interface",
+        "//source/common/event:dispatcher_lib",
+    ],
+)
+
+envoy_cc_library(
+    name = "dns_lib",
+    srcs = ["dns.cc"],
+    hdrs = ["dns.h"],
+    deps = [
+        "//include/envoy/event:dispatcher_interface",
+        "//include/envoy/network:dns_interface",
+    ],
+)
+
+envoy_cc_library(
+    name = "hot_restart_lib",
+    hdrs = ["hot_restart.h"],
+    deps = [
+        "//include/envoy/server:hot_restart_interface",
+        "//source/common/common:thread_lib",
+    ],
+)
+
+envoy_cc_library(
+    name = "server_lib",
+    srcs = ["server.cc"],
+    hdrs = ["server.h"],
+    deps = [
+        ":api_lib",
+        ":cluster_manager_lib",
+        ":connection_handler_lib",
+        ":dns_lib",
+        "//include/envoy/common:optional",
+        "//include/envoy/server:drain_manager_interface",
+        "//include/envoy/server:instance_interface",
+        "//include/envoy/ssl:context_manager_interface",
+        "//include/envoy/tracing:http_tracer_interface",
+        "//source/common/access_log:access_log_manager_lib",
+        "//source/common/json:config_schemas_lib",
+        "//source/common/runtime:runtime_lib",
+        "//source/common/ssl:context_lib",
+        "//source/common/thread_local:thread_local_lib",
+        "//source/server:configuration_lib",
+        "//source/server:server_lib",
+        "//source/server/http:admin_lib",
+    ],
+)

source/server/config_validation/api.cc

@@ -0,0 +1,14 @@
+#include "server/config_validation/api.h"
+
+#include "server/config_validation/dispatcher.h"
+
+namespace Api {
+
+ValidationImpl::ValidationImpl(std::chrono::milliseconds file_flush_interval_msec)
+    : Impl(file_flush_interval_msec) {}
+
+Event::DispatcherPtr ValidationImpl::allocateDispatcher() {
+  return Event::DispatcherPtr{new Event::ValidationDispatcher()};
+}
+
+} // Api

source/server/config_validation/api.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "envoy/api/api.h"
+#include "envoy/filesystem/filesystem.h"
+
+#include "common/api/api_impl.h"
+
+namespace Api {
+
+/**
+ * Config-validation-only implementation of Api::Api. Delegates to Api::Impl,
+ * except for allocateDispatcher() which sets up a ValidationDispatcher.
+ */
+class ValidationImpl : public Impl {
+public:
+  ValidationImpl(std::chrono::milliseconds file_flush_interval_msec);
+
+  Event::DispatcherPtr allocateDispatcher() override;
+};
+
+} // Api

source/server/config_validation/async_client.cc

@@ -0,0 +1,15 @@
+#include "server/config_validation/async_client.h"
+
+namespace Http {
+
+AsyncClient::Request* ValidationAsyncClient::send(MessagePtr&&, Callbacks&,
+                                                  const Optional<std::chrono::milliseconds>&) {
+  return nullptr;
+}
+
+AsyncClient::Stream* ValidationAsyncClient::start(StreamCallbacks&,
+                                                  const Optional<std::chrono::milliseconds>&) {
+  return nullptr;
+}
+
+} // Http