passenger 5.1.12 → 5.2.0

data/src/cxx_supportlib/JsonTools/CBindings.h

@@ -0,0 +1,101 @@
+/*
+ *  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_JSON_TOOLS_CBINDINGS_H_
+#define _PASSENGER_JSON_TOOLS_CBINDINGS_H_
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+	extern "C" {
+#endif
+
+
+typedef enum {
+	PSG_JSON_VALUE_TYPE_NULL,
+	PSG_JSON_VALUE_TYPE_INT,
+	PSG_JSON_VALUE_TYPE_UINT,
+	PSG_JSON_VALUE_TYPE_REAL,
+	PSG_JSON_VALUE_TYPE_STRING,
+	PSG_JSON_VALUE_TYPE_BOOLEAN,
+	PSG_JSON_VALUE_TYPE_ARRAY,
+	PSG_JSON_VALUE_TYPE_OBJECT
+} PsgJsonValueType;
+
+typedef void PsgJsonValue;
+typedef void PsgJsonValueIterator;
+
+PsgJsonValue *psg_json_value_new_null();
+PsgJsonValue *psg_json_value_new_with_type(PsgJsonValueType type);
+PsgJsonValue *psg_json_value_new_str(const char *val, size_t size);
+PsgJsonValue *psg_json_value_new_int(int val);
+PsgJsonValue *psg_json_value_new_uint(unsigned int val);
+PsgJsonValue *psg_json_value_new_real(double val);
+PsgJsonValue *psg_json_value_new_bool(int val);
+void psg_json_value_free(PsgJsonValue *val);
+
+PsgJsonValue *psg_json_value_get_or_create_null(PsgJsonValue *doc, const char *name, size_t size);
+PsgJsonValue *psg_json_value_get(PsgJsonValue *doc, const char *name, size_t size);
+PsgJsonValue *psg_json_value_get_at_index(PsgJsonValue *doc, unsigned int index);
+PsgJsonValueType psg_json_value_type(const PsgJsonValue *doc);
+int psg_json_value_eq(const PsgJsonValue *doc, const PsgJsonValue *doc2);
+int psg_json_value_is_member(const PsgJsonValue *doc, const char *name, size_t size);
+unsigned int psg_json_value_size(const PsgJsonValue *doc);
+
+PsgJsonValue *psg_json_value_set_value(PsgJsonValue *doc, const char *name, size_t name_size, const PsgJsonValue *val);
+PsgJsonValue *psg_json_value_set_str(PsgJsonValue *doc, const char *name, const char *val, size_t size);
+PsgJsonValue *psg_json_value_set_int(PsgJsonValue *doc, const char *name, int val);
+PsgJsonValue *psg_json_value_set_uint(PsgJsonValue *doc, const char *name, unsigned int val);
+PsgJsonValue *psg_json_value_set_real(PsgJsonValue *doc, const char *name, double val);
+PsgJsonValue *psg_json_value_set_bool(PsgJsonValue *doc, const char *name, int val);
+
+PsgJsonValue *psg_json_value_append_val(PsgJsonValue *doc, const PsgJsonValue *val);
+void psg_json_value_swap(PsgJsonValue *doc, PsgJsonValue *doc2);
+
+int psg_json_value_is_null(const PsgJsonValue *doc);
+int psg_json_value_empty(const PsgJsonValue *doc);
+const char *psg_json_value_as_cstr(const PsgJsonValue *doc);
+const char *psg_json_value_get_str(const PsgJsonValue *doc, size_t *size);
+
+void psg_json_value_begin(PsgJsonValue *doc, PsgJsonValueIterator *it);
+void psg_json_value_end(PsgJsonValue *doc, PsgJsonValueIterator *it);
+
+char *psg_json_value_to_styled_string(const PsgJsonValue *doc);
+
+PsgJsonValue *psg_autocast_value_to_json(const char *data, size_t size, char **error);
+
+PsgJsonValueIterator *psg_json_value_iterator_new();
+void psg_json_value_iterator_free(PsgJsonValueIterator *it);
+void psg_json_value_iterator_advance(PsgJsonValueIterator *it);
+int psg_json_value_iterator_eq(PsgJsonValueIterator *it, PsgJsonValueIterator *other);
+const char *psg_json_value_iterator_get_name(PsgJsonValueIterator *it, size_t *size);
+PsgJsonValue *psg_json_value_iterator_get_value(PsgJsonValueIterator *it);
+
+
+#ifdef __cplusplus
+	} // extern "C"
+#endif
+
+#endif /* _PASSENGER_JSON_TOOLS_CBINDINGS_H_ */

