mongrel2 0.0.1

data/lib/mongrel2/mixins.rb

@@ -0,0 +1,143 @@
+#!/usr/bin/ruby
+
+require 'logger'
+
+require 'mongrel2' unless defined?( Mongrel2 )
+require 'mongrel2/constants'
+
+
+module Mongrel2
+
+	# Add logging to a Mongrel2 class. Including classes get #log and #log_debug methods.
+	module Loggable
+
+		# A logging proxy class that wraps calls to the logger into calls that include
+		# the name of the calling class.
+		class ClassNameProxy
+
+			### Create a new proxy for the given +klass+.
+			def initialize( klass, force_debug=false )
+				@classname   = klass.name
+				@force_debug = force_debug
+			end
+
+			### Delegate debug messages to the global logger with the appropriate class name.
+			def debug( msg=nil, &block )
+				Mongrel2.logger.add( Logger::DEBUG, msg, @classname, &block )
+			end
+
+			### Delegate info messages to the global logger with the appropriate class name.
+			def info( msg=nil, &block )
+				return self.debug( msg, &block ) if @force_debug
+				Mongrel2.logger.add( Logger::INFO, msg, @classname, &block )
+			end
+
+			### Delegate warn messages to the global logger with the appropriate class name.
+			def warn( msg=nil, &block )
+				return self.debug( msg, &block ) if @force_debug
+				Mongrel2.logger.add( Logger::WARN, msg, @classname, &block )
+			end
+
+			### Delegate error messages to the global logger with the appropriate class name.
+			def error( msg=nil, &block )
+				return self.debug( msg, &block ) if @force_debug
+				Mongrel2.logger.add( Logger::ERROR, msg, @classname, &block )
+			end
+
+			### Delegate fatal messages to the global logger with the appropriate class name.
+			def fatal( msg=nil, &block )
+				Mongrel2.logger.add( Logger::FATAL, msg, @classname, &block )
+			end
+
+		end # ClassNameProxy
+
+		#########
+		protected
+		#########
+
+		### Copy constructor -- clear the original's log proxy.
+		def initialize_copy( original )
+			@log_proxy = @log_debug_proxy = nil
+			super
+		end
+
+		### Return the proxied logger.
+		def log
+			@log_proxy ||= ClassNameProxy.new( self.class )
+		end
+
+		### Return a proxied "debug" logger that ignores other level specification.
+		def log_debug
+			@log_debug_proxy ||= ClassNameProxy.new( self.class, true )
+		end
+
+	end # module Loggable
+
+	# A collection of ANSI color utility functions
+	module ANSIColorUtilities
+
+		# Set some ANSI escape code constants (Shamelessly stolen from Perl's
+		# Term::ANSIColor by Russ Allbery <rra@stanford.edu> and Zenin <zenin@best.com>
+		ANSI_ATTRIBUTES = {
+			'clear'      => 0,
+			'reset'      => 0,
+			'bold'       => 1,
+			'dark'       => 2,
+			'underline'  => 4,
+			'underscore' => 4,
+			'blink'      => 5,
+			'reverse'    => 7,
+			'concealed'  => 8,
+
+			'black'      => 30,   'on_black'   => 40,
+			'red'        => 31,   'on_red'     => 41,
+			'green'      => 32,   'on_green'   => 42,
+			'yellow'     => 33,   'on_yellow'  => 43,
+			'blue'       => 34,   'on_blue'    => 44,
+			'magenta'    => 35,   'on_magenta' => 45,
+			'cyan'       => 36,   'on_cyan'    => 46,
+			'white'      => 37,   'on_white'   => 47
+		}
+
+		###############
+		module_function
+		###############
+
+		### Create a string that contains the ANSI codes specified and return it
+		def ansi_code( *attributes )
+			attributes.flatten!
+			attributes.collect! {|at| at.to_s }
+			return '' unless /(?:vt10[03]|xterm(?:-color)?|linux|screen)/i =~ ENV['TERM']
+			attributes = ANSI_ATTRIBUTES.values_at( *attributes ).compact.join(';')
+
+			if attributes.empty?
+				return ''
+			else
+				return "\e[%sm" % attributes
+			end
+		end
+
+
+		### Colorize the given +string+ with the specified +attributes+ and return it, handling 
+		### line-endings, color reset, etc.
+		def colorize( *args )
+			string = ''
+
+			if block_given?
+				string = yield
+			else
+				string = args.shift
+			end
+
+			ending = string[/(\s)$/] || ''
+			string = string.rstrip
+
+			return ansi_code( args.flatten ) + string + ansi_code( 'reset' ) + ending
+		end
+
+	end # module ANSIColorUtilities
+
+end # module Mongrel2
+
+# vim: set nosta noet ts=4 sw=4:
+

