hayabusa 0.0.13 → 0.0.14

data/VERSION

@@ -1 +1 @@
-0.0.13
+0.0.14

data/bin/hayabusa_fcgi.fcgi

@@ -17,10 +17,9 @@ begin
   require "fileutils"
   
   #Try to load development-version to enable debugging without doing constant gem-installations.
-  path = "/home/kaspernj/Ruby/knjrbfw/lib/knjrbfw.rb"
-  if File.exists?(path)
-    require path
-  else
+  begin
+    require "#{File.realpath(File.dirname(__FILE__))}/../../knjrbfw/lib/knjrbfw.rb"
+  rescue LoadError
     require "knjrbfw"
   end
   

data/bin/hayabusa_fcgi.rb

@@ -17,10 +17,9 @@ begin
   require "fileutils"
   
   #Try to load development-version to enable debugging without doing constant gem-installations.
-  path = "/home/kaspernj/Ruby/knjrbfw/lib/knjrbfw.rb"
-  if File.exists?(path)
-    require path
-  else
+  begin
+    require "#{File.realpath(File.dirname(__FILE__))}/../../knjrbfw/lib/knjrbfw.rb"
+  rescue LoadError
     require "knjrbfw"
   end
   

data/bin/hayabusa_fcgi_server.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+#This script starts the Hayabusa-server that the FCGI-instances will connect- and proxy requests to.
+
+
+#Make stuff instantly printed to speed up.
+$stdout.sync = true
+
+require "rubygems"
+require "#{File.realpath(File.dirname(__FILE__))}/../lib/hayabusa.rb"
+require "base64"
+
+
+#Try to load parent path knjrbfw to allowed developing without updating Gem-installation constantly.
+begin
+  require "#{File.realpath(File.dirname(__FILE__))}/../../knjrbfw/lib/knjrbfw.rb"
+rescue LoadError
+  require "knjrbfw"
+end
+
+
+#Parse given arguments.
+opts = {}
+
+ARGV.each do |val|
+  if match = val.match(/^--(conf_path|fcgi_data_path|title)=(.+)$/)
+    opts[match[1].to_sym] = match[2]
+  else
+    raise "Unknown argument: '#{val}'."
+  end
+end
+
+raise "'conf-path' from arguments could not be found: '#{opts[:conf_path]}'." if !opts[:conf_path] or !File.exists?(opts[:conf_path])
+require opts[:conf_path]
+
+
+#Gemerate Hayabusa-config-hash.
+hayabusa_conf = Hayabusa::FCGI_CONF[:hayabusa]
+hayabusa_conf.merge!(
+  :debug => false,
+  :debug_log => true,
+  :debug_print => false,
+  :debug_print_err => false,
+  :cmdline => false,
+  :mailing_timeout => 1, #Since FCGI might terminate at any time, try to send out mails almost instantly in the background.
+  :port => 0 #Ruby picks random port and we get the actual port after starting the appserver.
+)
+fcgi_server = Hayabusa::Fcgi_server.new(:hayabusa_conf => hayabusa_conf)
+
+
+#Give information about this process to the FCGI-process that spawned us.
+puts Base64.strict_encode64(Marshal.dump(
+  :pid => Process.pid,
+  :port => fcgi_server.hayabusa.port
+))
+
+
+#Join the server and unlink the config-file when it terminates.
+begin
+  fcgi_server.hayabusa.join
+ensure
+  File.unlink(opts[:fcgi_data_path]) if opts[:fcgi_data_path] and File.exists?(opts[:fcgi_data_path])
+end

data/bin/hayabusa_spec_restart.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+#This script is used to restart the FCGI-spec-test servers.
+
+require "rubygems"
+require "php4r"
+
+#Close down the running instance of FCGI-server-process.
+fpath = "/tmp/hayabusa_fcgi_Fcgi_test_fcgi.conf"
+
+if File.exists?(fpath) and fcont = File.read(fpath) and !fcont.empty?
+  cont = Marshal.load(fcont)
+  Process.kill("HUP", cont[:pid])
+end
+
+#Restart apache to restart any FCGI instances.
+Php4r.passthru("apache2ctl restart")

data/hayabusa.gemspec

@@ -5,14 +5,14 @@
 
 Gem::Specification.new do |s|
   s.name = "hayabusa"
-  s.version = "0.0.13"
+  s.version = "0.0.14"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Kasper Johansen"]
-  s.date = "2012-09-20"
+  s.date = "2012-09-30"
   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"]
