passenger 1.0.5 → 2.0.1

data/ext/apache2/StandardApplicationPool.h

@@ -2,6 +2,8 @@
  *  Phusion Passenger - http://www.modrails.com/
  *  Copyright (C) 2008  Phusion
  *
+ *  Phusion Passenger is a trademark of Hongli Lai & Ninh Bui.
+ *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; version 2 of the License.
@@ -21,16 +23,18 @@
 #include <boost/shared_ptr.hpp>
 #include <boost/weak_ptr.hpp>
 #include <boost/thread.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/condition.hpp>
 #include <boost/bind.hpp>
+#include <boost/date_time/microsec_time_clock.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
 
 #include <string>
+#include <sstream>
 #include <map>
 #include <list>
 
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <stdio.h>
 #include <unistd.h>
 #include <ctime>
 #include <cerrno>
@@ -40,6 +44,7 @@
 
 #include "ApplicationPool.h"
 #include "Logging.h"
+#include "System.h"
 #ifdef PASSENGER_USE_DUMMY_SPAWN_MANAGER
 	#include "DummySpawnManager.h"
 #else
@@ -88,6 +93,10 @@ class StandardApplicationPool: public ApplicationPool {
 private:
 	static const int DEFAULT_MAX_IDLE_TIME = 120;
 	static const int DEFAULT_MAX_POOL_SIZE = 20;
+	static const int DEFAULT_MAX_INSTANCES_PER_APP = 0;
+	static const int CLEANER_THREAD_STACK_SIZE = 1024 * 128;
+	static const unsigned int MAX_GET_ATTEMPTS = 10;
+	static const unsigned int GET_TIMEOUT = 5000; // In milliseconds.
 
 	friend class ApplicationPoolServer;
 	struct AppContainer;
@@ -113,8 +122,10 @@ private:
 		unsigned int max;
 		unsigned int count;
 		unsigned int active;
+		unsigned int maxPerApp;
 		AppContainerList inactiveApps;
 		map<string, time_t> restartFileTimes;
+		map<string, unsigned int> appInstanceCount;
 	};
 	
 	typedef shared_ptr<SharedData> SharedDataPtr;
@@ -150,9 +161,9 @@ private:
 					data->inactiveApps.push_back(container);
 					container->ia_iterator = data->inactiveApps.end();
 					container->ia_iterator--;
+					data->active--;
+					data->activeOrMaxChanged.notify_all();
 				}
-				data->active--;
-				data->activeOrMaxChanged.notify_all();
 			}
 		}
 	};
@@ -176,8 +187,75 @@ private:
 	unsigned int &max;
 	unsigned int &count;
 	unsigned int &active;
+	unsigned int &maxPerApp;
 	AppContainerList &inactiveApps;
 	map<string, time_t> &restartFileTimes;
