passenger 3.0.0 → 3.0.1

data/ext/common/ApplicationPool/Pool.h

@@ -483,9 +483,16 @@ private:
 			result << "<has_metrics>true</has_metrics>";
 			result << "<cpu>" << (int) metrics.cpu << "</cpu>";
 			result << "<rss>" << metrics.rss << "</rss>";
-			if (metrics.realMemory != 0) {
-				result << "<real_memory>" << metrics.realMemory << "</real_memory>";
+			if (metrics.pss != -1) {
+				result << "<pss>" << metrics.pss << "</pss>";
 			}
+			if (metrics.privateDirty != -1) {
+				result << "<private_dirty>" << metrics.privateDirty << "</private_dirty>";
+			}
+			if (metrics.swap != -1) {
+				result << "<swap>" << metrics.swap << "</swap>";
+			}
+			result << "<real_memory>" << metrics.realMemory() << "</real_memory>";
 			result << "<vmsize>" << metrics.vmsize << "</vmsize>";
 			result << "<process_group_id>" << metrics.processGroupId << "</process_group_id>";
 			result << "<command>" << escapeForXml(metrics.command) << "</command>";
@@ -804,7 +811,7 @@ private:
 					// Now collect the process metrics and store them in the
 					// data structures, and log the state into the analytics logs.
 					UPDATE_TRACE_POINT();
-					ProcessMetricsCollector::Map allMetrics =
+					ProcessMetricMap allMetrics =
 						processMetricsCollector.collect(pids);
 					
 					UPDATE_TRACE_POINT();
@@ -822,13 +829,18 @@ private:
 						stringstream xml;
 						
 						if (group->analytics && analyticsLogger != NULL) {
+							ssize_t shared;
 							log = analyticsLogger->newTransaction(group->name,
 								"processes", group->unionStationKey);
 							xml << "Processes: <processes>";
+							xml << "<total_memory>" << allMetrics.totalMemory(shared) << "</total_memory>";
+							if (shared != -1) {
+								xml << "<total_shared_memory>" << shared << "</total_shared_memory>";
+							}
 						}
 						for (; process_info_it != process_info_it_end; process_info_it++) {
 							ProcessInfoPtr &processInfo = *process_info_it;
-							ProcessMetricsCollector::Map::const_iterator metrics_it =
+							ProcessMetricMap::const_iterator metrics_it =
 								allMetrics.find(processInfo->process->getPid());
 							if (metrics_it != allMetrics.end()) {
 								processInfo->metrics = metrics_it->second;

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 "3.0.0"
+#define PASSENGER_VERSION "3.0.1"
 
 #define FEEDBACK_FD 3
 

data/ext/common/EventedClient.h

@@ -123,7 +123,8 @@ private:
 		 * method fails to send all data immediately and EventedClient
 		 * schedules some data to be sent later, when the socket becomes
 		 * readable again. In here we will be watching for read
-		 * and write events.
+		 * and write events. Once all data has been sent out the system
+		 * will transition back to EC_CONNECTED.
 		 */
 		EC_WRITES_PENDING,
 		
@@ -140,8 +141,26 @@ private:
 		EC_TOO_MANY_WRITES_PENDING,
 		
 		/**
-		 * This state is entered from the EC_WRITES_PENDING or the
-		 * EC_TOO_MANY_WRITES_PENDING state when disconnect() is called.
+		 * This state is like EC_CONNECTED, but indicates that the write
+		 * side of the connection has been closed. In this state write()
+		 * calls won't have any effect.
+		 */
+		EC_RO_CONNECTED,
+		
+		/**
+		 * This state is entered from EC_WRITES_PENDING when
+		 * closeWrite() has been called. The system will continue
+		 * to send out pending data but write() calls won't append more
+		 * data to the outbox. After pending data has been sent out,
+		 * the system will transition to EC_RO_CONNECTED.
+		 */
+		EC_RO_CONNECTED_WITH_WRITES_PENDING,
+		
+		/**
+		 * This state is entered from the EC_WRITES_PENDING,
+		 * EC_TOO_MANY_WRITES_PENDING, EC_RO_CONNECTED_WITH_WIRTES_PENDING
+		 * or EC_RO_CONNECTED_WITH_TOO_MANY_WRITES_PENDING state when
+		 * disconnect() is called.
 		 * It means that we want to close the connection as soon as all
 		 * pending outgoing data has been sent. As soon as that happens
 		 * it'll transition to EC_DISCONNECTED. In this state no further
@@ -163,14 +182,16 @@ private:
 	/** Storage for data that could not be sent out immediately. */
 	string outbox;
 	int refcount;
-	bool m_notifyReads;
 	unsigned int outboxLimit;
+	bool m_notifyReads;
 	
 	void _onReadable(ev::io &w, int revents) {
 		emitEvent(onReadable);
 	}
 	
 	void onWritable(ev::io &w, int revents) {
+		assert(state != EC_CONNECTED);
+		assert(state != EC_RO_CONNECTED);
 		assert(state != EC_DISCONNECTED);
 		
 		this_thread::disable_interruption di;
@@ -185,7 +206,11 @@ private:
 			if (ret == -1) {
 				if (errno != EAGAIN) {
 					int e = errno;
-					disconnect(true);
+					if (writeErrorAction == DISCONNECT_FULL) {
+						disconnect(true);
+					} else {
+						closeWrite();
+					}
 					emitSystemErrorEvent("Cannot write data to client", e);
 					return;
 				}
@@ -213,6 +238,7 @@ private:
 		if (outbox.empty()) {
 			switch (state) {
 			case EC_CONNECTED:
+			case EC_RO_CONNECTED:
 				watchReadEvents(m_notifyReads);
 				watchWriteEvents(false);
 				break;
@@ -222,6 +248,11 @@ private:
 				watchReadEvents(m_notifyReads);
 				watchWriteEvents(false);
 				break;
+			case EC_RO_CONNECTED_WITH_WRITES_PENDING:
+				state = EC_RO_CONNECTED;
+				watchReadEvents(m_notifyReads);
+				watchWriteEvents(false);
+				break;
 			case EC_DISCONNECTING_WITH_WRITES_PENDING:
 				state = EC_DISCONNECTED;
 				watchReadEvents(false);
@@ -252,7 +283,12 @@ private:
 					watchWriteEvents(true);
 				}
 				break;
+			case EC_RO_CONNECTED:
+				fprintf(stderr, "BUG: when outbox is non-empty the state should never be EC_RO_CONNECTED!\n");
+				abort();
+				break;
 			case EC_WRITES_PENDING:
+			case EC_RO_CONNECTED_WITH_WRITES_PENDING:
 				watchReadEvents(m_notifyReads);
 				watchWriteEvents(true);
 				break;
@@ -300,6 +336,14 @@ public:
 	/** The client's file descriptor. Could be -1: see <tt>ioAllowed()</tt>. */
 	FileDescriptor fd;
 	
+	/** Controls what to do when a write error is encountered. */
+	enum {
+		/** Forcefully disconnect the client. */
+		DISCONNECT_FULL,
+		/** Close the writer side of the connection, but continue allowing reading. */
+		DISCONNECT_WRITE
+	} writeErrorAction;
+	
 	/**
 	 * Called when the file descriptor becomes readable and read notifications
 	 * are enabled (see <tt>notifyRead()</tt>). When there's too much pending
@@ -350,16 +394,17 @@ public:
 		  writeWatcher(loop),
 		  fd(_fd)
 	{
-		state           = EC_CONNECTED;
-		refcount        = 1;
-		m_notifyReads   = false;
-		outboxLimit     = 1024 * 32;
-		onReadable      = NULL;
-		onDisconnect    = NULL;
-		onDetach        = NULL;
+		state              = EC_CONNECTED;
+		refcount           = 1;
+		m_notifyReads      = false;
+		outboxLimit        = 1024 * 32;
+		writeErrorAction   = DISCONNECT_FULL;
+		onReadable         = NULL;
+		onDisconnect       = NULL;
+		onDetach           = NULL;
 		onPendingDataFlushed = NULL;
-		onSystemError   = NULL;
-		userData        = NULL;
+		onSystemError      = NULL;
+		userData           = NULL;
 		readWatcher.set(fd, ev::READ);
 		readWatcher.set<EventedClient, &EventedClient::_onReadable>(this);
 		writeWatcher.set<EventedClient, &EventedClient::onWritable>(this);
@@ -393,17 +438,35 @@ public:
 	}
 	
 	/**
-	 * Returns whether it is allowed to perform any I/O with this client.
+	 * Returns whether it is allowed to perform some kind of I/O with
+	 * this client, either reading or writing.
 	 * Usually true, and false when the client is either being disconnected
 	 * or has been disconnected. A return value of false indicates that
 	 * <tt>fd</tt> might be -1, but even when it isn't -1 you shouldn't
 	 * access <tt>fd</tt> anymore.
+	 * When the connection is half-closed (e.g. after closeWrite() has
+	 * been called) the return value is still be true. Only when I/O of any
+	 * kind is disallowed will this function return false.
 	 */
 	bool ioAllowed() const {
 		return state != EC_DISCONNECTING_WITH_WRITES_PENDING
 			&& state != EC_DISCONNECTED;
 	}
 	
+	/**
+	 * Returns whether it is allowed to write data to the client.
+	 * Usually true, and false when the client is either being disconnected
+	 * or has been disconnected or when the writer side of the client
+	 * connection has been closed. write() will do nothing if this function
+	 * returns false.
+	 */
+	bool writeAllowed() const {
+		return state == EC_CONNECTED
+			|| state == EC_WRITES_PENDING
+			|| state == EC_TOO_MANY_WRITES_PENDING
+			|| state == EC_RO_CONNECTED_WITH_WRITES_PENDING;
+	}
+	
 	/** Used by unit tests. */
 	bool readWatcherActive() const {
 		return readWatcher.is_active();
@@ -476,12 +539,15 @@ public:
 	 * network congestion) then the data will be buffered and scheduled for
 	 * sending later.
 	 *
-	 * If an I/O error was encountered then the client connection will be
-	 * closed by calling <tt>disconnect(true)</tt>. This means this method
-	 * could potentially call the <tt>onDisconnect</tt> callback.
+	 * If an I/O error was encountered then the action taken depends on the
+	 * value of <em>writeActionError</em>. By default it is DISCONNECT_FULL,
+	 * meaning the client connection will be closed by calling
+	 * <tt>disconnect(true)</tt>. This means this method could potentially
+	 * call the <tt>onDisconnect</tt> callback.
 	 *
-	 * If the client connection is already being closed or has already
-	 * been closed then this method does nothing.
+	 * If the client connection is already being closed, has already
+	 * been closed or if the writer side is closed, then this method does
+	 * nothing.
 	 *
 	 * The <tt>onPendingDataFlushed</tt> callback will be called after
 	 * this data and whatever existing pending data have been written
@@ -489,7 +555,7 @@ public:
 	 * of time.
 	 */
 	void write(const StaticString data[], unsigned int count) {
-		if (!ioAllowed()) {
+		if (!writeAllowed()) {
 			return;
 		}
 		
@@ -500,7 +566,11 @@ public:
 		ret = gatheredWrite(fd, data, count, outbox);
 		if (ret == -1) {
 			int e = errno;
-			disconnect(true);
+			if (writeErrorAction == DISCONNECT_FULL) {
+				disconnect(true);
+			} else {
+				closeWrite();
+			}
 			emitSystemErrorEvent("Cannot write data to client", e);
 		} else {
 			updateWatcherStates();
@@ -510,6 +580,39 @@ public:
 		}
 	}
 	
+	/**
+	 * Close only the writer side of the client connection.
+	 * After calling this method, subsequent write() calls won't do anything
+	 * anymore. Any pending outgoing data will be sent out whenever the
+	 * opportunity arises.
+	 *
+	 * This function does nothing if the client is being disconnected,
+	 * already disconnected or if only the writer side is closed.
+	 */
+	void closeWrite() {
+		this_thread::disable_syscall_interruption dsi;
+		
+		switch (state) {
+		case EC_CONNECTED:
+			assert(outbox.empty());
+			state = EC_RO_CONNECTED;
+			if (syscalls::shutdown(fd, SHUT_WR) == -1) {
+				int e = errno;
+				emitSystemErrorEvent(
+					"Cannot shutdown writer half of the client socket",
+					e);
+			}
+			break;
+		case EC_WRITES_PENDING:
+		case EC_TOO_MANY_WRITES_PENDING:
+			state = EC_RO_CONNECTED_WITH_WRITES_PENDING;
+			break;
+		default:
+			break;
+		}
+		updateWatcherStates();
+	}
+	
 	/**
 	 * Disconnects the client. This actually closes the underlying file
 	 * descriptor, even if the FileDescriptor object still has references.
@@ -543,7 +646,7 @@ public:
 		this_thread::disable_interruption di;
 		this_thread::disable_syscall_interruption dsi;
 		
-		if (state == EC_CONNECTED || force) {
+		if (state == EC_CONNECTED || state == EC_RO_CONNECTED || force) {
 			state = EC_DISCONNECTED;
 			watchReadEvents(false);
 			watchWriteEvents(false);
@@ -570,9 +673,10 @@ public:
 	 * Detaches the client file descriptor so that this EventedClient no longer
 	 * has any control over it. Any EventedClient I/O watchers on the client file
 	 * descriptor will be stopped and further I/O on the file descriptor via
-	 * EventedClient will become impossible. The original client file descriptor
-	 * is returned and <tt>onDetach</tt> is called. Subsequent calls to this
-	 * function will return -1 and will no longer call <tt>onDetach</tt>.
+	 * EventedClient will become impossible. Any pending outgoing data will be
+	 * discarded. The original client file descriptor is returned and
+	 * <tt>onDetach</tt> is called. Subsequent calls to this function will
+	 * return -1 and will no longer call <tt>onDetach</tt>.
 	 *
 	 * @post !ioAllowed()
 	 * @post fd == -1

data/ext/common/Exceptions.h

@@ -204,16 +204,20 @@ class SpawnException: public oxt::tracable_exception {
 private:
 	string msg;
 	bool m_hasErrorPage;
+	bool m_isHTML;
 	string m_errorPage;
 public:
 	SpawnException(const string &message)
 		: msg(message) {
 		m_hasErrorPage = false;
+		m_isHTML = false;
 	}
 	
-	SpawnException(const string &message, const string &errorPage)
-		: msg(message), m_errorPage(errorPage) {
+	SpawnException(const string &message, const string &errorPage, bool isHTML = true)
+		: msg(message), m_errorPage(errorPage)
+	{
 		m_hasErrorPage = true;
+		m_isHTML = isHTML;
 	}
 	
 	virtual ~SpawnException() throw() {}
@@ -234,6 +238,15 @@ public:
 	const string getErrorPage() const {
 		return m_errorPage;
 	}
+	
+	/**
+	 * Whether the error page content is HTML.
+	 *
+	 * @pre hasErrorPage()
+	 */
+	bool isHTML() const {
+		return m_isHTML;
+	}
 };
 
 /**

data/ext/common/FileDescriptor.h

@@ -26,20 +26,25 @@
 #define _PASSENGER_FILE_DESCRIPTOR_H_
 
 #include <boost/shared_ptr.hpp>
+#include <boost/make_shared.hpp>
 #include <oxt/system_calls.hpp>
 
+#include <utility>
 #include <unistd.h>
 #include <cerrno>
 
-#include "MessageChannel.h"
-#include "Exceptions.h"
+#include <Exceptions.h>
 
 namespace Passenger {
 
+using namespace std;
 using namespace boost;
 using namespace oxt;
 
 
+void safelyClose(int fd);
+
+
 /**
  * Wrapper class around a file descriptor integer, for RAII behavior.
  *
@@ -71,17 +76,22 @@ private:
 			}
 		}
 		
-		void close() {
+		void close(bool checkErrors = true) {
 			if (fd >= 0) {
 				this_thread::disable_syscall_interruption dsi;
 				int theFd = fd;
 				fd = -1;
-				if (syscalls::close(theFd) == -1 && errno != ENOTCONN) {
-					int e = errno;
-					throw SystemException("Cannot close file descriptor", e);
+				if (checkErrors) {
+					safelyClose(theFd);
+				} else {
+					syscalls::close(fd);
 				}
 			}
 		}
+		
+		void detach() {
+			fd = -1;
+		}
 	};
 
 	/** Shared pointer for reference counting on this file descriptor */
@@ -112,7 +122,7 @@ public:
 			 *    }
 			 */
 			int e = errno;
-			data.reset(new SharedData(fd));
+			data = make_shared<SharedData>(fd);
 			errno = e;
 		}
 	}
@@ -122,14 +132,37 @@ public:
 	 * nothing will happen. If there are multiple copies of this FileDescriptor
 	 * then the underlying file descriptor will be closed for every one of them.
 	 *
+	 * @params checkErrors Whether a SystemException should be thrown in case
+	 *                     closing the file descriptor fails. If false, errors
+	 *                     are silently ignored.
 	 * @throws SystemException Something went wrong while closing
-	 *                         the file descriptor.
+	 *                         the file descriptor. Only thrown if
+	 *                         checkErrors is true.
+	 * @post *this == -1
+	 */
+	void close(bool checkErrors = true) {
+		if (data != NULL) {
+			data->close(checkErrors);
+			data.reset();
+		}
+	}
+	
+	/**
+	 * Detach from the underlying file descriptor without closing it.
+	 * This FileDescriptor and all copies will no longer affect the
+	 * underlying file descriptors.
+	 *
+	 * @return The underlying file descriptor, or -1 if already closed.
 	 * @post *this == -1
 	 */
-	void close() {
+	int detach() {
 		if (data != NULL) {
-			data->close();
+			int fd = data->fd;
+			data->detach();
 			data.reset();
+			return fd;
+		} else {
+			return -1;
 		}
 	}
 	
@@ -159,7 +192,7 @@ public:
 		 */
 		int e = errno;
 		if (fd >= 0) {
-			data.reset(new SharedData(fd));
+			data = make_shared<SharedData>(fd);
 		} else {
 			data.reset();
 		}
@@ -185,6 +218,33 @@ public:
 	}
 };
 
+/**
+ * A structure containing two FileDescriptor objects. Behaves like a pair
+ * and like a two-element array.
+ */
+class FileDescriptorPair: public pair<FileDescriptor, FileDescriptor> {
+public:
+	FileDescriptorPair() { }
+	
+	FileDescriptorPair(const FileDescriptor &a, const FileDescriptor &b)
+		: pair<FileDescriptor, FileDescriptor>(a, b)
+		{ }
+	
+	FileDescriptor &operator[](int index) {
+		if (index == 0) {
+			return first;
+		} else if (index == 1) {
+			return second;
+		} else {
+			throw ArgumentException("Index must be either 0 of 1");
+		}
+	}
+};
+
+// Convenience aliases.
+typedef FileDescriptorPair Pipe;
+typedef FileDescriptorPair SocketPair;
+
 /**
  * A synchronization mechanism that's implemented with file descriptors,
  * and as such can be used in combination with select() and friends.
@@ -216,7 +276,11 @@ public:
 	}
 	
 	void notify() {
-		MessageChannel(writer).writeRaw("x", 1);
+		ssize_t ret = syscalls::write(writer, "x", 1);
+		if (ret == -1 && errno != EAGAIN) {
+			int e = errno;
+			throw SystemException("Cannot write notification data", e);
+		}
 	}
 	
 	int fd() const {