+  s.executables = ["check_running.rb", "hayabusa_benchmark.rb", "hayabusa_cgi.rb", "hayabusa_fcgi.fcgi", "hayabusa_fcgi.rb", "hayabusa_fcgi_server.rb", "hayabusa_spec_restart.rb", "knjappserver_start.rb"]
   s.extra_rdoc_files = [
     "LICENSE.txt",
     "README.rdoc"
@@ -31,6 +31,8 @@ Gem::Specification.new do |s|
     "bin/hayabusa_cgi.rb",
     "bin/hayabusa_fcgi.fcgi",
     "bin/hayabusa_fcgi.rb",
+    "bin/hayabusa_fcgi_server.rb",
+    "bin/hayabusa_spec_restart.rb",
     "bin/knjappserver_start.rb",
     "conf/apache2_cgi_rhtml_conf.conf",
     "conf/apache2_fcgi_rhtml_conf.conf",
@@ -54,6 +56,7 @@ Gem::Specification.new do |s|
     "lib/hayabusa_ext/translations.rb",
     "lib/hayabusa_ext/web.rb",
     "lib/hayabusa_fcgi.rb",
+    "lib/hayabusa_fcgi_server.rb",
     "lib/hayabusa_http_server.rb",
     "lib/hayabusa_http_session.rb",
     "lib/hayabusa_http_session_contentgroup.rb",

data/lib/hayabusa.rb

@@ -46,8 +46,8 @@ class Hayabusa
     #Require gems.
     require "rubygems"
     gems = [
-      [:Erubis, "erubis"],
       [:Knj, "knjrbfw"],
+      [:Erubis, "erubis"],
       [:Tsafe, "tsafe"],
       [:Tpool, "tpool"]
     ]
@@ -102,22 +102,20 @@ class Hayabusa
     
     
     @debug = @config[:debug]
-    if @debug
-      if !@config.key?(:debug_log) or @config[:debug_log]
-        @debug_log = true
-      else
-        @debug_log = false
-      end
-      
-      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
+    if !@config.key?(:debug_log) or @config[:debug_log]
+      @debug_log = true
+    else
+      @debug_log = false
+    end
+    
+    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
     
     @paused = 0
@@ -299,11 +297,10 @@ class Hayabusa
         :name => :request_begin,
         :connections_max => 1
       )
+      @events.add_event(:name => :http_session_destruct)
       
       #This event is used if the user himself wants stuff to be cleaned up when the appserver is cleaning up stuff.
-      @events.add_event(
-        :name => :on_clean
-      )
+      @events.add_event(:name => :on_clean)
     end
     
     #Set up the 'vars'-variable that can be used to set custom global variables for web-requests.
@@ -345,7 +342,7 @@ class Hayabusa
     end
     
     
-    #Clear memory at exit.
+    #Clear memory, flush emails, flush sessions and more at exit.
     Kernel.at_exit(&self.method(:stop))
     
     
@@ -497,7 +494,7 @@ class Hayabusa
       @httpserv.thread_accept.join
       @httpserv.thread_restart.join if @httpserv and @httpserv.thread_restart
     rescue Interrupt => e
-      STDOUT.puts "Trying to stop because of interrupt - please wait while various data is beging flushed."
+      self.log_puts("Trying to stop because of interrupt - please wait while various data is beging flushed.")
       self.stop
     end
     

data/lib/hayabusa_cgi_tools.rb

@@ -43,11 +43,17 @@ class Hayabusa::Cgi_tools
     
     headers = {"Hayabusa_mode" => "proxy"}
     cgi.env_table.each do |key, val|
-      if key[0, 5] == "HTTP_" and key != "HTTP_HAYABUSA_CGI_CONFIG"
+      keyl = key.to_s.downcase
+      
+      if key[0, 5] == "HTTP_"
         key = key[5, key.length].gsub("_", " ")
         key = key.to_s.split(" ").select{|w| w.capitalize! or w }.join(" ")
         key = key.gsub(" ", "-")
-        headers[key] = val
+        keyl = key.downcase
+        
+        if keyl != "connection" and keyl != "accept-encoding" and keyl != "hayabusa-fcgi-config" and key != "hayabusa-cgi-config"
+          headers[key] = val
+        end
       end
     end
     

data/lib/hayabusa_client_session.rb

@@ -75,6 +75,7 @@ class Hayabusa::Client_session
   
   def execute_page
     begin
+      @time_start = Time.now.to_f if @debug
       @hb.events.call(:request_begin, :httpsession => self) if @hb.events
       
       Timeout.timeout(@hb.config[:timeout]) do
@@ -140,7 +141,8 @@ class Hayabusa::Client_session
   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
