passenger 3.0.21 → 3.9.1.beta

data/test/ruby/shared/loader_spec.rb

@@ -0,0 +1,241 @@
+require 'socket'
+require 'phusion_passenger/utils'
+require 'phusion_passenger/message_channel'
+
+module PhusionPassenger
+
+class Loader
+	attr_reader :pid, :input, :output, :sockets
+
+	def initialize(command, app_root)
+		@app_root = app_root
+		a, input = UNIXSocket.pair
+		c, output = UNIXSocket.pair
+		@pid = pid = fork do
+			STDIN.reopen(a)
+			STDOUT.reopen(c)
+			input.close
+			output.close
+			Dir.chdir(app_root)
+			ENV['RAILS_ENV'] = ENV['RACK_ENV'] = ENV['PASSENGER_ENV'] = 'production'
+			exec(*command)
+		end
+		a.close
+		c.close
+		@input = input
+		@output = output
+		@sockets = {}
+	end
+
+	def self.new_with_sockets(input, output, app_root)
+		result = allocate
+		result.instance_variable_set(:@input, input)
+		result.instance_variable_set(:@output, output)
+		result.instance_variable_set(:@app_root, app_root)
+		result.instance_variable_set(:@sockets, {})
+		return result
+	end
+
+	def close
+		@input.close if !@input.closed?
+		@output.close if !@output.closed?
+		if @pid
+			begin
+				Process.kill('TERM', @pid)
+			rescue Errno::ESRCH
+			end
+			begin
+				Process.waitpid(@pid)
+			rescue Errno::ECHILD
+			end
+		end
+	end
+
+	def start(options = {})
+		init_message = read_response_line
+		if init_message != "I have control 1.0\n"
+			raise "Unknown response initialization message: #{init_message.inspect}"
+		end
+		write_request_line "You have control 1.0"
+		write_start_request(options)
+		return process_response
+	end
+
+	def connect_and_send_request(headers)
+		socket = Utils.connect_to_server(sockets["main"][:address])
+		channel = MessageChannel.new(socket)
+		data = ""
+		headers["REQUEST_METHOD"] ||= "GET"
+		headers["REQUEST_URI"] ||= headers["PATH_INFO"]
+		headers["QUERY_STRING"] ||= ""
+		headers["SCRIPT_NAME"] ||= ""
+		headers.each_pair do |key, value|
+			data << "#{key}\0#{value}\0"
+		end
+		channel.write_scalar(data)
+		return socket
+	end
+
+private
+	def write_request_line(line = "")
+		STDERR.puts "---> #{line}" if DEBUG
+		@input.puts line
+	end
+
+	def read_response_line
+		while true
+			line = @output.readline
+			STDERR.puts "<--- #{line.strip}" if DEBUG
+			if line.start_with?("!> ")
+				line.sub!(/^\!> /, '')
+				return line
+			end
+		end
+	end
+
+	def write_start_request(options)
+		write_request_line "passenger_root: #{PhusionPassenger.source_root}"
+		write_request_line "ruby_libdir: #{PhusionPassenger.ruby_libdir}"
+		write_request_line "generation_dir: #{Utils.passenger_tmpdir}"
+		write_request_line "log_level: 3" if DEBUG
+		options.each_pair do |key, value|
+			write_request_line "#{key}: #{value}"
+		end
+		write_request_line
+	end
+
+	def process_response
+		status = read_response_line
+
+		headers = {}
+		line = read_response_line
+		while line != "\n"
+			key, value = line.strip.split(/ *: */, 2)
+			if key == "socket"
+				process_socket(value)
+			else
+				headers[key] = value
+			end
+			line = read_response_line
+		end
+
+		if status == "Error\n"
+			body = @output.read
+		end
+
+		return { :status => status.strip, :headers => headers, :body => body }
+	end
+
+	def process_socket(spec)
+		name, address, protocol, concurrency = spec.split(';')
+		@sockets[name] = { :address => address, :protocol => protocol, :concurrency => concurrency }
+	end
+end
+
+class Preloader < Loader
+	def spawn(options = {})
+		socket = Utils.connect_to_server(sockets["spawn"])
+		loader = Loader.new_with_sockets(socket, socket.dup, @app_root)
+		begin
+			loader.send(:write_request_line, "spawn")
+			loader.send(:write_start_request, options)
+			
+			line = loader.output.readline
+			puts "<--- #{line.strip}" if DEBUG
+			if line != "OK\n"
+				raise "Unexpected spawn response status #{line.inspect}"
+			end
+
+			line = loader.output.readline
+			puts "<--- #{line.strip}" if DEBUG
+			loader.instance_variable_set(:@pid, line.to_i)
+
+			return loader
+		rescue
+			loader.close
+			raise
+		end
+	end
+
+private
+	def process_socket(spec)
+		sockets["spawn"] = spec
+	end
+end
+
+module LoaderSpecHelper
+	def self.included(klass)
+		klass.before(:each) do
+			@stubs = []
+		end
+		
+		klass.after(:each) do
+			begin
+				@loader.close if @loader
+				@preloader.close if @preloader
+			ensure
+				@stubs.each do |stub|
+					stub.destroy
+				end
+			end
+		end
+	end
+	
+	def before_start(code)
+		@before_start = code
+	end
+	
+	def after_start(code)
+		@after_start = code
+	end
+	
+	def register_stub(stub)
+		@stubs << stub
+		File.prepend(stub.startup_file, "#{@before_start}\n")
+		File.append(stub.startup_file, "\n#{@after_start}")
+		return stub
+	end
+	
+	def register_app(app)
+		@apps << app
+		return app
+	end
+
+	def start!(options = {})
+		result = start(options)
+		if result[:status] != "Ready"
+			violated "Loader failed to start; error page:\n#{result[:body]}"
+		end
+	end
+
+	def perform_request(headers)
+		socket = @loader.connect_and_send_request(headers)
+		headers = {}
+		line = socket.readline
+		while line != "\r\n"
+			key, value = line.strip.split(/ *: */, 2)
+			headers[key] = value
+			line = socket.readline
+		end
+		body = socket.read
+		socket.close
+		return [headers, body]
+	end
+end
+
+shared_examples_for "a loader" do
+	it "works" do
+		result = start
+		result[:status].should == "Ready"
+		headers, body = perform_request(
+			"REQUEST_METHOD" => "GET",
+			"PATH_INFO" => "/hello",
+			# For Rails 2
+			"REQUEST_URI" => "/hello"
+		)
+		headers["Status"].should == "200"
+		body.should == "hello world"
+	end
+end
+
+end # module PhusionPassenger

