passenger 4.0.2 → 4.0.3

data/ext/common/ApplicationPool2/DirectSpawner.h

@@ -109,7 +109,9 @@ private:
 		startBackgroundThread(detachProcessMain, (void *) (long) pid);
 	}
 	
-	vector<string> createCommand(const Options &options, shared_array<const char *> &args) const {
+	vector<string> createCommand(const Options &options, const SpawnPreparationInfo &preparation,
+		shared_array<const char *> &args) const
+	{
 		vector<string> startCommandArgs;
 		string agentsDir = resourceLocator.getAgentsDir();
 		vector<string> command;
@@ -129,6 +131,7 @@ private:
 			command.push_back(agentsDir + "/SpawnPreparer");
 		}
 		command.push_back(agentsDir + "/SpawnPreparer");
+		command.push_back(preparation.appRoot);
 		command.push_back(serializeEnvvarsFromPoolOptions(options));
 		command.push_back(startCommandArgs[0]);
 		// Note: do not try to set a process title here.
@@ -166,8 +169,8 @@ public:
 		possiblyRaiseInternalError(options);
 
 		shared_array<const char *> args;
-		vector<string> command = createCommand(options, args);
 		SpawnPreparationInfo preparation = prepareSpawn(options);
+		vector<string> command = createCommand(options, preparation, args);
 		SocketPair adminSocket = createUnixSocketPair();
 		Pipe errorPipe = createPipe();
 		DebugDirPtr debugDir = make_shared<DebugDir>(preparation.uid, preparation.gid);

data/ext/common/ApplicationPool2/Implementation.cpp

@@ -953,6 +953,12 @@ Group::detachedProcessesCheckerMain(GroupPtr self) {
 						assert(process->getLifeStatus() == Process::DEAD);
 						it++;
 						removeProcessFromList(process, detachedProcesses);
+					} else if (process->shutdownTimeoutExpired()) {
+						P_WARN("Detached process " << process->inspect() <<
+							" didn't shut down within " PROCESS_SHUTDOWN_TIMEOUT_DISPLAY
+							". Forcefully killing it with SIGKILL.");
+						kill(process->pid, SIGKILL);
+						it++;
 					} else {
 						it++;
 					}
@@ -991,7 +997,7 @@ Group::detachedProcessesCheckerMain(GroupPtr self) {
 		// someone wakes us up.
 		UPDATE_TRACE_POINT();
 		detachedProcessesCheckerCond.timed_wait(lock,
-			posix_time::milliseconds(10));
+			posix_time::milliseconds(100));
 	}
 }
 

data/ext/common/ApplicationPool2/Pool.h

@@ -434,17 +434,20 @@ public:
 		for (p_it = processes.begin(); p_it != processes.end(); p_it++) {
 			const ProcessPtr &process = *p_it;
 			char buf[128];
+			char cpubuf[10];
 			char membuf[10];
 			
+			snprintf(cpubuf, sizeof(cpubuf), "%d%%", (int) process->metrics.cpu);
 			snprintf(membuf, sizeof(membuf), "%ldM",
 				(unsigned long) (process->metrics.realMemory() / 1024));
 			snprintf(buf, sizeof(buf),
-					"  * PID   : %-5lu   Sessions : %-2u   Processed: %-5u   Uptime: %s\n"
-					"    Memory: %-5s   Last used: %s ago",
+					"  * PID: %-5lu   Sessions: %-2u      Processed: %-5u   Uptime: %s\n"
+					"    CPU: %-5s   Memory  : %-5s   Last used: %s ago",
 					(unsigned long) process->pid,
 					process->sessions,
 					process->processed,
 					process->uptime().c_str(),
+					cpubuf,
 					membuf,
 					distanceOfTimeInWords(process->lastUsed / 1000000).c_str());
 			result << buf << endl;
@@ -454,7 +457,7 @@ public:
 			} else if (process->enabled == Process::DISABLED) {
 				result << "    DISABLED" << endl;
 			} else if (process->enabled == Process::DETACHED) {
-				result << "    Shutting down...";
+				result << "    Shutting down..." << endl;
 			}
 
 			const Socket *socket;

data/ext/common/ApplicationPool2/Process.h

@@ -39,6 +39,7 @@
 #include <ApplicationPool2/Socket.h>
 #include <ApplicationPool2/Session.h>
 #include <ApplicationPool2/PipeWatcher.h>
+#include <Constants.h>
 #include <FileDescriptor.h>
 #include <SafeLibev.h>
 #include <Logging.h>
