em-http-server 0.1.0

data/.gitignore

@@ -0,0 +1,18 @@
+.idea
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in em-http-server.gemspec
+gemspec
+
+gem 'eventmachine'
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "bundler", "> 1.0.0"
+  gem 'rake'
+  gem 'test-unit'
+  gem 'simplecov'
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 alor
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,56 @@
+# Em::Http::Server
+
+Simple http server to be used with Eventmachine.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'em-http-server'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install em-http-server
+
+## Usage
+
+    require 'eventmachine'
+    require 'em-http-server'
+
+    class HTTPHandler < EM::Http::Server
+
+        def process_http_request
+              puts  @http_request_method
+              puts  @http_request_uri
+              puts  @http_query_string
+              puts  @http_protocol
+              puts  @http_content
+              puts  @http[:cookie]
+              puts  @http[:content_type]
+              # you have all the http headers in this hash
+              puts  @http.inspect
+
+              response = EM::DelegatedHttpResponse.new(self)
+              response.status = 200
+              response.content_type 'text/html'
+              response.content = 'It works'
+              response.send_response
+        end
+        
+    end
+
+    EM::run do
+        EM::start_server("0.0.0.0", 80, HTTPHandler)
+    end
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test

data/em-http-server.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |gem|
+  gem.authors       = ["alor"]
+  gem.email         = ["alberto.ornaghi@gmail.com"]
+  gem.description   = %q{Simple http server for eventmachine}
+  gem.summary       = %q{Simple http server for eventmachine with the same interface as evma_httpserver}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "em-http-server"
+  gem.require_paths = ["lib"]
+  gem.version       = "0.1.0"
+
+  gem.add_runtime_dependency "eventmachine"
+end

data/lib/em-http-server.rb

@@ -0,0 +1,2 @@
+require "em-http-server/response"
+require "em-http-server/server"

data/lib/em-http-server/response.rb

@@ -0,0 +1,314 @@
+# 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
+
+	# This class provides a wide variety of features for generating and
+	# dispatching HTTP responses. It allows you to conveniently generate
+	# headers and content (including chunks and multiparts), and dispatch
+	# responses (including deferred or partially-complete responses).
+	#
+	# Although HttpResponse is coded as a class, it's not complete as it
+	# stands. It assumes that it has certain of the behaviors of
+	# EventMachine::Connection. You must add these behaviors, either by
+	# subclassing HttpResponse, or using the alternate version of this
+	# class, DelegatedHttpResponse. See the test cases for current information
+	# on which behaviors you have to add.
+	#
+	# TODO, someday it would be nice to provide a version of this functionality
+	# that is coded as a Module, so it can simply be mixed into an instance of
+	# EventMachine::Connection.
+	#
+	class HttpResponse
+		attr_accessor :status, :status_string, :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) < 500)
+		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} #{@status_string || '...'}\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 = in_hash[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
+
+		# TODO, this is going to be way too slow. Cache up the uuidgens.
+		#
+		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
+      @status_string = "Moved Temporarily"
+			@headers["Location"] = location
+			send_response
+		end
+	end
+end
+
+#----------------------------------------------------------------------------
+
+require 'forwardable'
+
+module EventMachine
+	class DelegatedHttpResponse < HttpResponse
+		extend Forwardable
+		def_delegators :@delegate,
+			:send_data,
+			:close_connection,
+			:close_connection_after_writing
+
+		def initialize dele
+			super()
+			@delegate = dele
+		end
+	end
+end
+

data/lib/em-http-server/server.rb

