mongrel2 0.24.0 → 0.25.0.pre.285

data/lib/mongrel2/response.rb

@@ -1,5 +1,6 @@
 #!/usr/bin/ruby
 
+require 'stringio'
 require 'tnetstring'
 require 'yajl'
 require 'loggability'
@@ -31,10 +32,13 @@ 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 )
+
 		@sender_id = sender_id
 		@conn_id   = conn_id
 		@body      = body
 		@request   = nil
+		@chunksize = DEFAULT_CHUNKSIZE
 	end
 
 
@@ -50,12 +54,23 @@ class Mongrel2::Response
 	# the response will be routed to by the mongrel2 server
 	attr_accessor :conn_id
 
-	# The body of the response
-	attr_accessor :body
+	# The body of the response as an IO (or IOish) object
+	attr_reader :body
 
 	# The request that this response is for, if there is one
 	attr_accessor :request
 
+	# The number of bytes to write to Mongrel in a single "chunk"
+	attr_accessor :chunksize
+
+
+	### Set the response body to +newbody+. If +newbody+ is not a IO-like object (i.e., it
+	### doesn't respond to #eof?, it will be wrapped in a StringIO in 'a+' mode).
+	def body=( newbody )
+		newbody = StringIO.new( newbody, 'a+' ) unless newbody.respond_to?( :eof? )
+		@body = newbody
+	end
+
 
 	### Append the given +object+ to the response body. Returns the response for
 	### chaining.
@@ -67,15 +82,28 @@ class Mongrel2::Response
 
 	### Write the given +objects+ to the response body, calling #to_s on each one.
 	def puts( *objects )
-		objects.each do |obj|
-			self << obj.to_s.chomp << $/
-		end
+		self.body.puts( *objects )
 	end
 
 
 	### Stringify the response, which just returns its body.
 	def to_s
-		return self.body
+		pos = self.body.pos
+		self.body.pos = 0
+		return self.body.read
+	ensure
+		self.body.pos = pos
+	end
+
+
+	### Yield chunks of the response to the caller's block. By default, just yields
+	### the result of calling #to_s on the response.
+	def each_chunk
+		if block_given?
+			yield( self.to_s )
+		else
+			return [ self.to_s ].to_enum
+		end
 	end
 
 

data/lib/mongrel2/testing.rb

@@ -159,8 +159,7 @@ module Mongrel2
 			headers = self.make_merged_headers( :POST, uri, headers )
 			rclass = Mongrel2::Request.subclass_for_method( :POST )
 
-			req = rclass.new( self.sender_id, self.conn_id.to_s, uri.to_s, headers )
-			req.body = body
+			req = rclass.new( self.sender_id, self.conn_id.to_s, uri.to_s, headers, body )
 
 			return req
 		end
@@ -175,8 +174,7 @@ module Mongrel2
 			headers = self.make_merged_headers( :PUT, uri, headers )
 			rclass = Mongrel2::Request.subclass_for_method( :PUT )
 
-			req = rclass.new( self.sender_id, self.conn_id.to_s, uri.to_s, headers )
-			req.body = body
+			req = rclass.new( self.sender_id, self.conn_id.to_s, uri.to_s, headers, body )
 
 			return req
 		end

data/lib/mongrel2/websocket.rb

@@ -26,6 +26,11 @@ module Mongrel2::WebSocket
 
 	# WebSocket-related header and status constants
 	module Constants
+
+		# The default number of bytes to write out to Mongrel for a single "chunk"
+		DEFAULT_CHUNKSIZE = 512 * 1024 # 512 kilobytes
+
+
 		# WebSocket frame header
 		#    0                   1                   2                   3
 		#    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
@@ -245,9 +250,10 @@ module Mongrel2::WebSocket
 
 			super
 
-			@flags = Integer( self.headers.flags || DEFAULT_FLAGS )
+			@flags         = Integer( self.headers.flags || DEFAULT_FLAGS )
 			@request_frame = nil
