passenger-jmazzi 2.2.9

data/lib/phusion_passenger/utils/rewindable_input.rb

@@ -0,0 +1,116 @@
+# Modified version of Rack::RewindableInput with Ruby 1.9 fix.
+
+require 'tempfile'
+
+module PhusionPassenger
+module Utils
+
+  # Class which can make any IO object rewindable, including non-rewindable ones. It does
+  # this by buffering the data into a tempfile, which is rewindable.
+  #
+  # rack.input is required to be rewindable, so if your input stream IO is non-rewindable
+  # by nature (e.g. a pipe or a socket) then you can wrap it in an object of this class
+  # to easily make it rewindable.
+  #
+  # Don't forget to call #close when you're done. This frees up temporary resources that
+  # RewindableInput uses, though it does *not* close the original IO object.
+  class RewindableInput
+    def initialize(io)
+      @io = io
+      @rewindable_io = nil
+      @unlinked = false
+    end
+    
+    def gets
+      make_rewindable unless @rewindable_io
+      @rewindable_io.gets
+    end
+    
+    def read(*args)
+      make_rewindable unless @rewindable_io
+      @rewindable_io.read(*args)
+    end
+    
+    def each(&block)
+      make_rewindable unless @rewindable_io
+      @rewindable_io.each(&block)
+    end
+    
+    def rewind
+      make_rewindable unless @rewindable_io
+      @rewindable_io.rewind
+    end
+    
+    # Closes this RewindableInput object without closing the originally
+    # wrapped IO oject. Cleans up any temporary resources that this RewindableInput
+    # has created.
+    #
+    # This method may be called multiple times. It does nothing on subsequent calls.
+    def close
+      if @rewindable_io
+        if @unlinked
+          @rewindable_io.close
+        else
+          @rewindable_io.close!
+        end
+        @rewindable_io = nil
+      end
+    end
+    
+    private
+    
+    # Ruby's Tempfile class has a bug. Subclass it and fix it.
+    class Tempfile < ::Tempfile
+      def _close
+        @tmpfile.close if @tmpfile
+        @data[1] = nil if @data
+        @tmpfile = nil
+      end
+    end
+
+    def make_rewindable
+      # Buffer all data into a tempfile. Since this tempfile is private to this
+      # RewindableInput object, we chmod it so that nobody else can read or write
+      # it. On POSIX filesystems we also unlink the file so that it doesn't
+      # even have a file entry on the filesystem anymore, though we can still
+      # access it because we have the file handle open.
+      @rewindable_io = Tempfile.new('RackRewindableInput')
+      @rewindable_io.chmod(0000)
+      @rewindable_io.set_encoding(Encoding::BINARY) if @rewindable_io.respond_to?(:set_encoding)
+      @rewindable_io.binmode
+      if filesystem_has_posix_semantics? && !tempfile_unlink_contains_bug?
+        @rewindable_io.unlink
+        @unlinked = true
+      end
+      
+      buffer = ""
+      while @io.read(1024 * 4, buffer)
+        entire_buffer_written_out = false
+        while !entire_buffer_written_out
+          written = @rewindable_io.write(buffer)
+          entire_buffer_written_out = written == buffer.size
+          if !entire_buffer_written_out
+            buffer.slice!(0 .. written - 1)
+          end
+        end
+      end
+      @rewindable_io.rewind
+    end
+    
+    def filesystem_has_posix_semantics?
+      RUBY_PLATFORM !~ /(mswin|mingw|cygwin|java)/
+    end
+    
+    def tempfile_unlink_contains_bug?
+      # The tempfile library as included in Ruby 1.9.1-p152 and later
+      # contains a bug: unlinking an open Tempfile object also closes
+      # it, which breaks our expected POSIX semantics. This problem
+      # has been fixed in Ruby 1.9.2, but the Ruby team chose not to
+      # include the bug fix in later versions of the 1.9.1 series.
+      ruby_engine = defined?(RUBY_ENGINE) ? RUBY_ENGINE : "ruby"
+      ruby_engine == "ruby" && RUBY_VERSION == "1.9.1" && RUBY_PATCHLEVEL >= 152
+    end
+  end
+
+end # module Utils
+end # module PhusionPassenger

data/lib/phusion_passenger/wsgi/application_spawner.rb

