hayabusa 0.0.11 → 0.0.12

data/Gemfile.lock

@@ -12,7 +12,7 @@ GEM
       git (>= 1.2.5)
       rake
     json (1.7.5)
-    knjrbfw (0.0.94)
+    knjrbfw (0.0.97)
       datet
       http2
       php4r
@@ -37,7 +37,7 @@ GEM
       diff-lcs (~> 1.1.2)
     rspec-mocks (2.3.0)
     sqlite3 (1.3.6)
-    tpool (0.0.3)
+    tpool (0.0.4)
     treetop (1.4.10)
       polyglot
       polyglot (>= 0.3.1)

data/VERSION

@@ -1 +1 @@
-0.0.11
+0.0.12

data/hayabusa.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "hayabusa"
-  s.version = "0.0.11"
+  s.version = "0.0.12"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Kasper Johansen"]
-  s.date = "2012-09-12"
+  s.date = "2012-09-18"
   s.description = "A threadded web/app-server that focuses on threadding, shared ressources, speed and more."
   s.email = "k@spernj.org"
   s.executables = ["check_running.rb", "hayabusa_benchmark.rb", "hayabusa_cgi.rb", "hayabusa_fcgi.fcgi", "hayabusa_fcgi.rb", "knjappserver_start.rb"]
@@ -39,6 +39,7 @@ Gem::Specification.new do |s|
     "lib/hayabusa.rb",
     "lib/hayabusa_cgi_session.rb",
     "lib/hayabusa_cgi_tools.rb",
+    "lib/hayabusa_client_session.rb",
     "lib/hayabusa_custom_io.rb",
     "lib/hayabusa_database.rb",
     "lib/hayabusa_erb_handler.rb",
@@ -74,6 +75,8 @@ Gem::Specification.new do |s|
     "pages/benchmark_print.rhtml",
     "pages/benchmark_simple.rhtml",
     "pages/benchmark_threadded_content.rhtml",
+    "pages/config_cgi.rb",
+    "pages/config_fcgi.rb",
     "pages/debug_database_connections.rhtml",
     "pages/debug_http_sessions.rhtml",
     "pages/debug_memory_usage.rhtml",
@@ -81,30 +84,19 @@ Gem::Specification.new do |s|
     "pages/logs_latest.rhtml",
     "pages/logs_show.rhtml",
     "pages/spec.rhtml",
-    "pages/spec_post.rhtml",
+    "pages/spec_multiple_threads.rhtml",
+    "pages/spec_sleeper.rhtml",
     "pages/spec_test_multiple_clients.rhtml",
     "pages/spec_thread_joins.rhtml",
     "pages/spec_threadded_content.rhtml",
+    "pages/spec_vars_get.rhtml",
+    "pages/spec_vars_header.rhtml",
+    "pages/spec_vars_post.rhtml",
     "pages/tests.rhtml",
-    "spec/cgi_spec.rb",
-    "spec/custom_urls_spec.rb",
+    "pages/threadded_content_test.rhtml",
     "spec/fcgi_multiple_processes_spec.rb",
-    "spec/fcgi_spec.rb",
     "spec/hayabusa_spec.rb",
-    "spec/spec_helper.rb",
-    "tests/cgi_test/config_cgi.rb",
-    "tests/cgi_test/threadded_content_test.rhtml",
-    "tests/cgi_test/vars_get_test.rhtml",
-    "tests/cgi_test/vars_header_test.rhtml",
-    "tests/cgi_test/vars_post_test.rhtml",
-    "tests/fcgi_test/config_fcgi.rb",
-    "tests/fcgi_test/index.rhtml",
-    "tests/fcgi_test/multiple_threads.rhtml",
-    "tests/fcgi_test/sleeper.rhtml",
-    "tests/fcgi_test/threadded_content_test.rhtml",
-    "tests/fcgi_test/vars_get_test.rhtml",
-    "tests/fcgi_test/vars_header_test.rhtml",
-    "tests/fcgi_test/vars_post_test.rhtml"
+    "spec/spec_helper.rb"
   ]
   s.homepage = "http://github.com/kaspernj/hayabusa"
   s.licenses = ["MIT"]

