passenger 5.0.0.beta3 → 5.0.0.rc1

data/test/ruby/utils_spec.rb

@@ -12,30 +12,30 @@ PhusionPassenger.require_passenger_lib 'utils/native_support_utils'
 module PhusionPassenger
 
 describe Utils do
-	include Utils
-	include Utils::NativeSupportUtils
+  include Utils
+  include Utils::NativeSupportUtils
 
-	specify "#to_boolean works" do
-		LoaderSharedHelpers.to_boolean(nil).should be_false
-		LoaderSharedHelpers.to_boolean(false).should be_false
-		LoaderSharedHelpers.to_boolean(true).should be_true
-		LoaderSharedHelpers.to_boolean(1).should be_true
-		LoaderSharedHelpers.to_boolean(0).should be_true
-		LoaderSharedHelpers.to_boolean("").should be_true
-		LoaderSharedHelpers.to_boolean("true").should be_true
-		LoaderSharedHelpers.to_boolean("false").should be_false
-		LoaderSharedHelpers.to_boolean("bla bla").should be_true
-	end
+  specify "#to_boolean works" do
+    LoaderSharedHelpers.to_boolean(nil).should be_false
+    LoaderSharedHelpers.to_boolean(false).should be_false
+    LoaderSharedHelpers.to_boolean(true).should be_true
+    LoaderSharedHelpers.to_boolean(1).should be_true
+    LoaderSharedHelpers.to_boolean(0).should be_true
+    LoaderSharedHelpers.to_boolean("").should be_true
+    LoaderSharedHelpers.to_boolean("true").should be_true
+    LoaderSharedHelpers.to_boolean("false").should be_false
+    LoaderSharedHelpers.to_boolean("bla bla").should be_true
+  end
 
-	specify "#split_by_null_into_hash works" do
-		split_by_null_into_hash("").should == {}
-		split_by_null_into_hash("foo\0bar\0").should == { "foo" => "bar" }
-		split_by_null_into_hash("foo\0\0bar\0baz\0").should == { "foo" => "", "bar" => "baz" }
-		split_by_null_into_hash("foo\0bar\0baz\0\0").should == { "foo" => "bar", "baz" => "" }
-		split_by_null_into_hash("\0\0").should == { "" => "" }
-	end
+  specify "#split_by_null_into_hash works" do
+    split_by_null_into_hash("").should == {}
+    split_by_null_into_hash("foo\0bar\0").should == { "foo" => "bar" }
+    split_by_null_into_hash("foo\0\0bar\0baz\0").should == { "foo" => "", "bar" => "baz" }
+    split_by_null_into_hash("foo\0bar\0baz\0\0").should == { "foo" => "bar", "baz" => "" }
+    split_by_null_into_hash("\0\0").should == { "" => "" }
+  end
 
-	######################
+  ######################
 end
 
 end # module PhusionPassenger

data/test/stub/rack/config.ru

@@ -3,93 +3,93 @@
 require File.expand_path(File.dirname(__FILE__) + "/library")
 
 app = lambda do |env|
