mongrel2 0.51.0 → 0.52.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 8df9f187481c62410559366443e0a498a75858cc
-  data.tar.gz: d0b13dcd1f94d0835230fd2998c73aed4fbce747
+SHA256:
+  metadata.gz: 2ed8340c773b16f74e9fdfba40baf608f96c13726fc7cdbe4649c414dcb489fc
+  data.tar.gz: 8079493638f14d5e7158687c9e6b0643934821ebb98af1be174704ae833d4cad
 SHA512:
-  metadata.gz: 3a4149170b70e911f33b9e743d806138b1a48523298956c733cbc264cfb1cd0e20da45aae8985e302e1ef6648fd46f7c8f655894f338205e31c6e9777f22cdd8
-  data.tar.gz: fa5ca2d024561d07898f15e2da168e2db884722780a75231998d9269ac990a63279dfa00e4055f870bb72e39ff0a5981ffe0d828611575b602ea86a1dec71b45
+  metadata.gz: 5f9a258f6eeda490594c2601d9b8f8e4b11473f69dc0cffd4cfb324c4c49f62db8b9d26d8c55153895259fbd773bce0547070613ca931f491efcd055960c3b5c
+  data.tar.gz: 899fddeca183837af436fd89aafbf5bfcf9a64a79f2ae51ba25e0c039a2089bd9b115f7a4add96190596c9cb1e70e46e125e2d166cfaf609ba8c559453429599

data/ChangeLog

@@ -1,8 +1,99 @@
+2018-07-21  Michael Granger  <ged@FaerieMUD.org>
+
+	* .gems, Rakefile, lib/mongrel2/handler.rb, lib/mongrel2/websocket.rb,
+	mongrel2.gemspec, spec/helpers.rb, spec/mongrel2/connection_spec.rb,
+	spec/mongrel2/handler_spec.rb:
+	Refactor IO code to use cztop-reactor
+	[d266df105426] [tip]
+
+2018-05-31  Mahlon E. Smith  <mahlon@martini.nu>
+
+	* lib/mongrel2/constants.rb:
+	Update for changes to gem upstream.
+	[667013d5334c]
+
+2017-11-15  Michael Granger  <ged@FaerieMUD.org>
+
+	* .hgtags:
+	Added tag v0.51.0 for changeset 89afed83e6e2
+	[1a6fcd8e3a52]
+
+	* .hgsigs:
+	Added signature for changeset 5c042cae7457
+	[89afed83e6e2] [v0.51.0]
+
+	* cert/ged.pem, certs/ged.pem:
+	Fix the name of and update my gem-signing cert
+	[5c042cae7457]
+
+	* History.rdoc, lib/mongrel2.rb:
+	Bump the minor version, update history.
+	[1a66a960918d]
+
+	* Rakefile, mongrel2.gemspec:
+	Update libxml-ruby dep to the latest
+	[9253c00b0a2f]
+
+2017-11-08  Michael Granger  <ged@FaerieMUD.org>
+
+	* mongrel2.gemspec:
+	Update the gemspec
+	[f1817db64b7b]
+
+	* Manifest.txt:
+	Update the manifest
+	[f69cd800ac94]
+
+	* .ruby-version, .tm_properties, Rakefile, lib/mongrel2/config.rb,
+	lib/mongrel2/constants.rb, mongrel2.gemspec:
+	Support Sequel 5
+	[56a2daf04013]
+
+	* data/mongrel2/config.rb.in:
+	Add config input file
+	[19ce3acb3839]
+
+2017-07-05  Michael Granger  <ged@FaerieMUD.org>
+
+	* .hgtags:
+	Added tag v0.50.2 for changeset 08baa3b61eea
+	[79f113fd0f93]
+
+	* .hgsigs:
+	Added signature for changeset 99ce0d32ae15
+	[08baa3b61eea] [v0.50.2]
+
+	* History.rdoc, lib/mongrel2.rb:
+	Bump the patch version, update history.
+	[99ce0d32ae15]
+
+	* lib/mongrel2/handler.rb:
+	Add missing require to Strelka::Handler.
+	[6ad07a7a7775]
+
+2017-05-31  Michael Granger  <ged@FaerieMUD.org>
+
+	* .hgtags:
+	Added tag v0.50.1 for changeset 181a78ed2587
+	[af48c723c110]
+
+	* .hgsigs:
+	Added signature for changeset d7b71efe6141
+	[181a78ed2587] [v0.50.1]
+
+	* History.rdoc, lib/mongrel2.rb:
+	Bump the patch version, update history.
+	[d7b71efe6141]
+
+	* Rakefile, mongrel2.gemspec:
+	Pin Sequel to 4.45 to avoid breaking changes.
+	[e12627bad969]
+
 2017-05-31  Mahlon E. Smith  <mahlon@martini.nu>
 
 	* lib/mongrel2/handler.rb, spec/mongrel2/handler_spec.rb:
 	Randomize the inproc selfpipe socket name.
-	[6beef2396fd4] [github/master, tip]
+	[6beef2396fd4]
 
 2017-05-31  Mahlon E. Smith  <mahlon@laika.com>
 

data/History.rdoc

@@ -1,3 +1,11 @@
+== v0.52.0 [2018-07-21] Michael Granger <ged@FaerieMUD.org>
+
+Enhancements:
+
+- Refactor IO code to use cztop-reactor
+- Fix use of Gem.datadir for newer Rubygems.
+
+
 ==  v0.51.0 [2017-11-15] Michael Granger <ged@FaerieMUD.org>
 
 Enhancements:

data/Rakefile

@@ -26,6 +26,7 @@ hoespec = Hoe.spec 'mongrel2' do
 	self.developer 'Michael Granger', 'ged@FaerieMUD.org'
 
 	self.dependency 'cztop',                '~> 0.11'
+	self.dependency 'cztop-reactor',        '~> 0.3'
 	self.dependency 'libxml-ruby',          '~> 3.0'
 	self.dependency 'loggability',          '~> 0.12'
 	self.dependency 'sequel',               '~> 5.2'

data/lib/mongrel2.rb

@@ -22,10 +22,10 @@ module Mongrel2
 	abort "\n\n>>> Mongrel2 requires Ruby 2.2 or later. <<<\n\n" if RUBY_VERSION < '2.2.0'
 
 	# Library version constant
-	VERSION = '0.51.0'
+	VERSION = '0.52.0'
 
 	# Version-control revision constant
-	REVISION = %q$Revision: 1a66a960918d $
+	REVISION = %q$Revision: aa458f3f9ca9 $
 
 
 	require 'mongrel2/constants'

data/lib/mongrel2/constants.rb

@@ -11,8 +11,8 @@ module Mongrel2::Constants
 	# The Pathname of the data directory
 	DATA_DIR = if ENV['MONGREL2_DATADIR']
 			Pathname( ENV['MONGREL2_DATADIR'] )
-		elsif Gem.datadir( 'mongrel2' ) && File.directory?( Gem.datadir('mongrel2') )
-			Pathname( Gem.datadir('mongrel2') )
+		elsif Gem.loaded_specs[ 'mongrel2' ] && File.exist?( Gem.loaded_specs['mongrel2'].datadir )
+			Pathname( Gem.loaded_specs['mongrel2'].datadir )
 		else
 			Pathname( __FILE__ ).dirname.parent.parent + 'data/mongrel2'
 		end

data/lib/mongrel2/handler.rb

@@ -2,6 +2,8 @@
 #encoding: utf-8
 
 require 'cztop'
+require 'cztop/reactor'
+require 'cztop/reactor/signal_handling'
 require 'securerandom'
 require 'loggability'
 
@@ -85,7 +87,8 @@ require 'mongrel2/websocket'
 #
 class Mongrel2::Handler
 	extend Loggability
-	include Mongrel2::Constants
+	include Mongrel2::Constants,
+	        CZTop::Reactor::SignalHandling
 
 
 	# Loggability API -- set up logging under the 'mongrel2' log host
@@ -96,7 +99,7 @@ class Mongrel2::Handler
 	QUEUE_SIGS = [
 		:INT, :TERM, :HUP, :USR1,
 		# :TODO: :QUIT, :WINCH, :USR2, :TTIN, :TTOU
-	]
+	] & Signal.list.keys.map( &:to_sym )
 
 
 	### Create an instance of the handler using the config from the database with
@@ -136,14 +139,12 @@ class Mongrel2::Handler
 	### Create a new instance of the handler with the specified +app_id+, +send_spec+,
 	### and +recv_spec+.
 	def initialize( app_id, send_spec, recv_spec ) # :notnew:
+		super() # To the signal handler mixin
+
 		@app_id    = app_id
 
 		@conn      = Mongrel2::Connection.new( app_id, send_spec, recv_spec )
-
-		@self_pipe = nil
-		@poller    = nil
-
-		Thread.main[:signal_queue] = []
+		@reactor   = CZTop::Reactor.new
 	end
 
 
@@ -151,31 +152,30 @@ class Mongrel2::Handler
 	public
 	######
 
+	##
 	# The handler's Mongrel2::Connection object.
 	attr_reader :conn
 
+	##
 	# The app ID the app was created with
 	attr_reader :app_id
 
+	##
+	# The CZTop::Reactor that manages IO
+	attr_reader :reactor
+
 
 	### Run the handler.
 	def run
 		self.log.info "Starting up %p" % [ self ]
 
-		rand_id = "%d-%s" % [ Process.pid, SecureRandom.hex(8) ]
-		@self_pipe = {
-			reader: CZTop::Socket::PAIR.new( "@inproc://signal-handler-#{rand_id}" ),
-			writer: CZTop::Socket::PAIR.new( ">inproc://signal-handler-#{rand_id}" )
-		}
-
-		@poller = CZTop::Poller.new( @conn.request_sock, @self_pipe[:reader] )
-
-		self.set_signal_handlers
-		self.start_accepting_requests
+		self.reactor.register( @conn.request_sock, :read, &self.method(:on_socket_event) )
+		self.with_signal_handler( self.reactor, *QUEUE_SIGS ) do
+			self.start_accepting_requests
+		end
 
 		return self # For chaining
 	ensure
-		self.restore_signal_handlers
 		self.log.info "Done: %p" % [ self ]
 		@conn.close if @conn
 	end
@@ -224,7 +224,7 @@ class Mongrel2::Handler
 	### Shut down the handler.
 	def shutdown
 		self.log.info "Shutting down."
-		self.ignore_signals
+		self.reactor.stop_polling
 		@conn.close
 	end
 
@@ -234,9 +234,9 @@ class Mongrel2::Handler
 	def restart
 		self.log.info "Restarting"
 		if (( old_conn = @conn ))
