hayabusa 0.0.11 → 0.0.12

data/lib/hayabusa_fcgi.rb

@@ -119,7 +119,7 @@ class Hayabusa::Fcgi
           else
             self.handle_fcgi_request(:cgi => cgi)
           end
-        rescue Errno::ECONNABORTED
+        rescue Errno::ECONNABORTED, Errno::ECONNREFUSED
           $stderr.puts "[hayabusa] Connection to server was interrupted - trying again."
           @fcgi_proxy = nil #Force re-evaluate if this process should be host or proxy.
           retry
@@ -141,6 +141,7 @@ class Hayabusa::Fcgi
         end
       end
     ensure
+      $stderr.puts "[hayabusa] FCGI-loop stopped."
       @hayabusa.stop if @hayabusa
     end
   end

data/lib/hayabusa_http_server.rb

@@ -23,17 +23,17 @@ class Hayabusa::Http_server
       loop do
         begin
           if !@server or @server.closed?
-            STDOUT.puts "Starting TCPServer." if @debug
+            @hb.log_puts "Starting TCPServer." if @debug
             @server = TCPServer.new(@hb.config[:host], @hb.config[:port])
           end
           
-          STDOUT.puts "Trying to spawn new HTTP-session from socket-accept." if @debug
+          @hb.log_puts "Trying to spawn new HTTP-session from socket-accept." if @debug
           self.spawn_httpsession(@server.accept)
-          STDOUT.puts "Starting new HTTP-request." if @debug
+          @hb.log_puts "Starting new HTTP-request." if @debug
         rescue Exception => e
           if @debug
-            STDOUT.puts Knj::Errors.error_str(e)
-            STDOUT.print "Could not accept HTTP-request - waiting 1 sec and then trying again.\n"
+            @hb.log_puts Knj::Errors.error_str(e)
+            @hb.log_puts "Could not accept HTTP-request - waiting 1 sec and then trying again."
           end
           
           raise e if e.is_a?(SystemExit) or e.is_a?(Interrupt)
@@ -44,23 +44,29 @@ class Hayabusa::Http_server
   end
   
   def stop
-    STDOUT.print "Stopping accept-thread.\n" if @debug
+    while @working_count > 0
+      @hb.log_puts "Waiting until no HTTP-sessions are running." if @debug
+      sleep 0.1
+    end
+    
+    
+    @hb.log_puts "Stopping accept-thread." if @debug
     @thread_accept.kill if @thread_accept and @thread_accept.alive?
     @thread_restart.kill if @thread_restart and @thread_restart.alive?
     
-    STDOUT.print "Stopping all HTTP sessions.\n" if @debug
-    if @http_sessions
-      @http_sessions.each do |httpsession|
-        httpsession.destruct
-      end
-    end
+    #@hb.log_puts "Stopping all HTTP sessions." if @debug
+    #if @http_sessions
+    #  @http_sessions.each do |httpsession|
+    #    httpsession.destruct
+    #  end
+    #end
     
     begin
-      STDOUT.print "Stopping TCPServer.\n" if @debug
+      @hb.log_puts "Stopping TCPServer." if @debug
       @server.close if @server and !@server.closed?
-      STDOUT.print "TCPServer was closed.\n" if @debug
+      @hb.log_puts "TCPServer was closed." if @debug
     rescue Timeout::Error
-      raise "Could not close TCPserver.\n"
+      raise "Could not close TCPserver."
     rescue IOError => e
       if e.message == "closed stream"
         #ignore - it should be closed.
@@ -78,7 +84,7 @@ class Hayabusa::Http_server
   end
   
   def spawn_httpsession(socket)
-    STDOUT.puts "Starting new HTTP-session." if @debug
+    @hb.log_puts "Starting new HTTP-session." if @debug
     @http_sessions << Hayabusa::Http_session.new(self, socket)
   end
   

data/lib/hayabusa_http_session.rb

@@ -1,8 +1,5 @@
 #This class handels the HTTP-sessions.
-class Hayabusa::Http_session
-  attr_accessor :data, :alert_sent
-  attr_reader :cookie, :get, :headers, :ip, :session, :session_id, :session_hash, :hb, :active, :out, :eruby, :browser, :debug, :resp, :page_path, :post, :cgroup, :meta, :httpsession_var, :handler, :working
-  
+class Hayabusa::Http_session < Hayabusa::Client_session
   #Autoloader for subclasses.
   def self.const_missing(name)
     require "#{File.dirname(__FILE__)}/hayabusa_http_session_#{name.to_s.downcase}.rb"