data/lib/mongrel2/request.rb

@@ -0,0 +1,148 @@
+#!/usr/bin/ruby
+
+require 'tnetstring'
+require 'yajl'
+
+require 'mongrel2' unless defined?( Mongrel2 )
+require 'mongrel2/mixins'
+require 'mongrel2/table'
+
+
+# The Mongrel2 Request base class. Derivatives of this class represent a request from
+# a Mongrel2 server.
+class Mongrel2::Request
+	include Mongrel2::Loggable
+
+
+	# METHOD header -> request class mapping
+	@request_types = Hash.new {|h,k| h[k] = Mongrel2::Request }
+	class << self; attr_reader :request_types; end
+
+
+	### Register the specified +subclass+ as the class to instantiate when the +METHOD+
+	### header is one of the specified +req_methods+. This method exists for frameworks
+	### which wish to provide their own Request types.
+	###
+	### For example, if your framework has a JSONRequest class that inherits from
+	### Mongrel2::JSONRequest, and you want it to be returned from Mongrel2::Request.parse
+	### for METHOD=JSON requests:
+	###
+	###   class MyFramework::JSONRequest < Mongrel2::JSONRequest
+	###       register_request_type self, 'JSON'
+	###       
+	###       # Override #initialize to do any stuff specific to your
+	###       # request type, but you'll likely want to super() to
+	###       # Mongrel2::JSONRequest.
+	###       def initialize( * )
+	###           super
+	###           # Do some other stuff
+	###       end
+	###
+	###   end # class MyFramework::JSONRequest
+	###
+	### If you wish one of your subclasses to be used instead of Mongrel2::Request 
+	### for the default request class, register it with a METHOD of :__default.
+	def self::register_request_type( subclass, *req_methods )
+		req_methods.each do |methname|
+			if methname == :__default
+				# Clear cached lookups
+				Mongrel2.log.info "Registering %p as the default request type." % [ subclass ]
+				Mongrel2::Request.request_types.delete_if {|_, klass| klass == Mongrel2::Request }
+				Mongrel2::Request.request_types.default_proc = lambda {|h,k| h[k] = subclass }
+			else
+				Mongrel2.log.info "Registering %p for the %p method." % [ subclass, methname ]
+				Mongrel2::Request.request_types[ methname.to_sym ] = subclass
+			end
+		end
+	end
+
+
+	### Return the Mongrel2::Request class registered for the request method +methname+.
+	def self::subclass_for_method( methname )
+		return Mongrel2::Request.request_types[ methname.to_sym ]
+	end
+
+
+	### Parse the given +raw_request+ from a Mongrel2 server and return an appropriate
+	### request object.
+	def self::parse( raw_request )
+		sender, conn_id, path, rest = raw_request.split( ' ', 4 )
+		Mongrel2.log.debug "Parsing request for %p from %s:%s (rest: %p)" %
+			[ path, sender, conn_id, rest ]
+
+		# Extract the headers and the body, ignore the rest
+		headers, rest = TNetstring.parse( rest )
+		body, _       = TNetstring.parse( rest )
+
+		# Headers will be a JSON String when not using the TNetString protocol
+		if headers.is_a?( String )
+			Mongrel2.log.debug "  parsing old-style headers"
+			headers = Yajl::Parser.parse( headers )
+		end
+
+		# This isn't supposed to happen, but guard against it anyway
+		headers['METHOD'] =~ /^(\w+)$/ or
+			raise Mongrel2::UnhandledMethodError, headers['METHOD']
+		req_method = $1.untaint.to_sym
+		Mongrel2.log.debug "Request method is: %p" % [ req_method ]
+		concrete_class = self.subclass_for_method( req_method )
+
+		return concrete_class.new( sender, conn_id, path, headers, body, raw_request )
+	end
+
+
+
+	### Create a new Request object with the given +sender_id+, +conn_id+, +path+, +headers+, 
+	### and +body+. The optional +nil+ is for the raw request content, which can be useful
+	### later for debugging.
+	def initialize( sender_id, conn_id, path, headers, body, raw=nil )
+		@sender_id = sender_id
+		@conn_id   = Integer( conn_id )
+		@path      = path
+		@headers   = Mongrel2::Table.new( headers )
+		@body      = body
+
+		@raw       = raw
+	end
+
+
+	######
+	public
+	######
+
+	# The UUID of the requesting mongrel server
+	attr_reader :sender_id
+
+	# The listener ID on the server
+	attr_reader :conn_id
+
+	# The path component of the requested URL in HTTP, or the equivalent 
+	# for other request types
+	attr_reader :path
+
+	# The Mongrel2::Table object that contains the request headers
+	attr_reader :headers
+
+	# The request body data, if there is any, as a String
+	attr_reader :body
+
+	# The raw request content, if the request was parsed from mongrel2
+	attr_reader :raw
+
+
+	### Create a Mongrel2::Response that will respond to the same server/connection as
+	### the receiver. If you wish your specialized Request class to have a corresponding
+	### response type, you can override this method to achieve that.
+	def response
+		return Mongrel2::Response.from_request( self )
+	end
+
+	### Return +true+ if the request is a special 'disconnect' notification from Mongrel2.
+	def is_disconnect?
+		return false
+	end
+
+end # class Mongrel2::Request
+
+# vim: set nosta noet ts=4 sw=4:
+