@@ -233,10 +234,10 @@ public:
 		/** This process has been detached, and the detached processes checker has
 		 * verified that there are no active sessions left and has told the process
 		 * to shut down. In this state we're supposed to wait until the process
-		 * has actually shutdown, after which clean() must be called. */
+		 * has actually shutdown, after which cleanup() must be called. */
 		SHUTDOWN_TRIGGERED,
 		/**
-		 * The process has exited and clean() has been called. In this state,
+		 * The process has exited and cleanup() has been called. In this state,
 		 * this object is no longer usable.
 		 */
 		DEAD
@@ -275,6 +276,8 @@ public:
 	} oobwStatus;
 	/** Caches whether or not the OS process still exists. */
 	mutable bool m_osProcessExists;
+	/** Time at which shutdown began. */
+	time_t shutdownStartTime;
 	/** Collected by Pool::collectAnalytics(). */
 	ProcessMetrics metrics;
 	
@@ -309,7 +312,8 @@ public:
 		  lifeStatus(ALIVE),
 		  enabled(ENABLED),
 		  oobwStatus(OOBW_NOT_ACTIVE),
-		  m_osProcessExists(true)
+		  m_osProcessExists(true),
+		  shutdownStartTime(0)
 	{
 		SpawnerConfigPtr config;
 		if (_config == NULL) {
@@ -412,12 +416,17 @@ public:
 			lock_guard<boost::mutex> lock(lifetimeSyncher);
 			assert(lifeStatus == ALIVE);
 			lifeStatus = SHUTDOWN_TRIGGERED;
+			shutdownStartTime = SystemTime::get();
 		}
 		if (!dummy) {
 			syscalls::shutdown(adminSocket, SHUT_WR);
 		}
 	}
 
+	bool shutdownTimeoutExpired() const {
+		return SystemTime::get() >= shutdownStartTime + PROCESS_SHUTDOWN_TIMEOUT;
+	}
+
 	bool canCleanup() const {
 		return getLifeStatus() == SHUTDOWN_TRIGGERED && !osProcessExists();
 	}

data/ext/common/ApplicationPool2/SmartSpawner.h

@@ -120,6 +120,7 @@ private:
 			command.push_back(agentsDir + "/SpawnPreparer");
 		}
 		command.push_back(agentsDir + "/SpawnPreparer");
+		command.push_back(preparation.appRoot);
 		command.push_back(serializeEnvvarsFromPoolOptions(options));
 		command.push_back(preloaderCommand[0]);
 		// Note: do not try to set a process title here.
@@ -210,8 +211,8 @@ private:
 		checkChrootDirectories(options);
 		
 		shared_array<const char *> args;
-		vector<string> command = createRealPreloaderCommand(options, args);
 		preparation = prepareSpawn(options);
+		vector<string> command = createRealPreloaderCommand(options, args);
 		SocketPair adminSocket = createUnixSocketPair();
 		Pipe errorPipe = createPipe();
 		DebugDirPtr debugDir = make_shared<DebugDir>(preparation.uid, preparation.gid);

data/ext/common/Constants.h

@@ -26,7 +26,7 @@
 #define _PASSENGER_CONSTANTS_H_
 
 /* Don't forget to update lib/phusion_passenger.rb too. */
-#define PASSENGER_VERSION "4.0.2"
+#define PASSENGER_VERSION "4.0.3"
 
 #define FEEDBACK_FD 3
 
@@ -49,4 +49,7 @@
 
 #define POOL_HELPER_THREAD_STACK_SIZE (1024 * 256)
 
+#define PROCESS_SHUTDOWN_TIMEOUT 60 /* seconds */
+#define PROCESS_SHUTDOWN_TIMEOUT_DISPLAY "1 minute"
+
 #endif /* _PASSENGER_CONSTANTS_H */

data/ext/common/EventedBufferedInput.h

@@ -60,16 +60,23 @@ using namespace oxt;
  * the number of bytes that it has actually consumed. If not everything has been
  * consumed, then the handler will be called with the remaining data in the next
  * tick.
