mongrel2 0.0.1

data/lib/mongrel2/httprequest.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/ruby
+
+require 'mongrel2/request' unless defined?( Mongrel2::Request )
+require 'mongrel2/mixins'
+require 'mongrel2/httpresponse'
+
+
+# The Mongrel2 HTTP Request class. Instances of this class represent an HTTP request from
+# a Mongrel2 server.
+class Mongrel2::HTTPRequest < Mongrel2::Request
+	include Mongrel2::Loggable
+
+	# HTTP verbs from RFC2616
+	HANDLED_HTTP_METHODS = [ :OPTIONS, :GET, :HEAD, :POST, :PUT, :DELETE, :TRACE, :CONNECT ]
+
+	register_request_type( self, *HANDLED_HTTP_METHODS )
+
+
+	### Create a Mongrel2::HTTPResponse that corresponds to the receiver.
+	def response
+		return Mongrel2::HTTPResponse.from_request( self )
+	end
+
+
+	### Return +true+ if the request is an HTTP/1.1 request and its
+	### 'Connection' header indicates that the connection should stay
+	### open.
+	def keepalive?
+		unless self.headers[:version] == 'HTTP/1.1'
+			self.log.debug "Not an http/1.1 request: not persistent"
+			return false
+		end
+		conn_header = self.headers[:connection]
+		if !conn_header
+			self.log.debug "No Connection header: assume persistence"
+			return true
+		end
+
+		if conn_header.split( /\s*,\s*/ ).include?( 'close' )
+			self.log.debug "Connection: close header."
+			return false
+		else
+			self.log.debug "Connection header didn't contain 'close': assume persistence"
+			return true
+		end
+	end
+
+end # class Mongrel2::HTTPRequest
+
+# vim: set nosta noet ts=4 sw=4:
+

data/lib/mongrel2/httpresponse.rb

