hayabusa 0.0.1

data/lib/hayabusa_ext/cmdline.rb

@@ -0,0 +1,52 @@
+class Hayabusa
+  def initialize_cmdline
+    @cmds = {}
+    
+    Thread.new do
+      begin
+        $stdin.each_line do |line|
+          called = 0
+          @cmds.each do |key, connects|
+            data = {}
+            
+            if key.is_a?(Regexp)
+              if line.match(key)
+                connects.each do |conn|
+                  called += 1
+                  conn[:block].call(data)
+                end
+              end
+            else
+              raise "Unknown class for 'cmd_connect': '#{key.class.name}'."
+            end
+          end
+          
+          if called == 0
+            print "Unknown command: '#{line.strip}'.\n"
+          end
+        end
+      rescue => e
+        self.handle_error(e)
+      end
+    end
+    
+    self.cmd_connect(/^\s*restart\s*$/i, &self.method(:cmdline_on_restart_cmd))
+    self.cmd_connect(/^\s*stop\s*$/i, &self.method(:cmdline_on_stop_cmd))
+  end
+  
+  def cmdline_on_restart_cmd(data)
+    print "Restart will begin shortly.\n"
+    self.should_restart = true
+  end
+  
+  def cmdline_on_stop_cmd(data)
+    print "Stopping appserver.\n"
+    self.stop
+  end
+  
+  #Connects a proc to a specific command in the command-line (key should be a regex).
+  def cmd_connect(cmd, &block)
+    @cmds[cmd] = [] if !@cmds.key?(cmd)
+    @cmds[cmd] << {:block => block}
+  end
+end

data/lib/hayabusa_ext/errors.rb

@@ -0,0 +1,135 @@
+class Hayabusa
+  attr_reader :error_emails_pending
+  
+  def initialize_errors
+    @error_emails_pending = {}
+    @error_emails_pending_mutex = Mutex.new
+    
+    if @config[:error_emails_time]
+      @error_emails_time = @config[:error_emails_time]
+    elsif @config[:debug]
+      @error_emails_time = 5
+    else
+      @error_emails_time = 180
+    end
+    
+    self.timeout(:time => @error_emails_time, &self.method(:flush_error_emails))
+  end
+  
+  #Send error-emails based on error-emails-cache (cached so the same error isnt send out every time it occurrs to prevent spamming).
+  def flush_error_emails
+    @error_emails_pending_mutex.synchronize do
+      send_time_older_than = Time.new.to_i - @error_emails_time
+      
+      @error_emails_pending.each do |backtrace_hash, error_email|
+        if send_time_older_than < error_email[:last_time].to_i and error_email[:messages].length < 1000
+          next
+        end
+        
+        @config[:error_report_emails].each do |email|
+          next if !email or error_email[:messages].length <= 0
+          
+          if error_email[:messages].length == 1
+            html = error_email[:messages].first
+          else
+            html = "<b>First time:</b> #{Datet.in(error_email[:first_time]).out}<br />"
+            html << "<b>Last time:</b> #{Datet.in(error_email[:last_time]).out}<br />"
+            html << "<b>Number of errors:</b> #{error_email[:messages].length}<br />"
+            count = 0
+            
+            error_email[:messages].each do |error_msg|
+              count += 1
+              
+              if count > 10
+                html << "<br /><br /><b><i>Limiting to showing 10 out of #{error_email[:messages].length} messages.</i></b>"
+                break
+              end
+              
+              html << "<br /><br />"
+              html << "<b>Message #{count}</b><br />"
+              html << error_msg
+            end
+          end
+          
+          self.mail(
+            :to => email,
+            :subject => error_email[:subject],
+            :html => html,
+            :from => @config[:error_report_from]
+          )
+        end
+        
+        @error_emails_pending.delete(backtrace_hash)
+      end
+    end
+  end
+  
+  #Handels a given error. Sends to the admin-emails.
+  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"
+      end
+      
+      browser = _httpsession.browser if _httpsession
+      
+      send_email = true
+      send_email = false if !@config[:smtp_args]
+      send_email = false if !@config[:error_report_emails]
+      send_email = false if args.has_key?(:email) and !args[:email]
+      send_email = false if @config.key?(:error_report_bots) and !@config[:error_report_bots] and browser and browser["browser"] == "bot"
+      
+      if send_email
+        backtrace_hash = Knj::ArrayExt.array_hash(e.backtrace)
+        
+        if !@error_emails_pending.has_key?(backtrace_hash)
+          @error_emails_pending[backtrace_hash] = {
+            :first_time => Time.new,
+            :messages => [],
+            :subject => sprintf("Error @ %s", @config[:title]) + " (#{Knj::Strings.shorten(e.message, 100)})"
+          }
+        end
+        
+        html = "An error occurred.<br /><br />"
+        html << "<b>#{Knj::Web.html(e.class.name)}: #{Knj::Web.html(e.message)}</b><br /><br />"
+        
+        e.backtrace.each do |line|
+          html << "#{Knj::Web.html(line)}<br />"
+        end
+        
+        html << "<br /><b>Post:</b><br /><pre>#{Php4r.print_r(_post, true)}</pre>" if _post
+        html << "<br /><b>Get:</b><br /><pre>#{Php4r.print_r(_get, true)}</pre>" if _get
+        html << "<br /><b>Server:</b><br /><pre>#{Php4r.print_r(_server, true).html}</pre>" if _server
+        html << "<br /><b>Cookie:</b><br /><pre>#{Php4r.print_r(_cookie, true).html}</pre>" if _meta
+        html << "<br /><b>Session:</b><br /><pre>#{Php4r.print_r(_session, true).html}</pre>" if _session
+        html << "<br /><b>Session hash:</b><br /><pre>#{Php4r.print_r(_session_hash, true).html}</pre>" if _session_hash
+        
+        error_hash = @error_emails_pending[backtrace_hash]
+        error_hash[:last_time] = Time.new
+        error_hash[:messages] << html
+      end
+    end
+  end
+  
+  #Takes a proc and executes it. On error it alerts the error-message with javascript to the server, sends a javascript back and exits.
+  def on_error_go_back(&block)
+    begin
+      block.call
+    rescue => e
+      self.alert(e.message).back
+    end
+  end
+  
+  #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)
+  end
+  
+  #Prints a string with a single file-line-backtrace prepended which is useful for debugging.
+  def debugs(str)
+    #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"
+  end
+end

