fotonauts-eventmachine_httpserver 0.0.1

data/lib/evma_httpserver.rb

@@ -0,0 +1,35 @@
+# EventMachine HTTP Server
+#
+# Author:: blackhedd (gmail address: garbagecat10).
+# 
+# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+#
+# This program is made available under the terms of the GPL version 2.
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006 by Francis Cianfrocca. All Rights Reserved.
+#
+# Gmail: garbagecat10
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+#---------------------------------------------------------------------------
+#
+
+
+require 'eventmachine_httpserver'
+require 'evma_httpserver/response'
+

data/lib/evma_httpserver/response.rb

@@ -0,0 +1,278 @@
+# EventMachine HTTP Server
+# HTTP Response-support class
+#
+# Author:: blackhedd (gmail address: garbagecat10).
+# 
+# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+#
+# This program is made available under the terms of the GPL version 2.
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006 by Francis Cianfrocca. All Rights Reserved.
+#
+# Gmail: garbagecat10
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+#---------------------------------------------------------------------------
+#
+
+module EventMachine
+
+	class HttpResponse
+		attr_accessor :status, :content, :headers, :chunks, :multiparts
+
+		def initialize
+			@headers = {}
+		end
+
+		def keep_connection_open arg=true
+			@keep_connection_open = arg
+		end
+
+		# sugarings for headers
+		def content_type *mime
+			if mime.length > 0
+				@headers ["Content-type"] = mime.first.to_s
+			else
+				@headers ["Content-type"]
+			end
+		end
+
+		# Sugaring for Set-cookie headers. These are a pain because there can easily and
+		# legitimately be more than one. So we use an ugly verb to signify that.
+		# #add_set_cookies does NOT disturb the set-cookie headers which may have been
+		# added on a prior call. #set_cookie clears them out first.
+		def add_set_cookie *ck
+			if ck.length > 0
+				h = (@headers ["Set-cookie"] ||= [])
+				ck.each {|c| h << c}
+			end
+		end
+		def set_cookie *ck
+			h = (@headers ["Set-cookie"] ||= [])
+			if ck.length > 0
+				h.clear
+				add_set_cookie *ck
+			else
+				h
+			end
+		end
+
+
+		# This is intended to send a complete HTTP response, including closing the connection
+		# if appropriate at the end of the transmission. Don't use this method to send partial
+		# or iterated responses. This method will send chunks and multiparts provided they
+		# are all available when we get here.
+		# Note that the default @status is 200 if the value doesn't exist.
+		def send_response
+			send_headers
+			send_body
+			send_trailer
+			close_connection_after_writing unless (@keep_connection_open and (@status || 200) == 200)
+		end
+
+		# Send the headers out in alpha-sorted order. This will degrade performance to some
+		# degree, and is intended only to simplify the construction of unit tests.
+		#
+		def send_headers
+			raise "sent headers already" if @sent_headers
+			@sent_headers = true
+
+			fixup_headers
+
+			ary = []
+			ary << "HTTP/1.1 #{@status || 200} ...\r\n"
+			ary += generate_header_lines(@headers)
+			ary << "\r\n"
+
+			send_data ary.join
+		end
+
+
+		def generate_header_lines in_hash
+			out_ary = []
+			in_hash.keys.sort.each {|k|
+				v = @headers[k]
+				if v.is_a?(Array)
+					v.each {|v1| out_ary << "#{k}: #{v1}\r\n" }
+				else
+					out_ary << "#{k}: #{v}\r\n"
+				end
+			}
+			out_ary
+		end
+		private :generate_header_lines
+
+
+		# Examine the content type and data and other things, and perform a final
+		# fixup of the header array. We expect this to be called just before sending
+		# headers to the remote peer.
+		# In the case of multiparts, we ASSUME we will get called before any content
+		# gets sent out, because the multipart boundary is created here.
+		#
+		def fixup_headers
+			if @content
+				@headers ["Content-length"] = @content.to_s.length
+			elsif @chunks
+				@headers ["Transfer-encoding"] = "chunked"
+				# Might be nice to ENSURE there is no content-length header,
+				# but how to detect all the possible permutations of upper/lower case?
+			elsif @multiparts
+				@multipart_boundary = self.class.concoct_multipart_boundary
+				@headers ["Content-type"] = "multipart/x-mixed-replace; boundary=\"#{@multipart_boundary}\""
+			else
+				@headers ["Content-length"] = 0
+			end
+		end
+
+		# we send either content, chunks, or multiparts. Content can only be sent once.
+		# Chunks and multiparts can be sent any number of times.
+		# DO NOT close the connection or send any goodbye kisses. This method can
+		# be called multiple times to send out chunks or multiparts.
+		def send_body
+			if @content
+				send_content
+			elsif @chunks
+				send_chunks
+			elsif @multiparts
+				send_multiparts
+			else
+				@content = ""
+				send_content
+			end
+		end
+
+		# send a trailer which depends on the type of body we're dealing with.
+		# The assumption is that we're about to end the transmission of this particular
+		# HTTP response. (A connection-close may or may not follow.)
+		#
+		def send_trailer
+			send_headers unless @sent_headers
+			if @content
+				# no-op
+			elsif @chunks
+				unless @last_chunk_sent
+					chunk ""
+					send_chunks
+				end
+			elsif @multiparts
+				# in the lingo of RFC 2046/5.1.1, we're sending an "epilog"
+				# consisting of a blank line. I really don't know how that is
+				# supposed to interact with the case where we leave the connection
+				# open after transmitting the multipart response.
+				send_data "\r\n--#{@multipart_boundary}--\r\n\r\n"
+			else
+				# no-op
+			end
+		end
+
+		def send_content
+			raise "sent content already" if @sent_content
+			@sent_content = true
+			send_data((@content || "").to_s)
+		end
+
+		# add a chunk to go to the output.
+		# Will cause the headers to pick up "content-transfer-encoding"
+		# Add the chunk to a list. Calling #send_chunks will send out the
+		# available chunks and clear the chunk list WITHOUT closing the connection,
+		# so it can be called any number of times.
+		# TODO!!! Per RFC2616, we may not send chunks to an HTTP/1.0 client.
+		# Raise an exception here if our user tries to do so.
+		# Chunked transfer coding is defined in RFC2616 pgh 3.6.1.
+		# The argument can be a string or a hash. The latter allows for
+		# sending chunks with extensions (someday).
+		#
+		def chunk text
+			@chunks ||= []
+			@chunks << text
+		end
+
+		# send the contents of the chunk list and clear it out.
+		# ASSUMES that headers have been sent.
+		# Does NOT close the connection.
+		# Can be called multiple times.
+		# According to RFC2616, phg 3.6.1, the last chunk will be zero length.
+		# But some caller could accidentally set a zero-length chunk in the middle
+		# of the stream. If that should happen, raise an exception.
+		# The reason for supporting chunks that are hashes instead of just strings
+		# is to enable someday supporting chunk-extension codes (cf the RFC).
+		# TODO!!! We're not supporting the final entity-header that may be
+		# transmitted after the last (zero-length) chunk.
+		#
+		def send_chunks
+			send_headers unless @sent_headers
+			while chunk = @chunks.shift
+				raise "last chunk already sent" if @last_chunk_sent
+				text = chunk.is_a?(Hash) ? chunk[:text] : chunk.to_s
+				send_data "#{format("%x", text.length).upcase}\r\n#{text}\r\n"
+				@last_chunk_sent = true if text.length == 0
+			end
+		end
+
+		# To add a multipart to the outgoing response, specify the headers and the
+		# body. If only a string is given, it's treated as the body (in this case,
+		# the header is assumed to be empty).
+		#
+		def multipart arg
+			vals = if arg.is_a?(String)
+				{:body => arg, :headers => {}}
+			else
+				arg
+			end
+
+			@multiparts ||= []
+			@multiparts << vals
+		end
+
+		# Multipart syntax is defined in RFC 2046, pgh 5.1.1 et seq.
+		# The CRLF which introduces the boundary line of each part (content entity)
+		# is defined as being part of the boundary, not of the preceding part.
+		# So we don't need to mess with interpreting the last bytes of a part
+		# to ensure they are CRLF-terminated.
+		#
+		def send_multiparts
+			send_headers unless @sent_headers
+			while part = @multiparts.shift
+				send_data "\r\n--#{@multipart_boundary}\r\n"
+				send_data( generate_header_lines( part[:headers] || {} ).join)
+				send_data "\r\n"
+				send_data part[:body].to_s
+			end
+		end
+
+		#
+		#
+		def self.concoct_multipart_boundary
+			@multipart_index ||= 0
+			@multipart_index += 1
+			if @multipart_index >= 1000
+				@multipart_index = 0
+				@multipart_guid = nil
+			end
+			@multipart_guid ||= `uuidgen -r`.chomp.gsub(/\-/,"")
+			"#{@multipart_guid}#{@multipart_index}"
+		end
+		
+		def send_redirect location
+			@status = 302 # TODO, make 301 available by parameter
+			@headers["Location"] = location
+			send_response
+		end
+	end
+end
+

