passenger 5.1.12 → 5.2.0

data/src/agent/Watchdog/Config.h

@@ -0,0 +1,340 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2011-2017 Phusion Holding B.V.
+ *
+ *  "Passenger", "Phusion Passenger" and "Union Station" are registered
+ *  trademarks of Phusion Holding B.V.
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *  THE SOFTWARE.
+ */
+
+#ifndef _PASSENGER_WATCHDOG_CONFIG_H_
+#define _PASSENGER_WATCHDOG_CONFIG_H_
+
+#include <ConfigKit/TableTranslator.h>
+#include <ConfigKit/PrefixTranslator.h>
+#include <Core/Config.h>
+#include <Watchdog/ApiServer.h>
+#include <Shared/ApiAccountUtils.h>
+#include <Utils.h>
+#include <Utils/StrIntUtils.h>
+
+namespace Passenger {
+namespace Watchdog {
+
+using namespace std;
+
+
+/*
+ * BEGIN ConfigKit schema: Passenger::Watchdog::Schema
+ * (do not edit: following text is automatically generated
+ * by 'rake configkit_schemas_inline_comments')
+ *
+ *   admin_panel_authentication                                               object             -          secret
+ *   admin_panel_close_timeout                                                float              -          default(10.0)
+ *   admin_panel_connect_timeout                                              float              -          default(30.0)
+ *   admin_panel_data_debug                                                   boolean            -          default(false)
+ *   admin_panel_ping_interval                                                float              -          default(30.0)
+ *   admin_panel_ping_timeout                                                 float              -          default(30.0)
+ *   admin_panel_proxy_password                                               string             -          secret
+ *   admin_panel_proxy_timeout                                                float              -          default(30.0)
+ *   admin_panel_proxy_url                                                    string             -          -
+ *   admin_panel_proxy_username                                               string             -          -
+ *   admin_panel_reconnect_timeout                                            float              -          default(5.0)
+ *   admin_panel_url                                                          string             -          read_only
+ *   admin_panel_websocketpp_debug_access                                     boolean            -          default(false)
+ *   admin_panel_websocketpp_debug_error                                      boolean            -          default(false)
+ *   app_output_log_level                                                     string             -          default("notice")
+ *   benchmark_mode                                                           string             -          -
+ *   config_manifest                                                          object             -          read_only
+ *   controller_accept_burst_count                                            unsigned integer   -          default(32)
+ *   controller_addresses                                                     array of strings   -          default,read_only
+ *   controller_client_freelist_limit                                         unsigned integer   -          default(0)
+ *   controller_cpu_affine                                                    boolean            -          default(false),read_only
+ *   controller_file_buffered_channel_auto_start_mover                        boolean            -          default(true)
+ *   controller_file_buffered_channel_auto_truncate_file                      boolean            -          default(true)
+ *   controller_file_buffered_channel_buffer_dir                              string             -          default
+ *   controller_file_buffered_channel_delay_in_file_mode_switching            unsigned integer   -          default(0)
+ *   controller_file_buffered_channel_max_disk_chunk_read_size                unsigned integer   -          default(0)
+ *   controller_file_buffered_channel_threshold                               unsigned integer   -          default(131072)
+ *   controller_mbuf_block_chunk_size                                         unsigned integer   -          default(4096),read_only
+ *   controller_min_spare_clients                                             unsigned integer   -          default(0)
+ *   controller_pid_file                                                      string             -          default,read_only
+ *   controller_request_freelist_limit                                        unsigned integer   -          default(1024)
+ *   controller_secure_headers_password                                       string             -          default,secret
+ *   controller_socket_backlog                                                unsigned integer   -          default(2048),read_only
+ *   controller_start_reading_after_accept                                    boolean            -          default(true)
+ *   controller_threads                                                       unsigned integer   -          default,read_only
+ *   core_api_server_accept_burst_count                                       unsigned integer   -          default(32)
+ *   core_api_server_addresses                                                array of strings   -          default([]),read_only
+ *   core_api_server_authorizations                                           array              -          default("[FILTERED]"),secret
+ *   core_api_server_client_freelist_limit                                    unsigned integer   -          default(0)
+ *   core_api_server_file_buffered_channel_auto_start_mover                   boolean            -          default(true)
+ *   core_api_server_file_buffered_channel_auto_truncate_file                 boolean            -          default(true)
+ *   core_api_server_file_buffered_channel_buffer_dir                         string             -          default
+ *   core_api_server_file_buffered_channel_delay_in_file_mode_switching       unsigned integer   -          default(0)
+ *   core_api_server_file_buffered_channel_max_disk_chunk_read_size           unsigned integer   -          default(0)
+ *   core_api_server_file_buffered_channel_threshold                          unsigned integer   -          default(131072)
+ *   core_api_server_mbuf_block_chunk_size                                    unsigned integer   -          default(4096),read_only
+ *   core_api_server_min_spare_clients                                        unsigned integer   -          default(0)
+ *   core_api_server_request_freelist_limit                                   unsigned integer   -          default(1024)
+ *   core_api_server_start_reading_after_accept                               boolean            -          default(true)
+ *   core_file_descriptor_ulimit                                              unsigned integer   -          default(0),read_only
+ *   core_pid_file                                                            string             -          read_only
+ *   daemonize                                                                boolean            -          default(false)
+ *   default_abort_websockets_on_process_shutdown                             boolean            -          default(true)
+ *   default_app_file_descriptor_ulimit                                       unsigned integer   -          -
+ *   default_environment                                                      string             -          default("production")
+ *   default_force_max_concurrent_requests_per_process                        integer            -          default(-1)
+ *   default_friendly_error_pages                                             string             -          default("auto")
+ *   default_group                                                            string             -          default
+ *   default_load_shell_envvars                                               boolean            -          default(false)
+ *   default_max_preloader_idle_time                                          unsigned integer   -          default(300)
+ *   default_max_request_queue_size                                           unsigned integer   -          default(100)
+ *   default_max_requests                                                     unsigned integer   -          default(0)
+ *   default_meteor_app_settings                                              string             -          -
+ *   default_min_instances                                                    unsigned integer   -          default(1)
+ *   default_nodejs                                                           string             -          default("node")
+ *   default_python                                                           string             -          default("python")
+ *   default_ruby                                                             string             -          default("ruby")
+ *   default_server_name                                                      string             -          default
+ *   default_server_port                                                      unsigned integer   -          default
+ *   default_spawn_method                                                     string             -          default("smart")
+ *   default_sticky_sessions                                                  boolean            -          default(false)
+ *   default_sticky_sessions_cookie_name                                      string             -          default("_passenger_route")
+ *   default_user                                                             string             -          default("nobody")
+ *   file_descriptor_log_target                                               any                -          -
+ *   graceful_exit                                                            boolean            -          default(true)
+ *   hook_after_watchdog_initialization                                       string             -          -
+ *   hook_after_watchdog_shutdown                                             string             -          -
+ *   hook_before_watchdog_initialization                                      string             -          -
+ *   hook_before_watchdog_shutdown                                            string             -          -
+ *   instance_registry_dir                                                    string             -          default,read_only
+ *   integration_mode                                                         string             -          default("standalone")
+ *   log_level                                                                string             -          default("notice")
+ *   log_target                                                               any                -          default({"stderr": true})
+ *   max_pool_size                                                            unsigned integer   -          default(6)
+ *   multi_app                                                                boolean            -          default(false),read_only
+ *   passenger_root                                                           string             required   read_only
+ *   pidfiles_to_delete_on_exit                                               array of strings   -          default([])
+ *   pool_idle_time                                                           unsigned integer   -          default(300)
+ *   pool_selfchecks                                                          boolean            -          default(false)
+ *   prestart_urls                                                            array of strings   -          default([]),read_only
+ *   response_buffer_high_watermark                                           unsigned integer   -          default(134217728)
+ *   security_update_checker_certificate_path                                 string             -          -
+ *   security_update_checker_disabled                                         boolean            -          default(false)
+ *   security_update_checker_interval                                         unsigned integer   -          default(86400)
+ *   security_update_checker_proxy_url                                        string             -          -
+ *   security_update_checker_url                                              string             -          default("https://securitycheck.phusionpassenger.com/v1/check.json")
+ *   server_software                                                          string             -          default("Phusion_Passenger/5.2.0")
+ *   setsid                                                                   boolean            -          default(false)
+ *   show_version_in_header                                                   boolean            -          default(true)
+ *   single_app_mode_app_root                                                 string             -          default,read_only
+ *   single_app_mode_app_type                                                 string             -          read_only
+ *   single_app_mode_startup_file                                             string             -          read_only
+ *   standalone_engine                                                        string             -          default
+ *   startup_report_file                                                      string             -          -
+ *   stat_throttle_rate                                                       unsigned integer   -          default(10)
+ *   turbocaching                                                             boolean            -          default(true),read_only
+ *   user                                                                     string             -          default,read_only
+ *   user_switching                                                           boolean            -          default(true)
+ *   ust_router_address                                                       string             -          -
+ *   ust_router_password                                                      string             -          secret
+ *   vary_turbocache_by_cookie                                                string             -          -
+ *   watchdog_api_server_accept_burst_count                                   unsigned integer   -          default(32)
+ *   watchdog_api_server_addresses                                            array of strings   -          default([]),read_only
+ *   watchdog_api_server_authorizations                                       array              -          default("[FILTERED]"),secret
+ *   watchdog_api_server_client_freelist_limit                                unsigned integer   -          default(0)
+ *   watchdog_api_server_file_buffered_channel_auto_start_mover               boolean            -          default(true)
+ *   watchdog_api_server_file_buffered_channel_auto_truncate_file             boolean            -          default(true)
+ *   watchdog_api_server_file_buffered_channel_buffer_dir                     string             -          default
+ *   watchdog_api_server_file_buffered_channel_delay_in_file_mode_switching   unsigned integer   -          default(0)
+ *   watchdog_api_server_file_buffered_channel_max_disk_chunk_read_size       unsigned integer   -          default(0)
+ *   watchdog_api_server_file_buffered_channel_threshold                      unsigned integer   -          default(131072)
+ *   watchdog_api_server_mbuf_block_chunk_size                                unsigned integer   -          default(4096),read_only
+ *   watchdog_api_server_min_spare_clients                                    unsigned integer   -          default(0)
+ *   watchdog_api_server_request_freelist_limit                               unsigned integer   -          default(1024)
+ *   watchdog_api_server_start_reading_after_accept                           boolean            -          default(true)
+ *   watchdog_pid_file                                                        string             -          read_only
+ *   watchdog_pid_file_autodelete                                             boolean            -          default(true)
+ *   web_server_module_version                                                string             -          read_only
+ *   web_server_version                                                       string             -          read_only
+ *
+ * END
+ */
+class Schema: public ConfigKit::Schema {
+private:
+	/**
+	 * Scans `schema` for all options that start with `matchPrefix`. For each matching option,
+	 * a translation is inserted in the form of `addPrefix + optionName => optionName`.
+	 */
+	static void addPrefixTranslationsForKeysThatStartWith(const ConfigKit::Schema &schema,
+		ConfigKit::TableTranslator &translator,
+		const StaticString &matchPrefix, const StaticString &addPrefix)
+	{
+		const Json::Value doc = schema.inspect();
+		Json::Value::const_iterator it, end = doc.end();
+		for (it = doc.begin(); it != end; it++) {
+			if (startsWith(it.name(), matchPrefix)) {
+				translator.add(addPrefix + it.name(), it.name());
+			}
+		}
+	}
+
+	// Prefix config options that come from the given schema
+	template<typename SchemaType>
+	static void addSubSchemaPrefixTranslations(ConfigKit::TableTranslator &translator,
+		const StaticString &prefix)
+	{
+		vector<string> keys = SchemaType().inspect().getMemberNames();
+		vector<string>::const_iterator it, end = keys.end();
+		for (it = keys.begin(); it != end; it++) {
+			translator.add(prefix + *it, *it);
+		}
+	}
+
+	// Some options set their default value to this function to indicate
+	// that their actual default values cannot be inferred from a ConfigKit default
+	// value getter function. Instead they are determined inside WatchdogMain.cpp.
+	static Json::Value dummyDefaultValueGetter(const ConfigKit::Store &store) {
+		return Json::Value();
+	}
+
+	static Json::Value getDefaultControllerSecureHeadersPassword(const ConfigKit::Store &store) {
+		return RandomGenerator().generateAsciiString(24);
+	}
+
+	static Json::Value getDefaultUser(const ConfigKit::Store &store) {
+		if (store["user_switching"].asBool()) {
+			return Json::nullValue;
+		} else {
+			return store["default_user"];
+		}
+	}
+
+	static Json::Value getDefaultInstanceRegistryDir(const ConfigKit::Store &store) {
+		return getSystemTempDir();
+	}
+
+	static void validateAddresses(const ConfigKit::Store &config, vector<ConfigKit::Error> &errors) {
+		typedef ConfigKit::Error Error;
+
+		if (config["watchdog_api_server_addresses"].size() > SERVER_KIT_MAX_SERVER_ENDPOINTS) {
+			errors.push_back(Error("'{{watchdog_api_server_addresses}}' may contain at most "
+				+ toString(SERVER_KIT_MAX_SERVER_ENDPOINTS) + " items"));
+		}
+	}
+
+	static Json::Value normalizePaths(const Json::Value &effectiveValues) {
+		Json::Value updates;
+		updates["instance_registry_dir"] = absolutizePath(effectiveValues["instance_registry_dir"].asString());
+		if (!effectiveValues["watchdog_pid_file"].isNull()) {
+			updates["watchdog_pid_file"] = absolutizePath(effectiveValues["watchdog_pid_file"].asString());
+		}
+		return updates;
+	}
+
+public:
+	struct {
+		Core::Schema schema;
+		ConfigKit::TableTranslator translator;
+	} core;
+	struct {
+		ApiServer::Schema schema;
+		ConfigKit::TableTranslator translator;
+	} apiServer;
+	struct {
+		ServerKit::Schema schema;
+		ConfigKit::PrefixTranslator translator;
+	} apiServerKit;
+
+	Schema() {
+		using namespace ConfigKit;
+
+		// Add subschema: core
+		addPrefixTranslationsForKeysThatStartWith(core.schema, core.translator,
+			"api_server_", "core_");
+		core.translator.add("core_authorizations", "authorizations");
+		core.translator.add("core_password", "password");
+		core.translator.add("core_pid_file", "pid_file");
+		core.translator.add("core_file_descriptor_ulimit", "file_descriptor_ulimit");
+		core.translator.finalize();
+		addSubSchema(core.schema, core.translator);
+		erase("instance_dir");
+		erase("watchdog_fd_passing_password");
+		/***********/
+		/***********/
+
+		// Add subschema: apiServer
+		addSubSchemaPrefixTranslations<ServerKit::HttpServerSchema>(
+			apiServer.translator, "watchdog_api_server_");
+		apiServer.translator.add("watchdog_api_server_authorizations", "authorizations");
+		apiServer.translator.finalize();
+		addSubSchema(apiServer.schema, apiServer.translator);
+		erase("fd_passing_password");
+
+		// Add subschema: apiServerKit
+		apiServerKit.translator.setPrefixAndFinalize("watchdog_api_server_");
+		addSubSchema(apiServerKit.schema, apiServerKit.translator);
+		erase("watchdog_api_server_secure_mode_password");
+
+
+		overrideWithDynamicDefault("controller_addresses", STRING_ARRAY_TYPE,
+			OPTIONAL | READ_ONLY, dummyDefaultValueGetter);
+		overrideWithDynamicDefault("controller_pid_file", STRING_TYPE,
+			OPTIONAL | READ_ONLY, dummyDefaultValueGetter);
+
+		overrideWithDynamicDefault("controller_secure_headers_password", STRING_TYPE,
+			OPTIONAL | SECRET | CACHE_DEFAULT_VALUE, getDefaultControllerSecureHeadersPassword);
+		add("watchdog_pid_file", STRING_TYPE, OPTIONAL | READ_ONLY);
+		add("watchdog_pid_file_autodelete", BOOL_TYPE, OPTIONAL, true);
+		add("watchdog_api_server_addresses", STRING_ARRAY_TYPE, OPTIONAL | READ_ONLY, Json::arrayValue);
+		add("setsid", BOOL_TYPE, OPTIONAL, false);
+		add("daemonize", BOOL_TYPE, OPTIONAL, false);
+		add("startup_report_file", STRING_TYPE, OPTIONAL);
+		add("pidfiles_to_delete_on_exit", STRING_ARRAY_TYPE, OPTIONAL, Json::arrayValue);
+		addWithDynamicDefault("user", STRING_TYPE,
+			OPTIONAL | READ_ONLY | CACHE_DEFAULT_VALUE, getDefaultUser);
+		addWithDynamicDefault("instance_registry_dir", STRING_TYPE,
+			OPTIONAL | READ_ONLY | CACHE_DEFAULT_VALUE, getDefaultInstanceRegistryDir);
+
+		add("hook_before_watchdog_initialization", STRING_TYPE, OPTIONAL);
+		add("hook_after_watchdog_initialization", STRING_TYPE, OPTIONAL);
+		add("hook_before_watchdog_shutdown", STRING_TYPE, OPTIONAL);
+		add("hook_after_watchdog_shutdown", STRING_TYPE, OPTIONAL);
+
+		/***********/
+		/***********/
+
+		addValidator(validateAddresses);
+
+		addNormalizer(normalizePaths);
+
+		/***********/
+		/***********/
+
+		finalize();
+	}
+};
+
+
+} // namespace Watchdog
+} // namespace Passenger
+
+#endif /* _PASSENGER_WATCHDOG_CONFIG_H_ */

