passenger 3.0.0 → 3.0.1

data/lib/phusion_passenger/utils.rb

@@ -840,15 +840,12 @@ protected
 			return PhusionPassenger::NativeSupport.split_by_null_into_hash(data)
 		end
 	else
-		PADDING = "_"
-		NULL = "\0"
+		NULL = "\0".freeze
 		
 		def split_by_null_into_hash(data)
-			data << PADDING
-			array = data.split(NULL)
-			array.pop
-			data.slice!(data.size - 1, data.size - 1)
-			return Hash[*array]
+			args = data.split(NULL, -1)
+			args.pop
+			return Hash[*args]
 		end
 	end
 	

data/resources/mime.types

@@ -0,0 +1,73 @@
+
+types {
+    text/html                             html htm shtml;
+    text/css                              css;
+    text/xml                              xml;
+    image/gif                             gif;
+    image/jpeg                            jpeg jpg;
+    application/x-javascript              js;
+    application/atom+xml                  atom;
+    application/rss+xml                   rss;
+
+    text/mathml                           mml;
+    text/plain                            txt;
+    text/vnd.sun.j2me.app-descriptor      jad;
+    text/vnd.wap.wml                      wml;
+    text/x-component                      htc;
+
+    image/png                             png;
+    image/tiff                            tif tiff;
+    image/vnd.wap.wbmp                    wbmp;
+    image/x-icon                          ico;
+    image/x-jng                           jng;
+    image/x-ms-bmp                        bmp;
+    image/svg+xml                         svg;
+
+    application/java-archive              jar war ear;
+    application/mac-binhex40              hqx;
+    application/msword                    doc;
+    application/pdf                       pdf;
+    application/postscript                ps eps ai;
+    application/rtf                       rtf;
+    application/vnd.ms-excel              xls;
+    application/vnd.ms-powerpoint         ppt;
+    application/vnd.wap.wmlc              wmlc;
+    application/vnd.wap.xhtml+xml         xhtml;
+    application/vnd.google-earth.kml+xml  kml;
+    application/vnd.google-earth.kmz      kmz;
+    application/x-cocoa                   cco;
+    application/x-java-archive-diff       jardiff;
+    application/x-java-jnlp-file          jnlp;
+    application/x-makeself                run;
+    application/x-perl                    pl pm;
+    application/x-pilot                   prc pdb;
+    application/x-rar-compressed          rar;
+    application/x-redhat-package-manager  rpm;
+    application/x-sea                     sea;
+    application/x-shockwave-flash         swf;
+    application/x-stuffit                 sit;
+    application/x-tcl                     tcl tk;
+    application/x-x509-ca-cert            der pem crt;
+    application/x-xpinstall               xpi;
+    application/zip                       zip;
+
+    application/octet-stream              bin exe dll;
+    application/octet-stream              deb;
+    application/octet-stream              dmg;
+    application/octet-stream              eot;
+    application/octet-stream              iso img;
+    application/octet-stream              msi msp msm;
+
+    audio/midi                            mid midi kar;
+    audio/mpeg                            mp3;
+    audio/x-realaudio                     ra;
+
+    video/3gpp                            3gpp 3gp;
+    video/mpeg                            mpeg mpg;
+    video/quicktime                       mov;
+    video/x-flv                           flv;
+    video/x-mng                           mng;
+    video/x-ms-asf                        asx asf;
+    video/x-ms-wmv                        wmv;
+    video/x-msvideo                       avi;
+}

data/test/cxx/BufferedIOTest.cpp