+			self.reactor.unregister( old_conn.request_sock )
 			@conn = @conn.dup
-
-			@poller = CZTop::Poller.new( @conn.request_sock, @self_pipe[:reader] )
+			self.reactor.register( @conn.request_sock, :read, &self.method(:on_socket_event) )
 
 			self.log.debug "  conn %p -> %p" % [ old_conn, @conn ]
 			old_conn.close
@@ -247,28 +247,20 @@ class Mongrel2::Handler
 	### Start a loop, accepting a request and handling it.
 	def start_accepting_requests
 		self.log.info "Starting the request loop."
-		until @conn.closed?
-			begin
-				if event = @poller.wait
-					case event.socket
-					when @conn.request_sock
-						req = @conn.receive
-						self.accept_request( req ) unless @conn.closed?
-					when @self_pipe[:reader]
-						@self_pipe[:reader].wait
-						self.process_signal_queue
-					else
-						self.log.warn "Got unhandled poller event: %p" % [ event ]
-					end
-				end
-			rescue Errno::EAGAIN
-				# self.log.debug "Got EAGAIN, retrying."
-			rescue Interrupt
-				# self.log.debug "Got an Interrupt; retrying."
-			end
-		end
+		self.reactor.start_polling( ignore_interrupts: true )
+	end
+
 
-		self.log.debug "Done accepting requests."
+	### Reactor callback -- handle an IO event.
+	def on_socket_event( event )
+		if event.readable?
+			req = self.conn.receive
+			self.accept_request( req )
+		elsif event.writable?
+			raise "Request socket became writable?!"
+		else
+			raise "Socket event was neither readable nor writable! (%s)" % [ event ]
+		end
 	end
 
 
@@ -379,9 +371,9 @@ class Mongrel2::Handler
 	def handle_websocket( request )
 		self.log.warn "Unhandled WEBSOCKET frame (%p)" % [ request.headers.path ]
 		res = request.response
-		res.make_close_frame( WebSocket::CLOSE_POLICY_VIOLATION )
-		self.conn.reply( res)
+		res.make_close_frame( Mongrel2::WebSocket::CLOSE_POLICY_VIOLATION )
 
+		self.conn.reply( res )
 		self.conn.reply_close( request )
 
 		return nil
@@ -391,8 +383,8 @@ class Mongrel2::Handler
 	### Handle a WebSocket handshake HTTP +request+. If not overridden, this method drops
 	### the connection.
 	def handle_websocket_handshake( handshake )
-		self.log.warn "Unhandled WEBSOCKET_HANDSHAKE request (%p)" % [ request.headers.path ]
-		self.conn.reply_close( request )
+		self.log.warn "Unhandled WEBSOCKET_HANDSHAKE request (%p)" % [ handshake.headers.path ]
+		self.conn.reply_close( handshake )
 
 		return nil
 	end
@@ -401,7 +393,7 @@ class Mongrel2::Handler
 	### Handle a disconnect notice from Mongrel2 via the given +request+. Its return value
 	### is ignored.
 	def handle_disconnect( request )
-		self.log.info "Unhandled disconnect notice."
+		self.log.info "Connection %p closed." % [ request.conn_id ]
 		return nil
 	end
 
@@ -436,57 +428,9 @@ class Mongrel2::Handler
 	# :section: Signal Handling
 	# These methods set up some behavior for starting, restarting, and stopping
 	# your application when a signal is received. If you don't want signals to
-	# be handled, override #set_signal_handlers with an empty method.
+	# be handled, override #handle_signal with an empty method.
 	#
 
-	### Wake up the handler when a signal needs to be processed.
-	def wake_up
-		$stderr.puts "Waking up the signal handler"
-		@self_pipe[ :writer ].signal( 0 )
-		$stderr.puts "Done sending the wakeup."
-	end
-
-
-	### Set up signal handlers for common signals that will shut down, restart, etc.
-	def set_signal_handlers
-		self.log.debug "Setting up deferred signal handlers."
-		QUEUE_SIGS.each do |sig|
-			Signal.trap( sig ) do
-				Thread.main[:signal_queue] << sig
-				self.wake_up
-				$stderr.puts "Done handling the signal."
-			end
-		end
-	end
-
-
-	### Set all signal handlers to ignore.
-	def ignore_signals
-		self.log.debug "Ignoring signals."
-		QUEUE_SIGS.each do |sig|
-			Signal.trap( sig, :IGNORE )
-		end
-	end
-
-
-	### Set the signal handlers back to their defaults.
-	def restore_signal_handlers
-		self.log.debug "Restoring default signal handlers."
-		QUEUE_SIGS.each do |sig|
-			Signal.trap( sig, :DEFAULT )
-		end
-	end
-
-
-	### Handle any queued signals.
-	def process_signal_queue
-		# Look for any signals that arrived and handle them
-		while sig = Thread.main[:signal_queue].shift
-			self.handle_signal( sig )
-		end
-	end
-
-
 	### Handle signals.
 	def handle_signal( sig )
 		self.log.debug "Handling signal %s" % [ sig ]

data/lib/mongrel2/websocket.rb

@@ -463,6 +463,13 @@ module Mongrel2::WebSocket
 		end
 
 
