passenger 5.1.12 → 5.2.0

data/dev/configkit-schemas/update_schema_inline_comments.rb

@@ -0,0 +1,118 @@
+#!/usr/bin/env ruby
+require_relative '../../src/ruby_supportlib/phusion_passenger/utils/json'
+
+SimpleJSON = PhusionPassenger::Utils::JSON
+
+FILES = Dir['src/**/*.{h,cpp}']
+SCHEMAS = SimpleJSON.parse(File.read('dev/configkit-schemas/index.json'))
+
+def main
+  FILES.each do |path|
+    update_file(path)
+  end
+end
+
+def update_file(path)
+  content = File.open(path, 'r:utf-8') do |f|
+    f.read
+  end
+  orig_content = content.dup
+
+  pos = 0
+
+  while match_begin = /^(.*?)BEGIN ConfigKit schema: (.+)/.match(content, pos)
+    if match_end = /END/.match(content, match_begin.end(0))
+      prefix = match_begin.captures[0]
+      class_name = match_begin.captures[1]
+      replacement = format_inline_comment_for_schema(prefix, class_name)
+
+      content[match_begin.begin(0) .. match_end.end(0) - 1] = replacement
+      pos = match_begin.begin(0) + replacement.size
+    else
+      break
+    end
+  end
+
+  if content != orig_content
+    puts "Updating #{path}"
+    File.open(path, 'w:utf-8') do |f|
+      f.write(content)
+    end
+  end
+end
+
+def format_inline_comment_for_schema(prefix, class_name)
+  lines = [
+    "BEGIN ConfigKit schema: #{class_name}",
+    "(do not edit: following text is automatically generated",
+    "by 'rake configkit_schemas_inline_comments')",
+    ""
+  ]
+
+  if schema = SCHEMAS[class_name]
+    table = []
+    schema.each_pair do |key, info|
+      table << [
+        key,
+        info['type'],
+        info['required'] ? 'required' : '-',
+        format_option_names(info)
+      ]
+    end
+
+    column_lengths = find_max_column_lengths(table)
+    table.each do |row|
+      fmt = "  %-#{column_lengths[0]}s   %-#{column_lengths[1]}s   %-#{column_lengths[2]}s   %-#{column_lengths[3]}s"
+      lines << sprintf(fmt, *row)
+    end
+  else
+    lines << "(unknown: #{class_name} not in dev/configkit-schemas/index.json"
+    lines << " Please run:"
+    lines << "   touch src/schema_printer/SchemaPrinterMain.cpp.cxxcodebuilder"
+    lines << "   rake configkit_schemas_inline_comments"
+    lines << ")"
+  end
+
+  lines << ""
+  lines << "END"
+  lines.map{ |x| "#{prefix}#{x}".rstrip }.join("\n")
+end
+
+def format_option_names(schema_entry)
+  options = []
+  if schema_entry['has_default_value']
+    if schema_entry['has_default_value'] == 'static'
+      desc = format_default_value_desc(schema_entry['default_value'])
+      options << "default(#{desc})"
+    else
+      options << 'default'
+    end
+  end
+  options << 'secret' if schema_entry['secret']
+  options << 'read_only' if schema_entry['read_only']
+  result = options.join(',')
+  result = '-' if result.empty?
+  result
+end
+
+def format_default_value_desc(value)
+  if value.is_a?(Array) || value.is_a?(Hash)
+    SimpleJSON.generate(value)
+  else
+    SimpleJSON.generate([value]).sub(/\A\[/, '').sub(/\]\Z/, '')
+  end
+end
+
+def find_max_column_lengths(table)
+  lengths = []
+  table.each do |row|
+    row.each_with_index do |col, i|
+      if lengths[i].nil? || lengths[i] < col.size
+        lengths[i] = col.size
+      end
+    end
+  end
+  lengths
+end
+
+main

data/dev/copy_boost_headers