@@ -0,0 +1,104 @@
+#  Phusion Passenger - http://www.modrails.com/
+#  Copyright (c) 2008, 2009 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.
+
+require 'socket'
+require 'phusion_passenger/application'
+require 'phusion_passenger/message_channel'
+require 'phusion_passenger/utils'
+module PhusionPassenger
+module WSGI
+
+# Class for spawning WSGI applications.
+class ApplicationSpawner
+	include Utils
+	REQUEST_HANDLER = File.expand_path(File.dirname(__FILE__) + "/request_handler.py")
+	
+	def self.spawn_application(*args)
+		@@instance ||= ApplicationSpawner.new
+		@@instance.spawn_application(*args)
+	end
+	
+	# Spawn an instance of the given WSGI application. When successful, an
+	# Application object will be returned, which represents the spawned
+	# application.
+	#
+	# Raises:
+	# - AppInitError: The WSGI application raised an exception or called
+	#   exit() during startup.
+	# - SystemCallError, IOError, SocketError: Something went wrong.
+	def spawn_application(app_root, lower_privilege = true, lowest_user = "nobody", environment = "production")
+		a, b = UNIXSocket.pair
+		pid = safe_fork(self.class.to_s, true) do
+			a.close
+			
+			file_descriptors_to_leave_open = [0, 1, 2, b.fileno]
+			NativeSupport.close_all_file_descriptors(file_descriptors_to_leave_open)
+			close_all_io_objects_for_fds(file_descriptors_to_leave_open)
+			
+			run(MessageChannel.new(b), app_root, lower_privilege, lowest_user, environment)
+		end
+		b.close
+		Process.waitpid(pid) rescue nil
+		
+		channel = MessageChannel.new(a)
+		pid, socket_name, socket_type = channel.read
+		if pid.nil?
+			raise IOError, "Connection closed"
+		end
+		owner_pipe = channel.recv_io
+		return Application.new(@app_root, pid, socket_name,
+			socket_type, owner_pipe)
+	end
+
+private
+	def run(channel, app_root, lower_privilege, lowest_user, environment)
+		$0 = "WSGI: #{app_root}"
+		ENV['WSGI_ENV'] = environment
+		Dir.chdir(app_root)
+		if lower_privilege
+			lower_privilege('passenger_wsgi.py', lowest_user)
+		end
+		
+		socket_file = "#{passenger_tmpdir}/backends/wsgi_backend.#{Process.pid}.#{rand 10000000}"
+		server = UNIXServer.new(socket_file)
+		begin
+			reader, writer = IO.pipe
+			channel.write(Process.pid, socket_file, "unix")
+			channel.send_io(writer)
+			writer.close
+			channel.close
+			
+			NativeSupport.close_all_file_descriptors([0, 1, 2, server.fileno,
+				reader.fileno])
+			exec(REQUEST_HANDLER, socket_file, server.fileno.to_s,
+				reader.fileno.to_s)
+		rescue
+			server.close
+			File.unlink(socket_file)
+			raise
+		end
+	end
+end
+
+end # module WSGI
+end # module PhusionPassenger