data/test/test_app.rb

@@ -0,0 +1,239 @@
+require 'test/unit'
+require 'evma_httpserver'
+
+begin
+  once = false
+  require 'eventmachine'
+rescue LoadError => e
+  raise e if once
+  once = true
+  require 'rubygems'
+  retry
+end
+
+
+
+#--------------------------------------
+
+module EventMachine
+  module HttpServer
+    def process_http_request
+      send_data generate_response()
+      close_connection_after_writing
+    end
+  end
+end
+
+#--------------------------------------
+
+require 'socket'
+
+class TestApp < Test::Unit::TestCase
+
+  TestHost = "127.0.0.1"
+  TestPort = 8911
+
+  TestResponse_1 = <<EORESP
+HTTP/1.0 200 ...
+Content-length: 4
+Content-type: text/plain
+Connection: close
+
+1234
+EORESP
+
+  Thread.abort_on_exception = true
+
+  def test_simple_get
+    received_response = nil
+
+    EventMachine::HttpServer.module_eval do
+      def generate_response
+        TestResponse_1
+      end
+    end
+
+
+    EventMachine.run do
+      EventMachine.start_server TestHost, TestPort, EventMachine::HttpServer
+      EventMachine.add_timer(1) {raise "timed out"} # make sure the test completes
+
+      cb = proc do
+        tcp = TCPSocket.new TestHost, TestPort
+        tcp.write "GET / HTTP/1.0\r\n\r\n"
+        received_response = tcp.read
+      end
+      eb = proc { EventMachine.stop }
+      EventMachine.defer cb, eb
+    end
+
+    assert_equal( TestResponse_1, received_response )
+  end
+
+
+
+
+  # This frowsy-looking protocol handler allows the test harness to make some
+  # its local variables visible, so we can set them here and they can be asserted later.
+  class MyTestServer < EventMachine::Connection
+    include EventMachine::HttpServer
+    def initialize *args
+      super
+    end
+    def generate_response
+      @assertions.call
+      TestResponse_1
+    end
+  end
+
+
+
+  def test_parameters
+    path_info = "/test.html"
+    query_string = "a=b&c=d"
+    cookie = "eat_me=I'm a cookie"
+    etag = "12345"
+
+    # collect all the stuff we want to assert outside the actual test,
+    # to ensure it gets asserted even if the test catches some exception.
+    received_response = nil
+    request_parms = {}
+
+
+    EventMachine.run do
+      EventMachine.start_server(TestHost, TestPort, MyTestServer) do |conn|
+        # In each accepted connection, set up a procedure that will copy
+        # the request parameters into a local variable visible here, so
+        # we can assert the values later.
+        conn.instance_eval do
+          @assertions = proc {
+            parms = %w( PATH_INFO QUERY_STRING HTTP_COOKIE IF_NONE_MATCH
+            CONTENT_TYPE REQUEST_METHOD REQUEST_URI )
+            parms.each {|parm|
+              # request_parms is bound to a local variable visible in this context.
+              request_parms[parm] = ENV[parm]
+            }
+          }
+        end
+      end
+      EventMachine.add_timer(1) {raise "timed out"} # make sure the test completes
+
+      cb = proc do
+        tcp = TCPSocket.new TestHost, TestPort
+        data = [
+          "GET #{path_info}?#{query_string} HTTP/1.1\r\n",
+          "Cookie: #{cookie}\r\n",
+          "If-none-match: #{etag}\r\n",
+          "\r\n"
+        ].join
+        tcp.write(data)
+        received_response = tcp.read
+      end
+      eb = proc { EventMachine.stop }
+      EventMachine.defer cb, eb
+    end
+
+    assert_equal( TestResponse_1, received_response )
+    assert_equal( path_info, request_parms["PATH_INFO"] )
+    assert_equal( query_string, request_parms["QUERY_STRING"] )
+    assert_equal( cookie, request_parms["HTTP_COOKIE"] )
+    assert_equal( etag, request_parms["IF_NONE_MATCH"] )
+    assert_equal( nil, request_parms["CONTENT_TYPE"] )
+    assert_equal( "GET", request_parms["REQUEST_METHOD"] )
+    assert_equal( path_info, request_parms["REQUEST_URI"] )
+  end
+
+
+  def test_headers
+    received_header_string = nil
+    received_header_ary = nil
+
+    EventMachine.run do
+      EventMachine.start_server(TestHost, TestPort, MyTestServer) do |conn|
+        # In each accepted connection, set up a procedure that will copy
+        # the request parameters into a local variable visible here, so
+        # we can assert the values later.
+        # The @http_headers is set automatically and can easily be parsed.
+        # It isn't automatically parsed into Ruby values because that is
+        # a costly operation, but we should provide an optional method that
+        # does the parsing so it doesn't need to be done by users.
+        conn.instance_eval do
+          @assertions = proc do
+            received_header_string = @http_headers
+            received_header_ary = @http_headers.split(/\0/).map {|line| line.split(/:\s*/, 2) }
+          end
+        end
+      end
+
+      cb = proc do
+        tcp = TCPSocket.new TestHost, TestPort
+        data = [
+          "GET / HTTP/1.1\r\n",
+          "aaa: 111\r\n",
+          "bbb: 222\r\n",
+          "ccc: 333\r\n",
+          "ddd: 444\r\n",
+          "\r\n"
+        ].join
+        tcp.write data
+        received_response = tcp.read
+      end
+      eb = proc { EventMachine.stop }
+      EventMachine.defer cb, eb
+
+      EventMachine.add_timer(1) {raise "timed out"} # make sure the test completes
+    end
+
+    assert_equal( "aaa: 111\0bbb: 222\0ccc: 333\0ddd: 444\0\0", received_header_string )
+    assert_equal( [["aaa","111"], ["bbb","222"], ["ccc","333"], ["ddd","444"]], received_header_ary )
+  end
+
+
+
+
+
+  def test_post
+    received_header_string = nil
+    post_content = "1234567890"
+    content_type = "text/plain"
+    received_post_content = ""
+    received_content_type = ""
+
+    EventMachine.run do
+      EventMachine.start_server(TestHost, TestPort, MyTestServer) do |conn|
+        # In each accepted connection, set up a procedure that will copy
+        # the request parameters into a local variable visible here, so
+        # we can assert the values later.
+        # The @http_post_content variable is set automatically.
+        conn.instance_eval do
+          @assertions = proc do
+            received_post_content = @http_post_content
+            received_content_type = ENV["CONTENT_TYPE"]
+          end
+        end
+      end
+      EventMachine.add_timer(1) {raise "timed out"} # make sure the test completes
+
+      cb = proc do
+        tcp = TCPSocket.new TestHost, TestPort
+        data = [
+          "POST / HTTP/1.1\r\n",
+          "Content-type: #{content_type}\r\n",
+          "Content-length: #{post_content.length}\r\n",
+          "\r\n",
+          post_content
+        ].join
+        tcp.write(data)
+        received_response = tcp.read
+      end
+      eb = proc do
+        EventMachine.stop
+      end
+      EventMachine.defer cb, eb
+    end
+
+    assert_equal( received_post_content, post_content )
+    assert_equal( received_content_type, content_type )
+  end
+
+end