-			@errors = []
+			@errors        = []
+			@chunksize     = DEFAULT_CHUNKSIZE
 		end
 
 
@@ -270,6 +276,8 @@ module Mongrel2::WebSocket
 		# The Array of validation errors
 		attr_reader :errors
 
+		# The number of bytes to write to Mongrel in a single "chunk"
+		attr_accessor :chunksize
 
 		### Returns +true+ if the request's FIN flag is set. This flag indicates that
 		### this is the final fragment in a message.  The first fragment MAY also be
@@ -332,9 +340,7 @@ module Mongrel2::WebSocket
 
 		### Write the given +objects+ to the payload, calling #to_s on each one.
 		def puts( *objects )
-			objects.each do |obj|
-				self << obj.to_s.chomp << $/
-			end
+			self.payload.puts( *objects )
 		end
 
 
@@ -344,61 +350,101 @@ module Mongrel2::WebSocket
 			self.log.warn "Unknown status code %d" unless CLOSING_STATUS_DESC.key?( statuscode )
 			status_msg = "%d %s" % [ statuscode, CLOSING_STATUS_DESC[statuscode] ]
 
-			self.payload.replace( status_msg )
+			self.payload.truncate( 0 )
+			self.payload.puts( status_msg )
 		end
 
 
-		### Check the frame for problems, appending descriptions of any issues to
-		### the #errors array.
+		### Validate the frame, raising a Mongrel2::WebSocket::FrameError if there
+		### are validation problems.
 		def validate
+			unless self.valid?
+				self.log.error "Validation failed."
+				raise Mongrel2::WebSocket::FrameError, "invalid frame: %s" % [ self.errors.join(', ') ]
+			end
+		end
+
+
+		### Sanity-checks the frame and returns +false+ if any problems are found.
+		### Error messages will be in #errors.
+		def valid?
 			self.errors.clear
 
 			self.validate_payload_encoding
 			self.validate_control_frame
 			self.validate_opcode
 			self.validate_reserved_flags
+
+			return self.errors.empty?
 		end
 
 
-		### Sanity-checks the frame and returns +false+ if any problems are found.
-		### Error messages will be in #errors.
-		def valid?
+		### 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
 			self.validate
-			return self.errors.empty?
+
+			iter = Enumerator.new do |yielder|
+				self.bytes.each_slice( self.chunksize ) do |bytes|
+					yielder.yield( bytes.pack('C*') )
+				end
+			end
+
+			if block_given?
+				block = Proc.new
+				iter.each( &block )
+			else
+				return iter
+			end
 		end
 
 
 		### Stringify into a response suitable for sending to the client.
 		def to_s
-			data = self.payload.to_s
+			self.remember_payload_settings do
+				self.payload.rewind
+				self.payload.set_encoding( 'binary' )
 
-			# Make sure the outgoing payload is UTF-8, except in the case of a
-			# binary frame.
-			if self.opcode != :binary && data.encoding != Encoding::UTF_8
-				self.log.debug "Transcoding %s payload data to UTF-8" % [ data.encoding.name ]
-				data.encode!( Encoding::UTF_8 )
-			end
+				header = self.make_header
+				data = self.payload.read
 
-			# Make sure everything's in order
-			unless self.valid?
-				self.log.error "Validation failed."
-				raise Mongrel2::WebSocket::FrameError, "invalid frame: %s" %
-					[ self.errors.join( ', ' ) ]
+				return header + data
 			end
-
-			# Now force everything into binary so it can be catenated
-			data.force_encoding( Encoding::ASCII_8BIT )
-			return [
-				self.make_header( data ),
-				data
-			].join
 		end
 
 
 		### Return an Enumerator for the bytes of the raw frame as it appears
 		### on the wire.
 		def bytes
-			return self.to_s.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.bytes
+					body_i   = self.payload.bytes
+
+					header_i.each_with_index {|byte, i| yielder.yield(byte) }
+					body_i.each_with_index   {|byte, i| yielder.yield(byte) }
+				end
+			end
+		end
+
+
+		### 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
+
+			yield
+		ensure
+			self.payload.set_encoding( original_enc ) if original_enc
+			self.payload.pos = original_pos if original_pos
 		end
 
 
