mongrel2 0.0.1

data/History.rdoc

@@ -0,0 +1,4 @@
+== v0.0.1 [2011-09-12] Michael Granger <ged@FaerieMUD.org>
+
+Initial release.
+

data/Manifest.txt

@@ -0,0 +1,66 @@
+History.rdoc
+Manifest.txt
+README.rdoc
+Rakefile
+bin/m2sh.rb
+data/mongrel2/bootstrap.html
+data/mongrel2/config.sql
+data/mongrel2/mimetypes.sql
+examples/README.txt
+examples/config.rb
+examples/helloworld-handler.rb
+examples/request-dumper.rb
+examples/request-dumper.tmpl
+examples/run
+lib/mongrel2.rb
+lib/mongrel2/config.rb
+lib/mongrel2/config/directory.rb
+lib/mongrel2/config/dsl.rb
+lib/mongrel2/config/handler.rb
+lib/mongrel2/config/host.rb
+lib/mongrel2/config/log.rb
+lib/mongrel2/config/mimetype.rb
+lib/mongrel2/config/proxy.rb
+lib/mongrel2/config/route.rb
+lib/mongrel2/config/server.rb
+lib/mongrel2/config/setting.rb
+lib/mongrel2/config/statistic.rb
+lib/mongrel2/connection.rb
+lib/mongrel2/constants.rb
+lib/mongrel2/control.rb
+lib/mongrel2/exceptions.rb
+lib/mongrel2/handler.rb
+lib/mongrel2/httprequest.rb
+lib/mongrel2/httpresponse.rb
+lib/mongrel2/jsonrequest.rb
+lib/mongrel2/logging.rb
+lib/mongrel2/mixins.rb
+lib/mongrel2/request.rb
+lib/mongrel2/response.rb
+lib/mongrel2/table.rb
+lib/mongrel2/xmlrequest.rb
+spec/lib/constants.rb
+spec/lib/helpers.rb
+spec/lib/matchers.rb
+spec/mongrel2/config/directory_spec.rb
+spec/mongrel2/config/dsl_spec.rb
+spec/mongrel2/config/handler_spec.rb
+spec/mongrel2/config/host_spec.rb
+spec/mongrel2/config/log_spec.rb
+spec/mongrel2/config/proxy_spec.rb
+spec/mongrel2/config/route_spec.rb
+spec/mongrel2/config/server_spec.rb
+spec/mongrel2/config/setting_spec.rb
+spec/mongrel2/config/statistic_spec.rb
+spec/mongrel2/config_spec.rb
+spec/mongrel2/connection_spec.rb
+spec/mongrel2/constants_spec.rb
+spec/mongrel2/control_spec.rb
+spec/mongrel2/handler_spec.rb
+spec/mongrel2/httpresponse_spec.rb
+spec/mongrel2/logging_spec.rb
+spec/mongrel2/mixins_spec.rb
+spec/mongrel2/request_spec.rb
+spec/mongrel2/response_spec.rb
+spec/mongrel2/table_spec.rb
+spec/mongrel2_spec.rb

data/README.rdoc

