mongrel2 0.0.1

data/lib/mongrel2/config/directory.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+
+require 'mongrel2' unless defined?( Mongrel2 )
+require 'mongrel2/config' unless defined?( Mongrel2::Config )
+
+# Mongrel2 Directory (Dir) configuration class
+class Mongrel2::Config::Directory < Mongrel2::Config( :directory )
+
+	### As of Mongrel2/1.7.5:
+	# CREATE TABLE directory (id INTEGER PRIMARY KEY,
+	#    base TEXT,
+	#    index_file TEXT,
+	#    default_ctype TEXT,
+	#    cache_ttl INTEGER DEFAULT 0);
+
+	### Sequel validation callback: add errors if the record is invalid.
+	def validate
+		self.validate_base
+		self.validate_index_file
+		self.validate_default_ctype
+		self.validate_cache_ttl
+	end
+
+
+	#########
+	protected
+	#########
+
+	### Validate the 'base' directory which will be served.
+	def validate_base
+		if self.base
+			if self.base.start_with?( '/' )
+				errmsg = "[%p]: shouldn't start with '/'; that will fail when not in chroot." %
+					[ self.base ]
+				self.log.error( 'base ' + errmsg )
+				self.errors.add( :base, errmsg )
+			end
+
+			unless self.base.end_with?( '/' )
+				errmsg = "[%p]: must end with '/' or it won't work right." %
+					[ self.base ]
+				self.log.error( 'base ' + errmsg )
+				self.errors.add( :base, errmsg )
+			end
+		else
+			errmsg = "missing or nil"
+			self.log.error( 'base ' + errmsg )
+			self.errors.add( :base, errmsg )
+		end
+	end
+
+
+	### Validate the 'index_file' attribute.
+	def validate_index_file
+		self.validates_presence( :index_file, :message => "must not be nil" )
+	end
+
+
+	### Validate the index file attribute.
+	def validate_default_ctype
+		self.validates_presence( :default_ctype, :message => "must not be nil" )
+	end
+
+
+	### Validate the cache TTL if one is set.
+	def validate_cache_ttl
+		if self.cache_ttl && Integer( self.cache_ttl ) < 0
+			errmsg = "[%p]: not a positive Integer" % [ self.cache_ttl ]
+			self.log.error( 'cache_ttl' + errmsg )
+			self.errors.add( :cache_ttl, errmsg )
+		end
+	end
+
+
+
+
+end # class Mongrel2::Config::Directory
+

data/lib/mongrel2/config/dsl.rb

@@ -0,0 +1,206 @@
+#!/usr/bin/env ruby
+
+require 'mongrel2' unless defined?( Mongrel2 )
+require 'mongrel2/config' unless defined?( Mongrel2::Config )
+
+# Mongrel2 configuration DSL mixin
+#
+# == Example
+#
+# This is the mongrel2.org config re-expressed in the Ruby DSL:
+#
+#	# the server to run them all 
+#	server '2f62bd5-9e59-49cd-993c-3b6013c28f05' do
+#
+#	    access_log   "/logs/access.log"
+#	    error_log    "/logs/error.log"
+#	    chroot       "./"
+#	    pid_file     "/run/mongrel2.pid"
+#	    default_host "mongrel2.org"
+#	    name         "main"
+#	    port         6767
+#
+#	    # your main host 
+#	    host "mongrel2.org" do
+#
+#	        # a sample of doing some handlers 
+#	        route '@chat', handler(
+#	            'tcp://127.0.0.1:9999', 
+#	            '54c6755b-9628-40a4-9a2d-cc82a816345e', 
+#	            'tcp://127.0.0.1:9998'
+#	        ) 
+#
+#	        route '/handlertest', handler(
+#	            'tcp://127.0.0.1:9997', 
+#	            '34f9ceee-cd52-4b7f-b197-88bf2f0ec378', 
+#	            'tcp://127.0.0.1:9996'
+#	        ) 
+#
+#	        # a sample proxy route 
+#	        web_app_proxy = proxy( '127.0.0.1', 8080 ) 
+#
+#	        route '/chat/', web_app_proxy
+#	        route '/', web_app_proxy
+#
+#	        # here's a sample directory 
+#	        test_directory = directory(
+#	            'tests/',
+#	            :index_file => 'index.html',
+#	            :default_ctype => 'text/plain'
+#	        )
+#
+#	        route '/tests/', test_directory
+#	        route '/testsmulti/(.*.json)', test_directory
+#
+#	        chat_demo_dir = directory(
+#	            'examples/chat/static/', 
+#	            :index_file => 'index.html', 
+#	            :default_ctype => 'text/plain'
+#	        )
+#
+#	        route '/chatdemo/', chat_demo_dir
+#	        route '/static/', chat_demo_dir
+#
+#	        route '/mp3stream', handler( 
+#	            'tcp://127.0.0.1:9995', 
+#	            '53f9f1d1-1116-4751-b6ff-4fbe3e43d142', 
+#	            'tcp://127.0.0.1:9994'
+#	        ) 
+#	    end
+#
+#	end
+#
+#	settings(
+#	    "zeromq.threads"         => 1,
+#	    "upload.temp_store"      => "/home/zedshaw/projects/mongrel2/tmp/upload.XXXXXX", 
+#	    "upload.temp_store_mode" => "0666" 
+#	)
+#
+module Mongrel2::Config::DSL
+
+
+	# A decorator object that provides the DSL-ish interface to the various Config
+	# objects. It derives its interface on the fly from columns of the class it's 
+	# created with and a DSLMethods mixin if the target class defines one.
+	class Adapter
+		include Mongrel2::Loggable
+
+		### Adapt the specified +target+ to use a declarative interface.
+		def initialize( targetclass, opts={} )
+			self.log.debug "Wrapping a %p" % [ targetclass ]
+			@targetclass = targetclass
+			@target = @targetclass.new( opts )
+			self.decorate_with_column_declaratives( @target )
+			self.decorate_with_custom_declaratives( @targetclass )
+		end
+
+
+		######
+		public
+		######
+
+		# The decorated object
+		attr_reader :target
+
+
+		### Backport the singleton_class method if there isn't one.
+		unless instance_methods.include?( :singleton_class )
+			def singleton_class
+				class << self; self; end
+			end
+		end
+
+		### Add a declarative singleton method for the columns of the +adapted_object+.
+		def decorate_with_column_declaratives( adapted_object )
+			columns = adapted_object.columns
+			self.log.debug "  decorating for columns: %s" % [ columns.map( &:to_s ).sort.join(', ') ]
+
+			columns.each do |colname|
+
+				# Create a method that will act as a writer if called with an
+				# argument, and a reader if not.
+				method_body = Proc.new do |*args|
+					if args.empty?
+						self.target.send( colname )
+					else
+						self.target.send( "#{colname}=", *args )
+					end
+				end
+
+				# Install the method
+				self.singleton_class.send( :define_method, colname, &method_body )
+			end
+		end
+
+
+		### Mix in methods defined by the "DSLMethods" mixin defined by the class
+		### of the object being adapted.
+		def decorate_with_custom_declaratives( objectclass )
+			return unless objectclass.const_defined?( :DSLMethods )
+			self.singleton_class.send( :include, objectclass.const_get(:DSLMethods) )
+		end
+
+
+	end # class Adapter
+
+
+	### Create a Mongrel2::Config::Server with the specified +uuid+, evaluate 
+	### the block (if given) within its context, and return it.
+	def server( uuid, &block )
+		Mongrel2::Config.init_database
+
+		Mongrel2.log.debug "Server [%s] (block: %p)" % [ uuid, block ]
+		adapter = Adapter.new( Mongrel2::Config::Server, :uuid => uuid )
+		adapter.instance_eval( &block ) if block
+		return adapter.target
+	end
+
+
+	### Set the value of one of the 'Tweakable Expert Settings'
+	def setting( key, val )
+		Mongrel2::Config.init_database
+		return Mongrel2::Config::Setting.create( :key => key, :value => val )
+	end
+
+
+	### Set some 'Tweakable Expert Settings' en masse
+	def settings( hash )
+		result = []
+
+		Mongrel2::Config.db.transaction do
+			hash.each do |key, val|
+				result << setting( key, val )
+			end
+		end
+
+		return result
+	end
+
+
+	### Set up a mimetype mapping between files with the given +extension+ and +mimetype+.
+	def mimetype( extension, mimetype )
+		Mongrel2::Config.init_database
+
+		type = Mongrel2::Config::Mimetype.find_or_create( :extension => extension )
+		type.mimetype = mimetype
+		type.save
+
+		return type
+	end
+
+
+	### Set some mimetypes en masse.
+	def mimetypes( hash )
+		result = []
+
+		Mongrel2::Config.db.transaction do
+			hash.each do |ext, mimetype|
+				result << mimetype( ext, mimetype )
+			end
+		end
+
+		return result
+	end
+
+end # module Mongrel2::Config::DSL
+

data/lib/mongrel2/config/handler.rb

@@ -0,0 +1,124 @@
+#!/usr/bin/env ruby
+
+require 'mongrel2' unless defined?( Mongrel2 )
+require 'mongrel2/config' unless defined?( Mongrel2::Config )
+
+# Mongrel2 Handler configuration class
+class Mongrel2::Config::Handler < Mongrel2::Config( :handler )
+
+	### As of Mongrel2/1.7.5:
+	# CREATE TABLE handler (id INTEGER PRIMARY KEY,
+	#     send_spec TEXT, 
+	#     send_ident TEXT,
+	#     recv_spec TEXT,
+	#     recv_ident TEXT,
+	#    raw_payload INTEGER DEFAULT 0,
+	#    protocol TEXT DEFAULT 'json');
+
+
+	# The list of 0mq transports Mongrel2 can use; "You need to use the
+	# ZeroMQ syntax for configuring them, but this means with one
+	# configuration format you can use handlers that are using UDP, TCP,
+	# Unix, or PGM transports." Note that I'm assuming by 'udp' Zed means
+	# 'epgm', as I can't find any udp 0mq transport.
+	VALID_SPEC_SCHEMES = %w[epgm tcp ipc pgm]
+
+	# The list of valid protocols
+	#--
+	# handler.h: typedef enum { HANDLER_PROTO_JSON, HANDLER_PROTO_TNET } handler_protocol_t;
+	VALID_PROTOCOLS = %w[json tnetstring]
+
+
+	##
+	# :method: by_send_ident( uuid )
+	# 
+	# Look up a Handler by its send_ident, which should be a +uuid+ or similar String.
+	def_dataset_method( :by_send_ident ) do |ident|
+		filter( :send_ident => ident )
+	end
+
+
+	### Validate the object prior to saving it.
+	def validate
+		self.validate_idents
+		self.validate_specs
+		self.validate_protocol
+	end
+
+
+	#########
+	protected
+	#########
+
+	### Turn nil recv_ident values into the empty string before validating.
+	def before_validation
+		self.recv_ident ||= ''
+	end
+
+
+	### Validate the send_ident and recv_ident
+	### --
+	### :FIXME: I'm not sure if this is actually necessary, but it seems like
+	###         the ident should at least be UUID-like like the server ident.
+	def validate_idents
+		unless self.send_ident =~ /^\w[\w\-]+$/
+			errmsg = "[%p]: invalid sender identity (should be UUID-like)" % [ self.send_ident ]
+			self.log.error( 'send_ident: ' + errmsg )
+			self.errors.add( :send_ident, errmsg )
+		end
+
+		unless self.recv_ident == '' || self.send_ident =~ /^\w[\w\-]+$/
+			errmsg = "[%p]: invalid receiver identity (should be empty string or UUID-like)" %
+				[ self.recv_ident ]
+			self.log.error( 'send_ident: ' + errmsg )
+			self.errors.add( :send_ident, errmsg )
+		end
+	end
+
+
+	### Validate the send_spec and recv_spec.
+	def validate_specs
+		if err = check_0mq_spec( self.send_spec )
+			errmsg = "[%p]: %s" % [ self.send_spec, err ]
+			self.log.error( 'send_spec: ' + errmsg )
+			self.errors.add( :recv_spec, errmsg )
+		end
+
+		if err = check_0mq_spec( self.recv_spec )
+			errmsg = "[%p]: %s" % [ self.recv_spec, err ]
+			self.log.error( 'recv_spec: ' + errmsg )
+			self.errors.add( :recv_spec, errmsg )
+		end
+	end
+
+
+	### Validate the handler's protocol.
+	def validate_protocol
+		return unless self.protocol # nil == default
+		unless VALID_PROTOCOLS.include?( self.protocol )
+			errmsg = "[%p]: invalid" % [ self.protocol ]
+			self.log.error( 'protocol: ' + errmsg )
+			self.errors.add( :protocol, errmsg )
+		end
+	end
+
+
+
+	#######
+	private
+	#######
+
+	### Returns +true+ if +url+ is a valid 0mq transport specification.
+	def check_0mq_spec( url )
+		return "must not be nil" unless url
+
+		u = URI( url )
+		return "invalid 0mq transport #{u.scheme}" unless VALID_SPEC_SCHEMES.include?( u.scheme )
+
+		return nil
+	rescue URI::InvalidURIError
+		return 'not a URI; should be something like "tcp://127.0.0.1:9998"'
+	end
+
+end # class Mongrel2::Config::Handler
+

data/lib/mongrel2/config/host.rb

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+
+require 'mongrel2' unless defined?( Mongrel2 )
+require 'mongrel2/config' unless defined?( Mongrel2::Config )
+
+# Mongrel2 Host configuration class
+class Mongrel2::Config::Host < Mongrel2::Config( :host )
+
+	### As of Mongrel2/1.7.5:
+	# CREATE TABLE host (id INTEGER PRIMARY KEY, 
+	#     server_id INTEGER,
+	#     maintenance BOOLEAN DEFAULT 0,
+	#     name TEXT,
+	#     matching TEXT);
+
+	one_to_many :routes
+	many_to_one :server
+
+	### DSL methods for the Server context besides those automatically-generated from its
+	### columns.
+	module DSLMethods
+
+		### Add a Mongrel2::Config::Route to the Host object.
+		def route( path, target, opts={} )
+			self.target.save
+			Mongrel2.log.debug "Route %s -> %p [%p]" % [ path, target, opts ]
+
+			args = { :path => path, :target => target }
+			args.merge!( opts )
+			route = Mongrel2::Config::Route.new( args )
+
+			self.target.add_route( route )
+		end
+
+
+		# These are route _arguments_, so they need to be declared in Host's scope rather
+		# than Route's.
+
+		### Create a new Mongrel2::Config::Directory object for the specified +base+ and
+		### return it.
+		def directory( base, index_file, default_ctype='text/plain', opts={} )
+			opts.merge!( :base => base, :index_file => index_file, :default_ctype => default_ctype )
+			return Mongrel2::Config::Directory.create( opts )
+		end
+
+
+		### Create a new Mongrel2::Config::Proxy object for the specified +addr+ and
+		### +port+ and return it.
+		def proxy( addr, port=80 )
+			return Mongrel2::Config::Proxy.create( :addr => addr, :port => port )
+		end
+
+
+		### Create a new Mongrel2::Config::Handler object with the specified +send_spec+, 
+		### +send_ident+, +recv_spec+, +recv_ident+, and +options+ and return it.
+		def handler( send_spec, send_ident, recv_spec=nil, recv_ident='', options={} )
+			# Shift the opts hash over if the other optional args were omitted
+			if recv_spec.is_a?( Hash )
+				options = recv_spec
+				recv_spec = nil
+			elsif recv_ident.is_a?( Hash )
+				options = recv_ident
+				recv_ident = ''
+			end
+
+			# Default to one port below the request spec
+			unless recv_spec
+				port = send_spec[ /:(\d+)$/, 1 ] or
+					"Can't guess default port for a send_spec without one (%p)" % [ send_spec ]
+				recv_spec = URI( send_spec )
+				recv_spec.port = port.to_i - 1
+			end
+
+			options.merge!(
+				:send_spec  => send_spec.to_s,
+				:send_ident => send_ident,
+				:recv_spec  => recv_spec.to_s,
+				:recv_ident => recv_ident
+			)
+
+			Mongrel2.log.debug "Creating handler with options: %p" % [ options ]
+			return Mongrel2::Config::Handler.create( options )
+		end
+
+	end # module DSLMethods
+
+end # class Mongrel2::Config::Host
+