-	case env['PATH_INFO']
-	when '/'
-		if File.exist?("front_page.txt")
-			text_response(File.read("front_page.txt"))
-		else
-			text_response("front page")
-		end
-	when '/parameters'
-		req = Rack::Request.new(env)
-		method = env["REQUEST_METHOD"]
-		first = req.params["first"]
-		second = req.params["second"]
-		text_response("Method: #{method}\nFirst: #{first}\nSecond: #{second}\n")
-	when '/chunked'
-		chunks = ["7\r\nchunk1\n\r\n", "7\r\nchunk2\n\r\n", "7\r\nchunk3\n\r\n", "0\r\n\r\n"]
-		[200, { "Content-Type" => "text/html", "Transfer-Encoding" => "chunked" }, chunks]
-	when '/pid'
-		text_response(Process.pid)
-	when /^\/env/
-		body = ''
-		env.sort.each do |key, value|
-			body << "#{key} = #{value}\n"
-		end
-		text_response(body)
-	when '/system_env'
-		body = ''
-		ENV.sort.each do |key, value|
-			body << "#{key} = #{value}\n"
-		end
-		text_response(body)
-	when '/touch_file'
-		req = Rack::Request.new(env)
-		filename = req.params["file"]
-		File.open(filename, "w").close
-		text_response("ok")
-	when '/extra_header'
-		[200, { "Content-Type" => "text/html", "X-Foo" => "Bar" }, ["ok"]]
-	when '/cached'
-		text_response("This is the uncached version of /cached")
-	when '/upload_with_params'
-		req = Rack::Request.new(env)
-		name1 = binary_string(req.params["name1"])
-		name2 = binary_string(req.params["name2"])
-		file = req.params["data"][:tempfile]
-		file.binmode
-		text_response(
-			"name 1 = #{name1}\n" <<
-			"name 2 = #{name2}\n" <<
-			"data = #{file.read}")
-	when '/raw_upload_to_file'
-		File.open(env['HTTP_X_OUTPUT'], 'w') do |f|
-			while line = env['rack.input'].gets
-				f.write(line)
-				f.flush
-			end
-		end
-		text_response("ok")
-	when '/print_stderr'
-		STDERR.puts "hello world!"
-		text_response("ok")
-	when '/print_stdout_and_stderr'
-		STDOUT.puts "hello stdout!"
-		sleep 0.1  # Give HelperAgent the time to process stdout first.
-		STDERR.puts "hello stderr!"
-		text_response("ok")
-	when '/switch_protocol'
-		if env['HTTP_UPGRADE'] != 'raw' || env['HTTP_CONNECTION'].downcase != 'upgrade'
-			return [500, { "Content-Type" => "text/plain" }, ["Invalid headers"]]
-		end
-		env['rack.hijack'].call
-		io = env['rack.hijack_io']
-		begin
-			io.write("Status: 101 Switching Protocols\r\n")
-			io.write("Upgrade: raw\r\n")
-			io.write("Connection: Upgrade\r\n")
-			io.write("\r\n")
-			while !io.eof?
-				line = io.readline
-				io.write("Echo: #{line}")
-				io.flush
-			end
-		ensure
-			io.close
-		end
-	else
-		[404, { "Content-Type" => "text/plain" }, ["Unknown URI"]]
-	end
+  case env['PATH_INFO']
+  when '/'
+    if File.exist?("front_page.txt")
+      text_response(File.read("front_page.txt"))
+    else
+      text_response("front page")
+    end
+  when '/parameters'
+    req = Rack::Request.new(env)
+    method = env["REQUEST_METHOD"]
+    first = req.params["first"]
+    second = req.params["second"]
+    text_response("Method: #{method}\nFirst: #{first}\nSecond: #{second}\n")
+  when '/chunked'
+    chunks = ["7\r\nchunk1\n\r\n", "7\r\nchunk2\n\r\n", "7\r\nchunk3\n\r\n", "0\r\n\r\n"]
+    [200, { "Content-Type" => "text/html", "Transfer-Encoding" => "chunked" }, chunks]
+  when '/pid'
+    text_response(Process.pid)
+  when /^\/env/
+    body = ''
+    env.sort.each do |key, value|
+      body << "#{key} = #{value}\n"
+    end
+    text_response(body)
+  when '/system_env'
+    body = ''
+    ENV.sort.each do |key, value|
+      body << "#{key} = #{value}\n"
+    end
+    text_response(body)
+  when '/touch_file'
+    req = Rack::Request.new(env)
+    filename = req.params["file"]
+    File.open(filename, "w").close
+    text_response("ok")
+  when '/extra_header'
+    [200, { "Content-Type" => "text/html", "X-Foo" => "Bar" }, ["ok"]]
+  when '/cached'
+    text_response("This is the uncached version of /cached")
+  when '/upload_with_params'
+    req = Rack::Request.new(env)
+    name1 = binary_string(req.params["name1"])
+    name2 = binary_string(req.params["name2"])
+    file = req.params["data"][:tempfile]
+    file.binmode
+    text_response(
+      "name 1 = #{name1}\n" <<
+      "name 2 = #{name2}\n" <<
+      "data = #{file.read}")
+  when '/raw_upload_to_file'
+    File.open(env['HTTP_X_OUTPUT'], 'w') do |f|
+      while line = env['rack.input'].gets
+        f.write(line)
+        f.flush
+      end
+    end
+    text_response("ok")
+  when '/print_stderr'
+    STDERR.puts "hello world!"
+    text_response("ok")
+  when '/print_stdout_and_stderr'
+    STDOUT.puts "hello stdout!"
+    sleep 0.1  # Give HelperAgent the time to process stdout first.
+    STDERR.puts "hello stderr!"
+    text_response("ok")
+  when '/switch_protocol'
+    if env['HTTP_UPGRADE'] != 'raw' || env['HTTP_CONNECTION'].downcase != 'upgrade'
+      return [500, { "Content-Type" => "text/plain" }, ["Invalid headers"]]
+    end
+    env['rack.hijack'].call
+    io = env['rack.hijack_io']
+    begin
+      io.write("Status: 101 Switching Protocols\r\n")
+      io.write("Upgrade: raw\r\n")
+      io.write("Connection: Upgrade\r\n")
+      io.write("\r\n")
+      while !io.eof?
+        line = io.readline
+        io.write("Echo: #{line}")
+        io.flush
+      end
+    ensure
+      io.close
+    end
+  else
+    [404, { "Content-Type" => "text/plain" }, ["Unknown URI"]]
+  end
 end
 
 run app