@@ -0,0 +1,169 @@
+
+= Ruby-Mongrel2
+
+* http://deveiate.org/projects/Ruby-Mongrel2/
+
+== Description
+
+A complete Ruby connector for Mongrel2[http://mongrel2.org/].
+
+This library includes configuration-database ORM classes, a Ruby
+implementation of the 'm2sh' tool, a configuration DSL for generating config
+databases in pure Ruby, a Control port interface object, handler classes for creating applications or higher-level frameworks.
+
+It differs from the original Mongrel2 Ruby library (m2r), and the
+mongrel2-rack library in several ways:
+
+* It uses the C extension for 0MQ (zmq) instead of the FFI one. If you
+  strongly prefer the FFI library, both of the other Mongrel2 libraries use
+  it, so you'll want to stick to one of them.
+
+* It doesn't come with a Rack handler, or Rails examples, or anything fancy. I
+  intend to build my own webby framework bits around Mongrel2, and I thought
+  maybe someone else might want to as well. If you don't, well again, there
+  are two other libraries for you.
+
+* It includes configuration stuff. I want to make tools that use the Mongrel2
+  config database, so I wrote config classes. Sequel::Model made it
+  stupid-easy. There's also a DSL for generating a config database, too,
+  mostly because I found it an interesting exercise, and I like the way it
+  looks.
+
+
+== Installation
+
+    gem install mongrel2
+
+
+This library uses Jeremy Hinegardner's 'amalgalite' library for the config ORM classes, but it will also fall back to using the sqlite3 library instead:
+
+    # Loading the sqlite3 library explicitly
+    $ rspec -rsqlite3 -cfp spec
+    >>> Using SQLite3 1.3.4 for DB access.
+    .....[...]
+
+    Finished in 5.53 seconds
+    102 examples, 0 failures
+
+    # No -rsqlite3 means amalgalite loads first.
+    $ rspec -cfp spec
+    >>> Using Amalgalite 1.1.2 for DB access.
+    .....[...]
+
+    Finished in 3.67 seconds
+    102 examples, 0 failures
+
+
+== Usage
+
+The library consists of three major parts: the Config ORM classes, the
+Handler classes, and the Control class.
+
+=== Config ORM Classes
+
+There's one class per table like with most ORMs, a Mongrel2::Config::DSL mixin
+for adding the Ruby configuration DSL to your namespace, and the top-level
+Mongrel2::Config class, which manages the database connection, installs the
+schema, etc.
+
+* Mongrel2::Config
+  * Mongrel2::Config::DSL
+  * Mongrel2::Config::Server
+  * Mongrel2::Config::Host
+  * Mongrel2::Config::Route
+  * Mongrel2::Config::Directory
+  * Mongrel2::Config::Proxy
+  * Mongrel2::Config::Handler
+  * Mongrel2::Config::Setting
+  * Mongrel2::Config::Mimetype
+  * Mongrel2::Config::Statistic
+  * Mongrel2::Config::Log
+
+
+=== Handler Classes
+
+The main handler class is, unsurprisingly, Mongrel2::Handler. It uses a
+Mongrel2::Connection object to talk to the server, wrapping the request data
+up in a Mongrel2::Request object, and expecting a Mongrel2::Response in
+response.
+
+There are specialized Request classes for each of the kinds of requests
+Mongrel2 sends:
+
+* Mongrel2::HTTPRequest
+* Mongrel2::JSONRequest
+* Mongrel2::XMLRequest
+
+These are all {overridable}[rdoc-ref:Mongrel2::Request.register_request_type]
+if you should want a more-specialized class for one of them.
+
+The Mongrel2::Handler class itself has documentation on how to write your own
+handlers.
+
+
+=== The Control Class
+
+The Mongrel2::Control class is an object interface to {the Mongrel2 control
+port}[http://mongrel2.org/static/mongrel2-manual.html#x1-390003.8]. It can be
+used to stop and restart the server, check its status, etc.
+
+
+=== Other Classes
+
+There are a few other classes and modules, too:
+
+[Mongrel2::Constants]
+  A collection of constants used throughout the rest of the library.
+[Mongrel2::Loggable]
+  A mixin for adding logging methods to a class.
+[Mongrel2::Table]
+  A case-insensitive hash-like object class that can store multiple values per 
+  key, and serialize itself into RFC822-style headers. Used for 
+  request[rdoc-ref:Mongrel2::Request#headers] and 
+  response[rdoc-ref:Mongrel2::Response#headers] headers.
+
+
+== Contributing
+
+You can check out the current development source with Mercurial via its
+{Bitbucket project}[https://bitbucket.org/ged/ruby-mongrel2]. Or if you 
+prefer Git, via {its Github mirror}[https://github.com/ged/ruby-mongrel2].
+
+After checking out the source, run:
+
+    $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the API documentation.
+
+
+== License
+
+Copyright (c) 2011, Michael Granger
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the author/s, nor the names of the project's
+  contributors may be used to endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

data/Rakefile

@@ -0,0 +1,77 @@
+#!/usr/bin/env rake
+
+begin
+	require 'hoe'
+rescue LoadError
+	abort "This Rakefile requires 'hoe' (gem install hoe)"
+end
+
+# Work around borked RSpec support in this version
+if Hoe::VERSION == '2.12.0'
+	warn "Ignore warnings about not having rspec; it's a bug in Hoe 2.12.0"
+	require 'rspec'
+end
+
+Hoe.plugin :mercurial
+Hoe.plugin :signing
+
+Hoe.plugins.delete :rubyforge
+
+hoespec = Hoe.spec 'mongrel2' do
+	self.readme_file = 'README.rdoc'
+	self.history_file = 'History.rdoc'
+	self.extra_rdoc_files << 'README.rdoc' << 'History.rdoc'
+	self.spec_extras[:rdoc_options] = ['-t', 'Ruby-Mongrel2']
+
+	self.developer 'Michael Granger', 'ged@FaerieMUD.org'
+
+	self.dependency 'nokogiri',   '~> 1.5'
+	self.dependency 'sequel',     '~> 3.26'
+	self.dependency 'amalgalite', '~> 1.1'
+	self.dependency 'tnetstring', '~> 0.3'
+	self.dependency 'yajl-ruby',  '~> 0.8'
+	self.dependency 'zmq',        '~> 2.1.3.1'
+
+	self.dependency 'configurability', '~> 1.0', :developer
+	self.dependency 'rspec',           '~> 2.4', :developer
+
+	self.spec_extras[:licenses] = ["BSD"]
+	self.require_ruby_version( '>= 1.9.2' )
+
+	self.rdoc_locations << "deveiate:/usr/local/www/public/code/#{remote_rdoc_dir}"
+end
+
+ENV['VERSION'] ||= hoespec.spec.version.to_s
+
+# Ensure the specs pass before checking in
+task 'hg:precheckin' => :spec
+
+### Make the ChangeLog update if the repo has changed since it was last built
+file '.hg/branch'
+file 'ChangeLog' => '.hg/branch' do |task|
+	$stderr.puts "Updating the changelog..."
+	abort "Can't create the ChangeLog without hoe-mercurial (gem install hoe-mercurial)" unless
+		defined?( MercurialHelpers )
+
+	content = MercurialHelpers.make_changelog()
+	File.open( task.name, 'w', 0644 ) do |fh|
+		fh.print( content )
+	end
+end
+
+# Rebuild the ChangeLog immediately before release
+task :prerelease => 'ChangeLog'
+
+if Rake::Task.task_defined?( '.gemtest' )
+	Rake::Task['.gemtest'].clear
+	task '.gemtest' do
+		$stderr.puts "Not including a .gemtest until I'm confident the test suite is idempotent."
+	end
+end
+
+desc "Build a coverage report"
+task :coverage do
+	ENV["COVERAGE"] = 'yes'
+	Rake::Task[:spec].invoke
+end
+

data/bin/m2sh.rb

@@ -0,0 +1,600 @@
+#!/usr/bin/env ruby
+
+require 'pp'
+require 'shellwords'
+require 'tnetstring'
+
+require 'trollop'
+require 'highline'
+
+# Have to do it this way to avoid the vendored 'sysexits' under OSX.
+gem 'sysexits'
+require 'sysexits'
+
+require 'mongrel2'
+require 'mongrel2/config'
+
+
+# A tool for interacting with a Mongrel2 config database and server. This isn't
+# quite a replacement for the real m2sh yet; here's what I have working so far:
+#
+#   [√]    load  Load a config.
+#   [√]  config  Alias for load.
+#   [√]   shell  Starts an interactive shell.
+#   [√]  access  Prints the access log.
+#   [√] servers  Lists the servers in a config database.
+#   [√]   hosts  Lists the hosts in a server.
+#   [√]  routes  Lists the routes in a host.
+#   [√]  commit  Adds a message to the log.
+#   [√]     log  Prints the commit log.
+#   [√]   start  Starts a server.
+#   [ ]    stop  Stops a server.
+#   [ ]  reload  Reloads a server.
+#   [ ] running  Tells you what's running.
+#   [ ] control  Connects to the control port.
+#   [√] version  Prints the Mongrel2 and m2sh version.
+#   [√]    help  Get help, lists commands.
+#   [-]    uuid  Prints out a randomly generated UUID.
+#
+# I just use 'uuidgen' to generate uuids (which is all m2sh does, as
+# well), so I don't plan to implement that. Everything else should
+# be pretty easy.
+# 
+class Mongrel2::M2SHCommand
+	extend ::Sysexits
+	include Sysexits,
+	        Mongrel2::Loggable,
+	        Mongrel2::Constants
+
+	# Make a HighLine color scheme
+	COLOR_SCHEME = HighLine::ColorScheme.new do |scheme|
+		scheme[:header]	   = [ :bold, :yellow ]
+		scheme[:subheader] = [ :bold, :white ]
+		scheme[:key]	   = [ :white ]
+		scheme[:value]	   = [ :bold, :white ]
+		scheme[:error]	   = [ :red ]
+		scheme[:warning]   = [ :yellow ]
+		scheme[:message]   = [ :reset ]
+	end
+
+
+	# Path to the default history file for 'shell' mode
+	HISTORY_FILE = Pathname( "~/.m2shrb.history" )
+
+	# Number of items to store in history by default
+	DEFAULT_HISTORY_SIZE = 100
+
+	# The prompt the 'shell' mode should show
+	PROMPT = 'mongrel2> '
+
+
+	# Class instance variables
+	@command_help = Hash.new {|h,k| h[k] = { :desc => nil, :usage => ''} }
+	@prompt = @option_parser = nil
+
+
+	### Add a help string for the given +command+.
+	def self::help( command, helpstring=nil )
+		if helpstring
+			@command_help[ command.to_sym ][:desc] = helpstring
+		end
+
+		return @command_help[ command.to_sym ][:desc]
+	end
+
+
+	### Add/fetch the +usagestring+ for +command+.
+	def self::usage( command, usagestring=nil )
+		if usagestring
+			prefix = usagestring[ /\A(\s+)/, 1 ]
+			usagestring.gsub!( /^#{prefix}/m, '' ) if prefix
+
+			@command_help[ command.to_sym ][:usage] = usagestring
+		end
+
+		return @command_help[ command.to_sym ][:usage]
+	end
+
+
+	### Return the global Highline prompt object, creating it if necessary.
+	def self::prompt
+		unless @prompt
+			@prompt = HighLine.new
+			@prompt.wrap_at = @prompt.output_cols - 10
+		end
+
+		return @prompt
+	end
+
+
+	### Run the utility with the given +args+.
+	def self::run( args )
+		HighLine.color_scheme = COLOR_SCHEME
+
+		oparser = self.make_option_parser
+		opts = Trollop.with_standard_exception_handling( oparser ) do
+			oparser.parse( args )
+		end
+
+		command = oparser.leftovers.shift
+		self.new( opts ).run( command, *oparser.leftovers )
+		exit :ok
+
+	rescue => err
+		Mongrel2.logger.fatal "Oops: %s: %s" % [ err.class.name, err.message ]
+		Mongrel2.logger.debug { '  ' + err.backtrace.join("\n  ") }
+
+		exit :software_error
+	end
+
+
+	### Return a String that describes the available commands, e.g., for the 'help'
+	### command.
+	def self::make_command_table
+		commands = self.available_commands
+
+		# Build the command table
+		col1len = commands.map( &:length ).max
+		return commands.collect do |cmd|
+			helptext = self.help( cmd.to_sym ) or next # no help == invisible command
+			"%s  %s" % [
+				self.prompt.color(cmd.rjust(col1len), :key),
+				self.prompt.color(helptext, :value)
+			]
+		end.compact
+	end
+
+
+	### Return an Array of the available commands.
+	def self::available_commands
+		return self.public_instance_methods( false ).
+			map( &:to_s ).
+			grep( /_command$/ ).
+			map {|methodname| methodname.sub(/_command$/, '') }.
+			sort
+	end
+
+
+	### Create and configure a command-line option parser for the command.
+	### Returns a Trollop::Parser.
+	def self::make_option_parser
+		unless @option_parser
+			progname = File.basename( $0 )
+			default_configdb = Mongrel2::DEFAULT_CONFIG_URI
+
+			# Make a list of the log level names and the available commands
+			loglevels = Mongrel2::Logging::LOG_LEVELS.
+				sort_by {|name,lvl| lvl }.
+				collect {|name,lvl| name.to_s }.
+				join( ', ' )
+			command_table = self.make_command_table
+
+			@option_parser = Trollop::Parser.new do
+				banner "Mongrel2 (Ruby) Shell has these commands available:"
+
+				text ''
+				command_table.each {|line| text(line) }
+				text ''
+
+				text 'Global Options'
+				opt :config, "Specify the configfile to use.",
+					:default => DEFAULT_CONFIG_URI
+				text ''
+
+				text 'Other Options:'
+				opt :debug, "Turn debugging on. Also sets the --loglevel to 'debug'."
+				opt :loglevel, "Set the logging level. Must be one of: #{loglevels}",
+					:default => Mongrel2::Logging::LOG_LEVEL_NAMES[ Mongrel2.logger.level ]
+			end
+		end
+
+		return @option_parser
+	end
+
+
+	#################################################################
+	###	I N S T A N C E   M E T H O D S
+	#################################################################
+
+	### Create a new instance of the command and set it up with the given
+	### +options+.
+	def initialize( options )
+		Mongrel2.logger.formatter = Mongrel2::Logging::ColorFormatter.new( Mongrel2.logger )
+		@options = options
+		@shellmode = false
+
+		if @options.debug
+			$DEBUG = true
+			$VERBOSE = true
+			Mongrel2.logger.level = Logger::DEBUG
+		elsif @options.loglevel
+			Mongrel2.logger.level = Mongrel2::Logging::LOG_LEVELS[ @options.loglevel ]
+		end
+
+		Mongrel2::Config.configure( :configdb => @options.config )
+	end
+
+
+	######
+	public
+	######
+
+	# The Trollop options hash the command will read its configuration from
+	attr_reader :options
+
+	# True if running in shell mode
+	attr_reader :shellmode
+
+
+	# Delegate the instance #prompt method to the class method instead
+	define_method( :prompt, &self.method(:prompt) )
+
+
+	### Run the command with the specified +command+ and +args+.
+	def run( command, *args )
+		command ||= 'shell'
+		cmd_method = nil
+
+		begin
+			cmd_method = self.method( "#{command}_command" )
+		rescue NoMethodError => err
+			error "No such command"
+			exit :usage
+		end
+
+		cmd_method.call( *args )
+	end
+
+
+	#
+	# Commands
+	#
+
+	### The 'help' command
+	def help_command( *args )
+
+		# Subcommand help
+		if !args.empty?
+			command = args.shift
+
+			if self.class.available_commands.include?( command )
+				header( self.class.help(command) )
+				desc = "\n" + 'Usage: ' + command + ' ' + self.class.usage(command) + "\n"
+				message( desc )
+			else
+				error "No such command %p" % [ command ]
+			end
+
+		# Help by itself show the table of available commands
+		else
+			command_table = self.class.make_command_table
+			header "Available Commands"
+			message( *command_table )
+		end
+
+	end
+	help :help, "Show help for a single COMMAND if given, or list available commands if not"
+	usage :help, "[COMMAND]"
+
+
+	### The 'load' command
+	def load_command( *args )
+		configfile = args.shift or
+			raise "No configfile specified."
+
+		runspace = Module.new do
+			extend Mongrel2::Config::DSL
+		end
+
+		header "Loading config from #{configfile}"
+		source = File.read( configfile )
+		Mongrel2::Config.init_database!
+		runspace.module_eval( source, configfile, 0 )
+	end
+	help :load, "Overwrite the config database with the values from the speciifed CONFIGFILE."
+	usage :load, <<-END_USAGE
+	CONFIGFILE
+	Note: the CONFIGFILE should contain a configuration described using the
+	Ruby config DSL, not a Python-ish normal one. m2sh already works perfectly
+	fine for loading those.
+	END_USAGE
+
+
+	### The 'config' command
+	alias_method :config_command, :load_command
+	help :config, "Alias for 'load'."
+
+
+	### The 'init' command
+	def init_command( * )
+		if Mongrel2::Config.database_initialized?
+			abort "Okay, aborting." unless
+				self.prompt.agree( "Are you sure you want to destroy the current config? " )
+		end
+
+		header "Initializing #{self.options.config}"
+		Mongrel2::Config.init_database!
+	end
+	help :init, "Initialize a new empty config database."
+
+
+	### The 'shell' command.
+	def shell_command( * )
+		require 'readline'
+		require 'termios'
+		require 'shellwords'
+
+		term = Termios.getattr( $stdin )
+		@shellmode = true
+
+		# Set up the completion callback
+		# self.setup_completion
+
+		# Load saved command-line history
+		self.read_history
+
+		# Run until something sets the quit flag
+		quitting = false
+		until quitting
+			$stderr.puts
+			input = Readline.readline( PROMPT, true )
+			self.log.debug "Input is: %p" % [ input ]
+
+			# EOL makes the shell quit
+			if input.nil?
+				self.log.debug "EOL: setting quit flag"
+				quitting = true
+
+			# Blank input -- just reprompt
+			elsif input == ''
+				self.log.debug "No command. Re-displaying the prompt."
+
+			# Parse everything else into command + args
+			else
+				self.log.debug "Dispatching input: %p" % [ input ]
+				command, *args = Shellwords.split( input )
+
+				# Don't allow recursive shells
+				if command == 'shell'
+					error "Already in a shell."
+					next
+				end
+
+				begin
+					self.run( command, *args )
+				rescue => err
+					error "%p: %s" % [ err.class, err.message ]
+					err.backtrace.each do |frame|
+						self.log.debug "  " + frame
+					end
+				end
+			end
+		end
+
+		message "\nSaving history...\n"
+		self.save_history
+
+		message "done."
+
+	ensure
+		@shellmode = false
+		Termios.tcsetattr( $stdin, Termios::TCSANOW, term )
+	end
+	help :shell, "Start the program in interactive mode."
+
+
+	### The 'access' command
+	def access_command( logfile='logs/access.log', * )
+		#      1$             2$       3$       4$        5$        6$            7$        8$  9$
+		# ["localhost", "127.0.0.1", 53420, 1315533812, "GET", "/favicon.ico", "HTTP/1.1", 404, 0]
+		# -> [1315533812] 127.0.0.1:53420 localhost "GET /favicon.ico HTTP/1.1" 404 0
+		IO.foreach( logfile ) do |line|
+			row, _ = TNetstring.parse( line )
+			message %{[%4$d] %2$s:%3$d %1$s "%5$s %6$s %7$s" %8$03d %9$d} % row
+		end
+	end
+	help :access, "Dump the access log."
+	usage :access, "[logfile]\nThe logfile defaults to 'logs/access.log'."
+
+
+	### The 'servers' command
+	def servers_command( * )
+		header 'SERVERS:'
+		Mongrel2::Config.servers.each do |server|
+			message "%s  [%s]: %s" % [
+				self.prompt.color( server.name, :key ),
+				server.default_host,
+				server.uuid,
+			]
+		end
+	end
+	help :servers, "Lists the servers in a config database."
+
+
+	### The 'hosts' command
+	def hosts_command( *args )
+		servername = args.shift
+
+		# Start with all servers, then narrow it down if they specified a server name.
+		servers = Mongrel2::Config::Server.dataset
+		servers = servers.filter( :name => servername ) if servername
+
+		# Output a section for each server
+		servers.each do |server|
+			header "HOSTS for server #{server.name}:"
+			server.hosts.each do |host|
+				line = "%d: %s" % [ host.id, host.name ]
+				line << " /%s/" % [ host.matching ] if host.matching != host.name
+
+				message( line )
+			end
+
+			$stdout.puts
+		end
+	end
+	help :hosts, "Lists the hosts in a server, or in all servers if none is specified."
+	usage :hosts, "[server]"
+
+
+	### The 'routes' command
+	def routes_command( *args )
+		servername = args.shift
+		hostname = args.shift
+
+		# Start with all hosts, then narrow it down if a server and/or host was given.
+		hosts = Mongrel2::Config::Host.dataset
+		if servername
+			server = Mongrel2::Config::Server[ servername ] or
+				raise "No such server '#{servername}'"
+			hosts = server.hosts_dataset
+		end
+		hosts = hosts.filter( :name => hostname ) if hostname
+
+		# Output a section for each host
+		hosts.each do |host|
+			header "ROUTES for host #{host.server.name}/#{host.name}:"
+
+			host.routes.each do |route|
+				message( route.path )
+			end
+		end
+
+	end
+	help :routes, "Show the routes under a host."
+	usage :routes, "[server [host]]"
+
+
+	### The 'commit' command
+	def commit_command( *args )
+		what, where, why, how = *args
+		what ||= ''
+
+		log = Mongrel2::Config::Log.log_action( what, where, why, how )
+
+		header "Okay, logged."
+		message( log.to_s )
+	end
+	help :commit, "Add a message to the commit log."
+	usage :commit, "[WHAT [WHERE [WHY [HOW]]]]"
+
+
+	### The 'log' command
+	def log_command( *args )
+		header "Log Messages"
+		Mongrel2::Config::Log.order_by( :happened_at ).each do |log|
+			message( log.to_s )
+		end
+	end
+	help :log, "Prints the commit log."
+
+
+	### The 'start' command
+	def start_command( *args )
+		serverspec = args.shift
+		servers = Mongrel2::Config.servers
+
+		raise "No servers are configured." if servers.empty?
+		server = nil
+
+		# If there's only one configured server, just make sure if a serverspec was given
+		# that it would have matched.
+		if servers.length == 1
+			server = servers.first if !serverspec ||
+				servers.first.values_at( :uuid, :default_host, :name ).include?( serverspec )
+
+		# Otherwise, require an argument and search for the desired server if there is one
+		else
+			raise "You must specify a server uuid/hostname/name when more " +
+			      "than one server is configured." if servers.length > 1 && !serverspec
+
+			server = servers.find {|s| s.uuid == serverspec } ||
+			         servers.find {|s| s.default_host == serverspec } ||
+			         servers.find {|s| s.name == serverspec }
+		end
+
+		raise "No servers match '#{serverspec}'" unless server
+
+		# Run the command, waiting for it to finish if invoked from shell mode, or
+		# execing it if not.
+		cmd = [ 'mongrel2', Mongrel2::Config.pathname.to_s, server.uuid ]
+		if @shellmode
+			system( *cmd )
+		else
+			exec( *cmd )
+		end
+	end
+	help :start, "Starts a server."
+	usage :start, <<-END_USAGE
+	[SERVER]
+	If not specified, SERVER is assumed to be the only server entry in the
+	current config. If there are more than one, you must specify a SERVER.
+	
+	The SERVER can be a uuid, hostname, or server name, and are searched for
+	in that order.
+	END_USAGE
+
+
+	### The 'version' command
+	def version_command( *args )
+		message( "<%= color 'Version:', :header %> " + Mongrel2.version_string(true) )
+	end
+	help :version, "Prints the Ruby-Mongrel2 version."
+
+
+	#
+	# Utility methods
+	#
+
+	### Output normal output
+	def message( *parts )
+		self.prompt.say( parts.map(&:to_s).join($/) )
+	end
+
+
+	### Output the given +text+ highlighted as a header.
+	def header( text )
+		message( self.prompt.color(text, :header) )
+	end
+
+
+	### Output the given +text+ highlighted as an error.
+	def error( text )
+		message( self.prompt.color(text, :error) )
+	end
+
+
+	### Read command line history from HISTORY_FILE
+	def read_history
+		histfile = HISTORY_FILE.expand_path
+
+		if histfile.exist?
+			lines = histfile.readlines.collect {|line| line.chomp }
+			self.log.debug "Read %d saved history commands from %s." % [ lines.length, histfile ]
+			Readline::HISTORY.push( *lines )
+		else
+			self.log.debug "History file '%s' was empty or non-existant." % [ histfile ]
+		end
+	end
+
+
+	### Save command line history to HISTORY_FILE
+	def save_history
+		histfile = HISTORY_FILE.expand_path
+
+		lines = Readline::HISTORY.to_a.reverse.uniq.reverse
+		lines = lines[ -DEFAULT_HISTORY_SIZE, DEFAULT_HISTORY_SIZE ] if
+			lines.length > DEFAULT_HISTORY_SIZE
+
+		self.log.debug "Saving %d history lines to %s." % [ lines.length, histfile ]
+
+		histfile.open( File::WRONLY|File::CREAT|File::TRUNC ) do |ofh|
+			ofh.puts( *lines )
+		end
+	end
+
+
+end # class Mongrel2::M2SHCommand
+
+
+Mongrel2::M2SHCommand.run( ARGV.dup )
+