passenger 5.2.3 → 5.3.0

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

@@ -0,0 +1,211 @@
+/*
+ *  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_SPAWNING_KIT_CONTEXT_H_
+#define _PASSENGER_SPAWNING_KIT_CONTEXT_H_
+
+#include <boost/function.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/make_shared.hpp>
+#include <string>
+#include <algorithm>
+#include <cstddef>
+
+#include <ResourceLocator.h>
+#include <RandomGenerator.h>
+#include <Exceptions.h>
+#include <Utils/JsonUtils.h>
+#include <Utils/VariantMap.h>
+#include <ConfigKit/Store.h>
+
+namespace Passenger {
+	namespace ApplicationPool2 {
+		class Options;
+	}
+}
+
+namespace Passenger {
+namespace SpawningKit {
+
+using namespace std;
+
+
+class HandshakePrepare;
+typedef boost::function<void (const char *data, unsigned int size)> OutputHandler;
+typedef Passenger::ApplicationPool2::Options AppPoolOptions;
+
+
+class Context {
+public:
+	class Schema: public ConfigKit::Schema {
+	private:
+		static void validate(const ConfigKit::Store &config, vector<ConfigKit::Error> &errors) {
+			if (config["min_port_range"].asUInt() > config["max_port_range"].asUInt()) {
+				errors.push_back(ConfigKit::Error(
+					"'{{min_port_range}}' must be equal to or smaller than {{max_port_range}}"));
+			}
+			if (config["min_port_range"].asUInt() > 65535) {
+				errors.push_back(ConfigKit::Error(
+					"{{min_port_range}} must be equal to or less than 65535"));
+			}
+			if (config["max_port_range"].asUInt() > 65535) {
+				errors.push_back(ConfigKit::Error(
+					"{{max_port_range}} must be equal to or less than 65535"));
+			}
+		}
+
+	public:
+		Schema() {
+			using namespace ConfigKit;
+
+			add("min_port_range", UINT_TYPE, OPTIONAL, 5000);
+			add("max_port_range", UINT_TYPE, OPTIONAL, 65535);
+
+			addValidator(validate);
+			finalize();
+		}
+	};
+
+	struct DebugSupport {
+		// Used by DummySpawner and SpawnerFactory.
+		unsigned int dummyConcurrency;
+		unsigned long long dummySpawnDelay;
+		unsigned long long spawnerCreationSleepTime;
+
+		DebugSupport()
+			: dummyConcurrency(1),
+			  dummySpawnDelay(0),
+			  spawnerCreationSleepTime(0)
+			{ }
+	};
+
+private:
+	friend class HandshakePrepare;
+
+
+	mutable boost::mutex syncher;
+
+
+	/****** Context-global configuration ******/
+
+	// Actual configuration store.
+	ConfigKit::Store config;
+
+	// Below follows cached values.
+
+	// Other.
+	unsigned int minPortRange, maxPortRange;
+
+
+	/****** Working state ******/
+
+	bool finalized;
+	unsigned int nextPort;
+
+
+	void updateConfigCache() {
+		minPortRange = config["min_port_range"].asUInt();
+		maxPortRange = config["max_port_range"].asUInt();
+		nextPort = std::max(std::min(nextPort, maxPortRange), minPortRange);
+	}
+
+public:
+	/****** Dependencies ******/
+
+	ResourceLocator *resourceLocator;
+	RandomGeneratorPtr randomGenerator;
+	string integrationMode;
+	string instanceDir;
+	DebugSupport *debugSupport;
+	//UnionStation::ContextPtr unionStationContext;
+
+
+	Context(const Schema &schema, const Json::Value &initialConfig = Json::Value())
+		: config(schema),
+
+		  finalized(false),
+		  nextPort(0),
+
+		  resourceLocator(NULL),
+		  debugSupport(NULL)
+	{
+		vector<ConfigKit::Error> errors;
+
+        if (!config.update(initialConfig, errors)) {
+            throw ArgumentException("Invalid initial configuration: "
+                + toString(errors));
+        }
+        updateConfigCache();
+	}
+
+	Json::Value previewConfigUpdate(const Json::Value &updates,
+		vector<ConfigKit::Error> &errors)
+	{
+		boost::lock_guard<boost::mutex> l(syncher);
+		return config.previewUpdate(updates, errors);
+	}
+
+	bool configure(const Json::Value &updates, vector<ConfigKit::Error> &errors) {
+		boost::lock_guard<boost::mutex> l(syncher);
+		if (config.update(updates, errors)) {
+			updateConfigCache();
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	Json::Value inspectConfig() const {
+		boost::lock_guard<boost::mutex> l(syncher);
+		return config.inspect();
+	}
+
+	void finalize() {
+		TRACE_POINT();
+		if (resourceLocator == NULL) {
+			throw RuntimeException("ResourceLocator not initialized");
+		}
+		if (randomGenerator == NULL) {
+			randomGenerator = boost::make_shared<RandomGenerator>();
+		}
+		if (integrationMode.empty()) {
+			throw RuntimeException("integrationMode not set");
+		}
+
+		finalized = true;
+	}
+
+	bool isFinalized() const {
+		return finalized;
+	}
+};
+
+typedef boost::shared_ptr<Context> ContextPtr;
+
+
+} // namespace SpawningKit
+} // namespace Passenger
+
+#endif /* _PASSENGER_SPAWNING_KIT_CONTEXT_H_ */

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