+		### Set the :close opcode on this frame and set its status to +statuscode+.
+		def make_close_frame( statuscode=Mongrel2::WebSocket::CLOSE_NORMAL )
+			self.opcode = :close
+			self.set_status( statuscode )
+		end
+
+
 		### Overwrite the frame's payload with a status message based on
 		### +statuscode+.
 		def set_status( statuscode )
@@ -622,6 +629,12 @@ module Mongrel2::WebSocket
 		end
 
 
+		### Compatibility with Mongrel2::Response.
+		def extended_reply? # :nodoc:
+			return false
+		end
+
+
 		#########
 		protected
 		#########

data/spec/helpers.rb

@@ -91,6 +91,13 @@ module Mongrel2::SpecHelpers
 	end
 
 
+	### Make a Mongrel2::Request from the specified +opts+ and return it.
+	def make_request_object( opts={} )
+		data = make_request( opts )
+		return Mongrel2::Request.parse( data )
+	end
+
+
 	### Make a new-style (TNetstring headers) raw Mongrel2 request from the specified +opts+
 	### and return it as a String.
 	def make_tn_request( opts={} )
@@ -135,6 +142,13 @@ module Mongrel2::SpecHelpers
 	end
 
 
+	### Make a Mongrel2::JSONRequest from the specified +opts+ and return it.
+	def make_json_request_object( opts={} )
+		data = make_json_request( opts )
+		return Mongrel2::Request.parse( data )
+	end
+
+
 	### Make a Mongrel2 request for an XML route.
 	def make_xml_request( opts={} )
 		opts = TEST_XML_REQUEST_OPTS.merge( opts )
@@ -158,6 +172,13 @@ module Mongrel2::SpecHelpers
 	end
 
 
+	### Make a Mongrel2::XMLRequest from the specified +opts+ and return it.
+	def make_xml_request_object( opts={} )
+		data = make_xml_request( opts )
+		return Mongrel2::Request.parse( data )
+	end
+
+
 	### Make a Mongrel2 handshake request for a WebSocket route.
 	def make_websocket_handshake( opts={} )
 		opts = TEST_WEBSOCKET_REQUEST_OPTS.merge( opts )
@@ -180,6 +201,14 @@ module Mongrel2::SpecHelpers
 	end
 
 
+	### Make a Mongrel2::WebSocket::ClientHandshake from the specified +opts+ and
+	### return it.
+	def make_websocket_handshake_object( opts={} )
+		data = make_websocket_handshake( opts )
+		return Mongrel2::Request.parse( data )
+	end
+
+
 	### Make a Mongrel2 frame for a WebSocket route.
 	def make_websocket_frame( opts={} )
 		opts = TEST_WEBSOCKET_REQUEST_OPTS.merge( opts )
@@ -201,6 +230,13 @@ module Mongrel2::SpecHelpers
 		return data.encode( 'binary' )
 	end
 
+
+	### Make a Mongrel2::WebSocket::Frame from the specified +opts+ and return it.
+	def make_websocket_frame_object( opts={} )
+		data = make_websocket_frame( opts )
+		return Mongrel2::Request.parse( data )
+	end
+
 end
 
 

data/spec/mongrel2/connection_spec.rb

@@ -14,9 +14,6 @@ require 'mongrel2/connection'
 describe Mongrel2::Connection do
 	include Mongrel2::Config::DSL
 
-	before( :all ) do
-	end
-
 	# Ensure 0MQ never actually gets called
 	before( :each ) do
 		@conn = Mongrel2::Connection.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC )
@@ -28,6 +25,7 @@ describe Mongrel2::Connection do
 		expect( @conn.instance_variable_get( :@response_sock ) ).to be_nil()
 	end
 
+
 	it "connects to the endpoints specified on demand" do
 		request_sock = double( "request socket", options: OpenStruct.new )
 		response_sock = double( "response socket", options: OpenStruct.new )
@@ -45,10 +43,12 @@ describe Mongrel2::Connection do
 		expect( @conn.response_sock ).to eq( response_sock )
 	end
 
+
 	it "stringifies as a description of the appid and both sockets" do
 		expect( @conn.to_s ).to eq( "{#{TEST_UUID}} #{TEST_SEND_SPEC} <-> #{TEST_RECV_SPEC}" )
 	end
 
+
 	context "after a connection has been established" do
 
 		before( :each ) do
@@ -69,6 +69,7 @@ describe Mongrel2::Connection do
 			@conn.close
 		end
 
+
 		it "raises an exception if asked to fetch data after being closed" do
 			allow( @request_sock ).to receive( :close )
 			allow( @response_sock ).to receive( :close )
@@ -80,6 +81,7 @@ describe Mongrel2::Connection do
 			}.to raise_error( Mongrel2::ConnectionError, /operation on closed connection/i )
 		end
 
+
 		it "doesn't keep its request and response sockets when duped" do
 			request_sock2 = double( "request socket", :options => OpenStruct.new, :connect => nil )
 			response_sock2 = double( "response socket", :options => OpenStruct.new, :connect => nil )
@@ -92,6 +94,7 @@ describe Mongrel2::Connection do
 			expect( duplicate.response_sock ).to eq( response_sock2 )
 		end
 
+
 		it "doesn't keep its closed state when duped" do
 			expect( @request_sock ).to receive( :close )
 			expect( @response_sock ).to receive( :close )
@@ -102,22 +105,26 @@ describe Mongrel2::Connection do
 			expect( duplicate ).to_not be_closed()
 		end
 
