passenger 4.0.5 → 4.0.6

data/ext/common/Account.h

@@ -62,7 +62,7 @@ public:
 		ALL                       = ~0,
 		NONE                      = 0,
 		
-		// ApplicationPool::Server rights.
+		// ApplicationPool2::Server rights.
 		GET                       = 1 << 0,
 		CLEAR                     = 1 << 1,
 		DETACH                    = 1 << 2,
@@ -73,8 +73,9 @@ public:
 		//INSPECT_BACKEND_ADDRESSES = 1 << 6,
 		//INSPECT_DETACH_KEYS       = 1 << 7,
 		
-		// BacktracesServer rights.
-		INSPECT_BACKTRACES        = 1 << 8,
+		// HelperAgent admin rights.
+		INSPECT_REQUESTS          = 1 << 8,
+		INSPECT_BACKTRACES        = 1 << 9,
 		
 		// Other rights.
 		EXIT                      = 1 << 31

data/ext/common/AccountsDatabase.h

@@ -60,7 +60,7 @@ public:
 	}
 	
 	unsigned int size() const {
-		lock_guard<boost::mutex> l(lock);
+		boost::lock_guard<boost::mutex> l(lock);
 		return (unsigned int) accounts.size();
 	}
 	
@@ -76,13 +76,13 @@ public:
 	
 	AccountPtr add(const string &username, const string &passwordOrHash, bool hashGiven, int rights = Account::ALL) {
 		AccountPtr account(new Account(username, passwordOrHash, hashGiven, rights));
-		lock_guard<boost::mutex> l(lock);
+		boost::lock_guard<boost::mutex> l(lock);
 		accounts[username] = account;
 		return account;
 	}
 	
 	const AccountPtr get(const string &username) const {
-		lock_guard<boost::mutex> l(lock);
+		boost::lock_guard<boost::mutex> l(lock);
 		map<string, AccountPtr>::const_iterator it = accounts.find(username);
 		if (it == accounts.end()) {
 			return AccountPtr();
@@ -92,7 +92,7 @@ public:
 	}
 	
 	AccountPtr authenticate(const string &username, const StaticString &userSuppliedPassword) const {
-		lock_guard<boost::mutex> l(lock);
+		boost::lock_guard<boost::mutex> l(lock);
 		map<string, AccountPtr>::const_iterator it = accounts.find(username);
 		if (it == accounts.end()) {
 			return AccountPtr();
@@ -107,7 +107,7 @@ public:
 	}
 	
 	bool remove(const string &username) {
-		lock_guard<boost::mutex> l(lock);
+		boost::lock_guard<boost::mutex> l(lock);
 		map<string, AccountPtr>::iterator it = accounts.find(username);
 		if (it == accounts.end()) {
 			return false;
@@ -118,7 +118,7 @@ public:
 	}
 	
 	unsigned int getUniqueNumber() {
-		lock_guard<boost::mutex> l(lock);
+		boost::lock_guard<boost::mutex> l(lock);
 		unsigned int result = uniqueNumber;
 		uniqueNumber++;
 		return result;

data/ext/common/AgentsStarter.h

@@ -269,17 +269,6 @@ private:
 		}
 		return false;
 	}
-
-	string findUnionStationGatewayCert(const ResourceLocator &locator,
-		const VariantMap &params) const
-	{
-		string value = params.get("union_station_gateway_cert", false);
-		if (value.empty()) {
-			return locator.getResourcesDir() + "/union_station_gateway.crt";
-		} else {
-			return value;
-		}
-	}
 	
 public:
 	/**
@@ -391,7 +380,6 @@ public:
 		this_thread::disable_interruption di;
 		this_thread::disable_syscall_interruption dsi;
 		ResourceLocator locator(passengerRoot);
-		string realUnionStationGatewayCert = findUnionStationGatewayCert(locator, extraParams);
 		string watchdogFilename = locator.getAgentsDir() + "/PassengerWatchdog";
 		SocketPair fds;
 		int e;
@@ -586,7 +574,7 @@ public:
 				UPDATE_TRACE_POINT();
 				killProcessGroupAndWait(&pid, 5000);
 				guard.clear();
-				throw RuntimeException("One of the Passenger agents sent an unknown feedback message '" + args[0] + "'");
+				throw RuntimeException("The Phusion Passenger watchdog sent an unknown feedback message '" + args[0] + "'");
 			}
 		}
 	}

data/ext/common/ApplicationPool2/DirectSpawner.h

@@ -116,14 +116,14 @@ private:
 		string agentsDir = resourceLocator.getAgentsDir();
 		vector<string> command;
 		
-		split(options.getStartCommand(resourceLocator), '\1', startCommandArgs);
+		split(options.getStartCommand(resourceLocator), '\t', startCommandArgs);
 		if (startCommandArgs.empty()) {
 			throw RuntimeException("No startCommand given");
 		}
 
-		if (options.loadShellEnvvars) {
-			command.push_back("bash");
-			command.push_back("bash");
+		if (shouldLoadShellEnvvars(options, preparation)) {
+			command.push_back(preparation.shell);
+			command.push_back(preparation.shell);
 			command.push_back("-lc");
 			command.push_back("exec \"$@\"");
 			command.push_back("SpawnPreparerShell");

data/ext/common/ApplicationPool2/DummySpawner.h

@@ -61,7 +61,7 @@ public:
 		sockets->add("main", "tcp://127.0.0.1:1234", "session", config->concurrency);
 		syscalls::usleep(config->spawnTime);
 		
-		lock_guard<boost::mutex> l(lock);
+		boost::lock_guard<boost::mutex> l(lock);
 		count++;
 		ProcessPtr process = make_shared<Process>(SafeLibevPtr(),
 			(pid_t) count, "gupid-" + toString(count),

data/ext/common/ApplicationPool2/Group.h

@@ -184,6 +184,7 @@ private:
 	void wakeUpGarbageCollector();
 	bool poolAtFullCapacity() const;
 	bool anotherGroupIsWaitingForCapacity() const;
+	const ResourceLocator &getResourceLocator() const;
 
 	void verifyInvariants() const {
 		// !a || b: logical equivalent of a IMPLIES b.
@@ -514,7 +515,7 @@ private:
 		postLockActions.push_back(boost::bind(interruptAndJoinAllThreads,
 			shared_from_this()));
 		{
-			lock_guard<boost::mutex> l(lifetimeSyncher);
+			boost::lock_guard<boost::mutex> l(lifetimeSyncher);
 			lifeStatus = SHUT_DOWN;
 		}
 		selfPointer.reset();
@@ -668,7 +669,7 @@ public:
 		selfPointer = shared_from_this();
 		assert(disableWaitlist.empty());
 		{
-			lock_guard<boost::mutex> l(lifetimeSyncher);
+			boost::lock_guard<boost::mutex> l(lifetimeSyncher);
 			lifeStatus = SHUTTING_DOWN;
 		}
 	}
@@ -766,13 +767,13 @@ public:
 	
 	// Thread-safe.
 	bool isAlive() const {
-		lock_guard<boost::mutex> lock(lifetimeSyncher);
+		boost::lock_guard<boost::mutex> lock(lifetimeSyncher);
 		return lifeStatus == ALIVE;
 	}
 
 	// Thread-safe.
 	LifeStatus getLifeStatus() const {
-		lock_guard<boost::mutex> lock(lifetimeSyncher);
+		boost::lock_guard<boost::mutex> lock(lifetimeSyncher);
 		return lifeStatus;
 	}
 	
@@ -1080,6 +1081,10 @@ public:
 			P_BUG("Unknown 'lifeStatus' state " << (int) lifeStatus);
 		}
 
+		stream << "<options>";
+		options.toXml(stream, getResourceLocator());
+		stream << "</options>";
+
 		stream << "<processes>";
 		
 		for (it = enabledProcesses.begin(); it != enabledProcesses.end(); it++) {

data/ext/common/ApplicationPool2/Implementation.cpp

@@ -1042,6 +1042,11 @@ Group::anotherGroupIsWaitingForCapacity() const {
 	return false;
 }
 
+const ResourceLocator &
+Group::getResourceLocator() const {
+	return getPool()->spawnerFactory->getResourceLocator();
+}
+
 string
 Group::generateSecret(const SuperGroupPtr &superGroup) {
 	return superGroup->getPool()->randomGenerator->generateAsciiString(43);
@@ -1117,7 +1122,7 @@ PipeWatcher::initialize() {
 
 void
 PipeWatcher::start() {
-	lock_guard<boost::mutex> lock(startSyncher);
+	boost::lock_guard<boost::mutex> lock(startSyncher);
 	started = true;
 	startCond.notify_all();
 }

data/ext/common/ApplicationPool2/Options.h

@@ -35,6 +35,7 @@
 #include <Constants.h>
 #include <ResourceLocator.h>
 #include <StaticString.h>
+#include <Utils.h>
 
 namespace Passenger {
 namespace ApplicationPool2 {
@@ -172,7 +173,7 @@ public:
 	StaticString appType;
 	
 	/** The command for spawning the application process. This is a list of
-	 * arguments, separated by '\1', e.g. "ruby\1foo.rb". Only used
+	 * arguments, separated by '\t', e.g. "ruby\tfoo.rb". Only used
 	 * during spawning and only if appType.empty(). */
 	StaticString startCommand;
 	
@@ -479,46 +480,73 @@ public:
 		logger.reset();
 		return *this;
 	}
+
+	enum FieldSet {
+		SPAWN_OPTIONS = 1 << 0,
+		PER_GROUP_POOL_OPTIONS = 1 << 1,
+		ALL_OPTIONS = ~0
+	};
 	
 	/**
-	 * Append any spawning-relevant information in this Options object
-	 * to the given string vector, except for environmentVariables.
+	 * Append information in this Options object to the given string vector, except
+	 * for environmentVariables. You can customize what information you want through
+	 * the `elements` argument.
 	 */
-	void toVector(vector<string> &vec, const ResourceLocator &resourceLocator) const {
-		if (vec.capacity() < vec.size() + 40) {
-			vec.reserve(vec.size() + 40);
+	void toVector(vector<string> &vec, const ResourceLocator &resourceLocator,
+		int fields = ALL_OPTIONS) const
+	{
+		if (fields & SPAWN_OPTIONS) {
+			appendKeyValue (vec, "app_root",           appRoot);
+			appendKeyValue (vec, "app_group_name",     getAppGroupName());
+			appendKeyValue (vec, "app_type",           appType);
+			appendKeyValue (vec, "start_command",      getStartCommand(resourceLocator));
+			appendKeyValue (vec, "startup_file",       getStartupFile());
+			appendKeyValue (vec, "process_title",      getProcessTitle());
+			appendKeyValue2(vec, "log_level",          logLevel);
+			appendKeyValue3(vec, "start_timeout",      startTimeout);
+			appendKeyValue (vec, "environment",        environment);
+			appendKeyValue (vec, "base_uri",           baseURI);
+			appendKeyValue (vec, "spawn_method",       spawnMethod);
+			appendKeyValue (vec, "user",               user);
+			appendKeyValue (vec, "group",              group);
+			appendKeyValue (vec, "default_user",       defaultUser);
+			appendKeyValue (vec, "default_group",      defaultGroup);
+			appendKeyValue (vec, "restart_dir",        restartDir);
+			appendKeyValue (vec, "preexec_chroot",     preexecChroot);
+			appendKeyValue (vec, "postexec_chroot",    postexecChroot);
+			appendKeyValue (vec, "ruby",               ruby);
+			appendKeyValue (vec, "python",             python);
+			appendKeyValue (vec, "logging_agent_address",  loggingAgentAddress);
+			appendKeyValue (vec, "logging_agent_username", loggingAgentUsername);
+			appendKeyValue (vec, "logging_agent_password", loggingAgentPassword);
+			appendKeyValue4(vec, "debugger",           debugger);
+			appendKeyValue4(vec, "analytics",          analytics);
+			appendKeyValue (vec, "union_station_key",  unionStationKey);
+
+			appendKeyValue (vec, "group_secret",       groupSecret);
+		}
+		if (fields & PER_GROUP_POOL_OPTIONS) {
+			appendKeyValue3(vec, "min_processes",       minProcesses);
+			appendKeyValue2(vec, "max_preloader_idle_time", maxPreloaderIdleTime);
 		}
-		
-		appendKeyValue (vec, "app_root",           appRoot);
-		appendKeyValue (vec, "app_group_name",     getAppGroupName());
-		appendKeyValue (vec, "app_type",           appType);
-		appendKeyValue (vec, "start_command",      getStartCommand(resourceLocator));
-		appendKeyValue (vec, "process_title",      getProcessTitle());
-		appendKeyValue2(vec, "log_level",          logLevel);
-		appendKeyValue3(vec, "start_timeout",      startTimeout);
-		appendKeyValue (vec, "environment",        environment);
-		appendKeyValue (vec, "base_uri",           baseURI);
-		appendKeyValue (vec, "spawn_method",       spawnMethod);
-		appendKeyValue (vec, "user",               user);
-		appendKeyValue (vec, "group",              group);
-		appendKeyValue (vec, "default_user",       defaultUser);
-		appendKeyValue (vec, "default_group",      defaultGroup);
-		appendKeyValue (vec, "restart_dir",        restartDir);
-		appendKeyValue (vec, "preexec_chroot",     preexecChroot);
-		appendKeyValue (vec, "postexec_chroot",    postexecChroot);
-		appendKeyValue (vec, "ruby",               ruby);
-		appendKeyValue (vec, "python",             python);
-		appendKeyValue (vec, "logging_agent_address",  loggingAgentAddress);
-		appendKeyValue (vec, "logging_agent_username", loggingAgentUsername);
-		appendKeyValue (vec, "logging_agent_password", loggingAgentPassword);
-		appendKeyValue4(vec, "debugger",           debugger);
-		appendKeyValue4(vec, "analytics",          analytics);
-		appendKeyValue (vec, "union_station_key",  unionStationKey);
-		
-		appendKeyValue (vec, "group_secret",       groupSecret);
 		
 		/*********************************/
 	}
+
+	template<typename Stream>
+	void toXml(Stream &stream, const ResourceLocator &resourceLocator,
+		int fields = ALL_OPTIONS) const
+	{
+		vector<string> args;
+		unsigned int i;
+		
+		toVector(args, resourceLocator, fields);
+		for (i = 0; i < args.size(); i += 2) {
+			stream << "<" << args[i] << ">";
+			stream << escapeForXml(args[i + 1]);
+			stream << "</" << args[i] << ">";
+		}
+	}
 	
 	/**
 	 * Returns the app group name. If there is no explicitly set app group name
@@ -534,11 +562,11 @@ public:
 	
 	string getStartCommand(const ResourceLocator &resourceLocator) const {
 		if (appType == "classic-rails") {
-			return ruby + "\1" + resourceLocator.getHelperScriptsDir() + "/classic-rails-loader.rb";
+			return ruby + "\t" + resourceLocator.getHelperScriptsDir() + "/classic-rails-loader.rb";
 		} else if (appType == "rack") {
-			return ruby + "\1" + resourceLocator.getHelperScriptsDir() + "/rack-loader.rb";
+			return ruby + "\t" + resourceLocator.getHelperScriptsDir() + "/rack-loader.rb";
 		} else if (appType == "wsgi") {
-			return python + "\1" + resourceLocator.getHelperScriptsDir() + "/wsgi-loader.py";
+			return python + "\t" + resourceLocator.getHelperScriptsDir() + "/wsgi-loader.py";
 		} else {
 			return startCommand;
 		}

data/ext/common/ApplicationPool2/Pool.h

@@ -529,6 +529,12 @@ public:
 		return superGroups.get(options.getAppGroupName()).get();
 	}
 
+	struct GarbageCollectorState {
+		unsigned long long now;
+		unsigned long long nextGcRunTime;
+		vector<Callback> actions;
+	};
+
 	static void garbageCollect(PoolPtr self) {
 		TRACE_POINT();
 		{
@@ -551,13 +557,53 @@ public:
 		}
 	}
 
+	void maybeUpdateNextGcRuntime(GarbageCollectorState &state, unsigned long candidate) {
+		if (state.nextGcRunTime == 0 || candidate < state.nextGcRunTime) {
+			state.nextGcRunTime = candidate;
+		}
+	}
+
+	void maybeDetachIdleProcess(GarbageCollectorState &state, const GroupPtr &group,
+		const ProcessPtr &process, ProcessList::iterator &p_it)
+	{
+		assert(maxIdleTime > 0);
+		unsigned long long processGcTime =
+			process->lastUsed + maxIdleTime;
+		if (process->sessions == 0
+		 && state.now >= processGcTime
+		 && (unsigned long) group->enabledCount > group->options.minProcesses) {
+			ProcessList::iterator prev = p_it;
+			prev--;
+			P_DEBUG("Garbage collect idle process: " << process->inspect() <<
+				", group=" << group->name);
+			group->detach(process, state.actions);
+			p_it = prev;
+		} else {
+			maybeUpdateNextGcRuntime(state, processGcTime);
+		}
+	}
+
+	void maybeCleanPreloader(GarbageCollectorState &state, const GroupPtr &group) {
+		if (group->spawner->cleanable() && group->options.getMaxPreloaderIdleTime() != 0) {
+			unsigned long long spawnerGcTime =
+				group->spawner->lastUsed() +
+				group->options.getMaxPreloaderIdleTime() * 1000000;
+			if (state.now >= spawnerGcTime) {
+				P_DEBUG("Garbage collect idle spawner: group=" << group->name);
+				group->cleanupSpawner(state.actions);
+			} else {
+				maybeUpdateNextGcRuntime(state, spawnerGcTime);
+			}
+		}
+	}
+
 	unsigned long long realGarbageCollect() {
 		TRACE_POINT();
 		ScopedLock lock(syncher);
 		SuperGroupMap::iterator it, end = superGroups.end();
-		vector<Callback> actions;
-		unsigned long long now = SystemTime::getUsec();
-		unsigned long long nextGcRunTime = 0;
+		GarbageCollectorState state;
+		state.now = SystemTime::getUsec();
+		state.nextGcRunTime = 0;
 		
 		P_DEBUG("Garbage collection time...");
 		verifyInvariants();
@@ -572,45 +618,22 @@ public:
 			
 			for (g_it = groups.begin(); g_it != g_end; g_it++) {
 				GroupPtr group = *g_it;
-				ProcessList &processes = group->enabledProcesses;
-				ProcessList::iterator p_it, p_end = processes.end();
-				
-				for (p_it = processes.begin(); p_it != p_end; p_it++) {
-					ProcessPtr process = *p_it;
-					
-					// ...detach processes that have been idle for more than maxIdleTime.
-					unsigned long long processGcTime =
-						process->lastUsed + maxIdleTime;
-					if (process->sessions == 0
-					 && now >= processGcTime
-					 && (unsigned long) group->enabledCount > group->options.minProcesses) {
-						ProcessList::iterator prev = p_it;
-						prev--;
-						P_DEBUG("Garbage collect idle process: " << process->inspect() <<
-							", group=" << group->name);
-						group->detach(process, actions);
-						p_it = prev;
-					} else if (nextGcRunTime == 0
-					        || processGcTime < nextGcRunTime) {
-						nextGcRunTime = processGcTime;
+
+				if (maxIdleTime > 0) {
+					ProcessList &processes = group->enabledProcesses;
+					ProcessList::iterator p_it, p_end = processes.end();
+
+					for (p_it = processes.begin(); p_it != p_end; p_it++) {
+						ProcessPtr process = *p_it;
+						// ...detach processes that have been idle for more than maxIdleTime.
+						maybeDetachIdleProcess(state, group, process, p_it);
 					}
 				}
 				
 				group->verifyInvariants();
-				
+			
 				// ...cleanup the spawner if it's been idle for more than preloaderIdleTime.
-				if (group->spawner->cleanable()) {
-					unsigned long long spawnerGcTime =
-						group->spawner->lastUsed() +
-						group->options.getMaxPreloaderIdleTime() * 1000000;
-					if (now >= spawnerGcTime) {
-						P_DEBUG("Garbage collect idle spawner: group=" << group->name);
-						group->cleanupSpawner(actions);
-					} else if (nextGcRunTime == 0
-					        || spawnerGcTime < nextGcRunTime) {
-						nextGcRunTime = spawnerGcTime;
-					}
-				}
+				maybeCleanPreloader(state, group);
 			}
 			
 			superGroup->verifyInvariants();
@@ -621,22 +644,22 @@ public:
 
 		// Schedule next garbage collection run.
 		unsigned long long sleepTime;
-		if (nextGcRunTime == 0 || nextGcRunTime <= now) {
+		if (state.nextGcRunTime == 0 || state.nextGcRunTime <= state.now) {
 			if (maxIdleTime == 0) {
 				sleepTime = 10 * 60 * 1000000;
 			} else {
 				sleepTime = maxIdleTime;
 			}
 		} else {
-			sleepTime = nextGcRunTime - now;
+			sleepTime = state.nextGcRunTime - state.now;
 		}
 		P_DEBUG("Garbage collection done; next garbage collect in " <<
 			std::fixed << std::setprecision(3) << (sleepTime / 1000000.0) << " sec");
 
 		UPDATE_TRACE_POINT();
-		runAllActions(actions);
+		runAllActions(state.actions);
 		UPDATE_TRACE_POINT();
-		actions.clear();
+		state.actions.clear();
 		return sleepTime;
 	}
 
@@ -1182,6 +1205,18 @@ public:
 		return ProcessPtr();
 	}
 
+	ProcessPtr findProcessByPid(pid_t pid, bool lock = true) const {
+		vector<ProcessPtr> processes = getProcesses(lock);
+		vector<ProcessPtr>::const_iterator it, end = processes.end();
+		for (it = processes.begin(); it != end; it++) {
+			const ProcessPtr &process = *it;
+			if (process->pid == pid) {
+				return process;
+			}
+		}
+		return ProcessPtr();
+	}
+
 	bool detachSuperGroupByName(const string &name) {
 		TRACE_POINT();
 		ScopedLock l(syncher);
@@ -1261,6 +1296,21 @@ public:
 		return result;
 	}
 
+	bool detachProcess(pid_t pid) {
+		ScopedLock l(syncher);
+		ProcessPtr process = findProcessByPid(pid, false);
+		if (process != NULL) {
+			vector<Callback> actions;
+			bool result = detachProcessUnlocked(process, actions);
+			fullVerifyInvariants();
+			l.unlock();
+			runAllActions(actions);
+			return result;
+		} else {
+			return false;
+		}
+	}
+
 	bool detachProcess(const string &gupid) {
 		ScopedLock l(syncher);
 		ProcessPtr process = findProcessByGupid(gupid, false);