@@ -414,7 +460,7 @@ module Mongrel2::WebSocket
 				self.log.debug "Setting up response %p with symmetrical flags" % [ @response ]
 				if self.opcode == :ping
 					@response.opcode = :pong
-					@response.payload = self.payload
+					IO.copy_stream( self.payload, @response.payload, 4096 )
 				else
 					@response.opcode = self.opcode
 				end
@@ -472,15 +518,16 @@ module Mongrel2::WebSocket
 				self.rsv3? ? 1 : 0,
 				self.opcode,
 				self.numeric_opcode,
-				(self.payload.bytesize / 1024.0),
+				(self.payload.size / 1024.0),
 			]
 		end
 
 
-		### Make a WebSocket header for the receiving frame and return it.
-		def make_header( data )
+		### Make a WebSocket header for the frame and return it.
+		def make_header
 			header = ''.force_encoding( Encoding::ASCII_8BIT )
-			length = data.bytesize
+			length = self.payload.size
+
 			self.log.debug "Making wire protocol header for payload of %d bytes" % [ length ]
 
 			# Pack the frame according to its size
@@ -505,12 +552,14 @@ module Mongrel2::WebSocket
 		### #errors.
 		def validate_payload_encoding
 			if self.opcode == :binary
-				self.log.debug "Binary payload: forcing to ASCII-8BIT"
-				self.payload.force_encoding( Encoding::ASCII_8BIT )
+				self.log.debug "Binary payload: setting external encoding to ASCII-8BIT"
+				self.payload.set_encoding( Encoding::ASCII_8BIT )
 			else
-				self.log.debug "Non-binary payload: forcing to UTF-8"
-				self.payload.force_encoding( Encoding::UTF_8 )
-				self.errors << "Invalid UTF8 in payload" unless self.payload.valid_encoding?
+				self.log.debug "Non-binary payload: setting external encoding to UTF-8"
+				self.payload.set_encoding( Encoding::UTF_8 )
+				# :TODO: Is there a way to check that the data in a File or Socket will
+				# transcode successfully? Probably not.
+				# self.errors << "Invalid UTF8 in payload" unless self.payload.valid_encoding?
 			end
 		end
 
@@ -520,8 +569,8 @@ module Mongrel2::WebSocket
 		def validate_control_frame
 			return unless self.control?
 
-			if self.payload.bytesize > 125
-				self.log.error "Payload of control frame exceeds 125 bytes (%d)" % [ self.payload.bytesize ]
+			if self.payload.size > 125
+				self.log.error "Payload of control frame exceeds 125 bytes (%d)" % [ self.payload.size ]
 				self.errors << "payload of control frame cannot exceed 125 bytes"
 			end
 
@@ -536,7 +585,7 @@ module Mongrel2::WebSocket
 		### opcodes, you'll want to override this.
 		def validate_opcode
 			if self.opcode == :reserved
-				self.log.error "Frame uses reserved opcode 0x%x" % [ self.numeric_opcode ] 
+				self.log.error "Frame uses reserved opcode 0x%x" % [ self.numeric_opcode ]
 				self.errors << "Frame uses reserved opcode"
 			end
 		end
@@ -552,6 +601,16 @@ module Mongrel2::WebSocket
 		end
 
 
+		#######
+		private
+		#######
+
+		### Return a simple hexdump of the specified +data+.
+		def hexdump( data )
+			data.bytes.to_a.map {|byte| sprintf('%#02x',byte) }.join( ' ' )
+		end
+
+
 	end # class Frame
 
 end # module Mongrel2::WebSocket

data/spec/mongrel2/httprequest_spec.rb

@@ -143,46 +143,6 @@ describe Mongrel2::HTTPRequest do
 			@req.remote_ip.to_s.should == '127.0.0.1'
 		end
 
