passenger-jmazzi 2.2.9

data/test/stub/vendor_rails/minimal/README

@@ -0,0 +1 @@
+A minimalist simulation a Rails framework.

data/test/stub/vendor_rails/minimal/actionpack/lib/action_controller.rb

@@ -0,0 +1,19 @@
+module ActionController
+	class Base
+		def self.page_cache_directory
+			nil
+		end
+
+		def self.page_cache_directory=(dir)
+		end
+		
+		def self.helper(*whatever)
+		end
+		
+		def self.protect_from_forgery(*whatever)
+		end
+		
+		def self.session(*whatever)
+		end
+	end
+end

data/test/stub/vendor_rails/minimal/activerecord/lib/active_record.rb

@@ -0,0 +1,7 @@
+class ActiveRecord
+	class Base
+		def self.connected?
+			return false
+		end
+	end
+end

data/test/stub/vendor_rails/minimal/activesupport/lib/active_support.rb

@@ -0,0 +1,17 @@
+class Object
+	def require_dependency(name)
+		require(name)
+	end
+end
+
+class NilClass
+	def blank?
+		return true
+	end
+end
+
+class String
+	def blank?
+		return strip.empty?
+	end
+end

data/test/stub/vendor_rails/minimal/railties/lib/initializer.rb

@@ -0,0 +1,52 @@
+RAILS_FRAMEWORK_ROOT = File.expand_path("#{File.dirname(__FILE__)}/../..")
+
+module Rails
+	class Initializer
+		attr_accessor :configuration
+		
+		def self.run(action = :boot)
+			inst = self.new
+			if inst.respond_to?(action)
+				inst.send(action)
+			end
+		end
+		
+		def initialize
+			@configuration = Configuration.new
+		end
+		
+		def boot
+			set_load_path
+			load_environment
+		end
+		
+		def load_environment
+			require "#{RAILS_FRAMEWORK_ROOT}/activesupport/lib/active_support"
+			require "#{RAILS_FRAMEWORK_ROOT}/actionpack/lib/action_controller"
+		end
+		
+		def set_load_path
+			if defined?(RAILS_ROOT)
+				$LOAD_PATH << "#{RAILS_ROOT}/app/controllers"
+			end
+			$LOAD_PATH << "#{RAILS_FRAMEWORK_ROOT}/railties/lib"
+		end
+	
+	protected
+		class Configuration
+			attr_accessor :log_path
+			attr_accessor :default_log_path
+			
+			def initialize
+				@log_path = @default_log_path = 'foo.log'
+			end
+		end
+	end
+	
+	module VERSION
+		MAJOR = 2
+		MINOR = 0
+		TINY = 0
+		STRING = [MAJOR, MINOR, TINY].join('.')
+	end
+end

data/test/stub/vendor_rails/minimal/railties/lib/ruby_version_check.rb

@@ -0,0 +1 @@
+

data/test/stub/wsgi/passenger_wsgi.py

@@ -0,0 +1,3 @@
+def application(environ, start_response):
+	start_response('200 OK', [('Content-type', 'text/plain'), ('X-Foo', 'bar')])
+	return ['Hello World!<br><img src="wsgi-snake.png">']

data/test/stub/zsfa/index.html

@@ -0,0 +1,14 @@
+<table border="0">
+<tr>
+	<td rowspan="2"><img src="zsfa.png" style="vertical-align: top"></td>
+	<td style="vertical-align: top"><img src="header.png"></td>
+</tr>
+<tr>
+	<td>
+		<div style="font-size: 50pt; font-family: 'Times New Roman'; font-weight: bold">
+		<blink>Zed, you rock!</blink><br>
+		</div>
+		<small>Our integration tests like you.</small>
+	</td>
+</tr>
+</table>

data/test/support/Support.cpp

