strelka 0.6.0 → 0.7.0

data/lib/strelka/websocketserver/routing.rb

@@ -0,0 +1,116 @@
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+# encoding: utf-8
+
+require 'strelka' unless defined?( Strelka )
+require 'strelka/websocketserver' unless defined?( Strelka::WebSocketServer )
+require 'strelka/plugin' unless defined?( Strelka::Plugin )
+
+# Frame routing logic for Strelka WebSocketServers.
+#
+# For a protocol that defines its own opcodes:
+#
+#    class ChatServer
+#        plugin :routing
+#
+#        opcodes :nick => 7,
+#                :emote => 8
+#
+#        on_text do |frame|
+#            # ...
+#        end
+#
+#        on_nick do |frame|
+#            self.set_nick( frame.socket_id, frame.payload.read )
+#        end
+#
+#
+module Strelka::WebSocketServer::Routing
+	extend Loggability,
+	       Strelka::Plugin
+	include Strelka::Constants,
+	        Mongrel2::WebSocket::Constants
+
+
+	# Loggability API -- set up logging under the 'strelka' log host
+	log_to :strelka
+
+	# Plugins API -- set up load order
+	# run_inside :templating, :filters, :parameters
+
+
+	# Class methods to add to classes with routing.
+	module ClassMethods # :nodoc:
+
+		# The list of routes to pass to the Router when the application is created
+		attr_reader :op_callbacks
+		@op_callbacks = {}
+
+		# The Hash of opcodes that can be hooked
+		attr_reader :opcode_map
+		@opcode_map = {}
+
+
+		### Declare one or more opcodes in the form:
+		###
+		### {
+		###     <bit> => <label>,
+		### }
+		def opcodes( hash )
+			@opcode_map ||= {}
+			@opcode_map.merge!( hash )
+			@opcode_map.each do |bit, label|
+				self.log.debug "Set opcode %p to %#0x" % [ label, bit ]
+				declarative = "on_#{label}"
+				block = self.make_declarative( label )
+				self.log.debug "  declaring method %p on %p" % [ declarative, self ]
+				self.class.send( :define_method, declarative, &block )
+			end
+		end
+
+
+		### Make a declarative method for setting the callback for frames with the specified
+		### +opcode+ (Symbol).
+		def make_declarative( opcode )
+			self.log.debug "Making a declarative for %p" % [ opcode ]
+			return lambda do |&block|
+				self.log.debug "Setting handler for %p frames to %p" % [ opcode, block ]
+				methodname = "on_#{opcode}_frame"
+				define_method( methodname, &block )
+				self.op_callbacks[ opcode ] = self.instance_method( methodname )
+			end
+		end
+
+
+		### Inheritance hook -- inheriting classes inherit their parents' routes table.
+		def inherited( subclass )
+			super
+			subclass.instance_variable_set( :@opcode_map, self.opcode_map.dup )
+			subclass.instance_variable_set( :@op_callbacks, self.op_callbacks.dup )
+		end
+
+
+		### Extension callback -- install default opcode declaratives when the plugin
+		### is registered.
+		def self::extended( mod )
+			super
+			mod.opcodes( Mongrel2::WebSocket::Constants::OPCODE_NAME )
+		end
+
+	end # module ClassMethods
+
+
+
+	### Dispatch the incoming frame to its handler based on its opcode
+	def handle_frame( frame )
+		self.log.debug "[:routing] Opcode map is: %p" % [ self.class.opcode_map ]
+		opname = self.class.opcode_map[ frame.numeric_opcode ]
+		self.log.debug "[:routing] Routing frame: %p" % [ opname ]
+
+		handler = self.class.op_callbacks[ opname ] or return super
+
+		return handler.bind( self ).call( frame )
+	end
+
+end # module Strelka::WebSocketServer::Routing
+

data/lib/strelka/websocketserver.rb