@@ -48,7 +45,7 @@ class Hayabusa::Http_session
       "SERVER_PORT" => addr_peer[1]
     }
     
-    @resp = Hayabusa::Http_session::Response.new(:socket => @socket)
+    @resp = Hayabusa::Http_session::Response.new(:hb => @hb, :socket => @socket)
     @handler = Hayabusa::Http_session::Request.new(:hb => @hb, :httpsession => self)
     @cgroup = Hayabusa::Http_session::Contentgroup.new(:socket => @socket, :hb => @hb, :resp => @resp, :httpsession => self)
     @resp.cgroup = @cgroup
@@ -134,53 +131,6 @@ class Hayabusa::Http_session
     end
   end
   
-  #Creates a new Hayabusa::Binding-object and returns the binding for that object.
-  def create_binding
-    binding_obj = Hayabusa::Http_session::Page_environment.new(:httpsession => self, :hb => @hb)
-    return binding_obj.get_binding
-  end
-  
-  #Is called when content is added and begings to write the output if it goes above the limit.
-  def add_size(size)
-    @written_size += size
-    @cgroup.write_output if @written_size >= @size_send
-  end
-  
-  def threadded_content(block)
-    raise "No block was given." if !block
-    cgroup = Thread.current[:hayabusa][:contentgroup].new_thread
-    
-    Thread.new do
-      begin
-        self.init_thread
-        cgroup.register_thread
-        
-        @hb.db_handler.get_and_register_thread if @hb and @hb.db_handler.opts[:threadsafe]
-        @hb.ob.db.get_and_register_thread if @hb and @hb.ob.db.opts[:threadsafe]
-        
-        block.call
-      rescue Exception => e
-        Thread.current[:hayabusa][:contentgroup].write Knj::Errors.error_str(e, {:html => true})
-        _hb.handle_error(e)
-      ensure
-        Thread.current[:hayabusa][:contentgroup].mark_done
-        @hb.ob.db.free_thread if @hb and @hb.ob.db.opts[:threadsafe]
-        @hb.db_handler.free_thread if @hb and @hb.db_handler.opts[:threadsafe]
-      end
-    end
-  end
-  
-  def init_thread
-    Thread.current[:hayabusa] = {} if !Thread.current[:hayabusa]
-    Thread.current[:hayabusa][:hb] = @hb
-    Thread.current[:hayabusa][:httpsession] = self
-    Thread.current[:hayabusa][:session] = @session
-    Thread.current[:hayabusa][:get] = @get
-    Thread.current[:hayabusa][:post] = @post
-    Thread.current[:hayabusa][:meta] = @meta
-    Thread.current[:hayabusa][:cookie] = @cookie
-  end
-  
   def self.finalize(id)
     @hb.log_puts "Http_session finalize #{id}." if @debug
   end
@@ -202,11 +152,6 @@ class Hayabusa::Http_session
     @thread_request.kill if @thread_request.alive?
   end
   
-  #Forces the content to be the input - nothing else can be added after calling this.
-  def force_content(newcont)
-    @cgroup.force_content(newcont)
-  end
-  
   def serve
     @hb.log_puts "Generating meta, cookie, get, post and headers." if @debug
     @meta = @handler.meta.merge(@socket_meta)
@@ -287,70 +232,7 @@ class Hayabusa::Http_session
     Thread.current[:hayabusa][:contentgroup] = @cgroup
     time_start = Time.now.to_f if @debug
     
