passenger 4.0.14 → 4.0.16

data/ext/common/ApplicationPool2/AppTypes.cpp

@@ -32,6 +32,8 @@ 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_NODE, "node", "passenger_node.js", "Passenger NodeApp" },
+	{ PAT_METEOR, "meteor", ".meteor", "Passenger MeteorApp" },
 	{ PAT_NONE, NULL, NULL, NULL }
 };
 

data/ext/common/ApplicationPool2/AppTypes.h

@@ -42,6 +42,8 @@ typedef enum {
 	PAT_RACK,
 	PAT_WSGI,
 	PAT_CLASSIC_RAILS,
+	PAT_NODE,
+	PAT_METEOR,
 	PAT_NONE
 } PassengerAppType;
 

data/ext/common/ApplicationPool2/Common.h

@@ -70,7 +70,7 @@ enum DisableResult {
 	DR_NOOP,
 	
 	// The disabling of the process failed: an error occurred.
-	// Only passed to the callback.
+	// Returned by functions and passed to the callback.
 	DR_ERROR,
 
 	// Indicates that the process cannot be disabled immediately

data/ext/common/ApplicationPool2/Group.h

@@ -170,9 +170,17 @@ private:
 	static string generateSecret(const SuperGroupPtr &superGroup);
 	void onSessionInitiateFailure(const ProcessPtr &process, Session *session);
 	void onSessionClose(const ProcessPtr &process, Session *session);
-	void lockAndAsyncOOBWRequestIfNeeded(const ProcessPtr &process, DisableResult result, GroupPtr self);
-	void asyncOOBWRequestIfNeeded(const ProcessPtr &process);
+
+	/** Returns whether it is allowed to perform a new OOBW in this group. */
+	bool oobwAllowed() const;
+	/** Returns whether a new OOBW should be initiated for this process. */
+	bool shouldInitiateOobw(const ProcessPtr &process) const;
+	void maybeInitiateOobw(const ProcessPtr &process);
+	void lockAndMaybeInitiateOobw(const ProcessPtr &process, DisableResult result, GroupPtr self);
+	void initiateOobw(const ProcessPtr &process);
 	void spawnThreadOOBWRequest(GroupPtr self, ProcessPtr process);
+	void initiateNextOobwRequest();
+
 	void spawnThreadMain(GroupPtr self, SpawnerPtr spawner, Options options,
 		unsigned int restartsInitiated);
 	void spawnThreadRealMain(const SpawnerPtr &spawner, const Options &options,
@@ -184,6 +192,7 @@ private:
 	void wakeUpGarbageCollector();
 	bool poolAtFullCapacity() const;
 	bool anotherGroupIsWaitingForCapacity() const;
+	bool testOverflowRequestQueue() const;
 	const ResourceLocator &getResourceLocator() const;
 
 	void verifyInvariants() const {
@@ -233,6 +242,8 @@ private:
 			assert(process->enabled == Process::ENABLED);
 			assert(process->pqHandle != NULL);
 			assert(process->isAlive());
+			assert(process->oobwStatus == Process::OOBW_NOT_ACTIVE
+				|| process->oobwStatus == Process::OOBW_REQUESTED);
 		}
 
 		end = disablingProcesses.end();
@@ -241,6 +252,8 @@ private:
 			assert(process->enabled == Process::DISABLING);
 			assert(process->pqHandle == NULL);
 			assert(process->isAlive());
+			assert(process->oobwStatus == Process::OOBW_NOT_ACTIVE
+				|| process->oobwStatus == Process::OOBW_IN_PROGRESS);
 		}
 
 		end = disabledProcesses.end();
@@ -249,6 +262,8 @@ private:
 			assert(process->enabled == Process::DISABLED);
 			assert(process->pqHandle == NULL);
 			assert(process->isAlive());
+			assert(process->oobwStatus == Process::OOBW_NOT_ACTIVE
+				|| process->oobwStatus == Process::OOBW_IN_PROGRESS);
 		}
 
 		foreach (const ProcessPtr &process, detachedProcesses) {
@@ -305,6 +320,20 @@ private:
 		return session;
 	}
 
