mongrel2 0.15.1 → 0.16.0

data/examples/ws-echo.rb

@@ -0,0 +1,251 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'pathname'
+require 'logger'
+require 'mongrel2/config'
+require 'mongrel2/logging'
+require 'mongrel2/handler'
+
+
+# An example of a WebSocket (RFC6455) Mongrel2 application that echoes back whatever
+# (non-control) frames you send it. It will also ping all of its clients and disconnect
+# ones that don't reply within a given period.
+class WebSocketEchoServer < Mongrel2::Handler
+	include Mongrel2::WebSocket::Constants
+
+	# Number of seconds to wait between heartbeat PING frames
+	HEARTBEAT_RATE = 5.0
+
+	# Number of seconds to wait for a data frame or a PONG before considering
+	# a socket idle
+	SOCKET_IDLE_TIMEOUT = 15.0
+
+
+	# Add an instance variable to keep track of connections, and one for the
+	# heartbeat thread.
+	def initialize( * )
+		super
+		@connections = {}
+		@heartbeat = nil
+	end
+
+
+	######
+	public
+	######
+
+	# A Hash of last seen times keyed by [sender ID, connection ID] tuple
+	attr_reader :connections
+
+	# The Thread that sends PING frames to connected sockets and cull any
+	# that don't reply within SOCKET_IDLE_TIMEOUT seconds
+	attr_reader :heartbeat
+
+
+	# Called by Mongrel2::Handler when it starts accepting requests. Overridden
+	# to start up the heartbeat thread.
+	def start_accepting_requests
+		self.start_heartbeat
+		super
+	end
+
+
+	# Called by Mongrel2::Handler when the server is restarted. Overridden to
+	# restart the heartbeat thread.
+	def restart
+		self.stop_heartbeat
+		super
+		self.start_heartbeat
+	end
+
+
+	# Called by Mongrel2::Handler when the server is shut down. Overridden to
+	# stop the heartbeat thread.
+	def shutdown
+		self.stop_heartbeat
+		super
+	end
+
+
+	# Mongrel2 will send a disconnect notice when a client's connection closes;
+	# delete the connection when it does.
+	def handle_disconnect( request )
+		self.log.info "Client %d: disconnect." % [ request.conn_id ]
+		self.connections.delete( [request.sender_id, request.conn_id] )
+		return nil
+	end
+
+
+	# Non-websocket (e.g., plain HTTP) requests would ordinarily just get
+	# a 204 NO CONTENT response, but we tell Mongrel2 to just drop such connections
+	# immediately.
+	def handle( request )
+		self.log.info "Regular HTTP request (%s): closing channel." % [ request ]
+		self.conn.reply_close( request )
+		return nil
+	end
+
+
+	# This is the main handler for WebSocket requests. Each frame comes in as a
+	# Mongrel::WebSocket::Frame object, and then is dispatched according to what
+	# opcode it has.
+	def handle_websocket( frame )
+
+		# Log each frame
+		self.log.info "%s/%d: %s%s [%s]: %p" % [
+			frame.sender_id,
+			frame.conn_id,
+			frame.opcode.to_s.upcase,
+			frame.fin? ? '' : '(cont)',
+			frame.headers.x_forwarded_for,
+			frame.payload[ 0, 20 ],
+		]
+
+		# If a client sends an invalid frame, close their connection, but politely.
+		if !frame.valid?
+			self.log.error "  invalid frame from client: %s" % [ frame.errors.join(';') ]
+			res = frame.response( :close )
+			res.set_status( CLOSE_PROTOCOL_ERROR )
+			return res
+		end
+
+		# Update the 'last-seen' time unless the connection is closing
+		unless frame.opcode == :close
+			@connections[ [frame.sender_id, frame.conn_id] ] = Time.now
+		end
+
+		# Use the opcode to decide what method to call
+		self.log.debug "Handling a %s frame." % [ frame.opcode ]
+		handler = self.method( "handle_%s_frame" % [frame.opcode] )
+		return handler.call( frame )
+	end
+
+
+	# Handle TEXT, BINARY, and CONTINUATION frames by replying with an echo of the
+	# same data. Fragmented frames get echoed back as-is without any reassembly.
+	def handle_text_frame( frame )
+		self.log.info "Echoing data frame: %p" % [ frame ]
+
+		# Make the response frame
+		response = frame.response
+		response.fin = frame.fin?
+		response.payload = frame.payload
+
+		return response
+	end
+	alias_method :handle_binary_frame, :handle_text_frame
+	alias_method :handle_continuation_frame, :handle_text_frame
+
+
+	# Handle close frames
+	def handle_close_frame( frame )
+
+		# There will still be a connection slot if this close originated with
+		# the client. In that case, reply with the ACK CLOSE frame
+		self.conn.reply( frame.response(:close) ) if
+			self.connections.delete( [frame.sender_id, frame.conn_id] )
+
+		self.conn.reply_close( frame )
+		return nil
+	end
+
+
+	# Handle a PING frame; the response is a PONG with the same payload.
+	def handle_ping_frame( frame )
+		return frame.response
+	end
+
+
+	# Handle a PONG frame; nothing really to do
+	def handle_pong_frame( frame )
+		return nil
+	end
+
+
+	# Start a thread that will periodically ping connected sockets and remove any
+	# connections that don't reply
+	def start_heartbeat
+		self.log.info "Starting heartbeat thread."
+		@heartbeat = Thread.new do
+			Thread.current.abort_on_exception = true
+			self.log.debug "  Heartbeat thread started: %p" % [ Thread.current ]
+
+			# Use a thread-local variable to signal the thread to shut down
+			Thread.current[ :shutdown ] = false
+			until Thread.current[ :shutdown ]
+
+				# If there are active connections, remove any that have
+				# timed out and ping the rest
+				unless self.connections.empty?
+					self.cull_idle_sockets
+					self.ping_all_sockets
+				end
+
+				self.log.debug "    heartbeat thread sleeping"
+				sleep( HEARTBEAT_RATE )
+				self.log.debug "    heartbeat thread waking up"
+			end
+
+			self.log.info "Hearbeat thread exiting."
+		end
+	end
+
+
+	# Tell the heartbeat thread to exit.
+	def stop_heartbeat
+		@heartbeat[ :shutdown ] = true
+		@heartbeat.run.join if @heartbeat.alive?
+	end
+
+
+	# Disconnect any sockets that haven't sent any frames for at least
+	# SOCKET_IDLE_TIMEOUT seconds.
+	def cull_idle_sockets
+		self.log.debug "Culling idle sockets."
+
+		earliest = Time.now - SOCKET_IDLE_TIMEOUT
+
+		self.connections.each do |(sender_id, conn_id), lastframe|
+			next unless earliest > lastframe
+
+			# Make a CLOSE frame
+			frame = Mongrel2::WebSocket::Frame.new( sender_id, conn_id, '', {}, '' )
+			frame.opcode = :close
+			frame.set_status( CLOSE_EXCEPTION )
+
+			# Use the connection directly so we can send a frame and close the
+			# connection
+			self.conn.reply( frame )
+			self.conn.send_close( sender_id, conn_id )
+		end
+	end
+
+
+	# Send a PING frame to all connected sockets.
+	def ping_all_sockets
+		self.log.debug "Pinging all connected sockets."
+
+		self.connections.each do |(sender_id, conn_id), hash|
+			frame = Mongrel2::WebSocket::Frame.new( sender_id, conn_id, '', {}, 'heartbeat' )
+			frame.opcode = :ping
+			frame.fin = true
+
+			self.log.debug "  %s/%d: PING" % [ sender_id, conn_id ]
+			self.conn.reply( frame )
+		end
+
+		self.log.debug "  done with pings."
+	end
+
+
+end # class RequestDumper
+
+Mongrel2.log.level = $DEBUG||$VERBOSE ? Logger::DEBUG : Logger::INFO
+Mongrel2.log.formatter = Mongrel2::Logging::ColorFormatter.new( Mongrel2.log ) if $stdin.tty?
+
+# Point to the config database, which will cause the handler to use
+# its ID to look up its own socket info.
+Mongrel2::Config.configure( :configdb => 'examples.sqlite' )
+WebSocketEchoServer.run( 'ws-echo' )
+

