passenger 4.0.30 → 4.0.31

data/ext/common/Account.h

@@ -28,9 +28,9 @@
 #include <string>
 #include <vector>
 #include <boost/shared_ptr.hpp>
-#include "StaticString.h"
-#include "Exceptions.h"
-#include "Utils/StrIntUtils.h"
+#include <StaticString.h>
+#include <Exceptions.h>
+#include <Utils/StrIntUtils.h>
 
 namespace Passenger {
 
@@ -66,8 +66,9 @@ public:
 		CLEAR                     = 1 << 0,
 		DETACH                    = 1 << 1,
 		SET_PARAMETERS            = 1 << 2,
-		INSPECT_BASIC_INFO        = 1 << 3,
-		INSPECT_SENSITIVE_INFO    = 1 << 4,
+		RESTART                   = 1 << 3,
+		INSPECT_BASIC_INFO        = 1 << 4,
+		INSPECT_SENSITIVE_INFO    = 1 << 5,
 		
 		// HelperAgent admin rights.
 		INSPECT_REQUESTS          = 1 << 8,

data/ext/common/AgentsStarter.h

@@ -446,7 +446,7 @@ public:
 			UPDATE_TRACE_POINT();
 			FileDescriptor feedbackFd = fds[0];
 			vector<string> args;
-			bool result;
+			bool result = false;
 			
 			ScopeGuard guard(boost::bind(&AgentsStarter::killProcessGroupAndWait, &pid, 0));
 			fds[1].close();

data/ext/common/ApplicationPool2/Common.h

@@ -49,6 +49,63 @@ class Group;
 class Process;
 class Session;
 
+/**
+ * The result of a Group::spawn() call.
+ */
+enum SpawnResult {
+	// The spawn request has been honored. One or more processes are now being spawned.
+	SR_OK,
+
+	// A previous spawn request is still in progress, so this spawn request has been
+	// ignored. Having said that, the desired result (increasing the number of processes
+	// by one, within imposed constraints) will still be achieved.
+	SR_IN_PROGRESS,
+
+	// A non-rolling restart is currently in progress, so the spawn request cannot
+	// be honored.
+	SR_ERR_RESTARTING,
+
+	// Unable to spawn a new process: the upper bound of the group process limits have
+	// already been reached.
+	// The group limit is checked before checking whether the pool is at full capacity,
+	// so if you get this result then it is possible that the pool is also at full
+	// capacity at the same time.
+	SR_ERR_GROUP_UPPER_LIMITS_REACHED,
+
+	// Unable to spawn a new process: the pool is at full capacity. Pool capacity is
+	// checked after checking the group upper bound limits, so if you get this result
+	// then it is guaranteed that the group upper bound limits have not been reached.
+	SR_ERR_POOL_AT_FULL_CAPACITY
+};
+
+/**
+ * The result of a Group::attach() call.
+ */
+enum AttachResult {
+	// Attaching succeeded.
+	AR_OK,
+
+	// Attaching failed: the upper bound of the group process limits have
+	// already been reached.
+	// The group limit is checked before checking whether the pool is at full capacity,
+	// so if you get this result then it is possible that the pool is also at full
+	// capacity at the same time.
+	AR_GROUP_UPPER_LIMITS_REACHED,
+
+	// Attaching failed: the pool is at full capacity. Pool capacity is
+	// checked after checking the group upper bound limits, so if you get this result
+	// then it is guaranteed that the group upper bound limits have not been reached.
+	AR_POOL_AT_FULL_CAPACITY,
+
+	// Attaching failed: another group is waiting for capacity, while this group is
+	// not waiting for capacity. You should throw away the current process and let the
+	// other group spawn, e.g. by calling `pool->possiblySpawnMoreProcessesForExistingGroups()`.
+	// This is checked after checking for the group upper bound limits and the pool
+	// capacity, so if you get this result then there is guaranteed to be capacity
+	// in the current group and in the pool.
+	AR_ANOTHER_GROUP_IS_WAITING_FOR_CAPACITY
+};
+
 /**
  * The result of a Pool::disableProcess/Group::disable() call. Some values are only
  * returned by the functions, some values are only passed to the Group::disable()
@@ -79,6 +136,21 @@ enum DisableResult {
 	DR_DEFERRED
 };
 
+/**
+ * Determines the behavior of Pool::restartGroupsByName() and Group::restart().
+ * Specifically, determines whether to perform a rolling restart or not.
+ */
+enum RestartMethod {
+	// Whether a rolling restart is performed, is determined by whether rolling restart
+	// was enabled in the web server configuration (i.e. whether group->options.rollingRestart
+	// is already true).
+	RM_DEFAULT,
+	// Perform a blocking restart. group->options.rollingRestart will not be changed.
+	RM_BLOCKING,
+	// Perform a rolling restart. group->options.rollingRestart will not be changed.
+	RM_ROLLING
+};
+
 typedef boost::shared_ptr<Pool> PoolPtr;
 typedef boost::shared_ptr<SuperGroup> SuperGroupPtr;
 typedef boost::shared_ptr<Group> GroupPtr;

data/ext/common/ApplicationPool2/Group.h

@@ -93,9 +93,38 @@ private:
 	};
 	
 	/**
-	 * Protects `m_shuttingDown`.
+	 * Protects `lifeStatus`.
 	 */
 	mutable boost::mutex lifetimeSyncher;