data/test/stub/rack/library.rb

@@ -1,16 +1,16 @@
 # encoding: binary
 
 def text_response(body)
-	body = binary_string(body.to_s)
-	return [200, { "Content-Type" => "text/plain", "Content-Length" => body.size.to_s }, [body]]
+  body = binary_string(body.to_s)
+  return [200, { "Content-Type" => "text/plain", "Content-Length" => body.size.to_s }, [body]]
 end
 
 if "".respond_to?(:force_encoding)
-	def binary_string(str)
-		return str.force_encoding("binary")
-	end
+  def binary_string(str)
+    return str.force_encoding("binary")
+  end
 else
-	def binary_string(str)
-		return str
-	end
+  def binary_string(str)
+    return str
+  end
 end

data/test/stub/rack/start.rb

@@ -8,13 +8,13 @@ abort "Invalid initialization header" if STDIN.readline != "You have control 1.0
 
 options = {}
 while (line = STDIN.readline) != "\n"
-	name, value = line.strip.split(/: */, 2)
-	options[name] = value
+  name, value = line.strip.split(/: */, 2)
+  options[name] = value
 end
 
 if ARGV[0] == "--execself"
-	# Used for testing https://code.google.com/p/phusion-passenger/issues/detail?id=842#c19
-	exec("ruby", $0)
+  # Used for testing https://code.google.com/p/phusion-passenger/issues/detail?id=842#c19
+  exec("ruby", $0)
 end
 
 server = TCPServer.new('127.0.0.1', 0)
@@ -23,30 +23,30 @@ puts "!> socket: main;tcp://127.0.0.1:#{server.addr[1]};session;1"
 puts "!> "
 
 while true
