passenger 2.2.15 → 3.0.0.pre1

data/ext/common/Process.h

@@ -0,0 +1,255 @@
+/*
+ *  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_PROCESS_H_
+#define _PASSENGER_PROCESS_H_
+
+#include <boost/shared_ptr.hpp>
+#include <boost/function.hpp>
+#include <oxt/system_calls.hpp>
+#include <oxt/backtrace.hpp>
+#include <string>
+#include <map>
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include "Session.h"
+#include "MessageChannel.h"
+#include "Exceptions.h"
+#include "Logging.h"
+#include "Utils.h"
+
+namespace Passenger {
+
+using namespace std;
+using namespace boost;
+
+/**
+ * Represents a single application process, as spawned by SpawnManager
+ * or by ApplicationPool::Interface::get().
+ *
+ * @ingroup Support
+ */
+class Process {
+public:
+	struct SocketInfo {
+		string address;
+		string type;
+		
+		SocketInfo() {}
+		
+		SocketInfo(const string &address, const string &type) {
+			this->address = address;
+			this->type    = type;
+		}
+	};
+	
+	typedef map<string, SocketInfo> SocketInfoMap;
+	
+private:
+	string appRoot;
+	pid_t pid;
+	int ownerPipe;
+	string detachKey;
+	string connectPassword;
+	string gupid;
+	SocketInfoMap serverSockets;
+	SocketInfo *mainServerSocket;
+	function<void ()> destructionCallback;
+	
+public:
+	/**
+	 * Construct a new Process object.
+	 *
+	 * @param appRoot The application root of an application.
+	 *             This must be a valid directory, but the path does not have to be absolute.
+	 * @param pid The process ID of this application process.
+	 * @param ownerPipe The owner pipe of this application process.
+	 * @param serverSockets All the server sockets that this process listens on.
+	 *                      There must a server socket with the name 'main'.
+	 * @param detachKey A detach key. Used by the ApplicationPool algorithm.
+	 * @param connectPassword The password to use when connecting to this process.
+	 *                        Must be valid ASCII.
+	 * @param gupid A string which uniquely identifies this process.
+	 * @param destructionCallback A callback to be called when this Process is destroyed.
+	 * @throws ArgumentException If serverSockets has no socket named 'main'.
+	 */
+	Process(const string &appRoot, pid_t pid, int ownerPipe, const SocketInfoMap &serverSockets,
+	        const string &detachKey, const string &connectPassword, const string &gupid,
+	        const function<void ()> &destructionCallback = function<void ()>())
+	{
+		this->appRoot         = appRoot;
+		this->pid             = pid;
+		this->ownerPipe       = ownerPipe;
+		this->serverSockets   = serverSockets;
+		this->detachKey       = detachKey;
+		this->connectPassword = connectPassword;
+		this->gupid           = gupid;
+		this->destructionCallback = destructionCallback;
+		if (serverSockets.find("main") == serverSockets.end()) {
+			TRACE_POINT();
+			throw ArgumentException("There must be a server socket named 'main'.");
+		}
+		mainServerSocket = &this->serverSockets["main"];
+		P_TRACE(3, "Application process " << pid << " (" << this << "): created.");
+	}
+	
+	virtual ~Process() {
+		TRACE_POINT();
+		SocketInfoMap::const_iterator it;
+		int ret;
+		
+		if (ownerPipe != -1) {
+			do {
+				ret = close(ownerPipe);
+			} while (ret == -1 && errno == EINTR);
+		}
+		for (it = serverSockets.begin(); it != serverSockets.end(); it++) {
+			const SocketInfo &info = it->second;
+			if (info.type == "unix") {
+				do {
+					ret = unlink(info.address.c_str());
+				} while (ret == -1 && errno == EINTR);
+			}
+		}
+		P_TRACE(3, "Application process " << pid << " (" << this << "): destroyed.");
+		
+		if (destructionCallback) {
+			destructionCallback();
+		}
+	}
+	
+	/**
+	 * Returns the application root for this application process. See
+	 * the constructor for information about the application root.
+	 */
+	string getAppRoot() const {
+		return appRoot;
+	}
+	
+	/**
+	 * Returns the process ID of this application process.
+	 */
+	pid_t getPid() const {
+		return pid;
+	}
+	
+	/**
+	 * Returns this process's detach key.
+	 */
+	string getDetachKey() const {
+		return detachKey;
+	}
+	
+	/**
+	 * Returns this process's connect password. This password is
+	 * guaranteed to be valid ASCII.
+	 */
+	string getConnectPassword() const {
+		return connectPassword;
+	}
+	
+	/**
+	 * Returns this process's gupid. This is like a PID, but does not rotate
+	 * and is even unique over multiple servers.
+	 */
+	string getGupid() const {
+		return gupid;
+	}
+	
+	/**
+	 * Returns a map containing all server sockets that this process
+	 * listens on.
+	 */
+	const SocketInfoMap *getServerSockets() const {
+		return &serverSockets;
+	}
+	
+	/**
+	 * Request a new session from this application process by connecting to its
+	 * main server socket. This session represents the life time of a single
+	 * request/response pair, and can be used to send the request data to the
+	 * application process, as well as receiving the response data.
+	 *
+	 * The use of connect() is demonstrated in the following example.
+	 * @code
+	 *   // Request a new session from the process.
+	 *   SessionPtr session = process->newSession(...);
+	 *   
+	 *   // Send the request headers and request body data.
+	 *   session->sendHeaders(...);
+	 *   session->sendBodyBlock(...);
+	 *   // Done sending data, so we close the writer channel.
+	 *   session->shutdownWriter();
+	 *
+	 *   // Now read the HTTP response.
+	 *   string responseData = readAllDataFromSocket(session->getReader());
+	 *   // Done reading data, so we close the reader channel.
+	 *   session->shutdownReader();
+	 *
+	 *   // This session has now finished, so we close the session by resetting
+	 *   // the smart pointer to NULL (thereby destroying the Session object).
+	 *   session.reset();
+	 *
+	 *   // We can connect to a Process multiple times. Just make sure
+	 *   // the previous session is closed.
+	 *   session = process->newSession(...);
+	 * @endcode
+	 *
+	 * You <b>must</b> close a session when you no longer need it. If you
+	 * call connect() without having properly closed a previous session,
+	 * you might cause a deadlock because the application process may be
+	 * waiting for you to close the previous session.
+	 *
+	 * @param closeCallback A function which will be called when the session has been closed.
+	 * @param initiateNow Whether the session should be initiated immediately.
+	 *                    If set to false then you must call <tt>initiate()</tt> on
+	 *                    the session before it's usable.
+	 * @return A smart pointer to a Session object, which represents the created session.
+	 * @post result->initiated() == initiateNow
+	 * @throws SystemException Something went wrong during session initiation.
+	 * @throws IOException Something went wrong during session initiation.
+	 * @throws boost::thread_interrupted
+	 */
+	SessionPtr newSession(const StandardSession::CloseCallback &closeCallback = StandardSession::CloseCallback(),
+	                      bool initiateNow = true)
+	{
+		SessionPtr session(new StandardSession(pid, closeCallback,
+			mainServerSocket->type, mainServerSocket->address,
+			detachKey, connectPassword, gupid));
+		if (initiateNow) {
+			session->initiate();
+		}
+		return session;
+	}
+};
+
+/** Convenient alias for Process smart pointer. */
+typedef shared_ptr<Process> ProcessPtr;
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_PROCESS_H_ */