data/src/cxx_supportlib/LoggingKit/Config.h

@@ -44,6 +44,19 @@ namespace LoggingKit {
 using namespace std;
 
 
+/*
+ * BEGIN ConfigKit schema: Passenger::LoggingKit::Schema
+ * (do not edit: following text is automatically generated
+ * by 'rake configkit_schemas_inline_comments')
+ *
+ *   app_output_log_level         string    -   default("notice")
+ *   file_descriptor_log_target   any       -   -
+ *   level                        string    -   default("notice")
+ *   redirect_stderr              boolean   -   default(true)
+ *   target                       any       -   default({"stderr": true})
+ *
+ * END
+ */
 class Schema: public ConfigKit::Schema {
 private:
 	static Json::Value createStderrTarget();

data/src/cxx_supportlib/LoggingKit/Context.h

@@ -79,7 +79,8 @@ private:
 	bool shuttingDown;
 
 public:
-	Context(const Json::Value &initialConfig = Json::Value());
+	Context(const Json::Value &initialConfig = Json::Value(),
+		const ConfigKit::Translator &translator = ConfigKit::DummyTranslator());
 	~Context();
 	ConfigKit::Store getConfig() const;
 
@@ -88,6 +89,7 @@ public:
 		LoggingKit::ConfigChangeRequest &req);
 	void commitConfigChange(LoggingKit::ConfigChangeRequest &req)
 		BOOST_NOEXCEPT_OR_NOTHROW;
+	Json::Value inspectConfig() const;
 
 	OXT_FORCE_INLINE
 	const ConfigRealization *getConfigRealization() const {
@@ -107,7 +109,8 @@ private:
 };
 
 
-void initialize(const Json::Value &initialConfig);
+void initialize(const Json::Value &initialConfig = Json::Value(),
+	const ConfigKit::Translator &translator = ConfigKit::DummyTranslator());
 
 
 } // namespace LoggingKit

data/src/cxx_supportlib/LoggingKit/Forward.h

