hayabusa 0.0.3 → 0.0.4

data/lib/hayabusa_cgi_session.rb

@@ -1,6 +1,6 @@
 class Hayabusa::Cgi_session
   attr_accessor :data, :alert_sent
-  attr_reader :cookie, :get, :headers, :session, :session_id, :session_hash, :hb, :active, :out, :eruby, :browser, :debug, :resp, :page_path, :post, :cgroup, :meta, :httpsession_var, :handler, :working
+  attr_reader :cookie, :get, :headers, :session, :session_id, :session_hash, :hb, :active, :out, :eruby, :browser, :debug, :resp, :page_path, :post, :cgroup, :meta, :httpsession_var, :working
   
   def initialize(args)
     @args = args
@@ -104,7 +104,7 @@ class Hayabusa::Cgi_session
       
       Timeout.timeout(@hb.config[:timeout]) do
         if @handlers_cache.key?(@ext)
-          STDOUT.print "Calling handler.\n" if @debug
+          @hb.log_puts "Calling handler." if @debug
           @handlers_cache[@ext].call(self)
         else
           raise "CGI-mode shouldnt serve static files: '#{@page_path}'."
@@ -126,6 +126,29 @@ class Hayabusa::Cgi_session
     end
   end
   
+  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

data/lib/hayabusa_cgi_tools.rb

@@ -38,10 +38,7 @@ class Hayabusa::Cgi_tools
   
   #This method is used to proxy a request to another FCGI-process, since a single FCGI-process cant handle more requests simultanious.
   def proxy_request_to(args)
-    cgi = args[:cgi]
-    http = args[:http]
-    
-    File.open("/tmp/debug_#{Process.pid}_#{Time.new.to_f}.log", "w") do |fp_log|
+    cgi, http, fp_log = args[:cgi], args[:http], args[:fp_log]
     
     headers = {"Hayabusa_mode" => "proxy"}
     cgi.env_table.each do |key, val|
@@ -56,6 +53,7 @@ class Hayabusa::Cgi_tools
     #Make request.
     uri = Knj::Web.parse_uri(cgi.env_table["REQUEST_URI"])
     url = File.basename(uri[:path])
+    url = url[1, url.length] if url[0] == "/"
     
     if cgi.env_table["QUERY_STRING"].to_s.length > 0
       url << "?#{cgi.env_table["QUERY_STRING"]}"
@@ -64,39 +62,52 @@ class Hayabusa::Cgi_tools
     #cgi.print "Content-Type: text/html\r\n"
     #cgi.print "\r\n"
     
-    if cgi.request_method == "POST" and cgi.content_type.to_s.downcase.index("multipart/form-data") != nil
-      count = 0
-      http.post_multipart(:url => url, :post => self.convert_fcgi_post(cgi.params),
-        :default_headers => headers,
-        :cookies => false,
-        :on_content => proc{|line|
-          cgi.print(line) if count > 0
-          count += 1
-        }
-      )
-    elsif cgi.request_method == "POST"
-      count = 0
-      http.post(:url => url, :post => self.convert_fcgi_post(cgi.params),
-        :default_headers => headers,
-        :cookies => false,
-        :on_content => proc{|line|
-          cgi.print(line) if count > 0
-          count += 1
-        }
-      )
+    if args[:timeout]
+      ttime = args[:timeout]
     else
-      count = 0
-      http.get(:url => url,
-        :default_headers => headers,
-        :cookies => false,
-        :on_content => proc{|line|
-          fp_log.puts("Line: '#{line}'.")
-          cgi.print(line) if count > 0
-          count += 1
-        }
-      )
+      ttime = 30
     end
     
+    fp_log.puts("Proxying URL: '#{url}'.") if fp_log
+    
+    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(
+          :url => url,
+          :post => self.convert_fcgi_post(cgi.params),
+          :default_headers => headers,
+          :cookies => false,
+          :on_content => proc{|line|
+            cgi.print(line) if count > 0
+            count += 1
+          }
+        )
+      elsif cgi.request_method == "POST"
+        count = 0
+        http.post(
+          :url => url,
+          :post => self.convert_fcgi_post(cgi.params),
+          :default_headers => headers,
+          :cookies => false,
+          :on_content => proc{|line|
+            cgi.print(line) if count > 0
+            count += 1
+          }
+        )
+      else
+        count = 0
+        http.get(
+          :url => url,
+          :default_headers => headers,
+          :cookies => false,
+          :on_content => proc{|line|
+            cgi.print(line) if count > 0
+            count += 1
+          }
+        )
+      end
     end
   end
 end