-    begin
-      @hb.events.call(:request_begin, :httpsession => self) if @hb.events
-      
-      Timeout.timeout(@hb.config[:timeout]) do
-        if @handlers_cache.key?(@ext)
-          @hb.log_puts "Calling handler." if @debug
-          @handlers_cache[@ext].call(self)
-        else
-          #check if we should use a handler for this request.
-          @config[:handlers].each do |handler_info|
-            if handler_info.key?(:file_ext) and handler_info[:file_ext] == @ext
-              return handler_info[:callback].call(self)
-            elsif handler_info.key?(:path) and handler_info[:mount] and @meta["SCRIPT_NAME"].slice(0, handler_info[:path].length) == handler_info[:path]
-              @page_path = "#{handler_info[:mount]}#{@meta["SCRIPT_NAME"].slice(handler_info[:path].length, @meta["SCRIPT_NAME"].length)}"
-              break
-            end
-          end
-          
-          if !File.exists?(@page_path)
-            @resp.status = 404
-            @resp.header("Content-Type", "text/html")
-            @cgroup.write("File you are looking for was not found: '#{@meta["REQUEST_URI"]}'.")
-          else
-            if @headers["cache-control"] and @headers["cache-control"][0]
-              cache_control = {}
-              @headers["cache-control"][0].scan(/(.+)=(.+)/) do |match|
-                cache_control[match[1]] = match[2]
-              end
-            end
-            
-            cache_dont = true if cache_control and cache_control.key?("max-age") and cache_control["max-age"].to_i <= 0
-            lastmod = File.mtime(@page_path)
-            
-            @resp.header("Last-Modified", lastmod.httpdate)
-            @resp.header("Expires", (Time.now + 86400).httpdate) #next day.
-            
-            if !cache_dont and @headers["if-modified-since"] and @headers["if-modified-since"][0]
-              request_mod = Datet.in(@headers["if-modified-since"].first).time
-              
-              if request_mod == lastmod
-                @resp.status = 304
-                return nil
-              end
-            end
-            
-            @cgroup.new_io(:type => :file, :path => @page_path)
-          end
-        end
-      end
-    rescue SystemExit
-      #do nothing - ignore.
-    rescue Timeout::Error
-      @resp.status = 500
-      print "The request timed out."
-    end
-    
-    @cgroup.mark_done
-    @cgroup.write_output
-    @hb.log_puts "#{__id__} - Served '#{@meta["REQUEST_URI"]}' in #{Time.now.to_f - time_start} secs (#{@resp.status})." if @debug
-    @cgroup.join
-    
-    @hb.events.call(:request_done, {
-      :httpsession => self
-    }) if @hb.events
-    @httpsession_var = {}
+    self.execute_page
+    self.execute_done
   end
 end

data/lib/hayabusa_http_session_request.rb

@@ -70,7 +70,7 @@ class Hayabusa::Http_session::Request
     uri_raw = match[2]
     uri_raw = "index.rhtml" if uri_raw == ""
     
-    uri = Knj::Web.parse_uri(match[2])
+    uri = Knj::Web.parse_uri(match[2]) rescue {:path => match[2], :query => ""}
     
     page_filepath = Knj::Web.urldec(uri[:path])
     if page_filepath.empty? or page_filepath == "/" or File.directory?("#{@hb.config[:doc_root]}/#{page_filepath}")

data/lib/hayabusa_http_session_response.rb

@@ -28,6 +28,7 @@ class Hayabusa::Http_session::Response
   def initialize(args)
     @chunked = false
     @socket = args[:socket]
+    @hb = args[:hb]
   end
   
   def reset(args)
@@ -142,7 +143,7 @@ class Hayabusa::Http_session::Response
     end
     
     if @close and @mode != :cgi
-      _hb.log_puts("Closing socket.")
+      @hb.log_puts("Closing socket.")
       @socket.close
     end
   end

data/pages/config_cgi.rb

@@ -0,0 +1,19 @@
+Hayabusa::CGI_CONF = {
+  :hayabusa => {
+    :title => "Cgi_test",
+    :doc_root => File.realpath(File.dirname(__FILE__)),
+    :handlers_extra => [{
+      :regex => /^\/Kasper$/,
+      :callback => proc{|data|
+        data[:httpsession].page_path = nil
+        
+        eruby = data[:httpsession].eruby
+        eruby.connect(:on_error) do |e|
+          _hb.handle_error(e)
+        end
+        
+        eruby.import("#{File.dirname(__FILE__)}/../pages/spec.rhtml")
+      }
+    }]
+  }
+}

data/pages/config_fcgi.rb

@@ -0,0 +1,19 @@
+Hayabusa::FCGI_CONF = {
+  :hayabusa => {
+    :title => "Fcgi_test",
+    :doc_root => File.realpath(File.dirname(__FILE__)),
+    :handlers_extra => [{
+      :regex => /^\/Kasper$/,
+      :callback => proc{|data|
+        data[:httpsession].page_path = nil
+        
+        eruby = data[:httpsession].eruby
+        eruby.connect(:on_error) do |e|
+          _hb.handle_error(e)
+        end
+        
+        eruby.import("#{File.dirname(__FILE__)}/../pages/spec.rhtml")
+      }
+    }]
+  }
+}

data/spec/fcgi_multiple_processes_spec.rb

