passenger 3.9.2.beta → 4.0.0.rc4

data/ext/common/AgentsStarter.h

@@ -62,7 +62,6 @@ int  agents_starter_start(AgentsStarter *as,
                           unsigned short unionStationGatewayPort,
                           const char *unionStationGatewayCert,
                           const char *unionStationProxyAddress,
-                          const char *unionStationProxyType,
                           const char **prestartURLs, unsigned int prestartURLsCount,
                           const AfterForkCallback afterFork,
                           void *callbackArgument,

data/ext/common/AgentsStarter.hpp

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2010-2012 Phusion
+ *  Copyright (c) 2010-2013 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -385,7 +385,6 @@ public:
 	           unsigned short unionStationGatewayPort,
 	           const string &unionStationGatewayCert,
 	           const string &unionStationProxyAddress,
-	           const string &unionStationProxyType,
 	           const set<string> &prestartURLs,
 	           const function<void ()> &afterFork = function<void ()>())
 	{
@@ -426,7 +425,6 @@ public:
 			.setInt ("union_station_gateway_port", unionStationGatewayPort)
 			.set    ("union_station_gateway_cert", realUnionStationGatewayCert)
 			.set    ("union_station_proxy_address", unionStationProxyAddress)
-			.set    ("union_station_proxy_type",   unionStationProxyType)
 			.set    ("prestart_urls",   serializePrestartURLs(prestartURLs));
 		
 		SocketPair fds;

data/ext/common/ApplicationPool2/AppTypes.cpp

@@ -0,0 +1,74 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2013 Phusion
+ *
+ *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+ *
+ *  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.
+ */
+#include <ApplicationPool2/AppTypes.h>
+
+namespace Passenger {
+namespace ApplicationPool2 {
+
+// Don't forget to update ApplicationPool2::Options::getStartCommand() too.
+const AppTypeDefinition appTypeDefinitions[] = {
+	{ PAT_RACK, "rack", "config.ru", "Passenger RackApp" },
+	{ PAT_WSGI, "wsgi", "passenger_wsgi.py", "Passenger WsgiApp" },
+	{ PAT_CLASSIC_RAILS, "classic-rails", "config/environment.rb", "Passenger ClassicRailsApp" },
+	{ PAT_NONE, NULL, NULL, NULL }
+};
+
+} // namespace ApplicationPool2
+} // namespace Passenger
+
+
+using namespace Passenger;
+using namespace Passenger::ApplicationPool2;
+
+PassengerAppTypeDetector *
+passenger_app_type_detector_new() {
+	return new AppTypeDetector();
+}
+
+void
+passenger_app_type_detector_free(PassengerAppTypeDetector *detector) {
+	delete (AppTypeDetector *) detector;
+}
+
+PassengerAppType
+passenger_app_type_detector_check_document_root(PassengerAppTypeDetector *_detector,
+	const char *documentRoot, unsigned int len, int resolveFirstSymlink)
+{
+	AppTypeDetector *detector = (AppTypeDetector *) _detector;
+	return detector->checkDocumentRoot(StaticString(documentRoot, len), resolveFirstSymlink);
+}
+
+PassengerAppType
+passenger_app_type_detector_check_app_root(PassengerAppTypeDetector *_detector,
+	const char *appRoot, unsigned int len)
+{
+	AppTypeDetector *detector = (AppTypeDetector *) _detector;
+	return detector->checkAppRoot(StaticString(appRoot, len));
+}
+
+const char *
+passenger_get_app_type_name(PassengerAppType type) {
+	return getAppTypeName(type);
+}

data/ext/common/ApplicationPool2/AppTypes.h

@@ -0,0 +1,202 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2013 Phusion
+ *
+ *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+ *
+ *  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_APPLICATION_POOL2_APP_TYPES_H_
+#define _PASSENGER_APPLICATION_POOL2_APP_TYPES_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+typedef enum {
+	PAT_RACK,
+	PAT_WSGI,
+	PAT_CLASSIC_RAILS,
+	PAT_NONE
+} PassengerAppType;
+
+typedef void PassengerAppTypeDetector;
+
+PassengerAppTypeDetector *passenger_app_type_detector_new();
+void passenger_app_type_detector_free(PassengerAppTypeDetector *detector);
+PassengerAppType passenger_app_type_detector_check_document_root(PassengerAppTypeDetector *detector,
+	const char *documentRoot, unsigned int len, int resolveFirstSymlink);
+PassengerAppType passenger_app_type_detector_check_app_root(PassengerAppTypeDetector *detector,
+	const char *appRoot, unsigned int len);
+
+const char *passenger_get_app_type_name(PassengerAppType type);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#ifdef __cplusplus
+#include <oxt/macros.hpp>
+#include <oxt/backtrace.hpp>
+#include <cstdlib>
+#include <Logging.h>
+#include <StaticString.h>
+#include <Utils.h>
+#include <Utils/StrIntUtils.h>
+#include <Utils/CachedFileStat.hpp>
+
+namespace Passenger {
+namespace ApplicationPool2 {
+
+
+struct AppTypeDefinition {
+	const PassengerAppType type;
+	const char * const name;
+	const char * const startupFile;
+	const char * const processTitle;
+};
+
+extern const AppTypeDefinition appTypeDefinitions[];
+
+
+class AppTypeDetector {
+private:
+	CachedFileStat *cstat;
+	unsigned int throttleRate;
+	bool ownsCstat;
+
+	bool check(char *buf, const char *end, const StaticString &appRoot, const char *name) {
+		char *pos = buf;
+		pos = appendData(pos, end, appRoot);
+		pos = appendData(pos, end, "/");
+		pos = appendData(pos, end, name);
+		if (OXT_UNLIKELY(pos == end)) {
+			TRACE_POINT();
+			P_CRITICAL("BUG: buffer overflow");
+			abort();
+		}
+		return fileExists(StaticString(buf, pos - buf), cstat, throttleRate);
+	}
+
+public:
+	AppTypeDetector() {
+		cstat = new CachedFileStat();
+		ownsCstat = true;
+		throttleRate = 1;
+	}
+
+	AppTypeDetector(CachedFileStat *_cstat, unsigned int _throttleRate) {
+		cstat = _cstat;
+		ownsCstat = false;
+		throttleRate = _throttleRate;
+	}
+
+	~AppTypeDetector() {
+		if (ownsCstat) {
+			delete cstat;
+		}
+	}
+
+	PassengerAppType checkDocumentRoot(const StaticString &documentRoot, bool resolveFirstSymlink = false) {
+		if (!resolveFirstSymlink) {
+			return checkAppRoot(extractDirNameStatic(documentRoot));
+		} else {
+			char ntDocRoot[documentRoot.size() + 1];
+			memcpy(ntDocRoot, documentRoot.data(), documentRoot.size());
+			ntDocRoot[documentRoot.size()] = '\0';
+			string resolvedDocumentRoot = resolveSymlink(ntDocRoot);
+			return checkAppRoot(extractDirNameStatic(resolvedDocumentRoot));
+		}
+	}
+
+	PassengerAppType checkAppRoot(const StaticString &appRoot) {
+		char buf[appRoot.size() + 32];
+		const char *end = buf + appRoot.size() + 32;
+		const AppTypeDefinition *definition = &appTypeDefinitions[0];
+
+		while (definition->type != PAT_NONE) {
+			if (check(buf, end, appRoot, definition->startupFile)) {
+				return definition->type;
+			}
+			definition++;
+		}
+		return PAT_NONE;
+	}
+};
+
+
+inline const char *
+getAppTypeName(PassengerAppType type) {
+	const AppTypeDefinition *definition = &appTypeDefinitions[0];
+
+	while (definition->type != PAT_NONE) {
+		if (definition->type == type) {
+			return definition->name;
+		}
+		definition++;
+	}
+	return NULL;
+}
+
+inline PassengerAppType
+getAppType(const StaticString &name) {
+	const AppTypeDefinition *definition = &appTypeDefinitions[0];
+
+	while (definition->type != PAT_NONE) {
+		if (name == definition->name) {
+			return definition->type;
+		}
+		definition++;
+	}
+	return PAT_NONE;
+}
+
+inline const char *
+getAppTypeStartupFile(PassengerAppType type) {
+	const AppTypeDefinition *definition = &appTypeDefinitions[0];
+
+	while (definition->type != PAT_NONE) {
+		if (definition->type == type) {
+			return definition->startupFile;
+		}
+		definition++;
+	}
+	return NULL;
+}
+
+inline const char *
+getAppTypeProcessTitle(PassengerAppType type) {
+	const AppTypeDefinition *definition = &appTypeDefinitions[0];
+
+	while (definition->type != PAT_NONE) {
+		if (definition->type == type) {
+			return definition->processTitle;
+		}
+		definition++;
+	}
+	return NULL;
+}
+
+
+} // namespace ApplicationPool2
+} // namespace Passenger
+#endif /* __cplusplus */
+
+#endif /* _PASSENGER_APPLICATION_POOL2_APP_TYPES_H_ */

