passenger 5.0.0.beta3 → 5.0.0.rc1

data/lib/phusion_passenger/union_station/transaction.rb

@@ -26,143 +26,143 @@ PhusionPassenger.require_passenger_lib 'union_station/core'
 PhusionPassenger.require_passenger_lib 'utils/native_support_utils'
 
 module PhusionPassenger
-module UnionStation
+  module UnionStation
 
-class Transaction
-	include DebugLogging
+    class Transaction
+      include DebugLogging
 
-	attr_reader :txn_id
+      attr_reader :txn_id
 
-	def initialize(connection = nil, txn_id = nil)
-		if connection
-			@connection = connection
-			@txn_id = txn_id
-			connection.ref
-		end
-	end
+      def initialize(connection = nil, txn_id = nil)
+        if connection
+          @connection = connection
+          @txn_id = txn_id
+          connection.ref
+        end
+      end
 
-	def null?
-		return !@connection || !@connection.connected?
-	end
+      def null?
+        return !@connection || !@connection.connected?
+      end
 
-	def message(text)
-		if !@connection
-			timestamp_string = Core.timestamp_string
-			trace(3, "[Union Station log to null] #{@txn_id} #{timestamp_string} #{text}")
-			return
-		end
-		@connection.synchronize do
-			return if !@connection.connected?
-			begin
-				timestamp_string = Core.timestamp_string
-				trace(3, "[Union Station log] #{@txn_id} #{timestamp_string} #{text}")
-				@connection.channel.write("log", @txn_id, timestamp_string)
-				@connection.channel.write_scalar(text)
-			rescue SystemCallError, IOError => e
-				@connection.disconnect
-				warn("Error communicating with the logging agent: #{e.message}")
-			rescue Exception => e
-				@connection.disconnect
-				raise e
-			end
-		end
-	end
+      def message(text)
+        if !@connection
+          timestamp_string = Core.timestamp_string
+          trace(3, "[Union Station log to null] #{@txn_id} #{timestamp_string} #{text}")
+          return
+        end
+        @connection.synchronize do
+          return if !@connection.connected?
+          begin
+            timestamp_string = Core.timestamp_string
+            trace(3, "[Union Station log] #{@txn_id} #{timestamp_string} #{text}")
+            @connection.channel.write("log", @txn_id, timestamp_string)
+            @connection.channel.write_scalar(text)
+          rescue SystemCallError, IOError => e
+            @connection.disconnect
+            warn("Error communicating with the logging agent: #{e.message}")
+          rescue Exception => e
+            @connection.disconnect
+            raise e
+          end
+        end
+      end
 
-	def begin_measure(name, extra_info = nil)
-		if extra_info
-			extra_info_base64 = [extra_info].pack("m")
-			extra_info_base64.gsub!("\n", "")
-			extra_info_base64.strip!
-		else
-			extra_info_base64 = nil
-		end
-		times = Utils::NativeSupportUtils.process_times
-		message "BEGIN: #{name} (#{current_timestamp.to_s(36)},#{times.utime.to_s(36)},#{times.stime.to_s(36)}) #{extra_info_base64}"
-	end
+      def begin_measure(name, extra_info = nil)
+        if extra_info
+          extra_info_base64 = [extra_info].pack("m")
+          extra_info_base64.gsub!("\n", "")
+          extra_info_base64.strip!
+        else
+          extra_info_base64 = nil
+        end
+        times = Utils::NativeSupportUtils.process_times
+        message "BEGIN: #{name} (#{current_timestamp.to_s(36)},#{times.utime.to_s(36)},#{times.stime.to_s(36)}) #{extra_info_base64}"
+      end
 
