passenger 3.0.21 → 3.9.1.beta

data/helper-scripts/backtrace-sanitizer.rb

@@ -0,0 +1,114 @@
+#!/usr/bin/env ruby
+# Parses output of the glibc backtrace() function and
+# translates addresses into function names and source
+# file locations.
+
+class Addr2line
+	attr_reader :stdin, :stdout, :pid
+
+	def initialize(filename)
+		a, b = IO.pipe
+		c, d = IO.pipe
+		@pid = fork do
+			STDIN.reopen(a)
+			b.close
+			STDOUT.reopen(d)
+			c.close
+			exec("addr2line", "-Cfie", filename)
+		end
+		a.close
+		d.close
+		@stdin = b
+		@stdout = c
+		@stdin.sync = @stdout.sync = true
+	end
+
+	def query(address)
+		@stdin.write("#{address}\n")
+		function = @stdout.readline
+		source = @stdout.readline
+		function.strip!
+		source.strip!
+		return [function, source]
+	end
+
+	def close
+		@stdin.close
+		@stdout.close
+		Process.kill('KILL', @pid)
+		Process.waitpid(@pid) rescue nil
+	end
+end
+
+def passthrough(input, output)
+	while !input.eof?
+		data = input.readline
+		output.write(data)
+		output.flush
+	end
+end
+
+input = STDIN
+output = STDERR
+argv0, pid_or_filename = ARGV
+if pid_or_filename =~ /\A\d+\Z/
+	begin
+		exe_filename = File.expand_path(File.readlink("/proc/#{pid_or_filename}/exe"))
+	rescue Errno::ENOENT, Errno::EACCES => e
+		warn "*** backtrace-sanitizer warning: #{e} -> passthrough input"
+		passthrough(input, output)
+		exit
+	end
+else
+	exe_filename = File.expand_path(pid_or_filename)
+end
+exe_basename = File.basename(exe_filename)
+addr2lines = {}
+
+begin
+	while !input.eof?
+		line = input.readline.strip
+		# Example lines:
+		# ./test() [0x400b64]
+		# /lib/libc.so.6(__libc_start_main+0xfd) [0x7fcc0ad00c8d]
+		if line =~ /(.*)\[(.*?)\]$/
+			# Split line into:
+			# subject: /lib/libc.so.6(__libc_start_main+0xfd)
+			# address: 0x7fcc0ad00c8d
+			subject = $1
+			address = $2
+			subject.strip!
+			subject =~ /(.*?)(\((.*?)\))?$/
+			# Split subject into:
+			# file: /lib/libc.so.6
+			# context: __libc_start_main+0xfd
+			file = $1
+			context = $3
+			file.strip!
+			context = nil if context && context.empty?
+
+			if file =~ /\A\// && File.exist?(file)
+				filename = file
+			elsif file == argv0 || file == exe_filename || file == exe_basename
+				filename = exe_filename
+			else
+				filename = nil
+			end
+			if filename.nil?
+				output.puts line
+			else
+				addr2line = (addr2lines[filename] ||= Addr2line.new(filename))
+				function, source = addr2line.query(address)
+				new_context = "#{function} at #{source}"
+				new_context << "; #{context}" if context
+				output.puts "#{file}(#{new_context}) [#{address}]"
+			end
+		else
+			output.puts line
+		end
+	end
+ensure
+	addr2lines.each_value do |addr2line|
+		addr2line.close
+	end
+end

data/helper-scripts/classic-rails-loader.rb

