hayabusa 0.0.1

data/lib/hayabusa_ext/mailing.rb

@@ -0,0 +1,158 @@
+require "monitor"
+
+class Hayabusa
+  attr_reader :mails_waiting
+  
+  def initialize_mailing
+    require "knj/autoload/ping"
+    require "monitor"
+    
+    @mails_waiting = []
+    @mails_mutex = Monitor.new
+    @mails_queue_mutex = Monitor.new
+    @mails_timeout = self.timeout(:time => 30, &self.method(:mail_flush))
+  end
+  
+  #Queue a mail for sending. Possible keys are: :subject, :from, :to, :text and :html.
+  def mail(mail_args)
+    raise "'smtp_args' has not been given for the Hayabusa." if !@config[:smtp_args]
+    
+    @mails_queue_mutex.synchronize do
+      count_wait = 0
+      while @mails_waiting.length > 100
+        if count_wait >= 30
+          raise "Could not send email - too many emails was pending and none of them were being sent?"
+        end
+        
+        count_wait += 1
+        sleep 1
+      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
+      @mails_waiting << mailobj
+      self.mail_flush if mail_args[:now]
+      return mailobj
+    end
+  end
+  
+  #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
+      
+      if @mails_waiting.length <= 0
+        STDOUT.print "No mails to flush - skipping.\n" if @debug
+        return false
+      end
+      
+      STDOUT.print "Trying to ping Google to figure out if we are online...\n" if @debug
+      status = Ping.pingecho("google.dk", 10, 80)
+      if !status
+        STDOUT.print "We are not online - skipping mail flush.\n"
+        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
+      
+      begin
+        #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
+        require "knj/process_meta"
+        subproc = Knj::Process_meta.new("debug" => @debug, "debug_err" => true, "id" => "hayabusa_mailing")
+        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
+        @mails_waiting.each do |mail|
+          begin
+            STDOUT.print "Sending email: #{mail.__id__}\n" if @debug
+            if mail.send("proc" => subproc)
+              STDOUT.print "Email sent: #{mail.__id__}\n" if @debug
+              @mails_waiting.delete(mail)
+            end
+          rescue Timeout::Error
+            #ignore - 
+          rescue => e
+            @mails_waiting.delete(mail)
+            self.handle_error(e, {:email => false})
+          end
+          
+          sleep 1 #sleep so we dont take up too much bandwidth.
+        end
+      ensure
+        subproc.destroy if subproc
+        subproc = nil
+      end
+      
+      return nil
+    end
+  end
+  
+  #This class represents the queued mails.
+  class Mail
+    def initialize(args)
+      @args = args
+      
+      raise "No hayabusa-object was given (as :hb)." if !@args[:hb].is_a?(Hayabusa)
+      raise "No :to was given." if !@args[:to]
+      raise "No content was given (:html or :text)." if !@args[:html] and !@args[:text]
+    end
+    
+    #Returns a key from the arguments.
+    def [](key)
+      return @args[key]
+    end
+    
+    #Sends the email to the receiver.
+    def send(args = {})
+      STDOUT.print "Sending mail '#{__id__}'.\n" if @args[:hb].debug
+      
+      if @args[:from]
+        from = @args[:from]
+      elsif @args[:hb].config[:error_report_from]
+        from = @args[:hb].config[:error_report_from]
+      else
+        raise "Dont know where to take the 'from'-paramter from - none given in appserver config or mail-method-arguments?"
+      end
+      
+      if args["proc"]
+        args["proc"].static("Object", "require", "knj/mailobj")
+        mail = args["proc"].new("Knj::Mailobj", @args[:hb].config[:smtp_args])
+        mail._pm_send_noret("to=", @args[:to])
+        mail._pm_send_noret("subject=", @args[:subject]) if @args[:subject]
+        mail._pm_send_noret("html=", Knj::Strings.email_str_safe(@args[:html])) if @args[:html]
+        mail._pm_send_noret("text=", Knj::Strings.email_str_safe(@args[:text])) if @args[:text]
+        mail._pm_send_noret("from=", from)
+        mail._pm_send_noret("send")
+      else
+        require "knj/mailobj"
+        mail = Knj::Mailobj.new(@args[:hb].config[:smtp_args])
+        mail.to = @args[:to]
+        mail.subject = @args[:subject] if @args[:subject]
+        mail.html = Knj::Strings.email_str_safe(@args[:html]) if @args[:html]
+        mail.text = Knj::Strings.email_str_safe(@args[:text]) if @args[:text]
+        mail.from = from
+        mail.send
+      end
+      
+      @args[:status] = :sent
+      STDOUT.print "Sent email #{self.__id__}\n" 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
+      end
+      
+      @args[:errors][e.class.name] = {:count => 0} if !@args[:errors].has_key?(e.class.name)
+      @args[:errors][e.class.name][:count] += 1
+      raise e if @args[:errors][e.class.name][:count] >= 5
+      @args[:status] = :error
+      @args[:error] = e
+      
+      return false
+    end
+  end
+end