@@ -0,0 +1,187 @@
+#!/usr/bin/ruby
+
+require 'time'
+
+require 'mongrel2/response' unless defined?( Mongrel2::Response )
+require 'mongrel2/mixins'
+require 'mongrel2/constants'
+
+
+# The Mongrel2 HTTP Response class.
+class Mongrel2::HTTPResponse < Mongrel2::Response
+	include Mongrel2::Loggable,
+	        Mongrel2::Constants
+
+	# The format for building valid HTTP responses
+	STATUS_LINE_FORMAT = "HTTP/1.1 %03d %s".freeze
+
+	# The default status
+	DEFAULT_HTTP_STATUS = 200
+
+	# A network End-Of-Line
+	EOL = "\r\n".freeze
+
+	# The default content type
+	DEFAULT_CONTENT_TYPE = 'application/octet-stream'.freeze
+
+
+	### Set up a few things specific to HTTP responses
+	def initialize( sender_id, conn_id, body='', headers={} ) # :notnew:
+		if body.is_a?( Hash )
+			headers = body
+			body = ''
+		end
+
+		super( sender_id, conn_id, body )
+
+		@headers = Mongrel2::Table.new( headers )
+		@status = nil
+		self.reset
+	end
+
+
+	######
+	public
+	######
+
+	# The response headers (a Mongrel2::Table)
+	attr_reader :headers
+
+	# The HTTP status code
+	attr_accessor :status
+
+
+	### Stringify the response
+	def to_s
+		return [
+			self.status_line,
+			self.header_data,
+			self.body
+		].join( "\r\n" )
+	end
+
+
+	### Send the response status to the client
+	def status_line
+		self.log.warn "Building status line for unset status" if self.status.nil?
+
+		st = self.status || DEFAULT_HTTP_STATUS
+		return STATUS_LINE_FORMAT % [ st, HTTP::STATUS_NAME[st] ]
+	end
+
+
+	### Returns true if the response is ready to be sent to the client.
+	def handled?
+		return ! @status.nil?
+	end
+	alias_method :is_handled?, :handled?
+
+
+	### Return the numeric category of the response's status code (1-5)
+	def status_category
+		return 0 if self.status.nil?
+		return (self.status / 100).ceil
+	end
+
+
+	### Return true if response is in the 1XX range
+	def status_is_informational?
+		return self.status_category == 1
+	end
+
+	### Return true if response is in the 2XX range
+	def status_is_successful?
+		return self.status_category == 2
+	end
+
+
+	### Return true if response is in the 3XX range
+	def status_is_redirect?
+		return self.status_category == 3
+	end
+
+
+	### Return true if response is in the 4XX range
+	def status_is_clienterror?
+		return self.status_category == 4
+	end
+
+
+	### Return true if response is in the 5XX range
+	def status_is_servererror?
+		return self.status_category == 5
+	end
+
+
+	### Return the current response Content-Type.
+	def content_type
+		return self.headers[ :content_type ]
+	end
+
+
+	### Set the current response Content-Type.
+	def content_type=( type )
+		return self.headers[ :content_type ] = type
+	end
+
+
+	### Clear any existing headers and body and restore them to their defaults
+	def reset
+		@headers.clear
+		@headers[:server] = Mongrel2.version_string( true )
+		@status = nil
+		@body = ''
+
+		return true
+	end
+
+
+	### Return the current response header as a valid HTTP string.
+	def header_data
+		self.headers[:date] ||= Time.now.httpdate
+		self.headers[:content_length] ||= self.get_content_length
+
+		return self.headers.to_s
+	end
+
+
+	### Get the length of the body, either by calling its #length method if it has
+	### one, or using #seek and #tell if it implements those. If neither of those are
+	### possible, an exception is raised.
+	def get_content_length
+		if @body.respond_to?( :length )
+			return @body.length
+		elsif @body.respond_to?( :seek ) && @body.respond_to?( :tell )
+			starting_pos = @body.tell
+			@body.seek( 0, IO::SEEK_END )
+			length = @body.tell - starting_pos
+			@body.seek( starting_pos, IO::SEEK_SET )
+
+			return length
+		else
+			raise Mongrel2::ResponseError,
+				"No way to calculate the content length of the response (a %s)." %
+				[ @body.class.name ]
+		end
+	end
+
+
+	### Set the Connection header to allow pipelined HTTP.
+	def keepalive=( value )
+		self.headers[:connection] = value ? 'keep-alive' : 'close'
+	end
+	alias_method :pipelining_enabled=, :keepalive=
+
+
+	### Returns +true+ if the response has pipelining enabled.
+	def keepalive?
+		ka_header = self.headers[:connection]
+		return !ka_header.nil? && ka_header =~ /keep-alive/i
+		return false
+	end
+	alias_method :pipelining_enabled?, :keepalive?
+
+end # class Mongrel2::Response
+
+# vim: set nosta noet ts=4 sw=4:
+

data/lib/mongrel2/jsonrequest.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/ruby
+
+require 'yajl'
+
+require 'mongrel2/request' unless defined?( Mongrel2::Request )
+require 'mongrel2/mixins'
+
+
+# The Mongrel2 JSON Request class. Instances of this class represent a JSSocket request from
+# a Mongrel2 server.
+class Mongrel2::JSONRequest < Mongrel2::Request
+	include Mongrel2::Loggable
+
+	register_request_type( self, :JSON )
+
+
+	### Parse the body as JSON.
+	def initialize( sender_id, conn_id, path, headers, body, raw=nil )
+		super
+		self.log.debug "Parsing JSON request body"
+		@data = Yajl.load( body )
+		self.log.debug "  body is: %p" % [ @data ]
+	end
+
+
+	######
+	public
+	######
+
+	# The parsed request data
+	attr_reader :data
+
+
+	### Returns +true+ if the request is a special Mongrel2 'disconnect' 
+	### notification.
+	def is_disconnect?
+		return true if self.data['type'] == 'disconnect'
+	end
+
+end # class Mongrel2::JSONRequest
+
+# vim: set nosta noet ts=4 sw=4:
+