data/lib/mongrel2/response.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/ruby
+
+require 'tnetstring'
+require 'yajl'
+
+require 'mongrel2' unless defined?( Mongrel2 )
+require 'mongrel2/mixins'
+
+
+# The Mongrel2 Response base class.
+class Mongrel2::Response
+	include Mongrel2::Loggable
+
+	# The default number of bytes of the response body to send to the mongrel2
+	# server at a time.
+	DEFAULT_CHUNKSIZE = 1024 * 512
+
+
+	### Create a response to the specified +request+ and return it.
+	def self::from_request( request )
+		Mongrel2.log.debug "Creating a %p to request %p" % [ self, request ]
+		return new( request.sender_id, request.conn_id )
+	end
+
+
+	### Create a new Response object for the specified +sender_id+, +conn_id+, and +body+.
+	def initialize( sender_id, conn_id, body='' )
+		@sender_id = sender_id
+		@conn_id   = conn_id
+		@body      = body
+	end
+
+
+	######
+	public
+	######
+
+	# The response's UUID; this corresponds to the mongrel2 server the response will
+	# be routed to by the Connection.
+	attr_accessor :sender_id
+
+	# The response's connection ID; this corresponds to the identifier of the connection
+	# the response will be routed to by the mongrel2 server
+	attr_accessor :conn_id
+
+	# The body of the response
+	attr_accessor :body
+
+
+	### Append the given +object+ to the response body. Returns the response for
+	### chaining.
+	def <<( object )
+		self.body << object
+		return self
+	end
+
+
+	### Write the given +objects+ to the response body, calling #to_s on each one.
+	def puts( *objects )
+		objects.each do |obj|
+			self << obj.to_s.chomp << $/
+		end
+	end
+
+
+	### Stringify the response, which just returns its body.
+	def to_s
+		return self.body
+	end
+
+end # class Mongrel2::Response
+
+# vim: set nosta noet ts=4 sw=4:
+

data/lib/mongrel2/table.rb