+
 		it "can read raw request messages off of the request_sock" do
 			expect( @request_sock ).to receive( :receive ).and_return( CZTop::Message.new( "the data" ) )
 			expect( @conn.recv ).to eq( "the data" )
 		end
 
+
 		it "can read request messages off of the request_sock as Mongrel2::Request objects" do
-			msg = make_request()
-			expect( @request_sock ).to receive( :receive ).and_return( CZTop::Message.new( msg ) )
+			req = make_request()
+			expect( @request_sock ).to receive( :receive ).and_return( CZTop::Message.new(req) )
 			expect( @conn.receive ).to be_a( Mongrel2::Request )
 		end
 
+
 		it "can write raw response messages with a TNetString header onto the response_sock" do
 			expect( @response_sock ).to receive( :<< ).with( "#{TEST_UUID} 1:8, the data" )
 			@conn.send( TEST_UUID, 8, "the data" )
 		end
 
+
 		it "can write Mongrel2::Responses to the response_sock" do
 			expect( @response_sock ).to receive( :<< ).with( "#{TEST_UUID} 1:8, the data" )
 
@@ -125,30 +132,35 @@ describe Mongrel2::Connection do
 			@conn.reply( response )
 		end
 
+
 		it "can write raw response messages to more than one conn_id at the same time" do
 			expect( @response_sock ).to receive( :<< ).
 				with( "#{TEST_UUID} 15:8 16 44 45 1833, the data" )
 			@conn.broadcast( TEST_UUID, [8, 16, 44, 45, 1833], 'the data' )
 		end
 
+
 		it "can write raw response messages to more than one conn_id at the same time" do
 			expect( @response_sock ).to receive( :<< ).
 				with( "#{TEST_UUID} 15:8 16 44 45 1833, the data" )
 			@conn.broadcast( TEST_UUID, [8, 16, 44, 45, 1833], 'the data' )
 		end
 
+
 		it "can write an extended response message" do
 			expect( @response_sock ).to receive( :<< ).
 				with( "#{TEST_UUID} 3:X 8, 27:8:sendfile,12:the_data.txt,]" )
 			@conn.send_extended( TEST_UUID, 8, :sendfile, "the_data.txt" )
 		end
 
+
 		it "can broadcast an extended response message" do
 			expect( @response_sock ).to receive( :<< ).
 				with( "#{TEST_UUID} 9:X 8 16 32, 27:8:sendfile,12:the_data.txt,]" )
 			@conn.broadcast_extended( TEST_UUID, [8,16,32], :sendfile, "the_data.txt" )
 		end
 
+
 		it "can write a Mongrel2::Response with extended reply" do
 			expect( @response_sock ).to receive( :<< ).
 				with( "#{TEST_UUID} 1:8, " )
@@ -162,6 +174,7 @@ describe Mongrel2::Connection do
 			@conn.reply( response )
 		end
 
+
 		it "can tell the connection a request or a response was from to close" do
 			expect( @response_sock ).to receive( :<< ).with( "#{TEST_UUID} 1:8, " )
 
@@ -169,6 +182,7 @@ describe Mongrel2::Connection do
 			@conn.reply_close( response )
 		end
 
+
 		it "can broadcast a close to multiple connection IDs" do
 			expect( @response_sock ).to receive( :<< ).with( "#{TEST_UUID} 15:8 16 44 45 1833, " )
 			@conn.broadcast_close( TEST_UUID, [8, 16, 44, 45, 1833] )

data/spec/mongrel2/handler_spec.rb

@@ -16,48 +16,9 @@ require 'mongrel2/handler'
 
 describe Mongrel2::Handler, :db do
 
