passenger 2.0.6 → 2.1.2

data/lib/phusion_passenger/abstract_server_collection.rb

@@ -0,0 +1,301 @@
+#  Phusion Passenger - http://www.modrails.com/
+#  Copyright (C) 2008  Phusion
+#
+#  Phusion Passenger is a trademark of Hongli Lai & Ninh Bui.
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; version 2 of the License.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along
+#  with this program; if not, write to the Free Software Foundation, Inc.,
+#  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+require 'phusion_passenger/utils'
+
+module PhusionPassenger
+
+# This class maintains a collection of AbstractServer objects. One can add new
+# AbstractServer objects, or look up existing ones via a key.
+# AbstractServerCollection also automatically takes care of cleaning up
+# AbstractServers that have been idle for too long.
+#
+# This class exists because both SpawnManager and Railz::FrameworkSpawner need this kind
+# of functionality. SpawnManager maintains a collection of Railz::FrameworkSpawner
+# and Railz::ApplicationSpawner objects, while Railz::FrameworkSpawner maintains a
+# collection of Railz::ApplicationSpawner objects.
+#
+# This class is thread-safe as long as the specified thread-safety rules are followed.
+class AbstractServerCollection
+	attr_reader :next_cleaning_time
+	
+	include Utils
+	
+	def initialize
+		@collection = {}
+		@lock = Mutex.new
+		@cleanup_lock = Mutex.new
+		@cond = ConditionVariable.new
+		@done = false
+		
+		# The next time the cleaner thread should check for idle servers.
+		# The value may be nil, in which case the value will be calculated
+		# at the end of the #synchronized block.
+		#
+		# Invariant:
+		#    if value is not nil:
+		#       There exists an s in @collection with s.next_cleaning_time == value.
+		#       for all s in @collection:
+		#          if eligable_for_cleanup?(s):
+		#             s.next_cleaning_time <= value
+		@next_cleaning_time = Time.now + 60 * 60
+		@next_cleaning_time_changed = false
+		
+		@cleaner_thread = Thread.new do
+			begin
+				@lock.synchronize do
+					cleaner_thread_main
+				end
+			rescue Exception => e
+				print_exception(self.class.to_s, e)
+			end
+		end
+	end
+	
+	# Acquire the lock for this AbstractServerCollection object, and run
+	# the code within the block. The entire block will be a single atomic
+	# operation.
+	def synchronize
+		@lock.synchronize do
+			yield
+			if @next_cleaning_time.nil?
+				@collection.each_value do |server|
+					if @next_cleaning_time.nil? ||
+					   (eligable_for_cleanup?(server) &&
+					    server.next_cleaning_time < @next_cleaning_time
+					   )
+						@next_cleaning_time = server.next_cleaning_time
+					end
+				end
+				if @next_cleaning_time.nil?
+					# There are no servers in the collection with an idle timeout.
+					@next_cleaning_time = Time.now + 60 * 60
+				end
+				@next_cleaning_time_changed = true
+			end
+			if @next_cleaning_time_changed
+				@next_cleaning_time_changed = false
+				@cond.signal
+			end
+		end
+	end
+	
+	# Lookup and returns an AbstractServer with the given key.
+	#
+	# If there is no AbstractSerer associated with the given key, then the given
+	# block will be called. That block must return an AbstractServer object. Then,
+	# that object will be stored in the collection, and returned.
+	#
+	# The block must set the 'max_idle_time' attribute on the AbstractServer.
+	# AbstractServerCollection's idle cleaning interval will be adapted to accomodate
+	# with this. Changing the value outside this block is not guaranteed to have any
+	# effect on the idle cleaning interval.
+	# A max_idle_time value of nil or 0 means the AbstractServer will never be idle cleaned.
+	#
+	# If the block raises an exception, then the collection will not be modified,
+	# and the exception will be propagated.
+	#
+	# Precondition: this method must be called within a #synchronize block.
+	def lookup_or_add(key)
+		raise ArgumentError, "cleanup() has already been called." if @done
+		server = @collection[key]
+		if server
+			register_activity(server)
+			return server
+		else
+			server = yield
+			if !server.respond_to?(:start)
+				raise TypeError, "The block didn't return a valid AbstractServer object."
+			end
+			if eligable_for_cleanup?(server)
+				server.next_cleaning_time = Time.now + server.max_idle_time
+				if @next_cleaning_time && server.next_cleaning_time < @next_cleaning_time
+					@next_cleaning_time = server.next_cleaning_time
+					@next_cleaning_time_changed = true
+				end
+			end
+			@collection[key] = server
+			return server
+		end
+	end
+	
+	# Checks whether there's an AbstractServer object associated with the given key.
+	#
+	# Precondition: this method must be called within a #synchronize block.
+	def has_key?(key)
+		return @collection.has_key?(key)
+	end
+	
+	# Checks whether the collection is empty.
+	#
+	# Precondition: this method must be called within a #synchronize block.
+	def empty?
+		return @collection.empty?
+	end
+	
+	# Deletes from the collection the AbstractServer that's associated with the
+	# given key. If no such AbstractServer exists, nothing will happen.
+	#
+	# If the AbstractServer is started, then it will be stopped before deletion.
+	#
+	# Precondition: this method must be called within a #synchronize block.
+	def delete(key)
+		raise ArgumentError, "cleanup() has already been called." if @done
+		server = @collection[key]
+		if server
+			if server.started?
+				server.stop
+			end
+			@collection.delete(key)
+			if server.next_cleaning_time == @next_cleaning_time
+				@next_cleaning_time = nil
+			end
+		end
+	end
+	
+	# Notify this AbstractServerCollection that +server+ has performed an activity.
+	# This AbstractServerCollection will update the idle information associated with +server+
+	# accordingly.
+	#
+	# lookup_or_add already automatically updates idle information, so you only need to
+	# call this method if the time at which the server has performed an activity is
+	# not close to the time at which lookup_or_add had been called.
+	#
+	# Precondition: this method must be called within a #synchronize block.
+	def register_activity(server)
+		if eligable_for_cleanup?(server)
+			if server.next_cleaning_time == @next_cleaning_time
+				@next_cleaning_time = nil
+			end
+			server.next_cleaning_time = Time.now + server.max_idle_time
+		end
+	end
+	
+	# Tell the cleaner thread to check the collection as soon as possible, instead
+	# of sleeping until the next scheduled cleaning time.
+	#
+	# Precondition: this method must NOT be called within a #synchronize block.
+	def check_idle_servers!
+		@lock.synchronize do
+			@next_cleaning_time = Time.now - 60 * 60
+			@cond.signal
+		end
+	end
+	
+	# Iterate over all AbstractServer objects.
+	#
+	# Precondition: this method must be called within a #synchronize block.
+	def each
+		each_pair do |key, server|
+			yield server
+		end
+	end
+	
+	# Iterate over all keys and associated AbstractServer objects.
+	#
+	# Precondition: this method must be called within a #synchronize block.
+	def each_pair
+		raise ArgumentError, "cleanup() has already been called." if @done
+		@collection.each_pair do |key, server|
+			yield(key, server)
+		end
+	end
+	
+	# Delete all AbstractServers from the collection. Each AbstractServer will be
+	# stopped, if necessary.
+	#
+	# Precondition: this method must be called within a #synchronize block.
+	def clear
+		@collection.each_value do |server|
+			if server.started?
+				server.stop
+			end
+		end
+		@collection.clear
+		@next_cleaning_time = nil
+	end
+	
+	# Cleanup all resources used by this AbstractServerCollection. All AbstractServers
+	# from the collection will be deleted. Each AbstractServer will be stopped, if
+	# necessary. The background thread which removes idle AbstractServers will be stopped.
+	#
+	# After calling this method, this AbstractServerCollection object will become
+	# unusable.
+	#
+	# Precondition: this method must *NOT* be called within a #synchronize block.
+	def cleanup
+		@cleanup_lock.synchronize do
+			return if @done
+			@lock.synchronize do
+				@done = true
+				@cond.signal
+			end
+			@cleaner_thread.join
+			clear
+		end
+	end
+
+private
+	def cleaner_thread_main
+		while !@done
+			current_time = Time.now
+			# We add a 0.2 seconds delay to the sleep time because system
+			# timers are not entirely accurate.
+			sleep_time = (@next_cleaning_time - current_time).to_f + 0.2
+			if sleep_time > 0 && @cond.timed_wait(@lock, sleep_time)
+				next
+			else
+				keys_to_delete = nil
+				@next_cleaning_time = nil
+				@collection.each_pair do |key, server|
+					if eligable_for_cleanup?(server)
+						# Cleanup this server if its idle timeout has expired.
+						if server.next_cleaning_time <= current_time
+							keys_to_delete ||= []
+							keys_to_delete << key
+							if server.started?
+								server.stop
+							end
+						# If not, then calculate the next cleaning time because
+						# we're iterating the collection anyway.
+						elsif @next_cleaning_time.nil? ||
+						      server.next_cleaning_time < @next_cleaning_time
+							@next_cleaning_time = server.next_cleaning_time
+						end
+					end
+				end
+				if keys_to_delete
+					keys_to_delete.each do |key|
+						@collection.delete(key)
+					end
+				end
+				if @next_cleaning_time.nil?
+					# There are no servers in the collection with an idle timeout.
+					@next_cleaning_time = Time.now + 60 * 60
+				end
+			end
+		end
+	end
+	
+	# Checks whether the given server is eligible for being idle cleaned.
+	def eligable_for_cleanup?(server)
+		return server.max_idle_time && server.max_idle_time != 0
+	end
+end
+
+end # module PhusionPassenger

