mongrel2 0.0.1

data/lib/mongrel2/config/log.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+require 'etc'
+require 'socket'
+
+require 'mongrel2' unless defined?( Mongrel2 )
+require 'mongrel2/config' unless defined?( Mongrel2::Config )
+
+# Mongrel2 configuration Log class
+class Mongrel2::Config::Log < Mongrel2::Config( :log )
+
+	### As of Mongrel2/1.7.5:
+	# CREATE TABLE log(id INTEGER PRIMARY KEY,
+	#     who TEXT,
+	#     what TEXT,
+	#     location TEXT,
+	#     happened_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+	#     how TEXT,
+	#     why TEXT);
+
+	### Log an entry to the commit log with the given +what+, +why+, +where+, and +how+ values
+	### and return it after it's saved.
+	def self::log_action( what, why=nil, where=nil, how=nil )
+		where ||= Socket.gethostname
+		how ||= File.basename( $0 )
+
+		who = Etc.getlogin
+
+		return self.create(
+			who:      who,
+			what:     what,
+			location: where,
+			how:      how,
+			why:      why
+		)
+	end
+
+
+	# :todo: Correct the happened_at, which is set in UTC, but fetched in localtime.
+
+
+	### Stringify the log entry and return it.
+	def to_s
+		# 2011-09-09 19:35:40 [who] @where how: what (why)
+		return "%{happened_at} [%{who}] @%{location} %{how}: %{what} (%{why})" % self.values
+	end
+
+end # class Mongrel2::Config::Log

data/lib/mongrel2/config/mimetype.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require 'mongrel2' unless defined?( Mongrel2 )
+require 'mongrel2/config' unless defined?( Mongrel2::Config )
+
+# Mongrel2 Mimetype configuration class
+class Mongrel2::Config::Mimetype < Mongrel2::Config( :mimetype )
+
+	### As of Mongrel2/1.7.5:
+	# CREATE TABLE mimetype (id INTEGER PRIMARY KEY,
+	#   mimetype TEXT,
+	#   extension TEXT);
+
+end # class Mongrel2::Config::Mimetype
+

data/lib/mongrel2/config/proxy.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require 'mongrel2' unless defined?( Mongrel2 )
+require 'mongrel2/config' unless defined?( Mongrel2::Config )
+
+# Mongrel2 Proxy configuration class
+class Mongrel2::Config::Proxy < Mongrel2::Config( :proxy )
+
+	### As of Mongrel2/1.7.5:
+	# CREATE TABLE proxy (id INTEGER PRIMARY KEY,
+	#     addr TEXT,
+	#     port INTEGER);
+
+end # class Mongrel2::Config::Proxy
+

data/lib/mongrel2/config/route.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+require 'mongrel2' unless defined?( Mongrel2 )
+require 'mongrel2/config' unless defined?( Mongrel2::Config )
+
+# Mongrel2 Route configuration class
+class Mongrel2::Config::Route < Mongrel2::Config( :route )
+
+	### As of Mongrel2/1.7.5:
+	# CREATE TABLE route (id INTEGER PRIMARY KEY,
+	#     path TEXT,
+	#     reversed BOOLEAN DEFAULT 0,
+	#     host_id INTEGER,
+	#     target_id INTEGER,
+	#     target_type TEXT);
+
+	### Fetch the route's target, which is either a Mongrel2::Config::Directory, 
+	### Mongrel2::Config::Proxy, or Mongrel2::Config::Handler object.
+	def target
+		case self.target_type
+		when 'dir'
+			return Mongrel2::Config::Directory[ self.target_id ]
+		when 'proxy'
+			return Mongrel2::Config::Proxy[ self.target_id ]
+		when 'handler'
+			return Mongrel2::Config::Handler[ self.target_id ]
+		else
+			raise ArgumentError, "unknown target type %p" % [ self.target_type ]
+		end
+	end
+
+
+	### Set the target of the route to +object+, which should be one of the classes
+	### returned from #target.
+	def target=( object )
+		case object
+		when Mongrel2::Config::Directory
+			self.target_type = 'dir'
+		when Mongrel2::Config::Proxy
+			self.target_type = 'proxy'
+		when Mongrel2::Config::Handler
+			self.target_type = 'handler'
+		else
+			raise ArgumentError, "unknown target type %p" % [ object.class ]
+		end
+
+		self.target_id = object.id
+	end
+
+end # class Mongrel2::Config::Route
+