@@ -0,0 +1,147 @@
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+# encoding: utf-8
+
+require 'mongrel2/handler'
+require 'mongrel2/websocket'
+
+require 'strelka' unless defined?( Strelka )
+require 'strelka/mixins'
+require 'strelka/plugins'
+require 'strelka/discovery'
+
+
+# WebSocket (RFC 6455) Server base class.
+#
+#   class ChatServer < Strelka::WebSocketServer
+#
+#       # Set up a Hash for participating users
+#       def initialize( * )
+#           super
+#           @users = {}
+#       end
+#
+#       # Disconnect clients that don't answer a ping
+#       plugin :heartbeat
+#       heartbeat_rate 5.0
+#       idle_timeout 15.0
+#
+#       # When a websocket is set up, add a new user to the table, but without a nick.
+#       on_handshake do |frame|
+#           @users[ frame.socket_id ] = nil
+#           return frame.response # accept the connection
+#       end
+#
+#       # Handle incoming commands, which should be text frames
+#       on_text do |frame|
+#           senderid = frame.socket_id
+#           data = frame.payload.read
+#
+#           # If the input starts with '/', it's a command (e.g., /quit, /nick, etc.)
+#           output = nil
+#           if data.start_with?( '/' )
+#               output = self.command( senderid, data[1..-1] )
+#           else
+#               output = self.say( senderid, data )
+#           end
+#
+#           response = frame.response
+#           response.puts( output )
+#           return response
+#       end
+#
+#   end # class ChatServer
+#
+class Strelka::WebSocketServer < Mongrel2::Handler
+	extend Strelka::MethodUtilities,
+	       Strelka::PluginLoader,
+		   Strelka::Discovery
+
+
+	# Loggability API -- log to the Strelka logger
+	log_to :strelka
+
+
+	### Handle a WebSocket frame in +request+. If not overridden, WebSocket connections are
+	### closed with a policy error status.
+	def handle_websocket( frame )
+		response = nil
+
+		# Dispatch the frame
+		response = catch( :close_websocket ) do
+			self.log.debug "Incoming WEBSOCKET frame (%p):%s" % [ frame, frame.headers.path ]
+			self.handle_frame( frame )
+		end
+
+		return response
+	end
+
+
+	### Handle a WebSocket handshake HTTP +request+.
+	def handle_websocket_handshake( handshake )
+		self.log.warn "Incoming WEBSOCKET_HANDSHAKE request (%p)" % [ request.headers.path ]
+		return handshake.response( handshake.protocols.first )
+	end
+
+
+	### 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."
+		return nil
+	end
+
+
+	#########
+	protected
+	#########
+
+	### Default frame handler.
+	def handle_frame( frame )
+		if frame.control?
+			self.handle_control_frame( frame )
+		else
+			self.handle_content_frame( frame )
+		end
+	end
+
+
+	### Throw a :close_websocket frame that will close the current connection.
+	def close_with( frame, reason )
+		self.log.debug "Closing the connection: %p" % [ reason ]
+
+		# Make a CLOSE frame
+		frame = frame.response( :close )
+		frame.set_status( reason )
+
+		throw :close_websocket, frame
+	end
+
+
+	### Handle an incoming control frame.
+	def handle_control_frame( frame )
+		self.log.debug "Handling control frame: %p" % [ frame ]
+
+		case frame.opcode
+		when :ping
+			return frame.response
+		when :pong
+			return nil
+		when :close
+			self.conn.reply_close( frame )
+			return nil
+		else
+			self.close_with( frame, CLOSE_BAD_DATA_TYPE )
+		end
+	end
+
+
+	### Handle an incoming content frame.
+	def handle_content_frame( frame )
+		self.log.warn "Unhandled frame type %p" % [ frame.opcode ]
+		self.close_with( frame, CLOSE_BAD_DATA_TYPE )
+	end
+
+
+end # class Strelka::WebSocketServer
+

data/lib/strelka.rb

@@ -24,10 +24,10 @@ module Strelka
 	log_as :strelka
 
 	# Library version constant
-	VERSION = '0.6.0'
+	VERSION = '0.7.0'
 
 	# Version-control revision constant