data/ext/common/ApplicationPool2/Common.h

@@ -111,29 +111,31 @@ struct Ticket {
 
 struct SpawnerConfig {
 	// Used by SmartSpawner and DirectSpawner.
-	/** Whether to forward the preloader process's stdout to our stdout. */
+	/** Whether to print the preloader's and application's stdout. */
 	bool forwardStdout;
-	/** Whether to forward the preloader process's stderr to our stderr. */
+	/** Whether to print the preloader's and application's stderr. */
 	bool forwardStderr;
-	/** Where to forward the preloader process's stdout to. */
-	int forwardStdoutTo;
-	/** Where to forward the preloader process's stderr to. */
-	int forwardStderrTo;
+	/** A random generator to use. */
+	RandomGeneratorPtr randomGenerator;
 
 	// Used by DummySpawner and SpawnerFactory.
 	unsigned int concurrency;
 	unsigned int spawnerCreationSleepTime;
 	unsigned int spawnTime;
 
-	SpawnerConfig()
+	SpawnerConfig(const RandomGeneratorPtr &randomGenerator = RandomGeneratorPtr())
 		: forwardStdout(true),
 		  forwardStderr(true),
-		  forwardStdoutTo(STDOUT_FILENO),
-		  forwardStderrTo(STDERR_FILENO),
 		  concurrency(1),
 		  spawnerCreationSleepTime(0),
 		  spawnTime(0)
-		{ }
+	{
+		if (randomGenerator != NULL) {
+			this->randomGenerator = randomGenerator;
+		} else {
+			this->randomGenerator = make_shared<RandomGenerator>();
+		}
+	}
 };
 
 typedef shared_ptr<SpawnerConfig> SpawnerConfigPtr;

data/ext/common/ApplicationPool2/DirectSpawner.h

@@ -0,0 +1,256 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2011-2013 Phusion
+ *
+ *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+ *
+ *  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_APPLICATION_POOL2_DIRECT_SPAWNER_H_
+#define _PASSENGER_APPLICATION_POOL2_DIRECT_SPAWNER_H_
+
+#include <ApplicationPool2/Spawner.h>
+#include <limits.h>  // for PTHREAD_STACK_MIN
+#include <pthread.h>
+
+
+namespace Passenger {
+namespace ApplicationPool2 {
+
+using namespace std;
+using namespace boost;
+using namespace oxt;
+
+
+class DirectSpawner: public Spawner {
+private:
+	SafeLibevPtr libev;
+	
+	static int startBackgroundThread(void *(*mainFunction)(void *), void *arg) {
+		// Using raw pthread API because we don't want to register such
+		// trivial threads on the oxt::thread list.
+		pthread_t thr;
+		pthread_attr_t attr;
+		size_t stack_size = 96 * 1024;
+		
+		unsigned long min_stack_size;
+		bool stack_min_size_defined;
+		bool round_stack_size;
+		int ret;
+		
+		#ifdef PTHREAD_STACK_MIN
+			// PTHREAD_STACK_MIN may not be a constant macro so we need
+			// to evaluate it dynamically.
+			min_stack_size = PTHREAD_STACK_MIN;
+			stack_min_size_defined = true;
+		#else
+			// Assume minimum stack size is 128 KB.
+			min_stack_size = 128 * 1024;
+			stack_min_size_defined = false;
+		#endif
+		if (stack_size != 0 && stack_size < min_stack_size) {
+			stack_size = min_stack_size;
+			round_stack_size = !stack_min_size_defined;
+		} else {
+			round_stack_size = true;
+		}
+		
+		if (round_stack_size) {
+			// Round stack size up to page boundary.
+			long page_size;
+			#if defined(_SC_PAGESIZE)
+				page_size = sysconf(_SC_PAGESIZE);
+			#elif defined(_SC_PAGE_SIZE)
+				page_size = sysconf(_SC_PAGE_SIZE);
+			#elif defined(PAGESIZE)
+				page_size = sysconf(PAGESIZE);
+			#elif defined(PAGE_SIZE)
+				page_size = sysconf(PAGE_SIZE);
+			#else
+				page_size = getpagesize();
+			#endif
+			if (stack_size % page_size != 0) {
+				stack_size = stack_size - (stack_size % page_size) + page_size;
+			}
+		}
+		
+		pthread_attr_init(&attr);
+		pthread_attr_setdetachstate(&attr, 1);
+		pthread_attr_setstacksize(&attr, stack_size);
+		ret = pthread_create(&thr, &attr, mainFunction, arg);
+		pthread_attr_destroy(&attr);
+		return ret;
+	}
+	
+	static void *detachProcessMain(void *arg) {
+		this_thread::disable_syscall_interruption dsi;
+		pid_t pid = (pid_t) (long) arg;
+		syscalls::waitpid(pid, NULL, 0);
+		return NULL;
+	}
+	
+	void detachProcess(pid_t pid) {
+		startBackgroundThread(detachProcessMain, (void *) (long) pid);
+	}
+	
+	vector<string> createCommand(const Options &options, shared_array<const char *> &args) const {
+		vector<string> startCommandArgs;
+		string processTitle;
+		string agentsDir = resourceLocator.getAgentsDir();
+		vector<string> command;
+		
+		split(options.getStartCommand(resourceLocator), '\1', startCommandArgs);
+		if (startCommandArgs.empty()) {
+			throw RuntimeException("No startCommand given");
+		}
+		if (options.getProcessTitle().empty()) {
+			processTitle = startCommandArgs[0];
+		} else {
+			processTitle = options.getProcessTitle() + ": " + options.appRoot;
+		}
+		
+		if (options.loadShellEnvvars) {
+			command.push_back("bash");
+			command.push_back("bash");
+			command.push_back("-lc");
+			command.push_back("exec \"$@\"");
+			command.push_back("SpawnPreparerShell");
+		} else {
+			command.push_back(agentsDir + "/SpawnPreparer");
+		}
+		command.push_back(agentsDir + "/SpawnPreparer");
+		command.push_back(serializeEnvvarsFromPoolOptions(options));
+		command.push_back(startCommandArgs[0]);
+		command.push_back(processTitle);
+		for (unsigned int i = 1; i < startCommandArgs.size(); i++) {
+			command.push_back(startCommandArgs[i]);
+		}
+		
+		createCommandArgs(command, args);
+		return command;
+	}
+	
+public:
+	DirectSpawner(const SafeLibevPtr &_libev,
+		const ResourceLocator &_resourceLocator,
+		const ServerInstanceDir::GenerationPtr &_generation,
+		const SpawnerConfigPtr &_config = SpawnerConfigPtr())
+		: Spawner(_resourceLocator),
+		  libev(_libev)
+	{
+		generation = _generation;
+		if (_config == NULL) {
+			config = make_shared<SpawnerConfig>();
+		} else {
+			config = _config;
+		}
+	}
+	
+	virtual ProcessPtr spawn(const Options &options) {
+		TRACE_POINT();
+		this_thread::disable_interruption di;
+		this_thread::disable_syscall_interruption dsi;
+		P_DEBUG("Spawning new process: appRoot=" << options.appRoot);
+		possiblyRaiseInternalError(options);
+
+		shared_array<const char *> args;
+		vector<string> command = createCommand(options, args);
+		SpawnPreparationInfo preparation = prepareSpawn(options);
+		SocketPair adminSocket = createUnixSocketPair();
+		Pipe errorPipe = createPipe();
+		DebugDirPtr debugDir = make_shared<DebugDir>(preparation.uid, preparation.gid);
+		pid_t pid;
+		
+		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);
+			switchUser(preparation);
+			setWorkingDirectory(preparation);
+			execvp(args[0], (char * const *) args.get());
+			
+			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);
+			fflush(stderr);
+			_exit(1);
+			
+		} else if (pid == -1) {
+			int e = errno;
+			throw SystemException("Cannot fork a new process", e);
+			
+		} else {
+			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.libev = libev;
+			details.stderrCapturer =
+				make_shared<BackgroundIOCapturer>(
+					errorPipe.first,
+					string("[App ") + toString(pid) + " stderr] ",
+					config->forwardStderr);
+			details.stderrCapturer->start();
+			details.pid = pid;
+			details.adminSocket = adminSocket.second;
+			details.io = BufferedIO(adminSocket.second);
+			details.errorPipe = errorPipe.first;
+			details.options = &options;
+			details.forwardStderr = config->forwardStderr;
+			details.debugDir = debugDir;
+			
+			ProcessPtr process;
+			{
+				this_thread::restore_interruption ri(di);
+				this_thread::restore_syscall_interruption rsi(dsi);
+				process = negotiateSpawn(details);
+			}
+			detachProcess(process->pid);
+			guard.clear();
+			P_DEBUG("Process spawning done: appRoot=" << options.appRoot <<
+				", pid=" << process->pid);
+			return process;
+		}
+	}
+};
+
+
+} // namespace ApplicationPool2
+} // namespace Passenger
+
+#endif /* _PASSENGER_APPLICATION_POOL2_DIRECT_SPAWNER_H_ */