passenger 5.2.3 → 5.3.0

data/src/agent/Core/Controller/InitRequest.cpp

@@ -49,7 +49,6 @@ using namespace boost;
 struct Controller::RequestAnalysis {
 	const LString *flags;
 	ServerKit::HeaderTable::Cell *appGroupNameCell;
-	bool unionStationSupport;
 };
 
 
@@ -189,9 +188,6 @@ Controller::fillPoolOptionsFromConfigCaches(Options &options,
 
 	options.logLevel = int(LoggingKit::getLevel());
 	options.integrationMode = psg_pstrdup(pool, mainConfig.integrationMode);
-	options.ustRouterAddress = requestConfig->ustRouterAddress;
-	options.ustRouterUsername = P_STATIC_STRING("logging");
-	options.ustRouterPassword = requestConfig->ustRouterPassword;
 	options.userSwitching = mainConfig.userSwitching;
 	options.defaultUser = requestConfig->defaultUser;
 	options.defaultGroup = requestConfig->defaultGroup;
@@ -381,45 +377,9 @@ Controller::createNewPoolOptions(Client *client, Request *req,
 	boost::shared_ptr<Options> optionsCopy = boost::make_shared<Options>(options);
 	optionsCopy->persist(options);
 	optionsCopy->clearPerRequestFields();
-	optionsCopy->detachFromUnionStationTransaction();
 	poolOptionsCache.insert(options.getAppGroupName(), optionsCopy);
 }
 
-void
-Controller::initializeUnionStation(Client *client, Request *req, RequestAnalysis &analysis) {
-	if (analysis.unionStationSupport) {
-		Options &options = req->options;
-		ServerKit::HeaderTable &headers = req->secureHeaders;
-
-		const LString *key = headers.lookup("!~UNION_STATION_KEY");
-		if (key == NULL || key->size == 0) {
-			disconnectWithError(&client, "header !~UNION_STATION_KEY must be set.");
-			return;
-		}
-		key = psg_lstr_make_contiguous(key, req->pool);
-
-		const LString *filters = headers.lookup("!~UNION_STATION_FILTERS");
-		if (filters != NULL) {
-			filters = psg_lstr_make_contiguous(filters, req->pool);
-		}
-
-		options.transaction = unionStationContext->newTransaction(
-			options.getAppGroupName(), "requests",
-			string(key->start->data, key->size),
-			(filters != NULL)
-				? string(filters->start->data, filters->size)
-				: string());
-		if (!options.transaction->isNull()) {
-			options.analytics = true;
-			options.unionStationKey = StaticString(key->start->data, key->size);
-		}
-
-		req->beginStopwatchLog(&req->stopwatchLogs.requestProcessing, "request processing");
-		req->logMessage(string("Request method: ") + http_method_str(req->method));
-		req->logMessage("URI: " + StaticString(req->path.start->data, req->path.size));
-	}
-}
-
 void
 Controller::setStickySessionId(Client *client, Request *req) {
 	if (req->stickySession) {
@@ -477,8 +437,6 @@ Controller::onRequestBegin(Client *client, Request *req) {
 		analysis.appGroupNameCell = mainConfig.singleAppMode
 			? NULL
 			: req->secureHeaders.lookupCell(PASSENGER_APP_GROUP_NAME);
-		analysis.unionStationSupport = unionStationContext != NULL
-			&& getBoolOption(req, UNION_STATION_SUPPORT, false);
 		req->stickySession = getBoolOption(req, PASSENGER_STICKY_SESSIONS,
 			mainConfig.defaultStickySessions);
 		req->host = req->headers.lookup(HTTP_HOST);
@@ -498,7 +456,6 @@ Controller::onRequestBegin(Client *client, Request *req) {
 		if (req->ended()) {
 			return;
 		}
-		initializeUnionStation(client, req, analysis);
 		if (req->ended()) {
 			return;
 		}

data/src/agent/Core/Controller/InitializationAndShutdown.cpp

@@ -71,7 +71,6 @@ Controller::preinitialize() {
 	PASSENGER_STICKY_SESSIONS = "!~PASSENGER_STICKY_SESSIONS";
 	PASSENGER_STICKY_SESSIONS_COOKIE_NAME = "!~PASSENGER_STICKY_SESSIONS_COOKIE_NAME";
 	PASSENGER_REQUEST_OOB_WORK = "!~Request-OOB-Work";
-	UNION_STATION_SUPPORT = "!~UNION_STATION_SUPPORT";
 	REMOTE_ADDR = "!~REMOTE_ADDR";
 	REMOTE_PORT = "!~REMOTE_PORT";
 	REMOTE_USER = "!~REMOTE_USER";
@@ -98,9 +97,6 @@ Controller::initialize() {
 	if (appPool == NULL) {
 		throw RuntimeException("AppPool not initialized");
 	}
-	if (unionStationContext == NULL) {
-		unionStationContext = appPool->getUnionStationContext();
-	}
 
 	ParentClass::initialize();
 	turboCaching.initialize(config["turbocaching"].asBool());

data/src/agent/Core/Controller/Request.h

@@ -35,9 +35,6 @@
 #include <ServerKit/FdSourceChannel.h>
 #include <LoggingKit/LoggingKit.h>
 #include <Core/ApplicationPool/Pool.h>
-#include <Core/UnionStation/Context.h>
-#include <Core/UnionStation/Transaction.h>
-#include <Core/UnionStation/StopwatchLog.h>
 #include <Core/Controller/Config.h>
 #include <Core/Controller/AppResponse.h>
 
@@ -94,13 +91,6 @@ public:
 	ServerKit::FileBufferedChannel bodyBuffer;
 	boost::uint64_t bodyBytesBuffered; // After dechunking
 
-	struct {
-		UnionStation::StopwatchLog *requestProcessing;
-		UnionStation::StopwatchLog *bufferingRequestBody;
-		UnionStation::StopwatchLog *getFromPool;
-		UnionStation::StopwatchLog *requestProxying;
-	} stopwatchLogs;
-
 	HashedStaticString cacheKey;
 	LString *cacheControl;
 	LString *varyCookie;
@@ -122,9 +112,7 @@ public:
 
 	Request()
 		: BaseHttpRequest()
-	{
-		memset(&stopwatchLogs, 0, sizeof(stopwatchLogs));
-	}
+		{ }
 
 	const char *getStateString() const {
 		switch (state) {
@@ -145,28 +133,6 @@ public:
 		}
 	}
 
-	bool useUnionStation() const {
-		return options.transaction != NULL;
-	}
-
-	void beginStopwatchLog(UnionStation::StopwatchLog **stopwatchLog, const char *id, const char *nameAndData = NULL) {
-		if (options.transaction != NULL) {
-			*stopwatchLog = new UnionStation::StopwatchLog(options.transaction, id, nameAndData);
-		}
-	}
-
-	void endStopwatchLog(UnionStation::StopwatchLog **stopwatchLog, bool success = true) {
-		if (success && *stopwatchLog != NULL) {
-			(*stopwatchLog)->success();
-		}
-		delete *stopwatchLog;
-		*stopwatchLog = NULL;
-	}
-
-	void logMessage(const StaticString &message) {
-		options.transaction->message(message);
-	}
-
 	DEFINE_SERVER_KIT_BASE_HTTP_REQUEST_FOOTER(Passenger::Core::Request);
 };
 

data/src/agent/Core/Controller/SendRequest.cpp

@@ -446,14 +446,6 @@ Controller::determineHeaderSizeForSessionProtocol(Request *req,
 		dataSize += sizeof("on");
 	}
 
-	if (req->options.analytics) {
-		dataSize += sizeof("PASSENGER_TXN_ID");
-		dataSize += req->options.transaction->getTxnId().size() + 1;
-
-		dataSize += sizeof("PASSENGER_DELTA_MONOTONIC");
-		dataSize += delta_monotonic.size() + 1;
-	}
-
 	if (req->upgraded()) {
 		dataSize += sizeof("HTTP_CONNECTION");
 		dataSize += sizeof("upgrade");
@@ -564,16 +556,6 @@ Controller::constructHeaderForSessionProtocol(Request *req, char * restrict buff
 		pos = appendData(pos, end, P_STATIC_STRING_WITH_NULL("on"));
 	}
 
-	if (req->options.analytics) {
-		pos = appendData(pos, end, P_STATIC_STRING_WITH_NULL("PASSENGER_TXN_ID"));
-		pos = appendData(pos, end, req->options.transaction->getTxnId());
-		pos = appendData(pos, end, "", 1);
-
-		pos = appendData(pos, end, P_STATIC_STRING_WITH_NULL("PASSENGER_DELTA_MONOTONIC"));
-		pos = appendData(pos, end, delta_monotonic);
-		pos = appendData(pos, end, "", 1);
-	}
-
 	if (req->upgraded()) {
 		pos = appendData(pos, end, P_STATIC_STRING_WITH_NULL("HTTP_CONNECTION"));
 		pos = appendData(pos, end, P_STATIC_STRING_WITH_NULL("upgrade"));
@@ -863,20 +845,6 @@ Controller::constructHeaderBuffersForHttpProtocol(Request *req, struct iovec *bu
 		PUSH_STATIC_BUFFER("\r\n");
 	}
 
-	if (req->options.analytics) {
-		PUSH_STATIC_BUFFER("!~Passenger-Txn-Id: ");
-
-		if (buffers != NULL) {
-			BEGIN_PUSH_NEXT_BUFFER();
-			buffers[i].iov_base = (void *) req->options.transaction->getTxnId().data();
-			buffers[i].iov_len  = req->options.transaction->getTxnId().size();
-		}
-		INC_BUFFER_ITER(i);
-		dataSize += req->options.transaction->getTxnId().size();
-
-		PUSH_STATIC_BUFFER("\r\n");
-	}
-
 	PUSH_STATIC_BUFFER("\r\n");
 
 	nbuffers = i;

data/src/agent/Core/CoreMain.cpp

@@ -98,7 +98,6 @@
 #include <Core/Config.h>
 #include <Core/ConfigChange.h>
 #include <Core/ApplicationPool/Pool.h>
-#include <Core/UnionStation/Context.h>
 #include <Core/SecurityUpdateChecker.h>
 #include <Core/AdminPanelConnector.h>
 
@@ -146,9 +145,9 @@ namespace Core {
 
 		ResourceLocator resourceLocator;
 		RandomGeneratorPtr randomGenerator;
-		UnionStation::ContextPtr unionStationContext;
-		SpawningKit::ConfigPtr spawningKitConfig;
-		SpawningKit::FactoryPtr spawningKitFactory;
+		SpawningKit::Context::Schema spawningKitContextSchema;
+		SpawningKit::ContextPtr spawningKitContext;
+		ApplicationPool2::ContextPtr appPoolContext;
 		PoolPtr appPool;
 		Json::Value singleAppModeConfig;
 
@@ -621,12 +620,6 @@ onTerminationSignal(EV_P_ struct ev_signal *watcher, int revents) {
 	}
 }
 
-static void
-spawningKitErrorHandler(const SpawningKit::ConfigPtr &config, SpawnException &e, const Options &options) {
-	ApplicationPool2::processAndLogNewSpawnException(e, options, config);
-}
-
-
 static void
 initializeCurl() {
 	TRACE_POINT();
@@ -658,30 +651,25 @@ initializeNonPrivilegedWorkingObjects() {
 	}
 
 	UPDATE_TRACE_POINT();
-	if (!coreConfig->get("ust_router_address").isNull()) {
-		wo->unionStationContext = boost::make_shared<UnionStation::Context>(
-			coreConfig->get("ust_router_address").asString(),
-			"logging",
-			coreConfig->get("ust_router_password").asString());
-	}
-
-	UPDATE_TRACE_POINT();
-	wo->spawningKitConfig = boost::make_shared<SpawningKit::Config>();
-	wo->spawningKitConfig->resourceLocator = &wo->resourceLocator;
-	wo->spawningKitConfig->agentConfig = coreConfig->inspectEffectiveValues();
-	wo->spawningKitConfig->errorHandler = spawningKitErrorHandler;
-	wo->spawningKitConfig->unionStationContext = wo->unionStationContext;
-	wo->spawningKitConfig->randomGenerator = wo->randomGenerator;
-	wo->spawningKitConfig->instanceDir = coreConfig->get("instance_dir").asString();
-	if (!wo->spawningKitConfig->instanceDir.empty()) {
-		wo->spawningKitConfig->instanceDir = absolutizePath(
-			wo->spawningKitConfig->instanceDir);
+	wo->spawningKitContext = boost::make_shared<SpawningKit::Context>(
+		wo->spawningKitContextSchema);
+	wo->spawningKitContext->resourceLocator = &wo->resourceLocator;
+	wo->spawningKitContext->randomGenerator = wo->randomGenerator;
+	wo->spawningKitContext->integrationMode = coreConfig->get("integration_mode").asString();
+	wo->spawningKitContext->instanceDir = coreConfig->get("instance_dir").asString();
+	if (!wo->spawningKitContext->instanceDir.empty()) {
+		wo->spawningKitContext->instanceDir = absolutizePath(
+			wo->spawningKitContext->instanceDir);
 	}
-	wo->spawningKitConfig->finalize();
+	wo->spawningKitContext->finalize();
 
 	UPDATE_TRACE_POINT();
-	wo->spawningKitFactory = boost::make_shared<SpawningKit::Factory>(wo->spawningKitConfig);
-	wo->appPool = boost::make_shared<Pool>(wo->spawningKitFactory, coreConfig->inspectEffectiveValues());
+	wo->appPoolContext = boost::make_shared<ApplicationPool2::Context>();
+	wo->appPoolContext->spawningKitFactory = boost::make_shared<SpawningKit::Factory>(
+		wo->spawningKitContext.get());
+	wo->appPoolContext->agentConfig = coreConfig->inspectEffectiveValues();
+	wo->appPoolContext->finalize();
+	wo->appPool = boost::make_shared<Pool>(wo->appPoolContext.get());
 	wo->appPool->initialize();
 	wo->appPool->setMax(coreConfig->get("max_pool_size").asInt());
 	wo->appPool->setMaxIdleTime(coreConfig->get("pool_idle_time").asInt() * 1000000ULL);
@@ -727,7 +715,6 @@ initializeNonPrivilegedWorkingObjects() {
 			coreSchema->controllerSingleAppMode.translator);
 		two.controller->resourceLocator = &wo->resourceLocator;
 		two.controller->appPool = wo->appPool;
-		two.controller->unionStationContext = wo->unionStationContext;
 		two.controller->shutdownFinishCallback = controllerShutdownFinished;
 		two.controller->initialize();
 		wo->shutdownCounter.fetch_add(1, boost::memory_order_relaxed);

data/src/agent/Core/SpawningKit/Config.h

@@ -26,25 +26,16 @@
 #ifndef _PASSENGER_SPAWNING_KIT_CONFIG_H_
 #define _PASSENGER_SPAWNING_KIT_CONFIG_H_
 
-#include <boost/function.hpp>
-#include <boost/make_shared.hpp>
-#include <boost/thread.hpp>
-#include <string>
+#include <oxt/macros.hpp>
+#include <boost/shared_array.hpp>
+#include <vector>
 #include <cstddef>
 
 #include <jsoncpp/json.h>
 
-#include <ResourceLocator.h>
-#include <RandomGenerator.h>
-#include <Exceptions.h>
-#include <Utils/VariantMap.h>
-#include <Core/UnionStation/Context.h>
-
-namespace Passenger {
-namespace ApplicationPool2 {
-	class Options;
-} // namespace ApplicationPool2
-} // namespace Passenger
+#include <Constants.h>
+#include <StaticString.h>
+#include <DataStructures/StringKeyTable.h>
 
 namespace Passenger {
 namespace SpawningKit {
@@ -52,61 +43,344 @@ namespace SpawningKit {
 using namespace std;
 
 
-struct Config;
-typedef ApplicationPool2::Options Options;
-typedef boost::shared_ptr<Config> ConfigPtr;
+// The following hints are available:
+//
+// @require_non_empty
+// @pass_during_handshake
+// @non_confidential
+// @only_meaningful_if
+// @only_pass_during_handshake_if
+//
+// - begin hinted parseable class -
+class Config {
+private:
+	boost::shared_array<char> storage;
+
+	Json::Value tableToJson(const StringKeyTable<StaticString> &table) const {
+		Json::Value doc(Json::objectValue);
+		StringKeyTable<StaticString>::ConstIterator it(table);
+
+		while (*it != NULL) {
+			doc[it.getKey().toString()] = it.getValue().toString();
+			it.next();
+		}
+
+		return doc;
+	}
+
+public:
+	/**
+	 * The app group name that the spawned process shall belong to. SpawningKit does
+	 * not use this information directly: it is passed to LoggingKit when logging
+	 * app output.
+	 *
+	 * @hinted_parseable
+	 * @require_non_empty
+	 * @pass_during_handshake
+	 * @non_confidential
+	 */
+	StaticString appGroupName;
+
+	/**
+	 * The root directory of the application to spawn. For example, for Ruby apps, this
+	 * is the directory containing config.ru. The startCommand will be invoked from
+	 * this directory.
+	 *
+	 * @hinted_parseable
+	 * @require_non_empty
+	 * @pass_during_handshake
+	 * @non_confidential
+	 */
+	StaticString appRoot;
+
+	/**
+	 * The log level to use.
+	 *
+	 * @hinted_parseable
+	 * @pass_during_handshake
+	 * @non_confidential
+	 */
+	int logLevel;
+
+	/**
+	 * Whether the app to be spawned is generic or not. Generic
+	 * apps do not have special support for Passenger built in,
+	 * nor do we have a wrapper for loading the app.
+	 *
+	 * For example, Rack and Node.js apps are not considered
+	 * generic because we have wrappers for them. Go apps without
+	 * special Passenger support built in are considered generic.
+	 *
+	 * @hinted_parseable
+	 * @pass_during_handshake
+	 * @non_confidential
+	 */
+	bool genericApp: 1;
+
+	/**
+	 * If the app is not generic (`!genericApp`), then this specifies
+	 * whether the app is loaded through a wrapper (true), or whether
+	 * the app has special support for Passenger built in and is
+	 * started directly (false). The only use for this in SpawningKit
+	 * is to better format error messages.
+	 *
+	 * @hinted_parseable
+	 * @only_meaningful_if !config.genericApp
+	 * @pass_during_handshake
+	 * @non_confidential
+	 */
+	bool startsUsingWrapper: 1;
+
+	/**
+	 * When a wrapper is used to load the application, this field
+	 * specifies whether the wrapper is supplied by Phusion or by
+	 * a third party. The only use for this in SpawningKit is to better
+	 * format error messages.
+	 *
+	 * @hinted_parseable
+	 * @only_meaningful_if !config.genericApp && config.startsUsingWrapper
+	 * @pass_during_handshake
+	 * @non_confidential
+	 */
+	bool wrapperSuppliedByThirdParty: 1;
+
+	/**
+	 * If the app is not generic (`!genericApp`), then this specifies
+	 * whether SpawningKit should find a free port to pass to the app
+	 * so that it can listen on that port.
+	 * This is always done if the app is generic, but *can* be done
+	 * for non-generic apps as well.
+	 *
+	 * @hinted_parseable
+	 * @only_meaningful_if !config.genericApp
+	 */
+	bool findFreePort: 1;
+
+	/**
+	 * Whether to load environment variables set in shell startup
+	 * files (e.g. ~/.bashrc) during spawning.
+	 *
+	 * @hinted_parseable
+	 * @pass_during_handshake
+	 * @non_confidential
+	 */
+	bool loadShellEnvvars: 1;
 
-typedef void (*ErrorHandler)(const ConfigPtr &config, SpawnException &e, const Options &options);
-typedef boost::function<void (const char *data, unsigned int size)> OutputHandler;
+	/**
+	 * Set to true if you do not want SpawningKit to remove the
+	 * work directory after a spawning operation, which is useful
+	 * for debugging. Defaults to false.
+	 *
+	 * @hinted_parseable
+	 */
+	bool debugWorkDir: 1;
 
-struct Config {
-	// Used by error pages and hooks.
-	ResourceLocator *resourceLocator;
-	ErrorHandler errorHandler;
+	/**
+	 * The command to run in order to start the app.
+	 *
+	 * If `genericApp` is true, then the command string must contain '$PORT'.
+	 * The command string is expected to start the app on the given port.
+	 * SpawningKit will take care of passing an appropriate $PORT value to
+	 * the app.
+	 *
+	 * If `genericApp` is false, then the command string is expected do
+	 * either one of these things:
+	 * - If there is a wrapper available for the app, then the command string
+	 *   is to invoke the wrapper (and `startsUsingWrapper` should be true).
+	 * - Otherwise, the command string is to start the app directly, in
+	 *   Passenger mode (and `startsUsingWrapper` should be false).
+	 *
+	 * @hinted_parseable
+	 * @require_non_empty
+	 * @pass_during_handshake
+	 * @non_confidential
+	 */
+	StaticString startCommand;
 
-	boost::mutex agentConfigSyncher;
-	Json::Value agentConfig;
+	/**
+	 * The application's entry point file. If a relative path is given, then it
+	 * is relative to the app root. Only meaningful if app is to be loaded through
+	 * a wrapper.
+	 *
+	 * @hinted_parseable
+	 * @only_meaningful_if !config.genericApp && config.startsUsingWrapper
+	 * @require_non_empty
+	 * @pass_during_handshake
+	 * @non_confidential
+	 */
+	StaticString startupFile;
 
-	// Used for Union Station logging.
-	UnionStation::ContextPtr unionStationContext;
+	/**
+	 * A process title to set when spawning the application.
+	 *
+	 * @hinted_parseable
+	 * @pass_during_handshake
+	 * @non_confidential
+	 * @only_pass_during_handshake_if !config.processTitle.empty()
+	 */
+	StaticString processTitle;
 
-	// Used by SmartSpawner and DirectSpawner.
-	RandomGeneratorPtr randomGenerator;
-	string instanceDir;
+	/**
+	 * An application type name, e.g. "rack" or "node". The only use for this
+	 * in SpawningKit is to better format error messages.
+	 *
+	 * @hinted_parseable
+	 * @require_non_empty
+	 * @pass_during_handshake
+	 * @non_confidential
+	 */
+	StaticString appType;
 
-	// Used by DummySpawner and SpawnerFactory.
-	unsigned int concurrency;
-	unsigned int spawnerCreationSleepTime;
-	unsigned int spawnTime;
+	/**
+	 * The value to set PASSENGER_APP_ENV/RAILS_ENV/etc to.
+	 *
+	 * @hinted_parseable
+	 * @require_non_empty
+	 * @pass_during_handshake
+	 * @non_confidential
+	 */
+	StaticString appEnv;
 
-	// Used by PipeWatcher.
-	OutputHandler outputHandler;
+	/**
+	 * The spawn method used for spawning the app, i.e. "smart" or "direct".
+	 *
+	 * @hinted_parseable
+	 * @require_non_empty
+	 * @pass_during_handshake
+	 * @non_confidential
+	 */
+	StaticString spawnMethod;
 
-	// Other.
-	void *data;
+	/**
+	 * The base URI on which the app runs. If the app is running on the
+	 * root URI, then this value must be "/".
+	 *
+	 * @hinted_parseable
+	 * @require_non_empty
+	 * @pass_during_handshake base_uri
+	 * @non_confidential
+	 */
+	StaticString baseURI;
+
+	/**
+	 * The user to start run the app as. Only has effect if the current process
+	 * is running with root privileges.
+	 *
+	 * @hinted_parseable
+	 * @require_non_empty
+	 * @pass_during_handshake
+	 * @non_confidential
+	 */
+	StaticString user;
+
+	/**
+	 * The group to start run the app as. Only has effect if the current process
+	 * is running with root privileges.
+	 *
+	 * @hinted_parseable
+	 * @require_non_empty
+	 * @pass_during_handshake
+	 * @non_confidential
+	 */
+	StaticString group;
+
+	/**
+	 * Any environment variables to pass to the application. These will be set
+	 * after the OS shell has already done its work, but before the application
+	 * is started.
+	 *
+	 * @hinted_parseable
+	 * @pass_during_handshake
+	 */
+	StringKeyTable<StaticString> environmentVariables;
+
+	/**
+	 * Specifies that the app's stdout/stderr output should be written
+	 * to the given log file.
+	 *
+	 * @hinted_parseable
+	 * @pass_during_handshake
+	 */
+	StaticString logFile;
+
+	/**
+	 * The API key of the pool group that the spawned process is to belong to.
+	 *
+	 * @hinted_parseable
+	 * @pass_during_handshake
+	 * @only_pass_during_handshake_if !config.apiKey.empty()
+	 */
+	StaticString apiKey;
+
+	/**
+	 * A UUID that's generated on Group initialization, and changes every time
+	 * the Group receives a restart command. Allows Union Station to track app
+	 * restarts.
+	 *
+	 * @hinted_parseable
+	 * @pass_during_handshake
+	 * @only_pass_during_handshake_if !config.groupUuid.empty()
+	 */
+	StaticString groupUuid;
+
+	/**
+	 * Minimum user ID starting from which entering LVE and CageFS is allowed.
+	 *
+	 * @hinted_parseable
+	 */
+	unsigned int lveMinUid;
+
+	/**
+	 * The file descriptor ulimit that the app should have.
+	 * A value of 0 means that the ulimit should not be changed.
+	 *
+	 * @hinted_parseable
+	 * @pass_during_handshake
+	 * @non_confidential
+	 * @only_pass_during_handshake_if config.fileDescriptorUlimit > 0
+	 */
+	unsigned int fileDescriptorUlimit;
+
+	/**
+	 * The maximum amount of time, in milliseconds, that may be spent
+	 * on spawning the process or the preloader.
+	 *
+	 * @hinted_parseable
+	 * @require config.startTimeoutMsec > 0
+	 */
+	unsigned int startTimeoutMsec;
+
+	/*********************/
+	/*********************/
 
 	Config()
-		: resourceLocator(NULL),
-		  errorHandler(NULL),
-		  concurrency(1),
-		  spawnerCreationSleepTime(0),
-		  spawnTime(0),
-		  data(NULL)
+		: logLevel(DEFAULT_LOG_LEVEL),
+		  genericApp(false),
+		  startsUsingWrapper(false),
+		  wrapperSuppliedByThirdParty(false),
+		  findFreePort(false),
+		  loadShellEnvvars(false),
+		  debugWorkDir(false),
+		  appEnv(P_STATIC_STRING(DEFAULT_APP_ENV)),
+		  baseURI(P_STATIC_STRING("/")),
+		  lveMinUid(DEFAULT_LVE_MIN_UID),
+		  fileDescriptorUlimit(0),
+		  startTimeoutMsec(DEFAULT_START_TIMEOUT)
+		  /*********************/
 		{ }
 
-	void finalize() {
-		TRACE_POINT();
-		if (resourceLocator == NULL) {
-			throw RuntimeException("ResourceLocator not initialized");
-		}
-		if (randomGenerator == NULL) {
-			randomGenerator = boost::make_shared<RandomGenerator>();
-		}
-	}
+	void internStrings();
+	bool validate(vector<StaticString> &errors) const;
+	Json::Value getConfidentialFieldsToPassToApp() const;
+	Json::Value getNonConfidentialFieldsToPassToApp() const;
 };
+// - end hinted parseable class -
+
+
+#include <Core/SpawningKit/Config/AutoGeneratedCode.h>
 
 
-} // namespace ApplicationPool2
+} // namespace SpawningKit
 } // namespace Passenger
 
 #endif /* _PASSENGER_SPAWNING_KIT_CONFIG_H_ */