@@ -0,0 +1,84 @@
+#include <unistd.h>
+#include "Support.h"
+
+namespace Test {
+
+string
+readAll(int fd) {
+	string result;
+	char buf[1024 * 32];
+	ssize_t ret;
+	while (true) {
+		do {
+			ret = read(fd, buf, sizeof(buf));
+		} while (ret == -1 && errno == EINTR);
+		if (ret == 0) {
+			break;
+		} else if (ret == -1) {
+			throw SystemException("Cannot read from socket", errno);
+		} else {
+			result.append(buf, ret);
+		}
+	}
+	return result;
+}
+
+string
+replaceString(const string &str, const string &toFind, const string &replaceWith) {
+	string::size_type pos = str.find(toFind);
+	if (pos == string::npos) {
+		return str;
+	} else {
+		string result(str);
+		return result.replace(pos, toFind.size(), replaceWith);
+	}
+}
+
+void
+replaceStringInFile(const char *filename, const string &toFind, const string &replaceWith) {
+	FILE *f = fopen(filename, "r");
+	if (f == NULL) {
+		int e = errno;
+		string message = "Cannot open file '";
+		message.append(filename);
+		message.append("' for reading");
+		throw FileSystemException(message, e, filename);
+	}
+	string content(readAll(fileno(f)));
+	fclose(f);
+	
+	f = fopen(filename, "w");
+	if (f == NULL) {
+		int e = errno;
+		string message = "Cannot open file '";
+		message.append(filename);
+		message.append("' for writing");
+		throw FileSystemException(message, e, filename);
+	}
+	content = replaceString(content, toFind, replaceWith);
+	fwrite(content.data(), 1, content.size(), f);
+	fclose(f);
+}
+
+void
+touchFile(const char *filename, time_t timestamp) {
+	FILE *f = fopen(filename, "a");
+	if (f != NULL) {
+		fclose(f);
+	} else if (errno != EISDIR) {
+		int e = errno;
+		string message = "Cannot touch file '";
+		message.append(filename);
+		message.append("'");
+		throw FileSystemException(message, e, filename);
+	}
+	
+	if (timestamp != (time_t) -1) {
+		struct utimbuf times;
+		times.actime = timestamp;
+		times.modtime = timestamp;
+		utime(filename, &times);
+	}
+}
+
+} // namespace Test

data/test/support/Support.h

@@ -0,0 +1,118 @@
+#ifndef _TEST_SUPPORT_H_
+#define _TEST_SUPPORT_H_
+
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <iostream>
+#include <string>
+#include <exception>
+#include <cstdio>
+#include <cerrno>
+#include <cstring>
+#include <utime.h>
+
+#include "Exceptions.h"
+#include "Utils.h"
+
+namespace Test {
+
+using namespace std;
+using namespace Passenger;
+
+/**
+ * Read all data from the given file descriptor until EOF.
+ *
+ * @throws SystemException
+ */
+string readAll(int fd);
+
+/**
+ * Look for 'toFind' inside 'str', replace it with 'replaceWith' and return the result.
+ * Only the first occurence of 'toFind' is replaced.
+ */
+string replaceString(const string &str, const string &toFind, const string &replaceWith);
+
+/**
+ * Look for 'toFind' inside the given file, replace it with 'replaceWith' and write
+ * the result back to the file. Only the first occurence of 'toFind' is replaced.
+ *
+ * @throws FileSystemException
+ */
+void replaceStringInFile(const char *filename, const string &toFind, const string &replaceWith);
+
+/**
+ * Touch the given file: create the file if it doesn't exist, update its
+ * timestamp if it does. If the <tt>timestamp</tt> argument is -1, then
+ * the current system time will be used, otherwise the given timestamp
+ * will be used.
+ *
+ * @throws FileSystemException
+ */
+void touchFile(const char *filename, time_t timestamp = (time_t) - 1);
+
+/**
+ * Class which creates a temporary directory of the given name, and deletes
+ * it upon destruction.
+ */
+class TempDir {
+private:
+	string name;
+public:
+	TempDir(const string &name) {
+		this->name = name;
+		if (mkdir(name.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) != 0) {
+			int e = errno;
+			string message = "Cannot create directory '";
+			message.append(name);
+			message.append("'");
+			throw FileSystemException(message, e, name);
+		}
+	}
+	
+	~TempDir() {
+		removeDirTree(name);
+	}
+};
+
+/**
+ * Creates a temporary copy of the given directory. This copy is deleted
+ * upon object destruction.
+ */
+class TempDirCopy {
+private:
+	string dir;
+public:
+	TempDirCopy(const string &source, const string &dest) {
+		dir = dest;
+		removeDirTree(dest);
+		
+		char command[1024];
+		snprintf(command, sizeof(command), "cp -pR \"%s\" \"%s\"",
+			source.c_str(), dest.c_str());
+		system(command);
+	}
+	
+	~TempDirCopy() {
+		removeDirTree(dir);
+	}
+};
+
+/**
+ * Class which deletes the given file upon destruction.
+ */
+class DeleteFileEventually {
+private:
+	string filename;
+public:
+	DeleteFileEventually(const string &filename) {
+		this->filename = filename;
+	}
+	
+	~DeleteFileEventually() {
+		unlink(filename.c_str());
+	}
+};
+
+} // namespace Test
+
+#endif /* _TEST_SUPPORT_H_ */