data/lib/hayabusa.rb

@@ -84,6 +84,10 @@ class Hayabusa
       ]
     end
     
+    if @config[:handlers_extra]
+      @config[:handlers] += @config[:handlers_extra]
+    end
+    
     
     #Add extra handlers if given.
     @config[:handlers] += @config[:handlers_extra] if @config[:handlers_extra]
@@ -105,11 +109,15 @@ class Hayabusa
         @debug_log = false
       end
       
-      if !@config.key?(:debug_print) or @config[:debug_print]
+      if @config[:debug_print]
         @debug_print = true
       else
         @debug_print = false
       end
+      
+      if !@config.key?(:debug_print_err) or @config[:debug_print_err]
+        @debug_print_err = true
+      end
     end
     
     @paused = 0
@@ -346,8 +354,20 @@ class Hayabusa
   
   #Outputs to stderr and logs it.
   def log_puts(str)
-    @log_fp.puts str if @debug_log
-    STDOUT.puts str if @debug_print
+    if @debug_log
+      @log_fp.sync = true
+      @log_fp.puts str
+    end
+    
+    if @debug_print
+      STDOUT.sync = true
+      STDOUT.puts str
+    end
+    
+    if @debug_print_err
+      STDERR.sync = true
+      STDERR.puts str
+    end
   end
   
   def no_date(event, classname)

data/lib/hayabusa_cgi_session.rb

@@ -1,6 +1,6 @@
-class Hayabusa::Cgi_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, :working
+class Hayabusa::Cgi_session < Hayabusa::Client_session
+  attr_accessor :alert_sent, :data, :page_path
+  attr_reader :cookie, :get, :headers, :ip, :session, :session_id, :session_hash, :hb, :active, :out, :eruby, :browser, :debug, :resp, :post, :cgroup, :meta, :httpsession_var, :working
   
   def initialize(args)
     @args = args
@@ -105,24 +105,8 @@ class Hayabusa::Cgi_session
     
     
     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
-          raise "CGI-mode shouldnt serve static files: '#{@page_path}'."
-        end
-      end
-      
-      @cgroup.mark_done
-      @cgroup.write_output
-      @cgroup.join
-      
-      @hb.events.call(:request_done, {
-        :httpsession => self
-      }) if @hb.events
+      self.execute_page
+      self.execute_done
     rescue SystemExit
       #do nothing - ignore.
     rescue Timeout::Error
@@ -134,74 +118,4 @@ class Hayabusa::Cgi_session
   def handler
     return self
   end
-  
-  #Parses the if-modified-since header and returns it as a Time-object. Returns false is no if-modified-since-header is given or raises an RuntimeError if it cant be parsed.
-  def modified_since
-    return @modified_since if @modified_since
-    return false if !@meta["HTTP_IF_MODIFIED_SINCE"]
-    
-    mod_match = @meta["HTTP_IF_MODIFIED_SINCE"].match(/^([A-z]+),\s+(\d+)\s+([A-z]+)\s+(\d+)\s+(\d+):(\d+):(\d+)\s+(.+)$/)
-    raise "Could not parse 'HTTP_IF_MODIFIED_SINCE'." if !mod_match
-    
-    month_no = Datet.month_str_to_no(mod_match[3])
-    @modified_since = Time.utc(mod_match[4].to_i, month_no, mod_match[2].to_i, mod_match[5].to_i, mod_match[6].to_i, mod_match[7].to_i)
-    
-    return @modified_since
-  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
-  
-  #Creates a new Hayabusa::Binding-object and returns the binding for that object.
-  def create_binding
-    return Hayabusa::Http_session::Page_environment.new(:httpsession => self, :hb => @hb).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
-  
-  #Called from content-group.
-  def write(str)
-    @out.print(str)
-  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] = {
-      :hb => @hb,
-      :httpsession => self,
-      :get => @get,
-      :post => @post,
-      :meta => @meta,
-      :cookie => @cookie
-    }
-  end
 end

data/lib/hayabusa_cgi_tools.rb

@@ -71,8 +71,11 @@ class Hayabusa::Cgi_tools
     
     fp_log.puts("Proxying URL: '#{url}'.") if fp_log
     