@@ -26,13 +26,20 @@
 #ifndef _PASSENGER_SPAWNING_KIT_DIRECT_SPAWNER_H_
 #define _PASSENGER_SPAWNING_KIT_DIRECT_SPAWNER_H_
 
+#include <stdexcept>
+
 #include <Core/SpawningKit/Spawner.h>
+#include <Core/SpawningKit/Handshake/Session.h>
+#include <Core/SpawningKit/Handshake/Prepare.h>
+#include <Core/SpawningKit/Handshake/Perform.h>
+#include <ProcessManagement/Utils.h>
 #include <Constants.h>
 #include <LoggingKit/LoggingKit.h>
 #include <LveLoggingDecorator.h>
+#include <Utils/IOUtils.h>
+
 #include <limits.h>  // for PTHREAD_STACK_MIN
 #include <pthread.h>
-
 #include <adhoc_lve.h>
 
 namespace Passenger {
@@ -112,161 +119,144 @@ private:
 		startBackgroundThread(detachProcessMain, (void *) (long) pid);
 	}
 
-	vector<string> createCommand(const Options &options, const SpawnPreparationInfo &preparation,
-		shared_array<const char *> &args) const
+	void setConfigFromAppPoolOptions(Config *config, Json::Value &extraArgs,
+		const AppPoolOptions &options)
 	{
-		vector<string> startCommandArgs;
-		string agentFilename = config->resourceLocator->findSupportBinary(AGENT_EXE);
-		vector<string> command;
-
-		split(options.getStartCommand(*config->resourceLocator), '\t', startCommandArgs);
-		if (startCommandArgs.empty()) {
-			throw RuntimeException("No startCommand given");
-		}
-
-		if (shouldLoadShellEnvvars(options, preparation)) {
-			command.push_back(preparation.userSwitching.shell);
-			command.push_back(preparation.userSwitching.shell);
-			if (LoggingKit::getLevel() >= LoggingKit::DEBUG3) {
-				command.push_back("-lxc");
-			} else {
-				command.push_back("-lc");
-			}
-			command.push_back("exec \"$@\"");
-			command.push_back("SpawnPreparerShell");
-		} else {
-			command.push_back(agentFilename);
-		}
-		command.push_back(agentFilename);
-		command.push_back("spawn-preparer");
-		command.push_back(preparation.appRoot);
-		command.push_back(serializeEnvvarsFromPoolOptions(options));
-		command.push_back(startCommandArgs[0]);
-		// Note: do not try to set a process title here.
-		// https://code.google.com/p/phusion-passenger/issues/detail?id=855
-		command.push_back(startCommandArgs[0]);
-		for (unsigned int i = 1; i < startCommandArgs.size(); i++) {
-			command.push_back(startCommandArgs[i]);
-		}
-
-		createCommandArgs(command, args);
-		return command;
+		Spawner::setConfigFromAppPoolOptions(config, extraArgs, options);
+		config->spawnMethod = P_STATIC_STRING("direct");
 	}
 