-	def end_measure(name, error_encountered = false)
-		times = Utils::NativeSupportUtils.process_times
-		if error_encountered
-			message "FAIL: #{name} (#{current_timestamp.to_s(36)},#{times.utime.to_s(36)},#{times.stime.to_s(36)})"
-		else
-			message "END: #{name} (#{current_timestamp.to_s(36)},#{times.utime.to_s(36)},#{times.stime.to_s(36)})"
-		end
-	end
+      def end_measure(name, error_encountered = false)
+        times = Utils::NativeSupportUtils.process_times
+        if error_encountered
+          message "FAIL: #{name} (#{current_timestamp.to_s(36)},#{times.utime.to_s(36)},#{times.stime.to_s(36)})"
+        else
+          message "END: #{name} (#{current_timestamp.to_s(36)},#{times.utime.to_s(36)},#{times.stime.to_s(36)})"
+        end
+      end
 
-	def measure(name, extra_info = nil)
-		begin_measure(name, extra_info)
-		begin
-			yield
-		rescue Exception
-			error = true
-			is_closed = closed?
-			raise
-		ensure
-			end_measure(name, error) if !is_closed
-		end
-	end
+      def measure(name, extra_info = nil)
+        begin_measure(name, extra_info)
+        begin
+          yield
+        rescue Exception
+          error = true
+          is_closed = closed?
+          raise
+        ensure
+          end_measure(name, error) if !is_closed
+        end
+      end
 
-	def measured_time_points(name, begin_time, end_time, extra_info = nil)
-		if extra_info
-			extra_info_base64 = [extra_info].pack("m")
-			extra_info_base64.gsub!("\n", "")
-			extra_info_base64.strip!
-		else
-			extra_info_base64 = nil
-		end
-		begin_timestamp = begin_time.to_i * 1_000_000 + begin_time.usec
-		end_timestamp = end_time.to_i * 1_000_000 + end_time.usec
-		message "BEGIN: #{name} (#{begin_timestamp.to_s(36)}) #{extra_info_base64}"
-		message "END: #{name} (#{end_timestamp.to_s(36)})"
-	end
+      def measured_time_points(name, begin_time, end_time, extra_info = nil)
+        if extra_info
+          extra_info_base64 = [extra_info].pack("m")
+          extra_info_base64.gsub!("\n", "")
+          extra_info_base64.strip!
+        else
+          extra_info_base64 = nil
+        end
+        begin_timestamp = begin_time.to_i * 1_000_000 + begin_time.usec
+        end_timestamp = end_time.to_i * 1_000_000 + end_time.usec
+        message "BEGIN: #{name} (#{begin_timestamp.to_s(36)}) #{extra_info_base64}"
+        message "END: #{name} (#{end_timestamp.to_s(36)})"
+      end
 
-	def close(flush_to_disk = false)
-		@connection.synchronize do
-			return if !@connection.connected?
-			begin
-				# We need an ACK here. See thread_handler.rb finalize_request.
-				@connection.channel.write("closeTransaction", @txn_id,
-					Core.timestamp_string, true)
-				result = @connection.channel.read
-				if result != ["ok"]
-					raise "Expected logging agent to respond with 'ok', but got #{result.inspect} instead"
-				end
-				if flush_to_disk
-					@connection.channel.write("flush")
-					result = @connection.channel.read
-					if result != ["ok"]
-						raise "Invalid logging agent response #{result.inspect} to the 'flush' command"
-					end
-				end
-			rescue SystemCallError, IOError => e
-				@connection.disconnect
-				warn("Error communicating with the logging agent: #{e.message}")
-			rescue Exception => e
-				@connection.disconnect
-				raise e
-			ensure
-				@connection.unref
-				@connection = nil
-			end
-		end if @connection
-	end
+      def close(flush_to_disk = false)
+        @connection.synchronize do
+          return if !@connection.connected?
+          begin
+            # We need an ACK here. See thread_handler.rb finalize_request.
+            @connection.channel.write("closeTransaction", @txn_id,
+              Core.timestamp_string, true)
+            result = @connection.channel.read
+            if result != ["ok"]
+              raise "Expected logging agent to respond with 'ok', but got #{result.inspect} instead"
+            end
+            if flush_to_disk
+              @connection.channel.write("flush")
+              result = @connection.channel.read
+              if result != ["ok"]
+                raise "Invalid logging agent response #{result.inspect} to the 'flush' command"
+              end
+            end
+          rescue SystemCallError, IOError => e
+            @connection.disconnect
+            warn("Error communicating with the logging agent: #{e.message}")
+          rescue Exception => e
+            @connection.disconnect
+            raise e
+          ensure
+            @connection.unref
+            @connection = nil
+          end
+        end if @connection
+      end
 