data/lib/hayabusa_ext/threadding.rb

@@ -3,8 +3,8 @@ class Hayabusa
     @config[:threadding] = {} if !@config.has_key?(:threadding)
     @config[:threadding][:max_running] = 8 if !@config[:threadding].has_key?(:max_running)
     
-    @threadpool = Knj::Threadpool.new(:threads => @config[:threadding][:max_running], :sleep => 0.1)
-    @threadpool.events.connect(:on_error, &self.method(:threadpool_on_error))
+    @threadpool = Tpool.new(:threads => @config[:threadding][:max_running])
+    @threadpool.on_error(&self.method(:threadpool_on_error))
   end
   
   #Callback for when an error occurs in the threadpool.

data/lib/hayabusa_ext/translations.rb

@@ -4,7 +4,7 @@ class Hayabusa
   # print _hb.trans(obj, :title) #=> "Trala"
   def trans(obj, key, args = {})
     args[:locale] = self.trans_locale if !args[:locale]
-    trans_val = @translations.get(obj, key, args).to_s
+    trans_val = self.translations.get(obj, key, args).to_s
     trans_val = @events.call(:trans_no_str, {:obj => obj, :key => key, :args => args}) if trans_val.length <= 0
     return trans_val
   end
@@ -30,14 +30,16 @@ class Hayabusa
   #===Examples
   # _hb.trans_set(obj, {:title => "Trala"})
   def trans_set(obj, values, args = {})
+    raise "Translations-object now spawned." if !self.translations
     args[:locale] = self.trans_locale if !args[:locale]
-    @translations.set(obj, values, args)
+    self.translations.set(obj, values, args)
   end
   
   #Deletes all translations for the given object.
   #===Examples
   # _hb.trans_del(obj)
   def trans_del(obj)
-    @translations.delete(obj)
+    raise "Translations-object now spawned." if !self.translations
+    self.translations.delete(obj)
   end
 end

data/lib/hayabusa_fcgi.rb

