hayabusa 0.0.1

data/lib/hayabusa_cgi_session.rb

@@ -0,0 +1,128 @@
+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
+  
+  def initialize(args)
+    @args = args
+    @hb = @args[:hb]
+    
+    @config = @hb.config
+    @handlers_cache = @config[:handlers_cache]
+    cgi_conf = @config[:cgi]
+    @get, @post, @meta, @headers = cgi_conf[:get], cgi_conf[:post], cgi_conf[:meta], cgi_conf[:headers]
+    
+    if cgi_conf[:cgi]
+      @out = cgi_conf[:cgi]
+    else
+      @out = $stdout
+    end
+    
+    @written_size = 0
+    @size_send = @config[:size_send]
+    
+    @eruby = Knj::Eruby.new(
+      :cache_hash => @hb.eruby_cache,
+      :binding_callback => self.method(:create_binding)
+    )
+    
+    self.init_thread
+    
+    
+    #Parse URI (page_path and get).
+    match = @meta["SERVER_PROTOCOL"].match(/^HTTP\/1\.(\d+)\s*/)
+    raise "Could match HTTP-protocol from: '#{@meta["SERVER_PROTOCOL"]}'." if !match
+    http_version = "1.#{match[1]}"
+    
+    
+    Dir.chdir(@config[:doc_root])
+    @page_path = @meta["PATH_TRANSLATED"]
+    @ext = File.extname(@page_path).downcase[1..-1].to_s
+    
+    @resp = Hayabusa::Http_session::Response.new(:socket => self)
+    @resp.reset(:http_version => http_version, :mode => :cgi)
+    @resp.header("Content-Type", "text/html")
+    
+    @cgroup = Hayabusa::Http_session::Contentgroup.new(:socket => self, :hb => @hb, :resp => @resp, :httpsession => self)
+    @cgroup.reset
+    
+    @resp.cgroup = @cgroup
+    
+    begin
+      @hb.events.call(:request_begin, :httpsession => self) if @hb.events
+      
+      Timeout.timeout(@hb.config[:timeout]) do
+        if @handlers_cache.key?(@ext)
+          STDOUT.print "Calling handler.\n" if @debug
+          @handlers_cache[@ext].call(self)
+        else
+          raise "CGI-mode shouldnt serve static files."
+        end
+      end
+      
+      @cgroup.mark_done
+      @cgroup.write_output
+      @cgroup.join
+      
+      @hb.events.call(:request_done, {
+        :httpsession => self
+      }) if @hb.events
+    rescue SystemExit
+      #do nothing - ignore.
+    rescue Timeout::Error
+      @resp.status = 500
+      print "The request timed out."
+    end
+  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,
+      :session => @session,
+      :get => @get,
+      :post => @post,
+      :meta => @meta,
+      :cookie => @cookie
+    }
+  end
+end

data/lib/hayabusa_cgi_tools.rb

@@ -0,0 +1,102 @@
+class Hayabusa::Cgi_tools
+  attr_accessor :cgi
+  
+  def convert_fcgi_post(params)
+    post_hash = {}
+    
+    params.each do |key, val|
+      post_hash[key] = val.first
+    end
+    
+    post_ret = {}
+    post_hash.each do |varname, value|
+      Knj::Web.parse_name(post_ret, varname, value, :urldecode => true)
+    end
+    
+    return post_ret
+  end
+  
+  def env_table
+    return ENV
+  end
+  
+  def request_method
+    return ENV["REQUEST_METHOD"]
+  end
+  
+  def content_type
+    return ENV["CONTENT_TYPE"]
+  end
+  
+  def params
+    return self.cgi.params
+  end
+  
+  def print(arg)
+    Kernel.print arg.to_s
+  end
+  
+  #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|
+    
+    headers = {"Hayabusa_mode" => "proxy"}
+    cgi.env_table.each do |key, val|
+      if key[0, 5] == "HTTP_" and key != "HTTP_HAYABUSA_CGI_CONFIG"
+        key = key[5, key.length].gsub("_", " ")
+        key = key.to_s.split(" ").select{|w| w.capitalize! or w }.join(" ")
+        key = key.gsub(" ", "-")
+        headers[key] = val
+      end
+    end
+    
+    #Make request.
+    uri = Knj::Web.parse_uri(cgi.env_table["REQUEST_URI"])
+    url = File.basename(uri[:path])
+    
+    if cgi.env_table["QUERY_STRING"].to_s.length > 0
+      url << "?#{cgi.env_table["QUERY_STRING"]}"
+    end
+    
+    #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
+        }
+      )
+    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
+        }
+      )
+    end
+    
+    end
+  end
+end