-	def closed?
-		if @connection
-			@connection.synchronize do
-				return !@connection.connected?
-			end
-		else
-			return nil
-		end
-	end
+      def closed?
+        if @connection
+          @connection.synchronize do
+            return !@connection.connected?
+          end
+        else
+          return nil
+        end
+      end
 
-private
-	def current_timestamp
-		time = Core.current_time
-		return time.to_i * 1_000_000 + time.usec
-	end
-end
+    private
+      def current_timestamp
+        time = Core.current_time
+        return time.to_i * 1_000_000 + time.usec
+      end
+    end
 
-end # module UnionStation
+  end # module UnionStation
 end # module PhusionPassenger

data/lib/phusion_passenger/utils.rb

@@ -1,6 +1,6 @@
 # encoding: binary
 #  Phusion Passenger - https://www.phusionpassenger.com/
-#  Copyright (c) 2010-2014 Phusion
+#  Copyright (c) 2010-2015 Phusion
 #
 #  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
 #
@@ -24,171 +24,203 @@
 
 module PhusionPassenger
 
-# Utility functions.
-module Utils
-	extend self    # Make methods available as class methods.
-
-	def self.included(klass)
-		# When included into another class, make sure that Utils
-		# methods are made private.
-		public_instance_methods(false).each do |method_name|
-			klass.send(:private, method_name)
-		end
-	end
-
-	# Generate a long, cryptographically secure random ID string, which
-	# is also a valid filename.
-	def generate_random_id(method)
-		data = File.open("/dev/urandom", "rb") do |f|
-			f.read(64)
-		end
-		case method
-		when :base64
-			data = [data].pack('m')
-			data.gsub!("\n", '')
-			data.gsub!("+", '')
-			data.gsub!("/", '')
-			data.gsub!(/==$/, '')
-			return data
-		when :hex
-			return data.unpack('H*')[0]
-		else
-			raise ArgumentError, "Invalid method #{method.inspect}"
-		end
-	end
-
-	def retry_at_most(n, *exceptions)
-		n.times do |i|
-			begin
-				return yield
-			rescue *exceptions
-				if i == n - 1
-					raise
-				end
-			end
-		end
-	end
-
-	# Print the given exception, including the stack trace, to STDERR.
-	#
-	# +current_location+ is a string which describes where the code is
-	# currently at. Usually the current class name will be enough.
-	def print_exception(current_location, exception, destination = nil)
-		if !exception.is_a?(SystemExit)
-			data = exception.backtrace_string(current_location)
-			if defined?(DebugLogging) && self.is_a?(DebugLogging)
-				error(data)
-			else
-				destination ||= STDERR
-				destination.puts(data)
-				destination.flush if destination.respond_to?(:flush)
-			end
-		end
-	end
-
-	def get_socket_address_type(address)
-		if address =~ %r{^unix:.}
-			return :unix
-		elsif address =~ %r{^tcp://.}
-			return :tcp
-		else
-			return :unknown
-		end
-	end
-
-	def connect_to_server(address)
-		case get_socket_address_type(address)
-		when :unix
-			return UNIXSocket.new(address.sub(/^unix:/, ''))
-		when :tcp
-			host, port = address.sub(%r{^tcp://}, '').split(':', 2)
-			port = port.to_i
-			return TCPSocket.new(host, port)
-		else
-			raise ArgumentError, "Unknown socket address type for '#{address}'."
-		end
-	end
-
-	def local_socket_address?(address)
-		case get_socket_address_type(address)
-		when :unix
-			return true
-		when :tcp
-			host, port = address.sub(%r{^tcp://}, '').split(':', 2)
-			return host == "127.0.0.1" || host == "::1" || host == "localhost"
-		else
-			raise ArgumentError, "Unknown socket address type for '#{address}'."
-		end
-	end
-
-	# Checks whether the given process exists.
-	def process_is_alive?(pid)
-		begin
-			Process.kill(0, pid)
-			return true
-		rescue Errno::ESRCH
-			return false
-		rescue SystemCallError => e
-			return true
-		end
-	end
-
-	def require_option(hash, key)
-		if hash.has_key?(key)
-			return hash[key]
-		else
-			raise ArgumentError, "Option #{key.inspect} required"
-		end
-	end
-
-	def install_options_as_ivars(object, options, *keys)
-		keys.each do |key|
-			object.instance_variable_set("@#{key}", options[key])
-		end
-	end
-
-	# Returns a string which reports the backtraces for all threads,
-	# or if that's not supported the backtrace for the current thread.
-	def global_backtrace_report
-		if Kernel.respond_to?(:caller_for_all_threads)
-			all_thread_stacks = caller_for_all_threads
-		elsif Thread.respond_to?(:list) && Thread.public_method_defined?(:backtrace)
-			all_thread_stacks = {}
-			Thread.list.each do |thread|
-				all_thread_stacks[thread] = thread.backtrace
-			end
-		end
-
-		output = "========== Process #{Process.pid}: backtrace dump ==========\n"
-		if all_thread_stacks
-			all_thread_stacks.each_pair do |thread, stack|
-				if thread_name = thread[:name]
-					thread_name = "(#{thread_name})"
-				end
-				stack ||= ["(empty)"]
-				output << ("-" * 60) << "\n"
-				output << "# Thread: #{thread.inspect}#{thread_name}, "
-				if thread == Thread.main
-					output << "[main thread], "
-				end
-				if thread == Thread.current
-					output << "[current thread], "
-				end
-				output << "alive = #{thread.alive?}\n"
-				output << ("-" * 60) << "\n"
-				output << "    " << stack.join("\n    ")
-				output << "\n\n"
-			end
-		else
-			output << ("-" * 60) << "\n"
-			output << "# Current thread: #{Thread.current.inspect}\n"
-			output << ("-" * 60) << "\n"
-			output << "    " << caller.join("\n    ")
-		end
-		return output
-	end
-
-	####################################
-end
+  # Utility functions.
+  module Utils
+    extend self    # Make methods available as class methods.
+
+    def self.included(klass)
+      # When included into another class, make sure that Utils
+      # methods are made private.
+      public_instance_methods(false).each do |method_name|
+        klass.send(:private, method_name)
+      end
+    end
+
+    # Generate a long, cryptographically secure random ID string, which
+    # is also a valid filename.
+    def generate_random_id(method)
+      data = File.open("/dev/urandom", "rb") do |f|
+        f.read(64)
+      end
+      case method
+      when :base64
+        data = [data].pack('m')
+        data.gsub!("\n", '')
+        data.gsub!("+", '')
+        data.gsub!("/", '')
+        data.gsub!(/==$/, '')
+        return data
+      when :hex
+        return data.unpack('H*')[0]
+      else
+        raise ArgumentError, "Invalid method #{method.inspect}"
+      end
+    end
+
+    def retry_at_most(n, *exceptions)
+      n.times do |i|
+        begin
+          return yield
+        rescue *exceptions
+          if i == n - 1
+            raise
+          end
+        end
+      end
+    end
+
+    # Print the given exception, including the stack trace, to STDERR.
+    #
+    # +current_location+ is a string which describes where the code is
+    # currently at. Usually the current class name will be enough.
+    # It may be nil.
+    #
+    # This method requires 'ruby_core_enhancements'. If 'debug_logging'
+    # is loaded and included in the current module, it will use that for
+    # logging.
+    def print_exception(current_location, exception, destination = nil)
+      if !exception.is_a?(SystemExit)
+        data = exception.backtrace_string(current_location)
+        if defined?(DebugLogging) && self.is_a?(DebugLogging)
+          error(data)
+        else
+          destination ||= STDERR
+          destination.puts(data)
+          destination.flush if destination.respond_to?(:flush)
+        end
+      end
+    end
+
+    # A wrapper around Thread.new that installs a default exception handler.
+    # If an uncaught exception is encountered, it will immediately log the
+    # exception and abort the entire program.
+    #
+    # Thread#abort_on_exception is also supposed to do that, but the problem
+    # is that it is implemented by forwarding the uncaught exception
+    # to the main thread, which may not expect that particular exception
+    # and may not handle it properly. The exception could be forwarded to
+    # the main thread during any point of the main thread's execution.
+    #
+    # This method requires 'thread' and 'ruby_core_enhancements'.
+    # If 'debug_logging' is loaded and included in the current module,
+    # it will use that for logging.
+    def create_thread_and_abort_on_exception(*args)
+      Thread.new do
+        Thread.current.abort_on_exception = true
+        begin
+          yield(*args)
+        rescue SystemExit
+          raise
+        rescue Exception => e
+          print_exception(nil, e)
+          exit(1)
+        end
+      end
+    end
+
+    def get_socket_address_type(address)
+      if address =~ %r{^unix:.}
+        return :unix
+      elsif address =~ %r{^tcp://.}
+        return :tcp
+      else
+        return :unknown
+      end
+    end
+
+    def connect_to_server(address)
+      case get_socket_address_type(address)
+      when :unix
+        return UNIXSocket.new(address.sub(/^unix:/, ''))
+      when :tcp
+        host, port = address.sub(%r{^tcp://}, '').split(':', 2)
+        port = port.to_i
+        return TCPSocket.new(host, port)
+      else
+        raise ArgumentError, "Unknown socket address type for '#{address}'."
+      end
+    end
+
+    def local_socket_address?(address)
+      case get_socket_address_type(address)
+      when :unix
+        return true
+      when :tcp
+        host, port = address.sub(%r{^tcp://}, '').split(':', 2)
+        return host == "127.0.0.1" || host == "::1" || host == "localhost"
+      else
+        raise ArgumentError, "Unknown socket address type for '#{address}'."
+      end
+    end
+
+    # Checks whether the given process exists.
+    def process_is_alive?(pid)
+      begin
+        Process.kill(0, pid)
+        return true
+      rescue Errno::ESRCH
+        return false
+      rescue SystemCallError => e
+        return true
+      end
+    end
+
+    def require_option(hash, key)
+      if hash.has_key?(key)
+        return hash[key]
+      else
+        raise ArgumentError, "Option #{key.inspect} required"
+      end
+    end
+
+    def install_options_as_ivars(object, options, *keys)
+      keys.each do |key|
+        object.instance_variable_set("@#{key}", options[key])
+      end
+    end
+
+    # Returns a string which reports the backtraces for all threads,
+    # or if that's not supported the backtrace for the current thread.
+    def global_backtrace_report
+      if Kernel.respond_to?(:caller_for_all_threads)
+        all_thread_stacks = caller_for_all_threads
+      elsif Thread.respond_to?(:list) && Thread.public_method_defined?(:backtrace)
+        all_thread_stacks = {}
+        Thread.list.each do |thread|
+          all_thread_stacks[thread] = thread.backtrace
+        end
+      end
+
+      output = "========== Process #{Process.pid}: backtrace dump ==========\n"
+      if all_thread_stacks
+        all_thread_stacks.each_pair do |thread, stack|
+          if thread_name = thread[:name]
+            thread_name = "(#{thread_name})"
+          end
+          stack ||= ["(empty)"]
+          output << ("-" * 60) << "\n"
+          output << "# Thread: #{thread.inspect}#{thread_name}, "
+          if thread == Thread.main
+            output << "[main thread], "
+          end
+          if thread == Thread.current
+            output << "[current thread], "
+          end
+          output << "alive = #{thread.alive?}\n"
+          output << ("-" * 60) << "\n"
+          output << "    " << stack.join("\n    ")
+          output << "\n\n"
+        end
+      else
+        output << ("-" * 60) << "\n"
+        output << "# Current thread: #{Thread.current.inspect}\n"
+        output << ("-" * 60) << "\n"
+        output << "    " << caller.join("\n    ")
+      end
+      return output
+    end
+
+    ####################################
+  end
 
 end # module PhusionPassenger