@@ -24,7 +24,7 @@ describe "Hayabusa" do
           
           Http2.new(:host => "localhost", :user_agent => "Client#{t_i}", :debug => false) do |http|
             1.upto(25) do |request_i|
-              res = http.get(:url => "hayabusa_fcgi_test/multiple_threads.rhtml")
+              res = http.get(:url => "hayabusa_fcgi_test/spec_multiple_threads.rhtml")
               
               begin
                 data_json = JSON.parse(res.body)
@@ -84,11 +84,11 @@ describe "Hayabusa" do
         res2 = nil
         
         t1 = Thread.new do
-          res1 = http1.get(:url => "hayabusa_fcgi_test/sleeper.rhtml")
+          res1 = http1.get(:url => "hayabusa_fcgi_test/spec_sleeper.rhtml")
         end
         
         t2 = Thread.new do
-          res2 = http2.get(:url => "hayabusa_fcgi_test/sleeper.rhtml")
+          res2 = http2.get(:url => "hayabusa_fcgi_test/spec_sleeper.rhtml")
         end
         
         t1.join

data/spec/hayabusa_spec.rb

@@ -4,8 +4,10 @@ describe "Hayabusa" do
   it "should be able to start a sample-server" do
     require "rubygems"
     require "hayabusa"
-    require "knjrbfw"
+    require "/home/kaspernj/Dev/Ruby/Gems/knjrbfw/lib/knjrbfw.rb"
     require "sqlite3" if RUBY_ENGINE != "jruby"
+    require "json"
+    Knj.gem_require(:Http2, "http2")
     
     db_path = "#{Knj::Os.tmpdir}/hayabusa_rspec.sqlite3"
     File.unlink(db_path) if File.exists?(db_path)
@@ -29,45 +31,82 @@ describe "Hayabusa" do
       }
     )
     
+    $appserver.config[:handlers] << {
+      :regex => /^\/Kasper$/,
+      :callback => proc{|data|
+        data[:httpsession].page_path = nil
+        
+        eruby = data[:httpsession].eruby
+        eruby.connect(:on_error) do |e|
+          _hb.handle_error(e)
+        end
+        
+        eruby.import("#{File.dirname(__FILE__)}/../pages/spec.rhtml")
+      }
+    }
+    
     $appserver.vars[:test] = "kasper"
     $appserver.define_magic_var(:_testvar1, "Kasper")
     $appserver.define_magic_var(:_testvar2, "Johansen")
     $appserver.start
     
     raise "Expected thread-pool-priority to be '-3' but it wasnt: '#{$appserver.threadpool.args[:priority]}'." if $appserver.threadpool.args[:priority] != -3
+    
+    http = Http2.new(:host => "localhost", :port => 80)
+    
+    $testmodes = [{
+      :name => :standalone,
+      :path_pre => "",
+      :http => Http2.new(:host => "localhost", :port => 1515)
+    },{
+      :name => :cgi,
+      :path_pre => "hayabusa_cgi_test/",
+      :http => http
+    },{
+      :name => :fcgi,
+      :path_pre => "hayabusa_fcgi_test/",
+      :http => http
+    }]
   end
   
+  #it "should be able to handle custom urls" do
+  #  $testmodes.each do |tdata|
+  #    res = tdata[:http].get("#{tdata[:path_pre]}Kasper")
+  #    raise "Expected data to be 'Test' in mode '#{tdata[:name]}' but it wasnt: '#{res.body}'." if res.body != "Test"
+  #  end
+  #end
+  
   it "should be able to handle a GET-request." do
-    #Check that we are able to perform a simple GET request and get the correct data back.
-    require "http2"
-    $http = Http2.new(:host => "localhost", :port => 1515)
-    
-    res = $http.get("spec.rhtml")
-    raise "Unexpected HTML: '#{res.body}'." if res.body.to_s != "Test"
-    
-    #Check that URL-decoding are being done.
-    res = $http.get("spec.rhtml?choice=check_get_parse&value=#{Knj::Web.urlenc("gfx/nopic.png")}")
-    raise "Unexpected HTML: '#{res.body}'." if res.body.to_s != "gfx/nopic.png"
+    $testmodes.each do |tdata|
+      res = tdata[:http].get("#{tdata[:path_pre]}spec.rhtml")
+      raise "Unexpected HTML: '#{res.body}'." if res.body.to_s != "Test"
+      
+      #Check that URL-decoding are being done.
+      res = tdata[:http].get("#{tdata[:path_pre]}spec.rhtml?choice=check_get_parse&value=#{Knj::Web.urlenc("gfx/nopic.png")}")
+      raise "Unexpected HTML: '#{res.body}'." if res.body.to_s != "gfx/nopic.png"
+    end
   end
   
   it "should be able to handle a HEAD-request." do
     #Http2 doesnt support head?