data/lib/hayabusa_custom_io.rb

@@ -0,0 +1,22 @@
+class Hayabusa::Custom_io < StringIO
+  def print(str)
+    str = str.to_s
+    
+    if appsrv = Thread.current[:hayabusa] and cgroup = appsrv[:contentgroup] and httpsession = appsrv[:httpsession]
+      httpsession.add_size(str.size)
+      cgroup.write(str)
+    else
+      STDOUT.print(str) if !STDOUT.closed?
+    end
+  end
+  
+  def puts(str)
+    res = self.print(str)
+    self.print "\n"
+    return res
+  end
+  
+  alias << print
+  alias write print
+  alias p print
+end

data/lib/hayabusa_database.rb

@@ -0,0 +1,125 @@
+class Hayabusa::Database
+  SCHEMA = {
+    "tables" => {
+      "Log" => {
+        "columns" => [
+          {"name" => "id", "type" => "bigint", "autoincr" => true, "primarykey" => true},
+          {"name" => "text_value_id", "type" => "bigint"},
+          {"name" => "date_saved", "type" => "datetime"},
+          {"name" => "get_keys_data_id", "type" => "bigint"},
+          {"name" => "get_values_data_id", "type" => "bigint"},
+          {"name" => "post_keys_data_id", "type" => "bigint"},
+          {"name" => "post_values_data_id", "type" => "bigint"},
+          {"name" => "cookie_keys_data_id", "type" => "bigint"},
+          {"name" => "cookie_values_data_id", "type" => "bigint"},
+          {"name" => "meta_keys_data_id", "type" => "bigint"},
+          {"name" => "meta_values_data_id", "type" => "bigint"},
+          {"name" => "session_keys_data_id", "type" => "bigint"},
+          {"name" => "session_values_data_id", "type" => "bigint"},
+          {"name" => "tag_data_id", "type" => "bigint"},
+          {"name" => "comment_data_id", "type" => "bigint"}
+        ],
+        "indexes" => [
+          {"name" => "text_value_id", "columns" => ["text_value_id"]},
+          {"name" => "tag_data_id", "columns" => ["tag_data_id"]},
+          {"name" => "comment_data_id", "columns" => ["comment_data_id"]}
+        ]
+      },
+      "Log_access" => {
+        "columns" => [
+          {"name" => "id", "type" => "bigint", "autoincr" => true, "primarykey" => true},
+          {"name" => "session_id", "type" => "bigint"},
+          {"name" => "date_request", "type" => "datetime"},
+          {"name" => "ip_data_id", "type" => "bigint"},
+          {"name" => "get_keys_data_id", "type" => "bigint"},
+          {"name" => "get_values_data_id", "type" => "bigint"},
+          {"name" => "post_keys_data_id", "type" => "bigint"},
+          {"name" => "post_values_data_id", "type" => "bigint"},
+          {"name" => "cookie_keys_data_id", "type" => "bigint"},
+          {"name" => "cookie_values_data_id", "type" => "bigint"},
+          {"name" => "meta_keys_data_id", "type" => "bigint"},
+          {"name" => "meta_values_data_id", "type" => "bigint"}
+        ],
+        "indexes" =>  [
+          {"name" => "session_id", "columns" => ["session_id"]},
+          {"name" => "date_request", "columns" => ["date_request"]}
+        ]
+      },
+      "Log_data" => {
+        "columns" => [
+          {"name" => "id", "type" => "bigint", "autoincr" => true, "primarykey" => true},
+          {"name" => "id_hash", "type" => "varchar"}
+        ],
+        "indexes" => [
+          {"name" => "id_hash", "columns" => ["id_hash"]}
+        ]
+      },
+      "Log_data_link" => {
+        "columns" => [
+          {"name" => "id", "type" => "bigint", "autoincr" => true, "primarykey" => true},
+          {"name" => "no", "type" => "int"},
+          {"name" => "data_id", "type" => "bigint"},
+          {"name" => "value_id", "type" => "bigint"}
+        ],
+        "indexes" => [
+          {"name" => "data_id", "columns" => ["data_id"]},
+          {"name" => "value_id", "columns" => ["value_id"]}
+        ]
+      },
+      "Log_data_value" => {
+        "columns" => [
+          {"name" => "id", "type" => "bigint", "autoincr" => true, "primarykey" => true},
+          {"name" => "value", "type" => "text"}
+        ]
+      },
+      "Log_link" => {
+        "columns" => [
+          {"name" => "id", "type" => "bigint", "autoincr" => true, "primarykey" => true},
+          {"name" => "log_id", "type" => "bigint"},
+          {"name" => "object_class_value_id", "type" => "bigint"},
+          {"name" => "object_id", "type" => "bigint"}
+        ],
+        "indexes" => [
+          {"name" => "log_id", "columns" => ["log_id"]},
+          {"name" => "object_id", "columns" => ["object_id"]},
+          {"name" => "object_class_value_id", "columns" => ["object_class_value_id"]},
+          {"name" => "object_lookup", "columns" => ["object_class_value_id", "object_id"]},
+          {"name" => "log_lookup", "columns" => ["object_class_value_id", "object_id", "log_id"]}
+        ]
+      },
+      "Session" => {
+        "columns" => [
+          {"name" => "id", "type" => "bigint", "autoincr" => true, "primarykey" => true},
+          {"name" => "idhash", "type" => "varchar"},
+          {"name" => "sess_data", "type" => "text"},
+          {"name" => "date_added", "type" => "datetime"},
+          {"name" => "date_lastused", "type" => "datetime", "on_created" => proc{|d| d["db"].query("UPDATE Session SET date_lastused = '#{Datet.new.dbstr}'")}},
+          {"name" => "ip", "type" => "varchar", "maxlength" => 15},
+          {"name" => "user_agent", "type" => "text"},
+          {"name" => "remember", "type" => "enum", "maxlength" => "'0','1'", "default" => 0, "comment" => "If the session should be remembered or not."}
+        ],
+        "indexes" => [
+          {"name" => "date_added", "columns" => ["date_added"]},
+          {"name" => "idhash", "columns" => ["idhash"]}
+        ],
+        "renames" => ["sessions"]
+      },
+      "Translation" => {
+        "columns" => [
+          {"name" => "id", "type" => "bigint", "autoincr" => true, "primarykey" => true},
+          {"name" => "object_class", "type" => "varchar", "maxlength" => 50},
+          {"name" => "object_id", "type" => "bigint"},
+          {"name" => "key", "type" => "varchar", "maxlength" => 50},
+          {"name" => "locale", "type" => "varchar", "maxlength" => 5},
+          {"name" => "value", "type" => "text"}
+        ],
+        "indexes" => [
+          {"name" => "lookup", "columns" => ["object_class", "object_id", "key", "locale"]}
+        ],
+        "indexes_remove" => {
+          "object_class" => true
+        }
+      }
+    }
+  }
+end