data/ext/common/RandomGenerator.h

@@ -0,0 +1,160 @@
+/*
+ *  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_RANDOM_GENERATOR_H_
+#define _PASSENGER_RANDOM_GENERATOR_H_
+
+#include <string>
+
+#include <boost/noncopyable.hpp>
+#include <boost/shared_ptr.hpp>
+#include <oxt/system_calls.hpp>
+
+#include "StaticString.h"
+#include "Exceptions.h"
+#include "Utils/StrIntUtils.h"
+
+
+/**
+ * A random 
+ */
+namespace Passenger {
+
+using namespace std;
+using namespace boost;
+using namespace oxt;
+
+/**
+ * A random data generator. Data is generated using /dev/urandom, and
+ * is cryptographically secure. Unlike rand() and friends,
+ * RandomGenerator does not require seeding.
+ *
+ * The reason why RandomGenerator isn't a singleton is because opening
+ * /dev/urandom is *very* slow on Mac OS X and OpenBSD. Each object of
+ * this class caches the /dev/urandom file handle.
+ *
+ * This class is thread-safe as long as there are no concurrent
+ * calls to reopen() or close().
+ */
+class RandomGenerator: public boost::noncopyable {
+private:
+	FILE *handle;
+	
+public:
+	RandomGenerator(bool open = true) {
+		handle = NULL;
+		if (open) {
+			reopen();
+		}
+	}
+	
+	~RandomGenerator() {
+		this_thread::disable_syscall_interruption dsi;
+		close();
+	}
+	
+	void reopen() {
+		close();
+		handle = syscalls::fopen("/dev/urandom", "r");
+		if (handle == NULL) {
+			throw FileSystemException("Cannot open /dev/urandom",
+				errno, "/dev/urandom");
+		}
+	}
+	
+	void close() {
+		if (handle != NULL) {
+			syscalls::fclose(handle);
+			handle = NULL;
+		}
+	}
+	
+	StaticString generateBytes(void *buf, unsigned int size) {
+		size_t ret = syscalls::fread(buf, 1, size, handle);
+		if (ret != size) {
+			throw IOException("Cannot read sufficient data from /dev/urandom");
+		}
+		return StaticString((const char *) buf, size);
+	}
+	
+	string generateByteString(unsigned int size) {
+		char buf[size];
+		generateBytes(buf, size);
+		return string(buf, size);
+	}
+	
+	string generateHexString(unsigned int size) {
+		char buf[size];
+		generateBytes(buf, size);
+		return toHex(StaticString(buf, size));
+	}
+	
+	/**
+	 * Generates a random string of <em>size</em> bytes which is also
+	 * valid ASCII. The result consists only of the characters A-Z,
+	 * a-z and 0-9, and therefore the total number of possibilities
+	 * given a size of N is 62**N. However not every character has an
+	 * equal chance of being chosen: a-i have 5/256 chance of being
+	 * chosen, while other characters have 4/256 chance of being chosen.
+	 * Therefore, to match the entropy of a random binary string of
+	 * size N, one should choose a <em>size</em> which yields slightly
+	 * more possibilities than 2**N.
+	 */
+	string generateAsciiString(unsigned int size) {
+		char buf[size];
+		generateAsciiString(buf, size);
+		return string(buf, size);
+	}
+	
+	void generateAsciiString(char *_buf, unsigned int size) {
+		static const char chars[] = {
+			'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+			'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+			'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+			'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+			'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'
+		};
+		unsigned char *buf = (unsigned char *) _buf;
+		generateBytes(buf, size);
+		for (unsigned int i = 0; i < size; i++) {
+			buf[i] = chars[buf[i] % sizeof(chars)];
+		}
+	}
+	
+	int generateInt() {
+		int ret;
+		generateBytes(&ret, sizeof(ret));
+		return ret;
+	}
+	
+	unsigned int generateUint() {
+		return (unsigned int) generateInt();
+	}
+};
+
+typedef shared_ptr<RandomGenerator> RandomGeneratorPtr;
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_RANDOM_GENERATOR_H_ */

data/ext/common/ResourceLocator.h

@@ -0,0 +1,84 @@
+/*
+ *  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_RESOURCE_LOCATOR_H_
+#define _PASSENGER_RESOURCE_LOCATOR_H_
+
+#include <string>
+#include "Utils.h"
+
+namespace Passenger {
+
+class ResourceLocator {
+private:
+	string root;
+	bool nativelyPackaged;
+	
+public:
+	ResourceLocator(const string &passengerRoot) {
+		root = passengerRoot;
+		nativelyPackaged = !fileExists(root + "/Rakefile") ||
+			!fileExists(root + "/DEVELOPERS.TXT");
+	}
+	
+	string getSourceRoot() const {
+		if (nativelyPackaged) {
+			return "/usr/lib/phusion-passenger/source";
+		} else {
+			return root;
+		}
+	}
+	
+	string getAgentsDir() const {
+		if (nativelyPackaged) {
+			return "/usr/lib/phusion-passenger/agents";
+		} else {
+			return root + "/agents";
+		}
+	}
+	
+	string getHelperScriptsDir() const {
+		if (nativelyPackaged) {
+			return "/usr/share/phusion-passenger/helper-scripts";
+		} else {
+			return root + "/helper-scripts";
+		}
+	}
+	
+	string getSpawnServerFilename() const {
+		return getHelperScriptsDir() + "/passenger-spawn-server";
+	}
+	
+	string getCertificatesDir() const {
+		if (nativelyPackaged) {
+			return "/usr/share/phusion-passenger/certificates";
+		} else {
+			return root + "/misc/certificates";
+		}
+	}
+};
+
+}
+
+#endif /* _PASSENGER_RESOURCE_LOCATOR_H_ */