-	# Make a handler class for testing that only ever handles one request, and
-	# keeps track of any requests it handles and their responses.
-	class OneShotHandler < Mongrel2::Handler
-		def initialize( * )
-			@transactions = {}
-			super
-		end
-
-		attr_reader :transactions
-
-		# Overridden to accept one request and shut down
-		def dispatch_request( request )
-			response = super
-			self.transactions[ request ] = response
-			self.shutdown
-			return response
-		end
-
-	end # class OneShotHandler
-
-
-	# Ensure 0MQ never actually gets called
-	before( :each ) do
-		@request_sock    = instance_double( CZTop::Socket::PULL, :options => OpenStruct.new, :connect => nil, :close => nil )
-		@response_sock   = instance_double( CZTop::Socket::PUB, :options => OpenStruct.new, :connect => nil, :close => nil )
-		@selfpipe_reader = instance_double( CZTop::Socket::PAIR )
-		@selfpipe_writer = instance_double( CZTop::Socket::PAIR )
-		@poller          = instance_double( CZTop::Poller )
-		@poller_event    = instance_double( CZTop::Poller::Event )
-
-		allow( CZTop::Socket::PULL ).to receive( :new ).and_return( @request_sock )
-		allow( CZTop::Socket::PUB ).to receive( :new ).and_return( @response_sock )
-		allow( CZTop::Socket::PAIR ).to receive( :new ).with( %r|@inproc://signal-handler-\d+-\w{8}| ).
-			and_return( @selfpipe_reader )
-		allow( CZTop::Socket::PAIR ).to receive( :new ).with( %r|>inproc://signal-handler-\d+-\w{8}| ).
-			and_return( @selfpipe_writer )
-		allow( CZTop::Poller ).to receive( :new ).and_return( @poller )
-
-		allow( @poller ).to receive( :wait ).and_return( @poller_event )
-		allow( @poller_event ).to receive( :socket ).and_return( @request_sock )
-	end
-
+	# Make a handler class for testing
+	class TestingHandler < Mongrel2::Handler
+	end # class TestingHandler
 
 
 	context "with a Handler entry in the config database" do
@@ -85,30 +46,34 @@ describe Mongrel2::Handler, :db do
 		end
 
 
-		it "has a convenience method for instantiating and running a Handler given an " +
-		   "application ID" do
+		it "has a convenience method for instantiating and running a Handler given an application ID" do
+			reactor = instance_double( CZTop::Reactor )
+			expect( CZTop::Reactor ).to receive( :new ).and_return( reactor )
+			expect( reactor ).to receive( :register ).at_least( :once )
+			expect( reactor ).to receive( :unregister ).at_least( :once )
+			expect( reactor ).to receive( :start_polling ).with( ignore_interrupts: true )
 
-			req = make_request()
-			expect( @request_sock ).to receive( :receive ).and_return( CZTop::Message.new( req ) )
-
-			res = OneShotHandler.run( TEST_UUID )
+			handler = TestingHandler.run( TEST_UUID )
 
 			# It should have pulled its connection info from the Handler entry in the database
-			expect( res.conn.app_id ).to eq( TEST_UUID )
-			expect( res.conn.sub_addr ).to eq( TEST_SEND_SPEC )
-			expect( res.conn.pub_addr ).to eq( TEST_RECV_SPEC )
+			expect( handler.conn.app_id ).to eq( TEST_UUID )
+			expect( handler.conn.sub_addr ).to eq( TEST_SEND_SPEC )
+			expect( handler.conn.pub_addr ).to eq( TEST_RECV_SPEC )
 		end
 
 
-		it "knows what handler config corresponds to its" do
-			req = make_request()
-			expect( @request_sock ).to receive( :receive ).and_return( CZTop::Message.new( req ) )
+		it "knows what handler config corresponds to its app UUID" do
+			reactor = instance_double( CZTop::Reactor )
+			expect( CZTop::Reactor ).to receive( :new ).and_return( reactor )
+			expect( reactor ).to receive( :register ).at_least( :once )
+			expect( reactor ).to receive( :unregister ).at_least( :once )
+			expect( reactor ).to receive( :start_polling ).with( ignore_interrupts: true )
 
-			res = OneShotHandler.run( TEST_UUID )
+			handler = TestingHandler.run( TEST_UUID )
 
-			expect( res.handler_config ).to be_a( Mongrel2::Config::Handler )
-			expect( res.handler_config.send_spec ).to eq( TEST_SEND_SPEC )
-			expect( res.handler_config.recv_spec ).to eq( TEST_RECV_SPEC )
+			expect( handler.handler_config ).to be_a( Mongrel2::Config::Handler )
+			expect( handler.handler_config.send_spec ).to eq( TEST_SEND_SPEC )
+			expect( handler.handler_config.recv_spec ).to eq( TEST_RECV_SPEC )
 		end
 
 	end
@@ -130,194 +95,189 @@ describe Mongrel2::Handler, :db do
 	end
 
 
-	it "dispatches HTTP requests to the #handle method" do
-		req = make_request()
-		expect( @request_sock ).to receive( :receive ).and_return( CZTop::Message.new( req ) )
+	it "responds to HTTP requests with a 204 No Content response by default" do
+		request = make_request_object()
+		handler = TestingHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC )
 
-		res = OneShotHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
+		response = handler.dispatch_request( request )
 
-		expect( res.transactions.size ).to eq(  1  )
-		request, response = res.transactions.first
-		expect( request ).to be_a( Mongrel2::HTTPRequest )
 		expect( response ).to be_a( Mongrel2::HTTPResponse )
 		expect( response.status ).to eq( 204 )
 	end
 
 
 	it "ignores JSON messages by default" do
-		req = make_json_request()
-		expect( @request_sock ).to receive( :receive ).and_return( CZTop::Message.new( req ) )
+		request = make_json_request_object()
+		handler = TestingHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC )
 
-		res = OneShotHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
+		response = handler.dispatch_request( request )
 
-		expect( res.transactions.size ).to eq(  1  )
-		request, response = res.transactions.first
-		expect( request ).to be_a( Mongrel2::JSONRequest )
-		expect( response ).to be_nil()
+		expect( response ).to be_nil
 	end
 
 
 	it "dispatches JSON message to the #handle_json method" do
-		json_handler = Class.new( OneShotHandler ) do
+		json_handler_class = Class.new( TestingHandler ) do
 			def handle_json( request )
 				return request.response
 			end
 		end
+		request = make_json_request_object()
+		handler = json_handler_class.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC )
 
-		req = make_json_request()
-		expect( @request_sock ).to receive( :receive ).and_return( CZTop::Message.new( req ) )
-
-		res = json_handler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
+		response = handler.dispatch_request( request )
 
-		expect( res.transactions.size ).to eq(  1  )
-		request, response = res.transactions.first
-		expect( request ).to be_a( Mongrel2::JSONRequest )
 		expect( response ).to be_a( Mongrel2::Response )
 	end
 
 
 	it "ignores XML messages by default" do