-    require "timeout"
-    Timeout.timeout(ttime) do
+    #The HTTP-connection can have closed mean while, so we have to test it.
+    raise Errno::ECONNABORTED if !http.socket_working?
+    
+    #require "timeout"
+    #Timeout.timeout(ttime) do
       if cgi.request_method == "POST" and cgi.content_type.to_s.downcase.index("multipart/form-data") != nil
         count = 0
         http.post_multipart(
@@ -109,6 +112,6 @@ class Hayabusa::Cgi_tools
           }
         )
       end
-    end
+    #end
   end
 end

data/lib/hayabusa_client_session.rb

@@ -0,0 +1,151 @@
+#Various client-sessions should extend this class.
+class Hayabusa::Client_session
+  attr_accessor :alert_sent, :data, :page_path
+  attr_reader :cookie, :get, :headers, :ip, :session, :session_id, :session_hash, :hb, :active, :out, :eruby, :browser, :debug, :resp, :post, :cgroup, :meta, :httpsession_var, :working
+  
+  #Parses the if-modified-since header and returns it as a Time-object. Returns false is no if-modified-since-header is given or raises an RuntimeError if it cant be parsed.
+  def modified_since
+    return @modified_since if @modified_since
+    return false if !@meta["HTTP_IF_MODIFIED_SINCE"]
+    
+    mod_match = @meta["HTTP_IF_MODIFIED_SINCE"].match(/^([A-z]+),\s+(\d+)\s+([A-z]+)\s+(\d+)\s+(\d+):(\d+):(\d+)\s+(.+)$/)
+    raise "Could not parse 'HTTP_IF_MODIFIED_SINCE'." if !mod_match
+    
+    month_no = Datet.month_str_to_no(mod_match[3])
+    @modified_since = Time.utc(mod_match[4].to_i, month_no, mod_match[2].to_i, mod_match[5].to_i, mod_match[6].to_i, mod_match[7].to_i)
+    
+    return @modified_since
+  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
+  
+  #Creates a new Hayabusa::Binding-object and returns the binding for that object.
+  def create_binding
+    return Hayabusa::Http_session::Page_environment.new(:httpsession => self, :hb => @hb).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
+  
+  #Called from content-group.
+  def write(str)
+    @out.print(str)
+  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 execute_page
+    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
+              handler_info[:callback].call(self)
+              break
+            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
+            elsif handler_info.key?(:regex) and @meta["REQUEST_URI"].to_s.match(handler_info[:regex])
+              handler_info[:callback].call(:httpsession => self)
+              break
+            end
+          end
+          
+          if @page_path
+            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
+      end
+    rescue SystemExit
+      #do nothing - ignore.
+    rescue Timeout::Error
+      @resp.status = 500
+      print "The request timed out."
+    end
+  end
+  
+  def execute_done
+    @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 = {}
+  end
+end

data/lib/hayabusa_ext/threadding.rb

@@ -11,8 +11,8 @@ class Hayabusa
   end
   
   #Callback for when an error occurs in the threadpool.
-  def threadpool_on_error(error)
-    self.handle_error(error)
+  def threadpool_on_error(args)
+    self.handle_error(args[:error])
   end
   
   #Inits the thread so it has access to the appserver and various magic methods can be used.
@@ -65,6 +65,23 @@ class Hayabusa
     return thread_obj
   end
   
+  #If a custom thread is spawned, you can run whatever code within this block, and it will have its own database-connection and so on like normal Hayabusa-threads.
+  def thread_block(&block)
+    @ob.db.get_and_register_thread if @ob.db.opts[:threadsafe]
+    @db_handler.get_and_register_thread if @db_handler.opts[:threadsafe]
+    
+    thread = Thread.current
+    thread[:hayabusa] = {} if !thread[:hayabusa]
+    thread[:hayabusa][:hb] = self
+    
+    begin
+      block.call
+    ensure
+      @ob.db.free_thread if @ob.db.opts[:threadsafe]
+      @db_handler.free_thread if @db_handler.opts[:threadsafe]
+    end
+  end
+  
   #Runs a proc every number of seconds.
   def timeout(args = {}, &block)
     return Hayabusa::Threadding_timeout.new({