@@ -0,0 +1,135 @@
+#!/usr/bin/env ruby
+module PhusionPassenger
+module App
+	def self.options
+		return @@options
+	end
+
+	def self.format_exception(e)
+		result = "#{e} (#{e.class})"
+		if !e.backtrace.empty?
+			result << "\n  " << e.backtrace.join("\n  ")
+		end
+		return result
+	end
+
+	def self.exit_code_for_exception(e)
+		if e.is_a?(SystemExit)
+			return e.status
+		else
+			return 1
+		end
+	end
+	
+	def self.handshake_and_read_startup_request
+		STDOUT.sync = true
+		STDERR.sync = true
+		puts "!> I have control 1.0"
+		abort "Invalid initialization header" if STDIN.readline != "You have control 1.0\n"
+		
+		@@options = {}
+		while (line = STDIN.readline) != "\n"
+			name, value = line.strip.split(/: */, 2)
+			@@options[name] = value
+		end
+	end
+	
+	def self.init_passenger
+		$LOAD_PATH.unshift(options["ruby_libdir"])
+		require 'phusion_passenger'
+		PhusionPassenger.locate_directories(options["passenger_root"])
+		require 'phusion_passenger/native_support'
+		require 'phusion_passenger/ruby_core_enhancements'
+		require 'phusion_passenger/utils/tmpdir'
+		require 'phusion_passenger/loader_shared_helpers'
+		require 'phusion_passenger/request_handler'
+		LoaderSharedHelpers.init
+		@@options = LoaderSharedHelpers.sanitize_spawn_options(@@options)
+		Utils.passenger_tmpdir = options["generation_dir"]
+		NativeSupport.disable_stdio_buffering
+	rescue Exception => e
+		LoaderSharedHelpers.about_to_abort(e) if defined?(LoaderSharedHelpers)
+		puts "!> Error"
+		puts "!> "
+		puts format_exception(e)
+		exit exit_code_for_exception(e)
+	end
+	
+	def self.load_app
+		LoaderSharedHelpers.before_loading_app_code_step1('config/environment.rb', options)
+		LoaderSharedHelpers.before_loading_app_code_step2(options)
+		
+		require File.expand_path('config/environment')
+		require 'rails/version' if !defined?(Rails::VERSION)
+		if Rails::VERSION::MAJOR >= 3
+			LoaderSharedHelpers.about_to_abort
+			puts "!> Error"
+			puts "!> "
+			puts "!> This application is a Rails #{Rails::VERSION::MAJOR} " +
+				"application, but it was wrongly detected as a Rails " +
+				"1 or Rails 2 application. This is probably a bug in " +
+				"Phusion Passenger, so please report it."
+			exit 1
+		end
+		if !defined?(Dispatcher)
+			require 'dispatcher'
+		end
+		
+		# - No point in preloading the application sources if the garbage collector
+		#   isn't copy-on-write friendly.
+		# - Rails >= 2.2 already preloads application sources by default, so no need
+		#   to do that again.
+		if GC.copy_on_write_friendly? && !rails_will_preload_app_code?
+			# Rails 2.2+ uses application_controller.rb while old
+			# versions use application.rb.
+			require_dependency 'application'
+			['models','controllers','helpers'].each do |section|
+				Dir.glob("app/#{section}}/*.rb").each do |file|
+					require_dependency File.expand_path(file)
+				end
+			end
+		end
+		
+		LoaderSharedHelpers.after_loading_app_code(options)
+
+		if Rails::VERSION::STRING >= '2.3.0'
+			require 'phusion_passenger/rack/thread_handler_extension'
+			RequestHandler::ThreadHandler.send(:include, Rack::ThreadHandlerExtension)
+			app = ActionController::Dispatcher.new
+		else
+			require 'phusion_passenger/classic_rails/thread_handler_extension'
+			RequestHandler::ThreadHandler.send(:include, ClassicRails::ThreadHandlerExtension)
+			app = nil
+		end
+		handler = RequestHandler.new(STDIN, options.merge("app" => app))
+
+		LoaderSharedHelpers.before_handling_requests(false, options)
+		return handler
+		
+	rescue Exception => e
+		LoaderSharedHelpers.about_to_abort(e)
+		puts "!> Error"
+		puts "!> "
+		puts format_exception(e)
+		exit exit_code_for_exception(e)
+	end
+	
+	def self.rails_will_preload_app_code?
+		return ::Rails::Initializer.method_defined?(:load_application_classes)
+	end
+	
+	
+	################## Main code ##################
+	
+	
+	handshake_and_read_startup_request
+	init_passenger
+	handler = load_app
+	puts "!> Ready"
+	LoaderSharedHelpers.advertise_sockets(STDOUT, handler)
+	puts "!> "
+	handler.main_loop
+	LoaderSharedHelpers.after_handling_requests
+	
+end # module App
+end # module PhusionPassenger

data/helper-scripts/classic-rails-preloader.rb

