passenger 2.0.6 → 2.1.2

data/ext/apache2/Bucket.cpp

@@ -19,29 +19,67 @@
  */
 #include "Bucket.h"
 
+using namespace Passenger;
+
+static void bucket_destroy(void *data);
 static apr_status_t bucket_read(apr_bucket *a, const char **str, apr_size_t *len, apr_read_type_e block);
 
 static const apr_bucket_type_t apr_bucket_type_passenger_pipe = {
 	"PASSENGER_PIPE",
 	5,
 	apr_bucket_type_t::APR_BUCKET_DATA, 
-	apr_bucket_destroy_noop,
+	bucket_destroy,
 	bucket_read,
 	apr_bucket_setaside_notimpl,
 	apr_bucket_split_notimpl,
 	apr_bucket_copy_notimpl
 };
 
+struct BucketData {
+	Application::SessionPtr session;
+	apr_file_t *pipe;
+};
+
+static void
+bucket_destroy(void *data) {
+	BucketData *bucket_data = (BucketData *) data;
+	if (data != NULL) {
+		delete bucket_data;
+	}
+}
+
 static apr_status_t
 bucket_read(apr_bucket *bucket, const char **str, apr_size_t *len, apr_read_type_e block) {
 	apr_file_t *pipe;
 	char *buf;
 	apr_status_t ret;
 
-	pipe = (apr_file_t *) bucket->data;
+	BucketData *data = (BucketData *) bucket->data;
+	pipe = data->pipe;
 
 	*str = NULL;
 	*len = APR_BUCKET_BUFF_SIZE;
+	
+	if (block == APR_NONBLOCK_READ) {
+		/*
+		 * The bucket brigade that Hooks::handleRequest() passes using
+		 * ap_pass_brigade() is always passed through ap_content_length_filter,
+		 * which is a filter which attempts to read all data from the
+		 * bucket brigade and computes the Content-Length header from
+		 * that. We don't want this to happen; because suppose that the
+		 * Rails application sends back 1 GB of data, then
+		 * ap_content_length_filter will buffer this entire 1 GB of data
+		 * in memory before passing it to the HTTP client.
+		 *
+		 * ap_content_length_filter aborts and passes the bucket brigade
+		 * down the filter chain when it encounters an APR_EAGAIN, except
+		 * for the first read. So by returning APR_EAGAIN on every
+		 * non-blocking read request, we can prevent ap_content_length_filter
+		 * from buffering all data.
+		 */
+		return APR_EAGAIN;
+	}
+	
 	buf = (char *) apr_bucket_alloc(*len, bucket->list); // TODO: check for failure?
 
 	do {
@@ -50,6 +88,8 @@ bucket_read(apr_bucket *bucket, const char **str, apr_size_t *len, apr_read_type
 
 	if (ret != APR_SUCCESS && ret != APR_EOF) {
 		// ... we might want to set an error flag here ...
+		delete data;
+		bucket->data = NULL;
 		apr_bucket_free(buf);
 		return ret;
 	}
@@ -59,13 +99,21 @@ bucket_read(apr_bucket *bucket, const char **str, apr_size_t *len, apr_read_type
 	 */
 	if (*len > 0) {
 		apr_bucket_heap *h;
+		
+		*str = buf;
+		bucket->data = NULL;
+		
 		/* Change the current bucket to refer to what we read */
 		bucket = apr_bucket_heap_make(bucket, buf, *len, apr_bucket_free);
 		h = (apr_bucket_heap *) bucket->data;
 		h->alloc_len = APR_BUCKET_BUFF_SIZE; /* note the real buffer size */
-		*str = buf;
-		APR_BUCKET_INSERT_AFTER(bucket, passenger_bucket_create(pipe, bucket->list));
+		APR_BUCKET_INSERT_AFTER(bucket, passenger_bucket_create(
+			data->session, pipe, bucket->list));
+		delete data;
 	} else {
+		delete data;
+		bucket->data = NULL;
+		
 		apr_bucket_free(buf);
 		bucket = apr_bucket_immortal_make(bucket, "", 0);
 		*str = (const char *) bucket->data;
@@ -76,23 +124,27 @@ bucket_read(apr_bucket *bucket, const char **str, apr_size_t *len, apr_read_type
 	return APR_SUCCESS;
 }
 
-apr_bucket *
-passenger_bucket_make(apr_bucket *bucket, apr_file_t *pipe) {
+static apr_bucket *
+passenger_bucket_make(apr_bucket *bucket, Application::SessionPtr session, apr_file_t *pipe) {
+	BucketData *data = new BucketData();
+	data->session  = session;
+	data->pipe     = pipe;
+	
 	bucket->type   = &apr_bucket_type_passenger_pipe;
 	bucket->length = (apr_size_t)(-1);
 	bucket->start  = -1;
-	bucket->data   = pipe;
+	bucket->data   = data;
 	return bucket;
 }
 
 apr_bucket *
-passenger_bucket_create(apr_file_t *pipe, apr_bucket_alloc_t *list) {
+passenger_bucket_create(Application::SessionPtr session, apr_file_t *pipe, apr_bucket_alloc_t *list) {
 	apr_bucket *bucket;
 	
 	bucket = (apr_bucket *) apr_bucket_alloc(sizeof(*bucket), list);
 	APR_BUCKET_INIT(bucket);
 	bucket->free = apr_bucket_free;
 	bucket->list = list;
-	return passenger_bucket_make(bucket, pipe);
+	return passenger_bucket_make(bucket, session, pipe);
 }
 

data/ext/apache2/Bucket.h

@@ -21,18 +21,25 @@
 #define _PASSENGER_BUCKET_H_
 
 /**
- * apr_bucket_pipe closes a pipe's file descriptor when it has reached end-of-stream,
- * but not when an error has occurred. That behavior conflicts with Phusion Passenger's
- * file descriptor management code.
+ * apr_bucket_pipe closes a pipe's file descriptor when it has reached
+ * end-of-stream, but not when an error has occurred. This behavior is
+ * undesirable because it can easily cause file descriptor leaks.
  *
- * passenger_bucket is like apr_bucket_pipe, but never closes the pipe's file descriptor.
- * It also ignores the APR_NONBLOCK_READ because that's known to cause strange
- * I/O problems.
+ * passenger_bucket is like apr_bucket_pipe, but it also holds a reference to
+ * a Session. When a read error has occured or when end-of-stream has been
+ * reached, the Session will be dereferenced, so that the underlying file
+ * descriptor is closed.
+ *
+ * passenger_bucket also ignores the APR_NONBLOCK_READ flag because that's
+ * known to cause strange I/O problems.
  */
 
-#include "apr_buckets.h"
+#include <apr_buckets.h>
+#include "Application.h"
 
-apr_bucket *passenger_bucket_create(apr_file_t *pipe, apr_bucket_alloc_t *list);
+apr_bucket *passenger_bucket_create(Passenger::Application::SessionPtr session,
+                                    apr_file_t *pipe,
+                                    apr_bucket_alloc_t *list);
 
 #endif /* _PASSENGER_BUCKET_H_ */
 

data/ext/apache2/CachedFileStat.cpp

@@ -0,0 +1,114 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (C) 2009  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.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include "CachedFileStat.h"
+
+#include <map>
+#include <list>
+
+#include <boost/shared_ptr.hpp>
+#include <boost/thread.hpp>
+
+using namespace std;
+using namespace boost;
+using namespace Passenger;
+
+// CachedMultiFileStat is written in C++, with a C wrapper API around it.
+// I'm not going to reinvent my own linked list and hash table in C when I
+// can just use the STL.
+struct CachedMultiFileStat {
+	struct Item {
+		string filename;
+		CachedFileStat cstat;
+		
+		Item(const string &filename)
+			: cstat(filename)
+		{
+			this->filename = filename;
+		}
+	};
+	
+	typedef shared_ptr<Item> ItemPtr;
+	typedef list<ItemPtr> ItemList;
+	typedef map<string, ItemList::iterator> ItemMap;
+	
+	unsigned int maxSize;
+	ItemList items;
+	ItemMap cache;
+	boost::mutex lock;
+	
+	CachedMultiFileStat(unsigned int maxSize) {
+		this->maxSize = maxSize;
+	}
+	
+	int stat(const string &filename, struct stat *buf, unsigned int throttleRate = 0) {
+		boost::unique_lock<boost::mutex> l(lock);
+		ItemMap::iterator it(cache.find(filename));
+		ItemPtr item;
+		int ret;
+		
+		if (it == cache.end()) {
+			// Filename not in cache.
+			// If cache is full, remove the least recently used
+			// cache entry.
+			if (cache.size() == maxSize) {
+				ItemList::iterator listEnd(items.end());
+				listEnd--;
+				string filename((*listEnd)->filename);
+				items.pop_back();
+				cache.erase(filename);
+			}
+			
+			// Add to cache as most recently used.
+			item = ItemPtr(new Item(filename));
+			items.push_front(item);
+			cache[filename] = items.begin();
+		} else {
+			// Cache hit.
+			item = *it->second;
+			
+			// Mark this cache item as most recently used.
+			items.erase(it->second);
+			items.push_front(item);
+			cache[filename] = items.begin();
+		}
+		ret = item->cstat.refresh(throttleRate);
+		*buf = item->cstat.info;
+		return ret;
+	}
+};
+
+CachedMultiFileStat *
+cached_multi_file_stat_new(unsigned int max_size) {
+	return new CachedMultiFileStat(max_size);
+}
+
+void
+cached_multi_file_stat_free(CachedMultiFileStat *mstat) {
+	delete mstat;
+}
+
+int
+cached_multi_file_stat_perform(CachedMultiFileStat *mstat,
+                               const char *filename,
+                               struct stat *buf,
+                               unsigned int throttle_rate)
+{
+	return mstat->stat(filename, buf, throttle_rate);
+}

data/ext/apache2/CachedFileStat.h

@@ -0,0 +1,169 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (C) 2009  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.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef _PASSENGER_CACHED_FILE_STAT_H_
+#define _PASSENGER_CACHED_FILE_STAT_H_
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <time.h>
+
+#ifdef __cplusplus
+
+#include <errno.h>
+#include <string>
+#include <oxt/system_calls.hpp>
+
+#include "SystemTime.h"
+
+namespace Passenger {
+
+using namespace std;
+using namespace oxt;
+
+/**
+ * CachedFileStat allows one to stat() a file at a throttled rate, in order
+ * to minimize stress on the filesystem. It does this by caching the old stat
+ * data for a specified amount of time.
+ */
+class CachedFileStat {
+private:
+	/** The last return value of stat(). */
+	int last_result;
+
+	/** The errno set by the last stat() call. */
+	int last_errno;
+
+	/** The filename of the file to stat. */
+	string filename;
+
+	/** The last time a stat() was performed. */
+	time_t last_time;
+	
+	/**
+	 * Checks whether <em>interval</em> seconds have elapsed since <em>begin</em>
+	 * The current time is returned via the <tt>currentTime</tt> argument,
+	 * so that the caller doesn't have to call time() again if it needs the current
+	 * time.
+	 *
+	 * @pre begin <= time(NULL)
+	 * @return Whether <tt>interval</tt> seconds have elapsed since <tt>begin</tt>.
+	 * @throws SystemException Something went wrong while retrieving the time.
+	 * @throws boost::thread_interrupted
+	 */
+	bool expired(time_t begin, unsigned int interval, time_t &currentTime) {
+		currentTime = SystemTime::get();
+		return (unsigned int) (currentTime - begin) >= interval;
+	}
+
+public:
+	/** The cached stat info. */
+	struct stat info;
+	
+	/**
+	 * Creates a new CachedFileStat object. The file will not be
+	 * stat()ted until you call refresh().
+	 *
+	 * @param filename The file to stat.
+	 */
+	CachedFileStat(const string &filename) {
+		memset(&info, 0, sizeof(struct stat));
+		last_result = -1;
+		last_errno = 0;
+		this->filename = filename;
+		last_time = 0;
+	}
+	
+	/**
+	 * Re-stat() the file, if necessary. If <tt>throttleRate</tt> seconds have
+	 * passed since the last time stat() was called, then the file will be
+	 * re-stat()ted.
+	 *
+	 * The stat information, which may either be the result of a new stat() call
+	 * or just the old cached information, is be available in the <tt>info</tt>
+	 * member.
+	 *
+	 * @return 0 if the stat() call succeeded or if no stat() was performed,
+	 *         -1 if something went wrong while statting the file. In the latter
+	 *         case, <tt>errno</tt> will be populated with an appropriate error code.
+	 * @throws SystemException Something went wrong while retrieving the system time.
+	 * @throws boost::thread_interrupted
+	 */
+	int refresh(unsigned int throttleRate) {
+		time_t currentTime;
+		int ret;
+		
+		if (expired(last_time, throttleRate, currentTime)) {
+			ret = stat(filename.c_str(), &info);
+			if (ret == -1 && errno == EINTR) {
+				/* If the stat() call was interrupted, then don't
+				 * update any state so that the caller can call
+				 * this function again without us returning a
+				 * cached EINTR error.
+				 */
+				return -1;
+			} else {
+				last_result = ret;
+				last_errno = errno;
+				last_time = currentTime;
+				return ret;
+			}
+		} else {
+			errno = last_errno;
+			return last_result;
+		}
+	}
+};
+
+} // namespace Passenger
+
+#endif /* __cplusplus */
+
+
+#ifdef __cplusplus
+	extern "C" {
+#endif
+
+/**
+ * CachedMultiFileStat allows one to stat() files at a throttled rate, in order
+ * to minimize stress on the filesystem. It does this by caching the old stat
+ * data for a specified amount of time.
+ *
+ * Unlike CachedFileStat, which can only stat() one specific file per
+ * CachedFileStat object, CachedMultiFileStat can stat() any file. The
+ * number of cached stat() information is limited by the given cache size.
+ *
+ * This class is fully thread-safe.
+ */
+typedef struct CachedMultiFileStat CachedMultiFileStat;
+
+CachedMultiFileStat *cached_multi_file_stat_new(unsigned int max_size);
+void cached_multi_file_stat_free(CachedMultiFileStat *mstat);
+int  cached_multi_file_stat_perform(CachedMultiFileStat *mstat,
+                                    const char *filename,
+                                    struct stat *buf,
+                                    unsigned int throttle_rate);
+
+#ifdef __cplusplus
+	}
+#endif
+
+#endif /* _PASSENGER_CACHED_FILE_STAT_H_ */
+