+	/**
+	 * A Group object progresses through a life.
+	 *
+	 * Do not access directly, always use `isAlive()`/`getLifeStatus()` or
+	 * through `lifetimeSyncher`.
+	 * 
+	 * Invariant:
+	 *    if lifeStatus != ALIVE:
+	 *       enabledCount == 0
+	 *       disablingCount == 0
+	 *       disabledCount == 0
+	 */
+	enum LifeStatus {
+		/** Up and operational. */
+		ALIVE,
+		/** Being shut down. The containing SuperGroup has issued the shutdown()
+		 * command, and this Group is now waiting for all detached processes to
+		 * exit. You cannot call `get()`, `restart()` and other mutating methods
+		 * anymore, and all threads created by this Group will exit as soon
+		 * as possible.
+		 */
+		SHUTTING_DOWN,
+		/**
+		 * Shut down complete. Object no longer usable. No Processes are referenced
+		 * from this Group anymore.
+		 */
+		SHUT_DOWN
+	} lifeStatus;
+
 	/**
 	 * A back reference to the containing SuperGroup. Should never
 	 * be NULL because a SuperGroup should outlive all its containing
@@ -114,7 +143,19 @@ private:
 	 */
 	unsigned int restartsInitiated;
 	/**
-	 * Whether process(es) are being spawned right now.
+	 * The number of processes that are being spawned right now.
+	 *
+	 * Invariant:
+	 *     if processesBeingSpawned > 0: m_spawning
+	 */
+	short processesBeingSpawned;
+	/**
+	 * Whether the spawner thread is currently working. Note that even
+	 * if it's working, it doesn't necessarily mean that processes are
+	 * being spawned (i.e. that processesBeingSpawned > 0). After the
+	 * thread is done spawning a process, it will attempt to attach
+	 * the newly-spawned process to the group. During that time it's not
+	 * technically spawning anything.
 	 */
 	bool m_spawning;
 	/** Whether a non-rolling restart is in progress (i.e. whether spawnThreadRealMain()
@@ -125,35 +166,9 @@ private:
 	 * When rolling restarting is in progress, this flag is false.
 	 *
 	 * Invariant:
-	 *    if m_restarting: !m_spawning
+	 *    if m_restarting: processesBeingSpawned == 0
 	 */
 	bool m_restarting;
-	/**
-	 * Do not access directly, always use `isAlive()`/`getLifeStatus()` or
-	 * through `lifetimeSyncher`.
-	 * 
-	 * Invariant:
-	 *    if lifeStatus != ALIVE:
-	 *       enabledCount == 0
-	 *       disablingCount == 0
-	 *       disabledCount == 0
-	 */
-	enum LifeStatus {
-		/** Up and operational. */
-		ALIVE,
-		/** Being shut down. The containing SuperGroup has issued the shutdown()
-		 * command, and this Group is now waiting for all detached processes to
-		 * exit. You cannot call `get()`, `restart()` and other mutating methods
-		 * anymore, and all threads created by this Group will exit as soon
-		 * as possible.
-		 */
-		SHUTTING_DOWN,
-		/**
-		 * Shut down. Object no longer usable. No Processes are referenced from
-		 * this Group anymore.
-		 */
-		SHUT_DOWN
-	} lifeStatus;
 
 	/** Contains the spawn loop thread and the restarter thread. */
 	dynamic_thread_group interruptableThreads;