@@ -0,0 +1,161 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+GC.copy_on_write_friendly = true if GC.respond_to?(:copy_on_write_friendly=)
+
+module PhusionPassenger
+module App
+	def self.options
+		return @@options
+	end
+
+	def self.format_exception(e)
+		result = "#{e} (#{e.class})"
+		if !e.backtrace.empty?
+			result << "\n  " << e.backtrace.join("\n  ")
+		end
+		return result
+	end
+
+	def self.exit_code_for_exception(e)
+		if e.is_a?(SystemExit)
+			return e.status
+		else
+			return 1
+		end
+	end
+	
+	def self.handshake_and_read_startup_request
+		STDOUT.sync = true
+		STDERR.sync = true
+		puts "!> I have control 1.0"
+		abort "Invalid initialization header" if STDIN.readline != "You have control 1.0\n"
+		
+		@@options = {}
+		while (line = STDIN.readline) != "\n"
+			name, value = line.strip.split(/: */, 2)
+			@@options[name] = value
+		end
+	end
+	
+	def self.init_passenger
+		$LOAD_PATH.unshift(options["ruby_libdir"])
+		require 'phusion_passenger'
+		PhusionPassenger.locate_directories(options["passenger_root"])
+		require 'phusion_passenger/native_support'
+		require 'phusion_passenger/ruby_core_enhancements'
+		require 'phusion_passenger/utils/tmpdir'
+		require 'phusion_passenger/preloader_shared_helpers'
+		require 'phusion_passenger/loader_shared_helpers'
+		require 'phusion_passenger/request_handler'
+		LoaderSharedHelpers.init
+		@@options = LoaderSharedHelpers.sanitize_spawn_options(@@options)
+		Utils.passenger_tmpdir = options["generation_dir"]
+		NativeSupport.disable_stdio_buffering
+	rescue Exception => e
+		LoaderSharedHelpers.about_to_abort(e) if defined?(LoaderSharedHelpers)
+		puts "!> Error"
+		puts "!> "
+		puts format_exception(e)
+		exit exit_code_for_exception(e)
+	end
+	
+	def self.preload_app
+		LoaderSharedHelpers.before_loading_app_code_step1('config/environment.rb', options)
+		LoaderSharedHelpers.before_loading_app_code_step2(options)
+		
+		require File.expand_path('config/environment')
+		require 'rails/version' if !defined?(Rails::VERSION)
+		if Rails::VERSION::MAJOR >= 3
+			LoaderSharedHelpers.about_to_abort
+			puts "!> Error"
+			puts "!> "
+			puts "This application is a Rails #{Rails::VERSION::MAJOR} " +
+				"application, but it was wrongly detected as a Rails " +
+				"1 or Rails 2 application. This is probably a bug in " +
+				"Phusion Passenger, so please report it."
+			exit 1
+		end
+		if !defined?(Dispatcher)
+			require 'dispatcher'
+		end
+		
+		# - No point in preloading the application sources if the garbage collector
+		#   isn't copy-on-write friendly.
+		# - Rails >= 2.2 already preloads application sources by default, so no need
+		#   to do that again.
+		if GC.copy_on_write_friendly? && !rails_will_preload_app_code?
+			# Rails 2.2+ uses application_controller.rb while old
+			# versions use application.rb.
+			require_dependency 'application'
+			['models','controllers','helpers'].each do |section|
+				Dir.glob("app/#{section}}/*.rb").each do |file|
+					require_dependency File.expand_path(file)
+				end
+			end
+		end
+		
+		LoaderSharedHelpers.after_loading_app_code(options)
+		
+	rescue Exception => e
+		LoaderSharedHelpers.about_to_abort(e)
+		puts "!> Error"
+		puts "!> "
+		puts format_exception(e)
+		exit exit_code_for_exception(e)
+	end
+	
+	def self.rails_will_preload_app_code?
+		return ::Rails::Initializer.method_defined?(:load_application_classes)
+	end
+	
+	def self.negotiate_spawn_command
+		puts "!> I have control 1.0"
+		abort "Invalid initialization header" if STDIN.readline != "You have control 1.0\n"
+		
+		begin
+			while (line = STDIN.readline) != "\n"
+				name, value = line.strip.split(/: */, 2)
+				options[name] = value
+			end
+			@@options = LoaderSharedHelpers.sanitize_spawn_options(@@options)
+			
+			LoaderSharedHelpers.before_handling_requests(true, options)
+			if Rails::VERSION::STRING >= '2.3.0'
+				require 'phusion_passenger/rack/thread_handler_extension'
+				RequestHandler::ThreadHandler.send(:include, Rack::ThreadHandlerExtension)
+				app = ActionController::Dispatcher.new
+			else
+				require 'phusion_passenger/classic_rails/thread_handler_extension'
+				RequestHandler::ThreadHandler.send(:include, ClassicRails::ThreadHandlerExtension)
+				app = nil
+			end
+			handler = RequestHandler.new(STDIN, options.merge("app" => app))
+		rescue Exception => e
+			LoaderSharedHelpers.about_to_abort(e)
+			puts "!> Error"
+			puts "!> "
+			puts format_exception(e)
+			exit exit_code_for_exception(e)
+		end
+
+		puts "!> Ready"
+		LoaderSharedHelpers.advertise_sockets(STDOUT, handler)
+		puts "!> "
+		return handler
+	end
+	
+	
+	################## Main code ##################
+	
+	
+	handshake_and_read_startup_request
+	init_passenger
+	preload_app
+	if PreloaderSharedHelpers.run_main_loop(options) == :forked
+		handler = negotiate_spawn_command
+		handler.main_loop
+		LoaderSharedHelpers.after_handling_requests
+	end
+	
+end # module App
+end # module PhusionPassenger