-		req = make_xml_request()
-		expect( @request_sock ).to receive( :receive ).and_return( CZTop::Message.new( req ) )
+		request = make_xml_request_object()
+		handler = TestingHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC )
 
-		res = OneShotHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
+		response = handler.dispatch_request( request )
 
-		expect( res.transactions.size ).to eq(  1  )
-		request, response = res.transactions.first
-		expect( request ).to be_a( Mongrel2::XMLRequest )
-		expect( response ).to be_nil()
+		expect( response ).to be_nil
 	end
 
 
 	it "dispatches XML message to the #handle_xml method" do
-		xml_handler = Class.new( OneShotHandler ) do
+		xml_handler_class = Class.new( TestingHandler ) do
 			def handle_xml( request )
 				return request.response
 			end
 		end
+		request = make_xml_request_object()
+		handler = xml_handler_class.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC )
 
-		req = make_xml_request()
-		expect( @request_sock ).to receive( :receive ).and_return( CZTop::Message.new( req ) )
-
-		res = xml_handler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
+		response = handler.dispatch_request( request )
 
-		expect( res.transactions.size ).to eq(  1  )
-		request, response = res.transactions.first
-		expect( request ).to be_a( Mongrel2::XMLRequest )
 		expect( response ).to be_a( Mongrel2::Response )
 	end
 
 
+	it "drops the connection on websocket opening handshakes by default" do
+		request = make_websocket_handshake_object()
+		handler = TestingHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC )
+
+		expect( handler.conn ).to receive( :reply_close ).with( request )
+
+		response = handler.dispatch_request( request )
+
+		expect( response ).to be_nil
+	end
+
+
 	it "dispatches WebSocket opening handshakes to the #handle_websocket_handshake method" do
-		ws_handler = Class.new( OneShotHandler ) do
+		ws_handler_class = Class.new( TestingHandler ) do
 			def handle_websocket_handshake( handshake )
 				return handshake.response
 			end
 		end
+		request = make_websocket_handshake_object()
+		handler = ws_handler_class.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC )
 
-		req = make_websocket_handshake()
-		expect( @request_sock ).to receive( :receive ).and_return( CZTop::Message.new( req ) )
+		response = handler.dispatch_request( request )
 
-		res = ws_handler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
-
-		expect( res.transactions.size ).to eq(  1  )
-		request, response = res.transactions.first
-		expect( request ).to be_a( Mongrel2::WebSocket::ClientHandshake )
 		expect( response ).to be_a( Mongrel2::WebSocket::ServerHandshake )
 	end
 
 
-	it "dispatches WebSocket protocol frames to the #handle_websocket method" do
-		ws_handler = Class.new( OneShotHandler ) do
-			def handle_websocket( frame )
-				return frame.response
-			end
-		end
+	it "directly closes the connection on websocket frames with a protocol violation by default" do
+		request = make_websocket_frame_object()
+		handler = TestingHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC )
 
-		req = make_websocket_frame()
-		expect( @request_sock ).to receive( :receive ).and_return( CZTop::Message.new( req ) )
+		expect( handler.conn ).to receive( :reply_close ).with( request )
+		expect( handler.conn ).to receive( :reply ) do |reply|
+			expect( reply ).to be_a( Mongrel2::WebSocket::Frame )
+			expect( reply.opcode ).to eq( :close )
+			reply.payload.rewind
+			expect( reply.payload.read ).to start_with( '1008 ' )
+		end
 
-		res = ws_handler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
+		response = handler.dispatch_request( request )
 
-		expect( res.transactions.size ).to eq(  1  )
-		request, response = res.transactions.first
-		expect( request ).to be_a( Mongrel2::WebSocket::Frame )
-		expect( response ).to be_a( Mongrel2::WebSocket::Frame )
+		expect( response ).to be_nil
 	end
 
 
-	it "continues when a SocketError is received but the connection remains open" do
-		pending "Does this still apply?"
-		req = make_request()
-
-		expect( @request_sock ).to receive( :receive ).and_raise( SocketError.new("Interrupted system call.") )
-		expect( @request_sock ).to receive( :receive ).and_return( CZTop::Message.new( req ) )
+	it "dispatches WebSocket protocol frames to the #handle_websocket method" do
+		ws_handler_class = Class.new( TestingHandler ) do
+			def handle_websocket( frame )
+				return frame.response
+			end
+		end
+		request = make_websocket_frame_object()
+		handler = ws_handler_class.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC )
 
-		res = OneShotHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
+		response = handler.dispatch_request( request )
 
-		expect( res.transactions.size ).to eq(  1  )
-		request, response = res.transactions.first
-		expect( request ).to be_a( Mongrel2::HTTPRequest )
-		expect( response ).to be_a( Mongrel2::HTTPResponse )
-		expect( response.status ).to eq( 204 )
+		expect( response ).to be_a( Mongrel2::WebSocket::Frame )
 	end
 
 
 	it "ignores disconnect notices by default" do
-		req = make_json_request( :path => '@*', :body => {'type' => 'disconnect'} )
-		expect( @request_sock ).to receive( :receive ).and_return( CZTop::Message.new( req ) )
+		request = make_json_request_object( :path => '@*', :body => {'type' => 'disconnect'} )
+		handler = TestingHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC )
 
-		res = OneShotHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
+		response = handler.dispatch_request( request )
 