-public:
-	DirectSpawner(const ConfigPtr &_config)
-		: Spawner(_config)
-		{ }
-
-	virtual Result spawn(const Options &options) {
+	Result internalSpawn(const AppPoolOptions &options, Config &config,
+		HandshakeSession &session, const Json::Value &extraArgs,
+		JourneyStep &stepToMarkAsErrored)
+	{
 		TRACE_POINT();
-		boost::this_thread::disable_interruption di;
-		boost::this_thread::disable_syscall_interruption dsi;
-		P_DEBUG("Spawning new process: appRoot=" << options.appRoot);
-		possiblyRaiseInternalError(options);
-
-		shared_array<const char *> args;
-		SpawnPreparationInfo preparation = prepareSpawn(options);
-		vector<string> command = createCommand(options, preparation, args);
-		SocketPair adminSocket = createUnixSocketPair(__FILE__, __LINE__);
-		Pipe errorPipe = createPipe(__FILE__, __LINE__);
-		DebugDirPtr debugDir = boost::make_shared<DebugDir>(preparation.userSwitching.uid,
-			preparation.userSwitching.gid);
-		pid_t pid;
-
+		Pipe stdinChannel = createPipe(__FILE__, __LINE__);
+		Pipe stdoutAndErrChannel = createPipe(__FILE__, __LINE__);
 		adhoc_lve::LveEnter scopedLveEnter(LveLoggingDecorator::lveInitOnce(),
-		                                   preparation.userSwitching.uid,
-		                                   options.lveMinUid,
-		                                   LveLoggingDecorator::lveExitCallback);
+			session.uid,
+			config.lveMinUid,
+			LveLoggingDecorator::lveExitCallback);
 		LveLoggingDecorator::logLveEnter(scopedLveEnter,
-		                                 preparation.userSwitching.uid,
-		                                 options.lveMinUid);
+			session.uid,
+			config.lveMinUid);
+		string agentFilename = context->resourceLocator
+			->findSupportBinary(AGENT_EXE);
 