data/helper-scripts/node-loader.js

@@ -0,0 +1,314 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (c) 2012 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.
+ */
+
+var EventEmitter = require('events').EventEmitter;
+var net = require('net');
+GLOBAL.PhusionPassenger = new EventEmitter();
+
+/**
+ * Class for reading a stream line-by-line.
+ * Usage:
+ *
+ * reader = new LineReader(stream);
+ * reader.readLine(function(line) {
+ *     ...
+ *     // When done:
+ *     reader.close();
+ * });
+ */
+function LineReader(stream) {
+	var self = this;
+	this.stream = stream;
+
+	this.buffer = '';
+	this.lines = [];
+	this.callbacks = [];
+
+	function handleLineBuffer() {
+		if (self.lineBufferIsFull()) {
+			stream.pause();
+			self.paused = true;
+		}
+
+		while (self.buffer != undefined && self.lines.length > 0 && self.callbacks.length > 0) {
+			line = self.lines.shift();
+			callback = self.callbacks.shift();
+			callback(line);
+		}
+
+		if (self.buffer != undefined && !self.lineBufferIsFull() && self.paused) {
+			self.paused = false;
+			self.stream.resume();
+		}
+	}
+
+	function onData(data) {
+		var index, line, callback;
+
+		if (self.buffer == undefined) {
+			// Already closed.
+			return;
+		}
+
+		self.buffer += data;
+		while ((index = self.buffer.indexOf("\n")) != -1) {
+			line = self.buffer.substr(0, index + 1);
+			self.buffer = self.buffer.substr(index + 1);
+			self.lines.push(line);
+		}
+		handleLineBuffer();
+	}
+
+	function onEnd() {
+		if (self.buffer != undefined) {
+			self.lines.push(self.buffer);
+			self.buffer = '';
+			handleLineBuffer();
+			if (self.onEof) {
+				self.onEof();
+			}
+		}
+	}
+
+	this.onData = onData;
+	this.onEnd  = onEnd;
+	stream.on('data', onData);
+	stream.on('end', onEnd);
+	stream.resume();
+}
+
+LineReader.prototype.close = function() {
+	this.stream.pause();
+	this.stream.removeListener('data', this.onData);
+	this.stream.removeListener('end', this.onEnd);
+	this.buffer = undefined;
+	this.lines = undefined;
+}
+
+LineReader.prototype.lineBufferIsFull = function() {
+	return this.lines.length > 0;
+}
+
+LineReader.prototype.readLine = function(callback) {
+	if (this.lines.length > 0) {
+		var line = this.lines.shift();
+		if (!this.lineBufferIsFull() && this.paused) {
+			this.paused = false;
+			this.stream.resume();
+		}
+		callback(line);
+	} else {
+		this.callbacks.push(callback);
+	}
+}
+
+
+const
+	SPP_PARSING_SIZE = 0,
+	SPP_PARSING_HEADERS = 1,
+	SPP_DONE = 10,
+	SPP_ERROR = 11,
+	SPP_ENCODING = 'binary';
+
+function SessionProtocolParser() {
+	this.state = SPP_PARSING_SIZE;
+	this.processed = 0;
+	this.size = 0;
+	this.keys = [];
+}
+
+SessionProtocolParser.prototype.feed = function(buffer) {
+	var consumed = 0;
+	var locallyConsumed;
+
+	while (consumed < buffer.length && this.state != SPP_ERROR && this.state != SPP_DONE) {
+		switch (this.state) {
+		case SPP_PARSING_SIZE:
+			this.size += buffer[consumed] * Math.pow(256, 3 - this.processed);
+			locallyConsumed = 1;
+			this.processed++;
+			if (this.processed == 4) {
+				this.state = SPP_PARSING_HEADERS;
+				this.buffer = new Buffer(this.size);
+				this.processed = 0;
+			}
+			break;
+
+		case SPP_PARSING_HEADERS:
+			locallyConsumed = Math.min(buffer.length - consumed, this.buffer.length - this.processed);
+			buffer.copy(this.buffer, this.processed, consumed, consumed + locallyConsumed);
+			this.processed += locallyConsumed;
+			if (this.processed == this.buffer.length) {
+				this.state = SPP_DONE;
+				this.parse();
+			}
+			break;
+
+		default:
+			console.assert(false);
+			break;
+		}
+
+		consumed += locallyConsumed;
+	}
+
+	return consumed;
+}
+
+SessionProtocolParser.prototype.parse = function() {
+	function findZero(buffer, start) {
+		while (start < buffer.length) {
+			if (buffer[start] == 0) {
+				return start;
+			} else {
+				start++;
+			}
+		}
+		return -1;
+	}
+
+	var start = 0;
+	var key, value;
+
+	while (start < this.buffer.length) {
+		var keyEnd = findZero(this.buffer, start);
+		if (keyEnd != -1 && keyEnd + 1 < this.buffer.length) {
+			var valueStart = keyEnd + 1;
+			var valueEnd   = findZero(this.buffer, valueStart);
+			if (valueEnd != -1) {
+				key = this.buffer.toString(SPP_ENCODING, start, keyEnd);
+				value = this.buffer.toString(SPP_ENCODING, valueStart, valueEnd);
+				start = valueEnd + 1;
+				this.keys.push(key);
+				this[key] = value;
+			} else {
+				start = this.buffer.length;
+			}
+		} else {
+			start = this.buffer.length;
+		}
+	}
+}
+
+//var p = new SessionProtocolParser();
+//p.feed(new Buffer("\x00\x00\x00\x06hi\0ho\0"));
+//process.exit();
+
+
+function RequestHandler(readyCallback, clientCallback) {
+	var self = this;
+
+	function handleNewClient(socket) {
+		var state = 'PARSING_HEADER';
+		var parser = new SessionProtocolParser();
+
+		function handleData(data) {
+			if (state == 'PARSING_HEADER') {
+				parser.feed(data);
+				if (parser.state == SPP_DONE) {
+					state = 'HEADER_SEEN';
+					PhusionPassenger.emit('request', parser, socket);
+				} else if (parser.state == SPP_ERROR) {
+					console.error('Header parse error');
+					socket.destroySoon();
+				}
+			} else {
+				// Do nothing yet.
+			}
+		}
+
+		socket.on('data', handleData);
+	}
+
+	var server = net.createServer({ allowHalfOpen: true }, handleNewClient);
+	this.server = server;
+	server.listen(0, function() {
+		readyCallback(self);
+	});
+}
+
+
+/**************************/
+
+var reader = new LineReader(process.stdin);
+
+function readInitializationHeader() {
+	reader.readLine(function(line) {
+		if (line != "You have control 1.0\n") {
+			console.error('Invalid initialization header');
+			process.exit(1);
+		} else {
+			readOptions();
+		}
+	});
+}
+
+function readOptions() {
+	var options = {};
+
+	function readNextOption() {
+		reader.readLine(function(line) {
+			if (line == "\n") {
+				initialize(options);
+			} else if (line == "") {
+				console.error("End of stream encountered while reading initialization options");
+				process.exit(1);
+			} else {
+				var matches = line.replace(/\n/, '').match(/(.*?) *: *(.*)/);
+				options[matches[1]] = matches[2];
+				readNextOption();
+			}
+		});
+	}
+
+	readNextOption();
+}
+
+function initialize(options) {
+	PhusionPassenger.options = options;
+
+	PhusionPassenger.requestHandler = new RequestHandler(function() {
+		require(options.app_root + '/passenger_node.js');
+		process.stdout.write("!> Ready\n");
+		process.stdout.write("!> socket: main;tcp://127.0.0.1:" +
+			PhusionPassenger.requestHandler.server.address().port +
+			";session;0\n");
+		process.stdout.write("!> \n");
+	});
+
+	reader.close();
+	reader = undefined;
+	process.stdin.on('end', function() {
+		if (PhusionPassenger.listeners('exit').length == 0) {
+			process.exit(0);
+		} else {
+			PhusionPassenger.emit('exit');
+		}
+	});
+	process.stdin.resume();
+}
+
+process.stdout.write("!> I have control 1.0\n");
+readInitializationHeader();