data/lib/hayabusa_ext/sessions.rb

@@ -0,0 +1,71 @@
+class Hayabusa
+  def initialize_sessions
+    @sessions = Tsafe::MonHash.new
+  end
+  
+  #Returns or adds session based on idhash and meta-data.
+  def session_fromid(ip, idhash, meta)
+    ip = "bot" if idhash == "bot"
+    
+    if !@sessions.key?(idhash)
+      session = @ob.get_by(:Session, {"idhash" => idhash})
+      if !session
+        session = @ob.add(:Session, {
+          :idhash => idhash,
+          :user_agent => meta["HTTP_USER_AGENT"],
+          :ip => ip
+        })
+      end
+      
+      hash = {}
+      @sessions[idhash] = {
+        :dbobj => session,
+        :hash => hash
+      }
+    else
+      session = @sessions[idhash][:dbobj]
+      hash = @sessions[idhash][:hash]
+    end
+    
+    if ip != "bot" and !session.remember? and ip.to_s != session[:ip].to_s
+      raise ArgumentError, "Invalid IP."
+    end
+    
+    @sessions[idhash][:time_lastused] = Time.now
+    return [session, hash]
+  end
+  
+  #Generates a new session-ID by the meta data.
+  def session_generate_id(meta)
+    return Digest::MD5.hexdigest("#{Time.now.to_f}_#{meta["HTTP_HOST"]}_#{meta["REMOTE_HOST"]}_#{meta["HTTP_X_FORWARDED_SERVER"]}_#{meta["HTTP_X_FORWARDED_FOR"]}_#{meta["HTTP_X_FORWARDED_HOST"]}_#{meta["REMOTE_ADDR"]}_#{meta["HTTP_USER_AGENT"]}")
+  end
+  
+  #Will make the session rememberable for a year. IP wont be checked any more.
+  def session_remember
+    session = _httpsession.session
+    session[:remember] = 1
+    
+    self.cookie(
+      "name" => "HayabusaSession",
+      "value" => _httpsession.session_id,
+      "path" => "/",
+      "expires" => Time.now + 32140800 #add around 12 months
+    )
+  end
+  
+  #Writes all session-data to the database (normally it is cached in memory and not updated on change).
+  def sessions_flush
+    if @sessions
+      @sessions.each do |session_hash, session_data|
+        STDOUT.print "Flushing session: #{session_data[:dbobj].id}\n" if @debug
+        session_data[:dbobj].flush
+      end
+    end
+  end
+  
+  #Writes all session-data and resets the hash.
+  def sessions_reset
+    self.sessions_flush
+    @sessions = {}
+  end
+end

data/lib/hayabusa_ext/threadding.rb

@@ -0,0 +1,96 @@
+class Hayabusa
+  def initialize_threadding
+    @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))
+  end
+  
+  #Callback for when an error occurs in the threadpool.
+  def threadpool_on_error(event, error)
+    self.handle_error(error)
+  end
+  
+  #Inits the thread so it has access to the appserver and various magic methods can be used.
+  def thread_init(thread = nil)
+    thread = Thread.current if thread == nil
+    thread[:hayabusa] = {} if !thread[:hayabusa]
+    thread[:hayabusa][:hb] = self
+  end
+  
+  #Spawns a new thread with access to magic methods, _db-method and various other stuff in the appserver.
+  def thread(args = {})
+    raise "No block given." if !block_given?
+    args[:args] = [] if !args[:args]
+    
+    thread_obj = Hayabusa::Thread_instance.new(
+      :running => false,
+      :error => false,
+      :done => false
+    )
+    
+    @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
+        thread_obj.args[:running] = true
+        yield(*args[:args])
+      rescue => e
+        self.handle_error(e)
+        thread_obj.args[:error] = true
+        thread_obj.args[:error_obj] = e
+      ensure
+        STDOUT.print "Free thread ob-db.\n" if @debug
+        @ob.db.free_thread if @ob.db.opts[:threadsafe]
+        
+        STDOUT.print "Free thread db-handler.\n" if @debug
+        @db_handler.free_thread if @db_handler.opts[:threadsafe]
+        
+        STDOUT.print "Set args on thread.\n" if @debug
+        thread_obj.args[:running] = false
+        thread_obj.args[:done] = true
+      end
+    end
+    
+    return thread_obj
+  end
+  
+  #Runs a proc every number of seconds.
+  def timeout(args = {}, &block)
+    return Hayabusa::Threadding_timeout.new({
+      :hb => self,
+      :block => block,
+      :args => []
+    }.merge(args)).start
+  end
+  
+  #Spawns a thread to run the given proc and add the output of that block in the correct order to the HTML.
+  def threadded_content(&block)
+    _httpsession.threadded_content(block)
+    return nil
+  end
+end
+
+class Hayabusa::Thread_instance
+  attr_reader :args
+  
+  def initialize(args)
+    @args = args
+  end
+  
+  def join
+    sleep 0.1 while !@args[:done]
+  end
+  
+  def join_error
+    self.join
+    raise @args[:error_obj] if @args[:error_obj]
+  end
+end