data/test/ruby/shared/rails/analytics_logging_extensions_spec.rb

@@ -15,8 +15,9 @@ shared_examples_for "analytics logging extensions for Rails" do
 			"analytics" => true,
 			"logging_agent_address" => @socket_address,
 			"logging_agent_username" => "logging",
-			"logging_agent_password_base64" => base64("1234"),
-			"node_name" => "localhost"
+			"logging_agent_password" => "1234",
+			"node_name" => "localhost",
+			"app_group_name" => "foobar"
 		}
 	end
 	
@@ -26,32 +27,11 @@ shared_examples_for "analytics logging extensions for Rails" do
 		Process.waitpid(@agent_pid)
 	end
 	
-	def send_request_to_app(app, env)
-		if app.server_sockets[:main][1] == "unix"
-			@connection = UNIXSocket.new(app.server_sockets[:main][0])
-		else
-			addr, port = app.server_sockets[:main][0].split(/:/)
-			@connection = TCPSocket.new(addr, port.to_i)
-		end
-		channel = MessageChannel.new(@connection)
-		data = ""
-		env = {
-			"REQUEST_METHOD" => "GET",
-			"SCRIPT_NAME"    => "",
-			"PATH_INFO"      => "/",
-			"QUERY_STRING"   => "",
-			"SERVER_NAME"    => "localhost",
-			"SERVER_PORT"    => "80",
-			"PASSENGER_TXN_ID"     => "1234-abcd",
-			"PASSENGER_GROUP_NAME" => "foobar"
-		}.merge(env)
-		env["REQUEST_URI"] ||= env["PATH_INFO"]
-		env.each_pair do |key, value|
-			data << key << "\0"
-			data << value << "\0"
-		end
-		channel.write_scalar(data)
-		return @connection.read
+	def send_request_to_app(headers)
+		headers = {
+			"PASSENGER_TXN_ID"     => "1234-abcd"
+		}.merge(headers)
+		return perform_request(headers)
 	end
 	
 	def read_log(name_suffix)
@@ -69,36 +49,34 @@ shared_examples_for "analytics logging extensions for Rails" do
 	
 	it "doesn't install analytics logging extensions if analytics logging is turned off" do
 		@options.delete("analytics")