- *
- * TODO: this code is directly ported from Zangetsu's socket_input_wrapper.js. We
- * should port over the unit tests too.
  */
 template<size_t bufferSize = 1024 * 8>
 class EventedBufferedInput: public enable_shared_from_this< EventedBufferedInput<bufferSize> > {
 private:
 	enum State {
 		LIVE,
+		/**
+		 * @invariant
+		 *    paused
+		 *    socketPaused
+		 */
 		END_OF_STREAM,
+		/**
+		 * @invariant
+		 *    paused
+		 *    socketPaused
+		 */
 		READ_ERROR,
 		CLOSED
 	};
@@ -78,13 +85,54 @@ private:
 	FileDescriptor fd;
 	ev::io watcher;
 	StaticString buffer;
-	State state;
-	bool paused;
-	bool socketPaused;
-	bool nextTickInstalled;
+
+	State state: 2;
+	/**
+	 * Whether this EventedBufferedInput is paused (not started). If it's
+	 * paused it should not emit data events.
+	 * 
+	 * @invariant
+	 *    if paused:
+	 *       socketPaused
+	 */
+	bool paused: 1;
+	/**
+	 * Whether the underlying socket is also paused. This does not
+	 * necessarily mean the EventedBufferedInput is also paused because
+	 * it may be emitting data events from its internal buffer.
+	 */
+	bool socketPaused: 1;
+	/**
+	 * Whether the code is inside a processingBuffer() call.
+	 */
+	bool processingBuffer: 1;
+	/**
+	 * Whether processBuffer() is scheduled to be called in the next
+	 * event loop iteration.
+	 */
+	bool nextTickInstalled: 1;
+	/**
+	 * Increment this number to ensure that previously scheduled
+	 * processBuffer() calls will do nothing, effectively canceling
+	 * its scheduled calls.
+	 */
+	unsigned int generation;
 	int error;
+
 	char bufferData[bufferSize];
 
+	void verifyInvariants() {
+		// !a || b: logical equivalent of a IMPLIES b.
+		
+		assert(!( state == END_OF_STREAM ) || ( paused ));
+		assert(!( state == END_OF_STREAM ) || ( socketPaused ));
+		
+		assert(!( state == READ_ERROR ) || ( paused ));
+		assert(!( state == READ_ERROR ) || ( socketPaused ));
+		
+		assert(!( paused ) || ( socketPaused ));
+	}
+
 	void resetCallbackFields() {
 		onData = NULL;
 		onError = NULL;
@@ -96,7 +144,10 @@ private:
 		shared_ptr< EventedBufferedInput<bufferSize> > self = EventedBufferedInput<bufferSize>::shared_from_this();
 
 		EBI_TRACE("onReadable");
-		ssize_t ret = syscalls::read(fd, bufferData, bufferSize);
+		verifyInvariants();
+		assert(!nextTickInstalled);
+
+		ssize_t ret = readSocket(bufferData, bufferSize);
 		if (ret == -1) {
 			if (errno != EAGAIN) {
 				error = errno;
@@ -109,8 +160,11 @@ private:
 				watcher.stop();
 				state = READ_ERROR;
 				paused = true;
+				socketPaused = true;
+				verifyInvariants();
 				if (onError != NULL) {
 					onError(self, "Cannot read from socket", error);
+					verifyInvariants();
 				}
 			}
 
@@ -124,7 +178,10 @@ private:
 			watcher.stop();
 			state = END_OF_STREAM;
 			paused = true;
+			socketPaused = true;
+			verifyInvariants();
 			onData(self, StaticString());
+			verifyInvariants();
 
 		} else {
 			EBI_TRACE("read " << ret << " bytes");
@@ -135,29 +192,51 @@ private:
 
 			buffer = StaticString(bufferData, ret);
 			processBuffer();
+			verifyInvariants();
 		}
 	}
 
 	void processBufferInNextTick() {
 		if (!nextTickInstalled) {
 			nextTickInstalled = true;
-			libev->runAsync(boost::bind(
+			libev->runLater(boost::bind(
 				realProcessBufferInNextTick,
-				weak_ptr< EventedBufferedInput<bufferSize> >(this->shared_from_this())
+				weak_ptr< EventedBufferedInput<bufferSize> >(this->shared_from_this()),
+				generation
 			));
 		}
 	}
 
-	static void realProcessBufferInNextTick(weak_ptr< EventedBufferedInput<bufferSize> > wself) {
+	static void realProcessBufferInNextTick(weak_ptr< EventedBufferedInput<bufferSize> > wself,
+		unsigned int generation)
+	{
 		shared_ptr< EventedBufferedInput<bufferSize> > self = wself.lock();
-		if (self != NULL) {
+		if (self != NULL && generation == self->generation) {
+			self->verifyInvariants();
 			self->nextTickInstalled = false;
 			self->processBuffer();
+			self->verifyInvariants();
 		}
 	}
 
+	struct SetProcessingBufferToFalse {
+		EventedBufferedInput<bufferSize> *self;
+
+		SetProcessingBufferToFalse(EventedBufferedInput<bufferSize> *_self) {
+			self = _self;
+		}
+
+		~SetProcessingBufferToFalse() {
+			self->processingBuffer = false;
+		}
+	};
+
 	void processBuffer() {
 		EBI_TRACE("processBuffer");
+		assert(!processingBuffer);
+		processingBuffer = true;
+		SetProcessingBufferToFalse flagGuard(this);
+
 		if (state == CLOSED) {
 			return;
 		}
@@ -179,6 +258,7 @@ private:
 				socketPaused = false;
 				watcher.start();
 			}
+			cancelScheduledProcessBufferCall();
 		} else {
 			buffer = buffer.substr(consumed);
 			if (!socketPaused) {
@@ -189,18 +269,36 @@ private:
 				// Consume rest of the data in the next tick.
 				EBI_TRACE("Consume rest in next tick");
 				processBufferInNextTick();
+			} else {
+				cancelScheduledProcessBufferCall();
 			}
 		}
+
+		afterProcessingBuffer();
 	}
 
-	void _reset(SafeLibev *libev, const FileDescriptor &fd) {
+	void cancelScheduledProcessBufferCall() {
+		if (nextTickInstalled) {
+			nextTickInstalled = false;
+			generation++;
+		}
+	}
+
+	void _reset(SafeLibev *libev, const FileDescriptor &fd, bool firstTime = false) {
+		if (firstTime) {
+			generation = 0;
+		} else {
+			verifyInvariants();
+		}
 		this->libev = libev;
 		this->fd = fd;
 		buffer = StaticString();
 		state = LIVE;
 		paused = true;
 		socketPaused = true;
+		processingBuffer = false;
 		nextTickInstalled = false;
+		generation++;
 		error = 0;
 		if (watcher.is_active()) {
 			watcher.stop();
@@ -211,6 +309,16 @@ private:
 		if (fd != -1) {
 			watcher.set(fd, ev::READ);
 		}
+		verifyInvariants();
+	}
+
+protected:
+	virtual ssize_t readSocket(void *buf, size_t n) {
+		return syscalls::read(fd, buf, n);
+	}
+
+	virtual void afterProcessingBuffer() {
+		// Do nothing. To be overridden in unit tests.
 	}
 
 public:
@@ -223,21 +331,24 @@ public:
 
 	EventedBufferedInput() {
 		resetCallbackFields();
-		_reset(NULL, FileDescriptor());
+		_reset(NULL, FileDescriptor(), true);
 		watcher.set<EventedBufferedInput<bufferSize>,
 			&EventedBufferedInput<bufferSize>::onReadable>(this);
 		EBI_TRACE("created");
+		verifyInvariants();
 	}
 
 	EventedBufferedInput(SafeLibev *libev, const FileDescriptor &fd) {
 		resetCallbackFields();
-		_reset(libev, fd);
+		_reset(libev, fd, true);
 		watcher.set<EventedBufferedInput<bufferSize>,
 			&EventedBufferedInput<bufferSize>::onReadable>(this);
 		EBI_TRACE("created");
+		verifyInvariants();
 	}
 
-	~EventedBufferedInput() {
+	virtual ~EventedBufferedInput() {
+		cancelScheduledProcessBufferCall();
 		watcher.stop();
 		EBI_TRACE("destroyed");
 	}
@@ -254,17 +365,21 @@ public:
 	void stop() {
 		if (state == LIVE && !paused) {
 			EBI_TRACE("stop()");
+			verifyInvariants();
 			paused = true;
 			if (!socketPaused) {
 				socketPaused = true;
 				watcher.stop();
 			}
+			cancelScheduledProcessBufferCall();
+			verifyInvariants();
 		}
 	}
 
 	void start() {
 		if (state == LIVE && paused) {
 			EBI_TRACE("start()");
+			verifyInvariants();
 			assert(socketPaused);
 			
 			paused = false;
@@ -273,7 +388,9 @@ public:
 			} else {
 				socketPaused = false;
 				watcher.start();
+				cancelScheduledProcessBufferCall();
 			}
+			verifyInvariants();
 		}
 	}
 
@@ -281,11 +398,16 @@ public:
 		return !paused;
 	}
 
+	bool isSocketStarted() const {
+		return !socketPaused;
+	}
+
 	bool endReached() const {
 		return state == END_OF_STREAM;
 	}
 
 	void readNow() {
+		assert(!nextTickInstalled);
 		onReadable(watcher, 0);
 	}
 
@@ -322,6 +444,7 @@ public:
 		result << ", paused=" << paused;
 		result << ", socketPaused=" << socketPaused;
 		result << ", nextTickInstalled=" << nextTickInstalled;
+		result << ", generation=" << generation;
 		result << ", error=" << error;
 
 		return result.str();