@@ -74,7 +74,6 @@ enum TargetType {
 extern Context *context;
 
 
-void initialize(const Json::Value &initialConfig = Json::Value());
 void shutdown();
 
 const char *_strdupFastStringStream(const FastStringStream<> &stream);

data/src/cxx_supportlib/LoggingKit/Implementation.cpp

@@ -53,6 +53,7 @@
 #include <LoggingKit/Config.h>
 #include <LoggingKit/Context.h>
 #include <ConfigKit/ConfigKit.h>
+#include <FileTools/PathManip.h>
 #include <Utils.h>
 #include <Utils/StrIntUtils.h>
 #include <Utils/SystemTime.h>
@@ -70,8 +71,8 @@ AssertionFailureInfo lastAssertionFailure;
 
 
 void
-initialize(const Json::Value &initialConfig) {
-	context = new Context(initialConfig);
+initialize(const Json::Value &initialConfig, const ConfigKit::Translator &translator) {
+	context = new Context(initialConfig, translator);
 }
 
 void
@@ -404,8 +405,9 @@ normalizeConfig(const Json::Value &effectiveValues) {
 }
 
 
-Context::Context(const Json::Value &initialConfig)
-	: config(schema, initialConfig),
+Context::Context(const Json::Value &initialConfig,
+	const ConfigKit::Translator &translator)
+	: config(schema, initialConfig, translator),
 	  gcThread(NULL),
 	  shuttingDown(false)
 {
@@ -469,6 +471,12 @@ Context::commitConfigChange(LoggingKit::ConfigChangeRequest &req) BOOST_NOEXCEPT
 	newConfigRlz->finalize();
 }
 
+Json::Value
+Context::inspectConfig() const {
+	boost::lock_guard<boost::mutex> l(syncher);
+	return config.inspect();
+}
+
 pair<ConfigRealization*,MonotonicTimeUsec>
 Context::peekOldConfig() {
 	return oldConfigs.front();

data/src/cxx_supportlib/ResourceLocator.h

@@ -35,6 +35,7 @@
 #include <pwd.h>
 #include <Constants.h>
 #include <Exceptions.h>
+#include <FileTools/FileManip.h>
 #include <Utils.h>
 #include <Utils/IniFile.h>
 
@@ -53,6 +54,7 @@ using namespace boost;
 class ResourceLocator {
 private:
 	string installSpec;
+	string packagingMethod;
 	string binDir;
 	string supportBinariesDir;
 	string helperScriptsDir;
@@ -61,6 +63,7 @@ private:
 	string rubyLibDir;
 	string nodeLibDir;
 	string buildSystemDir;
+	bool originallyPackaged;
 
 	static string getOption(const string &file, const IniFileSectionPtr &section, const string &key) {
 		if (section->hasKey(key)) {
@@ -86,7 +89,9 @@ public:
 	{
 		if (getFileType(_installSpec) == FT_REGULAR) {
 			const string &file = _installSpec;
+			originallyPackaged = false;
 			IniFileSectionPtr options = IniFile(file).section("locations");
+			packagingMethod     = getOption(file, options, "packaging_method");
 			binDir              = getOption(file, options, "bin_dir");
 			supportBinariesDir  = getOption(file, options, "support_binaries_dir");
 			helperScriptsDir    = getOption(file, options, "helper_scripts_dir");
@@ -97,6 +102,8 @@ public:
 			buildSystemDir      = getOptionalSection(file, options, "node_libdir");
 		} else {
 			const string &root = _installSpec;
+			originallyPackaged  = true;
+			packagingMethod     = "unknown";
 			binDir              = root + "/bin";
 			supportBinariesDir  = root + "/buildout/support-binaries";
 			helperScriptsDir    = root + "/src/helper-scripts";
@@ -108,10 +115,18 @@ public:
 		}
 	}
 
+	bool isOriginallyPackaged() const {
+		return originallyPackaged;
+	}
+
 	const string &getInstallSpec() const {
 		return installSpec;
 	}
 
+	const string &getPackagingMethod() const {
+		return packagingMethod;
+	}
+
 	const string &getBinDir() const {
 		return binDir;
 	}

data/src/cxx_supportlib/ServerKit/Config.h

@@ -0,0 +1,156 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2014-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_SERVER_KIT_CONFIG_H_
+#define _PASSENGER_SERVER_KIT_CONFIG_H_
+
+// for std::swap()
+#if __cplusplus >= 201103L
+	#include <utility>
+#else
+	#include <algorithm>
+#endif
+#include <string>
+#include <boost/config.hpp>
+#include <boost/scoped_ptr.hpp>
+
+#include <ConfigKit/ConfigKit.h>
+#include <FileTools/PathManip.h>
+#include <Constants.h>
+#include <Utils.h>
+
+namespace Passenger {
+namespace ServerKit {
+
+using namespace std;
+
+
+/*
+ * BEGIN ConfigKit schema: Passenger::ServerKit::Schema
+ * (do not edit: following text is automatically generated
+ * by 'rake configkit_schemas_inline_comments')
+ *
+ *   file_buffered_channel_auto_start_mover               boolean            -   default(true)
+ *   file_buffered_channel_auto_truncate_file             boolean            -   default(true)
+ *   file_buffered_channel_buffer_dir                     string             -   default
+ *   file_buffered_channel_delay_in_file_mode_switching   unsigned integer   -   default(0)
+ *   file_buffered_channel_max_disk_chunk_read_size       unsigned integer   -   default(0)
+ *   file_buffered_channel_threshold                      unsigned integer   -   default(131072)
+ *   mbuf_block_chunk_size                                unsigned integer   -   default(4096),read_only
+ *   secure_mode_password                                 string             -   secret
+ *
+ * END
+ */
+class Schema: public ConfigKit::Schema {
+private:
+	static Json::Value getDefaultFileBufferedChannelBufferDir(const ConfigKit::Store &config) {
+		return getSystemTempDir();
+	}
+
+	static Json::Value normalize(const Json::Value &effectiveValues) {
+		Json::Value updates;
+
+		updates["file_buffered_channel_buffer_dir"] = absolutizePath(
+			effectiveValues["file_buffered_channel_buffer_dir"].asString());
+
+		return updates;
+	}
+
+public:
+	Schema() {
+		using namespace ConfigKit;
+
+		addWithDynamicDefault("file_buffered_channel_buffer_dir", STRING_TYPE,
+			OPTIONAL | CACHE_DEFAULT_VALUE, getDefaultFileBufferedChannelBufferDir);
+		add("file_buffered_channel_threshold", UINT_TYPE, OPTIONAL,
+			DEFAULT_FILE_BUFFERED_CHANNEL_THRESHOLD);
+		add("file_buffered_channel_delay_in_file_mode_switching", UINT_TYPE, OPTIONAL, 0);
+		add("file_buffered_channel_max_disk_chunk_read_size", UINT_TYPE, OPTIONAL, 0);
+		add("file_buffered_channel_auto_truncate_file", BOOL_TYPE, OPTIONAL, true);
+		// For unit testing purposes
+		add("file_buffered_channel_auto_start_mover", BOOL_TYPE, OPTIONAL, true);
+
+		add("mbuf_block_chunk_size", UINT_TYPE, OPTIONAL | READ_ONLY,
+			DEFAULT_MBUF_CHUNK_SIZE);
+		add("secure_mode_password", STRING_TYPE, OPTIONAL | SECRET);
+
+		addNormalizer(normalize);
+
+		finalize();
+	}
+};
+
+struct FileBufferedChannelConfig {
+	string bufferDir;
+	unsigned int threshold;
+	unsigned int delayInFileModeSwitching;
+	unsigned int maxDiskChunkReadSize;
+	bool autoTruncateFile;
+	bool autoStartMover;
+
+	FileBufferedChannelConfig(const ConfigKit::Store &config)
+		: bufferDir(config["file_buffered_channel_buffer_dir"].asString()),
+		  threshold(config["file_buffered_channel_threshold"].asUInt()),
+		  delayInFileModeSwitching(config["file_buffered_channel_delay_in_file_mode_switching"].asUInt()),
+		  maxDiskChunkReadSize(config["file_buffered_channel_max_disk_chunk_read_size"].asUInt()),
+		  autoTruncateFile(config["file_buffered_channel_auto_truncate_file"].asBool()),
+		  autoStartMover(config["file_buffered_channel_auto_start_mover"].asBool())
+		{ }
+
+	void swap(FileBufferedChannelConfig &other) BOOST_NOEXCEPT_OR_NOTHROW {
+		bufferDir.swap(other.bufferDir);
+		std::swap(threshold, other.threshold);
+		std::swap(delayInFileModeSwitching, other.delayInFileModeSwitching);
+		std::swap(maxDiskChunkReadSize, other.maxDiskChunkReadSize);
+		std::swap(autoTruncateFile, other.autoTruncateFile);
+		std::swap(autoStartMover, other.autoStartMover);
+	}
+};
+
+struct Config {
+	string secureModePassword;
+	FileBufferedChannelConfig fileBufferedChannelConfig;
+
+	Config(const ConfigKit::Store &config)
+		: secureModePassword(config["secure_mode_password"].asString()),
+		  fileBufferedChannelConfig(config)
+		{ }
+
+	void swap(Config &other) BOOST_NOEXCEPT_OR_NOTHROW {
+		secureModePassword.swap(other.secureModePassword);
+		fileBufferedChannelConfig.swap(other.fileBufferedChannelConfig);
+	}
+};
+
+struct ConfigChangeRequest {
+	boost::scoped_ptr<ConfigKit::Store> configStore;
+	boost::scoped_ptr<Config> config;
+};
+
+
+} // namespace ServerKit
+} // namespace Passenger
+
+#endif /* _PASSENGER_SERVER_KIT_CONFIG_H_ */

data/src/cxx_supportlib/ServerKit/Context.h

@@ -26,14 +26,16 @@
 #ifndef _PASSENGER_SERVER_KIT_CONTEXT_H_
 #define _PASSENGER_SERVER_KIT_CONTEXT_H_
 
-#include <boost/make_shared.hpp>
 #include <string>
-#include <cstddef>
-#include <jsoncpp/json.h>
+#include <boost/config.hpp>
+
+#include <ServerKit/Config.h>
+#include <ConfigKit/ConfigKit.h>
 #include <MemoryKit/mbuf.h>
+#include <LoggingKit/Assert.h>
 #include <SafeLibev.h>
-#include <Constants.h>
-#include <Utils/StrIntUtils.h>
+#include <Exceptions.h>
+#include <Utils.h>
 #include <Utils/JsonUtils.h>
 
 extern "C" {
@@ -43,54 +45,73 @@ extern "C" {
 namespace Passenger {
 namespace ServerKit {
 
+using namespace std;
 
-struct FileBufferedChannelConfig {
-	string bufferDir;
-	unsigned int threshold;
-	unsigned int delayInFileModeSwitching;
-	unsigned int maxDiskChunkReadSize;
-	bool autoTruncateFile;
-	bool autoStartMover;
-
-	FileBufferedChannelConfig()
-		: bufferDir("/tmp"),
-		  threshold(DEFAULT_FILE_BUFFERED_CHANNEL_THRESHOLD),
-		  delayInFileModeSwitching(0),
-		  maxDiskChunkReadSize(0),
-		  autoTruncateFile(true),
-		  autoStartMover(true)
-		{ }
-};
 
 class Context {
 private:
-	void initialize() {
-		mbuf_pool.mbuf_block_chunk_size = DEFAULT_MBUF_CHUNK_SIZE;
-		MemoryKit::mbuf_pool_init(&mbuf_pool);
-	}
+	ConfigKit::Store configStore;
 
 public:
+	typedef ServerKit::ConfigChangeRequest ConfigChangeRequest;
+
+	// Dependencies
 	SafeLibevPtr libev;
 	struct uv_loop_s *libuv;
+
+	// Others
+	Config config;
 	struct MemoryKit::mbuf_pool mbuf_pool;
-	string secureModePassword;
-	FileBufferedChannelConfig defaultFileBufferedChannelConfig;
 
-	Context(const SafeLibevPtr &_libev, struct uv_loop_s *_libuv)
-		: libev(_libev),
-		  libuv(_libuv)
-	{
-		initialize();
+	Context(const Schema &schema, const Json::Value &initialConfig = Json::Value(),
+		const ConfigKit::Translator &translator = ConfigKit::DummyTranslator())
+		: configStore(schema, initialConfig, translator),
+		  libuv(NULL),
+		  config(configStore)
+		{ }
+
+	~Context() {
+		MemoryKit::mbuf_pool_deinit(&mbuf_pool);
+	}
+
+	void initialize() {
+		if (libev == NULL) {
+			throw RuntimeException("libev must be non-NULL");
+		}
+		if (libuv == NULL) {
+			throw RuntimeException("libuv must be non-NULL");
+		}
+
+		mbuf_pool.mbuf_block_chunk_size = configStore["mbuf_block_chunk_size"].asUInt();
+		MemoryKit::mbuf_pool_init(&mbuf_pool);
 	}
 
-	Context(struct ev_loop *loop)
-		: libev(boost::make_shared<SafeLibev>(loop))
+	bool configure(const Json::Value &updates, vector<ConfigKit::Error> &errors) {
+		ConfigChangeRequest req;
+		bool result = prepareConfigChange(updates, errors, req);
+		if (result) {
+			commitConfigChange(req);
+		}
+		return result;
+	}
+
+	bool prepareConfigChange(const Json::Value &updates,
+		vector<ConfigKit::Error> &errors, ConfigChangeRequest &req)
 	{
-		initialize();
+		req.configStore.reset(new ConfigKit::Store(configStore, updates, errors));
+		if (errors.empty()) {
+			req.config.reset(new Config(*req.configStore));
+		}
+		return errors.empty();
 	}
 
-	~Context() {
-		MemoryKit::mbuf_pool_deinit(&mbuf_pool);
+	void commitConfigChange(ConfigChangeRequest &req) BOOST_NOEXCEPT_OR_NOTHROW {
+		configStore.swap(*req.configStore);
+		config.swap(*req.config);
+	}
+
+	Json::Value inspectConfig() const {
+		return configStore.inspect();
 	}
 
 	Json::Value inspectStateAsJson() const {