-		app = spawn_some_application(@options) do |stub|
-			File.write("#{stub.app_root}/app/controllers/foo_controller.rb", %Q{
-				class FooController < ActionController::Base
-					def index
-						File.open("out.txt", "w") do |f|
-							f.write(request.env["PASSENGER_ANALYTICS_WEB_LOG"].class.to_s)
-						end
-						render :nothing => true
+		File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
+			class FooController < ActionController::Base
+				def index
+					File.open("out.txt", "w") do |f|
+						f.write(request.env["PASSENGER_ANALYTICS_WEB_LOG"].class.to_s)
 					end
+					render :nothing => true
 				end
-			})
-		end
-		send_request_to_app(app, "PATH_INFO" => "/foo")
+			end
+		})
+		start!(@options)
+		send_request_to_app("PATH_INFO" => "/foo")
 		eventually(5) do
-			filename = "#{app.app_root}/out.txt"
+			filename = "#{@stub.app_root}/out.txt"
 			File.exist?(filename) && File.read(filename) == "NilClass"
 		end
 	end
 	
 	it "logs the controller and action name" do
-		app = spawn_some_application(@options) do |stub|
-			File.write("#{stub.app_root}/app/controllers/foo_controller.rb", %Q{
-				class FooController < ActionController::Base
-					def index
-						render :nothing => true
-					end
+		File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
+			class FooController < ActionController::Base
+				def index
+					render :nothing => true
 				end
-			})
-		end
-		send_request_to_app(app, "PATH_INFO" => "/foo")
+			end
+		})
+		start!(@options)
+		send_request_to_app("PATH_INFO" => "/foo")
 		eventually(5) do
 			flush_logging_agent(@logging_agent_password, @socket_address)
 			log = read_log("requests/**/log.txt")
@@ -107,16 +85,15 @@ shared_examples_for "analytics logging extensions for Rails" do
 	end
 	
 	it "logs uncaught exceptions in controller actions" do
-		app = spawn_some_application(@options) do |stub|
-			File.write("#{stub.app_root}/app/controllers/crash_controller.rb", %Q{
-				class CrashController < ActionController::Base
-					def index
-						raise "something went wrong"
-					end
+		File.write("#{@stub.app_root}/app/controllers/crash_controller.rb", %Q{
+			class CrashController < ActionController::Base
+				def index
+					raise "something went wrong"
 				end
-			})
-		end
-		send_request_to_app(app, "PATH_INFO" => "/crash")
+			end
+		})
+		start!(@options)
+		send_request_to_app("PATH_INFO" => "/crash")
 		eventually(5) do
 			flush_logging_agent(@logging_agent_password, @socket_address)
 			log = read_log("exceptions/**/log.txt")
@@ -129,20 +106,19 @@ shared_examples_for "analytics logging extensions for Rails" do
 	end
 	
 	it "logs ActionController benchmarks" do
-		app = spawn_some_application(@options) do |stub|
-			File.write("#{stub.app_root}/app/controllers/foo_controller.rb", %Q{
-				class FooController < ActionController::Base
-					def index
-						# The '::' prefix works around a Dependencies
-						# bug in Rails 1.2
-						::ActionController::Base.benchmark("hello") do
-						end
-						render :nothing => true
+		File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
+			class FooController < ActionController::Base
+				def index
+					# The '::' prefix works around a Dependencies
+					# bug in Rails 1.2
+					::ActionController::Base.benchmark("hello") do
 					end
+					render :nothing => true
 				end
-			})
-		end
-		send_request_to_app(app, "PATH_INFO" => "/foo")
+			end
+		})
+		start!(@options)
+		send_request_to_app("PATH_INFO" => "/foo")
 		eventually(5) do
 			flush_logging_agent(@logging_agent_password, @socket_address)
 			log = read_log("requests/**/log.txt")
@@ -152,18 +128,17 @@ shared_examples_for "analytics logging extensions for Rails" do
 	end
 	
 	it "logs ActionView benchmarks" do
-		app = spawn_some_application(@options) do |stub|
-			File.write("#{stub.app_root}/app/controllers/foo_controller.rb", %Q{
-				class FooController < ActionController::Base
-				end
-			})
-			FileUtils.mkdir_p("#{stub.app_root}/app/views/foo")
-			File.write("#{stub.app_root}/app/views/foo/index.rhtml", %Q{
-				<% benchmark("hello") do %>
-				<% end %>
-			})
-		end
-		send_request_to_app(app, "PATH_INFO" => "/foo")
+		File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
+			class FooController < ActionController::Base
+			end
+		})
+		FileUtils.mkdir_p("#{@stub.app_root}/app/views/foo")
+		File.write("#{@stub.app_root}/app/views/foo/index.rhtml", %Q{
+			<% benchmark("hello") do %>
+			<% end %>
+		})
+		start!(@options)
+		send_request_to_app("PATH_INFO" => "/foo")
 		eventually(5) do
 			flush_logging_agent(@logging_agent_password, @socket_address)
 			log = read_log("requests/**/log.txt")