data/lib/phusion_passenger/wsgi/request_handler.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python
+#  Phusion Passenger - http://www.modrails.com/
+#  Copyright (c) 2008, 2009 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.
+
+import socket, os, random, sys, struct, select, imp
+import exceptions, traceback
+
+from socket import _fileobject
+
+class RequestHandler:
+	def __init__(self, socket_file, server, owner_pipe, app):
+		self.socket_file = socket_file
+		self.server = server
+		self.owner_pipe = owner_pipe
+		self.app = app
+	
+	def cleanup(self):
+		self.server.close()
+		try:
+			os.remove(self.socket_file)
+		except:
+			pass
+	
+	def main_loop(self):
+		done = False
+		try:
+			while not done:
+				client, address = self.accept_connection()
+				if not client:
+					done = True
+					break
+				try:
+					try:
+						env, input_stream = self.parse_request(client)
+						if env:
+							if env['REQUEST_METHOD'] == 'ping':
+								self.process_ping(env, input_stream, client)
+							else:
+								self.process_request(env, input_stream, client)
+						else:
+							done = True
+					except KeyboardInterrupt:
+						done = True
+					except Exception, e:
+						traceback.print_tb(sys.exc_info()[2])
+						sys.stderr.write(str(e.__class__) + ": " + e.message + "\n")
+				finally:
+					try:
+						client.close()
+					except:
+						pass
+		except KeyboardInterrupt:
+			pass
+
+	def accept_connection(self):
+		result = select.select([self.owner_pipe, self.server.fileno()], [], [])[0]
+		if self.server.fileno() in result:
+			return self.server.accept()
+		else:
+			return (None, None)
+	
+	def parse_request(self, client):
+		buf = ''
+		while len(buf) < 4:
+			tmp = client.recv(4 - len(buf))
+			if len(tmp) == 0:
+				return (None, None)
+			buf += tmp
+		header_size = struct.unpack('>I', buf)[0]
+		
+		buf = ''
+		while len(buf) < header_size:
+			tmp = client.recv(header_size - len(buf))
+			if len(tmp) == 0:
+				return (None, None)
+			buf += tmp
+		
+		headers = buf.split("\0")
+		headers.pop() # Remove trailing "\0"
+		env = {}
+		i = 0
+		while i < len(headers):
+			env[headers[i]] = headers[i + 1]
+			i += 2
+		
+		return (env, client)
+	
+	def process_request(self, env, input_stream, output_stream):
+		# The WSGI speculation says that the input paramter object passed needs to
+		# implement a few file-like methods. This is the reason why we "wrap" the socket._socket
+		# into the _fileobject to solve this.
+		#
+		# Otherwise, the POST data won't be correctly retrieved by Django.
+		#
+		# See: http://www.python.org/dev/peps/pep-0333/#input-and-error-streams
+		env['wsgi.input']		 = _fileobject(input_stream,'r',512)
+		env['wsgi.errors']		 = sys.stderr
+		env['wsgi.version']		 = (1, 0)
+		env['wsgi.multithread']	 = False
+		env['wsgi.multiprocess'] = True
+		env['wsgi.run_once']	 = True
+		if env.get('HTTPS','off') in ('on', '1'):
+			env['wsgi.url_scheme'] = 'https'
+		else:
+			env['wsgi.url_scheme'] = 'http'
+			
+
+		# The following environment variables are required by WSCI PEP #333 
+		# see: http://www.python.org/dev/peps/pep-0333/#environ-variables
+		if 'HTTP_CONTENT_LENGTH' in env:
+			env['CONTENT_LENGTH'] = env.get('HTTP_CONTENT_LENGTH')
+			
+		
+		headers_set = []
+		headers_sent = []
+		
+		def write(data):
+			if not headers_set:
+				raise AssertionError("write() before start_response()")
+			elif not headers_sent:
+				# Before the first output, send the stored headers.
+				status, response_headers = headers_sent[:] = headers_set
+				output_stream.send('Status: %s\r\n' % status)
+				for header in response_headers:
+					output_stream.send('%s: %s\r\n' % header)
+				output_stream.send('\r\n')
+			output_stream.send(data)
+		
+		def start_response(status, response_headers, exc_info = None):
+			if exc_info:
+				try:
+					if headers_sent:
+						# Re-raise original exception if headers sent.
+						raise exc_info[0], exc_info[1], exc_info[2]
+				finally:
+					# Avoid dangling circular ref.
+					exc_info = None
+			elif headers_set:
+				raise AssertionError("Headers already set!")
+			
+			headers_set[:] = [status, response_headers]
+			return write
+		
+		result = self.app(env, start_response)
+		try:
+			for data in result:
+				# Don't send headers until body appears.
+				if data:
+					write(data)
+			if not headers_sent:
+				# Send headers now if body was empty.
+				write('')
+		finally:
+			if hasattr(result, 'close'):
+				result.close()
+	
+	def process_ping(self, env, input_stream, output_stream):
+		output_stream.send("pong")
+
+def import_error_handler(environ, start_response):
+	write = start_response('500 Import Error', [('Content-type', 'text/plain')])
+	write("An error occurred importing your passenger_wsgi.py")
+	raise KeyboardInterrupt # oh WEIRD.
+
+if __name__ == "__main__":
+	socket_file = sys.argv[1]
+	server = socket.fromfd(int(sys.argv[2]), socket.AF_UNIX, socket.SOCK_STREAM)
+	owner_pipe = int(sys.argv[3])
+	
+	try:
+		app_module = imp.load_source('passenger_wsgi', 'passenger_wsgi.py')
+		handler = RequestHandler(socket_file, server, owner_pipe, app_module.application)
+	except:
+		handler = RequestHandler(socket_file, server, owner_pipe, import_error_handler)
+
+	try:
+		handler.main_loop()
+	finally:
+		handler.cleanup()

data/man/passenger-config.1

@@ -0,0 +1,29 @@
+.TH "passenger-config" "1" "2.0" "Phusion Passenger" "User Commands"
+.SH "NAME"
+.LP 
+passenger\-config \- Show configuration settings for Phusion Passenger
+.SH "SYNOPSIS"
+.LP 
+\fBpassenger\-config\fR \fI\-\-root\fR | \fI\-\-version\fR
+.SH "DESCRIPTION"
+.LP 
+\fBpassenger\-config\fR shows the current configuration settings for Phusion Passenger. You need to select one of the following options.
+.SH "OPTIONS"
+.TP 
+\fB\-\-root\fR
+Shows the Phusion Passenger root directory
+.TP 
+\fB\-\-version\fR
+Shows the current Phusion Passenger version number
+.SH "SEE ALSO"
+.LP 
+passenger\-memory\-stats(1), passenger\-stress\-test(1), passenger\-status(8)
+.LP 
+User guide at http://www.modrails.com/documentation.html
+.SH "AUTHOR"
+.LP 
+Phusion Passenger is written by Phusion (http://www.phusion.nl)
+.LP 
+"Phusion" and "Phusion Passenger" are trademarks of Hongli Lai & Ninh Bui.
+.LP 
+This manual page was written by Neil Wilson <neil@brightbox.co.uk> for the Ubuntu project (but may be used by others).