passenger 3.0.0 → 3.0.1

data/ext/common/LoggingAgent/LoggingServer.h

@@ -67,7 +67,7 @@ using namespace oxt;
 class LoggingServer: public EventedMessageServer {
 private:
 	static const int MAX_LOG_SINK_CACHE_SIZE = 512;
-	static const int GARBAGE_COLLECTION_TIMEOUT = 1.25 * 60 * 60;  // 1 hour 15 minutes
+	static const int GARBAGE_COLLECTION_TIMEOUT = (int) (1.25 * 60 * 60);  // 1 hour 15 minutes
 	
 	struct LogSink;
 	typedef shared_ptr<LogSink> LogSinkPtr;
@@ -195,7 +195,7 @@ private:
 		virtual void flush() {
 			if (bufferSize > 0) {
 				lastFlushed = ev_now(server->getLoop());
-				MessageChannel(fd).writeRaw(StaticString(buffer, bufferSize));
+				writeExact(fd, buffer, bufferSize);
 				bufferSize = 0;
 				notifyChanges();
 			}

data/ext/common/LoggingAgent/RemoteSender.h

@@ -80,7 +80,20 @@ private:
 		string responseBody;
 		
 		void resetConnection() {
-			curl_easy_reset(curl);
+			if (curl != NULL) {
+				#ifdef HAS_CURL_EASY_RESET
+					curl_easy_reset(curl);
+				#else
+					curl_easy_cleanup(curl);
+					curl = NULL;
+				#endif
+			}
+			if (curl == NULL) {
+				curl = curl_easy_init();
+				if (curl == NULL) {
+					throw IOException("Unable to create a CURL handle");
+				}
+			}
 			curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, lastErrorMessage);
 			curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
 			curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curlDataReceived);
@@ -117,11 +130,6 @@ private:
 			this->port = port;
 			certificate = cert;
 			
-			curl = curl_easy_init();
-			if (curl == NULL) {
-				throw IOException("Unable to create a CURL handle");
-			}
-			
 			hostHeader = "Host: " + hostName;
 			headers = NULL;
 			headers = curl_slist_append(headers, hostHeader.c_str());
@@ -129,6 +137,7 @@ private:
 				throw IOException("Unable to create a CURL linked list");
 			}
 			
+			curl = NULL;
 			resetConnection();
 		}
 		

data/ext/common/MessageChannel.h

@@ -40,6 +40,7 @@
 #include <errno.h>
 #include <unistd.h>
 #include <cstdarg>
+#include <cmath>
 #if !APR_HAVE_IOVEC
 	// We don't want apr_want.h to redefine 'struct iovec'.
 	// http://groups.google.com/group/phusion-passenger/browse_thread/thread/7e162f60df212e9c
@@ -51,12 +52,14 @@
 #include "Exceptions.h"
 #include "Utils/Timer.h"
 #include "Utils/MemZeroGuard.h"