@@ -0,0 +1,364 @@
+#include "TestSupport.h"
+#include "Utils/BufferedIO.h"
+#include "Utils/Timer.h"
+#include "Utils/IOUtils.h"
+#include <algorithm>
+
+using namespace Passenger;
+using namespace std;
+
+namespace tut {
+	struct BufferedIOTest {
+		FileDescriptor reader, writer;
+		BufferedIO io;
+		
+		string readData;
+		unsigned int counter;
+		char buf[100];
+		BufferedIO::AcceptFunction a_eof;
+		BufferedIO::AcceptFunction a_twoBytesRead;
+		
+		BufferedIOTest() {
+			Pipe p = createPipe();
+			reader = p.first;
+			writer = p.second;
+			io = BufferedIO(reader);
+			counter = 0;
+			memset(buf, 0, sizeof(buf));
+			a_eof = boost::bind(&BufferedIOTest::eof, this, _1, _2);
+			a_twoBytesRead = boost::bind(&BufferedIOTest::twoBytesRead, this, _1, _2);
+		}
+		
+		void write(const StaticString &data) {
+			::write(writer, data.c_str(), data.size());
+		}
+		
+		pair<unsigned int, bool> twoBytesRead(const char *data, unsigned int size) {
+			if (counter == 2) {
+				return make_pair(0, true);
+			} else {
+				unsigned int toRead = min(2u - counter, size);
+				readData.append(data, toRead);
+				counter += toRead;
+				return make_pair(toRead, counter == 2);
+			}
+		}
+		
+		pair<unsigned int, bool> eof(const char *data, unsigned int size) {
+			readData.append(data, size);
+			return make_pair(size, false);
+		}
+		
+		static void writeAfterSomeTime(int fd, int sleepTime, string data) {
+			syscalls::usleep(sleepTime);
+			writeExact(fd, data);
+		}
+		
+		static void closeAfterSomeTime(FileDescriptor fd, int sleepTime) {
+			syscalls::usleep(sleepTime);
+			fd.close();
+		}
+	};
+	
+	DEFINE_TEST_GROUP(BufferedIOTest);
+
+	/***** Test readUntil() *****/
+	
+	TEST_METHOD(1) {
+		// If the connection is already closed and the buffer is empty, then it returns 0.
+		writer.close();
+		ensure_equals(io.readUntil(a_eof), 0u);
+		ensure_equals(readData, "");
+		ensure_equals(io.getBuffer(), "");
+	}
+	
+	TEST_METHOD(2) {
+		// If the connection is already closed and the buffer is non-empty,
+		// then it reads from the buffer.
+		writer.close();
+		io.unread("hello world");
+		ensure_equals(io.readUntil(a_twoBytesRead), 2u);
+		ensure_equals(readData, "he");
+		ensure_equals(io.readUntil(a_eof), 9u);
+		ensure_equals(readData, "hello world");
+		ensure_equals(io.getBuffer(), "");
+	}
+	
+	TEST_METHOD(3) {
+		// If the buffer is empty then it reads from the connection.
+		write("hello world");
+		writer.close();
+		ensure_equals("(1)", io.readUntil(a_twoBytesRead), 2u);
+		ensure_equals("(2)", readData, "he");
+		ensure_equals("(5)", io.readUntil(a_eof), 9u);
+		ensure_equals("(6)", readData, "hello world");
+		ensure_equals("(7)", io.readUntil(a_eof), 0u);
+		ensure_equals("(8)", readData, "hello world");
+		ensure_equals(io.getBuffer(), "");
+	}
+	
+	TEST_METHOD(4) {
+		// If the buffer is non-empty then it reads from the
+		// buffer first, then from the connection.
+		io.unread("hel");
+		write("lo world");
+		writer.close();
+		
+		ensure_equals("(1)", io.readUntil(a_twoBytesRead), 2u);
+		ensure_equals("(2)", readData, "he");
+		counter = 0;
+		ensure_equals("(3)", io.readUntil(a_twoBytesRead), 2u);
+		ensure_equals("(4)", readData, "hell");
+		ensure_equals("(5)", io.readUntil(a_eof), 7u);
+		ensure_equals("(6)", readData, "hello world");
+		ensure_equals("(7)", io.readUntil(a_eof), 0u);
+		ensure_equals("(8)", readData, "hello world");
+		ensure_equals(io.getBuffer(), "");
+	}
+	
+	TEST_METHOD(5) {
+		// It blocks until the acceptor function says it's done or until EOF.
+		TempThread thr1(boost::bind(writeAfterSomeTime, writer, 20000, "aa"));
+		Timer timer1;
+		ensure_equals(io.readUntil(a_twoBytesRead), 2u);
+		ensure_equals(readData, "aa");
+		ensure("At least 18 msec elapsed", timer1.elapsed() >= 18);
+		ensure("At most 30 msec elapsed", timer1.elapsed() <= 30);
+		
+		TempThread thr2(boost::bind(closeAfterSomeTime, writer, 20000));
+		Timer timer2;
+		ensure_equals(io.readUntil(a_twoBytesRead), 0u);
+		ensure_equals(readData, "aa");
+		ensure("At least 18 msec elapsed", timer2.elapsed() >= 18);
+		ensure("At most 30 msec elapsed", timer2.elapsed() <= 30);
+	}
+	
+	TEST_METHOD(6) {
+		// It throws TimeoutException if it cannot read enough data
+		// within the specified timeout.
+		unsigned long long timeout = 50000;
+		io.unread("he");
+		write("llo");
+		Timer timer;
+		try {
+			io.readUntil(a_eof, &timeout);
+			fail("TimeoutException expected");
+		} catch (const TimeoutException &) {
+			ensure("At least 45 msec elapsed", timer.elapsed() >= 45);
+			ensure("At most 65 msec elapsed", timer.elapsed() < 65);
+			ensure("It deducts the waited time from the timeout", timeout < 5000);
+			ensure_equals(readData, "hello");
+			ensure_equals(io.getBuffer(), "");
+		}
+	}
+	
+	/***** Test read() *****/
+	
+	TEST_METHOD(10) {
+		// If the connection is already closed and the buffer is empty, then it returns 0.
+		writer.close();
+		ensure_equals(io.read(buf, sizeof(buf)), 0u);
+		ensure_equals(io.getBuffer(), "");
+	}
+	
+	TEST_METHOD(11) {
+		// If the connection is already closed and the buffer is non-empty
+		// and >= N bytes, then it reads everything from the buffer.
+		io.unread("hel");
+		write("lo world");
+		writer.close();
+		ensure_equals(io.read(buf, 5), 5u);
+		ensure_equals(StaticString(buf), "hello");
+		ensure_equals(io.getBuffer(), " world");
+	}
+	
+	TEST_METHOD(12) {
+		// If the connection is already closed and the buffer is non-empty
+		// and < N bytes, then it reads N bytes from the buffer and the rest
+		// from the connection.
+		io.unread("hel");
+		write("lo world");
+		writer.close();
+		ensure_equals(io.read(buf, sizeof(buf)), 11u);
+		ensure_equals(StaticString(buf), "hello world");
+		ensure_equals(io.getBuffer(), "");
+	}
+	
+	TEST_METHOD(13) {
+		// If the buffer is empty then it reads from the connection.
+		write("hello world");
+		ensure_equals(io.read(buf, 5), 5u);
+		ensure_equals(StaticString(buf), "hello");
+		ensure_equals(io.getBuffer(), " world");
+	}
+	
+	TEST_METHOD(14) {
+		// If the buffer is non-empty then it reads from the
+		// buffer first, then from the connection.
+		write("hello world");
+		
+		ensure_equals(io.read(buf, 2), 2u);
+		ensure_equals(StaticString(buf), "he");
+		ensure_equals(io.getBuffer(), "llo world");
+		
+		ensure_equals(io.read(buf, 7), 7u);
+		ensure_equals(StaticString(buf), "llo wor");
+		ensure_equals(io.getBuffer(), "ld");
+	}
+	
+	TEST_METHOD(15) {
+		// It blocks until the given number of bytes are read or until EOF.
+		TempThread thr1(boost::bind(writeAfterSomeTime, writer, 20000, "aa"));
+		Timer timer1;
+		ensure_equals(io.read(buf, 2), 2u);
+		ensure_equals(StaticString(buf), "aa");
+		ensure("At least 18 msec elapsed", timer1.elapsed() >= 18);
+		ensure("At most 30 msec elapsed", timer1.elapsed() <= 30);
+		
+		TempThread thr2(boost::bind(closeAfterSomeTime, writer, 20000));
+		Timer timer2;
+		ensure_equals(io.read(buf, sizeof(buf)), 0u);
+		ensure_equals(StaticString(buf), "aa");
+		ensure("At least 18 msec elapsed", timer2.elapsed() >= 18);
+		ensure("At most 30 msec elapsed", timer2.elapsed() <= 30);
+	}
+	
+	TEST_METHOD(16) {
+		// It throws TimeoutException if it cannot read enough data
+		// within the specified timeout.
+		unsigned long long timeout = 50000;
+		io.unread("he");
+		write("llo");
+		Timer timer;
+		try {
+			io.read(buf, sizeof(buf), &timeout);
+			fail("TimeoutException expected");
+		} catch (const TimeoutException &) {
+			ensure("At least 45 msec elapsed", timer.elapsed() >= 45);
+			ensure("At most 65 msec elapsed", timer.elapsed() < 65);
+			ensure("It deducts the waited time from the timeout", timeout < 5000);
+			ensure_equals(io.getBuffer(), "");
+		}
+	}
+	
+	/***** Test readAll() *****/
+	
+	TEST_METHOD(20) {
+		// It reads everything until EOF.
+		TempThread thr1(boost::bind(writeAfterSomeTime, writer, 20000, "aa"));
+		TempThread thr2(boost::bind(closeAfterSomeTime, writer, 40000));
+		Timer timer;
+		ensure_equals(io.readAll(), "aa");
+		ensure_equals(io.getBuffer(), "");
+		ensure("At least 38 msec elapsed", timer.elapsed() >= 38);
+		ensure("At most 50 msec elapsed", timer.elapsed() <= 50);
+	}
+	
+	TEST_METHOD(21) {
+		// It throws TimeoutException if it cannot read enough data
+		// within the specified timeout.
+		unsigned long long timeout = 50000;
+		io.unread("he");
+		write("llo");
+		Timer timer;
+		try {
+			io.readAll(&timeout);
+			fail("TimeoutException expected");
+		} catch (const TimeoutException &) {
+			ensure("At least 45 msec elapsed", timer.elapsed() >= 45);
+			ensure("At most 65 msec elapsed", timer.elapsed() < 65);
+			ensure("It deducts the waited time from the timeout", timeout < 5000);
+			ensure_equals(io.getBuffer(), "");
+		}
+	}
+	
+	/***** Test readLine() *****/
+	
+	TEST_METHOD(25) {
+		// If the connection is already closed and the buffer is empty,
+		// then it returns the empty string.
+		writer.close();
+		ensure_equals(io.readLine(), "");
+		ensure_equals(io.getBuffer(), "");
+	}
+	
+	TEST_METHOD(26) {
+		// If the connection is already closed and the buffer is non-empty,
+		// then it returns the first line in the buffer.
+		writer.close();
+		io.unread("hello\nworld\n.");
+		ensure_equals(io.readLine(), "hello\n");
+		ensure_equals(io.getBuffer(), "world\n.");
+		ensure_equals(io.readLine(), "world\n");
+		ensure_equals(io.getBuffer(), ".");
+		ensure_equals(io.readLine(), ".");
+		ensure_equals(io.getBuffer(), "");
+	}
+	
+	TEST_METHOD(27) {
+		// If the buffer is empty then it reads from the connection.
+		write("hello\nworld\n.");
+		ensure_equals(io.readLine(), "hello\n");
+		ensure_equals(io.getBuffer(), "world\n.");
+	}
+	
+	TEST_METHOD(28) {
+		// If the buffer is non-empty then it reads from the
+		// buffer first, then from the connection.
+		io.unread("hello");
+		write("\nworld\n.");
+		ensure_equals(io.readLine(), "hello\n");
+		ensure_equals(io.getBuffer(), "world\n.");
+		ensure_equals(io.readLine(), "world\n");
+		ensure_equals(io.getBuffer(), ".");
+	}
+	
+	TEST_METHOD(29) {
+		// If the line is too long then it throws a SecurityException.
+		write("abcd");
+		try {
+			io.readLine(3);
+			fail("SecurityException expected");
+		} catch (const SecurityException &) {
+			// Pass.
+		}
+	}
+	
+	TEST_METHOD(30) {
+		// It blocks until a line can be read or until EOF.
+		TempThread thr1(boost::bind(writeAfterSomeTime, writer, 20000, "hello"));
+		TempThread thr2(boost::bind(writeAfterSomeTime, writer, 35000, "\nworld\n."));
+		Timer timer1;
+		ensure_equals(io.readLine(), "hello\n");
+		ensure_equals(io.getBuffer(), "world\n.");
+		ensure("At least 33 msec elapsed", timer1.elapsed() >= 33);
+		ensure("At most 45 msec elapsed", timer1.elapsed() <= 45);
+		
+		TempThread thr3(boost::bind(closeAfterSomeTime, writer, 20000));
+		Timer timer2;
+		ensure_equals(io.readLine(), "world\n");
+		ensure_equals(io.getBuffer(), ".");
+		ensure_equals(io.readLine(), ".");
+		ensure_equals(io.getBuffer(), "");
+		ensure("At least 18 msec elapsed", timer2.elapsed() >= 18);
+		ensure("At most 30 msec elapsed", timer2.elapsed() <= 30);
+	}
+	
+	TEST_METHOD(31) {
+		// It throws TimeoutException if it cannot read enough data
+		// within the specified timeout.
+		unsigned long long timeout = 30000;
+		io.unread("he");
+		write("llo");
+		Timer timer;
+		try {
+			io.readLine(1024, &timeout);
+			fail("TimeoutException expected");
+		} catch (const TimeoutException &) {
+			ensure("At least 25 msec elapsed", timer.elapsed() >= 25);
+			ensure("At most 40 msec elapsed", timer.elapsed() < 40);
+			ensure("It deducts the waited time from the timeout", timeout < 5000);
+			ensure_equals(io.getBuffer(), "");
+		}
+	}
+}