data/test/support/apache2_controller.rb

@@ -0,0 +1,250 @@
+require 'erb'
+require 'fileutils'
+require 'phusion_passenger/platform_info'
+
+# A class for starting, stopping and restarting Apache, and for manipulating
+# its configuration file. This is used by the integration tests.
+#
+# Before a test begins, the test instructs Apache2Controller to create an Apache
+# configuration folder, which contains an Apache configuration file and other
+# configuration resources that Apache needs. The Apache configuration file is
+# created from a template (see Apache2Controller::STUB_DIR).
+# The test can define configuration customizations. For example, it can tell
+# Apache2Controller to add configuration options, virtual host definitions, etc.
+#
+# After the configuration folder has been created, Apache2Controller will start
+# Apache. After Apache has been started, the test will be run. Apache2Controller
+# will stop Apache after the test is done.
+#
+# Apache2Controller ensures that starting, stopping and restarting are not prone
+# to race conditions. For example, it ensures that when #start returns, Apache
+# really is listening on its server socket instead of still initializing.
+#
+# == Usage
+#
+# Suppose that you want to test a hypothetical "AlwaysPrintHelloWorld"
+# Apache configuration option. Then you can write the following test:
+#
+#   apache = Apache2Controller.new
+#   
+#   # Add a configuration option to the configuration file.
+#   apache << "AlwaysPrintHelloWorld on"
+#   
+#   # Write configuration file and start Apache with that configuration file.
+#   apache.start
+#   
+#   begin
+#       response_body = http_get("http://localhost:#{apache.port}/some/url")
+#       response_body.should == "hello world!"
+#   ensure
+#       apache.stop
+#   end
+class Apache2Controller
+	STUB_DIR = File.expand_path(File.dirname(__FILE__) + "/../stub/apache2")
+	
+	class VHost
+		attr_accessor :domain
+		attr_accessor :document_root
+		attr_accessor :additional_configs
+		
+		def initialize(domain, document_root)
+			@domain = domain
+			@document_root = document_root
+			@additional_configs = []
+		end
+		
+		def <<(config)
+			@additional_configs << config
+		end
+	end
+	
+	attr_accessor :port
+	attr_accessor :vhosts
+	
+	def initialize(options = nil)
+		set(options) if options
+		@port = 64506
+		@vhosts = []
+		@extra = []
+		@server_root = File.expand_path('tmp.apache2')
+		@passenger_root = File.expand_path(File.dirname(__FILE__) + "/../..")
+		@mod_passenger = File.expand_path(File.dirname(__FILE__) + "/../../ext/apache2/mod_passenger.so")
+	end
+	
+	def set(options)
+		options.each_pair do |key, value|
+			instance_variable_set("@#{key}", value)
+		end
+	end
+	
+	# Create an Apache configuration folder and start Apache on that
+	# configuration folder. This method does not return until Apache
+	# has done initializing.
+	#
+	# If Apache is already started, this this method will stop Apache first.
+	def start
+		if running?
+			stop
+		else
+			File.unlink("#{@server_root}/httpd.pid") rescue nil
+		end
+		
+		if File.exist?(@server_root)
+			FileUtils.rm_r(@server_root)
+		end
+		FileUtils.mkdir_p(@server_root)
+		write_config_file
+		FileUtils.cp("#{STUB_DIR}/mime.types", @server_root)
+		
+		if !system(PlatformInfo.httpd, "-f", "#{@server_root}/httpd.conf", "-k", "start")
+			raise "Could not start an Apache server."
+		end
+		
+		begin
+			# Wait until the PID file has been created.
+			Timeout::timeout(20) do
+				while !File.exist?("#{@server_root}/httpd.pid")
+					sleep(0.1)
+				end
+			end
+			# Wait until Apache is listening on the server port.
+			Timeout::timeout(7) do
+				done = false
+				while !done
+					begin
+						socket = TCPSocket.new('localhost', @port)
+						socket.close
+						done = true
+					rescue Errno::ECONNREFUSED
+						sleep(0.1)
+					end
+				end
+			end
+		rescue Timeout::Error
+			raise "Could not start an Apache server."
+		end
+		File.chmod(0666, *Dir["#{@server_root}/*"]) rescue nil
+	end
+	
+	def graceful_restart
+		write_config_file
+		if !system(PlatformInfo.httpd, "-f", "#{@server_root}/httpd.conf", "-k", "graceful")
+			raise "Cannot restart Apache."
+		end
+	end
+	
+	# Stop Apache and delete its configuration folder. This method waits
+	# until Apache is done with its shutdown procedure.
+	#
+	# This method does nothing if Apache is already stopped.
+	def stop
+		pid_file = "#{@server_root}/httpd.pid"
+		if File.exist?(pid_file)
+			begin
+				pid = File.read(pid_file).strip.to_i
+				Process.kill('SIGTERM', pid)
+			rescue Errno::ESRCH
+				# Looks like a stale pid file.
+				FileUtils.rm_r(@server_root)
+				return
+			end
+		end
+		begin
+			# Wait until the PID file is removed.
+			Timeout::timeout(17) do
+				while File.exist?(pid_file)
+					sleep(0.1)
+				end
+			end
+			# Wait until the server socket is closed.
+			Timeout::timeout(7) do
+				done = false
+				while !done
+					begin
+						socket = TCPSocket.new('localhost', @port)
+						socket.close
+						sleep(0.1)
+					rescue SystemCallError
+						done = true
+					end
+				end
+			end
+		rescue Timeout::Error
+			raise "Unable to stop Apache."
+		end
+		if File.exist?(@server_root)
+			FileUtils.rm_r(@server_root)
+		end
+	end
+	
+	# Define a virtual host configuration block for the Apache configuration
+	# file. If there was already a vhost definition with the same domain name,
+	# then it will be overwritten.
+	#
+	# The given document root will be created if it doesn't exist.
+	def set_vhost(domain, document_root)
+		FileUtils.mkdir_p(document_root)
+		vhost = VHost.new(domain, document_root)
+		if block_given?
+			yield vhost
+		end
+		vhosts.reject! {|host| host.domain == domain}
+		vhosts << vhost
+	end
+	
+	# Checks whether this Apache instance is running.
+	def running?
+		if File.exist?("#{@server_root}/httpd.pid")
+			pid = File.read("#{@server_root}/httpd.pid").strip
+			begin
+				Process.kill(0, pid.to_i)
+				return true
+			rescue Errno::ESRCH
+				return false
+			rescue SystemCallError
+				return true
+			end
+		else
+			return false
+		end
+	end
+	
+	# Defines a configuration snippet to be added to the Apache configuration file.
+	def <<(line)
+		@extra << line
+	end
+
+private
+	def get_binding
+		return binding
+	end
+	
+	def write_config_file
+		template = ERB.new(File.read("#{STUB_DIR}/httpd.conf.erb"))
+		File.open("#{@server_root}/httpd.conf", 'w') do |f|
+			f.write(template.result(get_binding))
+		end
+	end
+	
+	def modules_dir
+		@@modules_dir ||= `#{PlatformInfo.apxs2} -q LIBEXECDIR`.strip
+	end
+	
+	def builtin_modules
+		@@builtin_modules ||= `#{PlatformInfo.httpd} -l`.split("\n").grep(/\.c$/).map do |line|
+			line.strip
+		end
+	end
+	
+	def has_builtin_module?(name)
+		return builtin_modules.include?(name)
+	end
+	
+	def has_module?(name)
+		return File.exist?("#{modules_dir}/#{name}")
+	end
+	
+	def we_are_root?
+		return Process.uid == 0
+	end
+end