+	map<string, unsigned int> &appInstanceCount;
+	
+	/**
+	 * Verify that all the invariants are correct.
+	 */
+	bool inline verifyState() {
+	#if PASSENGER_DEBUG
+		// Invariant for _apps_.
+		ApplicationMap::const_iterator it;
+		for (it = apps.begin(); it != apps.end(); it++) {
+			AppContainerList *list = it->second.get();
+			P_ASSERT(!list->empty(), false, "List for '" << it->first << "' is nonempty.");
+			
+			AppContainerList::const_iterator prev_lit;
+			AppContainerList::const_iterator lit;
+			prev_lit = list->begin();
+			lit = prev_lit;
+			lit++;
+			for (; lit != list->end(); lit++) {
+				if ((*prev_lit)->sessions > 0) {
+					P_ASSERT((*lit)->sessions > 0, false,
+						"List for '" << it->first <<
+						"' is sorted from nonactive to active");
+				}
+			}
+		}
+		
+		P_ASSERT(active <= count, false,
+			"active (" << active << ") < count (" << count << ")");
+		P_ASSERT(inactiveApps.size() == count - active, false,
+			"inactive_apps.size() == count - active");
+	#endif
+		return true;
+	}
+	
+	template<typename LockActionType>
+	string toString(LockActionType lockAction) const {
+		unique_lock<mutex> l(lock, lockAction);
+		stringstream result;
+		
+		result << "----------- General information -----------" << endl;
+		result << "max      = " << max << endl;
+		result << "count    = " << count << endl;
+		result << "active   = " << active << endl;
+		result << "inactive = " << inactiveApps.size() << endl;
+		result << endl;
+		
+		result << "----------- Applications -----------" << endl;
+		ApplicationMap::const_iterator it;
+		for (it = apps.begin(); it != apps.end(); it++) {
+			AppContainerList *list = it->second.get();
+			AppContainerList::const_iterator lit;
+			
+			result << it->first << ": " << endl;
+			for (lit = list->begin(); lit != list->end(); lit++) {
+				AppContainer *container = lit->get();
+				char buf[128];
+				
+				snprintf(buf, sizeof(buf), "PID: %-8d  Sessions: %d",
+					container->app->getPid(), container->sessions);
+				result << "  " << buf << endl;
+			}
+			result << endl;
+		}
+		return result.str();
+	}
 	
 	bool needsRestart(const string &appRoot) {
 		string restartFile(appRoot);
@@ -185,21 +263,15 @@ private:
 		
 		struct stat buf;
 		bool result;
-		if (stat(restartFile.c_str(), &buf) == 0) {
-			int ret;
-			#ifdef TESTING_APPLICATION_POOL
-				if (getenv("nextRestartTxtDeletionShouldFail") != NULL) {
-					unsetenv("nextRestartTxtDeletionShouldFail");
-					ret = -1;
-					errno = EACCES;
-				} else {
-					ret = unlink(restartFile.c_str());
-				}
-			#else
-				do {
-					ret = unlink(restartFile.c_str());
-				} while (ret == -1 && errno == EAGAIN);
-			#endif
+		int ret;
+		
+		do {
+			ret = stat(restartFile.c_str(), &buf);
+		} while (ret == -1 && errno == EINTR);
+		if (ret == 0) {
+			do {
+				ret = unlink(restartFile.c_str());
+			} while (ret == -1 && (errno == EINTR || errno == EAGAIN));
 			if (ret == 0 || errno == ENOENT) {
 				restartFileTimes.erase(appRoot);
 				result = true;
@@ -222,64 +294,74 @@ private:
 	}
 	
 	void cleanerThreadMainLoop() {
-		mutex::scoped_lock l(lock);
-		while (!done) {
-			xtime xt;
-			xtime_get(&xt, TIME_UTC);
-			xt.sec += maxIdleTime + 1;
-			if (cleanerThreadSleeper.timed_wait(l, xt)) {
-				// Condition was woken up.
-				if (done) {
-					// StandardApplicationPool is being destroyed.
-					break;
-				} else {
-					continue;
+		this_thread::disable_syscall_interruption dsi;
+		unique_lock<mutex> l(lock);
+		try {
+			while (!done && !this_thread::interruption_requested()) {
+				xtime xt;
+				xtime_get(&xt, TIME_UTC);
+				xt.sec += maxIdleTime + 1;
+				if (cleanerThreadSleeper.timed_wait(l, xt)) {
+					// Condition was woken up.
+					if (done) {
+						// StandardApplicationPool is being destroyed.
+						break;
+					} else {
+						// maxIdleTime changed.
+						continue;
+					}
 				}
-			}
-			
-			time_t now = time(NULL);
-			AppContainerList::iterator it;
-			for (it = inactiveApps.begin(); it != inactiveApps.end(); it++) {
-				AppContainer &container(*it->get());
-				ApplicationPtr app(container.app);
-				AppContainerListPtr appList(apps[app->getAppRoot()]);
 				
-				if (now - container.lastUsed > (time_t) maxIdleTime) {
-					P_DEBUG("Cleaning idle app " << app->getAppRoot() <<
-						" (PID " << app->getPid() << ")");
-					appList->erase(container.iterator);
+				time_t now = InterruptableCalls::time(NULL);
+				AppContainerList::iterator it;
+				for (it = inactiveApps.begin(); it != inactiveApps.end(); it++) {
+					AppContainer &container(*it->get());
+					ApplicationPtr app(container.app);
+					AppContainerListPtr appList(apps[app->getAppRoot()]);
 					
-					AppContainerList::iterator prev = it;
-					prev--;
-					inactiveApps.erase(it);
-					it = prev;
-					
-					count--;
-				}
-				if (appList->empty()) {
-					apps.erase(app->getAppRoot());
-					data->restartFileTimes.erase(app->getAppRoot());
+					if (now - container.lastUsed > (time_t) maxIdleTime) {
+						P_DEBUG("Cleaning idle app " << app->getAppRoot() <<
+							" (PID " << app->getPid() << ")");
+						appList->erase(container.iterator);
+						
+						AppContainerList::iterator prev = it;
+						prev--;
+						inactiveApps.erase(it);
+						it = prev;
+						
+						appInstanceCount[app->getAppRoot()]--;
+						
+						count--;
+					}
+					if (appList->empty()) {
+						apps.erase(app->getAppRoot());
+						appInstanceCount.erase(app->getAppRoot());
+						data->restartFileTimes.erase(app->getAppRoot());
+					}
 				}
 			}
+		} catch (const exception &e) {
+			P_ERROR("Uncaught exception: " << e.what());
 		}
 	}
 	
-	void detach() {
-		detached = true;
-		
-		ApplicationMap::iterator it;
-		for (it = apps.begin(); it != apps.end(); it++) {
-			AppContainerList &list = *(it->second.get());
-			AppContainerList::iterator it2;
-			for (it2 = list.begin(); it2 != list.end(); it2++) {
-				(*it2)->app->detach();
-			}
-		}
-	}
-	
+	/**
+	 * @throws boost::thread_interrupted
+	 * @throws SpawnException
+	 * @throws SystemException
+	 */
 	pair<AppContainerPtr, AppContainerList *>
-	spawnOrUseExisting(mutex::scoped_lock &l, const string &appRoot,
-	                   bool lowerPrivilege, const string &lowestUser) {
+	spawnOrUseExisting(
+		mutex::scoped_lock &l,
+		const string &appRoot,
+		bool lowerPrivilege,
+		const string &lowestUser,
+		const string &environment,
+		const string &spawnMethod,
+		const string &appType
+	) {
+		this_thread::disable_interruption di;
+		this_thread::disable_syscall_interruption dsi;
 		AppContainerPtr container;
 		AppContainerList *list;
 		
@@ -301,37 +383,63 @@ private:
 					count--;
 				}
 				apps.erase(appRoot);
+				appInstanceCount.erase(appRoot);
 				spawnManager.reload(appRoot);
 				it = apps.end();
+				activeOrMaxChanged.notify_all();
 			}
 			
 			if (it != apps.end()) {
 				list = it->second.get();
-		
-				if (list->front()->sessions == 0 || count >= max) {
+				
+				if (list->front()->sessions == 0) {
 					container = list->front();
 					list->pop_front();
 					list->push_back(container);
 					container->iterator = list->end();
 					container->iterator--;
-					if (container->sessions == 0) {
-						inactiveApps.erase(container->ia_iterator);
-					}
+					inactiveApps.erase(container->ia_iterator);
 					active++;
+					activeOrMaxChanged.notify_all();
+				} else if (count >= max || (
+					maxPerApp != 0 && appInstanceCount[appRoot] >= maxPerApp )
+					) {
+					AppContainerList::iterator it(list->begin());
+					AppContainerList::iterator smallest(list->begin());
+					it++;
+					for (; it != list->end(); it++) {
+						if ((*it)->sessions < (*smallest)->sessions) {
+							smallest = it;
+						}
+					}
+					container = *smallest;
+					list->erase(smallest);
+					list->push_back(container);
+					container->iterator = list->end();
+					container->iterator--;
 				} else {
 					container = ptr(new AppContainer());
-					container->app = spawnManager.spawn(appRoot,
-						lowerPrivilege, lowestUser);
+					{
+						this_thread::restore_interruption ri(di);
+						this_thread::restore_syscall_interruption rsi(dsi);
+						container->app = spawnManager.spawn(appRoot,
+							lowerPrivilege, lowestUser, environment,
+							spawnMethod, appType);
+					}
 					container->sessions = 0;
 					list->push_back(container);
 					container->iterator = list->end();
 					container->iterator--;
+					appInstanceCount[appRoot]++;
 					count++;
 					active++;
 					activeOrMaxChanged.notify_all();
 				}
 			} else {
-				while (active >= max) {
+				while (!(
+					active < max &&
+					(maxPerApp == 0 || appInstanceCount[appRoot] < maxPerApp)
+				)) {
 					activeOrMaxChanged.wait(l);
 				}
 				if (count == max) {
@@ -342,18 +450,28 @@ private:
 					if (list->empty()) {
 						apps.erase(container->app->getAppRoot());
 						restartFileTimes.erase(container->app->getAppRoot());
+						appInstanceCount.erase(container->app->getAppRoot());
+					} else {
+						appInstanceCount[container->app->getAppRoot()]--;
 					}
 					count--;
 				}
 				container = ptr(new AppContainer());
-				container->app = spawnManager.spawn(appRoot, lowerPrivilege, lowestUser);
+				{
+					this_thread::restore_interruption ri(di);
+					this_thread::restore_syscall_interruption rsi(dsi);
+					container->app = spawnManager.spawn(appRoot, lowerPrivilege, lowestUser,
+						environment, spawnMethod, appType);
+				}
 				container->sessions = 0;
 				it = apps.find(appRoot);
 				if (it == apps.end()) {
 					list = new AppContainerList();
 					apps[appRoot] = ptr(list);
+					appInstanceCount[appRoot] = 1;
 				} else {
 					list = it->second.get();
+					appInstanceCount[appRoot]++;
 				}
 				list->push_back(container);
 				container->iterator = list->end();
@@ -394,9 +512,6 @@ public:
 	 *            specified, no log file will be used, and the spawn server
 	 *            will use the same standard output/error channels as the
 	 *            current process.
-	 * @param environment The RAILS_ENV environment that all RoR applications
-	 *            should use. If an empty string is specified, the current value
-	 *            of the RAILS_ENV environment variable will be used.
 	 * @param rubyCommand The Ruby interpreter's command.
 	 * @param user The user that the spawn manager should run as. This
 	 *             parameter only has effect if the current process is
@@ -409,12 +524,11 @@ public:
 	 */
 	StandardApplicationPool(const string &spawnServerCommand,
 	             const string &logFile = "",
-	             const string &environment = "production",
 	             const string &rubyCommand = "ruby",
 	             const string &user = "")
 	        :
 		#ifndef PASSENGER_USE_DUMMY_SPAWN_MANAGER
-		spawnManager(spawnServerCommand, logFile, environment, rubyCommand, user),
+		spawnManager(spawnServerCommand, logFile, rubyCommand, user),
 		#endif
 		data(new SharedData()),
 		lock(data->lock),
@@ -423,20 +537,27 @@ public:
 		max(data->max),
 		count(data->count),
 		active(data->active),
+		maxPerApp(data->maxPerApp),
 		inactiveApps(data->inactiveApps),
-		restartFileTimes(data->restartFileTimes)
+		restartFileTimes(data->restartFileTimes),
+		appInstanceCount(data->appInstanceCount)
 	{
 		detached = false;
 		done = false;
 		max = DEFAULT_MAX_POOL_SIZE;
 		count = 0;
 		active = 0;
+		maxPerApp = DEFAULT_MAX_INSTANCES_PER_APP;
 		maxIdleTime = DEFAULT_MAX_IDLE_TIME;
-		cleanerThread = new thread(bind(&StandardApplicationPool::cleanerThreadMainLoop, this));
+		cleanerThread = new thread(
+			bind(&StandardApplicationPool::cleanerThreadMainLoop, this),
+			CLEANER_THREAD_STACK_SIZE
+		);
 	}
 	
 	virtual ~StandardApplicationPool() {
 		if (!detached) {
+			this_thread::disable_interruption di;
 			{
 				mutex::scoped_lock l(lock);
 				done = true;
@@ -447,34 +568,46 @@ public:
 		delete cleanerThread;
 	}
 	
-	virtual Application::SessionPtr
-	get(const string &appRoot, bool lowerPrivilege = true, const string &lowestUser = "nobody") {
-		unsigned int attempt;
-		const unsigned int MAX_ATTEMPTS = 5;
+	virtual Application::SessionPtr get(
+		const string &appRoot,
+		bool lowerPrivilege = true,
+		const string &lowestUser = "nobody",
+		const string &environment = "production",
+		const string &spawnMethod = "smart",
+		const string &appType = "rails"
+	) {
+		using namespace boost::posix_time;
+		unsigned int attempt = 0;
+		ptime timeLimit(get_system_time() + millisec(GET_TIMEOUT));
+		unique_lock<mutex> l(lock);
 		
-		attempt = 0;
 		while (true) {
 			attempt++;
 			
-			mutex::scoped_lock l(lock);
 			pair<AppContainerPtr, AppContainerList *> p(
-				spawnOrUseExisting(l, appRoot, lowerPrivilege, lowestUser)
+				spawnOrUseExisting(l, appRoot, lowerPrivilege, lowestUser,
+					environment, spawnMethod, appType)
 			);
 			AppContainerPtr &container(p.first);
 			AppContainerList &list(*p.second);
-			
+
 			container->lastUsed = time(NULL);
 			container->sessions++;
+			
+			P_ASSERT(verifyState(), Application::SessionPtr(),
+				"State is valid:\n" << toString(false));
 			try {
 				return container->app->connect(SessionCloseCallback(data, container));
 			} catch (const exception &e) {
 				container->sessions--;
-				if (attempt == MAX_ATTEMPTS) {
-					string message("Cannot connect to an existing application instance for '");
+				if (attempt == MAX_GET_ATTEMPTS) {
+					string message("Cannot connect to an existing "
+						"application instance for '");
 					message.append(appRoot);
 					message.append("': ");
 					try {
-						const SystemException &syse = dynamic_cast<const SystemException &>(e);
+						const SystemException &syse =
+							dynamic_cast<const SystemException &>(e);
 						message.append(syse.sys());
 					} catch (const bad_cast &) {
 						message.append(e.what());
@@ -484,9 +617,13 @@ public:
 					list.erase(container->iterator);
 					if (list.empty()) {
 						apps.erase(appRoot);
+						appInstanceCount.erase(appRoot);
 					}
 					count--;
 					active--;
+					activeOrMaxChanged.notify_all();
+					P_ASSERT(verifyState(), Application::SessionPtr(),
+						"State is valid.");
 				}
 			}
 		}
@@ -499,6 +636,7 @@ public:
 		apps.clear();
 		inactiveApps.clear();
 		restartFileTimes.clear();
+		appInstanceCount.clear();
 		count = 0;
 		active = 0;
 	}
@@ -523,9 +661,27 @@ public:
 		return count;
 	}
 	
+	virtual void setMaxPerApp(unsigned int maxPerApp) {
+		mutex::scoped_lock l(lock);
+		this->maxPerApp = maxPerApp;
+		activeOrMaxChanged.notify_all();
+	}
+	
 	virtual pid_t getSpawnServerPid() const {
 		return spawnManager.getServerPid();
 	}
+	
+	/**
+	 * Returns a textual description of the internal state of
+	 * the application pool.
+	 */
+	virtual string toString(bool lockMutex = true) const {
+		if (lockMutex) {
+			return toString(boost::adopt_lock);
+		} else {
+			return toString(boost::defer_lock);
+		}
+	}
 };
 
 } // namespace Passenger