data/lib/mongrel2.rb

@@ -14,10 +14,10 @@ module Mongrel2
 	abort "\n\n>>> Mongrel2 requires Ruby 1.9.2 or later. <<<\n\n" if RUBY_VERSION < '1.9.2'
 
 	# Library version constant
-	VERSION = '0.15.1'
+	VERSION = '0.16.0'
 
 	# Version-control revision constant
-	REVISION = %q$Revision: e943c9068b73 $
+	REVISION = %q$Revision: 4fc45a463af8 $
 
 
 	require 'mongrel2/logging'
@@ -57,6 +57,7 @@ module Mongrel2
 	require 'mongrel2/httprequest'
 	require 'mongrel2/jsonrequest'
 	require 'mongrel2/xmlrequest'
+	require 'mongrel2/websocket'
 	require 'mongrel2/response'
 	require 'mongrel2/control'
 

data/lib/mongrel2/config/server.rb

@@ -5,10 +5,12 @@ require 'pathname'
 
 require 'mongrel2' unless defined?( Mongrel2 )
 require 'mongrel2/config' unless defined?( Mongrel2::Config )
+require 'mongrel2/constants'
 
 
 # Mongrel2 Server configuration class
 class Mongrel2::Config::Server < Mongrel2::Config( :server )
+	include Mongrel2::Constants
 
 	### As of Mongrel2/1.7.5:
 	# CREATE TABLE server (id INTEGER PRIMARY KEY,