-    #res = $http.head("/spec.rhtml")
+    #res = $http.head("spec.rhtml")
     #raise "HEAD-request returned content - it shouldnt?" if res.body.to_s.length > 0
   end
   
   it "should be able to handle a POST-request." do
-    res = $http.post(:url => "spec.rhtml", :post => {
-      "postdata" => "Test post"
-    })
-    raise "POST-request did not return expected data: '#{res.body}'." if res.body.to_s.strip != "Test post"
-    
-    res = $http.post(:url => "spec.rhtml?choice=dopostconvert", :post => {
-      "postdata" => "Test post",
-      "array" => ["a", "b", "d"]
-    })
-    data = JSON.parse(res.body)
-    raise "Expected posted data restored but it wasnt: '#{data}'." if data["array"]["0"] != "a" or data["array"]["1"] != "b" or data["array"]["2"] != "d"
+    $testmodes.each do |tdata|
+      res = tdata[:http].post(:url => "#{tdata[:path_pre]}spec.rhtml", :post => {
+        "postdata" => "Test post"
+      })
+      raise "POST-request did not return expected data: '#{res.body}' for '#{tdata[:name]}'." if res.body.to_s.strip != "Test post"
+      
+      res = tdata[:http].post(:url => "#{tdata[:path_pre]}spec.rhtml?choice=dopostconvert", :post => {
+        "postdata" => "Test post",
+        "array" => ["a", "b", "d"]
+      })
+      data = JSON.parse(res.body)
+      raise "Expected posted data restored but it wasnt: '#{data}'." if data["array"]["0"] != "a" or data["array"]["1"] != "b" or data["array"]["2"] != "d"
+    end
   end
   
   it "should be able to join the server so other tests can be made manually." do
@@ -82,30 +121,31 @@ describe "Hayabusa" do
   end
   
   it "should be able to use the header-methods." do
-    res = $http.get("spec.rhtml")
-    raise "Normal header data could not be detected." if res.header("testheader") != "NormalHeader"
-    raise "Raw header data could not be detected." if res.header("testraw") != "RawHeader"
+    $testmodes.each do |tdata|
+      res = tdata[:http].get("#{tdata[:path_pre]}spec.rhtml")
+      raise "Normal header data could not be detected." if res.header("testheader") != "NormalHeader"
+      raise "Raw header data could not be detected." if res.header("testraw") != "RawHeader"
+    end
   end
   
   it "should be able to set and get multiple cookies at the same time." do
-    require "json"
-    
-    res = $http.get("spec.rhtml?choice=test_cookie")
-    raise res.body if res.body.to_s.length > 0
-    
-    res = $http.get("spec.rhtml?choice=get_cookies")
-    parsed = JSON.parse(res.body)
-    
-    raise "Unexpected value for 'TestCookie': '#{parsed["TestCookie"]}'." if parsed["TestCookie"] != "TestValue"
-    raise "Unexpected value for 'TestCookie2': '#{parsed["TestCookie2"]}'." if parsed["TestCookie2"] != "TestValue2"
-    raise "Unexpected value for 'TestCookie3': '#{parsed["TestCookie3"]}'." if parsed["TestCookie3"] != "TestValue 3 "
+    $testmodes.each do |tdata|
+      res = tdata[:http].get("#{tdata[:path_pre]}spec.rhtml?choice=test_cookie")
+      raise res.body if res.body.to_s.length > 0
+      
+      res = tdata[:http].get("#{tdata[:path_pre]}spec.rhtml?choice=get_cookies")
+      parsed = JSON.parse(res.body)
+      
+      raise "Unexpected value for 'TestCookie': '#{parsed["TestCookie"]}'." if parsed["TestCookie"] != "TestValue"
+      raise "Unexpected value for 'TestCookie2': '#{parsed["TestCookie2"]}'." if parsed["TestCookie2"] != "TestValue2"
+      raise "Unexpected value for 'TestCookie3': '#{parsed["TestCookie3"]}'." if parsed["TestCookie3"] != "TestValue 3 "
+    end
   end
   
   it "should be able to run the rspec_threadded_content test correctly." do