+#include "Utils/IOUtils.h"
 
 namespace Passenger {
 
 using namespace std;
 using namespace oxt;
 
+
 /**
  * Convenience class for I/O operations on file descriptors.
  *
@@ -208,7 +211,7 @@ public:
 			data.append(1, DELIMITER);
 		}
 		
-		writeRaw(data);
+		writeExact(fd, data);
 	}
 	
 	/**
@@ -295,7 +298,7 @@ public:
 	 */
 	void writeUint32(unsigned int value) {
 		uint32_t l = htonl(value);
-		writeRaw((const char *) &l, sizeof(uint32_t));
+		writeExact(fd, &l, sizeof(uint32_t));
 	}
 	
 	/**
@@ -330,52 +333,7 @@ public:
 	 */
 	void writeScalar(const char *data, unsigned int size) {
 		writeUint32(size);
-		writeRaw(data, size);
-	}
-	
-	/**
-	 * Send a block of data over the underlying file descriptor.
-	 * This method blocks until everything is sent.
-	 *
-	 * @note Security guarantee: this method will not copy the data in memory,
-	 *       so it's safe to use this method to write passwords to the underlying
-	 *       file descriptor.
-	 *
-	 * @param data The data to send.
-	 * @param size The number of bytes in <tt>data</tt>.
-	 * @pre <tt>data != NULL</tt>
-	 * @throws SystemException An error occured while writing the data to the file descriptor.
-	 * @throws boost::thread_interrupted
-	 * @see readRaw()
-	 */
-	void writeRaw(const char *data, unsigned int size) {
-		ssize_t ret;
-		unsigned int written = 0;
-		do {
-			ret = syscalls::write(fd, data + written, size - written);
-			if (ret == -1) {
-				throw SystemException("write() failed", errno);
-			} else {
-				written += ret;
-			}
-		} while (written < size);
-	}
-	
-	/**
-	 * Send a block of data over the underlying file descriptor.
-	 * This method blocks until everything is sent.
-	 *
-	 * @note Security guarantee: this method will not copy the data in memory,
-	 *       so it's safe to use this method to write passwords to the underlying
-	 *       file descriptor.
-	 *
-	 * @param data The data to send.
-	 * @pre <tt>data != NULL</tt>
-	 * @throws SystemException An error occured while writing the data to the file descriptor.
-	 * @throws boost::thread_interrupted
-	 */
-	void writeRaw(const string &data) {
-		writeRaw(data.c_str(), data.size());
+		writeExact(fd, data, size);
 	}
 	
 	/**
@@ -612,63 +570,21 @@ public:
 	 * @throws TimeoutException Unable to read <tt>size</tt> bytes of data within
 	 *                          <tt>timeout</tt> milliseconds.
 	 * @throws boost::thread_interrupted
-	 * @see writeRaw()
 	 */
 	bool readRaw(void *buf, unsigned int size, unsigned long long *timeout = NULL) {
-		ssize_t ret;
-		unsigned int alreadyRead = 0;
-		
-		while (alreadyRead < size) {
-			if (timeout != NULL && !waitUntilReadable(timeout)) {
-				throw TimeoutException("Cannot read enough data within the specified timeout.");
-			}
-			ret = syscalls::read(fd, (char *) buf + alreadyRead, size - alreadyRead);
-			if (ret == -1) {
-				throw SystemException("read() failed", errno);
-			} else if (ret == 0) {
-				return false;
-			} else {
-				alreadyRead += ret;
+		if (timeout != NULL) {
+			unsigned long long t = *timeout * 1000;
+			unsigned int ret;
+			try {
+				ret = Passenger::readExact(fd, buf, size, &t);
+				*timeout = llroundl((long double) t / 1000);
+				return ret == size;
+			} catch (...) {
+				*timeout = llroundl((long double) t / 1000);
+				throw;
 			}
-		}
-		return true;
-	}
-	
-	/**
-	 * Waits at most <tt>*timeout</tt> milliseconds for the file descriptor to become readable.
-	 * Returns true if it become readable within the timeout, false if the timeout expired.
-	 *
-	 * <tt>*timeout</tt> may be 0, in which case this method will check whether the file
-	 * descriptor is readable, and immediately returns without waiting.
-	 *
-	 * If no exception is thrown, this method deducts the number of milliseconds that has
-	 * passed from <tt>*timeout</tt>.
-	 *
-	 * @throws SystemException
-	 * @throws boost::thread_interrupted
-	 */
-	bool waitUntilReadable(unsigned long long *timeout) {
-		fd_set fds;
-		struct timeval tv;
-		int ret;
-		
-		FD_ZERO(&fds);
-		FD_SET(fd, &fds);
-		tv.tv_sec  = *timeout / 1000;
-		tv.tv_usec = *timeout % 1000 * 1000;
-		
-		Timer timer;
-		ret = syscalls::select(fd + 1, &fds, NULL, NULL, &tv);
-		if (ret == -1) {
-			throw SystemException("select() failed", errno);
 		} else {
-			unsigned long long elapsed = timer.elapsed();
-			if (elapsed > *timeout) {
-				*timeout = 0;
-			} else {
-				*timeout -= elapsed;
-			}
-			return ret != 0;
+			return Passenger::readExact(fd, buf, size) == size;
 		}
 	}
 	

data/ext/common/PoolOptions.h

@@ -437,6 +437,7 @@ struct PoolOptions {
 		if (copy.environmentVariables != NULL) {
 			copy.environmentVariables->getItems(); // Prefetch items now while we still can.
 		}
+		copy.log.reset();
 		return copy;
 	}
 	

data/ext/common/ResourceLocator.h

@@ -26,59 +26,109 @@
 #define _PASSENGER_RESOURCE_LOCATOR_H_
 
 #include <string>
-#include "Utils.h"
+#include <IniFile.h>
+#include <Exceptions.h>
+#include <Utils.h>
 
 namespace Passenger {
 
+using namespace boost;
+
+
+/**
+ * Locates various Phusion Passenger resources on the filesystem.
+ */
 class ResourceLocator {
 private:
-	string root;
-	bool nativelyPackaged;
+	string agentsDir;
+	string helperScriptsDir;
+	string resourcesDir;
+	string docDir;
+	string rubyLibDir;
+	string compilableSourceDir;
+	string apache2Module;
 	
-public:
-	ResourceLocator(const string &passengerRoot) {
-		root = passengerRoot;
-		nativelyPackaged = !fileExists(root + "/Rakefile") ||
-			!fileExists(root + "/DEVELOPERS.TXT");
+	string getOption(const string &file, const IniFileSectionPtr &section, const string &key) const {
+		if (section->hasKey(key)) {
+			return section->get(key);
+		} else {
+			throw RuntimeException("Option '" + key + "' missing in file " + file);
+		}
 	}
 	
-	string getSourceRoot() const {
-		if (nativelyPackaged) {
-			return "/usr/lib/phusion-passenger/source";
+public:
+	ResourceLocator(const string &rootOrFile) {
+		if (getFileType(rootOrFile) == FT_DIRECTORY) {
+			string root = rootOrFile;
+			bool nativelyPackaged = !fileExists(root + "/Rakefile") ||
+				!fileExists(root + "/DEVELOPERS.TXT");
+			
+			if (nativelyPackaged) {
+				agentsDir           = "/usr/lib/phusion-passenger/agents";
+				helperScriptsDir    = "/usr/share/phusion-passenger/helper-scripts";
+				resourcesDir        = "/usr/share/phusion-passenger";
+				docDir              = "/usr/share/doc/phusion-passenger";
+				rubyLibDir          = "";
+				compilableSourceDir = "/usr/share/phusion-passenger/compilable-source";
+				apache2Module       = "/usr/lib/apache2/modules/mod_passenger.so";
+			} else {
+				agentsDir           = root + "/agents";
+				helperScriptsDir    = root + "/helper-scripts";
+				resourcesDir        = root + "/resources";
+				docDir              = root + "/doc";
+				rubyLibDir          = root + "/lib";
+				compilableSourceDir = root;
+				apache2Module       = root + "ext/apache2/mod_passenger.so";
+			}
+			
 		} else {
-			return root;
+			string file = rootOrFile;
+			IniFileSectionPtr options = IniFile(file).section("locations");
+			agentsDir           = getOption(file, options, "agents");
+			helperScriptsDir    = getOption(file, options, "helper_scripts");
+			resourcesDir        = getOption(file, options, "resources");
+			docDir              = getOption(file, options, "doc");
+			rubyLibDir          = getOption(file, options, "rubylib");
+			compilableSourceDir = getOption(file, options, "compilable_source");
+			apache2Module       = getOption(file, options, "apache2_module");
 		}
 	}
 	
 	string getAgentsDir() const {
-		if (nativelyPackaged) {
-			return "/usr/lib/phusion-passenger/agents";
-		} else {
-			return root + "/agents";
-		}
+		return agentsDir;
 	}
 	
 	string getHelperScriptsDir() const {
-		if (nativelyPackaged) {
-			return "/usr/share/phusion-passenger/helper-scripts";
-		} else {
-			return root + "/helper-scripts";
-		}
+		return helperScriptsDir;
 	}
 	
 	string getSpawnServerFilename() const {
 		return getHelperScriptsDir() + "/passenger-spawn-server";
 	}
 	
-	string getCertificatesDir() const {
-		if (nativelyPackaged) {
-			return "/usr/share/phusion-passenger/certificates";
-		} else {
-			return root + "/misc";
-		}
+	string getResourcesDir() const {
+		return resourcesDir;
+	}
+	
+	string getDocDir() const {
+		return docDir;
+	}
+	
+	// Can be empty.
+	string getRubyLibDir() const {
+		return rubyLibDir;
+	}
+	
+	string getCompilableSourceDir() const {
+		return compilableSourceDir;
+	}
+	
+	string getApache2ModuleFilename() const {
+		return apache2Module;
 	}
 };
 
+
 }
 
 #endif /* _PASSENGER_RESOURCE_LOCATOR_H_ */

data/ext/common/SafeLibev.h

@@ -0,0 +1,149 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (c) 2010 Phusion
+ *
+ *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *  THE SOFTWARE.
+ */
+#ifndef _PASSENGER_SAFE_LIBEV_H_
+#define _PASSENGER_SAFE_LIBEV_H_
+
+#include <ev++.h>
+#include <vector>
+#include <boost/thread.hpp>
+#include <boost/function.hpp>
+#include <boost/bind.hpp>
+
+namespace Passenger {
+
+using namespace std;
+using namespace boost;
+
+
+/**
+ * Class for thread-safely using libev.
+ */
+class SafeLibev {
+private:
+	typedef function<void ()> Callback;
+	
+	struct ev_loop *loop;
+	pthread_t loopThread;
+	ev_async async;
+	
+	boost::mutex syncher;
+	condition_variable cond;
+	vector<Callback> commands;
+	
+	static void asyncHandler(EV_P_ ev_async *w, int revents) {
+		SafeLibev *self = (SafeLibev *) w->data;
+		unique_lock<boost::mutex> l(self->syncher);
+		vector<Callback> commands = self->commands;
+		self->commands.clear();
+		l.unlock();
+		
+		vector<Callback>::const_iterator it, end = commands.end();
+		for (it = commands.begin(); it != commands.end(); it++) {
+			(*it)();
+		}
+	}
+	
+	template<typename Watcher>
+	void startWatcherAndNotify(Watcher *watcher, bool *done) {
+		watcher->set(loop);
+		watcher->start();
+		unique_lock<boost::mutex> l(syncher);
+		*done = true;
+		cond.notify_all();
+	}
+	
+	template<typename Watcher>
+	void stopWatcherAndNotify(Watcher *watcher, bool *done) {
+		watcher->stop();
+		unique_lock<boost::mutex> l(syncher);
+		*done = true;
+		cond.notify_all();
+	}
+	
+public:
+	SafeLibev(struct ev_loop *loop) {
+		this->loop = loop;
+		loopThread = pthread_self();
+		ev_async_init(&async, asyncHandler);
+		async.data = this;
+		ev_async_start(loop, &async);
+	}
+	
+	~SafeLibev() {
+		ev_async_stop(loop, &async);
+	}
+	
+	struct ev_loop *getLoop() const {
+		return loop;
+	}
+	
+	template<typename Watcher>
+	void start(Watcher &watcher) {
+		if (pthread_equal(pthread_self(), loopThread)) {
+			watcher.set(loop);
+			watcher.start();
+		} else {
+			unique_lock<boost::mutex> l(syncher);
+			bool done = false;
+			commands.push_back(boost::bind(&SafeLibev::startWatcherAndNotify<Watcher>,
+				this, &watcher, &done));
+			ev_async_send(loop, &async);
+			while (!done) {
+				cond.wait(l);
+			}
+		}
+	}
+	
+	template<typename Watcher>
+	void stop(Watcher &watcher) {
+		if (pthread_equal(pthread_self(), loopThread)) {
+			watcher.stop();
+		} else {
+			unique_lock<boost::mutex> l(syncher);
+			bool done = false;
+			commands.push_back(boost::bind(&SafeLibev::stopWatcherAndNotify<Watcher>,
+				this, &watcher, &done));
+			ev_async_send(loop, &async);
+			while (!done) {
+				cond.wait(l);
+			}
+		}
+	}
+	
+	void run(const Callback &callback) {
+		if (pthread_equal(pthread_self(), loopThread)) {
+			callback();
+		} else {
+			unique_lock<boost::mutex> l(syncher);
+			commands.push_back(callback);
+			ev_async_send(loop, &async);
+		}
+	}
+};
+
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_SAFE_LIBEV_H_ */