data/lib/hayabusa_ext/threadding_timeout.rb

@@ -0,0 +1,101 @@
+class Hayabusa::Threadding_timeout
+  attr_reader :timeout
+  
+  def initialize(args)
+    @args = args
+    @hb = @args[:hb]
+    raise "No time given." if !@args.key?(:time)
+    @mutex = Mutex.new
+    @running = false
+  end
+  
+  def time=(newtime)
+    @args[:time] = newtime.to_s.to_i
+  end
+  
+  def time
+    return @args[:time]
+  end
+  
+  #Starts the timeout.
+  def start
+    @run = true
+    @thread = Thread.new do
+      loop do
+        begin
+          if @args[:counting]
+            @timeout = @args[:time]
+            
+            while @timeout > 0
+              @timeout += -1
+              break if @hb.should_restart or !@run
+              sleep 1
+            end
+          else
+            sleep @args[:time]
+          end
+          
+          break if @hb.should_restart or !@run
+          
+          @mutex.synchronize do
+            @hb.threadpool.run do
+              @hb.ob.db.get_and_register_thread if @hb.ob.db.opts[:threadsafe]
+              @hb.db_handler.get_and_register_thread if @hb.db_handler.opts[:threadsafe]
+              
+              Thread.current[:hayabusa] = {
+                :hb => @hb,
+                :db => @hb.db_handler
+              }
+              
+              begin
+                @running = true
+                
+                if @args.key?(:timeout)
+                  Timeout.timeout(@args[:timeout]) do
+                    @args[:block].call(*@args[:args])
+                  end
+                else
+                  @args[:block].call(*@args[:args])
+                end
+              ensure
+                @running = false
+                @hb.ob.db.free_thread if @hb.ob.db.opts[:threadsafe]
+                @hb.db_handler.free_thread if @hb.db_handler.opts[:threadsafe]
+              end
+            end
+          end
+        rescue => e
+          @hb.handle_error(e)
+        end
+      end
+    end
+    
+    return self
+  end
+  
+  #Stops the timeout.
+  def stop
+    @run = false
+    @mutex.synchronize do
+      @thread.kill if @thread.alive?
+      @thread = nil
+    end
+  end
+  
+  #Returns various data.
+  def [](key)
+    return @timeout if key == :hayabusa_timeout
+    raise "No such key: '#{key}'."
+  end
+  
+  #Returns true if the thread is alive or not.
+  def alive?
+    return @thread.alive? if @thread
+    return false
+  end
+  
+  #Returns true if the timeout is running or not.
+  def running?
+    return @running
+  end
+end

data/lib/hayabusa_ext/translations.rb

@@ -0,0 +1,43 @@
+class Hayabusa
+  #Translates a given key for a given object.
+  #===Examples
+  # 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 = @events.call(:trans_no_str, {:obj => obj, :key => key, :args => args}) if trans_val.length <= 0
+    return trans_val
+  end
+  
+  #Returns the locale for the current thread.
+  def trans_locale(args = {})
+    if args.is_a?(Hash) and args[:locale]
+      return args[:locale]
+    elsif _session and _session[:locale]
+      return _session[:locale]
+    elsif _httpsession and _httpsession.data[:locale]
+      return _httpsession.data[:locale]
+    elsif Thread.current[:locale]
+      return Thread.current[:locale]
+    elsif @config[:locale_default]
+      return @config[:locale_default]
+    end
+    
+    raise "Could not figure out locale."
+  end
+  
+  #Sets new translations for the given object.
+  #===Examples
+  # _hb.trans_set(obj, {:title => "Trala"})
+  def trans_set(obj, values, args = {})
+    args[:locale] = self.trans_locale if !args[:locale]
+    @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)
+  end
+end