@@ -0,0 +1,172 @@
+class Hayabusa::Fcgi
+  def initialize
+    #Spawn CGI-variable to emulate FCGI part.
+    @cgi_tools = Hayabusa::Cgi_tools.new
+    
+    #We cant define the Hayabusa-server untuil we receive the first headers, so wait for the first request.
+    @hayabusa = nil
+    @hayabusa_fcgi_conf_path = nil
+    @fcgi_proxy = nil
+    @debug = false
+  end
+  
+  def evaluate_mode
+    #If this is a FCGI-proxy-instance then the HTTP-connection should be checked if it is working.
+    if @fcgi_proxy
+      if !@fcgi_proxy[:http].socket_working?
+        @fcgi_proxy = nil
+      end
+    end
+    
+    #Skip the actual check if Hayabusa is spawned or this is a working FCGI-proxy-instance.
+    return nil if @hayabusa or @fcgi_proxy
+    
+    #Parse the configuration-header and generate Hayabusa-config-hash.
+    raise "No HTTP_HAYABUSA_FCGI_CONFIG-header was given." if !@cgi.env_table["HTTP_HAYABUSA_FCGI_CONFIG"]
+    @hayabusa_fcgi_conf_path = @cgi.env_table["HTTP_HAYABUSA_FCGI_CONFIG"]
+    require @hayabusa_fcgi_conf_path
+    raise "No 'Hayabusa::FCGI_CONF'-constant was spawned by '#{@cgi.env_table["HTTP_HAYABUSA_FCGI_CONFIG"]}'." if !Hayabusa.const_defined?(:FCGI_CONF)
+    conf = Hayabusa::FCGI_CONF
+    
+    hayabusa_conf = Hayabusa::FCGI_CONF[:hayabusa]
+    hayabusa_conf.merge!(
+      :cmdline => false,
+      :port => 0 #Ruby picks random port and we get the actual port after starting the appserver.
+    )
+    
+    #Figure out if this should be a host-FCGI-process or a proxy-FCGI-process.
+    fcgi_config_fp = "#{Knj::Os.tmpdir}/hayabusa_fcgi_#{hayabusa_conf[:title]}_fcgi.conf"
+    FileUtils.touch(fcgi_config_fp) if !File.exists?(fcgi_config_fp)
+    
+    File.open(fcgi_config_fp) do |fp|
+      fp.flock(File::LOCK_EX)
+      
+      fcgi_config_cont = File.read(fcgi_config_fp)
+      if !fcgi_config_cont.empty?
+        #Seems like an instance is already running - check PID to be sure.
+        fcgi_config = Marshal.load(File.read(fcgi_config_fp))
+        pid = fcgi_config[:pid]
+        
+        if Knj::Unix_proc.pid_running?(pid)
+          #Set this instance to run in proxy-mode.
+          begin
+            @fcgi_proxy = fcgi_config
+            require "http2"
+            @fcgi_proxy[:http] = Http2.new(:host => "localhost", :port => @fcgi_proxy[:port].to_i)
+            
+            if hayabusa_conf[:debug]
+              @fcgi_proxy[:fp_log] = File.open("/tmp/hayabusa_#{hayabusa_conf[:hayabusa][:title]}_#{Process.pid}.log", "w")
+              @fcgi_proxy[:fp_log].sync = true
+            end
+          rescue
+            @fcgi_proxy = nil
+            raise
+          end
+        end
+      end
+      
+      #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
+        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
+          ))
+        end
+      end
+    end
+  end
+  
+  def fcgi_loop
+    $stderr.puts "[hayabusa] Starting FCGI." if @debug
+    FCGI.each_cgi do |cgi|
+      begin
+        #cgi.print "Content-Type: text/html\r\n"
+        #cgi.print "\r\n"
+        
+        #Set 'cgi'-variable for CGI-tools.
+        @cgi_tools.cgi = cgi
+        @cgi = cgi
+        
+        #Evaluate the mode of this instance.
+        self.evaluate_mode
+        
+        #Ensure the same FCGI-process isnt active for more than one website.
+        raise "Expected 'HTTP_HAYABUSA_FCGI_CONFIG' to be '#{@hayabusa_fcgi_conf_path}' but it wasnt: '#{cgi.env_table["HTTP_HAYABUSA_FCGI_CONFIG"]}'." if @hayabusa_fcgi_conf_path and @hayabusa_fcgi_conf_path != cgi.env_table["HTTP_HAYABUSA_FCGI_CONFIG"]
+        
+        if @fcgi_proxy
+          #Proxy request to the host-FCGI-process.
+          $stderr.puts "[hayabusa] Proxying request." if @debug
+          begin
+            @cgi_tools.proxy_request_to(:cgi => cgi, :http => @fcgi_proxy[:http], :fp_log => @fcgi_proxy[:fp_log])
+          rescue Errno::ECONNABORTED
+            @fcgi_proxy = nil #Force re-evaluate if this process should be host or proxy.
+            raise
+          end
+        else
+          self.handle_fcgi_request(:cgi => cgi)
+        end
+      rescue Exception => e
+        cgi.print "Content-Type: text/html\r\n"
+        cgi.print "\r\n"
+        cgi.print Knj::Errors.error_str(e, :html => true)
+        
+        if @hayabusa
+          @hayabusa.log_puts e.inspect
+          @hayabusa.log_puts e.backtrace
+        else
+          STDERR.puts e.inspect
+          STDERR.puts e.backtrace
+        end
+      ensure
+        @cgi = nil
+        @cgi_tools.cgi = nil
+      end
+    end
+  end
+  
+  def handle_fcgi_request(args)
+    #Host the FCGI-process.
+    $stderr.puts "[hayabusa] Running request as CGI." if @debug
+    
+    #Enforce $stdout variable.
+    $stdout = @hayabusa.cio
+    
+    #The rest is copied from the FCGI-part.
+    headers = {}
+    @cgi.env_table.each do |key, val|
+      if key[0, 5] == "HTTP_" and key != "HTTP_HAYABUSA_FCGI_CONFIG"
+        key = key[5, key.length].gsub("_", " ").gsub(" ", "-")
+        headers[key] = val
+      end
+    end
+    
+    meta = @cgi.env_table.to_hash
+    
+    uri = Knj::Web.parse_uri(meta["REQUEST_URI"])
+    meta["PATH_TRANSLATED"] = File.basename(uri[:path])
+    
+    cgi_data = {
+      :cgi => @cgi,
+      :headers => headers,
+      :get => Knj::Web.parse_urlquery(@cgi.env_table["QUERY_STRING"], :urldecode => true, :force_utf8 => true),
+      :meta => meta
+    }
+    if @cgi.request_method == "POST"
+      cgi_data[:post] = @cgi_tools.convert_fcgi_post(@cgi.params)
+    else
+      cgi_data[:post] = {}
+    end
+    
+    @hayabusa.config[:cgi] = cgi_data
+    
+    
+    #Handle request.
+    @hayabusa.start_cgi_request
+  end
+end

