passenger 4.0.60 → 5.0.0.beta1

data/ext/common/ApplicationPool2/SpawnObject.h

@@ -0,0 +1,83 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2014 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_POOL_SPAWNER_OBJECT_H_
+#define _PASSENGER_APPLICATION_POOL_SPAWNER_OBJECT_H_
+
+#include <boost/noncopyable.hpp>
+#include <boost/move/core.hpp>
+#include <MemoryKit/palloc.h>
+#include <ApplicationPool2/Common.h>
+
+namespace Passenger {
+namespace ApplicationPool2 {
+
+
+class SpawnObject: public boost::noncopyable {
+private:
+	BOOST_MOVABLE_BUT_NOT_COPYABLE(SpawnObject)
+
+public:
+	psg_pool_t *pool;
+	ProcessPtr process;
+
+	SpawnObject() {
+		pool = psg_create_pool(PSG_DEFAULT_POOL_SIZE);
+	}
+
+	SpawnObject(BOOST_RV_REF(SpawnObject) r)
+		: pool(r.pool),
+		  process(r.process)
+	{
+		r.pool = NULL;
+		r.process.reset();
+	}
+
+	~SpawnObject() {
+		if (pool != NULL) {
+			psg_destroy_pool(pool);
+		}
+	}
+
+	SpawnObject &operator=(BOOST_RV_REF(SpawnObject) r) {
+		if (this != &r) {
+			if (pool != r.pool) {
+				if (pool != NULL) {
+					psg_destroy_pool(pool);
+				}
+				pool = r.pool;
+			}
+			r.pool = NULL;
+			process = r.process;
+			r.process.reset();
+		}
+		return *this;
+	}
+};
+
+
+} // namespace ApplicationPool2
+} // namespace Passenger
+
+#endif /* _PASSENGER_APPLICATION_POOL_SPAWNER_OBJECT_H_ */

data/ext/common/ApplicationPool2/Spawner.h

@@ -62,9 +62,12 @@
 #include <boost/shared_array.hpp>
 #include <boost/bind.hpp>
 #include <boost/foreach.hpp>
+#include <boost/move/move.hpp>
 #include <oxt/system_calls.hpp>
 #include <oxt/backtrace.hpp>
 #include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
@@ -77,18 +80,18 @@
 #include <ApplicationPool2/Common.h>
 #include <ApplicationPool2/Process.h>
 #include <ApplicationPool2/Options.h>
+#include <ApplicationPool2/SpawnObject.h>
 #include <ApplicationPool2/PipeWatcher.h>
 #include <FileDescriptor.h>
 #include <Exceptions.h>
 #include <StaticString.h>
-#include <ServerInstanceDir.h>
 #include <Utils.h>
 #include <Utils/BufferedIO.h>
 #include <Utils/ScopeGuard.h>
 #include <Utils/Timer.h>
 #include <Utils/IOUtils.h>
 #include <Utils/StrIntUtils.h>