@@ -0,0 +1,216 @@
+#!/usr/bin/ruby
+
+require 'forwardable'
+
+require 'mongrel2' unless defined?( Mongrel2 )
+require 'mongrel2/mixins'
+
+
+# The Mongrel2 Table class. Instances of this class provide a case-insensitive hash-like
+# object that can store multiple values per key.
+#
+#   headers = Mongrel2::Table.new
+#   headers['User-Agent'] = 'PornBrowser 1.1.5'
+#   headers['user-agent']  # => 'PornBrowser 1.1.5'
+#   headers[:user_agent]   # => 'PornBrowser 1.1.5'
+#   headers.user_agent     # => 'PornBrowser 1.1.5'
+# 
+# == Author/s
+# 
+# * Michael Granger <ged@FaerieMUD.org>
+# * Mahlon E. Smith <mahlon@martini.nu>
+#
+class Mongrel2::Table
+	extend Forwardable
+	include Mongrel2::Loggable
+
+	# Methods that understand case-insensitive keys
+	KEYED_METHODS = [ :"[]", :"[]=", :delete, :fetch, :has_key?, :include?, :member?, :store ]
+
+
+	### Auto-generate methods which call the given +delegate+ after normalizing
+	### their first argument via +normalize_key+
+	def self::def_normalized_delegators( delegate, *syms )
+		syms.each do |methodname|
+			define_method( methodname ) do |key, *args|
+				nkey = normalize_key( key )
+				instance_variable_get( delegate ).
+					__send__( methodname, nkey, *args )
+			end
+		end
+	end
+
+
+	### Create a new Mongrel2::Table using the given +hash+ for initial
+	### values.
+	def initialize( initial_values={} )
+		@hash = {}
+		initial_values.each {|k,v| self.append(k => v) }
+	end
+
+
+	### Make sure the inner Hash is unique on duplications.
+	def initialize_copy( orig_table ) # :nodoc:
+		@hash = orig_table.to_hash
+	end
+
+
+	######
+	public
+	######
+
+	# Delegate a handful of methods to the underlying Hash after normalizing
+	# the key.
+	def_normalized_delegators :@hash, *KEYED_METHODS
+
+
+	# Delegate some methods to the underlying Hash
+	begin
+		unoverridden_methods = Hash.instance_methods(false).collect {|mname| mname.to_sym }
+		def_delegators :@hash, *( unoverridden_methods - KEYED_METHODS )
+	end
+
+
+	### Append the keys and values in the given +hash+ to the table, transforming
+	### each value into an array if there was an existing value for the same key.
+	def append( hash )
+		self.merge!( hash ) do |key,origval,newval|
+			[ origval, newval ].flatten
+		end
+	end
+
+
+	### Return the Table as RFC822 headers in a String
+	def to_s
+		@hash.collect do |header,value|
+			Array( value ).collect {|val|
+				"%s: %s" % [
+					normalize_header( header ),
+					val
+				]
+			}
+		end.flatten.sort.join( "\r\n" ) + "\r\n"
+	end
+
+
+	### Enumerator for iterating over the table contents, yielding each as an RFC822 header.
+	def each_header( &block )
+		enum = Enumerator.new do |yielder|
+			@hash.each do |header, value|
+				Array( value ).each do |val|
+					yielder.yield( normalize_header(header), val.to_s )
+				end
+			end
+		end
+
+		if block
+			return enum.each( &block )
+		else
+			return enum
+		end
+	end
+
+
+	### Return the Table as a hash.
+	def to_h
+		@hash.dup
+	end
+	alias_method :to_hash, :to_h
+
+
+	### Merge +other_table+ into the receiver.
+	def merge!( other_table, &merge_callback )
+		nhash = normalize_hash( other_table.to_hash )
+		@hash.merge!( nhash, &merge_callback )
+	end
+	alias_method :update!, :merge!
+
+
+	### Return a new table which is the result of merging the receiver
+	### with +other_table+ in the same fashion as Hash#merge. If the optional
+	### +merge_callback+ block is provided, it is called whenever there is a
+	### key collision between the two.
+	def merge( other_table, &merge_callback ) # :yields: key, original_value, new_value
+		other = self.dup
+		other.merge!( other_table, &merge_callback )
+		return other
+	end
+	alias_method :update, :merge
+
+
+	### Return an array containing the values associated with the given
+	### keys.
+	def values_at( *keys )
+		@hash.values_at( *(keys.collect {|k| normalize_key(k)}) )
+	end
+
+
+	#########
+	protected
+	#########
+
+	### Proxy method: handle getting/setting headers via methods instead of the
+	### index operator.
+	def method_missing( sym, *args )
+		# work magic
+		return super unless sym.to_s =~ /^([a-z]\w+)(=)?$/
+
+		# If it's an assignment, the (=)? will have matched
+		key, assignment = $1, $2
+
+		method_body = nil
+		if assignment
+			method_body = self.make_setter( key )
+		else
+			method_body = self.make_getter( key )
+		end
+
+		self.class.send( :define_method, sym, &method_body )
+		return self.method( sym ).call( *args )
+	end
+
+
+	### Create a Proc that will act as a setter for the given key
+	def make_setter( key )
+		return Proc.new {|new_value| self[ key ] = new_value }
+	end
+
+
+	### Create a Proc that will act as a getter for the given key
+	def make_getter( key )
+		return Proc.new { self[key] }
+	end
+
+
+	#######
+	private
+	#######
+
+	### Return a copy of +hash+ with all of its keys normalized by #normalize_key.
+	def normalize_hash( hash )
+		hash = hash.dup
+		hash.keys.each do |key|
+			nkey = normalize_key( key )
+			hash[ nkey ] = hash.delete( key ) if key != nkey
+		end
+
+		return hash
+	end
+
+
+	### Normalize the given key to equivalence
+	def normalize_key( key )
+		key.to_s.downcase.gsub('-', '_').to_sym
+	end
+
+
+	### Return the given key as an RFC822-style header label
+	def normalize_header( key )
+		key.to_s.split( '_' ).collect {|part| part.capitalize }.join( '-' )
+	end
+
+
+end # class Mongrel2::Table
+
+# vim: set nosta noet ts=4 sw=4:
+