@@ -0,0 +1,94 @@
+require 'rubygems'
+require 'eventmachine'
+
+module EventMachine
+  module Http
+    class Server < EM::P::HeaderAndContentProtocol
+
+      # everything starts from here.
+      # Protocol::HeaderAndContentProtocol does the dirty job for us
+      # it will pass headers and content, we just need to parse the headers
+      # the fill the right variables
+      def receive_request(headers, content)
+
+        # save the whole headers array, verbatim
+        @http_headers = headers
+
+        # parse the headers into an hash to be able to access them like:
+        #  @http[:host]
+        #  @http[:content_type]
+        @http = headers_2_hash headers
+
+        # parse the HTTP request
+        parse_first_header headers.first
+
+        # save the binary content
+        @http_content = content
+
+        # invoke the method in the user-provided instance
+        if respond_to?(:process_http_request)
+          process_http_request
+        end
+      end
+
+      # parse the first HTTP header line
+      # get the http METHOD, URI and PROTOCOL
+      def parse_first_header(line)
+
+        # split the line into:  METHOD URI PROTOCOL
+        # eg:  GET / HTTP1/1
+        parsed = line.split(' ')
+
+        # a correct request has three parts
+        send_error(400, "Bad request") unless parsed.size == 3
+
+        @http_request_method, uri, @http_protocol = parsed
+
+        # uri must begin with a /
+        send_error(400, "Bad request") unless uri.start_with?('/')
+
+        # optional query string
+        @http_request_uri, @http_query_string = uri.split('?')
+      end
+
+      # send back to the client an HTTP error
+      def send_error(code, desc)
+        string = "HTTP1/1 #{code} #{desc}\r\n"
+        string << "Connection: close\r\n"
+        string << "Content-type: text/plain\r\n"
+        string << "\r\n"
+        string << "Detected error: HTTP code #{code}"
+        send_data string
+        close_connection_after_writing
+      end
+
+    end
+  end
+end
+
+
+if __FILE__ == $0
+
+  class HTTPHandler < EM::Http::Server
+
+    def process_http_request
+      puts  @http_request_method
+      puts  @http_request_uri
+      puts  @http_query_string
+      puts  @http_protocol
+      puts  @http[:cookie]
+      puts  @http[:content_type]
+      puts  @http_content
+      puts  @http.inspect
+    end
+
+  end
+
+  port = 8080
+  # all the events are handled here
+  EM::run do
+    EM::start_server("0.0.0.0", port, HTTPHandler)
+    puts "Listening on port #{port}..."
+  end
+
+end

data/test/test_app.rb