data/lib/mongrel2/connection.rb

@@ -136,7 +136,7 @@ class Mongrel2::Connection
 	### 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( ' ' )
+		idlist = conn_ids.flatten.map( &:to_s ).join( ' ' )
 		self.send( sender_id, idlist, data )
 	end
 
@@ -188,7 +188,7 @@ class Mongrel2::Connection
 	### Returns a string containing a human-readable representation of the Connection,
 	### suitable for debugging.
 	def inspect
-		state = if @request_socket
+		state = if @request_sock
 			if self.closed?
 				"closed"
 			else

data/lib/mongrel2/handler.rb

@@ -8,6 +8,8 @@ require 'mongrel2/config'
 require 'mongrel2/request'
 require 'mongrel2/httprequest'
 require 'mongrel2/jsonrequest'
+require 'mongrel2/xmlrequest'
+require 'mongrel2/websocket'
 
 # Mongrel2 Handler application class. Instances of this class are the applications
 # which connection to one or more Mongrel2 routes and respond to requests.
@@ -18,27 +20,27 @@ require 'mongrel2/jsonrequest'
 # document with a timestamp.
 #
 #     #!/usr/bin/env ruby
-#     
+#
 #     require 'mongrel2/handler'
-#     
+#
 #     class HelloWorldHandler < Mongrel2::Handler
-#     
-#       ### The main method to override -- accepts requests and 
+#
+#       ### The main method to override -- accepts requests and
 #       ### returns responses.
 #       def handle( request )
 #           response = request.response
-#     
+#
 #           response.status = 200
 #           response.headers.content_type = 'text/plain'
 #           response.puts "Hello, world, it's #{Time.now}!"
-#           
+#
 #           return response
 #       end
-#     
+#
 #     end # class HelloWorldHandler
-#     
+#
 #     HelloWorldHandler.run( 'helloworld-handler' )
-# 
+#
 # This assumes the Mongrel2 SQLite config database is in the current
 # directory, and is named 'config.sqlite' (the Mongrel2 default), but
 # if it's somewhere else, you can point the Mongrel2::Config class
@@ -46,7 +48,7 @@ require 'mongrel2/jsonrequest'
 #
 #     require 'mongrel2/config'
 #     Mongrel2::Config.configure( :configdb => 'mongrel2.db' )
-# 
+#
 # Mongrel2 also includes support for Configurability, so you can
 # configure it along with your database connection, etc. Just add a
 # 'mongrel2' section to the config with a 'configdb' key that points
@@ -55,14 +57,14 @@ require 'mongrel2/jsonrequest'
 #     # config.yaml
 #     db:
 #       uri: postgres://www@localhost/db01