data/lib/hayabusa_http_server.rb

@@ -21,12 +21,12 @@ class Hayabusa::Http_server
     
     @thread_accept = Thread.new do
       loop do
-        if !@server or @server.closed?
-          STDOUT.puts "Starting TCPServer." if @debug
-          @server = TCPServer.new(@hb.config[:host], @hb.config[:port])
-        end
-        
         begin
+          if !@server or @server.closed?
+            STDOUT.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
           self.spawn_httpsession(@server.accept)
           STDOUT.puts "Starting new HTTP-request." if @debug

data/lib/hayabusa_http_session.rb

@@ -55,7 +55,7 @@ class Hayabusa::Http_session
     
     Dir.chdir(@config[:doc_root])
     ObjectSpace.define_finalizer(self, self.class.method(:finalize).to_proc) if @debug
-    STDOUT.print "New httpsession #{self.__id__} (total: #{@httpserver.http_sessions.count}).\n" if @debug
+    @hb.log_puts "New httpsession #{self.__id__} (total: #{@httpserver.http_sessions.count})." if @debug
     
     @thread_request = Thread.new(&self.method(:thread_request_run))
   end
@@ -80,15 +80,15 @@ class Hayabusa::Http_session
           @working = false
           break if @hb.should_restart
           
-          STDOUT.print "#{__id__} - Waiting to parse from socket.\n" if @debug
+          @hb.log_puts "#{__id__} - Waiting to parse from socket." if @debug
           Timeout.timeout(1800) do
             @handler.socket_parse(@socket)
           end
           
-          STDOUT.print "#{__id__} - Done parsing from socket.\n" if @debug
+          @hb.log_puts "#{__id__} - Done parsing from socket." if @debug
           
           while @hb.paused? #Check if we should be waiting with executing the pending request.
-            STDOUT.print "#{__id__} - Paused! (#{@hb.paused}) - sleeping.\n" if @debug
+            @hb.log_puts "#{__id__} - Paused! (#{@hb.paused}) - sleeping." if @debug
             sleep 0.1
           end
           
@@ -96,7 +96,7 @@ class Hayabusa::Http_session
           
           if max_requests_working and @httpserver
             while @httpserver.working_count.to_i >= max_requests_working
-              STDOUT.print "#{__id__} - Maximum amounts of requests are working (#{@httpserver.working_count}, #{max_requests_working}) - sleeping.\n" if @debug
+              @hb.log_puts "#{__id__} - Maximum amounts of requests are working (#{@httpserver.working_count}, #{max_requests_working}) - sleeping." if @debug
               sleep 0.1
             end
           end
@@ -106,13 +106,13 @@ class Hayabusa::Http_session
           @hb.ob.db.get_and_register_thread if @hb.ob.db.opts[:threadsafe]
           
           @working = true