data/lib/mongrel2/logging.rb

@@ -0,0 +1,241 @@
+#!/usr/bin/ruby
+
+require 'logger'
+require 'date'
+
+require 'mongrel2' unless defined?( Mongrel2 )
+require 'mongrel2/mixins'
+
+
+# A mixin that adds a logging subsystem to the extended object.
+module Mongrel2::Logging
+
+	### Logging
+	# Log levels
+	LOG_LEVELS = {
+		'debug' => Logger::DEBUG,
+		'info'  => Logger::INFO,
+		'warn'  => Logger::WARN,
+		'error' => Logger::ERROR,
+		'fatal' => Logger::FATAL,
+	}.freeze
+	LOG_LEVEL_NAMES = LOG_LEVELS.invert.freeze
+
+
+	### Inclusion hook
+	def self::extended( mod )
+		super
+
+		class << mod
+			# the log formatter that will be used when the logging subsystem is reset
+			attr_accessor :default_log_formatter
+
+			# the logger that will be used when the logging subsystem is reset
+			attr_accessor :default_logger
+
+			# the logger that's currently in effect
+			attr_accessor :logger
+			alias_method :log, :logger
+			alias_method :log=, :logger=
+		end
+
+		mod.default_logger = mod.logger = Logger.new( $stderr )
+		mod.default_logger.level = $DEBUG ? Logger::DEBUG : Logger::WARN
+		mod.default_log_formatter = Mongrel2::Logging::Formatter.new( mod.default_logger )
+	end
+
+
+	### Reset the global logger object to the default
+	def reset_logger
+		self.logger = self.default_logger
+		self.logger.level = $DEBUG ? Logger::DEBUG : Logger::WARN
+		self.logger.formatter = self.default_log_formatter
+	end
+
+
+	### Returns +true+ if the global logger has not been set to something other than
+	### the default one.
+	def using_default_logger?
+		return self.logger == self.default_logger
+	end
+
+
+	# A alternate formatter for Logger instances.
+	class Formatter < Logger::Formatter
+
+		# The format to output unless debugging is turned on
+		DEFAULT_FORMAT = "[%1$s.%2$06d %3$d/%4$s] %5$5s -- %7$s\n"
+
+		# The format to output if debugging is turned on
+		DEFAULT_DEBUG_FORMAT = "[%1$s.%2$06d %3$d/%4$s] %5$5s {%6$s} -- %7$s\n"
+
+
+		### Initialize the formatter with a reference to the logger so it can check for log level.
+		def initialize( logger, format=DEFAULT_FORMAT, debug=DEFAULT_DEBUG_FORMAT ) # :notnew:
+			@logger       = logger
+			@format       = format
+			@debug_format = debug
+
+			super()
+		end
+
+		######
+		public
+		######
+
+		# The Logger object associated with the formatter
+		attr_accessor :logger
+
+		# The logging format string
+		attr_accessor :format
+
+		# The logging format string that's used when outputting in debug mode
+		attr_accessor :debug_format
+
+
+		### Log using either the DEBUG_FORMAT if the associated logger is at ::DEBUG level or
+		### using FORMAT if it's anything less verbose.
+		def call( severity, time, progname, msg )
+			args = [
+				time.strftime( '%Y-%m-%d %H:%M:%S' ),                         # %1$s
+				time.usec,                                                    # %2$d
+				Process.pid,                                                  # %3$d
+				Thread.current == Thread.main ? 'main' : Thread.object_id,    # %4$s
+				severity,                                                     # %5$s
+				progname,                                                     # %6$s
+				msg                                                           # %7$s
+			]
+
+			if @logger.level == Logger::DEBUG
+				return self.debug_format % args
+			else
+				return self.format % args
+			end
+		end
+	end # class LogFormatter
+
+
+	# A ANSI-colorized formatter for Logger instances.
+	class ColorFormatter < Logger::Formatter
+		extend Mongrel2::ANSIColorUtilities
+
+		# Color settings
+		LEVEL_FORMATS = {
+			:debug => colorize( :bold, :black ) {"[%1$s.%2$06d %3$d/%4$s] %5$5s {%6$s} -- %7$s\n"},
+			:info  => colorize( :normal ) {"[%1$s.%2$06d %3$d/%4$s] %5$5s -- %7$s\n"},
+			:warn  => colorize( :bold, :yellow ) {"[%1$s.%2$06d %3$d/%4$s] %5$5s -- %7$s\n"},
+			:error => colorize( :red ) {"[%1$s.%2$06d %3$d/%4$s] %5$5s -- %7$s\n"},
+			:fatal => colorize( :bold, :red ) {"[%1$s.%2$06d %3$d/%4$s] %5$5s -- %7$s\n"},
+		}
+
+
+		### Initialize the formatter with a reference to the logger so it can check for log level.
+		def initialize( logger, settings={} ) # :notnew:
+			settings = LEVEL_FORMATS.merge( settings )
+
+			@logger   = logger
+			@settings = settings
+
+			super()
+		end
+
+		######
+		public
+		######
+
+		# The Logger object associated with the formatter
+		attr_accessor :logger
+
+		# The formats, by level
+		attr_accessor :settings
+
+
+		### Log using the format associated with the severity
+		def call( severity, time, progname, msg )
+			args = [
+				time.strftime( '%Y-%m-%d %H:%M:%S' ),                         # %1$s
+				time.usec,                                                    # %2$d
+				Process.pid,                                                  # %3$d
+				Thread.current == Thread.main ? 'main' : Thread.object_id,    # %4$s
+				severity,                                                     # %5$s
+				progname,                                                     # %6$s
+				msg                                                           # %7$s
+			]
+
+			return self.settings[ severity.downcase.to_sym ] % args
+		end
+	end # class LogFormatter
+
+
+	# An alternate formatter for Logger instances that outputs +div+ HTML
+	# fragments.
+	class HtmlFormatter < Logger::Formatter
+
+		# The default HTML fragment that'll be used as the template for each log message.
+		HTML_LOG_FORMAT = %q{
+		<div class="log-message %5$s">
+			<span class="log-time">%1$s.%2$06d</span>
+			[
+				<span class="log-pid">%3$d</span>
+				/
+				<span class="log-tid">%4$s</span>
+			]
+			<span class="log-level">%5$s</span>
+			:
+			<span class="log-name">%6$s</span>
+			<span class="log-message-text">%7$s</span>
+		</div>
+		}
+
+		### Override the logging formats with ones that generate HTML fragments
+		def initialize( logger, format=HTML_LOG_FORMAT ) # :notnew:
+			@logger = logger
+			@format = format
+			super()
+		end
+
+
+		######
+		public
+		######
+
+		# The HTML fragment that will be used as a format() string for the log
+		attr_accessor :format
+
+
+		### Return a log message composed out of the arguments formatted using the
+		### formatter's format string
+		def call( severity, time, progname, msg )
+			args = [
+				time.strftime( '%Y-%m-%d %H:%M:%S' ),                         # %1$s
+				time.usec,                                                    # %2$d
+				Process.pid,                                                  # %3$d
+				Thread.current == Thread.main ? 'main' : Thread.object_id,    # %4$s
+				severity.downcase,                                            # %5$s
+				progname,                                                     # %6$s
+				html_escape( msg ).gsub(/\n/, '<br />')                       # %7$s
+			]
+
+			return self.format % args
+		end
+
+
+		#######
+		private
+		#######
+
+		### Return a copy of the specified +string+ with HTML special characters escaped as
+		### HTML entities.
+		def html_escape( string )
+			return string.
+				gsub( /&/, '&amp;' ).
+				gsub( /</, '&lt;' ).
+				gsub( />/, '&gt;' )
+		end
+
+	end # class HtmlLogFormatter
+
+end # module Mongrel2
+
+# vim: set nosta noet ts=4 sw=4:
+