@@ -0,0 +1,270 @@
+require 'test/unit'
+require 'em-http-server'
+
+begin
+  once = false
+  require 'eventmachine'
+rescue LoadError => e
+  raise e if once
+  once = true
+  require 'rubygems'
+  retry
+end
+
+
+
+#--------------------------------------
+
+module EventMachine
+  class HttpServer < EM::Http::Server
+    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.class_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::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_http = {}
+    request_uri = ""
+    request_query = ""
+    request_method = ""
+
+
+    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 {
+            request_method = @http_request_method
+            request_uri = @http_request_uri
+            request_query = @http_query_string
+            request_http = @http
+          }
+        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_uri )
+    assert_equal( query_string, request_query )
+    assert_equal( cookie, request_http[:cookie] )
+    assert_equal( etag, request_http[:if_none_match] )
+    assert_equal( nil, request_http[:content_type] )
+    assert_equal( "GET", request_method )
+  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.map {|line| line }
+          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( ["GET / HTTP/1.1", "aaa: 111", "bbb: 222", "ccc: 333", "ddd: 444"], 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_content
+            received_content_type = @http[: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( post_content, received_post_content)
+    assert_equal( content_type, received_content_type)
+  end
+
+
+  def test_invalid
+    received_response = nil
+
+    EventMachine.run do
+      EventMachine.start_server(TestHost, TestPort, MyTestServer) do |conn|
+        conn.instance_eval do
+          @assertions = proc do
+          end
+        end
+      end
+
+      cb = proc do
+        tcp = TCPSocket.new TestHost, TestPort
+        data = [
+          "GET foo HTTP/1.1\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( "HTTP1/1 400 Bad request\r\nConnection: close\r\nContent-type: text/plain\r\n\r\nDetected error: HTTP code 400", received_response )
+  end
+
+
+end

data/test/test_delegated.rb

@@ -0,0 +1,187 @@
+require 'test/unit'
+require 'em-http-server'
+
+begin
+  once = false
+  require 'eventmachine'
+rescue LoadError => e
+  raise e if once
+  once = true
+  require 'rubygems'
+  retry
+end
+
+
+#--------------------------------------
+
+
+class TestDelegatedHttpResponse < Test::Unit::TestCase
+
+	# This is a delegate class that (trivially) implements the
+	# several classes needed to work with HttpResponse.
+	#
+	class D
+		attr_reader :output_data
+		attr_reader :closed_after_writing
+
+		def send_data data
+			@output_data ||= ""
+			@output_data << data
+		end
+		def close_connection_after_writing
+			@closed_after_writing = true
+		end
+	end
+
+	def setup
+	end
+
+
+	def teardown
+	end
+
+
+	def test_properties
+		a = EM::DelegatedHttpResponse.new( D.new )
+		a.status = 200
+		a.content = "Some content"
+		a.headers["Content-type"] = "text/xml"
+	end
+
+	def test_header_sugarings
+		a = EM::DelegatedHttpResponse.new( D.new )
+		a.content_type "text/xml"
+		a.set_cookie "a=b"
+		a.headers["X-bayshore"] = "aaaa"
+
+		assert_equal({
+			"Content-type" => "text/xml",
+			"Set-cookie" => ["a=b"],
+			"X-bayshore" => "aaaa"
+		}, a.headers)
+	end
+
+	def test_send_response
+		d = D.new
+		a = EM::DelegatedHttpResponse.new( d )
+		a.status = 200
+		a.send_response
+		assert_equal([
+			     "HTTP/1.1 200 ...\r\n",
+			     "Content-length: 0\r\n",
+			     "\r\n"
+		].join, d.output_data)
+		assert_equal( true, d.closed_after_writing )
+	end
+
+	def test_send_response_1
+		d = D.new
+		a = EM::DelegatedHttpResponse.new( d )
+		a.status = 200
+		a.content_type "text/plain"
+		a.content = "ABC"
+		a.send_response
+		assert_equal([
+			     "HTTP/1.1 200 ...\r\n",
+			     "Content-length: 3\r\n",
+			     "Content-type: text/plain\r\n",
+			     "\r\n",
+			     "ABC"
+		].join, d.output_data)
+		assert( d.closed_after_writing )
+	end
+
+	def test_send_response_no_close
+		d = D.new
+		a = EM::DelegatedHttpResponse.new( d )
+		a.status = 200
+		a.content_type "text/plain"
+		a.content = "ABC"
+		a.keep_connection_open
+		a.send_response
+		assert_equal([
+			     "HTTP/1.1 200 ...\r\n",
+			     "Content-length: 3\r\n",
+			     "Content-type: text/plain\r\n",
+			     "\r\n",
+			     "ABC"
+		].join, d.output_data)
+		assert( ! d.closed_after_writing )
+	end
+
+	def test_send_response_multiple_times
+		a = EM::DelegatedHttpResponse.new( D.new )
+		a.status = 200
+		a.send_response
+		assert_raise( RuntimeError ) {
+			a.send_response
+		}
+	end
+
+	def test_send_headers
+		d = D.new
+		a = EM::DelegatedHttpResponse.new( d )
+		a.status = 200
+		a.send_headers
+		assert_equal([
+			     "HTTP/1.1 200 ...\r\n",
+			     "Content-length: 0\r\n",
+			     "\r\n"
+		].join, d.output_data)
+		assert( ! d.closed_after_writing )
+		assert_raise( RuntimeError ) {
+			a.send_headers
+		}
+	end
+
+	def test_send_chunks
+		d = D.new
+		a = EM::DelegatedHttpResponse.new( d )
+		a.chunk "ABC"
+		a.chunk "DEF"
+		a.chunk "GHI"
+		a.keep_connection_open
+		a.send_response
+		assert_equal([
+			     "HTTP/1.1 200 ...\r\n",
+			     "Transfer-encoding: chunked\r\n",
+			     "\r\n",
+			     "3\r\n",
+			     "ABC\r\n",
+			     "3\r\n",
+			     "DEF\r\n",
+			     "3\r\n",
+			     "GHI\r\n",
+			     "0\r\n",
+			     "\r\n"
+		].join, d.output_data)
+		assert( !d.closed_after_writing )
+	end
+
+	def test_send_chunks_with_close
+		d = D.new
+		a = EM::DelegatedHttpResponse.new( d )
+		a.chunk "ABC"
+		a.chunk "DEF"
+		a.chunk "GHI"
+		a.send_response
+		assert_equal([
+			     "HTTP/1.1 200 ...\r\n",
+			     "Transfer-encoding: chunked\r\n",
+			     "\r\n",
+			     "3\r\n",
+			     "ABC\r\n",
+			     "3\r\n",
+			     "DEF\r\n",
+			     "3\r\n",
+			     "GHI\r\n",
+			     "0\r\n",
+			     "\r\n"
+		].join, d.output_data)
+		assert( d.closed_after_writing )
+	end
+
+end
+
+
+

data/test/test_response.rb

@@ -0,0 +1,242 @@
+require 'test/unit'
+require 'em-http-server'
+
+begin
+  once = false
+  require 'eventmachine'
+rescue LoadError => e
+  raise e if once
+  once = true
+  require 'rubygems'
+  retry
+end
+
+
+#--------------------------------------
+
+module EventMachine
+
+  # This is a test harness wired into the HttpResponse class so we
+  # can test it without requiring any actual network communication.
+  #
+  class HttpResponse
+    attr_reader :output_data
+    attr_reader :closed_after_writing
+
+    def send_data data
+      @output_data ||= ""
+      @output_data << data
+    end
+    def close_connection_after_writing
+      @closed_after_writing = true
+    end
+  end
+end
+
+#--------------------------------------
+
+
+class TestHttpResponse < Test::Unit::TestCase
+
+  def test_properties
+    a = EventMachine::HttpResponse.new
+    a.status = 200
+    a.content = "Some content"
+    a.headers["Content-type"] = "text/xml"
+  end
+
+  def test_header_sugarings
+    a = EventMachine::HttpResponse.new
+    a.content_type "text/xml"
+    a.set_cookie "a=b"
+    a.headers["X-bayshore"] = "aaaa"
+
+    assert_equal({
+      "Content-type" => "text/xml",
+      "Set-cookie" => ["a=b"],
+      "X-bayshore" => "aaaa"
+    }, a.headers)
+  end
+
+  def test_send_response
+    a = EventMachine::HttpResponse.new
+    a.status = 200
+    a.send_response
+    assert_equal([
+           "HTTP/1.1 200 ...\r\n",
+           "Content-length: 0\r\n",
+           "\r\n"
+    ].join, a.output_data)
+    assert_equal( true, a.closed_after_writing )
+  end
+
+  def test_send_response_with_status
+    a = EventMachine::HttpResponse.new
+    a.status = 200
+    a.status_string = "OK-TEST"
+    a.send_response
+    assert_equal([
+           "HTTP/1.1 200 OK-TEST\r\n",
+           "Content-length: 0\r\n",
+           "\r\n"
+    ].join, a.output_data)
+    assert_equal( true, a.closed_after_writing )
+  end
+
+  def test_send_response_1
+    a = EventMachine::HttpResponse.new
+    a.status = 200
+    a.content_type "text/plain"
+    a.content = "ABC"
+    a.send_response
+    assert_equal([
+           "HTTP/1.1 200 ...\r\n",
+           "Content-length: 3\r\n",
+           "Content-type: text/plain\r\n",
+           "\r\n",
+           "ABC"
+    ].join, a.output_data)
+    assert( a.closed_after_writing )
+  end
+
+  def test_send_response_no_close
+    a = EventMachine::HttpResponse.new
+    a.status = 200
+    a.content_type "text/plain"
+    a.content = "ABC"
+    a.keep_connection_open
+    a.send_response
+    assert_equal([
+           "HTTP/1.1 200 ...\r\n",
+           "Content-length: 3\r\n",
+           "Content-type: text/plain\r\n",
+           "\r\n",
+           "ABC"
+    ].join, a.output_data)
+    assert( ! a.closed_after_writing )
+  end
+
+  def test_send_response_no_close_with_a_404_response
+    a = EventMachine::HttpResponse.new
+    a.status = 404
+    a.content_type "text/plain"
+    a.content = "ABC"
+    a.keep_connection_open
+    a.send_response
+    assert_equal([
+           "HTTP/1.1 404 ...\r\n",
+           "Content-length: 3\r\n",
+           "Content-type: text/plain\r\n",
+           "\r\n",
+           "ABC"
+    ].join, a.output_data)
+    assert( ! a.closed_after_writing )
+  end
+
+  def test_send_response_no_close_with_a_201_response
+    a = EventMachine::HttpResponse.new
+    a.status = 201
+    a.content_type "text/plain"
+    a.content = "ABC"
+    a.keep_connection_open
+    a.send_response
+    assert_equal([
+           "HTTP/1.1 201 ...\r\n",
+           "Content-length: 3\r\n",
+           "Content-type: text/plain\r\n",
+           "\r\n",
+           "ABC"
+    ].join, a.output_data)
+    assert( ! a.closed_after_writing )
+  end
+
+  def test_send_response_no_close_with_a_500_response
+    a = EventMachine::HttpResponse.new
+    a.status = 500
+    a.content_type "text/plain"
+    a.content = "ABC"
+    a.keep_connection_open
+    a.send_response
+    assert_equal([
+           "HTTP/1.1 500 ...\r\n",
+           "Content-length: 3\r\n",
+           "Content-type: text/plain\r\n",
+           "\r\n",
+           "ABC"
+    ].join, a.output_data)
+    assert( a.closed_after_writing )
+  end
+
+  def test_send_response_multiple_times
+    a = EventMachine::HttpResponse.new
+    a.status = 200
+    a.send_response
+    assert_raise( RuntimeError ) {
+      a.send_response
+    }
+  end
+
+  def test_send_headers
+    a = EventMachine::HttpResponse.new
+    a.status = 200
+    a.send_headers
+    assert_equal([
+           "HTTP/1.1 200 ...\r\n",
+           "Content-length: 0\r\n",
+           "\r\n"
+    ].join, a.output_data)
+    assert( ! a.closed_after_writing )
+    assert_raise( RuntimeError ) {
+      a.send_headers
+    }
+  end
+
+  def test_send_chunks
+    a = EventMachine::HttpResponse.new
+    a.chunk "ABC"
+    a.chunk "DEF"
+    a.chunk "GHI"
+    a.keep_connection_open
+    a.send_response
+    assert_equal([
+           "HTTP/1.1 200 ...\r\n",
+           "Transfer-encoding: chunked\r\n",
+           "\r\n",
+           "3\r\n",
+           "ABC\r\n",
+           "3\r\n",
+           "DEF\r\n",
+           "3\r\n",
+           "GHI\r\n",
+           "0\r\n",
+           "\r\n"
+    ].join, a.output_data)
+    assert( !a.closed_after_writing )
+  end
+
+  def test_send_chunks_with_close
+    a = EventMachine::HttpResponse.new
+    a.chunk "ABC"
+    a.chunk "DEF"
+    a.chunk "GHI"
+    a.send_response
+    assert_equal([
+           "HTTP/1.1 200 ...\r\n",
+           "Transfer-encoding: chunked\r\n",
+           "\r\n",
+           "3\r\n",
+           "ABC\r\n",
+           "3\r\n",
+           "DEF\r\n",
+           "3\r\n",
+           "GHI\r\n",
+           "0\r\n",
+           "\r\n"
+    ].join, a.output_data)
+    assert( a.closed_after_writing )
+  end
+
+end
+
+
+

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: em-http-server
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- alor
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &70366152260060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70366152260060
+description: Simple http server for eventmachine
+email:
+- alberto.ornaghi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- em-http-server.gemspec
+- lib/em-http-server.rb
+- lib/em-http-server/response.rb
+- lib/em-http-server/server.rb
+- test/test_app.rb
+- test/test_delegated.rb
+- test/test_response.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Simple http server for eventmachine with the same interface as evma_httpserver
+test_files:
+- test/test_app.rb
+- test/test_delegated.rb
+- test/test_response.rb