data/lib/phusion_passenger/admin_tools.rb

@@ -0,0 +1,25 @@
+module PhusionPassenger
+
+module AdminTools
+	def self.tmpdir
+		["PASSENGER_TMPDIR", "TMPDIR"].each do |name|
+			if ENV.has_key?(name) && !ENV[name].empty?
+				return ENV[name]
+			end
+		end
+		return "/tmp"
+	end
+	
+	def self.process_is_alive?(pid)
+		begin
+			Process.kill(0, pid)
+			return true
+		rescue Errno::ESRCH
+			return false
+		rescue SystemCallError => e
+			return true
+		end
+	end
+end # module AdminTools
+
+end # module PhusionPassenger

data/lib/phusion_passenger/admin_tools/control_process.rb

@@ -0,0 +1,107 @@
+require 'rexml/document'
+require 'fileutils'
+require 'phusion_passenger/admin_tools'
+require 'phusion_passenger/message_channel'
+
+module PhusionPassenger
+module AdminTools
+
+class ControlProcess
+	class Instance
+		attr_accessor :pid, :socket_name, :socket_type, :sessions, :uptime
+		INT_PROPERTIES = [:pid, :sessions]
+	end
+
+	attr_accessor :path
+	attr_accessor :pid
+	
+	def self.list(clean_stale = true)
+		results = []
+		Dir["#{AdminTools.tmpdir}/passenger.*"].each do |dir|
+			dir =~ /passenger.(\d+)\Z/
+			next if !$1
+			pid = $1.to_i
+			begin
+				results << ControlProcess.new(pid, dir)
+			rescue ArgumentError
+				# Stale Passenger temp folder. Clean it up if instructed.
+				if clean_stale
+					puts "*** Cleaning stale folder #{dir}"
+					FileUtils.rm_rf(dir)
+				end
+			end
+		end
+		return results
+	end
+	
+	def initialize(pid, path = nil)
+		if !AdminTools.process_is_alive?(pid)
+			raise ArgumentError, "There is no control process with PID #{pid}."
+		end
+		@pid = pid
+		if path
+			@path = path
+		else
+			@path = "#{AdminTools.tmpdir}/passenger.#{pid}"
+		end
+	end
+	
+	def status
+		reload
+		return @status
+	end
+	
+	def xml
+		reload
+		return @xml
+	end
+	
+	def domains
+		reload
+		return @domains
+	end
+	
+	def instances
+		return domains.map do |domain|
+			domain[:instances]
+		end.flatten
+	end
+	
+private
+	def reload
+		return if @status
+		File.open("#{path}/status.fifo", 'r') do |f|
+			channel = MessageChannel.new(f)
+			@status = channel.read_scalar
+			@xml = channel.read_scalar
+		end
+		doc = REXML::Document.new(@xml)
+		
+		@domains = []
+		doc.elements.each("info/domains/domain") do |domain|
+			instances = []
+			d = {
+				:name => domain.elements["name"].text,
+				:instances => instances
+			}
+			domain.elements.each("instances/instance") do |instance|
+				i = Instance.new
+				instance.elements.each do |element|
+					if i.respond_to?("#{element.name}=")
+						if Instance::INT_PROPERTIES.include?(element.name.to_sym)
+							value = element.text.to_i
+						else
+							value = element.text
+						end
+						i.send("#{element.name}=", value)
+					end
+				end
+				instances << i
+			end
+			@domains << d
+		end
+	end
+end
+
+end # module AdminTools
+end # module PhusionPassenger