@@ -197,13 +212,16 @@ private:
 		unsigned int restartsInitiated);
 	void spawnThreadRealMain(const SpawnerPtr &spawner, const Options &options,
 		unsigned int restartsInitiated);
-	void finalizeRestart(GroupPtr self, Options options, SpawnerFactoryPtr spawnerFactory,
-		unsigned int restartsInitiated, vector<Callback> postLockActions);
+	void finalizeRestart(GroupPtr self, Options options, RestartMethod method,
+		SpawnerFactoryPtr spawnerFactory, unsigned int restartsInitiated,
+		vector<Callback> postLockActions);
 	void startCheckingDetachedProcesses(bool immediately);
 	void detachedProcessesCheckerMain(GroupPtr self);
 	void wakeUpGarbageCollector();
 	bool poolAtFullCapacity() const;
 	bool anotherGroupIsWaitingForCapacity() const;
+	boost::shared_ptr<Group> findOtherGroupWaitingForCapacity() const;
+	ProcessPtr poolForceFreeCapacity(const Group *exclude, vector<Callback> &postLockActions);
 	bool testOverflowRequestQueue() const;
 	const ResourceLocator &getResourceLocator() const;
 	void runAttachHooks(const ProcessPtr process) const;
@@ -217,21 +235,22 @@ private:
 		assert(disablingCount >= 0);
 		assert(disabledCount >= 0);
 		assert(enabledProcesses.empty() == (pqueue.top() == NULL));
-		assert(!( enabledCount == 0 && disablingCount > 0 ) || spawning());
-		assert(!( !spawning() ) || ( enabledCount > 0 || disablingCount == 0 ));
+		assert(!( enabledCount == 0 && disablingCount > 0 ) || ( processesBeingSpawned > 0) );
+		assert(!( !m_spawning ) || ( enabledCount > 0 || disablingCount == 0 ));
 
 		assert((lifeStatus == ALIVE) == (spawner != NULL));
 
 		// Verify getWaitlist invariants.
 		assert(!( !getWaitlist.empty() ) || ( enabledProcesses.empty() || verifyNoRequestsOnGetWaitlistAreRoutable() ));
-		assert(!( enabledProcesses.empty() && !spawning() && !restarting() && !poolAtFullCapacity() ) || ( getWaitlist.empty() ));
-		assert(!( !getWaitlist.empty() ) || ( !enabledProcesses.empty() || spawning() || restarting() || poolAtFullCapacity() ));
+		assert(!( enabledProcesses.empty() && !m_spawning && !restarting() && !poolAtFullCapacity() ) || ( getWaitlist.empty() ));
+		assert(!( !getWaitlist.empty() ) || ( !enabledProcesses.empty() || m_spawning || restarting() || poolAtFullCapacity() ));
 		
 		// Verify disableWaitlist invariants.
 		assert((int) disableWaitlist.size() >= disablingCount);
 
-		// Verify m_spawning and m_restarting.
-		assert(!( m_restarting ) || !m_spawning);
+		// Verify processesBeingSpawned, m_spawning and m_restarting.
+		assert(!( processesBeingSpawned > 0 ) || ( m_spawning ));
+		assert(!( m_restarting ) || ( processesBeingSpawned == 0 ));
 
 		// Verify lifeStatus.
 		LifeStatus lifeStatus = getLifeStatus();