@@ -173,23 +148,18 @@ shared_examples_for "analytics logging extensions for Rails" do
 	end
 	
 	it "logs successful SQL queries" do
-		app = spawn_some_application(@options) do |stub|
-			File.write("#{stub.app_root}/config/database.yml",
-				"production:\n" +
-				"  adapter: sqlite3\n" +
-				"  database: db.sqlite3\n")
-			File.write("#{stub.app_root}/app/controllers/foo_controller.rb", %Q{
-				class FooController < ActionController::Base
-					def index
-						db = ActiveRecord::Base.connection
-						db.execute("CREATE TABLE foobar (id INT)")
-						db.execute("INSERT INTO foobar VALUES (1)")
-						render :nothing => true
-					end
+		File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
+			class FooController < ActionController::Base
+				def index
+					db = ActiveRecord::Base.connection
+					db.execute("CREATE TABLE foobar (id INT)")
+					db.execute("INSERT INTO foobar VALUES (1)")
+					render :nothing => true
 				end
-			})
-		end
-		send_request_to_app(app, "PATH_INFO" => "/foo")
+			end
+		})
+		start!(@options.merge("active_record" => true))
+		send_request_to_app("PATH_INFO" => "/foo")
 		extra_info_regex = Regexp.escape(base64("SQL\nCREATE TABLE foobar (id INT)"))
 		eventually(5) do
 			flush_logging_agent(@logging_agent_password, @socket_address)
@@ -200,22 +170,17 @@ shared_examples_for "analytics logging extensions for Rails" do
 	end
 	
 	it "logs failed SQL queries" do
-		app = spawn_some_application(@options) do |stub|
-			File.write("#{stub.app_root}/config/database.yml",
-				"production:\n" +
-				"  adapter: sqlite3\n" +
-				"  database: db.sqlite3\n")
-			File.write("#{stub.app_root}/app/controllers/foo_controller.rb", %Q{
-				class FooController < ActionController::Base
-					def index
-						db = ActiveRecord::Base.connection
-						db.execute("INVALID QUERY")
-						render :nothing => true
-					end
+		File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
+			class FooController < ActionController::Base
+				def index
+					db = ActiveRecord::Base.connection
+					db.execute("INVALID QUERY")
+					render :nothing => true
 				end
-			})
-		end
-		send_request_to_app(app, "PATH_INFO" => "/foo")
+			end
+		})
+		start!(@options.merge("active_record" => true))
+		send_request_to_app("PATH_INFO" => "/foo")
 		extra_info_regex = Regexp.escape(base64("SQL\nINVALID QUERY"))
 		if rails_version >= '3.0'
 			pending do
@@ -236,16 +201,15 @@ shared_examples_for "analytics logging extensions for Rails" do
 	end
 	
 	it "logs controller processing time of successful actions" do
-		app = spawn_some_application(@options) do |stub|
-			File.write("#{stub.app_root}/app/controllers/foo_controller.rb", %Q{
-				class FooController < ActionController::Base
-					def index
-						render :nothing => true
-					end
+		File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
+			class FooController < ActionController::Base
+				def index
+					render :nothing => true
 				end
-			})
-		end
-		send_request_to_app(app, "PATH_INFO" => "/foo")
+			end
+		})
+		start!(@options)
+		send_request_to_app("PATH_INFO" => "/foo")
 		eventually(5) do
 			flush_logging_agent(@logging_agent_password, @socket_address)
 			log = read_log("requests/**/log.txt")
@@ -255,16 +219,15 @@ shared_examples_for "analytics logging extensions for Rails" do
 	end
 	
 	it "logs controller processing time of failed actions" do
-		app = spawn_some_application(@options) do |stub|
-			File.write("#{stub.app_root}/app/controllers/foo_controller.rb", %Q{
-				class FooController < ActionController::Base
-					def index
-						raise "crash"
-					end
+		File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
+			class FooController < ActionController::Base
+				def index
+					raise "crash"
 				end
-			})
-		end
-		send_request_to_app(app, "PATH_INFO" => "/foo")
+			end
+		})
+		start!(@options)
+		send_request_to_app("PATH_INFO" => "/foo")
 		eventually(5) do
 			flush_logging_agent(@logging_agent_password, @socket_address)
 			log = read_log("requests/**/log.txt")
@@ -274,19 +237,18 @@ shared_examples_for "analytics logging extensions for Rails" do
 	end
 	
 	it "logs view rendering time of successful actions" do