-    res = $http.get("spec_threadded_content.rhtml")
-    
-    if res.body != "12345678910"
-      raise res.body.to_s
+    $testmodes.each do |tdata|
+      res = tdata[:http].get("#{tdata[:path_pre]}spec_threadded_content.rhtml")
+      raise "Expected body to be '12345678910' for mode '#{tdata[:name]}' but it wasnt: '#{res.body.to_s}'." if res.body.to_s != "12345678910"
     end
   end
   
@@ -145,15 +185,20 @@ describe "Hayabusa" do
   end
   
   it "should be able to join threads tarted from _hb.thread." do
-    res = $http.get("spec_thread_joins.rhtml")
-    raise res.body if res.body.to_s != "12345"
+    $testmodes.each do |tdata|
+      res = tdata[:http].get("#{tdata[:path_pre]}spec_thread_joins.rhtml")
+      raise res.body if res.body.to_s != "12345"
+    end
   end
   
   it "should be able to properly parse special characters in post-requests." do
-    res = $http.post(:url => "spec_post.rhtml", :post => {
-      "test" => "123+456%789%20"
-    })
-    raise res.body if res.body != "123+456%789%20"
+    $testmodes.each do |tdata|
+      res = tdata[:http].post(:url => "#{tdata[:path_pre]}spec_vars_post.rhtml", :post => {
+        "test" => "123+456%789%20"
+      })
+      data = JSON.parse(res.body)
+      raise res.body if data["test"] != "123+456%789%20"
+    end
   end
   
   it "should be able to do logging" do
@@ -193,6 +238,70 @@ describe "Hayabusa" do
     raise "Expected count to be 0 but got: #{logs.length}" if logs.length != 0
   end
   
+  it "should handle multi-threadding well" do
+    ts = []
+    es = []
+    
+    #Execute multiple threads to test FCGI-proxy and thread-safety.
+    1.upto(5) do
+      $testmodes.each do |tdata|
+        ts << Thread.new do
+          begin
+            res = tdata[:http].post(:url => "#{tdata[:path_pre]}spec_vars_post.rhtml", :post => {
+              "test_special_chars" => "1%23+-456",
+              "var" => {
+                0 => 1,
+                1 => 2,
+                3 => {
+                  "kasper" => 5,
+                  "arr" => ["a", "b", "c"]
+                }
+              }
+            })
+            
+            begin
+              data = JSON.parse(res.body)
+            rescue JSON::GeneratorError
+              raise "Could not parse JSON from result: '#{res.body}'."
+            end
+            
+            begin
+              raise "Expected hash to be a certain way: '#{data}'." if data["var"]["0"] != "1" or data["var"]["1"] != "2" or data["var"]["3"]["kasper"] != "5" or data["var"]["3"]["arr"]["0"] != "a" or data["var"]["3"]["arr"]["1"] != "b"
+            rescue => e
+              raise "Error when parsing result: '#{data}'."
+            end
+            
+            raise "Expected 'test_special_chars' to be '1%23+-456' but it wasnt: '#{data["test_special_chars"]}'." if data["test_special_chars"] != "1%23+-456"
+            
+            res = tdata[:http].get("#{tdata[:path_pre]}spec_threadded_content.rhtml")
+            raise "Expected body to be '12345678910' but it was: '#{res.body}'." if res.body != "12345678910"
+            
+            res = tdata[:http].get("#{tdata[:path_pre]}spec_vars_get.rhtml?var[]=1&var[]=2&var[]=3&var[3][kasper]=5")
+            data = JSON.parse(res.body)
+            raise "Expected hash to be a certain way: '#{data}'." if data["var"]["0"] != "1" or data["var"]["1"] != "2" or data["var"]["3"]["kasper"] != "5"
+            
+            
+            
+            res = tdata[:http].get("#{tdata[:path_pre]}spec_vars_header.rhtml")
+            raise "Expected header 'testheader' to be 'TestValue' but it wasnt: '#{res.header("testheader")}'." if res.header("testheader") != "TestValue"
+          rescue => e
+            es << e
+            puts e.inspect
+            puts e.backtrace
+          end
+        end
+      end
+      
+      ts.each do |t|
+        t.join
+      end
+      
+      es.each do |e|
+        raise e
+      end
+    end
+  end
+  
   it "should be able to stop." do
     $appserver.stop
   end