data/src/agent/Watchdog/CoreWatcher.cpp

@@ -25,6 +25,7 @@
  */
 
 #include <Shared/Fundamentals/Utils.h>
+#include <Utils/MessageIO.h>
 
 class CoreWatcher: public AgentWatcher {
 protected:
@@ -52,9 +53,27 @@ protected:
 	}
 
 	virtual void sendStartupArguments(pid_t pid, FileDescriptor &fd) {
-		VariantMap options = *agentsOptions;
-		options.erase("ust_router_authorizations");
-		options.writeToFd(fd);
+		Json::Value config = watchdogSchema->core.translator.translate(
+			watchdogConfig->inspectEffectiveValues());
+
+		Json::Value::iterator it, end = wo->extraConfigToPassToSubAgents.end();
+		for (it = wo->extraConfigToPassToSubAgents.begin(); it != end; it++) {
+			config[it.name()] = *it;
+		}
+
+		config["pid_file"] = wo->corePidFile;
+		config["watchdog_fd_passing_password"] = wo->fdPassingPassword;
+		config["controller_addresses"] = wo->controllerAddresses;
+		config["api_server_addresses"] = wo->coreApiServerAddresses;
+		config["api_server_authorizations"] = wo->coreApiServerAuthorizations;
+
+		// The special value "-" means "don't set a controller secure headers password".
+		if (config["controller_secure_headers_password"].asString() == "-") {
+			config.removeMember("controller_secure_headers_password");
+		}
+
+		ConfigKit::Store filteredConfig(watchdogSchema->core.schema, config);
+		writeScalarMessage(fd, filteredConfig.inspectEffectiveValues().toStyledString());
 	}
 
 	virtual bool processStartupInfo(pid_t pid, FileDescriptor &fd, const vector<string> &args) {
@@ -65,17 +84,12 @@ public:
 	CoreWatcher(const WorkingObjectsPtr &wo)
 		: AgentWatcher(wo)
 	{
-		agentFilename = wo->resourceLocator->findSupportBinary(AGENT_EXE);
+		agentFilename = Agent::Fundamentals::context->
+			resourceLocator->findSupportBinary(AGENT_EXE);
 	}
 
-	virtual void reportAgentsInformation(VariantMap &report) {
-		const VariantMap &options = *agentsOptions;
-		vector<string> addresses = options.getStrSet("core_addresses");
-		report.set("core_address", addresses.front());
-		report.set("core_password", options.get("core_password"));
-
-		// For backwards compatibility:
-		report.set("server_address", addresses.front());
-		report.set("server_password", options.get("core_password"));
+	virtual void reportAgentStartupResult(Json::Value &report) {
+		report["core_address"] = wo->controllerAddresses[0].asString();
+		report["core_password"] = watchdogConfig->get("controller_secure_headers_password").asString();
 	}
 };

data/src/agent/Watchdog/InstanceDirToucher.cpp

@@ -110,7 +110,7 @@ private:
 
 	void
 	threadMain() {
-		string originalOomScore = agentsOptions->get("original_oom_score", false);
+		string originalOomScore = wo->extraConfigToPassToSubAgents["oom_score"].asString();
 		string workingDir = wo->instanceDir->getPath().c_str();
 
 		while (!boost::this_thread::interruption_requested()) {

data/src/agent/Watchdog/WatchdogMain.cpp

@@ -65,7 +65,9 @@
 #include <Shared/Fundamentals/Initialization.h>
 #include <Shared/ApiServerUtils.h>
 #include <Core/OptionParser.h>
+#include <Watchdog/Config.h>
 #include <Watchdog/ApiServer.h>
+#include <JsonTools/Autocast.h>
 #include <Constants.h>
 #include <InstanceDirectory.h>
 #include <FileDescriptor.h>
@@ -75,7 +77,6 @@
 #include <Exceptions.h>
 #include <StaticString.h>
 #include <Hooks.h>
-#include <ResourceLocator.h>
 #include <Utils.h>
 #include <Utils/Timer.h>
 #include <Utils/ScopeGuard.h>
@@ -106,34 +107,46 @@ class AgentWatcher;
 /***** Working objects *****/
 
 namespace Passenger {
-namespace WatchdogAgent {
+namespace Watchdog {
 	struct WorkingObjects {
 		RandomGenerator randomGenerator;
 		EventFd errorEvent;
 		EventFd exitEvent;
-		ResourceLocatorPtr resourceLocator;
 		uid_t defaultUid;
 		gid_t defaultGid;
 		InstanceDirectoryPtr instanceDir;
-		int reportFile;
+		int startupReportFile;
 		int lockFile;
 		vector<string> cleanupPidfiles;
 		bool pidsCleanedUp;
 		bool pidFileCleanedUp;
+		string corePidFile;
+		string fdPassingPassword;
+		Json::Value extraConfigToPassToSubAgents;
+		Json::Value controllerAddresses;
+		Json::Value coreApiServerAddresses;
+		Json::Value coreApiServerAuthorizations;
+		Json::Value watchdogApiServerAddresses;
+		Json::Value watchdogApiServerAuthorizations;
 
-		ApiAccountDatabase apiAccountDatabase;
 		int apiServerFds[SERVER_KIT_MAX_SERVER_ENDPOINTS];
 		BackgroundEventLoop *bgloop;
 		ServerKit::Context *serverKitContext;
-		ServerKit::HttpServerSchema apiServerSchema;
-		ApiServer *apiServer;
+		ServerKit::Schema serverKitSchema;
+		ApiServer::ApiServer *apiServer;
 
 		WorkingObjects()
 			: errorEvent(__FILE__, __LINE__, "WorkingObjects: errorEvent"),
 			  exitEvent(__FILE__, __LINE__, "WorkingObjects: exitEvent"),
-			  reportFile(-1),
+			  startupReportFile(-1),
 			  pidsCleanedUp(false),
 			  pidFileCleanedUp(false),
+			  extraConfigToPassToSubAgents(Json::objectValue),
+			  controllerAddresses(Json::arrayValue),
+			  coreApiServerAddresses(Json::arrayValue),
+			  coreApiServerAuthorizations(Json::arrayValue),
+			  watchdogApiServerAddresses(Json::arrayValue),
+			  watchdogApiServerAuthorizations(Json::arrayValue),
 			  bgloop(NULL),
 			  serverKitContext(NULL),
 			  apiServer(NULL)
@@ -145,12 +158,13 @@ namespace WatchdogAgent {
 	};
 
 	typedef boost::shared_ptr<WorkingObjects> WorkingObjectsPtr;
-} // namespace WatchdogAgent
+} // namespace Watchdog
 } // namespace Passenger
 
-using namespace Passenger::WatchdogAgent;
+using namespace Passenger::Watchdog;
 
-static VariantMap *agentsOptions;
+static Schema *watchdogSchema;
+static ConfigKit::Store *watchdogConfig;
 static WorkingObjects *workingObjects;
 
 static void cleanup(const WorkingObjectsPtr &wo);
@@ -347,10 +361,10 @@ readCleanupPids(const WorkingObjectsPtr &wo) {
 				buf[ret] = '\0';
 				result.push_back(atoi(buf));
 			} else {
-				P_WARN("Cannot read cleanup PID file " << filename);
+				P_WARN("Cannot read cleanup PID file " << relative(filename).c_str() << " (" << filename << ")");
 			}
 		} else {
-			P_WARN("Cannot open cleanup PID file " << filename);
+			P_WARN("Cannot open cleanup PID file " << relative(filename).c_str() << " (" << filename << ")");
 		}
 	}
 
@@ -378,9 +392,9 @@ killCleanupPids(const WorkingObjectsPtr &wo) {
 
 static void
 deletePidFile(const WorkingObjectsPtr &wo) {
-	string pidFile = agentsOptions->get("pid_file", false);
-	if (!pidFile.empty() && !wo->pidFileCleanedUp && agentsOptions->getBool("delete_pid_file")) {
-		syscalls::unlink(pidFile.c_str());
+	Json::Value pidFile = watchdogConfig->get("watchdog_pid_file");
+	if (!pidFile.isNull() && !wo->pidFileCleanedUp && watchdogConfig->get("watchdog_pid_file_autodelete").asBool()) {
+		syscalls::unlink(pidFile.asCString());
 		wo->pidFileCleanedUp = true;
 	}
 }
@@ -499,25 +513,14 @@ forceAllAgentsShutdown(const WorkingObjectsPtr &wo, vector<AgentWatcherPtr> &wat
 	}
 }
 
-static string
-inferDefaultGroup(const string &defaultUser) {
-	struct passwd *userEntry = getpwnam(defaultUser.c_str());
-	if (userEntry == NULL) {
-		throw ConfigurationException(
-			string("The user that PassengerDefaultUser refers to, '") +
-			defaultUser + "', does not exist.");
-	}
-	return getGroupName(userEntry->pw_gid);
-}
-
 static void
 runHookScriptAndThrowOnError(const char *name) {
 	TRACE_POINT();
 	HookScriptOptions options;
 
 	options.name = name;
-	options.spec = agentsOptions->get(string("hook_") + name, false);
-	options.agentsOptions = agentsOptions;
+	options.spec = watchdogConfig->get(string("hook_") + name).asString();
+	options.agentConfig = watchdogConfig->inspectEffectiveValues();
 
 	if (!runHookScripts(options)) {
 		throw RuntimeException(string("Hook script ") + name + " failed");
@@ -611,13 +614,14 @@ usage() {
 }
 
 static void
-parseOptions(int argc, const char *argv[], VariantMap &options) {
+parseOptions(int argc, const char *argv[], ConfigKit::Store &config) {
 	OptionParser p(usage);
+	Json::Value updates(Json::objectValue);
 	int i = 2;
 
 	while (i < argc) {
 		if (p.isValueFlag(argc, i, argv[i], '\0', "--passenger-root")) {
-			options.set("passenger_root", argv[i + 1]);
+			updates["passenger_root"] = argv[i + 1];
 			i += 2;
 		} else if (p.isFlag(argv[i], '\0', "--BC")
 			|| p.isFlag(argv[i], '\0', "--begin-core-args"))
@@ -633,10 +637,20 @@ parseOptions(int argc, const char *argv[], VariantMap &options) {
 				 || p.isFlag(argv[i], '\0', "--begin-ust-router-args"))
 				{
 					break;
-				} else if (!parseCoreOption(argc, argv, i, options)) {
-					fprintf(stderr, "ERROR: unrecognized core argument %s. Please "
-						"type '%s core --help' for usage.\n", argv[i], argv[0]);
-					exit(1);
+				} else {
+					Json::Value coreUpdates(Json::objectValue);
+					if (!parseCoreOption(argc, argv, i, coreUpdates)) {
+						fprintf(stderr, "ERROR: unrecognized core argument %s. Please "
+							"type '%s core --help' for usage.\n", argv[i], argv[0]);
+						exit(1);
+					}
+
+					Json::Value::iterator it, end = coreUpdates.end();
+					for (it = coreUpdates.begin(); it != end; it++) {
+						string translatedName = watchdogSchema->core.translator.
+							reverseTranslateOne(it.name());
+						updates[translatedName] = *it;
+					}
 				}
 			}
 		} else if (p.isFlag(argv[i], '\0', "--BU")
@@ -661,15 +675,13 @@ parseOptions(int argc, const char *argv[], VariantMap &options) {
 			}
 		} else if (p.isValueFlag(argc, i, argv[i], '\0', "--api-listen")) {
 			if (getSocketAddressType(argv[i + 1]) != SAT_UNKNOWN) {
-				vector<string> addresses = options.getStrSet("watchdog_api_addresses",
-					false);
+				Json::Value &addresses = updates["watchdog_api_server_addresses"];
 				if (addresses.size() == SERVER_KIT_MAX_SERVER_ENDPOINTS - 1) {
 					fprintf(stderr, "ERROR: you may specify up to %u --api-listen addresses.\n",
 						SERVER_KIT_MAX_SERVER_ENDPOINTS - 1);
 					exit(1);
 				}
-				addresses.push_back(argv[i + 1]);
-				options.setStrSet("watchdog_api_addresses", addresses);
+				addresses.append(argv[i + 1]);
 				i += 2;
 			} else {
 				fprintf(stderr, "ERROR: invalid address format for --api-listen. The address "
@@ -679,9 +691,6 @@ parseOptions(int argc, const char *argv[], VariantMap &options) {
 			}
 		} else if (p.isValueFlag(argc, i, argv[i], '\0', "--authorize")) {
 			vector<string> args;
-			vector<string> authorizations = options.getStrSet("watchdog_authorizations",
-				false);
-
 			split(argv[i + 1], ':', args);
 			if (args.size() < 2 || args.size() > 3) {
 				fprintf(stderr, "ERROR: invalid format for --authorize. The syntax "
@@ -689,46 +698,43 @@ parseOptions(int argc, const char *argv[], VariantMap &options) {
 				exit(1);
 			}
 
-			authorizations.push_back(argv[i + 1]);
-			options.setStrSet("watchdog_authorizations", authorizations);
+			updates["watchdog_api_server_authorizations"].append(argv[i + 1]);
 			i += 2;
 		} else if (p.isValueFlag(argc, i, argv[i], '\0', "--instance-registry-dir")) {
-			options.set("instance_registry_dir", argv[i + 1]);
+			updates["instance_registry_dir"] = argv[i + 1];
 			i += 2;
 		} else if (p.isFlag(argv[i], '\0', "--no-user-switching")) {
-			options.setBool("user_switching", false);
+			updates["user_switching"] = false;
 			i++;
 		} else if (p.isValueFlag(argc, i, argv[i], '\0', "--default-user")) {
-			options.set("default_user", argv[i + 1]);
+			updates["default_user"] = argv[i + 1];
 			i += 2;
 		} else if (p.isValueFlag(argc, i, argv[i], '\0', "--default-group")) {
-			options.set("default_group", argv[i + 1]);
+			updates["default_group"] = argv[i + 1];
 			i += 2;
 		} else if (p.isFlag(argv[i], '\0', "--daemonize")) {
-			options.setBool("daemonize", true);
+			updates["daemonize"] = true;
 			i++;
 		} else if (p.isValueFlag(argc, i, argv[i], '\0', "--user")) {
-			options.set("user", argv[i + 1]);
+			updates["user"] = argv[i + 1];
 			i += 2;
 		} else if (p.isValueFlag(argc, i, argv[i], '\0', "--pid-file")) {
-			options.set("pid_file", argv[i + 1]);
+			updates["watchdog_pid_file"] = argv[i + 1];
 			i += 2;
 		} else if (p.isFlag(argv[i], '\0', "--no-delete-pid-file")) {
-			options.setBool("delete_pid_file", false);
+			updates["watchdog_pid_file_autodelete"] = false;
 			i++;
 		} else if (p.isValueFlag(argc, i, argv[i], '\0', "--log-level")) {
-			options.setInt("log_level", atoi(argv[i + 1]));
+			updates["log_level"] = argv[i + 1];
 			i += 2;
 		} else if (p.isValueFlag(argc, i, argv[i], '\0', "--report-file")) {
-			options.set("report_file", argv[i + 1]);
+			updates["startup_report_file"] = argv[i + 1];
 			i += 2;
 		} else if (p.isValueFlag(argc, i, argv[i], '\0', "--cleanup-pidfile")) {
-			vector<string> pidfiles = options.getStrSet("cleanup_pidfiles", false);
-			pidfiles.push_back(argv[i + 1]);
-			options.setStrSet("cleanup_pidfiles", pidfiles);
+			updates["pidfiles_to_delete_on_exit"].append(argv[i + 1]);
 			i += 2;
 		} else if (p.isValueFlag(argc, i, argv[i], '\0', "--log-file")) {
-			options.set("debug_log_file", argv[i + 1]);
+			updates["log_target"] = argv[i + 1];
 			i += 2;
 		} else if (p.isValueFlag(argc, i, argv[i], '\0', "--ctl")) {
 			const char *value = strchr(argv[i + 1], '=');
@@ -744,7 +750,7 @@ parseOptions(int argc, const char *argv[], VariantMap &options) {
 					"The value must be non-empty.\n", argv[i + 1]);
 				exit(1);
 			}
-			options.set(name, value);
+			updates[name] = autocastValueToJson(value);
 			i += 2;
 		} else if (p.isFlag(argv[i], 'h', "--help")) {
 			usage();
@@ -755,6 +761,15 @@ parseOptions(int argc, const char *argv[], VariantMap &options) {
 			exit(1);
 		}
 	}
+
+	if (!updates.empty()) {
+		vector<ConfigKit::Error> errors;
+		if (!config.update(updates, errors)) {
+			P_BUG("Unable to set initial configuration: " <<
+				ConfigKit::toString(errors) << "\n"
+				"Raw initial configuration: " << updates.toStyledString());
+		}
+	}
 }
 
 static void
@@ -778,47 +793,18 @@ initializeBareEssentials(int argc, char *argv[], WorkingObjectsPtr &wo) {
 	 */
 	string oldOomScore = setOomScoreNeverKill();
 
-	agentsOptions = new VariantMap();
-	*agentsOptions = initializeAgent(argc, &argv, SHORT_PROGRAM_NAME " watchdog",
+	watchdogSchema = new Schema();
+	watchdogConfig = new ConfigKit::Store(*watchdogSchema);
+	initializeAgent(argc, &argv, SHORT_PROGRAM_NAME " watchdog",
+		*watchdogConfig, watchdogSchema->core.schema.loggingKit.translator,
 		parseOptions, NULL, 2);
-	agentsOptions->set("original_oom_score", oldOomScore);
 
 	// Start all sub-agents with this environment variable.
 	setenv("PASSENGER_USE_FEEDBACK_FD", "true", 1);
 
 	wo = boost::make_shared<WorkingObjects>();
 	workingObjects = wo.get();
-}
-
-static void
-setAgentsOptionsDefaults() {
-	VariantMap &options = *agentsOptions;
-
-	options.setDefault("instance_registry_dir", getSystemTempDir());
-	options.setDefaultBool("user_switching", true);
-	options.setDefault("default_user", DEFAULT_WEB_APP_USER);
-	if (!options.has("default_group")) {
-		options.set("default_group",
-			inferDefaultGroup(options.get("default_user")));
-	}
-	options.setDefault("integration_mode", DEFAULT_INTEGRATION_MODE);
-	if (options.get("integration_mode") == "standalone") {
-		options.setDefault("standalone_engine", "builtin");
-	}
-	options.setDefault("server_software", SERVER_TOKEN_NAME "/" PASSENGER_VERSION);
-	options.setDefaultStrSet("cleanup_pidfiles", vector<string>());
-	options.setDefault("data_buffer_dir", getSystemTempDir());
-	options.setDefaultBool("delete_pid_file", true);
-}
-
-static void
-sanityCheckOptions() {
-	VariantMap &options = *agentsOptions;
-
-	if (!options.has("passenger_root")) {
-		fprintf(stderr, "ERROR: please set the --passenger-root argument.\n");
-		exit(1);
-	}
+	wo->extraConfigToPassToSubAgents["oom_score"] = oldOomScore;
 }
 
 static void
@@ -831,7 +817,7 @@ maybeSetsid() {
 	 * WatchdogLauncher.h already calls setsid() before exec()ing
 	 * the Watchdog, but Flying Passenger does not.
 	 */
-	if (agentsOptions->getBool("setsid", false)) {
+	if (watchdogConfig->get("setsid").asBool()) {
 		setsid();
 	}
 }
@@ -850,7 +836,7 @@ maybeDaemonize() {
 	pid_t pid;
 	int e;
 
-	if (agentsOptions->getBool("daemonize", false)) {
+	if (watchdogConfig->get("daemonize").asBool()) {
 		pid = fork();
 		if (pid == 0) {
 			setsid();
@@ -867,16 +853,17 @@ maybeDaemonize() {
 static void
 createPidFile() {
 	TRACE_POINT();
-	string pidFile = agentsOptions->get("pid_file", false);
-	if (!pidFile.empty()) {
+	Json::Value pidFile = watchdogConfig->get("watchdog_pid_file");
+	if (!pidFile.isNull()) {
 		char pidStr[32];
 
 		snprintf(pidStr, sizeof(pidStr), "%lld", (long long) getpid());
 
-		int fd = syscalls::open(pidFile.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0644);
+		int fd = syscalls::open(pidFile.asCString(), O_WRONLY | O_CREAT | O_TRUNC, 0644);
 		if (fd == -1) {
 			int e = errno;
-			throw FileSystemException("Cannot create PID file " + pidFile, e, pidFile);
+			throw FileSystemException("Cannot create PID file " + pidFile.asString(),
+				e, pidFile.asString());
 		}
 
 		UPDATE_TRACE_POINT();
@@ -886,26 +873,27 @@ createPidFile() {
 }
 
 static void
-openReportFile(const WorkingObjectsPtr &wo) {
+openStartupReportFile(const WorkingObjectsPtr &wo) {
 	TRACE_POINT();
-	string reportFile = agentsOptions->get("report_file", false);
-	if (!reportFile.empty()) {
-		int fd = syscalls::open(reportFile.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0600);
+	Json::Value path = watchdogConfig->get("startup_report_file");
+	if (!path.isNull()) {
+		int fd = syscalls::open(path.asCString(), O_WRONLY | O_CREAT | O_TRUNC, 0600);
 		if (fd == -1) {
 			int e = errno;
-			throw FileSystemException("Cannot open report file " + reportFile, e, reportFile);
+			throw FileSystemException("Cannot open report file " + path.asString(),
+				e, path.asString());
 		}
 
-		P_LOG_FILE_DESCRIPTOR_OPEN4(fd, __FILE__, __LINE__, "WorkingObjects: reportFile");
-		wo->reportFile = fd;
+		P_LOG_FILE_DESCRIPTOR_OPEN4(fd, __FILE__, __LINE__, "WorkingObjects: startupReportFile");
+		wo->startupReportFile = fd;
 	}
 }
 
 static void
 chdirToTmpDir() {
-	vector<string> pidfiles = agentsOptions->getStrSet("cleanup_pidfiles", false);
-	if (pidfiles.size() > 0) {
-		string str = pidfiles.front();
+	const Json::Value pidfiles = watchdogConfig->get("pidfiles_to_delete_on_exit");
+	if (!pidfiles.empty()) {
+		string str = pidfiles[0].asString();
 		string dir = str.substr(0,str.find_last_of('/'));
 		if (dir != "" && chdir(dir.c_str()) == -1) {
 			throw RuntimeException("Cannot change working directory to " + dir);
@@ -916,8 +904,7 @@ chdirToTmpDir() {
 static void
 lowerPrivilege() {
 	TRACE_POINT();
-	const VariantMap &options = *agentsOptions;
-	string userName = options.get("user", false);
+	string userName = watchdogConfig->get("user").asString();
 
 	if (geteuid() == 0 && !userName.empty()) {
 		struct passwd *pwUser = getpwnam(userName.c_str());
@@ -965,9 +952,8 @@ lowerPrivilege() {
 
 static void
 lookupDefaultUidGid(uid_t &uid, gid_t &gid) {
-	VariantMap &options = *agentsOptions;
-	const string &defaultUser = options.get("default_user");
-	const string &defaultGroup = options.get("default_group");
+	const string defaultUser = watchdogConfig->get("default_user").asString();
+	const string defaultGroup = watchdogConfig->get("default_group").asString();
 	struct passwd *userEntry;
 
 	userEntry = getpwnam(defaultUser.c_str());
@@ -989,39 +975,32 @@ initializeWorkingObjects(const WorkingObjectsPtr &wo, InstanceDirToucherPtr &ins
 	uid_t uidBeforeLoweringPrivilege)
 {
 	TRACE_POINT();
-	VariantMap &options = *agentsOptions;
-	vector<string> strset;
-
-	options.set("instance_registry_dir",
-		absolutizePath(options.get("instance_registry_dir")));
-	if (options.get("server_software").find(SERVER_TOKEN_NAME) == string::npos
-	 && options.get("server_software").find(FLYING_PASSENGER_NAME) == string::npos)
-	{
-		options.set("server_software", options.get("server_software") +
-			(" " SERVER_TOKEN_NAME "/" PASSENGER_VERSION));
-	}
-
-	wo->resourceLocator = boost::make_shared<ResourceLocator>(agentsOptions->get("passenger_root"));
+	Json::Value doc;
+	Json::Value::iterator it, end;
 
 	UPDATE_TRACE_POINT();
 	lookupDefaultUidGid(wo->defaultUid, wo->defaultGid);
-	wo->cleanupPidfiles = options.getStrSet("cleanup_pidfiles", false);
+
+	doc = watchdogConfig->get("pidfiles_to_delete_on_exit");
+	for (it = doc.begin(); it != doc.end(); it++) {
+		wo->cleanupPidfiles.push_back(it->asString());
+	}
 
 	UPDATE_TRACE_POINT();
 	InstanceDirectory::CreationOptions instanceOptions;
-	instanceOptions.userSwitching = options.getBool("user_switching");
+	instanceOptions.userSwitching = watchdogConfig->get("user_switching").asBool();
 	instanceOptions.originalUid = uidBeforeLoweringPrivilege;
 	instanceOptions.defaultUid = wo->defaultUid;
 	instanceOptions.defaultGid = wo->defaultGid;
 	instanceOptions.properties["name"] = wo->randomGenerator.generateAsciiString(8);
-	instanceOptions.properties["integration_mode"] = options.get("integration_mode");
-	instanceOptions.properties["server_software"] = options.get("server_software");
-	if (options.get("integration_mode") == "standalone") {
-		instanceOptions.properties["standalone_engine"] = options.get("standalone_engine");
+	instanceOptions.properties["integration_mode"] = watchdogConfig->get("integration_mode").asString();
+	instanceOptions.properties["server_software"] = watchdogConfig->get("server_software").asString();
+	if (watchdogConfig->get("integration_mode").asString() == "standalone") {
+		instanceOptions.properties["standalone_engine"] = watchdogConfig->get("standalone_engine").asString();
 	}
 	wo->instanceDir = boost::make_shared<InstanceDirectory>(instanceOptions,
-		options.get("instance_registry_dir"));
-	options.set("instance_dir", wo->instanceDir->getPath());
+		watchdogConfig->get("instance_registry_dir").asString());
+	wo->extraConfigToPassToSubAgents["instance_dir"] = wo->instanceDir->getPath();
 	instanceDirToucher = boost::make_shared<InstanceDirToucher>(wo);
 
 	UPDATE_TRACE_POINT();
@@ -1039,7 +1018,7 @@ initializeWorkingObjects(const WorkingObjectsPtr &wo, InstanceDirToucherPtr &ins
 	UPDATE_TRACE_POINT();
 	string readOnlyAdminPassword = wo->randomGenerator.generateAsciiString(24);
 	string fullAdminPassword = wo->randomGenerator.generateAsciiString(24);
-	if (geteuid() == 0 && !options.getBool("user_switching")) {
+	if (geteuid() == 0 && !watchdogConfig->get("user_switching").asBool()) {
 		createFile(wo->instanceDir->getPath() + "/read_only_admin_password.txt",
 			readOnlyAdminPassword, S_IRUSR, wo->defaultUid, wo->defaultGid);
 		createFile(wo->instanceDir->getPath() + "/full_admin_password.txt",
@@ -1050,31 +1029,38 @@ initializeWorkingObjects(const WorkingObjectsPtr &wo, InstanceDirToucherPtr &ins
 		createFile(wo->instanceDir->getPath() + "/full_admin_password.txt",
 			fullAdminPassword, S_IRUSR | S_IWUSR);
 	}
-	options.setDefault("core_pid_file", wo->instanceDir->getPath() + "/core.pid");
-	options.set("watchdog_fd_passing_password", wo->randomGenerator.generateAsciiString(24));
+
+	if (watchdogConfig->get("core_pid_file").isNull()) {
+		wo->corePidFile = wo->instanceDir->getPath() + "/core.pid";
+	} else {
+		wo->corePidFile = watchdogConfig->get("core_pid_file").asString();
+	}
+	wo->fdPassingPassword = wo->randomGenerator.generateAsciiString(24);
 
 	UPDATE_TRACE_POINT();
-	strset = options.getStrSet("core_addresses", false);
-	strset.insert(strset.begin(),
-		"unix:" + wo->instanceDir->getPath() + "/agents.s/core");
-	options.setStrSet("core_addresses", strset);
-	options.setDefault("core_password",
-		wo->randomGenerator.generateAsciiString(24));
-
-	strset = options.getStrSet("core_api_addresses", false);
-	strset.insert(strset.begin(),
-		"unix:" + wo->instanceDir->getPath() + "/agents.s/core_api");
-	options.setStrSet("core_api_addresses", strset);
+	wo->controllerAddresses.append("unix:" + wo->instanceDir->getPath() + "/agents.s/core");
+	doc = watchdogConfig->get("controller_addresses");
+	for (it = doc.begin(); it != doc.end(); it++) {
+		wo->controllerAddresses.append(*it);
+	}
+
+	wo->coreApiServerAddresses.append("unix:" + wo->instanceDir->getPath() + "/agents.s/core_api");
+	doc = watchdogConfig->get("core_api_server_addresses");
+	for (it = doc.begin(); it != doc.end(); it++) {
+		wo->coreApiServerAddresses.append(*it);
+	}
 
 	UPDATE_TRACE_POINT();
-	strset = options.getStrSet("core_authorizations", false);
-	strset.insert(strset.begin(),
+	wo->coreApiServerAuthorizations.append(
 		"readonly:ro_admin:" + wo->instanceDir->getPath() +
 		"/read_only_admin_password.txt");
-	strset.insert(strset.begin(),
+	wo->coreApiServerAuthorizations.append(
 		"full:admin:" + wo->instanceDir->getPath() +
 		"/full_admin_password.txt");
-	options.setStrSet("core_authorizations", strset);
+	doc = watchdogConfig->get("core_api_server_authorizations");
+	for (it = doc.begin(); it != doc.end(); it++) {
+		wo->coreApiServerAuthorizations.append(*it);
+	}
 }
 
 static void
@@ -1095,57 +1081,65 @@ makeFileWorldReadableAndWritable(const string &path) {
 static void
 initializeApiServer(const WorkingObjectsPtr &wo) {
 	TRACE_POINT();
-	VariantMap &options = *agentsOptions;
-	vector<string> authorizations = options.getStrSet("watchdog_authorizations", false);
-	vector<string> apiAddresses = options.getStrSet("watchdog_api_addresses", false);
+	Json::Value doc;
+	Json::Value::iterator it;
 	string description;
 
 	UPDATE_TRACE_POINT();
-	authorizations.insert(authorizations.begin(),
+	wo->watchdogApiServerAuthorizations.append(
 		"readonly:ro_admin:" + wo->instanceDir->getPath() +
 		"/read_only_admin_password.txt");
-	authorizations.insert(authorizations.begin(),
+	wo->watchdogApiServerAuthorizations.append(
 		"full:admin:" + wo->instanceDir->getPath() +
 		"/full_admin_password.txt");
-	options.setStrSet("watchdog_authorizations", authorizations);
-
-	foreach (description, authorizations) {
-		try {
-			wo->apiAccountDatabase.add(description);
-		} catch (const ArgumentException &e) {
-			throw std::runtime_error(e.what());
-		}
+	doc = watchdogConfig->get("watchdog_api_server_authorizations");
+	for (it = doc.begin(); it != doc.end(); it++) {
+		wo->watchdogApiServerAuthorizations.append(*it);
 	}
 
 	UPDATE_TRACE_POINT();
-	apiAddresses.insert(apiAddresses.begin(),
-		"unix:" + wo->instanceDir->getPath() + "/agents.s/watchdog_api");
-	options.setStrSet("watchdog_api_addresses", apiAddresses);
+	wo->watchdogApiServerAddresses.append(
+		"unix:" + wo->instanceDir->getPath() +
+		"/agents.s/watchdog_api");
+	doc = watchdogConfig->get("watchdog_api_server_addresses");
+	for (it = doc.begin(); it != doc.end(); it++) {
+		wo->watchdogApiServerAddresses.append(*it);
+	}
 
 	UPDATE_TRACE_POINT();
-	for (unsigned int i = 0; i < apiAddresses.size(); i++) {
-		P_DEBUG("API server will listen on " << apiAddresses[i]);
-		wo->apiServerFds[i] = createServer(apiAddresses[i], 0, true,
+	for (unsigned int i = 0; i < wo->watchdogApiServerAddresses.size(); i++) {
+		string address = wo->watchdogApiServerAddresses[i].asString();
+		P_DEBUG("API server will listen on " << address);
+		wo->apiServerFds[i] = createServer(address, 0, true,
 			__FILE__, __LINE__);
-		if (getSocketAddressType(apiAddresses[i]) == SAT_UNIX) {
-			makeFileWorldReadableAndWritable(parseUnixSocketAddress(apiAddresses[i]));
+		if (getSocketAddressType(address) == SAT_UNIX) {
+			makeFileWorldReadableAndWritable(parseUnixSocketAddress(address));
 		}
 	}
 
 	UPDATE_TRACE_POINT();
+	Json::Value contextConfig = watchdogConfig->inspectEffectiveValues();
 	wo->bgloop = new BackgroundEventLoop(true, true);
-	wo->serverKitContext = new ServerKit::Context(wo->bgloop->safe,
-		wo->bgloop->libuv_loop);
-	wo->serverKitContext->defaultFileBufferedChannelConfig.bufferDir =
-		absolutizePath(options.get("data_buffer_dir"));
+	wo->serverKitContext = new ServerKit::Context(
+		watchdogSchema->apiServerKit.schema,
+		contextConfig,
+		watchdogSchema->apiServerKit.translator);
+	wo->serverKitContext->libev = wo->bgloop->safe;
+	wo->serverKitContext->libuv = wo->bgloop->libuv_loop;
+	wo->serverKitContext->initialize();
 
 	UPDATE_TRACE_POINT();
-	wo->apiServer = new ApiServer(wo->serverKitContext, wo->apiServerSchema);
-	wo->apiServer->apiAccountDatabase = &wo->apiAccountDatabase;
+	Json::Value apiServerConfig = watchdogConfig->inspectEffectiveValues();
+	apiServerConfig["fd_passing_password"] = wo->fdPassingPassword;
+	apiServerConfig["authorizations"] = wo->watchdogApiServerAuthorizations;
+	wo->apiServer = new ApiServer::ApiServer(
+		wo->serverKitContext,
+		watchdogSchema->apiServer.schema,
+		apiServerConfig,
+		watchdogSchema->apiServer.translator);
 	wo->apiServer->exitEvent = &wo->exitEvent;
-	wo->apiServer->fdPassingPassword = options.get("watchdog_fd_passing_password");
 	wo->apiServer->initialize();
-	for (unsigned int i = 0; i < apiAddresses.size(); i++) {
+	for (unsigned int i = 0; i < wo->watchdogApiServerAddresses.size(); i++) {
 		wo->apiServer->listen(wo->apiServerFds[i]);
 	}
 }
@@ -1199,34 +1193,27 @@ beginWatchingAgents(const WorkingObjectsPtr &wo, vector<AgentWatcherPtr> &watche
 }
 
 static void
-reportAgentsInformation(const WorkingObjectsPtr &wo, const vector<AgentWatcherPtr> &watchers) {
+reportStartupResult(const WorkingObjectsPtr &wo, const vector<AgentWatcherPtr> &watchers) {
 	TRACE_POINT();
-	VariantMap report;
+	Json::Value report;
 
-	report.set("instance_dir", wo->instanceDir->getPath());
+	report["instance_dir"] = wo->instanceDir->getPath();
 
 	foreach (AgentWatcherPtr watcher, watchers) {
-		watcher->reportAgentsInformation(report);
+		watcher->reportAgentStartupResult(report);
 	}
 
 	if (feedbackFdAvailable()) {
-		report.writeToFd(FEEDBACK_FD, "Agents information");
+		writeArrayMessage(FEEDBACK_FD, "Agents information", NULL);
+		writeScalarMessage(FEEDBACK_FD, report.toStyledString());
 	}
 
-	if (wo->reportFile != -1) {
-		Json::Value doc;
-		VariantMap::ConstIterator it;
-		string str;
-
-		for (it = report.begin(); it != report.end(); it++) {
-			doc[it->first] = it->second;
-		}
-		str = doc.toStyledString();
-
-		writeExact(wo->reportFile, str.data(), str.size());
-		close(wo->reportFile);
-		P_LOG_FILE_DESCRIPTOR_CLOSE(wo->reportFile);
-		wo->reportFile = -1;
+	if (wo->startupReportFile != -1) {
+		string str = report.toStyledString();
+		writeExact(wo->startupReportFile, str.data(), str.size());
+		close(wo->startupReportFile);
+		P_LOG_FILE_DESCRIPTOR_CLOSE(wo->startupReportFile);
+		wo->startupReportFile = -1;
 	}
 }
 
@@ -1262,10 +1249,7 @@ watchdogMain(int argc, char *argv[]) {
 	WorkingObjectsPtr wo;
 
 	initializeBareEssentials(argc, argv, wo);
-	setAgentsOptionsDefaults();
-	sanityCheckOptions();
 	P_NOTICE("Starting " SHORT_PROGRAM_NAME " watchdog...");
-	P_DEBUG("Watchdog options: " << agentsOptions->inspect());
 	InstanceDirToucherPtr instanceDirToucher;
 	vector<AgentWatcherPtr> watchers;
 	uid_t uidBeforeLoweringPrivilege = geteuid();
@@ -1275,7 +1259,7 @@ watchdogMain(int argc, char *argv[]) {
 		maybeSetsid();
 		maybeDaemonize();
 		createPidFile();
-		openReportFile(wo);
+		openStartupReportFile(wo);
 		chdirToTmpDir();
 		lowerPrivilege();
 		initializeWorkingObjects(wo, instanceDirToucher, uidBeforeLoweringPrivilege);
@@ -1309,7 +1293,7 @@ watchdogMain(int argc, char *argv[]) {
 		TRACE_POINT();
 		startAgents(wo, watchers);
 		beginWatchingAgents(wo, watchers);
-		reportAgentsInformation(wo, watchers);
+		reportStartupResult(wo, watchers);
 		finalizeInstanceDir(wo);
 		P_INFO("All " PROGRAM_NAME " agents started!");
 		UPDATE_TRACE_POINT();