@@ -345,7 +364,7 @@ private:
 	}
 
 	/* Determines which process to route a get() action to. The returned process
-	 * is guaranteed to be `canBeRoutedTo()`, i.e. not at full utilization.
+	 * is guaranteed to be `canBeRoutedTo()`, i.e. not totally busy.
 	 *
 	 * A request is routed to an enabled processes, or if there are none,
 	 * from a disabling process. The rationale is as follows:
@@ -376,7 +395,7 @@ private:
 				}
 			}
 		} else {
-			Process *process = findProcessWithLowestUtilization(disablingProcesses);
+			Process *process = findProcessWithLowestBusyness(disablingProcesses);
 			if (process->canBeRoutedTo()) {
 				return RouteResult(process);
 			} else {
@@ -395,7 +414,7 @@ private:
 			} else {
 				pqueue.erase(process->pqHandle);
 			}
-			process->pqHandle = pqueue.push(process, process->utilization());
+			process->pqHandle = pqueue.push(process, process->busyness());
 		}
 		return session;
 	}
@@ -425,12 +444,12 @@ private:
 		return NULL;
 	}
 
-	Process *findProcessWithLowestUtilization(const ProcessList &processes) const {
+	Process *findProcessWithLowestBusyness(const ProcessList &processes) const {
 		Process *result = NULL;
 		ProcessList::const_iterator it, end = processes.end();
 		for (it = processes.begin(); it != end; it++) {
 			Process *process = it->get();
-			if (result == NULL || process->utilization() < result->utilization()) {
+			if (result == NULL || process->busyness() < result->busyness()) {
 				result = process;
 			}
 		}
@@ -478,7 +497,7 @@ private:
 		process->it = destination.last_iterator();
 		if (&destination == &enabledProcesses) {
 			process->enabled = Process::ENABLED;
-			process->pqHandle = pqueue.push(process.get(), process->utilization());
+			process->pqHandle = pqueue.push(process.get(), process->busyness());
 			enabledCount++;
 		} else if (&destination == &disablingProcesses) {
 			process->enabled = Process::DISABLING;
@@ -664,7 +683,7 @@ public:
 	 * their numbers.
 	 * These lists do not intersect. A process is in exactly 1 list.
 	 *
-	 * 'pqueue' orders all enabled processes according to utilization() values,
+	 * 'pqueue' orders all enabled processes according to busyness() values,
 	 * from small to large.
 	 *
 	 * Invariants:
@@ -678,14 +697,14 @@ public:
 	 *    enabledProcesses.empty() == (pqueue.top() == NULL)
 	 *
 	 *    if (enabledCount == 0):
-	 *       spawning() || restarting() || poolAtFullCapacity()
+	 *       processesBeingSpawned > 0 || restarting() || poolAtFullCapacity()
 	 *    if (enabledCount == 0) and (disablingCount > 0):
-	 *       spawning()
-	 *    if !spawning():
-	 *       (enabledCount > 0) or (disablingCount == 0)
+	 *       processesBeingSpawned > 0
+	 *    if !m_spawning:
+	 *       (enabledCount > 0) || (disablingCount == 0)
 	 *
-	 *    if pqueue.top().atFullUtilization():
-	 *       All enabled processes are at full utilization.
+	 *    if pqueue.top().isTotallyBusy():
+	 *       All enabled processes are totally busy.
 	 *
 	 *    for all process in enabledProcesses:
 	 *       process.enabled == Process::ENABLED
@@ -741,7 +760,7 @@ public:
 	 * The only reason why there are no enabled processes, while at the same time we're
 	 * not spawning or waiting for pool capacity, is because there is nothing to do.
 	 * 
-	 *    if enabledProcesses.empty() && !spawning() && !restarting() && !poolAtFullCapacity():
+	 *    if enabledProcesses.empty() && !m_spawning && !restarting() && !poolAtFullCapacity():
 	 *       getWaitlist is empty
 	 * 
 	 * Equivalently:
@@ -750,7 +769,7 @@ public:
 	 * unable to do that because of resource limits.
 	 * 
 	 *    if getWaitlist is non-empty:
-	 *       !enabledProcesses.empty() || spawning() || restarting() || poolAtFullCapacity()
+	 *       !enabledProcesses.empty() || m_spawning || restarting() || poolAtFullCapacity()
 	 */
 	deque<GetWaiter> getWaitlist;
 	/**
@@ -768,7 +787,12 @@ public:
 	 *    (lifeStatus == ALIVE) == (spawner != NULL)
 	 */
 	SpawnerPtr spawner;
-	
+
+
+	/********************************************
+	 * Constructors and destructors
+	 ********************************************/
+
 	Group(const SuperGroupPtr &superGroup, const Options &options, const ComponentInfo &info);
 	~Group();
 
@@ -799,7 +823,52 @@ public:
 		}
 	}
 
-	SessionPtr get(const Options &newOptions, const GetCallback &callback) {
+
+	/********************************************
+	 * Life time and back-reference methods
+	 ********************************************/
+
+	/**
+	 * Thread-safe.
+	 * @pre getLifeState() != SHUT_DOWN
+	 * @post result != NULL
+	 */
+	SuperGroupPtr getSuperGroup() const {
+		return superGroup.lock();
+	}
+	
+	void setSuperGroup(const SuperGroupPtr &superGroup) {
+		assert(this->superGroup.lock() == NULL);
+		this->superGroup = superGroup;
+	}
+	
+	/**
+	 * Thread-safe.
+	 * @pre getLifeState() != SHUT_DOWN
+	 * @post result != NULL
+	 */
+	PoolPtr getPool() const;
+	
+	// Thread-safe.
+	bool isAlive() const {
+		boost::lock_guard<boost::mutex> lock(lifetimeSyncher);
+		return lifeStatus == ALIVE;
+	}
+
+	// Thread-safe.
+	LifeStatus getLifeStatus() const {
+		boost::lock_guard<boost::mutex> lock(lifetimeSyncher);
+		return lifeStatus;
+	}
+
+
+	/********************************************
+	 * Core methods
+	 ********************************************/
+
+	SessionPtr get(const Options &newOptions, const GetCallback &callback,
+		vector<Callback> &postLockActions)
+	{
 		assert(isAlive());
 
 		if (OXT_LIKELY(!restarting())) {
@@ -809,7 +878,22 @@ public:
 				mergeOptions(newOptions);
 			}
 			if (OXT_UNLIKELY(!newOptions.noop && shouldSpawnForGetAction())) {
-				spawn();
+				// If we're trying to spawn the first process for this group, and
+				// spawning failed because the pool is at full capacity, then we
+				// try to kill some random idle process in the pool and try again.
+				if (spawn() == SR_ERR_POOL_AT_FULL_CAPACITY && enabledCount == 0) {
+					P_INFO("Unable to spawn the the sole process for group " << name <<
+						" because the max pool size has been reached. Trying " <<
+						"to shutdown another idle process to free capacity...");
+					if (poolForceFreeCapacity(this, postLockActions) != NULL) {
+						SpawnResult result = spawn();
+						assert(result == SR_OK);
+						(void) result;
+					} else {
+						P_INFO("There are no processes right now that are eligible "
+							"for shutdown. Will try again later.");
+					}
+				}
 			}
 		}
 		
@@ -831,19 +915,19 @@ public:
 			 * then we generally want to use them, except:
 			 * - When non-rolling restarting because those disabling processes
 			 *   are from the old version.
-			 * - When all disabling processes are at full utilization.
+			 * - When all disabling processes are totally busy.
 			 *
 			 * Whenever a disabling process cannot be used, call the callback
 			 * after a process has been spawned or has failed to spawn, or
 			 * when a disabling process becomes available.
 			 */
-			assert(spawning() || restarting() || poolAtFullCapacity());
+			assert(m_spawning || restarting() || poolAtFullCapacity());
 
 			if (disablingCount > 0 && !restarting()) {
-				Process *process = findProcessWithLowestUtilization(
+				Process *process = findProcessWithLowestBusyness(
 					disablingProcesses);
 				assert(process != NULL);
-				if (!process->atFullUtilization()) {
+				if (!process->isTotallyBusy()) {
 					return newSession(process);
 				}
 			}
@@ -855,7 +939,7 @@ public:
 		} else {
 			RouteResult result = route(newOptions);
 			if (result.process == NULL) {
-				/* Looks like all processes are at full utilization.
+				/* Looks like all processes are totally busy.
 				 * Wait until a new one has been spawned or until
 				 * resources have become free.
 				 */
@@ -869,53 +953,33 @@ public:
 			}
 		}
 	}
-	
-	/**
-	 * Thread-safe.
-	 * @pre getLifeState() != SHUT_DOWN
-	 * @post result != NULL
-	 */
-	SuperGroupPtr getSuperGroup() const {
-		return superGroup.lock();
-	}
-	
-	void setSuperGroup(const SuperGroupPtr &superGroup) {
-		assert(this->superGroup.lock() == NULL);
-		this->superGroup = superGroup;
-	}
-	
-	/**
-	 * Thread-safe.
-	 * @pre getLifeState() != SHUT_DOWN
-	 * @post result != NULL
-	 */
-	PoolPtr getPool() const;
-	
-	// Thread-safe.
-	bool isAlive() const {
-		boost::lock_guard<boost::mutex> lock(lifetimeSyncher);
-		return lifeStatus == ALIVE;
-	}
 
-	// Thread-safe.
-	LifeStatus getLifeStatus() const {
-		boost::lock_guard<boost::mutex> lock(lifetimeSyncher);
-		return lifeStatus;
-	}
-	
+
+	/********************************************
+	 * State mutation methods
+	 ********************************************/
+
 	// Thread-safe, but only call outside the pool lock!
 	void requestOOBW(const ProcessPtr &process);
-	
+
 	/**
 	 * Attaches the given process to this Group and mark it as enabled. This
-	 * function doesn't touch getWaitlist so be sure to fix its invariants
-	 * afterwards if necessary.
+	 * function doesn't touch `getWaitlist` so be sure to fix its invariants
+	 * afterwards if necessary, e.g. by calling `assignSessionsToGetWaiters()`.
 	 */
-	void attach(const ProcessPtr &process, vector<Callback> &postLockActions) {
+	AttachResult attach(const ProcessPtr &process, vector<Callback> &postLockActions) {
 		assert(process->getGroup() == NULL || process->getGroup().get() == this);
 		assert(process->isAlive());
 		assert(isAlive());
 
+		if (processUpperLimitsReached()) {
+			return AR_GROUP_UPPER_LIMITS_REACHED;
+		} else if (poolAtFullCapacity()) {
+			return AR_POOL_AT_FULL_CAPACITY;
+		} else if (!isWaitingForCapacity() && anotherGroupIsWaitingForCapacity()) {
+			return AR_ANOTHER_GROUP_IS_WAITING_FOR_CAPACITY;
+		}
+
 		process->setGroup(shared_from_this());
 		process->stickySessionId = generateStickySessionId();
 		P_DEBUG("Attaching process " << process->inspect());
@@ -953,6 +1017,8 @@ public:
 		wakeUpGarbageCollector();
 
 		postLockActions.push_back(boost::bind(&Group::runAttachHooks, this, process));
+
+		return AR_OK;
 	}
 
 	/**
@@ -1096,24 +1162,104 @@ public:
 		}
 	}
 
+	/**
+	 * Attempts to increase the number of processes by one, while respecting the
+	 * resource limits. That is, this method will ensure that there are at least
+	 * `minProcesses` processes, but no more than `maxProcesses` processes, and no
+	 * more than `pool->max` processes in the entire pool.
+	 */
+	SpawnResult spawn() {
+		assert(isAlive());
+		if (m_spawning) {
+			return SR_IN_PROGRESS;
+		} else if (restarting()) {
+			return SR_ERR_RESTARTING;
+		} else if (processUpperLimitsReached()) {
+			return SR_ERR_GROUP_UPPER_LIMITS_REACHED;
+		} else if (poolAtFullCapacity()) {
+			return SR_ERR_POOL_AT_FULL_CAPACITY;
+		} else {
+			P_DEBUG("Requested spawning of new process for group " << name);
+			interruptableThreads.create_thread(
+				boost::bind(&Group::spawnThreadMain,
+					this, shared_from_this(), spawner,
+					options.copyAndPersist().clearPerRequestFields(),
+					restartsInitiated),
+				"Group process spawner: " + name,
+				POOL_HELPER_THREAD_STACK_SIZE);
+			m_spawning = true;
+			processesBeingSpawned++;
+			return SR_OK;
+		}
+	}
+
 	void cleanupSpawner(vector<Callback> &postLockActions) {
 		assert(isAlive());
 		postLockActions.push_back(boost::bind(doCleanupSpawner, spawner));
 	}
 
-	unsigned int utilization() const {
-		int result = enabledCount;
-		if (spawning()) {
-			result++;
-		}
-		return result;
+	void restart(const Options &options, RestartMethod method = RM_DEFAULT);
+
+
+	/********************************************
+	 * Queries
+	 ********************************************/
+
+	unsigned int getProcessCount() const {
+		return enabledCount + disablingCount + disabledCount;
 	}
-	
+
+	/**
+	 * Returns the number of processes in this group that should be part of the
+	 * ApplicationPool process limits calculations.
+	 */
+	unsigned int capacityUsed() const {
+		return enabledCount + disablingCount + disabledCount + processesBeingSpawned;
+	}
+
+	/**
+	 * Returns whether the lower bound of the group-specific process limits
+	 * have been satisfied. Note that even if the result is false, the pool limits
+	 * may not allow spawning, so you should check `pool->atFullCapacity()` too.
+	 */
+	bool processLowerLimitsSatisfied() const {
+		return capacityUsed() >= options.minProcesses;
+	}
+
+	/**
+	 * Returns whether the upper bound of the group-specific process limits have
+	 * been reached, or surpassed. Does not check whether pool limits have been
+	 * reached. Use `pool->atFullCapacity()` to check for that.
+	 */
+	bool processUpperLimitsReached() const {
+		return options.maxProcesses != 0 && capacityUsed() >= options.maxProcesses;
+	}
+
+	/**
+	 * Returns whether all enabled processes are totally busy. If so, another
+	 * process should be spawned, if allowed by the process limits.
+	 * Returns false if there are no enabled processes.
+	 */
+	bool allEnabledProcessesAreTotallyBusy() const {
+		return enabledCount > 0 && pqueue.top()->isTotallyBusy();
+	}
+
+	/**
+	 * Checks whether this group is waiting for capacity on the pool to
+	 * become available before it can continue processing requests.
+	 */
+	bool isWaitingForCapacity() const {
+		return enabledProcesses.empty()
+			&& processesBeingSpawned == 0
+			&& !m_restarting
+			&& !getWaitlist.empty();
+	}
+
 	bool garbageCollectable(unsigned long long now = 0) const {
 		/* if (now == 0) {
 			now = SystemTime::getUsec();
 		}
-		return utilization() == 0
+		return busyness() == 0
 			&& getWaitlist.empty()
 			&& disabledProcesses.empty()
 			&& options.getMaxPreloaderIdleTime() != 0
@@ -1128,26 +1274,15 @@ public:
 	 * specific case that another get action is to be performed.
 	 */
 	bool shouldSpawnForGetAction() const;
-	/** Whether a new process is allowed to be spawned for this group. */
-	bool allowSpawn() const;
-	
-	/** Start spawning a new process in the background, in case this
-	 * isn't already happening and the group isn't being restarted.
-	 * Will ensure that at least options.minProcesses processes are spawned.
+
+	/**
+	 * Whether a new process is allowed to be spawned for this group,
+	 * i.e. whether the upper processes limits have not been reached.
 	 */
-	void spawn() {
-		assert(isAlive());
-		if (!spawning() && !restarting()) {
-			P_DEBUG("Requested spawning of new process for group " << name);
-			interruptableThreads.create_thread(
-				boost::bind(&Group::spawnThreadMain,
-					this, shared_from_this(), spawner,
-					options.copyAndPersist().clearPerRequestFields(),
-					restartsInitiated),
-				"Group process spawner: " + name,
-				POOL_HELPER_THREAD_STACK_SIZE);
-			m_spawning = true;
-		}
+	bool allowSpawn() const {
+		return isAlive()
+			&& !processUpperLimitsReached()
+			&& !poolAtFullCapacity();
 	}
 	
 	bool needsRestart(const Options &options) {
@@ -1159,9 +1294,7 @@ public:
 			       fileChangeChecker.changed(restartFile, options.statThrottleRate);
 		}
 	}
-	
-	void restart(const Options &options);
-	
+
 	bool spawning() const {
 		return m_spawning;
 	}
@@ -1170,25 +1303,6 @@ public:
 		return m_restarting;
 	}
 
-	/**
-	 * Returns the number of processes in this group that should be part for the
-	 * MaxPoolSize constraint calculation.
-	 */
-	unsigned int getProcessCount() const {
-		return enabledCount + disablingCount + disabledCount;
-	}
-
-	/**
-	 * Checks whether this group is waiting for capacity on the pool to
-	 * become available before it can continue processing requests.
-	 */
-	bool isWaitingForCapacity() const {
-		return enabledProcesses.empty()
-			&& !m_spawning
-			&& !m_restarting
-			&& !getWaitlist.empty();
-	}
-
 	template<typename Stream>
 	void inspectXml(Stream &stream, bool includeSecrets = true) const {
 		ProcessList::const_iterator it;
@@ -1201,10 +1315,11 @@ public:
 		stream << "<enabled_process_count>" << enabledCount << "</enabled_process_count>";
 		stream << "<disabling_process_count>" << disablingCount << "</disabling_process_count>";
 		stream << "<disabled_process_count>" << disabledCount << "</disabled_process_count>";
-		stream << "<utilization>" << utilization() << "</utilization>";
+		stream << "<capacity_used>" << capacityUsed() << "</capacity_used>";
 		stream << "<get_wait_list_size>" << getWaitlist.size() << "</get_wait_list_size>";
 		stream << "<disable_wait_list_size>" << disableWaitlist.size() << "</disable_wait_list_size>";
-		if (spawning()) {
+		stream << "<processes_being_spawned>" << processesBeingSpawned << "</processes_being_spawned>";
+		if (m_spawning) {
 			stream << "<spawning/>";
 		}
 		if (restarting()) {