data/lib/hayabusa_erb_handler.rb

@@ -0,0 +1,27 @@
+class Hayabusa::Erb_handler
+  def initialize
+    @connected = {}
+  end
+  
+  def erb_handler(httpsess)
+    eruby = httpsess.eruby
+    
+    if !@connected.key?(eruby.__id__)
+      eruby.connect("error", &self.method(:on_error))
+      @connected[eruby.__id__] = true
+    end
+    
+    if !File.exists?(httpsess.page_path)
+      eruby.import("#{File.dirname(__FILE__)}/../pages/error_notfound.rhtml")
+    else
+      eruby.import(httpsess.page_path)
+    end
+    
+    httpsess.resp.status = 500 if eruby.error
+  end
+  
+  #Handels the event when an error in the eruby-instance occurs.
+  def on_error(e)
+    _hb.handle_error(e)
+  end
+end

data/lib/hayabusa_ext/cleaner.rb

@@ -0,0 +1,140 @@
+class Hayabusa
+  def initialize_cleaner
+    #This should not be runned via _hb.timeout because timeout wont run when @should_restart is true! - knj
+    Thread.new(&self.method(:clean_autorestart))
+    
+    #This flushes (writes) all session-data to the server and deletes old unused sessions from the database.
+    self.timeout(:time => @config[:cleaner_timeout], &self.method(:clean_sessions))
+  end
+  
+  def clean
+    self.clean_sessions
+    self.clean_autorestart
+  end
+  
+  def clean_autorestart
+    begin
+      if @config[:autorestart]
+        time = 1
+      else
+        time = 15
+      end
+      
+      loop do
+        sleep time
+        
+        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]
+          
+          if mbs_used.to_i >= @config[:restart_when_used_memory].to_i
+            STDOUT.print "Memory is over #{@config[:restart_when_used_memory]} - restarting.\n"
+            @should_restart = true
+          end
+        end
+        
+        if @should_restart and !@should_restart_done and !@should_restart_runnning
+          begin
+            @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.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.
+            begin
+              Timeout.timeout(30) do
+                loop do
+                  working_count = self.httpserv.working_count
+                  working = false
+                  
+                  if working_count and working_count > 0
+                    working = true
+                    STDOUT.print "Someone is working - wait two sec and try to restart again!\n"
+                  end
+                  
+                  if !working
+                    STDOUT.print "Found window where no sessions were active - restarting!\n"
+                    break
+                  else
+                    sleep 0.2
+                  end
+                  
+                  STDOUT.print "Trying to find window with no active sessions to restart...\n"
+                end
+              end
+            rescue Timeout::Error
+              STDOUT.print "Could not find a timing window for restarting... Forcing restart!\n"
+            end
+            
+            #Flush emails again if any are pending (while we tried to find a window to restart)...
+            STDOUT.print "Flushing mails.\n"
+            self.mail_flush
+            
+            STDOUT.print "Stopping appserver.\n"
+            self.stop
+            
+            STDOUT.print "Figuring out restart-command.\n"
+            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"
+              mycmd = mycmd.gsub(/\s+hayabusa.rb/, " #{Knj::Strings.unixsafe(fpath)}")
+            end
+            
+            STDOUT.print "Restarting knjAppServer with command: #{mycmd}\n"
+            @should_restart_done = true
+            print exec(mycmd)
+            exit
+          rescue => e
+            STDOUT.puts e.inspect
+            STDOUT.puts e.backtrace
+          end
+        end
+      end
+    rescue => e
+      self.handle_error(e)
+    end
+  end
+  
+  #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]
+    
+    #Clean up various inactive sessions.
+    session_not_ids = []
+    time_check = Time.now.to_i - 300
+    newsessions = {}
+    @sessions.each do |session_hash, session_data|
+      session_data[:dbobj].flush
+      
+      if session_data[:time_lastused].to_i > time_check
+        newsessions[session_hash] = session_data
+        session_not_ids << session_data[:dbobj].id
+      end
+    end
+    
+    @sessions = newsessions
+    
+    STDOUT.print "Delete sessions...\n" if @config[: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]
+      @ob.delete(session)
+      @sessions.delete(idhash)
+    end
+    
+    #Clean database weak references from the tables-module.
+    @db.clean
+    
+    #Clean the object-handler.
+    @ob.clean_all
+    
+    #Call various user-connected methods.
+    @events.call(:on_clean) if @events
+  end
+end