-		expect( res.transactions.size ).to eq(  1  )
-		request, response = res.transactions.first
-		expect( request ).to be_a( Mongrel2::JSONRequest )
-		expect( response ).to be_nil()
+		expect( response ).to be_nil
 	end
 
 
 	it "dispatches disconnect notices to the #handle_disconnect method" do
-		disconnect_handler = Class.new( OneShotHandler ) do
+		disconnect_handler_class = Class.new( TestingHandler ) do
+			def initialize( * )
+				super
+				@handled_disconnect = false
+			end
+
+			attr_reader :handled_disconnect
+
 			def handle_disconnect( request )
+				@handled_disconnect = true
 				self.log.debug "Doing stuff for disconnected connection %d" % [ request.conn_id ]
 			end
 		end
+		request = make_json_request_object( :path => '@*', :body => {'type' => 'disconnect'} )
+		handler = disconnect_handler_class.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC )
 
-		req = make_json_request( :path => '@*', :body => {'type' => 'disconnect'} )
-		expect( @request_sock ).to receive( :receive ).and_return( CZTop::Message.new( req ) )
-
-		res = disconnect_handler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
+		response = handler.dispatch_request( request )
 
-		expect( res.transactions.size ).to eq(  1  )
-		request, response = res.transactions.first
-		expect( request ).to be_a( Mongrel2::JSONRequest )
-		expect( response ).to be_nil()
+		expect( response ).to be_nil
+		expect( handler.handled_disconnect ).to eq( true )
 	end
 
 
 	it "cancels async upload notices by default" do
-		req = make_request( 'METHOD' => 'POST', :headers => {'x-mongrel2-upload-start' => 'uploadfile.XXX'} )
-		expect( @request_sock ).to receive( :receive ).and_return( CZTop::Message.new( req ) )
-		expect( @response_sock ).to receive( :<< ).with( "#{TEST_UUID} 1:8, " )
+		request = make_request_object(
+			'METHOD' => 'POST',
+			headers: {'x-mongrel2-upload-start' => 'uploadfile.XXX'}
+		)
+		handler = TestingHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC )
+		expect( handler.conn ).to receive( :reply_close ).with( request )
 
-		res = OneShotHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
+		response = handler.dispatch_request( request )
 
-		expect( res.transactions.size ).to eq(  1  )
-		request, response = res.transactions.first
-		expect( response ).to be_nil()
+		expect( response ).to be_nil
 	end
 
 
 	it "re-establishes its connection when told to restart" do
-		res = OneShotHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC )
-		pipe_reader = instance_double( CZTop::Socket::PAIR )
-		pipe_writer = instance_double( CZTop::Socket::PAIR )
-		res.instance_variable_set( :@self_pipe, {reader: pipe_reader, writer: pipe_writer} )
+		handler = TestingHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC )
+		original_conn = handler.conn
+
+		expect( handler.reactor ).to receive( :unregister ).with( original_conn.request_sock )
+		expect( handler.reactor ).to receive( :register ) do |request_sock, mode, &callback|
+			expect( request_sock ).to be_a( CZTop::Socket )
+			expect( request_sock ).to_not equal( original_conn.request_sock )
+			expect( mode ).to eq( :read )
+		end
 
-		original_conn = res.conn
-		res.restart
+		handler.restart
 
-		expect( res.conn ).to_not equal( original_conn )
+		expect( handler.conn ).to_not equal( original_conn )
 	end
 
 
@@ -325,14 +285,18 @@ describe Mongrel2::Handler, :db do
 		spoolfile = Pathname.new( Dir.tmpdir + '/mongrel2.uskd8l1' )
 		spoolfile.write( "Hi!" )
 
-		req = make_request( 'METHOD' => 'POST', :headers => {
-			'x-mongrel2-upload-start' => spoolfile.basename,
-			'x-mongrel2-upload-done'  => spoolfile.basename
-		})
-		expect( @request_sock ).to receive( :receive ).and_return( CZTop::Message.new( req ) )
+		request = make_request_object(
+			'METHOD' => 'POST',
+			headers: {
+				'x-mongrel2-upload-start' => spoolfile.basename,
+				'x-mongrel2-upload-done'  => spoolfile.basename
+			}
+		)
+		handler = TestingHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC )
+
+		expect( handler.conn ).to receive( :reply ).with( a_kind_of(Mongrel2::Response) )
+		response = handler.accept_request( request )
 
-		res = OneShotHandler.new( TEST_UUID, TEST_SEND_SPEC, TEST_RECV_SPEC ).run
-		request, response = res.transactions.first
 		expect( request.body ).to be_closed
 		expect( spoolfile ).to_not exist
 	end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongrel2
 version: !ruby/object:Gem::Version
-  version: 0.51.0
+  version: 0.52.0
 platform: ruby
 authors:
 - Michael Granger
@@ -35,7 +35,7 @@ cert_chain:
   X0qdrKi+2aZZ0NGuFj9AItBsVmAvkBGIpX4TEKQp5haEbPpmaqO5nIIhV26PXmyT
   OMKv6pWsoS81vw5KAGBmfX8nht/Py90DQrbRvakATGI=
   -----END CERTIFICATE-----
-date: 2017-11-15 00:00:00.000000000 Z
+date: 2018-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cztop
@@ -51,6 +51,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: cztop-reactor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: libxml-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -399,7 +413,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Ruby-Mongrel2 is a complete Ruby connector for Mongrel2[http://mongrel2.org/]