@@ -42,12 +42,19 @@ ESSENTIALS = [
   "boost/core",
   "boost/bind",
   "boost/function",
+  "boost/ratio*",
+  "boost/integer*",
+  "boost/chrono*",
+  "boost/random*",
+  "boost/asio*",
   "boost/optional.hpp",
   "boost/optional",
   "boost/utility",
   "libs/thread/src",
   "libs/system/src",
   "libs/regex/src",
+  "libs/chrono/src",
+  "libs/random/src",
   "boost/preprocessor",
   "boost/parameter",
   "boost/date_time/gregorian/formatters_limited.hpp",
@@ -74,7 +81,9 @@ EXCLUDE = [
   "libs/regex/src/icu.cpp",
   "libs/regex/src/usinstances.cpp",
   "boost/atomic/detail/windows.hpp",
-  "boost/regex/icu.hpp"
+  "boost/regex/icu.hpp",
+  "boost/asio/detail/win*",
+  "boost/asio/detail/impl/win*"
 ]
 PROGRAM_SOURCE = %q{
   #include <boost/shared_ptr.hpp>
@@ -99,6 +108,8 @@ PROGRAM_SOURCE = %q{
   #include <boost/move/utility.hpp>
   #include <boost/atomic.hpp>
   #include <boost/typeof/typeof.hpp>
+  #include <boost/asio.hpp>
+  #include <boost/pointer_cast.hpp>
 }
 
 require 'fileutils'
@@ -168,6 +179,7 @@ def cleanup
   FileUtils.rm_rf("boost/smart_ptr/detail/sp_counted_base_w32.hpp")
   FileUtils.rm_rf("boost/smart_ptr/detail/atomic_count_win32.hpp")
   FileUtils.rm_rf("boost/config/platform/win32.hpp")
+  FileUtils.rm_rf("boost/chrono/detail/inlined/win")
   File.unlink("test.cpp") rescue nil
 end
 

data/dev/index_cxx_dependencies.rb

@@ -6,6 +6,7 @@ SEARCH_PATHS = [
   "src/agent",
   "src/cxx_supportlib",
   "src/cxx_supportlib/vendor-copy",
+  "src/cxx_supportlib/vendor-copy/websocketpp",
   "src/cxx_supportlib/vendor-modified",
   "test/cxx"
 ]
@@ -153,6 +154,8 @@ def extract_dependencies(source)
       end
     end
   end
+  result.sort!
+  result.uniq!
   result
 end
 
@@ -164,7 +167,9 @@ def search_include_file(name, first_search_path = nil)
   end
   search_paths.each do |path|
     if File.exist?("#{path}/#{name}")
-      return "#{path}/#{name}"
+      result = File.expand_path("#{path}/#{name}")
+      result.sub!(/\A#{Regexp.escape(Dir.pwd)}\//, '')
+      return result
     end
   end
   nil
@@ -186,19 +191,27 @@ def gather_all_dependencies_recursively(source_file, basic_map, result)
   deps = basic_map[source_file]
   if deps
     deps.each do |dep|
-      result[dep] = true
-      gather_all_dependencies_recursively(dep, basic_map, result)
+      if !result[dep]
+        result[dep] = true
+        gather_all_dependencies_recursively(dep, basic_map, result)
+      end
     end
   end
 end
 
+def generate_full_map_for(source_file, basic_map)
+  gather_results = {}
+  gather_all_dependencies_recursively(
+    source_file, basic_map, gather_results)
+  result = gather_results.keys
+  result.sort!
+  result
+end
+
 def generate_full_map(basic_map)
   result = {}
   basic_map.keys.sort.each do |source_file|
-    gather_results = {}
-    gather_all_dependencies_recursively(
-      source_file, basic_map, gather_results)
-    result[source_file] = gather_results.keys.sort
+    result[source_file] = generate_full_map_for(source_file, basic_map)
   end
   result
 end

data/dev/vagrant/provision.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 set -ex
 set -o pipefail
 

data/resources/mime.types

@@ -30,6 +30,7 @@ types {
     application/vnd.ms-fontobject         eot;
 
     application/java-archive              jar war ear;
+    application/json                      json;
     application/mac-binhex40              hqx;
     application/msword                    doc;
     application/pdf                       pdf;

data/resources/templates/standalone/http.erb

@@ -3,7 +3,7 @@ include '<%= PhusionPassenger.resources_dir %>/mime.types';
 
 passenger_root '<%= PhusionPassenger.install_spec %>';
 passenger_abort_on_startup_error on;
-passenger_ctl cleanup_pidfiles <%= serialize_strset("#{@working_dir}/temp_dir_toucher.pid") %>;
+passenger_ctl pidfiles_to_delete_on_exit '["<%= "#{@working_dir}/temp_dir_toucher.pid" %>"]';
 passenger_ctl integration_mode standalone;
 passenger_ctl standalone_engine nginx;
 passenger_user_switching off;
@@ -17,11 +17,9 @@ passenger_user_switching off;
     <% if @options[:user] %>
         passenger_user <%= @options[:user] %>;
         passenger_default_user <%= @options[:user] %>;
-        passenger_analytics_log_user <%= @options[:user] %>;
     <% else %>
         passenger_user <%= current_user %>;
         passenger_default_user <%= current_user %>;
-        passenger_analytics_log_user <%= current_user %>;
     <% end %>
 <% end %>
 
@@ -38,9 +36,6 @@ passenger_user_switching off;
 <%= nginx_http_option(:security_update_check_proxy) %>
 <%= nginx_http_option(:data_buffer_dir) %>
 <%= nginx_http_option(:core_file_descriptor_ulimit) %>
-<%= nginx_http_option(:union_station_gateway_address) %>
-<%= nginx_http_option(:union_station_gateway_port) %>
-<%= nginx_http_option(:union_station_gateway_cert) %>
 <% @options[:ctls].each do |ctl| %>
     passenger_ctl '<%= ctl.split("=", 2)[0] %>' '<%= ctl.split("=", 2)[1] %>';
 <% end %>

data/src/agent/Core/AdminPanelConnector.h

@@ -0,0 +1,550 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 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_ADMIN_PANEL_CONNECTOR_H_
+#define _PASSENGER_ADMIN_PANEL_CONNECTOR_H_
+
+#include <sys/wait.h>
+
+#include <boost/scoped_ptr.hpp>
+#include <boost/thread.hpp>
+#include <boost/bind.hpp>
+
+#include <Constants.h>
+#include <WebSocketCommandReverseServer.h>
+#include <InstanceDirectory.h>
+#include <ConfigKit/SchemaUtils.h>
+#include <Core/ApplicationPool/Pool.h>
+#include <ProcessManagement/Ruby.h>
+#include <Utils/StrIntUtils.h>
+#include <Utils/IOUtils.h>
+
+#include <jsoncpp/json.h>
+
+namespace Passenger {
+namespace Core {
+
+using namespace std;
+using namespace oxt;
+
+class AdminPanelConnector {
+public:
+	/**
+	 * BEGIN ConfigKit schema: Passenger::Core::AdminPanelConnector::Schema
+	 * (do not edit: following text is automatically generated
+	 * by 'rake configkit_schemas_inline_comments')
+	 *
+	 *   authentication              object    -          secret
+	 *   close_timeout               float     -          default(10.0)
+	 *   connect_timeout             float     -          default(30.0)
+	 *   data_debug                  boolean   -          default(false)
+	 *   instance_dir                string    -          read_only
+	 *   integration_mode            string    -          default("standalone")
+	 *   log_prefix                  string    -          -
+	 *   ping_interval               float     -          default(30.0)
+	 *   ping_timeout                float     -          default(30.0)
+	 *   proxy_password              string    -          secret
+	 *   proxy_timeout               float     -          default(30.0)
+	 *   proxy_url                   string    -          -
+	 *   proxy_username              string    -          -
+	 *   reconnect_timeout           float     -          default(5.0)
+	 *   ruby                        string    -          default("ruby")
+	 *   standalone_engine           string    -          default
+	 *   url                         string    required   -
+	 *   web_server_module_version   string    -          read_only
+	 *   web_server_version          string    -          read_only
+	 *   websocketpp_debug_access    boolean   -          default(false)
+	 *   websocketpp_debug_error     boolean   -          default(false)
+	 *
+	 * END
+	 */
+	struct Schema: public WebSocketCommandReverseServer::Schema {
+		Schema()
+			: WebSocketCommandReverseServer::Schema(false)
+		{
+			using namespace ConfigKit;
+
+			add("integration_mode", STRING_TYPE, OPTIONAL, DEFAULT_INTEGRATION_MODE);
+			addWithDynamicDefault("standalone_engine", STRING_TYPE, OPTIONAL,
+				ConfigKit::getDefaultStandaloneEngine);
+			add("instance_dir", STRING_TYPE, OPTIONAL | READ_ONLY);
+			add("web_server_version", STRING_TYPE, OPTIONAL | READ_ONLY);
+			add("web_server_module_version", STRING_TYPE, OPTIONAL | READ_ONLY);
+			add("ruby", STRING_TYPE, OPTIONAL, "ruby");
+
+			addValidator(ConfigKit::validateIntegrationMode);
+			addValidator(ConfigKit::validateStandaloneEngine);
+
+			finalize();
+		}
+	};
+
+	typedef WebSocketCommandReverseServer::ConfigChangeRequest ConfigChangeRequest;
+
+	typedef WebSocketCommandReverseServer::ConnectionPtr ConnectionPtr;
+	typedef WebSocketCommandReverseServer::MessagePtr MessagePtr;
+	typedef boost::function<Json::Value (void)> ConfigGetter;
+
+private:
+	WebSocketCommandReverseServer server;
+	dynamic_thread_group threads;
+	Json::Value globalPropertiesFromInstanceDir;
+
+	bool onMessage(WebSocketCommandReverseServer *server,
+		const ConnectionPtr &conn, const MessagePtr &msg)
+	{
+		Json::Value doc;
+
+		try {
+			doc = parseAndBasicValidateMessageAsJSON(msg->get_payload());
+		} catch (const RuntimeException &e) {
+			Json::Value reply;
+			reply["result"] = "error";
+			reply["request_id"] = doc["request_id"];
+			reply["data"]["message"] = e.what();
+			sendJsonReply(conn, reply);
+			return true;
+		}
+
+		if (doc["action"] == "get") {
+			return onGetMessage(conn, doc);
+		} else {
+			return onUnknownMessageAction(conn, doc);
+		}
+	}
+
+
+	bool onGetMessage(const ConnectionPtr &conn, const Json::Value &doc) {
+		const string resource = doc["resource"].asString();
+
+		if (resource == "server_properties") {
+			return onGetServerProperties(conn, doc);
+		} else if (resource == "global_properties") {
+			return onGetGlobalProperties(conn, doc);
+		} else if (resource == "global_configuration") {
+			return onGetGlobalConfiguration(conn, doc);
+		} else if (resource == "global_statistics") {
+			return onGetGlobalStatistics(conn, doc);
+		} else if (resource == "application_properties") {
+			return onGetApplicationProperties(conn, doc);
+		} else if (resource == "application_configuration") {
+			return onGetApplicationConfig(conn, doc);
+		} else {
+			return onUnknownResource(conn, doc);
+		}
+	}
+
+	bool onGetServerProperties(const ConnectionPtr &conn, const Json::Value &doc) {
+		threads.create_thread(
+			boost::bind(&AdminPanelConnector::onGetServerPropertiesBgJob, this,
+				conn, doc, server.getConfig()["ruby"].asString()),
+			"AdminPanelCommandServer: get_server_properties background job",
+			128 * 1024);
+		return false;
+	}
+
+	void onGetServerPropertiesBgJob(const ConnectionPtr &conn, const Json::Value &doc,
+		const string &ruby)
+	{
+		vector<string> args;
+		args.push_back("passenger-config");
+		args.push_back("system-properties");
+
+		int status = 0;
+		string output;
+		try {
+			runInternalRubyTool(*resourceLocator, ruby, args, &status, &output);
+		} catch (const std::exception &e) {
+			server.getIoService().post(boost::bind(
+				&AdminPanelConnector::onGetServerPropertiesDone, this,
+				conn, doc, string(), -1, e.what()
+			));
+			return;
+		}
+
+		server.getIoService().post(boost::bind(
+			&AdminPanelConnector::onGetServerPropertiesDone, this,
+			conn, doc, output, status, string()
+		));
+	}
+
+	void onGetServerPropertiesDone(const ConnectionPtr &conn, const Json::Value &doc,
+		const string output, int status, const string &error)
+	{
+		Json::Value reply;
+		reply["request_id"] = doc["request_id"];
+		if (error.empty()) {
+			if (status == 0 || status == -1) {
+				Json::Reader reader;
+				Json::Value dataDoc;
+
+				if (output.empty()) {
+					reply["result"] = "error";
+					reply["data"]["message"] = "Error parsing internal helper tool output";
+					P_ERROR(getLogPrefix() << "Error parsing internal helper tool output.\n" <<
+						"Raw data: \"\"");
+				} else if (reader.parse(output, dataDoc)) {
+					reply["result"] = "ok";
+					reply["data"] = dataDoc;
+				} else {
+					reply["result"] = "error";
+					reply["data"]["message"] = "Error parsing internal helper tool output";
+					P_ERROR(getLogPrefix() << "Error parsing internal helper tool output.\n" <<
+						"Error: " << reader.getFormattedErrorMessages() << "\n"
+						"Raw data: \"" << cEscapeString(output) << "\"");
+				}
+			} else {
+				int exitStatus = WEXITSTATUS(status);
+				reply["result"] = "error";
+				reply["data"]["message"] = "Internal helper tool exited with status "
+					+ toString(exitStatus);
+				P_ERROR(getLogPrefix() << "Internal helper tool exited with status "
+					<< exitStatus << ". Raw output: \"" << cEscapeString(output) << "\"");
+			}
+		} else {
+			reply["result"] = "error";
+			reply["data"]["message"] = error;
+		}
+		sendJsonReply(conn, reply);
+		server.doneReplying(conn);
+	}
+
+	bool onGetGlobalProperties(const ConnectionPtr &conn, const Json::Value &doc) {
+		const ConfigKit::Store &config = server.getConfig();
+		Json::Value reply, data;
+		reply["result"] = "ok";
+		reply["request_id"] = doc["request_id"];
+
+		data = globalPropertiesFromInstanceDir;
+		data["version"] = PASSENGER_VERSION;
+		data["core_pid"] = Json::UInt(getpid());
+
+		string integrationMode = config["integration_mode"].asString();
+		data["integration_mode"]["name"] = integrationMode;
+		if (!config["web_server_module_version"].isNull()) {
+			data["integration_mode"]["web_server_module_version"] = config["web_server_module_version"];
+		}
+		if (integrationMode == "standalone") {
+			data["integration_mode"]["standalone_engine"] = config["standalone_engine"];
+		}
+		if (!config["web_server_version"].isNull()) {
+			data["integration_mode"]["web_server_version"] = config["web_server_version"];
+		}
+
+		data["originally_packaged"] = resourceLocator->isOriginallyPackaged();
+		if (!resourceLocator->isOriginallyPackaged()) {
+			data["packaging_method"] = resourceLocator->getPackagingMethod();
+		}
+
+		reply["data"] = data;
+		sendJsonReply(conn, reply);
+		return true;
+	}
+
+	bool onGetGlobalConfiguration(const ConnectionPtr &conn, const Json::Value &doc) {
+		threads.create_thread(
+			boost::bind(&AdminPanelConnector::onGetGlobalConfigurationBgJob, this,
+				conn, doc),
+			"AdminPanelCommandServer: get_global_config background job",
+			128 * 1024);
+		return false;
+	}
+
+	void onGetGlobalConfigurationBgJob(const ConnectionPtr &conn, const Json::Value &input) {
+		Json::Value globalConfig = configGetter()["config_manifest"]["effective_value"]["global_configuration"];
+		server.getIoService().post(boost::bind(
+			&AdminPanelConnector::onGetGlobalConfigDone, this,
+			conn, input, globalConfig
+		));
+	}
+
+	void onGetGlobalConfigDone(const ConnectionPtr &conn, const Json::Value &input,
+		Json::Value config)
+	{
+		Json::Value reply;
+
+		reply["result"] = "ok";
+		reply["request_id"] = input["request_id"];
+		reply["data"]["options"] = config;
+
+		sendJsonReply(conn, reply);
+		server.doneReplying(conn);
+	}
+
+	bool onGetGlobalStatistics(const ConnectionPtr &conn, const Json::Value &doc) {
+		Json::Value reply;
+		reply["result"] = "error";
+		reply["request_id"] = doc["request_id"];
+		reply["data"]["message"] = "Action not implemented";
+		sendJsonReply(conn, reply);
+		return true;
+	}
+
+	bool onGetApplicationProperties(const ConnectionPtr &conn, const Json::Value &doc) {
+		ConfigKit::Schema argumentsSchema =
+			ApplicationPool2::Pool::ToJsonOptions::createSchema();
+		Json::Value args(Json::objectValue), reply;
+		ApplicationPool2::Pool::ToJsonOptions inspectOptions =
+			ApplicationPool2::Pool::ToJsonOptions::makeAuthorized();
+
+		if (doc.isMember("arguments")) {
+			ConfigKit::Store store(argumentsSchema);
+			vector<ConfigKit::Error> errors;
+
+			if (store.update(doc["arguments"], errors)) {
+				inspectOptions.set(store.inspectEffectiveValues());
+			} else {
+				reply["result"] = "error";
+				reply["request_id"] = doc["request_id"];
+				reply["data"]["message"] = "Invalid arguments: " +
+					ConfigKit::toString(errors);
+				sendJsonReply(conn, reply);
+				return true;
+			}
+		}
+
+		reply["result"] = "ok";
+		reply["request_id"] = doc["request_id"];
+		reply["data"]["applications"] = appPool->inspectPropertiesInAdminPanelFormat(
+			inspectOptions);
+		sendJsonReply(conn, reply);
+		return true;
+	}
+
+	static void modifyEnvironmentVariables(Json::Value &option) {
+		Json::Value::iterator it;
+		for (it = option.begin(); it != option.end(); it++) {
+			Json::Value &suboption = *it;
+			suboption["value"] = suboption["value"].toStyledString();
+		}
+	}
+
+	bool onGetApplicationConfig(const ConnectionPtr &conn, const Json::Value &doc) {
+		Json::Value appConfigsContainer = configGetter()["config_manifest"]
+			["effective_value"]["application_configurations"];
+		Json::Value appConfigsContainerOutput;
+		Json::Value args(Json::objectValue), reply;
+
+		if (doc.isMember("arguments")) {
+			ConfigKit::Schema argumentsSchema =
+				ApplicationPool2::Pool::ToJsonOptions::createSchema();
+			ConfigKit::Store store(argumentsSchema);
+			vector<ConfigKit::Error> errors;
+
+			if (!store.update(doc["arguments"], errors)) {
+				reply["result"] = "error";
+				reply["request_id"] = doc["request_id"];
+				reply["data"]["message"] = "Invalid arguments: " +
+					ConfigKit::toString(errors);
+				sendJsonReply(conn, reply);
+				return true;
+			}
+
+			Json::Value allowedApplicationIds =
+				store.inspectEffectiveValues()["application_ids"];
+			if (allowedApplicationIds.isNull()) {
+				appConfigsContainerOutput = appConfigsContainer;
+			} else {
+				appConfigsContainerOutput = filterJsonObject(
+					appConfigsContainer,
+					allowedApplicationIds);
+			}
+		} else {
+			appConfigsContainerOutput = appConfigsContainer;
+		}
+
+		reply["result"] = "ok";
+		reply["request_id"] = doc["request_id"];
+		reply["data"]["options"] = appConfigsContainerOutput;
+
+		sendJsonReply(conn, reply);
+		return true;
+	}
+
+
+	bool onUnknownResource(const ConnectionPtr &conn, const Json::Value &doc) {
+		Json::Value reply;
+		reply["result"] = "error";
+		reply["request_id"] = doc["request_id"];
+		reply["data"]["message"] = "Unknown resource '" + doc["resource"].asString() + "'";
+		sendJsonReply(conn, reply);
+		return true;
+	}
+
+	bool onUnknownMessageAction(const ConnectionPtr &conn, const Json::Value &doc) {
+		Json::Value reply;
+		reply["result"] = "error";
+		reply["request_id"] = doc["request_id"];
+		reply["data"]["message"] = "Unknown action '" + doc["action"].asString() + "'";
+		sendJsonReply(conn, reply);
+		return true;
+	}
+
+
+	Json::Value parseAndBasicValidateMessageAsJSON(const string &msg) const {
+		Json::Value doc;
+		Json::Reader reader;
+		if (!reader.parse(msg, doc)) {
+			throw RuntimeException("Error parsing command JSON document: "
+				+ reader.getFormattedErrorMessages());
+		}
+
+		if (!doc.isObject()) {
+			throw RuntimeException("Invalid command JSON document: must be an object");
+		}
+		if (!doc.isMember("action")) {
+			throw RuntimeException("Invalid command JSON document: missing 'action' key");
+		}
+		if (!doc["action"].isString()) {
+			throw RuntimeException("Invalid command JSON document: the 'action' key must be a string");
+		}
+		if (!doc.isMember("request_id")) {
+			throw RuntimeException("Invalid command JSON document: missing 'request_id' key");
+		}
+		if (!doc.isMember("resource")) {
+			throw RuntimeException("Invalid command JSON document: missing 'resource' key");
+		}
+		if (!doc["resource"].isString()) {
+			throw RuntimeException("Invalid command JSON document: the 'resource' key must be a string");
+		}
+		if (doc.isMember("arguments") && !doc["arguments"].isObject()) {
+			throw RuntimeException("Invalid command JSON document: the 'arguments' key, when present, must be an object");
+		}
+
+		return doc;
+	}
+
+	void sendJsonReply(const ConnectionPtr &conn, const Json::Value &doc) {
+		Json::FastWriter writer;
+		string str = writer.write(doc);
+		WCRS_DEBUG_FRAME(&server, "Replying with:", str);
+		conn->send(str);
+	}
+
+	void readInstanceDirProperties(const string &instanceDir) {
+		Json::Value doc;
+		Json::Reader reader;
+
+		if (!reader.parse(readAll(instanceDir + "/properties.json"), doc)) {
+			throw RuntimeException("Cannot parse " + instanceDir + "/properties.json: "
+				+ reader.getFormattedErrorMessages());
+		}
+
+		globalPropertiesFromInstanceDir["instance_id"] = doc["instance_id"];
+		globalPropertiesFromInstanceDir["watchdog_pid"] = doc["watchdog_pid"];
+	}
+
+	Json::Value filterJsonObject(const Json::Value &object,
+		const Json::Value &allowedKeys) const
+	{
+		Json::Value::const_iterator it, end = allowedKeys.end();
+		Json::Value result(Json::objectValue);
+
+		for (it = allowedKeys.begin(); it != end; it++) {
+			if (object.isMember(it->asString())) {
+				result[it->asString()] = object[it->asString()];
+			}
+		}
+
+		return result;
+	}
+
+	void initializePropertiesWithoutInstanceDir() {
+		globalPropertiesFromInstanceDir["instance_id"] =
+			InstanceDirectory::generateInstanceId();
+	}
+
+	string getLogPrefix() const {
+		return server.getConfig()["log_prefix"].asString();
+	}
+
+	WebSocketCommandReverseServer::MessageHandler createMessageFunctor() {
+		return boost::bind(&AdminPanelConnector::onMessage, this,
+			boost::placeholders::_1, boost::placeholders::_2,
+			boost::placeholders::_3);
+	}
+
+public:
+	/******* Dependencies *******/
+
+	ResourceLocator *resourceLocator;
+	ApplicationPool2::PoolPtr appPool;
+	ConfigGetter configGetter;
+
+
+	AdminPanelConnector(const Schema &schema, const Json::Value &config,
+		const ConfigKit::Translator &translator = ConfigKit::DummyTranslator())
+		: server(schema, createMessageFunctor(), config, translator),
+		  resourceLocator(NULL)
+	{
+		if (!config["instance_dir"].isNull()) {
+			readInstanceDirProperties(config["instance_dir"].asString());
+		} else {
+			initializePropertiesWithoutInstanceDir();
+		}
+	}
+
+	void initialize() {
+		if (resourceLocator == NULL) {
+			throw RuntimeException("resourceLocator must be non-NULL");
+		}
+		if (appPool == NULL) {
+			throw RuntimeException("appPool must be non-NULL");
+		}
+		if (configGetter == NULL) {
+			throw RuntimeException("configGetter must be non-NULL");
+		}
+		server.initialize();
+	}
+
+	void run() {
+		server.run();
+	}
+
+	void asyncPrepareConfigChange(const Json::Value &updates,
+		ConfigChangeRequest &req,
+		const ConfigKit::CallbackTypes<WebSocketCommandReverseServer>::PrepareConfigChange &callback)
+	{
+		server.asyncPrepareConfigChange(updates, req, callback);
+	}
+
+	void asyncCommitConfigChange(ConfigChangeRequest &req,
+		const ConfigKit::CallbackTypes<WebSocketCommandReverseServer>::CommitConfigChange &callback)
+		BOOST_NOEXCEPT_OR_NOTHROW
+	{
+		server.asyncCommitConfigChange(req, callback);
+	}
+
+	void asyncShutdown(const WebSocketCommandReverseServer::Callback &callback
+		= WebSocketCommandReverseServer::Callback())
+	{
+		server.asyncShutdown(callback);
+	}
+};
+
+} // namespace Core
+} // namespace Passenger
+
+#endif /* _PASSENGER_ADMIN_PANEL_CONNECTOR_H_ */