-#     
+#
 #     mongrel2:
 #       configdb: mongrel2.db
-#     
+#
 #     whatever_else:
 #       ...
-# 
-# Now just loading and installing the config configures Mongrel2 as 
+#
+# Now just loading and installing the config configures Mongrel2 as
 # well:
 #
 #     require 'configurability/config'
@@ -77,7 +79,7 @@ require 'mongrel2/jsonrequest'
 #     app = HelloWorldHandler.new( 'helloworld-handler',
 #         'tcp://otherhost:9999', 'tcp://otherhost:9998' )
 #     app.run
-#     
+#
 class Mongrel2::Handler
 	include Mongrel2::Loggable,
 	        Mongrel2::Constants
@@ -159,22 +161,20 @@ class Mongrel2::Handler
 	def start_accepting_requests
 		until @conn.closed?
 			req = @conn.receive
-			self.log.info( req.inspect )
-
 			res = self.dispatch_request( req )
 
 			if res
 				self.log.info( res.inspect )
 				@conn.reply( res ) unless @conn.closed?
-			else
-				self.log.info "  no response; ignoring."
 			end
 		end
 	rescue ZMQ::Error => err
-		self.log.error "%p while accepting requests: %s" % [ err.class, err.message ]
-		self.log.debug { err.backtrace.join("\n  ") }
+		unless @conn.closed?
+			self.log.error "%p while accepting requests: %s" % [ err.class, err.message ]
+			self.log.debug { err.backtrace.join("\n  ") }
 
-		retry unless @conn.closed?
+			retry
+		end
 	end
 
 
@@ -196,8 +196,12 @@ class Mongrel2::Handler
 			when Mongrel2::XMLRequest
 				self.log.debug "XML message request."
 				return self.handle_xml( request )
+			when Mongrel2::WebSocket::Frame
+				self.log.debug "WEBSOCKET message request."
+				return self.handle_websocket( request )
 			else
-				self.log.error "Unhandled request type %p" % [ request.class ]
+				self.log.error "Unhandled request type %s (%p)" %
+					[ request.headers['METHOD'], request.class ]
 				return nil
 			end
 		end
@@ -235,22 +239,32 @@ class Mongrel2::Handler
 	end
 
 
-	### Handle a JSON message +request+. If not overridden, JSON message ('@route') 
+	### Handle a JSON message +request+. If not overridden, JSON message ('@route')
 	### requests are ignored.
 	def handle_json( request )
-		self.log.warn "Unhandled JSON message request (%p)" % [ request.headers[:path] ]
+		self.log.warn "Unhandled JSON message request (%p)" % [ request.headers.path ]
 		return nil
 	end
 
 
-	### Handle an XML message +request+. If not overridden, XML message ('<route') 
+	### Handle an XML message +request+. If not overridden, XML message ('<route')
 	### requests are ignored.
 	def handle_xml( request )
-		self.log.warn "Unhandled XML message request (%p)" % [ request.headers[:path] ]
+		self.log.warn "Unhandled XML message request (%p)" % [ request.headers.pack ]
 		return nil
 	end
 
 
+	### Handle a WebSocket frame in +request+. If not overridden, WebSocket connections are
+	### closed with a policy error status.
+	def handle_websocket( request )
+		self.log.warn "Unhandled WEBSOCKET message request (%p)" % [ request.headers.path ]
+		res = request.response
+		res.make_close_frame( WebSocket::CLOSE_POLICY_VIOLATION )
+		return res
+	end
+
+
 	### Handle a disconnect notice from Mongrel2 via the given +request+. Its return value
 	### is ignored.
 	def handle_disconnect( request )
@@ -267,7 +281,7 @@ class Mongrel2::Handler
 	#
 
 	### Set up signal handlers for SIGINT, SIGTERM, SIGINT, and SIGUSR1 that will call the
-	### #on_hangup_signal, #on_termination_signal, #on_interrupt_signal, and 
+	### #on_hangup_signal, #on_termination_signal, #on_interrupt_signal, and
 	### #on_user1_signal methods, respectively.
 	def set_signal_handlers
 		Signal.trap( :HUP,  &self.method(:on_hangup_signal) )