data/lib/{passenger → phusion_passenger}/application.rb

@@ -17,8 +17,8 @@
 #  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 require 'rubygems'
-require 'passenger/exceptions'
-module Passenger
+require 'phusion_passenger/exceptions'
+module PhusionPassenger
 
 # Represents a single application instance.
 class Application
@@ -29,10 +29,16 @@ class Application
 	# The process ID of this application instance.
 	attr_reader :pid
 	
-	# The name of the Unix socket on which the application instance will accept
-	# new connections.
+	# The name of the socket on which the application instance will accept
+	# new connections. See #listen_socket_type on how one should interpret
+	# this value.
 	attr_reader :listen_socket_name
 	
+	# The type of socket that #listen_socket_name refers to. Currently this
+	# is always 'unix', which means that #listen_socket_name refers to the
+	# filename of a Unix domain socket.
+	attr_reader :listen_socket_type
+	
 	# The owner pipe of the application instance (an IO object). Please see
 	# RequestHandler for a description of the owner pipe.
 	attr_reader :owner_pipe
@@ -81,23 +87,14 @@ class Application
 
 	# Creates a new instance of Application. The parameters correspond with the attributes
 	# of the same names. No exceptions will be thrown.
-	def initialize(app_root, pid, listen_socket_name, using_abstract_namespace, owner_pipe)
+	def initialize(app_root, pid, listen_socket_name, listen_socket_type, owner_pipe)
 		@app_root = app_root
 		@pid = pid
 		@listen_socket_name = listen_socket_name
-		@using_abstract_namespace = using_abstract_namespace
+		@listen_socket_type = listen_socket_type
 		@owner_pipe = owner_pipe
 	end
 	
-	# Whether _listen_socket_name_ refers to a Unix socket in the abstract namespace.
-	# In any case, _listen_socket_name_ does *not* contain the leading null byte.
-	#
-	# Note that at the moment, only Linux seems to support abstract namespace Unix
-	# sockets.
-	def using_abstract_namespace?
-		return @using_abstract_namespace
-	end
-	
 	# Close the connection with the application instance. If there are no other
 	# processes that have connections to this application instance, then it will
 	# shutdown as soon as possible.
@@ -108,4 +105,4 @@ class Application
 	end
 end
 
-end # module Passenger
+end # module PhusionPassenger