-		app = spawn_some_application(@options) do |stub|
-			File.write("#{stub.app_root}/app/controllers/foo_controller.rb", %Q{
-				class FooController < ActionController::Base
-					def index
-					end
+		File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
+			class FooController < ActionController::Base
+				def index
 				end
-			})
-			FileUtils.mkdir_p("#{stub.app_root}/app/views/foo")
-			File.write("#{stub.app_root}/app/views/foo/index.rhtml", %Q{
-				hello world
-			})
-		end
-		send_request_to_app(app, "PATH_INFO" => "/foo")
+			end
+		})
+		FileUtils.mkdir_p("#{@stub.app_root}/app/views/foo")
+		File.write("#{@stub.app_root}/app/views/foo/index.rhtml", %Q{
+			hello world
+		})
+		start!(@options)
+		send_request_to_app("PATH_INFO" => "/foo")
 		eventually(5) do
 			flush_logging_agent(@logging_agent_password, @socket_address)
 			log = read_log("requests/**/log.txt")
@@ -297,19 +259,18 @@ shared_examples_for "analytics logging extensions for Rails" do
 	end
 	
 	it "logs view rendering time of failed actions" do
-		app = spawn_some_application(@options) do |stub|
-			File.write("#{stub.app_root}/app/controllers/foo_controller.rb", %Q{
-				class FooController < ActionController::Base
-					def index
-					end
+		File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
+			class FooController < ActionController::Base
+				def index
 				end
-			})
-			FileUtils.mkdir_p("#{stub.app_root}/app/views/foo")
-			File.write("#{stub.app_root}/app/views/foo/index.rhtml", %Q{
-				<% raise "crash!" %>
-			})
-		end
-		send_request_to_app(app, "PATH_INFO" => "/foo")
+			end
+		})
+		FileUtils.mkdir_p("#{@stub.app_root}/app/views/foo")
+		File.write("#{@stub.app_root}/app/views/foo/index.rhtml", %Q{
+			<% raise "crash!" %>
+		})
+		start!(@options)
+		send_request_to_app("PATH_INFO" => "/foo")
 		eventually(5) do
 			flush_logging_agent(@logging_agent_password, @socket_address)
 			log = read_log("requests/**/log.txt")
@@ -320,22 +281,21 @@ shared_examples_for "analytics logging extensions for Rails" do
 	
 	it "logs cache hits" do
 		if rails_version >= '2.1'
-			app = spawn_some_application(@options) do |stub|
-				File.write("#{stub.app_root}/app/controllers/foo_controller.rb", %Q{
-					class FooController < ActionController::Base
-						def index
-							Rails.cache.write("key1", "foo")
-							Rails.cache.write("key2", "foo")
-							Rails.cache.write("key3", "foo")
-							Rails.cache.read("key1")
-							Rails.cache.fetch("key2")
-							Rails.cache.fetch("key3") { "bar" }
-							render :text => 'ok'
-						end
+			File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
+				class FooController < ActionController::Base
+					def index
+						Rails.cache.write("key1", "foo")
+						Rails.cache.write("key2", "foo")
+						Rails.cache.write("key3", "foo")
+						Rails.cache.read("key1")
+						Rails.cache.fetch("key2")
+						Rails.cache.fetch("key3") { "bar" }
+						render :text => 'ok'
 					end
-				})
-			end
-			send_request_to_app(app, "PATH_INFO" => "/foo")
+				end
+			})
+			start!(@options)
+			send_request_to_app("PATH_INFO" => "/foo")
 			eventually(5) do
 				flush_logging_agent(@logging_agent_password, @socket_address)
 				log = read_log("requests/**/log.txt")
@@ -348,19 +308,18 @@ shared_examples_for "analytics logging extensions for Rails" do
 	
 	it "logs cache misses" do
 		if rails_version >= '2.1'
-			app = spawn_some_application(@options) do |stub|
-				File.write("#{stub.app_root}/app/controllers/foo_controller.rb", %Q{
-					class FooController < ActionController::Base
-						def index
-							Rails.cache.read("key1")
-							Rails.cache.fetch("key2")
-							Rails.cache.fetch("key3") { "bar" }
-							render :text => 'ok'
-						end
+			File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
+				class FooController < ActionController::Base
+					def index
+						Rails.cache.read("key1")
+						Rails.cache.fetch("key2")
+						Rails.cache.fetch("key3") { "bar" }
+						render :text => 'ok'
 					end
-				})
-			end
-			send_request_to_app(app, "PATH_INFO" => "/foo")
+				end
+			})
+			start!(@options)
+			send_request_to_app("PATH_INFO" => "/foo")
 			eventually(5) do
 				flush_logging_agent(@logging_agent_password, @socket_address)
 				log = read_log("requests/**/log.txt")