data/lib/mongrel2/config/server.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+
+require 'mongrel2' unless defined?( Mongrel2 )
+require 'mongrel2/config' unless defined?( Mongrel2::Config )
+
+
+# Mongrel2 Server configuration class
+class Mongrel2::Config::Server < Mongrel2::Config( :server )
+
+	### As of Mongrel2/1.7.5:
+	# CREATE TABLE server (id INTEGER PRIMARY KEY,
+	#     uuid TEXT,
+	#     access_log TEXT,
+	#     error_log TEXT,
+	#     chroot TEXT DEFAULT '/var/www',
+	#     pid_file TEXT,
+	#     default_host TEXT,
+	#     name TEXT DEFAULT '',
+	#     bind_addr TEXT DEFAULT "0.0.0.0",
+	#     port INTEGER,
+	#     use_ssl INTEGER default 0);
+
+	one_to_many :hosts
+
+
+	#
+	# :section: Validation Callbacks
+	#
+
+	### Sequel validation callback: add errors if the record is invalid.
+	def validate
+		self.validates_presence [ :access_log, :error_log, :pid_file, :default_host, :port ],
+			message: 'is missing or nil'
+	end
+
+
+
+	### DSL methods for the Server context besides those automatically-generated from its
+	### columns.
+	module DSLMethods
+
+		### Add a Mongrel2::Config::Host to the Server object with the given +hostname+. If a
+		### +block+ is specified, it can be used to further configure the Host.
+		def host( name, &block )
+			self.target.save( :validate => false )
+
+			Mongrel2.log.debug "Host [%s] (block: %p)" % [ name, block ]
+			adapter = Mongrel2::Config::DSL::Adapter.new( Mongrel2::Config::Host,
+				:name => name, :matching => name )
+			adapter.instance_eval( &block ) if block
+			self.target.add_host( adapter.target )
+		end
+
+
+	end # module DSLMethods
+
+end # class Mongrel2::Config::Server
+

data/lib/mongrel2/config/setting.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require 'mongrel2' unless defined?( Mongrel2 )
+require 'mongrel2/config' unless defined?( Mongrel2::Config )
+
+# Mongrel2 Setting configuration class
+class Mongrel2::Config::Setting < Mongrel2::Config( :setting )
+
+	### As of Mongrel2/1.7.5:
+	# CREATE TABLE setting (id INTEGER PRIMARY KEY, 
+	# 	key TEXT, 
+	# 	value TEXT);
+
+end # class Mongrel2::Config::Setting
+

data/lib/mongrel2/config/statistic.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+require 'mongrel2' unless defined?( Mongrel2 )
+require 'mongrel2/config' unless defined?( Mongrel2::Config )
+
+# Mongrel2 configuration statistic class
+class Mongrel2::Config::Statistic < Mongrel2::Config( :statistic )
+
+	### As of Mongrel2/1.7.5:
+	# CREATE TABLE statistic (id SERIAL, 
+	#     other_type TEXT,
+	#     other_id INTEGER,
+	#     name text,
+	#     sum REAL,
+	#     sumsq REAL,
+	#     n INTEGER,
+	#     min REAL,
+	#     max REAL,
+	#     mean REAL,
+	#     sd REAL,
+	#     primary key (other_type, other_id, name));
+
+end # class Mongrel2::Config::Statistic

data/lib/mongrel2/connection.rb