data/lib/hayabusa_ext/logging.rb

@@ -0,0 +1,404 @@
+class Hayabusa
+  def initialize_logging
+    @logs_access_pending = []
+    @logs_mutex = Mutex.new
+    
+    if @config[:logging] and @config[:logging][:access_db]
+      self.timeout(:time => 30, &self.method(:flush_access_log))
+    end
+  end
+  
+  #Writes all queued access-logs to the database.
+  def flush_access_log
+    return nil if @logs_access_pending.empty?
+    
+    @logs_mutex.synchronize do
+      ins_arr = @logs_access_pending
+      @logs_access_pending = []
+      inserts = []
+      inserts_links = []
+      
+      ins_arr.each do |ins|
+        gothrough = [{
+          :col => :get_keys_data_id,
+          :hash => ins[:get],
+          :type => :keys
+        },{
+          :col => :get_values_data_id,
+          :hash => ins[:get],
+          :type => :values
+        },{
+          :col => :post_keys_data_id,
+          :hash => ins[:post],
+          :type => :keys
+        },{
+          :col => :post_values_data_id,
+          :hash => ins[:post],
+          :type => :values
+        },{
+          :col => :cookie_keys_data_id,
+          :hash => ins[:cookie],
+          :type => :keys
+        },{
+          :col => :cookie_values_data_id,
+          :hash => ins[:cookie],
+          :type => :values
+        },{
+          :col => :meta_keys_data_id,
+          :hash => ins[:meta],
+          :type => :keys
+        },{
+          :col => :meta_values_data_id,
+          :hash => ins[:meta],
+          :type => :values
+        }]
+        ins_hash = {
+          :session_id => ins[:session_id],
+          :date_request => ins[:date_request]
+        }
+        
+        gothrough.each do |data|
+          if data[:type] == :keys
+            hash = Knj::ArrayExt.hash_keys_hash(data[:hash])
+          else
+            hash = Knj::ArrayExt.hash_values_hash(data[:hash])
+          end
+          
+          data_id = @ob.static(:Log_data, :by_id_hash, hash)
+          if !data_id
+            data_id = @db.insert(:Log_data, {"id_hash" => hash}, {:return_id => true})
+            
+            link_count = 0
+            data[:hash].keys.sort.each do |key|
+              if data[:type] == :keys
+                ins_data = "#{key.to_s}"
+              else
+                ins_data = "#{data[:hash][key]}"
+              end
+              
+              ins_data = ins_data.force_encoding("UTF-8") if ins_data.respond_to?(:force_encoding)
+              data_value_id = @ob.static(:Log_data_value, :force_id, ins_data)
+              inserts_links << {:no => link_count, :data_id => data_id, :value_id => data_value_id}
+              link_count += 1
+            end
+          end
+          
+          ins_hash[data[:col]] = data_id
+        end
+        
+        hash = Knj::ArrayExt.array_hash(ins[:ips])
+        data_id = @ob.static(:Log_data, :by_id_hash, hash)
+        
+        if !data_id
+          data_id = @db.insert(:Log_data, {"id_hash" => hash}, {:return_id => true})
+          
+          link_count = 0
+          ins[:ips].each do |ip|
+            data_value_id = @ob.static(:Log_data_value, :force_id, ip)
+            inserts_links << {:no => link_count, :data_id => data_id, :value_id => data_value_id}
+            link_count += 1
+          end
+        end
+        
+        ins_hash[:ip_data_id] = data_id
+        inserts << ins_hash
+      end
+      
+      @db.insert_multi(:Log_access, inserts)
+      @db.insert_multi(:Log_data_link, inserts_links)
+      @ob.unset_class([:Log_access, :Log_data, :Log_data_link, :Log_data_value])
+    end
+  end
+  
+  #Converts fileuploads into strings so logging wont be crazy big.
+  def log_hash_safe(hash)
+    hash_obj = {}
+    hash.each do |key, val|
+      if val.is_a?(Hayabusa::Http_session::Post_multipart::File_upload)
+        hash_obj[key] = "<Fileupload>"
+      elsif val.is_a?(Hash)
+        hash_obj[key] = self.log_hash_safe(val)
+      else
+        hash_obj[key] = val
+      end
+    end
+    
+    return hash_obj
+  end
+  
+  #Handles the hashes that should be logged.
+  def log_hash_ins(hash_obj)
+    #Sort out fileuploads - it would simply bee too big to log this.
+    hash_obj = self.log_hash_safe(hash_obj)
+    
+    inserts_links = []
+    ret = {}
+    [:keys, :values].each do |type|
+      if type == :keys
+        hash = Knj::ArrayExt.hash_keys_hash(hash_obj)
+      else
+        hash = Knj::ArrayExt.hash_values_hash(hash_obj)
+      end
+      
+      data_id = @db.single(:Log_data, {"id_hash" => hash})
+      data_id = data_id[:id] if data_id
+      
+      if !data_id
+        data_id = @db.insert(:Log_data, {"id_hash" => hash}, {:return_id => true})
+        
+        link_count = 0
+        hash_obj.keys.sort.each do |key|
+          if type == :keys
+            ins_data = "#{key.to_s}"
+          else
+            ins_data = "#{hash_obj[key].to_s}"
+          end
+          
+          ins_data = ins_data.force_encoding("UTF-8") if ins_data.respond_to?(:force_encoding)
+          data_value_id = @ob.static(:Log_data_value, :force_id, ins_data)
+          inserts_links << {:no => link_count, :data_id => data_id, :value_id => data_value_id}
+          link_count += 1
+        end
+      end
+      
+      if type == :keys
+        ret[:keys_data_id] = data_id
+      else
+        ret[:values_data_id] = data_id
+      end
+    end
+    
+    @db.insert_multi(:Log_data_link, inserts_links)
+    
+    return ret
+  end
+  
+  def log_data_hash(keys_id, values_id)
+    begin
+      keys_data_obj = @ob.get(:Log_data, keys_id)
+      values_data_obj = @ob.get(:Log_data, values_id)
+    rescue Errno::ENOENT
+      return {}
+    end
+    
+    sql = "
+      SELECT
+        key_value.value AS `key`,
+        value_value.value AS value
+      
+      FROM
+        Log_data_link AS key_links,
+        Log_data_link AS value_links,
+        Log_data_value AS key_value,
+        Log_data_value AS value_value
+      
+      WHERE
+        key_links.data_id = '#{keys_id}' AND
+        value_links.data_id = '#{values_id}' AND
+        key_links.no = value_links.no AND
+        key_value.id = key_links.value_id AND
+        value_value.id = value_links.value_id
+      
+      ORDER BY
+        key_links.no
+    "
+    
+    hash = {}
+    db.q(sql) do |d_hash|
+      hash[d_hash[:key].to_sym] = d_hash[:value]
+    end
+    
+    return hash
+  end
+  
+  #Writes a custom log to the database.
+  def log(msg, objs, args = {})
+    #This can come in handy if migrating logs to appserver-database.
+    if args[:date_saved]
+      date_saved = args[:date_saved]
+    else
+      date_saved = Time.now
+    end
+    
+    objs = [objs] if !objs.is_a?(Array)
+    
+    @logs_mutex.synchronize do
+      log_value_id = @ob.static(:Log_data_value, :force_id, msg)
+      
+      ins_data = {
+        :date_saved => date_saved,
+        :text_value_id => log_value_id
+      }
+      
+      get_hash = log_hash_ins(_get) if _get
+      if get_hash
+        ins_data[:get_keys_data_id] = get_hash[:keys_data_id]
+        ins_data[:get_values_data_id] = get_hash[:values_data_id]
+      end
+      
+      post_hash = log_hash_ins(_post) if _post
+      if post_hash
+        ins_data[:post_keys_data_id] = post_hash[:keys_data_id]
+        ins_data[:post_values_data_id] = post_hash[:values_data_id]
+      end
+      
+      cookie_hash = log_hash_ins(_cookie) if _cookie
+      if cookie_hash
+        ins_data[:post_keys_data_id] = cookie_hash[:keys_data_id]
+        ins_data[:post_values_data_id] = cookie_hash[:values_data_id]
+      end
+      
+      meta_hash = log_hash_ins(_meta) if _meta
+      if cookie_hash
+        ins_data[:meta_keys_data_id] = meta_hash[:keys_data_id]
+        ins_data[:meta_values_data_id] = meta_hash[:values_data_id]
+      end
+      
+      session_hash = log_hash_ins(_session) if _session
+      if session_hash
+        ins_data[:session_keys_data_id] = session_hash[:keys_data_id]
+        ins_data[:session_values_data_id] = session_hash[:values_data_id]
+      end
+      
+      if args[:tag]
+        tag_value_id = @ob.static(:Log_data_value, :force_id, args[:tag])
+        ins_data[:tag_data_id] = tag_value_id
+      end
+      
+      if args[:comment]
+        comment_value_id = @ob.static(:Log_data_value, :force_id, args[:comment])
+        ins_data[:comment_data_id] = comment_value_id
+      end
+      
+      log_id = @db.insert(:Log, ins_data, {:return_id => true})
+      
+      log_links = []
+      objs.each do |obj|
+        class_data_id = @ob.static(:Log_data_value, :force_id, obj.class.name)
+        
+        log_links << {
+          :object_class_value_id => class_data_id,
+          :object_id => obj.id,
+          :log_id => log_id
+        }
+      end
+      
+      @db.insert_multi(:Log_link, log_links)
+    end
+  end
+  
+  #Deletes all logs for an object.
+  def logs_delete(obj)
+    @db.q_buffer do |db_buffer|
+      buffer_hash = {:db_buffer => db_buffer}
+      
+      @ob.list(:Log_link, {"object_class" => obj.class.name, "object_id" => obj.id}) do |log_link|
+        log = log_link.log
+        @ob.delete(log_link, buffer_hash)
+        @ob.delete(log, buffer_hash) if log and log.links("count" => true) <= 0
+      end
+    end
+  end
+  
+  #Returns the HTML for a table with logs from a given object.
+  def logs_table(obj, args = {})
+    if args[:out]
+      html = args[:out]
+    else
+      html = $stdout
+    end
+    
+    html = ""
+    
+    html << "<table class=\"list hayabusa_log_table\">"
+    html << "<thead>"
+    html << "<tr>"
+    html << "<th>ID</th>"
+    html << "<th>Message</th>"
+    html << "<th style=\"width: 130px;\">Date &amp; time</th>"
+    html << "<th>Tag</th>"
+    html << "<th>Objects</th>" if args[:ob_use]
+    html << "<th>IP</th>" if args[:show_ip]
+    html << "</tr>"
+    html << "</thead>"
+    html << "<tbody>"
+    
+    count = 0
+    @ob.list(:Log_link, {"object_class" => obj.class.name, "object_id" => obj.id, "limit" => 500, "orderby" => [["id", "desc"]]}) do |link|
+      count += 1
+      log = link.log
+      
+      msg_lines = log.text.split("\n")
+      first_line = msg_lines[0].to_s
+      
+      classes = ["hayabusa_log", "hayabusa_log_#{log.id}"]
+      classes << "hayabusa_log_multiple_lines" if msg_lines.length > 1
+      
+      html << "<tr class=\"#{classes.join(" ")}\">"
+      html << "<td>#{log.id}</td>"
+      html << "<td>#{first_line.html}</td>"
+      html << "<td>#{log.date_saved_str}</td>"
+      html << "<td>#{log.tag.html}</td>"
+      
+      if args[:ob_use]
+        begin
+          html << "<td>#{log.objects_html(args[:ob_use])}</td>"
+        rescue => e
+          html << "<td>#{e.message.html}</td>"
+        end
+      end
+      
+      html << "<td>#{log.ip}</td>" if args[:show_ip]
+      html << "</tr>"
+    end
+    
+    if count <= 0
+      html << "<tr>"
+      html << "<td colspan=\"2\" class=\"error\">No logs were found for that object.</td>"
+      html << "</tr>"
+    end
+    
+    html << "</tbody>"
+    html << "</table>"
+    
+    return nil
+  end
+  
+  #Removes all logs for objects that have been deleted.
+  #===Examples
+  #Remember to pass Knj::Objects-object handler to the method.
+  # appsrv.logs_delete_dead(:ob => ob, :debug => false)
+  def logs_delete_dead(args)
+    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]
+      @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])
+        next if obj_exists
+        
+        log = log_link.log
+        
+        STDOUT.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]
+          @ob.delete(log, :db_buffer => db_buffer)
+        end
+      end
+      
+      STDOUT.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]
+        @ob.delete(log, :db_buffer => db_buffer)
+      end
+    end
+  end
+end