-	REVISION = %q$Revision: a043d61c759c $
+	REVISION = %q$Revision: 2caa91898658 $
 
 	require 'strelka/constants'
 	require 'strelka/exceptions'
@@ -36,6 +36,7 @@ module Strelka
 	require 'strelka/app'
 	require 'strelka/httprequest'
 	require 'strelka/httpresponse'
+	require 'strelka/discovery'
 
 
 	### Get the library version. If +include_buildnum+ is true, the version string will
@@ -67,10 +68,10 @@ module Strelka
 	### named +gemname+. Returns the first matching class, or raises an exception if no
 	### app class was found.
 	def self::App( appname, gemname=nil )
-		path, _ = Strelka::App.find( appname, gemname )
+		path, _ = Strelka::Discovery.find( appname, gemname )
 		raise LoadError, "Can't find the %s app." % [ appname ] unless path
 
-		apps = Strelka::App.load( path ) or
+		apps = Strelka::Discovery.load( path ) or
 			raise ScriptError "Loading %s didn't define a Strelka::App class." % [ path ]
 
 		return apps.first

data/spec/{lib/constants.rb → constants.rb}

@@ -8,7 +8,8 @@ require 'strelka' unless defined?( Strelka )
 ### A collection of constants used in testing
 module Strelka::TestConstants # :nodoc:all
 
-	include Strelka::Constants
+	include Strelka::Constants,
+	        Mongrel2::WebSocket::Constants
 
 	unless defined?( TEST_HOST )
 
@@ -24,7 +25,7 @@ module Strelka::TestConstants # :nodoc:all
 
 		# Freeze all testing constants
 		constants.each do |cname|
-			const_get(cname).freeze
+			const_get(cname).freeze if cname.to_s.start_with?( 'TEST_' )
 		end
 	end
 

data/spec/{lib/helpers.rb → helpers.rb}

@@ -8,11 +8,8 @@ BEGIN {
 	srcdir = basedir.parent
 	mongrel2dir = srcdir + 'Mongrel2/lib'
 
-	libdir = basedir + "lib"
-
-	$LOAD_PATH.unshift( mongrel2dir.to_s ) unless $LOAD_PATH.include?( mongrel2dir.to_s )
-	$LOAD_PATH.unshift( basedir.to_s ) unless $LOAD_PATH.include?( basedir.to_s )
-	$LOAD_PATH.unshift( libdir.to_s ) unless $LOAD_PATH.include?( libdir.to_s )
+	$LOAD_PATH.unshift( mongrel2dir.to_s ) unless
+		!mongrel2dir.directory? || $LOAD_PATH.include?( mongrel2dir.to_s )
 }
 
 # SimpleCov test coverage reporting; enable this using the :coverage rake task
@@ -40,7 +37,7 @@ require 'mongrel2/testing'
 require 'strelka'
 require 'strelka/testing'
 
-require 'spec/lib/constants'
+require_relative 'constants'
 
 Loggability.format_with( :color ) if $stdout.tty?
 
@@ -103,19 +100,23 @@ module Strelka::SpecHelpers
 end
 
 
-abort "You need a version of RSpec >= 2.6.0" unless defined?( RSpec )
-
 ### Mock with RSpec
-RSpec.configure do |c|
+RSpec.configure do |config|
 	include Strelka::TestConstants
 
-	c.mock_with( :rspec )
+	config.treat_symbols_as_metadata_keys_with_true_values = true
+	config.run_all_when_everything_filtered = true
+	config.filter_run :focus
+	config.order = 'random'
+	config.mock_with( :rspec ) do |mock|
+		mock.syntax = :expect
+	end
 
-	c.extend( Strelka::TestConstants )
+	config.extend( Strelka::TestConstants )
 
-	c.include( Loggability::SpecHelpers )
-	c.include( Mongrel2::SpecHelpers )
-	c.include( Strelka::SpecHelpers )
+	config.include( Loggability::SpecHelpers )
+	config.include( Mongrel2::SpecHelpers )
+	config.include( Strelka::SpecHelpers )
 end
 
 # vim: set nosta noet ts=4 sw=4: