mongrel2 0.52.2 → 0.53.0

data/lib/mongrel2/response.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require 'stringio'
 require 'tnetstring'
@@ -32,7 +33,7 @@ class Mongrel2::Response
 
 	### Create a new Response object for the specified +sender_id+, +conn_id+, and +body+.
 	def initialize( sender_id, conn_id, body='' )
-		body = StringIO.new( body, 'a+' ) unless body.respond_to?( :read )
+		body = StringIO.new( body.dup, 'a+' ) unless body.respond_to?( :read )
 
 		@sender_id             = sender_id
 		@conn_id               = conn_id
@@ -76,7 +77,7 @@ class Mongrel2::Response
 	### Set the response's entity body to +newbody+. If +newbody+ is a String-ish object
 	### (i.e., it responds to #to_str), it will be wrapped in a StringIO in 'a+' mode).
 	def body=( newbody )
-		newbody = StringIO.new( newbody, 'a+' ) if newbody.respond_to?( :to_str )
+		newbody = StringIO.new( newbody.dup, 'a+' ) if newbody.respond_to?( :to_str )
 		@body = newbody
 	end
 
@@ -131,15 +132,22 @@ class Mongrel2::Response
 	end
 
 
+	### Returns a string containing the request's sender and connection IDs
+	### separated by a colon.
+	def socket_id
+		return "%s:%d" % [ self.sender_id, self.conn_id ]
+	end
+
+
+
 	### Returns a string containing a human-readable representation of the Response,
 	### suitable for debugging.
 	def inspect
-		return "#<%p:0x%016x %s (%s/%d)>" % [
+		return "#<%p:0x%016x %s (%s)>" % [
 			self.class,
 			self.object_id * 2,
 			self.inspect_details,
-			self.sender_id,
-			self.conn_id
+			self.socket_id
 		]
 	end
 

data/lib/mongrel2/table.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require 'forwardable'
 require 'loggability'
@@ -28,7 +29,10 @@ class Mongrel2::Table
 	log_to :mongrel2
 
 	# Methods that understand case-insensitive keys
-	KEYED_METHODS = [ :"[]", :"[]=", :delete, :fetch, :has_key?, :include?, :member?, :store ]
+	KEYED_METHODS = %i[ [] []= delete fetch has_key? include? member? store ]
+
+	# Method to not delegate to the inner hash
+	NON_DELEGATED_METHODS = %i[ inspect freeze ]
 
 
 	### Auto-generate methods which call the given +delegate+ after normalizing
@@ -74,7 +78,7 @@ class Mongrel2::Table
 	# Delegate some methods to the underlying Hash
 	begin
 		unoverridden_methods = Hash.instance_methods(false).collect {|mname| mname.to_sym }
-		def_delegators :@hash, *( unoverridden_methods - KEYED_METHODS )
+		def_delegators :@hash, *( unoverridden_methods - KEYED_METHODS - NON_DELEGATED_METHODS )
 	end
 
 
@@ -152,6 +156,23 @@ class Mongrel2::Table
 	end
 
 
+	### Return a human-readable representation of the object suitable for debugging.
+	def inspect
+		return "#<%p:%#x %p>" % [
+			self.class,
+			self.object_id * 2,
+			@hash
+		]
+	end
+
+
+	### Overridden to freeze the inner hash as well.
+	def freeze
+		super
+		@hash.freeze
+	end
+
+
 	#########
 	protected
 	#########

data/lib/mongrel2/testing.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 
 require 'uri'
 require 'pathname'
@@ -108,7 +109,7 @@ module Mongrel2
 		DEFAULT_TESTING_ROUTE = DEFAULT_TESTING_URL.path
 
 		# The default set of headers used for HTTP requests
-		DEFAULT_TESTING_HEADERS  = {
+		DEFAULT_TESTING_HEADERS  = Mongrel2::Table.new(
 			'x-forwarded-for' => '127.0.0.1',
 			'accept-language' => 'en-US,en;q=0.8',
 			'accept-encoding' => 'gzip,deflate,sdch',
@@ -120,7 +121,7 @@ module Mongrel2
 			                     'Safari/535.1',
 			'url-scheme'      => 'http',
 			'VERSION'         => 'HTTP/1.1',
-		}
+		)
 
 		# The defaults used by the HTTP request factory
 		DEFAULT_FACTORY_CONFIG = {
@@ -161,12 +162,12 @@ module Mongrel2
 			config = self.class.default_factory_config.merge( config )
 
 			@sender_id = config[:sender_id]
+			@conn_id   = config[:conn_id]
 			@host      = config[:host]
 			@port      = config[:port]
 			@route     = config[:route]
-			@headers   = Mongrel2::Table.new( config[:headers] )
 
-			@conn_id = 0
+			@headers   = Mongrel2::Table.new( config[:headers] )
 		end
 
 		######
@@ -286,7 +287,7 @@ module Mongrel2
 
 	# A factory for generating WebSocket request objects for testing.
 	#
-	class WebSocketFrameFactory < Mongrel2::RequestFactory
+	class WebSocketRequestFactory < Mongrel2::RequestFactory
 		include Mongrel2::Constants
 
 		# The default host
@@ -294,11 +295,8 @@ module Mongrel2
 		DEFAULT_TESTING_PORT  = '8113'
 		DEFAULT_TESTING_ROUTE = '/ws'
 
-		# The default WebSocket opcode
-		DEFAULT_OPCODE = :text
-
 		# Default headers
-		DEFAULT_TESTING_HEADERS = {
+		DEFAULT_TESTING_HEADERS = Mongrel2::Table.new(
 			'METHOD'                => 'WEBSOCKET',
 			'PATTERN'               => '/ws',
 			'URI'                   => '/ws',
@@ -312,7 +310,7 @@ module Mongrel2
 			'origin'                => "http://#{DEFAULT_TESTING_HOST}",
 			'FLAGS'                 => '0x89', # FIN + PING
 			'x-forwarded-for'       => '127.0.0.1'
-		}
+		)
 
 		# The defaults used by the websocket request factory
 		DEFAULT_FACTORY_CONFIG = {
@@ -332,20 +330,6 @@ module Mongrel2
 		end
 
 
-		### Create a new factory using the specified +config+.
-		def initialize( config={} )
-			config[:headers] = DEFAULT_TESTING_HEADERS.merge( config[:headers] ) if config[:headers]
-			config = DEFAULT_FACTORY_CONFIG.merge( config )
-
-			@sender_id = config[:sender_id]
-			@host      = config[:host]
-			@port      = config[:port]
-			@route     = config[:route]
-			@headers   = Mongrel2::Table.new( config[:headers] )
-
-			@conn_id   = 0
-		end
-
 		######
 		public
 		######
@@ -447,6 +431,8 @@ module Mongrel2
 			headers.origin    = "http://#{headers.host}"
 			headers.flags     = "0x%02x" % [ flags ]
 
+			self.log.debug "Headers are: %p" % [ headers ]
+
 			return headers
 		end
 
@@ -489,5 +475,6 @@ module Mongrel2
 
 	end # class WebSocketFrameFactory
 
+
 end # module Mongrel2
 

data/lib/mongrel2/websocket.rb

@@ -1,5 +1,7 @@
 # -*- ruby -*-
-#encoding: utf-8
+# frozen_string_literal: true
+
+require 'forwardable'
 
 require 'mongrel2/request' unless defined?( Mongrel2::Request )
 require 'mongrel2/constants'
@@ -196,22 +198,46 @@ module Mongrel2::WebSocket
 	end # module WebSocket
 	include Constants
 
+
 	# Base exception class for WebSocket-related errors
 	class Error < ::RuntimeError; end
 
+
 	# Exception raised when a frame is malformed, doesn't parse, or is otherwise invalid.
 	class FrameError < Mongrel2::WebSocket::Error; end
 
+
 	# Exception raised when a handshake is created with an unrequested sub-protocol.
 	class HandshakeError < Mongrel2::WebSocket::Error; end
 
 
-	# A mixin containing methods common to WebSocket frame classes.
-	module Methods
+	# A mixin containing methods for request/response classes that wrap a Frame.
+	module FrameMethods
+		extend Forwardable
+
+
+		##
+		# The Websocket data as a Mongrel2::WebSocket::Frame
+		attr_reader :frame
+
+		##
+		# Delegate some methods to the contained frame
+		def_instance_delegators :frame,
+			:opcode, :opcode=, :numeric_opcode, :payload, :each_chunk, :flags, :set_flags,
+			:fin?, :fin=, :rsv1?, :rsv1=, :rsv2?, :rsv2=, :rsv3?, :rsv3=, :control?,
+			:has_rsv_flags?
+
+		### Append operator -- append +object+ to the contained frame's payload and
+		### return the receiver.
+		def <<( object )
+			self.frame << object
+			return self
+		end
+
 
-		### Get a string identifying the websocket the frame belongs to.
-		def socket_id
-			return [ self.sender_id, self.conn_id ].join( ':' )
+		### Return the details to include in the contents of the #inspected object.
+		def inspect_details
+			return "frame: %p" % [ self.frame ]
 		end
 
 	end # module Methods
@@ -219,8 +245,7 @@ module Mongrel2::WebSocket
 
 	# The client (request) handshake for a WebSocket opening handshake.
 	class ClientHandshake < Mongrel2::HTTPRequest
-		include Mongrel2::WebSocket::Constants,
-		        Mongrel2::WebSocket::Methods
+		include Mongrel2::WebSocket::Constants
 
 		# Set this class as the one that will handle WEBSOCKET_HANDSHAKE requests
 		register_request_type( self, :WEBSOCKET_HANDSHAKE )
@@ -265,8 +290,7 @@ module Mongrel2::WebSocket
 
 	# The server (response) handshake for a WebSocket opening handshake.
 	class ServerHandshake < Mongrel2::HTTPResponse
-		include Mongrel2::WebSocket::Constants,
-		        Mongrel2::WebSocket::Methods
+		include Mongrel2::WebSocket::Constants
 
 		### Create a server handshake frame from the given client +handshake+.
 		def self::from_request( handshake )
@@ -303,39 +327,151 @@ module Mongrel2::WebSocket
 	end # class ServerHandshake
 
 
-	# WebSocket frame class; this is used for both requests and responses in
-	# WebSocket services.
-	class Frame < Mongrel2::Request
-		include Mongrel2::WebSocket::Constants,
-		        Mongrel2::WebSocket::Methods
-
-		# The default frame header flags: FIN + CLOSE
-		DEFAULT_FLAGS = FIN_FLAG | OPCODE[:close]
+	# WebSocket request -- this is the container for Frames from a client.
+	class Request < Mongrel2::Request
+		include Mongrel2::WebSocket::FrameMethods
 
 
 		# Set this class as the one that will handle WEBSOCKET requests
 		register_request_type( self, :WEBSOCKET )
 
 
-		### Override the type of response returned by this request type. Since
-		### WebSocket connections are symmetrical, responses are just new
-		### Mongrel2::WebSocket::Frames with the same Mongrel2 sender and
-		### connection IDs.
+		### Override the type of response returned by this request type.
 		def self::response_class
-			return self
+			return Mongrel2::WebSocket::Response
+		end
+
+
+		### Init a few instance variables unique to websocket requests/responses.
+		def initialize( * )
+			super
+
+			payload = self.body.read
+			self.body.rewind
+
+			@frame = Mongrel2::WebSocket::Frame.new( payload, self.headers.flags )
+		end
+
+
+		### Create a frame in response to the receiving Frame (i.e., with the same
+		### Mongrel2 connection ID and sender).
+		def response( payload=nil, *flags )
+			res = super()
+
+			if payload.is_a?( Symbol ) || payload.is_a?( Integer )
+				flags.unshift( payload )
+				payload = nil
+			end
+
+			if payload
+				res.payload.truncate( 0 )
+				res.payload << payload
+			end
+			res.set_flags( *flags ) unless flags.empty?
+
+			return res
 		end
 
+	end # class Request
+
+
+	# WebSocket response -- this is the container for Frames sent to a client.
+	class Response < Mongrel2::Response
+		extend Forwardable
+		include Mongrel2::WebSocket::FrameMethods
+
 
-		### Create a response frame from the given request +frame+.
-		def self::from_request( frame )
-			self.log.debug "Creating a %p response to request %p" % [ self, frame ]
-			response = new( frame.sender_id, frame.conn_id, frame.path )
-			response.request_frame = frame
+		### Return a response to the specified +request+, inferring appropriate flags
+		### if appropriate.
+		def self::from_request( request )
+			response = super
+
+			if request.opcode == :ping
+				response.opcode = :pong
+				IO.copy_stream( request.payload, response.payload, 4096 )
+			else
+				# Numeric in case it's a custom (reserved) value
+				response.opcode = request.numeric_opcode
+			end
 
 			return response
 		end
 
 
+		### Init a few instance variables unique to websocket requests/responses.
+		def initialize( sender_id, conn_id, body='' )
+			@frame = Mongrel2::WebSocket::Frame.new( body )
+			super( sender_id, conn_id, @frame.payload )
+		end
+
+
+		##
+		# Delegate some methods to the contained frame
+		def_instance_delegators :frame,
+			:puts, :to_s, :each_chunk, :<<, :make_close_frame, :set_status
+
+	end # class Response
+
+
+	# WebSocket frame class; this is used for both requests and responses in
+	# WebSocket services.
+	class Frame
+		extend Loggability
+		include Mongrel2::WebSocket::Constants
+
+
+		# The default frame header flags: FIN + CLOSE
+		DEFAULT_FLAGS = FIN_FLAG | OPCODE[:close]
+
+		# The default size of the payload of fragment frames
+		DEFAULT_FRAGMENT_SIZE = 4096
+
+
+		# Loggability API -- log to the mongrel2 logger
+		log_to :mongrel2
+
+
+		### Create one or more fragmented frames for the data read from +io+ and yield
+		### each to the specified block. If no block is given, return a iterator that
+		### will yield the frames instead. The +io+ can be any object that responds to
+		### #readpartial, and the blocking semantics follow those of that method when
+		### iterating.
+		def self::each_fragment( io, opcode, size: DEFAULT_FRAGMENT_SIZE, &block )
+			raise ArgumentError, "Invalid opcode %p" % [opcode] unless OPCODE.key?( opcode )
+
+			iter = Enumerator.new do |yielder|
+				count = 0
+
+				until io.eof?
+					self.log.debug "Reading frame %d" % [ count ]
+					data = io.readpartial( size )
+					frame = if count.zero?
+							new( data, opcode )
+						else
+							new( data, :continuation )
+						end
+					frame.fin = io.eof?
+
+					yielder.yield( frame )
+
+					count += 1
+				end
+			end
+
+			return iter.each( &block ) if block
+			return iter
+		end
+
+
+		# Make convenience constructors for each opcode
+		OPCODE.keys.each do |opcode_name|
+			define_singleton_method( opcode_name ) do |payload='', *flags|
+				flags << opcode_name
+				return new( payload, *flags )
+			end
+		end
+
+
 		### Define accessors for the flag of the specified +name+ and +bit+.
 		def self::attr_flag( name, bitmask )
 			define_method( "#{name}?" ) do
@@ -351,22 +487,18 @@ module Mongrel2::WebSocket
 		end
 
 
-
 		#################################################################
 		###	I N S T A N C E   M E T H O D S
 		#################################################################
 
-		### Override the constructor to add Integer flags extracted from the FLAGS header.
-		def initialize( sender_id, conn_id, path, headers={}, payload='', raw=nil )
-			payload.force_encoding( Encoding::UTF_8 ) if
-				payload.encoding == Encoding::ASCII_8BIT
+		### Create a new websocket frame that will be the body of a request or response.
+		def initialize( payload='', *flags )
+			@payload   = StringIO.new( payload.dup )
+			@flags     = DEFAULT_FLAGS
+			@errors    = []
+			@chunksize = DEFAULT_CHUNKSIZE
 
-			super
-
-			@flags         = Integer( self.headers.flags || DEFAULT_FLAGS )
-			@request_frame = nil
-			@errors        = []
-			@chunksize     = DEFAULT_CHUNKSIZE
+			self.set_flags( *flags ) unless flags.empty?
 		end
 
 
@@ -375,17 +507,14 @@ module Mongrel2::WebSocket
 		######
 
 		# The payload data
-		attr_accessor :body
-		alias_method :payload, :body
-		alias_method :payload=, :body=
+		attr_accessor :payload
+		alias_method :body, :payload
+		alias_method :body=, :payload=
 
 
 		# The frame's header flags as an Integer
 		attr_accessor :flags
 
-		# The frame that this one is a response to
-		attr_accessor :request_frame
-
 		# The Array of validation errors
 		attr_reader :errors
 
@@ -407,6 +536,38 @@ module Mongrel2::WebSocket
 		attr_flag :rsv3, RSV3_FLAG
 
 
+		### Apply flag bits and opcodes: (:fin, :rsv1, :rsv2, :rsv3, :continuation,
+		### :text, :binary, :close, :ping, :pong) to the frame.
+		###
+		###   # Transform the frame into a CLOSE frame and set its FIN flag
+		###   frame.set_flags( :fin, :close )
+		###
+		def set_flags( *flag_symbols )
+			flag_symbols.flatten!
+			flag_symbols.compact!
+
+			self.log.debug "Setting flags for symbols: %p" % [ flag_symbols ]
+
+			flag_symbols.each do |flag|
+				case flag
+				when :fin, :rsv1, :rsv2, :rsv3
+					self.__send__( "#{flag}=", true )
+				when :continuation, :text, :binary, :close, :ping, :pong
+					self.opcode = flag
+				when Integer
+					self.log.debug "  setting Integer flags directly: %#08b" % [ flag ]
+					self.flags |= flag
+				when /\A0x\h{2}\z/
+					val = Integer( flag )
+					self.log.debug "  setting (stringified) Integer flags directly: %#08b" % [ val ]
+					self.flags = val
+				else
+					raise ArgumentError, "Don't know what the %p flag is." % [ flag ]
+				end
+			end
+		end
+
+
 		### Returns true if one or more of the RSV1-3 bits is set.
 		def has_rsv_flags?
 			return ( self.flags & RSV_FLAG_MASK ).nonzero?
@@ -486,7 +647,8 @@ module Mongrel2::WebSocket
 		def validate
 			unless self.valid?
 				self.log.error "Validation failed."
-				raise Mongrel2::WebSocket::FrameError, "invalid frame: %s" % [ self.errors.join(', ') ]
+				raise Mongrel2::WebSocket::FrameError, "invalid frame: %s" %
+					[ self.errors.join(', ') ]
 			end
 		end
 
@@ -507,7 +669,7 @@ module Mongrel2::WebSocket
 
 		### Mongrel2::Connection API -- Yield the response in chunks if called with a block, else
 		### return an Enumerator that will do the same.
-		def each_chunk
+		def each_chunk( &block )
 			self.validate
 
 			iter = Enumerator.new do |yielder|
@@ -516,122 +678,42 @@ module Mongrel2::WebSocket
 				end
 			end
 
-			if block_given?
-				block = Proc.new
-				iter.each( &block )
-			else
-				return iter
-			end
+			return iter unless block
+			return iter.each( &block )
 		end
 
 
 		### Stringify into a response suitable for sending to the client.
 		def to_s
-			self.remember_payload_settings do
-				self.payload.rewind
-				self.payload.set_encoding( 'binary' )
-
-				header = self.make_header
-				data = self.payload.read
-
-				return header + data
-			end
+			return self.each_byte.to_a.pack( 'C*' )
 		end
 
 
 		### Return an Enumerator for the bytes of the raw frame as it appears
 		### on the wire.
-		def bytes
-			self.remember_payload_settings do
-				self.payload.rewind
-				self.log.debug "Making a bytes iterator for a %s payload" %
-					[ self.payload.external_encoding.name ]
-
-				return Enumerator.new do |yielder|
-					self.payload.set_encoding( 'binary' )
-					self.payload.rewind
-
-					header_i = self.make_header.each_byte
-					body_i   = self.payload.each_byte
-
-					header_i.each_with_index {|byte, i| yielder.yield(byte) }
-					body_i.each_with_index   {|byte, i| yielder.yield(byte) }
-				end
-			end
-		end
+		def each_byte( &block )
+			self.log.debug "Making a bytes iterator for a %s payload" %
+				[ self.payload.external_encoding.name ]
 
+			payload_copy = self.payload.clone
+			payload_copy.set_encoding( 'binary' )
+			payload_copy.rewind
 
-		### Remember the payload IO's external encoding, position, etc. and restore them
-		### when the block returns.
-		def remember_payload_settings
-			original_enc = self.payload.external_encoding
-			original_pos = self.payload.pos
+			iter = self.make_header.each_byte + payload_copy.each_byte
 
-			yield
-		ensure
-			self.payload.set_encoding( original_enc ) if original_enc
-			self.payload.pos = original_pos if original_pos
+			return iter unless block
+			return iter.each( &block )
 		end
+		alias_method :bytes, :each_byte
 
 
-		### Create a frame in response to the receiving Frame (i.e., with the same
-		### Mongrel2 connection ID and sender).
-		def response( *flags )
-			unless @response
-				@response = super()
-
-				# Set the opcode
-				self.log.debug "Setting up response %p with symmetrical flags" % [ @response ]
-				if self.opcode == :ping
-					@response.opcode = :pong
-					IO.copy_stream( self.payload, @response.payload, 4096 )
-				else
-					@response.opcode = self.numeric_opcode
-				end
-
-				# Set flags in the response
-				unless flags.empty?
-					self.log.debug "  applying custom flags: %p" % [ flags ]
-					@response.set_flags( *flags )
-				end
-
-			end
-
-			return @response
-		end
-
-
-		### Apply flag bits and opcodes: (:fin, :rsv1, :rsv2, :rsv3, :continuation,
-		### :text, :binary, :close, :ping, :pong) to the frame.
-		###
-		###   # Transform the frame into a CLOSE frame and set its FIN flag
-		###   frame.set_flags( :fin, :close )
-		###
-		def set_flags( *flag_symbols )
-			flag_symbols.flatten!
-			flag_symbols.compact!
-
-			self.log.debug "Setting flags for symbols: %p" % [ flag_symbols ]
-
-			flag_symbols.each do |flag|
-				case flag
-				when :fin, :rsv1, :rsv2, :rsv3
-					self.__send__( "#{flag}=", true )
-				when :continuation, :text, :binary, :close, :ping, :pong
-					self.opcode = flag
-				when Integer
-					self.log.debug "  setting Integer flags directly: 0b%08b" % [ flag ]
-					self.flags |= flag
-				else
-					raise ArgumentError, "Don't know what the %p flag is." % [ flag ]
-				end
-			end
-		end
-
-
-		### Compatibility with Mongrel2::Response.
-		def extended_reply? # :nodoc:
-			return false
+		### Return the frame as a human-readable string suitable for debugging.
+		def inspect
+			return "#<%p:%#0x %s>" % [
+				self.class,
+				self.object_id * 2,
+				self.inspect_details,
+			]
 		end
 
 
@@ -655,7 +737,7 @@ module Mongrel2::WebSocket
 
 		### Make a WebSocket header for the frame and return it.
 		def make_header
-			header = ''.force_encoding( Encoding::ASCII_8BIT )
+			header = nil
 			length = self.payload.size
 
 			self.log.debug "Making wire protocol header for payload of %d bytes" % [ length ]