-		it "knows if it's an 'async upload started' notification" do
-			@req.headers.x_mongrel2_upload_start = '/tmp/mongrel2.upload.20120503-54578-rs3l2g'
-			@req.should be_upload_started()
-			@req.should_not be_upload_done()
-		end
-
-		it "knows if it's an 'async upload done' notification" do
-			@req.headers.x_mongrel2_upload_start = '/tmp/mongrel2.upload.20120503-54578-rs3l2g'
-			@req.headers.x_mongrel2_upload_done = '/tmp/mongrel2.upload.20120503-54578-rs3l2g'
-			@req.should_not be_upload_started()
-			@req.should be_upload_done()
-			@req.should be_valid_upload()
-		end
-
-		it "knows if it's not a valid 'async upload done' notification" do
-			@req.headers.x_mongrel2_upload_start = '/tmp/mongrel2.upload.20120503-54578-rs3l2g'
-			@req.headers.x_mongrel2_upload_done = '/etc/passwd'
-			@req.should_not be_upload_started()
-			@req.should be_upload_done()
-			@req.should_not be_valid_upload()
-		end
-
-		it "raises an exception if the uploaded file fetched with mismatched headers" do
-			@req.headers.x_mongrel2_upload_start = '/tmp/mongrel2.upload.20120503-54578-rs3l2g'
-			@req.headers.x_mongrel2_upload_done = '/etc/passwd'
-
-			expect {
-				@req.uploaded_file
-			}.to raise_error( Mongrel2::UploadError, /upload headers/i )
-		end
-
-		it "can return a Pathname object for the uploaded file if it's valid" do
-			@req.headers.x_mongrel2_upload_start = '/tmp/mongrel2.upload.20120503-54578-rs3l2g'
-			@req.headers.x_mongrel2_upload_done = '/tmp/mongrel2.upload.20120503-54578-rs3l2g'
-
-			@req.should be_valid_upload()
-			@req.uploaded_file.should be_a( Pathname )
-			@req.uploaded_file.to_s.should == '/tmp/mongrel2.upload.20120503-54578-rs3l2g'
-		end
-
 	end
 
 end

data/spec/mongrel2/httpresponse_spec.rb

@@ -75,7 +75,7 @@ describe Mongrel2::HTTPResponse do
 	end
 
 	it "doesn't have a body" do
-		@response.body.should be_empty()
+		@response.body.size.should == 0
 	end
 
 	it "stringifies to a valid RFC2616 response string" do
@@ -94,7 +94,8 @@ describe Mongrel2::HTTPResponse do
 		@response.reset
 
 		@response.should_not be_handled()
-		@response.body.should == ''
+		@response.body.should be_a( StringIO )
+		@response.body.size.should == 0
 		@response.headers.should have(1).keys
 	end
 
@@ -116,7 +117,7 @@ describe Mongrel2::HTTPResponse do
 
 	it "can find the length of its body if it's a String with multi-byte characters in it" do
 		test_body = 'Хорошая собака, Стрелке! Очень хорошо.'
-		@response.body = test_body
+		@response << test_body
 
 		@response.get_content_length.should == test_body.bytesize
 	end
@@ -238,14 +239,6 @@ describe Mongrel2::HTTPResponse do
 		@response.get_content_length.should == 0
 	end
 
-	it "raises a descriptive error message if it can't get the body's length" do
-		@response.body = Object.new
-
-		lambda {
-			@response.get_content_length
-		}.should raise_error( Mongrel2::ResponseError, /content length/i )
-	end
-
 
 	it "can build a valid HTTP status line for its status" do
 		@response.status = HTTP::SEE_OTHER
@@ -271,7 +264,8 @@ describe Mongrel2::HTTPResponse do
 
 	it "has a puts method for appending objects to the body" do
 		@response.puts( :something_to_sable )
-		@response.body.should == "something_to_sable\n"
+		@response.body.rewind
+		@response.body.read.should == "something_to_sable\n"
 	end
 
 end