@@ -0,0 +1,212 @@
+#!/usr/bin/ruby
+
+require 'zmq'
+require 'yajl'
+
+require 'mongrel2' unless defined?( Mongrel2 )
+require 'mongrel2/mixins'
+
+
+# The Mongrel2 connection class. Connection objects serve as a front end for 
+# the ZMQ sockets which talk to the mongrel2 server/s for your handler. It receives 
+# TNetString requests and wraps Mongrel2::Request objects around them, and
+# then encodes and sends Mongrel2::Response objects back to the server.
+#
+# == References
+# * http://mongrel2.org/static/mongrel2-manual.html#x1-700005.3
+class Mongrel2::Connection
+	include Mongrel2::Loggable
+
+
+	### Create a new Connection identified by +app_id+ (a UUID or other unique string) that
+	### will connect to a Mongrel2 server on the +sub_addr+ and +pub_addr+ (e.g., 
+	### 'tcp://127.0.0.1:9998').
+	def initialize( app_id, sub_addr, pub_addr )
+		@app_id   = app_id
+		@sub_addr = sub_addr
+		@pub_addr = pub_addr
+
+		@request_sock = @response_sock = nil
+		@closed = false
+	end
+
+
+	### Copy constructor -- don't keep the +original+'s sockets or closed state.
+	def initialize_copy( original )
+		@request_sock = @response_sock = nil
+		@closed = false
+	end
+
+
+
+	######
+	public
+	######
+
+	# The application's UUID that identifies it to Mongrel2
+	attr_reader :app_id
+
+	# The connection's subscription (request) socket address
+	attr_reader :sub_addr
+
+	# The connection's publication (response) socket address
+	attr_reader :pub_addr
+
+
+	### Establish both connections to the Mongrel2 server.
+	def connect
+		ctx = Mongrel2.zmq_context
+		self.log.debug "0mq Context is: %p" % [ ctx ]
+
+		self.log.info "Connecting request socket (%s)" % [ @sub_addr ]
+		@request_sock  = ctx.socket( ZMQ::PULL )
+		@request_sock.setsockopt( ZMQ::LINGER, 0 )
+		@request_sock.connect( @sub_addr )
+
+		self.log.info "Connecting response socket (%s)" % [ @pub_addr ]
+		@response_sock  = ctx.socket( ZMQ::PUB )
+		@response_sock.setsockopt( ZMQ::LINGER, 0 )
+		@response_sock.setsockopt( ZMQ::IDENTITY, @app_id )
+		@response_sock.connect( @pub_addr )
+	end
+
+
+	### Fetch the ZMQ::PULL socket for incoming requests, establishing the
+	### connection to Mongrel if it hasn't been already.
+	def request_sock
+		self.check_closed
+		self.connect unless @request_sock
+		return @request_sock
+	end
+
+
+	### Fetch the ZMQ::PUB socket for outgoing responses, establishing the
+	### connection to Mongrel if it hasn't been already.
+	def response_sock
+		self.check_closed
+		self.connect unless @response_sock
+		return @response_sock
+	end
+
+
+	### Fetch the next request from the server as raw TNetString data.
+	def recv
+		self.check_closed
+
+		self.log.debug "Fetching next request"
+		data = self.request_sock.recv
+		self.log.debug "  got request data: %p" % [ data ]
+		return data
+	end
+
+
+	### Fetch the next request from the server as a Mongrel2::Request object.
+	def receive
+		raw_req = self.recv
+		return Mongrel2::Request.parse( raw_req )
+	end
+
+
+	### Write a raw +data+ to the given connection ID (+conn_id+) at the given +sender_id+.
+	def send( sender_id, conn_id, data )
+		self.check_closed
+        header = "%s %d:%s," % [ sender_id, conn_id.to_s.length, conn_id ]
+		buf = header + ' ' + data
+		self.log.debug "Sending response: %p" % [ buf ]
+		self.response_sock.send( buf )
+	end
+
+
+	### Write the specified +response+ (Mongrel::Response object) to the requester.
+	def reply( response )
+		self.send( response.sender_id, response.conn_id, response.to_s )
+	end
+
+
+	### Send the given +data+ to one or more connected clients identified by +client_ids+
+	### via the server specified by +sender_id+. The +client_ids+ should be an Array of
+	### Integer IDs no longer than Mongrel2::MAX_IDENTS.
+	def broadcast( sender_id, conn_ids, data )
+		idlist = conn_ids.map( &:to_s ).join( ' ' )
+		self.send( sender_id, idlist, data )
+	end
+
+
+	### Tell the server to close the connection associated with the given +sender_id+ and
+	### +conn_id+.
+	def send_close( sender_id, conn_id )
+		self.send( sender_id, conn_id, '' )
+	end
+
+
+	### Tell the server to close the connection associated with the given +request_or_response+.
+	def reply_close( request_or_response )
+		self.send_close( request_or_response.sender_id, request_or_response.conn_id )
+	end
+
+
+	### Tell the server associated with +sender_id+ to close the connections associated 
+	### with +conn_ids+.
+	def broadcast_close( sender_id, *conn_ids )
+		self.broadcast( sender_id, conn_ids.flatten, '' )
+	end
+
+
+	### Close both of the sockets and mark the Connection as closed.
+	def close
+		return if self.closed?
+		self.closed = true
+		@request_sock.close if @request_sock
+		@response_sock.close if @response_sock
+	end
+
+
+	### Returns +true+ if the connection to the Mongrel2 server has been closed.
+	def closed?
+		return @closed
+	end
+
+
+	### Returns a string containing a human-readable representation of the Connection,
+	### suitable for debugging.
+	def inspect
+		state = if @request_socket
+			if self.closed?
+				"closed"
+			else
+				"connected"
+			end
+		else
+			"not connected"
+		end
+
+		return "#<%p:0x%08x {%s} %s <-> %s (%s)>" % [
+			self.class,
+			self.object_id * 2,
+			self.app_id,
+			self.sub_addr,
+			self.pub_addr,
+			state,
+		]
+	end
+
+
+
+	#########
+	protected
+	#########
+
+	# True if the Connection to the Mongrel2 server has been closed.
+	attr_writer :closed
+
+
+	### Check to be sure the Connection hasn't been closed, raising a Mongrel2::ConnectionError
+	### if it has.
+	def check_closed
+		raise Mongrel2::ConnectionError, "operation on closed Connection" if self.closed?
+	end
+
+end # class Mongrel2::Connection
+
+# vim: set nosta noet ts=4 sw=4:
+