+	bool pushGetWaiter(const Options &newOptions, const GetCallback &callback) {
+		if (OXT_LIKELY(!testOverflowRequestQueue()
+			&& (newOptions.maxRequestQueueSize == 0
+			    || getWaitlist.size() < newOptions.maxRequestQueueSize)))
+		{
+			getWaitlist.push(GetWaiter(newOptions.copyAndPersist().clearLogger(), callback));
+			return true;
+		} else {
+			P_WARN("Request queue is full. Returning an error");
+			callback(SessionPtr(), make_shared<RequestQueueFullException>());
+			return false;
+		}
+	}
+
 	Process *findProcessWithLowestUtilization(const ProcessList &processes) const {
 		Process *result = NULL;
 		ProcessList::const_iterator it, end = processes.end();
@@ -577,14 +606,17 @@ public:
 	 *       process.enabled == Process::ENABLED
 	 *       process.pqHandle != NULL
 	 *       process.isAlive()
+	 *       process.oobwStatus == Process::OOBW_NOT_ACTIVE || process.oobwStatus == Process::OOBW_REQUESTED
 	 *    for all processes in disablingProcesses:
 	 *       process.enabled == Process::DISABLING
 	 *       process.pqHandle == NULL
 	 *       process.isAlive()
+	 *       process.oobwStatus == Process::OOBW_NOT_ACTIVE || process.oobwStatus == Process::OOBW_IN_PROGRESS
 	 *    for all process in disabledProcesses:
 	 *       process.enabled == Process::DISABLED
 	 *       process.pqHandle == NULL
 	 *       process.isAlive()
+	 *       process.oobwStatus == Process::OOBW_NOT_ACTIVE || process.oobwStatus == Process::OOBW_IN_PROGRESS
 	 */
 	int enabledCount;
 	int disablingCount;
@@ -723,8 +755,9 @@ public:
 				}
 			}
 
-			getWaitlist.push(GetWaiter(newOptions.copyAndPersist().clearLogger(), callback));
-			P_DEBUG("No session checked out yet: group is spawning or restarting");
+			if (pushGetWaiter(newOptions, callback)) {
+				P_DEBUG("No session checked out yet: group is spawning or restarting");
+			}
 			return SessionPtr();
 		} else {
 			Process *process = pqueue.top();
@@ -734,8 +767,9 @@ public:
 				 * Wait until a new one has been spawned or until
 				 * resources have become free.
 				 */
-				getWaitlist.push(GetWaiter(newOptions.copyAndPersist().clearLogger(), callback));
-				P_DEBUG("No session checked out yet: all processes are at full capacity");
+				if (pushGetWaiter(newOptions, callback)) {
+					P_DEBUG("No session checked out yet: all processes are at full capacity");
+				}
 				return SessionPtr();
 			} else {
 				P_DEBUG("Session checked out from process " << process->inspect());
@@ -924,7 +958,12 @@ public:
 			P_DEBUG("Disabling ENABLED process " << process->inspect() <<
 				"; enabledCount=" << enabledCount << ", process.sessions=" << process->sessions);
 			assert(enabledCount >= 0);
-			if (enabledCount <= 1 || process->sessions > 0) {
+			if (enabledCount == 1 && !allowSpawn()) {
+				P_WARN("Cannot disable sole enabled process in group " << name <<
+					" because spawning is not allowed according to the current" <<
+					" configuration options");
+				return DR_ERROR;
+			} else if (enabledCount <= 1 || process->sessions > 0) {
 				removeProcessFromList(process, enabledProcesses);
 				addProcessToList(process, disablingProcesses);
 				disableWaitlist.push_back(DisableWaiter(process, callback));
@@ -992,6 +1031,8 @@ 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.
@@ -1032,6 +1073,14 @@ 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.

data/ext/common/ApplicationPool2/Implementation.cpp

@@ -62,8 +62,9 @@ copyException(const tracable_exception &e) {
 	
 	TRY_COPY_EXCEPTION(ConfigurationException);
 	
-	TRY_COPY_EXCEPTION(SpawnException);
+	TRY_COPY_EXCEPTION(RequestQueueFullException);
 	TRY_COPY_EXCEPTION(GetAbortedException);
+	TRY_COPY_EXCEPTION(SpawnException);
 	
 	TRY_COPY_EXCEPTION(InvalidModeStringException);
 	TRY_COPY_EXCEPTION(ArgumentException);
@@ -104,6 +105,7 @@ rethrowException(const ExceptionPtr &e) {
 	TRY_RETHROW_EXCEPTION(ConfigurationException);
 	
 	TRY_RETHROW_EXCEPTION(SpawnException);
+	TRY_RETHROW_EXCEPTION(RequestQueueFullException);
 	TRY_RETHROW_EXCEPTION(GetAbortedException);
 	
 	TRY_RETHROW_EXCEPTION(InvalidModeStringException);
@@ -452,7 +454,7 @@ Group::onSessionClose(const ProcessPtr &process, Session *session) {
 			removeProcessFromList(process, disablingProcesses);
 			addProcessToList(process, disabledProcesses);
 			removeFromDisableWaitlist(process, DR_SUCCESS, actions);
-			asyncOOBWRequestIfNeeded(process);
+			maybeInitiateOobw(process);
 		}
 		
 		pool->fullVerifyInvariants();
@@ -461,7 +463,7 @@ Group::onSessionClose(const ProcessPtr &process, Session *session) {
 
 	} else {
 		// This could change process->enabled.
-		asyncOOBWRequestIfNeeded(process);
+		maybeInitiateOobw(process);
 
 		if (!getWaitlist.empty() && process->enabled == Process::ENABLED) {
 			/* If there are clients on this group waiting for a process to
@@ -484,47 +486,111 @@ Group::requestOOBW(const ProcessPtr &process) {
 	}
 }
 
+bool
+Group::oobwAllowed() const {
+	unsigned int oobwInstances = 0;
+	foreach (const ProcessPtr &process, disablingProcesses) {
+		if (process->oobwStatus == Process::OOBW_IN_PROGRESS) {
+			oobwInstances += 1;
+		}
+	}
+	foreach (const ProcessPtr &process, disabledProcesses) {
+		if (process->oobwStatus == Process::OOBW_IN_PROGRESS) {
+			oobwInstances += 1;
+		}
+	}
+	return oobwInstances < options.maxOutOfBandWorkInstances;
+}
+
+bool
+Group::shouldInitiateOobw(const ProcessPtr &process) const {
+	return process->oobwStatus == Process::OOBW_REQUESTED
+		&& process->enabled != Process::DETACHED
+		&& process->isAlive()
+		&& oobwAllowed();
+}
+
+void
+Group::maybeInitiateOobw(const ProcessPtr &process) {
+	if (shouldInitiateOobw(process)) {
+		initiateOobw(process);
+	}
+}
+
 // The 'self' parameter is for keeping the current Group object alive
 void
-Group::lockAndAsyncOOBWRequestIfNeeded(const ProcessPtr &process, DisableResult result, GroupPtr self) {
+Group::lockAndMaybeInitiateOobw(const ProcessPtr &process, DisableResult result, GroupPtr self) {
 	TRACE_POINT();
 	
-	if (result != DR_SUCCESS && result != DR_CANCELED) {
-		return;
-	}
-	
 	// Standard resource management boilerplate stuff...
 	PoolPtr pool = getPool();
 	unique_lock<boost::mutex> lock(pool->syncher);
 	if (OXT_UNLIKELY(!process->isAlive() || !isAlive())) {
 		return;
 	}
-	
-	P_DEBUG("Process " << process->inspect() << " disabled; proceeding with OOBW");
-	asyncOOBWRequestIfNeeded(process);
+
+	assert(process->oobwStatus == Process::OOBW_IN_PROGRESS);
+
+	if (result == DR_SUCCESS) {
+		if (process->enabled == Process::DISABLED) {
+			P_DEBUG("Process " << process->inspect() << " disabled; proceeding " <<
+				"with out-of-band work");
+			process->oobwStatus = Process::OOBW_REQUESTED;
+			if (shouldInitiateOobw(process)) {
+				initiateOobw(process);
+			} else {
+				// We do not re-enable the process because it's likely that the
+				// administrator has explicitly changed the state.
+				P_DEBUG("Out-of-band work for process " << process->inspect() << " aborted "
+					"because the process no longer requests out-of-band work");
+				process->oobwStatus = Process::OOBW_NOT_ACTIVE;
+			}
+		} else {
+			// We do not re-enable the process because it's likely that the
+			// administrator has explicitly changed the state.
+			P_DEBUG("Out-of-band work for process " << process->inspect() << " aborted "
+				"because the process was reenabled after disabling");
+			process->oobwStatus = Process::OOBW_NOT_ACTIVE;
+		}
+	} else {
+		P_DEBUG("Out-of-band work for process " << process->inspect() << " aborted "
+			"because the process could not be disabled");
+		process->oobwStatus = Process::OOBW_NOT_ACTIVE;
+	}
 }
 
 void
-Group::asyncOOBWRequestIfNeeded(const ProcessPtr &process) {
-	if (process->oobwStatus != Process::OOBW_REQUESTED
-		|| process->enabled == Process::DETACHED
-		|| !process->isAlive())
+Group::initiateOobw(const ProcessPtr &process) {
+	assert(process->oobwStatus == Process::OOBW_REQUESTED);
+
+	process->oobwStatus = Process::OOBW_IN_PROGRESS;
+
+	if (process->enabled == Process::ENABLED
+	 || process->enabled == Process::DISABLING)
 	{
-		return;
-	}
-	if (process->enabled == Process::ENABLED) {
 		// We want the process to be disabled. However, disabling a process is potentially
 		// asynchronous, so we pass a callback which will re-aquire the lock and call this
 		// method again.
 		P_DEBUG("Disabling process " << process->inspect() << " in preparation for OOBW");
 		DisableResult result = disable(process,
-			boost::bind(&Group::lockAndAsyncOOBWRequestIfNeeded, this,
+			boost::bind(&Group::lockAndMaybeInitiateOobw, this,
 				_1, _2, shared_from_this()));
-		if (result == DR_DEFERRED) {
+		switch (result) {
+		case DR_SUCCESS:
+			// Continue code flow.
+			break;
+		case DR_DEFERRED:
+			// lockAndMaybeInitateOobw() will eventually be called.
+			return;
+		case DR_ERROR:
+		case DR_NOOP:
+			P_DEBUG("Out-of-band work for process " << process->inspect() << " aborted "
+				"because the process could not be disabled");
+			process->oobwStatus = Process::OOBW_NOT_ACTIVE;
 			return;
+		default:
+			P_BUG("Unexpected disable() result " << result);
 		}
-	} else if (process->enabled == Process::DISABLING) {
-		return;
 	}
 	
 	assert(process->enabled == Process::DISABLED);
@@ -533,7 +599,7 @@ Group::asyncOOBWRequestIfNeeded(const ProcessPtr &process) {
 	P_DEBUG("Initiating OOBW request for process " << process->inspect());
 	interruptableThreads.create_thread(
 		boost::bind(&Group::spawnThreadOOBWRequest, this, shared_from_this(), process),
-		"OOB request thread for process " + process->inspect(),
+		"OOBW request thread for process " + process->inspect(),
 		POOL_HELPER_THREAD_STACK_SIZE);
 }
 
@@ -577,7 +643,7 @@ Group::spawnThreadOOBWRequest(GroupPtr self, ProcessPtr process) {
 			return;
 		}
 		
-		assert(process->oobwStatus = Process::OOBW_IN_PROGRESS);
+		assert(process->oobwStatus == Process::OOBW_IN_PROGRESS);
 		assert(process->sessions == 0);
 		socket = process->sessionSockets.top();
 		assert(socket != NULL);
@@ -640,8 +706,10 @@ Group::spawnThreadOOBWRequest(GroupPtr self, ProcessPtr process) {
 			enable(process, actions);
 			assignSessionsToGetWaiters(actions);
 		}
-		
+
 		pool->fullVerifyInvariants();
+
+		initiateNextOobwRequest();
 	}
 	UPDATE_TRACE_POINT();
 	runAllActions(actions);
@@ -654,6 +722,20 @@ Group::spawnThreadOOBWRequest(GroupPtr self, ProcessPtr process) {
 	}
 }
 
+void
+Group::initiateNextOobwRequest() {
+	ProcessList::const_iterator it, end = enabledProcesses.end();
+	for (it = enabledProcesses.begin(); it != end; it++) {
+		const ProcessPtr &process = *it;
+		if (shouldInitiateOobw(process)) {
+			// We keep an extra reference to processes to prevent premature destruction.
+			ProcessPtr p = process;
+			initiateOobw(p);
+			return;
+		}
+	}
+}
+
 // The 'self' parameter is for keeping the current Group object alive while this thread is running.
 void
 Group::spawnThreadMain(GroupPtr self, SpawnerPtr spawner, Options options, unsigned int restartsInitiated) {
@@ -779,7 +861,7 @@ Group::spawnThreadRealMain(const SpawnerPtr &spawner, const Options &options, un
 		m_spawning = false;
 		
 		done = done
-			|| ((unsigned long) enabledCount >= options.minProcesses && getWaitlist.empty())
+			|| ((unsigned long) getProcessCount() >= options.minProcesses && getWaitlist.empty())
 			|| pool->atFullCapacity(false);
 		m_spawning = !done;
 		if (done) {
@@ -803,13 +885,11 @@ Group::spawnThreadRealMain(const SpawnerPtr &spawner, const Options &options, un
 
 bool
 Group::shouldSpawn() const {
-	return !m_spawning
+	return allowSpawn()
 		&& (
-			(unsigned long) enabledCount < options.minProcesses
+			(unsigned long) getProcessCount() < options.minProcesses
 			|| (enabledCount > 0 && pqueue.top()->atFullCapacity())
-		)
-		&& isAlive()
-		&& !poolAtFullCapacity();
+		);
 }
 
 bool
@@ -817,6 +897,11 @@ Group::shouldSpawnForGetAction() const {
 	return enabledCount == 0 || shouldSpawn();
 }
 
+bool
+Group::allowSpawn() const {
+	return isAlive() && !poolAtFullCapacity();
+}
+
 void
 Group::restart(const Options &options) {
 	vector<Callback> actions;
@@ -1035,6 +1120,18 @@ Group::anotherGroupIsWaitingForCapacity() const {
 	return false;
 }
 
+bool
+Group::testOverflowRequestQueue() const {
+	// This has a performance penalty, although I'm not sure whether the penalty is
+	// any greater than a hash table lookup if I were to implement it in Options.
+	Pool::DebugSupportPtr debug = getPool()->debugSupport;
+	if (debug) {
+		return debug->testOverflowRequestQueue;
+	} else {
+		return false;
+	}
+}
+
 const ResourceLocator &
 Group::getResourceLocator() const {
 	return getPool()->spawnerFactory->getResourceLocator();
@@ -1094,6 +1191,11 @@ Session::requestOOBW() {
 	process->getGroup()->requestOOBW(process);
 }
 
+int
+Session::kill(int signo) {
+	return getProcess()->kill(signo);
+}
+
 
 PipeWatcher::DataCallback PipeWatcher::onData;