-		pid = syscalls::fork();
+		session.journey.setStepPerformed(SPAWNING_KIT_PREPARATION);
+		session.journey.setStepInProgress(SPAWNING_KIT_FORK_SUBPROCESS);
+		session.journey.setStepInProgress(SUBPROCESS_BEFORE_FIRST_EXEC);
+		stepToMarkAsErrored = SPAWNING_KIT_FORK_SUBPROCESS;
+
+		pid_t pid = syscalls::fork();
 		if (pid == 0) {
-			setenv("PASSENGER_DEBUG_DIR", debugDir->getPath().c_str(), 1);
 			purgeStdio(stdout);
 			purgeStdio(stderr);
 			resetSignalHandlersAndMask();
 			disableMallocDebugging();
-			int adminSocketCopy = dup2(adminSocket.first, 3);
-			int errorPipeCopy = dup2(errorPipe.second, 4);
-			dup2(adminSocketCopy, 0);
-			dup2(adminSocketCopy, 1);
-			dup2(errorPipeCopy, 2);
-			closeAllFileDescriptors(2);
-			setChroot(preparation);
-			setUlimits(options);
-			switchUser(preparation);
-			setWorkingDirectory(preparation);
-			execvp(args[0], (char * const *) args.get());
+			int stdinCopy = dup2(stdinChannel.first, 3);
+			int stdoutAndErrCopy = dup2(stdoutAndErrChannel.second, 4);
+			dup2(stdinCopy, 0);
+			dup2(stdoutAndErrCopy, 1);
+			dup2(stdoutAndErrCopy, 2);
+			closeAllFileDescriptors(2, true);
+			execlp(agentFilename.c_str(),
+				agentFilename.c_str(),
+				"spawn-env-setupper",
+				session.workDir->getPath().c_str(),
+				"--before",
+				NULL);
 
 			int e = errno;
-			printf("!> Error\n");
-			printf("!> \n");
-			printf("Cannot execute \"%s\": %s (errno=%d)\n", command[0].c_str(),
-				strerror(e), e);
 			fprintf(stderr, "Cannot execute \"%s\": %s (errno=%d)\n",
-				command[0].c_str(), strerror(e), e);
-			fflush(stdout);
+				agentFilename.c_str(), strerror(e), e);
 			fflush(stderr);
 			_exit(1);
 
 		} else if (pid == -1) {
 			int e = errno;
-			throw SystemException("Cannot fork a new process", e);
+			session.journey.setStepErrored(SPAWNING_KIT_FORK_SUBPROCESS);
+			SpawnException ex(OPERATING_SYSTEM_ERROR, session.journey, &config);
+			ex.setSummary(StaticString("Cannot fork a new process: ") + strerror(e)
+				+ " (errno=" + toString(e) + ")");
+			ex.setAdvancedProblemDetails(StaticString("Cannot fork a new process: ")
+				+ strerror(e) + " (errno=" + toString(e) + ")");
+			throw ex.finalize();
 
 		} else {
 			UPDATE_TRACE_POINT();
+			session.journey.setStepPerformed(SPAWNING_KIT_FORK_SUBPROCESS);
+			session.journey.setStepInProgress(SPAWNING_KIT_HANDSHAKE_PERFORM);
+			stepToMarkAsErrored = SPAWNING_KIT_HANDSHAKE_PERFORM;
+
 			scopedLveEnter.exit();
 
-			P_LOG_FILE_DESCRIPTOR_PURPOSE(adminSocket.first,
-				"App " << pid << " (" << options.appRoot << ") adminSocket[0]");
-			P_LOG_FILE_DESCRIPTOR_PURPOSE(adminSocket.second,
-				"App " << pid << " (" << options.appRoot << ") adminSocket[1]");
-			P_LOG_FILE_DESCRIPTOR_PURPOSE(errorPipe.first,
-				"App " << pid << " (" << options.appRoot << ") errorPipe[0]");
-			P_LOG_FILE_DESCRIPTOR_PURPOSE(errorPipe.second,
-				"App " << pid << " (" << options.appRoot << ") errorPipe[1]");
+			P_LOG_FILE_DESCRIPTOR_PURPOSE(stdinChannel.second,
+				"App " << pid << " (" << options.appRoot << ") stdin");
+			P_LOG_FILE_DESCRIPTOR_PURPOSE(stdoutAndErrChannel.first,
+				"App " << pid << " (" << options.appRoot << ") stdoutAndErr");
 
 			UPDATE_TRACE_POINT();
 			ScopeGuard guard(boost::bind(nonInterruptableKillAndWaitpid, pid));
 			P_DEBUG("Process forked for appRoot=" << options.appRoot << ": PID " << pid);
-			adminSocket.first.close();
-			errorPipe.second.close();
-
-			NegotiationDetails details;
-			details.preparation = &preparation;
-			details.stderrCapturer =
-				boost::make_shared<BackgroundIOCapturer>(
-					errorPipe.first,
-					pid,
-					// The cast works around a compilation problem in Clang.
-					(const char *) "stderr",
-					options.getAppGroupName(),
-					options.appLogFile);
-			details.stderrCapturer->start();
-			details.pid = pid;
-			details.adminSocket = adminSocket.second;
-			details.io = BufferedIO(adminSocket.second);
-			details.errorPipe = errorPipe.first;
-			details.options = &options;
-			details.debugDir = debugDir;
+			stdinChannel.first.close();
+			stdoutAndErrChannel.second.close();
 
-			UPDATE_TRACE_POINT();
-			Result result;
-			{
-				boost::this_thread::restore_interruption ri(di);
-				boost::this_thread::restore_syscall_interruption rsi(dsi);
-				result = negotiateSpawn(details);
-			}
+			HandshakePerform(session, pid, stdinChannel.second,
+				stdoutAndErrChannel.first).execute();
 
 			UPDATE_TRACE_POINT();
-			detachProcess(result["pid"].asInt());
+			detachProcess(session.result.pid);
 			guard.clear();
+			session.journey.setStepPerformed(SPAWNING_KIT_HANDSHAKE_PERFORM);
 			P_DEBUG("Process spawning done: appRoot=" << options.appRoot <<
-				", pid=" << result["pid"].asInt());
-			return result;
+				", pid=" << session.result.pid);
+			return session.result;
+		}
+	}
+
+public:
+	DirectSpawner(Context *context)
+		: Spawner(context)
+		{ }
+
+	virtual Result spawn(const AppPoolOptions &options) {
+		TRACE_POINT();
+		boost::this_thread::disable_interruption di;
+		boost::this_thread::disable_syscall_interruption dsi;
+		P_DEBUG("Spawning new process: appRoot=" << options.appRoot);
+		possiblyRaiseInternalError(options);
+
+		UPDATE_TRACE_POINT();
+		Config config;
+		Json::Value extraArgs;
+		try {
+			setConfigFromAppPoolOptions(&config, extraArgs, options);
+		} catch (const std::exception &originalException) {
+			UPDATE_TRACE_POINT();
+			Journey journey(SPAWN_THROUGH_PRELOADER, true);
+			journey.setStepErrored(SPAWNING_KIT_PREPARATION, true);
+			SpawnException e(originalException, journey, &config);
+			throw e.finalize();
+		}
+
+		UPDATE_TRACE_POINT();
+		HandshakeSession session(*context, config, SPAWN_DIRECTLY);
+		session.journey.setStepInProgress(SPAWNING_KIT_PREPARATION);
+		HandshakePrepare(session, extraArgs).execute();
+		JourneyStep stepToMarkAsErrored = SPAWNING_KIT_PREPARATION;
+
+		UPDATE_TRACE_POINT();
+		try {
+			return internalSpawn(options, config, session, extraArgs,
+				stepToMarkAsErrored);
+		} catch (const SpawnException &) {
+			throw;
+		} catch (const std::exception &originalException) {
+			UPDATE_TRACE_POINT();
+			session.journey.setStepErrored(stepToMarkAsErrored, true);
+			throw SpawnException(originalException, session.journey,
+				&config).finalize();
 		}
 	}
 };