+    @hb.log_puts "#{__id__} - Served '#{@meta["REQUEST_URI"]}' in #{Time.now.to_f - @time_start} secs (#{@resp.status})." if @debug
+    @time_start = nil
     @cgroup.join
     
     @hb.events.call(:request_done, {

data/lib/hayabusa_ext/cleaner.rb

@@ -25,11 +25,11 @@ class Hayabusa
         
         if @config.has_key?(:restart_when_used_memory) and !@should_restart
           mbs_used = (Php4r.memory_get_usage / 1024) / 1024
-          STDOUT.print "Restart when over #{@config[:restart_when_used_memory]}mb\n" if @config[:debug]
-          STDOUT.print "Used: #{mbs_used}mb\n" if @config[:debug]
+          self.log_puts("Restart when over #{@config[:restart_when_used_memory]}mb") if @debug
+          self.log_puts("Used: #{mbs_used}mb") if @debug
           
           if mbs_used.to_i >= @config[:restart_when_used_memory].to_i
-            STDOUT.print "Memory is over #{@config[:restart_when_used_memory]} - restarting.\n"
+            self.log_puts("Memory is over #{@config[:restart_when_used_memory]} - restarting.") if @debug
             @should_restart = true
           end
         end
@@ -39,7 +39,7 @@ class Hayabusa
             @should_restart_runnning = true
             
             #When we begin to restart it should go as fast as possible - so start by flushing out any emails waiting so it goes faster the last time...
-            STDOUT.print "Flushing mails.\n"
+            self.log_puts("Flushing mails.") if @debug
             self.mail_flush
             
             #Lets try to find a time where no thread is working within the next 30 seconds. If we cant - we interrupt after 10 seconds and restart the server.
@@ -51,48 +51,48 @@ class Hayabusa
                   
                   if working_count and working_count > 0
                     working = true
-                    STDOUT.print "Someone is working - wait two sec and try to restart again!\n"
+                    self.log_puts("Someone is working - wait two sec and try to restart again!") if @debug
                   end
                   
                   if !working
-                    STDOUT.print "Found window where no sessions were active - restarting!\n"
+                    self.log_puts("Found window where no sessions were active - restarting!") if @debug
                     break
                   else
                     sleep 0.2
                   end
                   
-                  STDOUT.print "Trying to find window with no active sessions to restart...\n"
+                  self.log_puts("Trying to find window with no active sessions to restart...") if @debug
                 end
               end
             rescue Timeout::Error
-              STDOUT.print "Could not find a timing window for restarting... Forcing restart!\n"
+              self.log_puts("Could not find a timing window for restarting... Forcing restart!") if @debug
             end
             
             #Flush emails again if any are pending (while we tried to find a window to restart)...
-            STDOUT.print "Flushing mails.\n"
+            self.log_puts("Flushing mails.") if @debug
             self.mail_flush
             
-            STDOUT.print "Stopping appserver.\n"
+            self.log_puts("Stopping appserver.") if @debug
             self.stop
             
-            STDOUT.print "Figuring out restart-command.\n"
+            self.log_puts("Figuring out restart-command.") if @debug
             mycmd = @config[:restart_cmd]
             
             if !mycmd or mycmd.to_s.strip.length <= 0
               fpath = File.realpath("#{File.dirname(__FILE__)}/../hayabusa.rb")
               mycmd = Knj::Os.executed_cmd
               
-              STDOUT.print "Previous cmd: #{mycmd}\n"
+              self.log_puts("Previous cmd: #{mycmd}") if @debug
               mycmd = mycmd.gsub(/\s+hayabusa.rb/, " #{Knj::Strings.unixsafe(fpath)}")
             end
             
-            STDOUT.print "Restarting knjAppServer with command: #{mycmd}\n"
+            self.log_puts("Restarting knjAppServer with command: #{mycmd}") if @debug
             @should_restart_done = true
             print exec(mycmd)
             exit
           rescue => e
-            STDOUT.puts e.inspect
-            STDOUT.puts e.backtrace
+            self.log_puts(e.inspect)
+            self.log_puts(e.backtrace)
           end
         end
       end
@@ -103,7 +103,7 @@ class Hayabusa
   
   #This method can be used to clean the appserver. Dont call this from a HTTP-request.
   def clean_sessions
-    STDOUT.print "Cleaning sessions on appserver.\n" if @config[:debug]
+    self.log_puts("Cleaning sessions on appserver.") if @debug
     
     #Clean up various inactive sessions.
     session_not_ids = []
@@ -120,10 +120,10 @@ class Hayabusa
     
     @sessions = newsessions
     
-    STDOUT.print "Delete sessions...\n" if @config[:debug]
+    self.log_puts("Delete sessions...") if @debug
     @ob.list(:Session, {"id_not" => session_not_ids, "date_lastused_below" => (Time.now - 5356800)}) do |session|
       idhash = session[:idhash]
-      STDOUT.print "Deleting session: '#{session.id}'.\n" if @config[:debug]
+      self.log_puts("Deleting session: '#{session.id}'.") if @debug
       @ob.delete(session)
       @sessions.delete(idhash)
     end

data/lib/hayabusa_ext/errors.rb

@@ -68,7 +68,7 @@ class Hayabusa
   def handle_error(e, args = {})
     @error_emails_pending_mutex.synchronize do
       if !Thread.current[:hayabusa] or !Thread.current[:hayabusa][:httpsession]
-        STDOUT.print "#{Knj::Errors.error_str(e)}\n\n"
+        self.log_puts("#{Knj::Errors.error_str(e)}\n")
       end
       
       browser = _httpsession.browser if _httpsession
@@ -122,7 +122,7 @@ class Hayabusa
   
   #Prints a detailed overview of the object in the terminal from where the appserver was started. This can be used for debugging.
   def dprint(obj)
-    STDOUT.print Php4r.print_r(obj, true)
+    self.log_puts(Php4r.print_r(obj, true))
   end
   
   #Prints a string with a single file-line-backtrace prepended which is useful for debugging.
@@ -130,6 +130,6 @@ class Hayabusa
     #Get backtrace.
     backtrace_str = caller[0]
     backtrace_match = backtrace_str.match(/^(.+):(\d+):in /)
-    STDOUT.print "#{File.basename(backtrace_match[1])}:#{backtrace_match[2]}: #{str}\n"
+    self.log_puts("#{File.basename(backtrace_match[1])}:#{backtrace_match[2]}: #{str}")
   end
 end

data/lib/hayabusa_ext/logging.rb

@@ -372,7 +372,7 @@ class Hayabusa
     raise "No :ob-argument given." if !args[:ob]
     
     @db.q_buffer do |db_buffer|
-      STDOUT.puts "Starting to look for dead log-links." if @debug or args[:debug]
+      self.log_puts("Starting to look for dead log-links.") if @debug or args[:debug]
       @ob.list(:Log_link, :cloned_ubuf => true) do |log_link|
         classname = log_link.object_class.to_s.split("::").last
         obj_exists = args[:ob].exists?(classname, log_link[:object_id])
@@ -380,23 +380,23 @@ class Hayabusa
         
         log = log_link.log
         
-        STDOUT.puts "Deleting log-link #{log_link.id} for #{classname}(#{log_link[:object_id]})." if @debug or args[:debug]
+        self.log_puts("Deleting log-link #{log_link.id} for #{classname}(#{log_link[:object_id]}).") if @debug or args[:debug]
         @ob.delete(log_link, :db_buffer => db_buffer)
         
         links_count = log.links("count" => true)
         
         if links_count <= 0
-          STDOUT.puts "Deleting log #{log.id} because it has no more links." if @debug or args[:debug]
+          self.log_puts("Deleting log #{log.id} because it has no more links.") if @debug or args[:debug]
           @ob.delete(log, :db_buffer => db_buffer)
         end
       end
       
-      STDOUT.puts "Starting to look for logs with no links." if @debug or args[:debug]
+      self.log_puts("Starting to look for logs with no links.") if @debug or args[:debug]
       @ob.list(:Log, {
         [:Log_link, "id"] => {:type => :sqlval, :val => :null},
         :cloned_ubuf => true
       }) do |log|
-        STDOUT.puts "Deleting log #{log.id} because it has no links: '#{log.text}'." if @debug or args[:debug]
+        self.log_puts("Deleting log #{log.id} because it has no links: '#{log.text}'.") if @debug or args[:debug]
         @ob.delete(log, :db_buffer => db_buffer)
       end
     end

data/lib/hayabusa_ext/mailing.rb

@@ -28,7 +28,7 @@ class Hayabusa
       end
       
       mailobj = Hayabusa::Mail.new({:hb => self, :errors => {}, :status => :waiting}.merge(mail_args))
-      STDOUT.print "Added mail '#{mailobj.__id__}' to the mail-send-queue.\n" if debug
+      self.log_puts("Added mail '#{mailobj.__id__}' to the mail-send-queue.") if debug
       @mails_waiting << mailobj
       
       #Try to send right away and raise error instantly if something happens if told to do so.
@@ -44,34 +44,34 @@ class Hayabusa
   #Sends all queued mails to the respective servers, if we are online.
   def mail_flush
     @mails_mutex.synchronize do
-      STDOUT.print "Flushing mails.\n" if @debug
+      self.log_puts("Flushing mails.") if @debug
       
       if @mails_waiting.length <= 0
-        STDOUT.print "No mails to flush - skipping.\n" if @debug
+        self.log_puts("No mails to flush - skipping.") if @debug
         return false
       end
       
-      STDOUT.print "Trying to ping Google to figure out if we are online...\n" if @debug
+      self.log_puts("Trying to ping Google to figure out if we are online...") if @debug
       status = Ping.pingecho("google.dk", 10, 80)
       if !status
-        STDOUT.print "We are not online - skipping mail flush.\n"
+        self.log_puts("We are not online - skipping mail flush.")
         return false  #Dont run if we dont have a connection to the internet and then properly dont have a connection to the SMTP as well.
       end
       
       #Use subprocessing to avoid the mail-framework (activesupport and so on, also possible memory leaks in those large frameworks).
-      STDOUT.print "Starting subprocess for mailing.\n" if @debug
+      self.log_puts("Starting subprocess for mailing.") if @debug
       Knj::Process_meta.new("debug" => @debug, "debug_err" => true, "id" => "hayabusa_mailing") do |subproc|
         subproc.static("Object", "require", "rubygems")
         subproc.static("Object", "require", "mail")
         subproc.static("Object", "require", "#{@config[:knjrbfw_path]}knjrbfw")
         subproc.static("Object", "require", "knj/autoload")
         
-        STDOUT.print "Flushing emails." if @debug
+        self.log_puts("Flushing emails.") if @debug
         @mails_waiting.each do |mail|
           begin
-            STDOUT.print "Sending email: #{mail.__id__}\n" if @debug
+            self.log_puts("Sending email: #{mail.__id__}") if @debug
             if mail.send("proc" => subproc)
-              STDOUT.print "Email sent: #{mail.__id__}\n" if @debug
+              self.log_puts("Email sent: #{mail.__id__}") if @debug
               @mails_waiting.delete(mail)
             end
           rescue Timeout::Error
@@ -117,7 +117,7 @@ class Hayabusa
     
     #Sends the email to the receiver.
     def send(args = {})
-      STDOUT.print "Sending mail '#{__id__}'.\n" if @args[:hb].debug
+      @args[:hb].log_puts("Sending mail '#{__id__}'.") if @args[:hb].debug
       
       if args["proc"]
         args["proc"].static("Object", "require", "knj/mailobj")
@@ -139,13 +139,13 @@ class Hayabusa
       end
       
       @args[:status] = :sent
-      STDOUT.print "Sent email #{self.__id__}\n" if @args[:hb].debug
+      @args[:hb].log_puts("Sent email #{self.__id__}") if @args[:hb].debug
       return true
     rescue => e
       if @args[:hb].debug
-        STDOUT.print "Could not send email.\n"
-        STDOUT.puts e.inspect
-        STDOUT.puts e.backtrace
+        @args[:hb].log_puts("Could not send email.")
+        @args[:hb].log_puts(e.inspect)
+        @args[:hb].log_puts(e.backtrace)
       end
       
       @args[:errors][e.class.name] = {:count => 0} if !@args[:errors].has_key?(e.class.name)

data/lib/hayabusa_ext/sessions.rb

@@ -73,7 +73,7 @@ class Hayabusa
   def sessions_flush
     if @sessions
       @sessions.each do |session_hash, session_data|
-        STDOUT.print "Flushing session: #{session_data[:dbobj].id}\n" if @debug
+        self.log_puts("Flushing session: #{session_data[:dbobj].id}") if @debug
         session_data[:dbobj].flush
       end
     end

data/lib/hayabusa_ext/threadding.rb

@@ -1,7 +1,7 @@
 class Hayabusa
   def initialize_threadding
     @config[:threadding] = {} if !@config.has_key?(:threadding)
-    @config[:threadding][:max_running] = 8 if !@config[:threadding].has_key?(:max_running)
+    @config[:threadding][:max_running] = 16 if !@config[:threadding].has_key?(:max_running)
     
     threadpool_args = {:threads => @config[:threadding][:max_running]}
     threadpool_args[:priority] = @config[:threadding][:priority] if @config[:threadding].key?(:priority)
@@ -30,35 +30,38 @@ class Hayabusa
     thread_obj = Hayabusa::Thread_instance.new(
       :running => false,
       :error => false,
-      :done => false
+      :done => false,
+      :args => args
     )
     
     @threadpool.run_async do
-      @ob.db.get_and_register_thread if @ob.db.opts[:threadsafe]
-      @db_handler.get_and_register_thread if @db_handler.opts[:threadsafe]
-      
-      Thread.current[:hayabusa] = {
-        :hb => self,
-        :db => @db_handler
-      }
-      
       begin
+        @ob.db.get_and_register_thread if @ob.db.opts[:threadsafe]
+        @db_handler.get_and_register_thread if @db_handler.opts[:threadsafe]
+        
+        Thread.current[:hayabusa] = {
+          :hb => self,
+          :db => @db_handler
+        }
+        
         thread_obj.args[:running] = true
         yield(*args[:args])
+        _hb.log_puts("Done yielding for #{args[:id]}")
       rescue => e
-        self.handle_error(e)
         thread_obj.args[:error] = true
         thread_obj.args[:error_obj] = e
+        
+        self.handle_error(e)
       ensure
-        STDOUT.print "Free thread ob-db.\n" if @debug
+        _hb.log_puts("Seting arguments on thread.") if @debug
+        thread_obj.args[:running] = false
+        thread_obj.args[:done] = true
+        
+        _hb.log_puts("Free thread ob-db.") if @debug
         @ob.db.free_thread if @ob.db.opts[:threadsafe]
         
-        STDOUT.print "Free thread db-handler.\n" if @debug
+        _hb.log_puts("Free thread db-handler.") if @debug
         @db_handler.free_thread if @db_handler.opts[:threadsafe]
-        
-        STDOUT.print "Seting arguments on thread.\n" if @debug
-        thread_obj.args[:running] = false
-        thread_obj.args[:done] = true
       end
     end
     
@@ -105,8 +108,24 @@ class Hayabusa::Thread_instance
     @args = args
   end
   
+  def running?
+    return @args[:running]
+  end
+  
+  def done?
+    return @args[:done]
+  end
+  
+  def error?
+    return true if @args[:error]
+    return false
+  end
+  
   def join
-    sleep 0.1 while !@args[:done]
+    while !@args[:done] and !@args[:error]
+      _hb.log_puts(@args)
+      sleep 0.1
+    end
   end
   
   def join_error

data/lib/hayabusa_fcgi.rb

@@ -1,3 +1,4 @@
+#This class is used for FCGI-sessions. It normally starts a Hayabusa-host-process which this (and other) FCGI-processes will proxy requests to. The host-process will automatically kill itself when no more FCGI-sessions are connected to emulate normal FCGI behaviour.
 class Hayabusa::Fcgi
   def initialize
     #Spawn CGI-variable to emulate FCGI part.
@@ -10,6 +11,7 @@ class Hayabusa::Fcgi
     @debug = false
   end
   
+  #Evaluates if a new host-process should be started or we should proxy calls to an existing one.
   def evaluate_mode
     #If this is a FCGI-proxy-instance then the HTTP-connection should be checked if it is working.
     if @fcgi_proxy
@@ -52,7 +54,7 @@ class Hayabusa::Fcgi
           #Set this instance to run in proxy-mode.
           begin
             @fcgi_proxy = fcgi_config
-            Knj.gem_require(:Http2, "http2")
+            Knj.gem_require(:Http2)
             
             begin
               @fcgi_proxy[:http] = Http2.new(:host => "localhost", :port => @fcgi_proxy[:port].to_i)
@@ -74,21 +76,46 @@ class Hayabusa::Fcgi
       
       #No instance is already running - start new Hayabusa-instance in both CGI- and socket-mode and write that to the config-file so other instances will register this as the main host-instance.
       if !@fcgi_proxy
+        #Spawn sub-process that actually runs the Hayabusa-server.
+        require "open3"
+        cmd = "#{Knj::Os.executed_executable} #{File.realpath(File.dirname(__FILE__))}/../bin/hayabusa_fcgi_server.rb --conf_path=#{Knj::Strings.unixsafe(@hayabusa_fcgi_conf_path)} --fcgi_data_path=#{Knj::Strings.unixsafe(fcgi_config_fp)}"
+        
+        #Only used to identify the running FCGI-server host-processes with 'ps aux'.
+        cmd << "--title=#{Knj::Strings.unixsafe(hayabusa_conf[:title])}" if hayabusa_conf[:title]
+        
+        $stderr.puts("Executing command to start FCGI-server: #{cmd}")
+        io_out, io_in, io_err = Open3.popen3(cmd)
+        
+        #Get data that should contain PID and port.
+        read = io_in.gets
+        raise "Host-process didnt return required data." if !read
+        
+        #Parse data from the host-process (port and PID).
+        begin
+          data = Marshal.load(Base64.strict_decode64(read.strip))
+        rescue
+          raise "Invalid data given from host-process: '#{read}'."
+        end
+        
+        
+        #Detach the process where the HTTP-server runs from this process.
+        Process.detach(data[:pid])
+        
+        #Write the data about the new HTTP-server in the config-file and re-evaluate mode. The host-process should not write the file itself, since this process has a lock on that file, and another process might try to start another host-process while writing the file from the host-process, which is not desired.
         File.open(fcgi_config_fp, "w") do |fp|
-          @hayabusa = Hayabusa.new(hayabusa_conf)
-          
-          #Start web-server for proxy-requests.
-          @hayabusa.start
-          
           fp.write(Marshal.dump(
-            :pid => Process.pid,
-            :port => @hayabusa.port
+            :pid => data[:pid],
+            :port => data[:port]
           ))
+          
+          #Started host-process - evaluate mode again and proxy request to the host-process.
+          raise Errno::EAGAIN
         end
       end
     end
   end
   
+  #Handels the requests comming from the FCGI-object in a loop.
   def fcgi_loop
     $stderr.puts "[hayabusa] Starting FCGI." if @debug
     
@@ -119,8 +146,8 @@ class Hayabusa::Fcgi
           else
             self.handle_fcgi_request(:cgi => cgi)
           end
-        rescue Errno::ECONNABORTED, Errno::ECONNREFUSED
-          $stderr.puts "[hayabusa] Connection to server was interrupted - trying again."
+        rescue Errno::ECONNABORTED, Errno::ECONNREFUSED, Errno::ECONNRESET => e
+          $stderr.puts "[hayabusa] Connection to server was interrupted - trying again: <#{e.class.name}> #{e.message}"
           @fcgi_proxy = nil #Force re-evaluate if this process should be host or proxy.
           retry
         rescue Exception => e
@@ -146,6 +173,7 @@ class Hayabusa::Fcgi
     end
   end
   
+  #Handles the request as a real request on a Hayabusa-host running inside the current process. This is not used any more but kept if we need support for it once again (maybe the developer should be able to decide this in some kind of config?).
   def handle_fcgi_request(args)
     #Host the FCGI-process.
     $stderr.puts "[hayabusa] Running request as CGI." if @debug

data/lib/hayabusa_fcgi_server.rb

@@ -0,0 +1,30 @@
+#This class is used to start Hayabusa in its own process, which FCGI-sessions then connects to. This way only one instance of Hayabusa is actually running to allowed FCGI-sessions to "commuicate" with each other (because they are running in the same process).
+class Hayabusa::Fcgi_server
+  attr_reader :hayabusa
+  
+  def initialize(args)
+    #Start web-server for proxy-requests.
+    @hayabusa = Hayabusa.new(args[:hayabusa_conf])
+    @hayabusa.start
+    
+    #In FCGI-mode the host-process should exit when zero FCGI-connections are active.
+    @hayabusa.events.connect(:http_session_destruct, &self.method(:on_http_session_destruct))
+  end
+  
+  #Called when a HTTP-session destructs (disconnects). Used to stop the Hayabusa-appserver when no connections are active to only be running when FCGI-sessions are running.
+  def on_http_session_destruct(*args)
+    @hayabusa.log_puts("HTTP-connection destruction - checking if no connections are active any more.")
+    
+    stop = false
+    httpserv = @hayabusa.httpserv
+    
+    if !httpserv or !httpserv.http_sessions or httpserv.http_sessions.empty?
+      stop = true
+    end
+    
+    if stop
+      @hayabusa.log_puts("Stopping server because no active connections.")
+      @hayabusa.stop
+    end
+  end
+end

data/lib/hayabusa_http_server.rb

@@ -1,5 +1,6 @@
 require "socket"
 
+#This class opens a port to run the HTTP-server on. It then spawns "Hayabusa::Http_session" for each active connection.
 class Hayabusa::Http_server
   attr_accessor :working_count
   attr_reader :hb, :http_sessions, :thread_accept, :thread_restart, :server
@@ -10,6 +11,7 @@ class Hayabusa::Http_server
     @mutex_count = Mutex.new
   end
   
+  #Opens a port with TCPServer and spins up a thread to accept connections.
   def start
     @http_sessions = []
     @working_count = 0
@@ -43,6 +45,7 @@ class Hayabusa::Http_server
     end
   end
   
+  #Gently stops the HTTP-server. Will wait for various HTTP-sessions to be finish with a page (but wont wait for them to disconnect in regards to keep-alive).
   def stop
     while @working_count > 0
       @hb.log_puts "Waiting until no HTTP-sessions are running." if @debug
@@ -83,11 +86,13 @@ class Hayabusa::Http_server
     @hb = nil
   end
   
+  #Spawns a new HTTP-session with the given socket.
   def spawn_httpsession(socket)
-    @hb.log_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
   
+  #Increases and decreases the 'working_count'-variable to keep track of how many HTTP-sessions are currently processing pages (used for gentle stops).
   def count_block
     begin
       added = false

data/lib/hayabusa_http_session.rb

@@ -141,14 +141,14 @@ class Hayabusa::Http_session < Hayabusa::Client_session
     begin
       @socket.close if !@socket.closed?
     rescue => e
-      STDOUT.puts e.inspect
-      STDOUT.puts e.backtrace
+      @hb.log_puts(e.inspect)
+      @hb.log_puts(e.backtrace)
       #ignore if it fails...
     end
     
     @httpserver.http_sessions.delete(self) if @httpserver and @httpserver.http_sessions
-    
     @eruby.destroy if @eruby
+    @hb.events.call(:http_session_destruct, :httpsession => self) if @hb.events
     @thread_request.kill if @thread_request.alive?
   end
   
@@ -208,7 +208,7 @@ class Hayabusa::Http_session < Hayabusa::Client_session
         "name" => "HayabusaSession",
         "value" => @session_id,
         "path" => "/",
-        "expires" => Time.now + 32140800 #add around 12 months
+        "expires" => Time.now + 32140800 #add around 12 months from the current time
       )
     end
     
@@ -230,7 +230,6 @@ class Hayabusa::Http_session < Hayabusa::Client_session
     @hb.log_puts "Initializing thread and content-group." if @debug
     self.init_thread
     Thread.current[:hayabusa][:contentgroup] = @cgroup
-    time_start = Time.now.to_f if @debug
     
     self.execute_page
     self.execute_done

data/lib/hayabusa_http_session_request.rb

@@ -159,7 +159,7 @@ class Hayabusa::Http_session::Request
             if @hb
               @hb.handle_error(e)
             else
-              STDOUT.print Knj::Errors.error_str(e)
+              STDOUT.print Knj::Errors.error_str(e) if !STDOUT.closed?
             end
           end
         end

data/pages/spec_thread_joins.rhtml

@@ -1,20 +1,35 @@
 <%
+  #Knj.p _hb.config
+  #exit
+  
+  _hb.log_puts("1")
   print "1"
   
+  _hb.log_puts("2")
   cont = "2"
-  t1 = _hb.thread do
+  t1 = _hb.thread(:id => 4) do
     sleep 0.5
+    _hb.log_puts("4")
     cont << "4"
+    _hb.log_puts("4 done")
   end
   
-  t2 = _hb.thread do
-    sleep 0.1
+  t2 = _hb.thread(:id => 3) do
+    sleep 0.3
+    _hb.log_puts("3")
     cont << "3"
+    _hb.log_puts("3 done")
   end
   
+  sleep 0.1
+  
+  raise "Expected thread 1 to be running but it wasnt." if !t1.running?
+  raise "Expected thread 2 to be running but it wasnt." if !t2.running?
+  
   t1.join
   t2.join_error
   
+  _hb.log_puts("5")
   cont << "5"
   
   print cont

data/spec/fcgi_multiple_processes_spec.rb

@@ -3,7 +3,7 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 describe "Hayabusa" do
   it "should handle sessions correctly under stressed conditions" do
     require "knjrbfw"
-    Knj.gem_require(:Http2, "http2")
+    Knj.gem_require(:Http2)
     require "json"
     
     ts = []

metadata

@@ -2,7 +2,7 @@
 name: hayabusa
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.13
+  version: 0.0.14
 platform: ruby
 authors: 
 - Kasper Johansen
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-09-20 00:00:00 Z
+date: 2012-09-30 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: knjrbfw
@@ -141,6 +141,8 @@ executables:
 - hayabusa_cgi.rb
 - hayabusa_fcgi.fcgi
 - hayabusa_fcgi.rb
+- hayabusa_fcgi_server.rb
+- hayabusa_spec_restart.rb
 - knjappserver_start.rb
 extensions: []
 
@@ -161,6 +163,8 @@ files:
 - bin/hayabusa_cgi.rb
 - bin/hayabusa_fcgi.fcgi
 - bin/hayabusa_fcgi.rb
+- bin/hayabusa_fcgi_server.rb
+- bin/hayabusa_spec_restart.rb
 - bin/knjappserver_start.rb
 - conf/apache2_cgi_rhtml_conf.conf
 - conf/apache2_fcgi_rhtml_conf.conf
@@ -184,6 +188,7 @@ files:
 - lib/hayabusa_ext/translations.rb
 - lib/hayabusa_ext/web.rb
 - lib/hayabusa_fcgi.rb
+- lib/hayabusa_fcgi_server.rb
 - lib/hayabusa_http_server.rb
 - lib/hayabusa_http_session.rb
 - lib/hayabusa_http_session_contentgroup.rb
@@ -240,7 +245,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 4196066907538091400
+      hash: 888767182680774997
       segments: 
       - 0
       version: "0"