-          STDOUT.print "#{__id__} - Serving.\n" if @debug
+          @hb.log_puts "#{__id__} - Serving." if @debug
           
           @httpserver.count_block do
             self.serve
           end
         ensure
-          STDOUT.print "#{__id__} - Closing request.\n" if @debug
+          @hb.log_puts "#{__id__} - Closing request." if @debug
           @working = false
           
           #Free reserved database-connections.
@@ -121,13 +121,14 @@ class Hayabusa::Http_session
         end
       end
     rescue Timeout::Error
-      STDOUT.print "#{__id__} - Closing httpsession because of timeout.\n" if @debug
+      @hb.log_puts "#{__id__} - Closing httpsession because of timeout." if @debug
     rescue Errno::ECONNRESET, Errno::ENOTCONN, Errno::EPIPE => e
-      STDOUT.print "#{__id__} - Connection error (#{e.inspect})...\n" if @debug
+      @hb.log_puts "#{__id__} - Connection error (#{e.inspect})..." if @debug
+      @hb.log_puts e.backtrace
     rescue Interrupt => e
       raise e
     rescue Exception => e
-      STDOUT.puts Knj::Errors.error_str(e)
+      @hb.log_puts Knj::Errors.error_str(e)
     ensure
       self.destruct
     end
@@ -181,11 +182,11 @@ class Hayabusa::Http_session
   end
   
   def self.finalize(id)
-    STDOUT.print "Http_session finalize #{id}.\n" if @debug
+    @hb.log_puts "Http_session finalize #{id}." if @debug
   end
   
   def destruct
-    STDOUT.print "Http_session destruct (#{@httpserver.http_sessions.length})\n" if @debug and @httpserver and @httpserver.http_sessions
+    @hb.log_puts "Http_session destruct (#{@httpserver.http_sessions.length})" if @debug and @httpserver and @httpserver.http_sessions
     
     begin
       @socket.close if !@socket.closed?
@@ -207,7 +208,7 @@ class Hayabusa::Http_session
   end
   
   def serve
-    STDOUT.print "Generating meta, cookie, get, post and headers.\n" if @debug
+    @hb.log_puts "Generating meta, cookie, get, post and headers." if @debug
     @meta = @handler.meta.merge(@socket_meta)
     @cookie = @handler.cookie
     @get = @handler.get
@@ -244,7 +245,7 @@ class Hayabusa::Http_session
       raise "Could not figure out the IP of the session."
     end
     
-    STDOUT.print "Figuring out session-ID, session-object and more.\n" if @debug
+    @hb.log_puts "Figuring out session-ID, session-object and more." if @debug
     if @cookie["HayabusaSession"].to_s.length > 0
       @session_id = @cookie["HayabusaSession"]
     elsif @browser["browser"] == "bot"
@@ -273,7 +274,7 @@ class Hayabusa::Http_session
     end
     
     if @config.key?(:logging) and @config[:logging][:access_db]
-      STDOUT.print "Doing access-logging.\n" if @debug
+      @hb.log_puts "Doing access-logging." if @debug
       @ips = [@meta["REMOTE_ADDR"]]
       @ips << @meta["HTTP_X_FORWARDED_FOR"].split(",")[0].strip if @meta["HTTP_X_FORWARDED_FOR"]
       @hb.logs_access_pending << {
@@ -287,7 +288,7 @@ class Hayabusa::Http_session
       }
     end
     
-    STDOUT.print "Initializing thread and content-group.\n" if @debug
+    @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
@@ -297,7 +298,7 @@ class Hayabusa::Http_session
       
       Timeout.timeout(@hb.config[:timeout]) do
         if @handlers_cache.key?(@ext)
-          STDOUT.print "Calling handler.\n" if @debug
+          @hb.log_puts "Calling handler." if @debug
           @handlers_cache[@ext].call(self)
         else
           #check if we should use a handler for this request.
@@ -350,7 +351,7 @@ class Hayabusa::Http_session
     
     @cgroup.mark_done
     @cgroup.write_output
-    STDOUT.print "#{__id__} - Served '#{@meta["REQUEST_URI"]}' in #{Time.now.to_f - time_start} secs (#{@resp.status}).\n" if @debug
+    @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, {