-#include <Utils/Base64.h>
+#include <Utils/modp_b64.h>
 #include <Utils/ProcessMetricsCollector.h>
 
 namespace tut {
@@ -350,7 +353,6 @@ protected:
 		/****** Working state ******/
 		BufferedIO io;
 		string gupid;
-		string connectPassword;
 		unsigned long long spawnStartTime;
 		unsigned long long timeout;
 
@@ -371,10 +373,6 @@ private:
 	static void appendNullTerminatedKeyValue(string &output, const StaticString &key,
 		const StaticString &value)
 	{
-		unsigned int minCapacity = key.size() + value.size() + 2;
-		if (output.capacity() < minCapacity) {
-			output.reserve(minCapacity + 1024);
-		}
 		output.append(key.data(), key.size());
 		output.append(1, '\0');
 		output.append(value.data(), value.size());
@@ -384,17 +382,23 @@ private:
 	void sendSpawnRequest(NegotiationDetails &details) {
 		TRACE_POINT();
 		try {
+			const size_t UNIX_PATH_MAX = sizeof(((struct sockaddr_un *) 0)->sun_path);
 			string data = "You have control 1.0\n"
-				"passenger_root: " + config->resourceLocator.getRoot() + "\n"
+				"passenger_root: " + config->resourceLocator->getRoot() + "\n"
 				"passenger_version: " PASSENGER_VERSION "\n"
-				"ruby_libdir: " + config->resourceLocator.getRubyLibDir() + "\n"
-				"generation_dir: " + generation->getPath() + "\n"
+				"ruby_libdir: " + config->resourceLocator->getRubyLibDir() + "\n"
 				"gupid: " + details.gupid + "\n"
-				"connect_password: " + details.connectPassword + "\n";
+				"UNIX_PATH_MAX: " + toString(UNIX_PATH_MAX) + "\n";
+			if (!details.options->groupSecret.empty()) {
+				"connect_password: " + details.options->groupSecret + "\n";
+			}
+			if (!config->instanceDir.empty()) {
+				data.append("socket_dir: " + config->instanceDir + "/apps.s\n");
+			}
 
 			vector<string> args;
 			vector<string>::const_iterator it, end;
-			details.options->toVector(args, config->resourceLocator, Options::SPAWN_OPTIONS);
+			details.options->toVector(args, *config->resourceLocator, Options::SPAWN_OPTIONS);
 			for (it = args.begin(); it != args.end(); it++) {
 				const string &key = *it;
 				it++;
@@ -421,9 +425,11 @@ private:
 		}
 	}
 
-	ProcessPtr handleSpawnResponse(NegotiationDetails &details) {
+	SpawnObject handleSpawnResponse(NegotiationDetails &details) {
 		TRACE_POINT();
-		SocketListPtr sockets = boost::make_shared<SocketList>();
+		SocketList sockets;
+		SpawnObject result;
+
 		while (true) {
 			string line;
 
@@ -484,10 +490,13 @@ private:
 							SpawnException::APP_STARTUP_PROTOCOL_ERROR,
 							details);
 					}
-					sockets->add(args[0],
-						fixupSocketAddress(*details.options, args[1]),
-						args[2],
-						atoi(args[3]));
+
+					StaticString name = psg_pstrdup(result.pool, args[0]);
+					StaticString address = psg_pstrdup(result.pool,
+						fixupSocketAddress(*details.options, args[1]));
+					StaticString protocol = psg_pstrdup(result.pool, args[2]);
+
+					sockets.add(name, address, protocol, atoi(args[3]));
 				} else {
 					throwAppSpawnException("An error occurred while starting the "
 						"web application. It reported a wrongly formatted 'socket'"
@@ -502,8 +511,8 @@ private:
 				vector<pid_t> pids;
 
 				pids.push_back(pid);
-				ProcessMetricMap result = collector.collect(pids);
-				if (result[pid].uid != details.preparation->uid) {
+				ProcessMetricMap metrics = collector.collect(pids);
+				if (metrics[pid].uid != details.preparation->uid) {
 					throwAppSpawnException("An error occurred while starting the "
 						"web application. The PID that the loader has returned does "
 						"not have the same UID as the loader itself.",
@@ -520,24 +529,24 @@ private:
 			}
 		}
 
-		if (sockets->hasSessionSockets() == 0) {
+		if (!sockets.hasSessionSockets()) {
 			throwAppSpawnException("An error occured while starting the web "
 				"application. It did not advertise any session sockets.",
 				SpawnException::APP_STARTUP_PROTOCOL_ERROR,
 				details);
 		}
 
-		ProcessPtr process = boost::make_shared<Process>(
+		result.process = boost::make_shared<Process>(
 			details.pid,
-			details.gupid, details.connectPassword,
+			details.gupid,
 			details.adminSocket, details.errorPipe,
 			sockets, creationTime, details.spawnStartTime);
-		process->codeRevision = details.preparation->codeRevision;
-		return process;
+		result.process->codeRevision = psg_pstrdup(result.pool,
+			details.preparation->codeRevision);
+		return boost::move(result);
 	}
 
 protected:
-	ServerInstanceDir::GenerationPtr generation;
 	SpawnerConfigPtr config;
 
 	static void nonInterruptableKillAndWaitpid(pid_t pid) {
@@ -1109,7 +1118,7 @@ protected:
 
 		appendNullTerminatedKeyValue(result, "IN_PASSENGER", "1");
 		appendNullTerminatedKeyValue(result, "PYTHONUNBUFFERED", "1");
-		appendNullTerminatedKeyValue(result, "NODE_PATH", config->resourceLocator.getNodeLibDir());
+		appendNullTerminatedKeyValue(result, "NODE_PATH", config->resourceLocator->getNodeLibDir());
 		appendNullTerminatedKeyValue(result, "RAILS_ENV", options.environment);
 		appendNullTerminatedKeyValue(result, "RACK_ENV", options.environment);
 		appendNullTerminatedKeyValue(result, "WSGI_ENV", options.environment);
@@ -1127,14 +1136,27 @@ protected:
 				options.baseURI);
 		}
 
-		it  = options.environmentVariables.begin();
-		end = options.environmentVariables.end();
-		while (it != end) {
-			appendNullTerminatedKeyValue(result, it->first, it->second);
-			it++;
+		string envvarsData;
+		try {
+			envvarsData = modp::b64_decode(options.environmentVariables.data(),
+				options.environmentVariables.size());
+		} catch (const std::runtime_error &) {
+			P_WARN("Unable to decode base64-encoded environment variables: " <<
+				options.environmentVariables);
+			envvarsData.clear();
+		}
+
+		if (!envvarsData.empty()) {
+			// The envvars data is in the same format as `result`,
+			// so we can just append it.
+			result.append(envvarsData);
 		}
 
-		return Base64::encode(result);
+		try {
+			return modp::b64_encode(result);
+		} catch (const std::runtime_error &) {
+			throw RuntimeException("Unable to encode data into a base64 string");
+		}
 	}
 
 	void switchUser(const SpawnPreparationInfo &info) {
@@ -1285,12 +1307,11 @@ protected:
 	/**
 	 * Execute the process spawning negotiation protocol.
 	 */
-	ProcessPtr negotiateSpawn(NegotiationDetails &details) {
+	SpawnObject negotiateSpawn(NegotiationDetails &details) {
 		TRACE_POINT();
 		details.spawnStartTime = SystemTime::getUsec();
 		details.gupid = integerToHex(SystemTime::get() / 60) + "-" +
-			config->randomGenerator->generateAsciiString(11);
-		details.connectPassword = config->randomGenerator->generateAsciiString(43);
+			config->randomGenerator->generateAsciiString(10);
 		details.timeout = details.options->startTimeout * 1000;
 
 		string result;
@@ -1344,7 +1365,7 @@ protected:
 				handleInvalidSpawnResponseType(result, details);
 			}
 		}
-		return ProcessPtr(); // Never reached.
+		return SpawnObject(); // Never reached.
 	}
 
 	void handleSpawnErrorResponse(NegotiationDetails &details) {
@@ -1435,7 +1456,7 @@ public:
 		{ }
 
 	virtual ~Spawner() { }
-	virtual ProcessPtr spawn(const Options &options) = 0;
+	virtual SpawnObject spawn(const Options &options) = 0;
 
 	/** Does not depend on the event loop. */
 	virtual bool cleanable() const {

data/ext/common/ApplicationPool2/SpawnerFactory.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2011-2013 Phusion
+ *  Copyright (c) 2011-2014 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -40,32 +40,26 @@ using namespace oxt;
 
 class SpawnerFactory {
 private:
-	ServerInstanceDir::GenerationPtr generation;
 	boost::mutex syncher;
 	SpawnerConfigPtr config;
 	DummySpawnerPtr dummySpawner;
 
 	SpawnerPtr tryCreateSmartSpawner(const Options &options) {
-		string dir = config->resourceLocator.getHelperScriptsDir();
+		string dir = config->resourceLocator->getHelperScriptsDir();
 		vector<string> preloaderCommand;
-		if (options.appType == "classic-rails") {
-			preloaderCommand.push_back(options.ruby);
-			preloaderCommand.push_back(dir + "/classic-rails-preloader.rb");
-		} else if (options.appType == "rack") {
+		if (options.appType == "rack") {
 			preloaderCommand.push_back(options.ruby);
 			preloaderCommand.push_back(dir + "/rack-preloader.rb");
 		} else {
 			return SpawnerPtr();
 		}
-		return boost::make_shared<SmartSpawner>(generation, preloaderCommand,
+		return boost::make_shared<SmartSpawner>(preloaderCommand,
 			options, config);
 	}
 
 public:
-	SpawnerFactory(const ServerInstanceDir::GenerationPtr &_generation,
-		const SpawnerConfigPtr &_config)
-		: generation(_generation),
-		  config(_config)
+	SpawnerFactory(const SpawnerConfigPtr &_config)
+		: config(_config)
 		{ }
 
 	virtual ~SpawnerFactory() { }
@@ -74,12 +68,12 @@ public:
 		if (options.spawnMethod == "smart" || options.spawnMethod == "smart-lv2") {
 			SpawnerPtr spawner = tryCreateSmartSpawner(options);
 			if (spawner == NULL) {
-				spawner = boost::make_shared<DirectSpawner>(generation, config);
+				spawner = boost::make_shared<DirectSpawner>(config);
 			}
 			return spawner;
 		} else if (options.spawnMethod == "direct" || options.spawnMethod == "conservative") {
 			boost::shared_ptr<DirectSpawner> spawner = boost::make_shared<DirectSpawner>(
-				generation, config);
+				config);
 			return spawner;
 		} else if (options.spawnMethod == "dummy") {
 			syscalls::usleep(config->spawnerCreationSleepTime);

data/ext/common/ApplicationPool2/SuperGroup.h

@@ -29,6 +29,7 @@
 #include <boost/bind.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/make_shared.hpp>
+#include <boost/container/vector.hpp>
 #include <oxt/thread.hpp>
 #include <vector>
 #include <utility>
@@ -37,6 +38,7 @@
 #include <ApplicationPool2/ComponentInfo.h>
 #include <ApplicationPool2/Group.h>
 #include <ApplicationPool2/Options.h>
+#include <Utils/SmallVector.h>
 
 namespace Passenger {
 namespace ApplicationPool2 {
@@ -169,29 +171,21 @@ public:
 	};
 
 	typedef boost::function<void (ShutdownResult result)> ShutdownCallback;
+	typedef SmallVector<GroupPtr, 1> GroupList;
 
 private:
 	friend class Pool;
 	friend class Group;
 
 	Options options;
-	/** A number for concurrency control, incremented every time the state changes.
-	 * Every background thread that SuperGroup spawns knows the generation number
-	 * from when the thread was spawned. A thread generally does some work outside
-	 * the lock, then grabs the lock and updates the information in this SuperGroup
-	 * with the results of the work. But before updating happens it first checks
-	 * whether the generation number is as expected, so increasing this generation
-	 * number will prevent old threads from updating the information with possibly
-	 * now-stale information. It is a good way to prevent A-B-A concurrency
-	 * problems.
-	 */
-	unsigned int generation;
 
 
 	// Thread-safe.
-	static boost::mutex &getPoolSyncher(const PoolPtr &pool);
-	static void runAllActions(const vector<Callback> &actions);
+	static boost::mutex &getPoolSyncher(Pool *pool);
+	static void runAllActions(const boost::container::vector<Callback> &actions);
+	const PoolPtr getPoolPtr();
 	string generateSecret() const;
+	bool selfCheckingEnabled() const;
 	void runInitializationHooks() const;
 	void runDestructionHooks() const;
 	void setupInitializationOrDestructionHook(HookScriptOptions &options) const;
@@ -200,8 +194,13 @@ private:
 		unsigned int stackSize);
 
 	void verifyInvariants() const {
+		#ifndef NDEBUG
 		// !a || b: logical equivalent of a IMPLIES b.
 
+		if (!selfCheckingEnabled()) {
+			return;
+		}
+
 		assert(groups.empty() ==
 			(state == INITIALIZING || state == DESTROYING || state == DESTROYED));
 		assert((defaultGroup == NULL) ==
@@ -209,6 +208,7 @@ private:
 		assert(!( state == READY || state == RESTARTING || state == DESTROYING || state == DESTROYED ) ||
 			( getWaitlist.empty() ));
 		assert(!( state == DESTROYED ) || ( detachedGroups.empty() ));
+		#endif
 	}
 
 	void setState(State newState) {
@@ -225,8 +225,8 @@ private:
 		return infos;
 	}
 
-	Group *findDefaultGroup(const vector<GroupPtr> &groups) const {
-		vector<GroupPtr>::const_iterator it;
+	Group *findDefaultGroup(const SuperGroup::GroupList &groups) const {
+		SuperGroup::GroupList::const_iterator it;
 
 		for (it = groups.begin(); it != groups.end(); it++) {
 			const GroupPtr &group = *it;
@@ -238,7 +238,7 @@ private:
 	}
 
 	pair<GroupPtr, unsigned int> findGroupCorrespondingToComponent(
-		const vector<GroupPtr> &groups, const ComponentInfo &info) const
+		const SuperGroup::GroupList &groups, const ComponentInfo &info) const
 	{
 		unsigned int i;
 		for (i = 0; i < groups.size(); i++) {
@@ -253,7 +253,7 @@ private:
 	static void oneGroupHasBeenShutDown(SuperGroupPtr self, GroupPtr group) {
 		// This function is either called from the pool event loop or directly from
 		// the detachAllGroups post lock actions. In both cases getPool() is never NULL.
-		PoolPtr pool = self->getPool();
+		Pool *pool = self->getPool();
 		boost::lock_guard<boost::mutex> lock(self->getPoolSyncher(pool));
 
 		vector<GroupPtr>::iterator it, end = self->detachedGroups.end();
@@ -268,7 +268,9 @@ private:
 	/** One of the post lock actions can potentially perform a long-running
 	 * operation, so running them in a thread is advised.
 	 */
-	void detachAllGroups(vector<GroupPtr> &groups, vector<Callback> &postLockActions) {
+	void detachAllGroups(GroupList &groups,
+		boost::container::vector<Callback> &postLockActions)
+	{
 		foreach (const GroupPtr &group, groups) {
 			// doRestart() may temporarily nullify elements in 'groups'.
 			if (group == NULL) {
@@ -291,7 +293,7 @@ private:
 		groups.clear();
 	}
 
-	void assignGetWaitlistToGroups(vector<Callback> &postLockActions) {
+	void assignGetWaitlistToGroups(boost::container::vector<Callback> &postLockActions) {
 		while (!getWaitlist.empty()) {
 			GetWaiter &waiter = getWaitlist.front();
 			Group *group = route(waiter.options);
@@ -300,7 +302,7 @@ private:
 			SessionPtr session = group->get(adjustedOptions, waiter.callback,
 				postLockActions);
 			if (session != NULL) {
-				postLockActions.push_back(boost::bind(
+				postLockActions.push_back(boost::bind(GetCallback::call,
 					waiter.callback, session, ExceptionPtr()));
 			}
 			getWaitlist.pop_front();
@@ -329,7 +331,7 @@ private:
 
 		// Wait until 'detachedGroups' is empty.
 		UPDATE_TRACE_POINT();
-		PoolPtr pool = getPool();
+		Pool *pool = getPool();
 		boost::unique_lock<boost::mutex> lock(getPoolSyncher(pool));
 		verifyInvariants();
 		while (true) {
@@ -368,21 +370,38 @@ private:
 
 public:
 	mutable boost::mutex backrefSyncher;
-	const boost::weak_ptr<Pool> pool;
+	// Public, read-only
+	Pool *pool;
 
+	/** A number for concurrency control, incremented every time the state changes.
+	 * Every background thread that SuperGroup spawns knows the generation number
+	 * from when the thread was spawned. A thread generally does some work outside
+	 * the lock, then grabs the lock and updates the information in this SuperGroup
+	 * with the results of the work. But before updating happens it first checks
+	 * whether the generation number is as expected, so increasing this generation
+	 * number will prevent old threads from updating the information with possibly
+	 * now-stale information. It is a good way to prevent A-B-A concurrency
+	 * problems.
+	 *
+	 * Private.
+	 */
+	unsigned int generation;
+	// Private
 	State state;
+
+	// Public, read-only
 	string name;
 	string secret;
 
 	/** Invariant:
-	 * groups.empty() == (state == INITIALIZING || state == DESTROYING || state == DESTROYED)
+	 * (defaultGroup == NULL) == (state == INITIALIZING || state == DESTROYING || state == DESTROYED)
 	 */
-	vector<GroupPtr> groups;
+	Group *defaultGroup;
 
 	/** Invariant:
-	 * (defaultGroup == NULL) == (state == INITIALIZING || state == DESTROYING || state == DESTROYED)
+	 * groups.empty() == (state == INITIALIZING || state == DESTROYING || state == DESTROYED)
 	 */
-	Group *defaultGroup;
+	GroupList groups;
 
 	/**
 	 * get() requests for this super group that cannot be immediately satisfied
@@ -417,7 +436,7 @@ public:
 	/** One MUST call initialize() after construction because shared_from_this()
 	 * is not available in the constructor.
 	 */
-	SuperGroup(const PoolPtr &_pool, const Options &options)
+	SuperGroup(Pool *_pool, const Options &options)
 		: pool(_pool)
 	{
 		this->options = options.copyAndPersist().detachFromUnionStationTransaction();
@@ -455,8 +474,9 @@ public:
 	 * because Pool::destroy() joins all threads, so Pool can never
 	 * be destroyed before all thread callbacks have finished.
 	 */
-	PoolPtr getPool() const {
-		return pool.lock();
+	OXT_FORCE_INLINE
+	Pool *getPool() const {
+		return pool;
 	}
 
 	bool isAlive() const {
@@ -492,7 +512,8 @@ public:
 	 * One of the post lock actions can potentially perform a long-running
 	 * operation, so running them in a thread is advised.
 	 */
-	void destroy(bool allowReinitialization, vector<Callback> &postLockActions,
+	void destroy(bool allowReinitialization,
+		boost::container::vector<Callback> &postLockActions,
 		const ShutdownCallback &callback)
 	{
 		verifyInvariants();
@@ -575,7 +596,7 @@ public:
 	}
 
 	SessionPtr get(const Options &newOptions, const GetCallback &callback,
-		vector<Callback> &postLockActions)
+		boost::container::vector<Callback> &postLockActions)
 	{
 		switch (state) {
 		case INITIALIZING:
@@ -622,11 +643,15 @@ public:
 	}
 
 	unsigned int capacityUsed() const {
-		vector<GroupPtr>::const_iterator it, end = groups.end();
 		unsigned int result = 0;
 
-		for (it = groups.begin(); it != end; it++) {
-			result += (*it)->capacityUsed();
+		if (groups.size() == 1) {
+			result += defaultGroup->capacityUsed();
+		} else {
+			GroupList::const_iterator it, end = groups.end();
+			for (it = groups.begin(); it != end; it++) {
+				result += (*it)->capacityUsed();
+			}
 		}
 		if (state == INITIALIZING || state == RESTARTING) {
 			result++;
@@ -635,13 +660,17 @@ public:
 	}
 
 	unsigned int getProcessCount() const {
-		unsigned int result = 0;
-		vector<GroupPtr>::const_iterator g_it, g_end = groups.end();
-		for (g_it = groups.begin(); g_it != g_end; g_it++) {
-			const GroupPtr &group = *g_it;
-			result += group->getProcessCount();
+		if (groups.size() == 1) {
+			return defaultGroup->getProcessCount();
+		} else {
+			unsigned int result = 0;
+			GroupList::const_iterator g_it, g_end = groups.end();
+			for (g_it = groups.begin(); g_it != g_end; g_it++) {
+				const GroupPtr &group = *g_it;
+				result += group->getProcessCount();
+			}
+			return result;
 		}
-		return result;
 	}
 
 	bool needsRestart() const {