-	ios = select([server, STDIN])[0]
-	if ios.include?(server)
-		client = server.accept
-		line = client.readline
-		if line == "ping\n"
-			client.write("pong\n")
-		elsif line == "pid\n"
-			client.write("#{Process.pid}\n")
-		elsif line == "envvars\n"
-			str = ""
-			ENV.each_pair do |key, value|
-				str << "#{key} = #{value}\n"
-			end
-			client.write(str)
-		else
-			client.write("unknown request\n")
-		end
-		client.close
-	end
-	if ios.include?(STDIN)
-		begin
-			STDIN.readline
-		rescue EOFError
-			exit
-		end
-	end
+  ios = select([server, STDIN])[0]
+  if ios.include?(server)
+    client = server.accept
+    line = client.readline
+    if line == "ping\n"
+      client.write("pong\n")
+    elsif line == "pid\n"
+      client.write("#{Process.pid}\n")
+    elsif line == "envvars\n"
+      str = ""
+      ENV.each_pair do |key, value|
+        str << "#{key} = #{value}\n"
+      end
+      client.write(str)
+    else
+      client.write("unknown request\n")
+    end
+    client.close
+  end
+  if ios.include?(STDIN)
+    begin
+      STDIN.readline
+    rescue EOFError
+      exit
+    end
+  end
 end

data/test/support/apache2_controller.rb

@@ -41,218 +41,218 @@ PhusionPassenger.require_passenger_lib 'platform_info/ruby'
 #       apache.stop
 #   end
 class Apache2Controller
-	include PhusionPassenger
-	STUB_DIR = File.expand_path(File.dirname(__FILE__) + "/../stub/apache2")
+  include PhusionPassenger
+  STUB_DIR = File.expand_path(File.dirname(__FILE__) + "/../stub/apache2")
 
-	class VHost
-		attr_accessor :domain
-		attr_accessor :document_root
-		attr_accessor :additional_configs
+  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 initialize(domain, document_root)
+      @domain = domain
+      @document_root = document_root
+      @additional_configs = []
+    end
 
-		def <<(config)
-			@additional_configs << config
-		end
-	end
+    def <<(config)
+      @additional_configs << config
+    end
+  end
 
-	attr_accessor :port
-	attr_accessor :vhosts
-	attr_reader :server_root
+  attr_accessor :port
+  attr_accessor :vhosts
+  attr_reader :server_root
 
-	def initialize(options = nil)
-		set(options) if options
-		@port = 64506
-		@vhosts = []
-		@extra = []
-		@server_root = File.expand_path('tmp.apache2')
-		@passenger_root = File.expand_path(PhusionPassenger.install_spec)
-		@mod_passenger = PhusionPassenger.apache2_module_path
-	end
+  def initialize(options = nil)
+    set(options) if options
+    @port = 64506
+    @vhosts = []
+    @extra = []
+    @server_root = File.expand_path('tmp.apache2')
+    @passenger_root = File.expand_path(PhusionPassenger.install_spec)
+    @mod_passenger = PhusionPassenger.apache2_module_path
+  end
 
-	def set(options)
-		options.each_pair do |key, value|
-			instance_variable_set("@#{key}", value)
-		end
-	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
+  # 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 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
+    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
-		Dir["#{@server_root}/*"].each do |filename|
-			if File.file?(filename)
-				File.chmod(0666, filename)
-			end
-		end
-	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
+    Dir["#{@server_root}/*"].each do |filename|
+      if File.file?(filename)
+        File.chmod(0666, filename)
+      end
+    end
+  end
 
-	def graceful_restart
-		write_config_file
-		if !system(PlatformInfo.httpd, "-f", "#{@server_root}/httpd.conf", "-k", "graceful")
-			raise "Cannot restart Apache."
-		end
-	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.chmod_R(0777, @server_root)
-			FileUtils.rm_r(@server_root)
-		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.chmod_R(0777, @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
+  # 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
+  # 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
+  # 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 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 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 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 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_builtin_module?(name)
+    return builtin_modules.include?(name)
+  end
 
-	def has_module?(name)
-		return File.exist?("#{modules_dir}/#{name}")
-	end
+  def has_module?(name)
+    return File.exist?("#{modules_dir}/#{name}")
+  end
 
-	def we_are_root?
-		return Process.uid == 0
-	end
+  def we_are_root?
+    return Process.uid == 0
+  end
 end