hayabusa 0.0.1

data/lib/hayabusa_ext/web.rb

@@ -0,0 +1,190 @@
+class Hayabusa
+  #Imports a .rhtml-file and executes it.
+  #===Examples
+  #  _hb.import("/some/path/page.rhtml")
+  def import(filepath)
+    if filepath.to_s.index("../proc/self") != nil
+      raise Errno::EACCES, "Possible attempt to hack the appserver."
+    end
+    
+    _httpsession.eruby.import(filepath)
+  end
+  
+  #Redirects to another URL.
+  #===Examples
+  #  _hb.redirect("someotherpage.rhtml")
+  #  _hb.redirect("newpage.rhtml", :perm => true)
+  def redirect(url, args = {})
+    #Header way
+    if !_httpsession.alert_sent and !self.headers_sent?
+      if args[:perm]
+        _httpsession.resp.status = 301 if !self.headers_sent?
+      else
+        _httpsession.resp.status = 303 if !self.headers_sent?
+      end
+      
+      self.header("Location", url) if !self.headers_sent?
+    end
+    
+    print "<script type=\"text/javascript\">location.href=\"#{url}\";</script>"
+    exit
+  end
+  
+  #Sends a javascript-alert to the HTML.
+  #===Examples
+  #  _hb.alert("Hello world!")
+  def alert(msg)
+    _httpsession.alert_sent = true
+    Knj::Web.alert(msg)
+    return self
+  end
+  
+  #Define a cookies in the clients browser.
+  #===Examples
+  #  _hb.cookie(:name => "MyCookie", :value => "Trala")
+  def cookie(cookie)
+    raise "No HTTP-session attached to this thread." if !_httpsession
+    raise "HTTP-session not active." if !_httpsession.resp
+    raise "Not a hash: '#{cookie.class.name}', '#{cookie}'." unless cookie.is_a?(Hash)
+    _httpsession.resp.cookie(cookie)
+    return nil
+  end
+  
+  #Sends a header to the clients browser.
+  #===Examples
+  #  _hb.header("Content-Type", "text/javascript")
+  def header(key, val)
+    raise "No HTTP-session attached to this thread." if !_httpsession
+    raise "HTTP-session not active." if !_httpsession.resp
+    _httpsession.resp.header(key, val)
+    return nil
+  end
+  
+  #Sends a raw header-line to the clients browser.
+  def header_raw(str)
+    raise "No HTTP-session attached to this thread." if !_httpsession
+    raise "HTTP-session not active." if !_httpsession.resp
+    Php4r.header(str)
+    return nil
+  end
+  
+  #Returns true if the headers are already sent.
+  #===Examples
+  #  _hb.headers_sent? #=> true
+  def headers_sent?
+    return true if _httpsession.resp.headers_sent
+    return false
+  end
+  
+  #Define the size for when to automatically send headers. If you want to send hundres of kilobytes and then a header, you can use this method to do so.
+  #===Examples
+  #Set the size to 200 kb.
+  #  _hb.headers_send_size = (1024 * 200)
+  def headers_send_size=(newsize)
+    raise "The headers are already sent and you cannot modify the send-size any more." if self.headers_sent?
+    _httpsession.size_send = newsize.to_i
+    return nil
+  end
+  
+  #Serves the given filepath and enables caching for it. No other content should be written to the page when using this method.
+  #===Examples
+  #  _hb.header("Content-Type", "text/javascript")
+  #  _hb.serve_file("somefile.js")
+  def serve_file(filepath)
+    raise "File doesnt exist: '#{filepath}'." if !File.exists?(filepath)
+    httpsess = _httpsession
+    headers = httpsess.headers
+    resp = httpsess.resp
+    
+    if headers["cache-control"] and headers["cache-control"][0]
+      cache_control = {}
+      headers["cache-control"][0].scan(/(.+)=(.+)/) do |match|
+        cache_control[match[1]] = match[2]
+      end
+    end
+    
+    cache_dont = true if cache_control and cache_control.key?("max-age") and cache_control["max-age"].to_i <= 0
+    lastmod = File.mtime(filepath)
+    
+    self.header("Last-Modified", lastmod.httpdate)
+    self.header("Expires", (Time.now + 86400).httpdate) #next day.
+    
+    if !cache_dont and headers["if-modified-since"] and headers["if-modified-since"][0]
+      request_mod = Datet.in(headers["if-modified-since"].first).time
+      
+      if request_mod == lastmod
+        resp.status = 304
+        return nil
+      end
+    end
+    
+    httpsess.force_content(:type => :file, :path => filepath)
+    return nil
+  end
+  
+  #Sends a javascript back to the browser and exits.
+  def back
+    Knj::Web.back
+  end
+  
+  #Draw a input in a table.
+  def inputs(*args)
+    return Knj::Web.inputs(args)
+  end
+  
+  #Urlencodes a string.
+  #===Examples
+  #  _hb.redirect("mypage.rhtml?arg=#{_hb.urlenc(value_variable)}")
+  def urlenc(str)
+    return Knj::Web.urlenc(str)
+  end
+  
+  #Urldecodes a string.
+  def urldec(str)
+    return Knj::Web.urldec(str)
+  end
+  
+  #Returns a number localized as a string.
+  def num(*args)
+    return Knj::Locales.number_out(*args)
+  end
+  
+  #Hashes with numeric keys will be turned into arrays instead. This is not done automatically because it can wrongly corrupt data if not used correctly.
+  def get_parse_arrays(arg = nil, ob = nil)
+    arg = _get.clone if !arg
+    
+    #Parses key-numeric-hashes into arrays and converts special model-strings into actual models.
+    if arg.is_a?(Hash) and Knj::ArrayExt.hash_numeric_keys?(arg)
+      arr = []
+      
+      arg.each do |key, val|
+        arr << val
+      end
+      
+      return self.get_parse_arrays(arr, ob)
+    elsif arg.is_a?(Hash)
+      arg.each do |key, val|
+        arg[key] = self.get_parse_arrays(val, ob)
+      end
+      
+      return arg
+    elsif arg.is_a?(Array)
+      arg.each_index do |key|
+        arg[key] = self.get_parse_arrays(arg[key], ob)
+      end
+      
+      return arg
+    elsif arg.is_a?(String) and match = arg.match(/^#<Model::(.+?)::(\d+)>$/)
+      ob = @ob if !ob
+      return ob.get(match[1], match[2])
+    else
+      return arg
+    end
+  end
+  
+  #Returns the socket-port the appserver is currently running on.
+  def port
+    raise "Http-server not spawned yet. Call Hayabusa#start to spawn it." if !@httpserv
+    return @httpserv.server.addr[1]
+  end
+end

data/lib/hayabusa_http_server.rb

@@ -0,0 +1,102 @@
+require "socket"
+
+class Hayabusa::Http_server
+  attr_accessor :working_count
+  attr_reader :hb, :http_sessions, :thread_accept, :thread_restart, :server
+  
+  def initialize(hb)
+    @hb = hb
+    @debug = @hb.config[:debug]
+    @mutex_count = Mutex.new
+  end
+  
+  def start
+    @http_sessions = []
+    @working_count = 0
+    
+    raise "No host was given." if @hb and !@hb.config.has_key?(:host)
+    raise "No port was given." if @hb and !@hb.config.has_key?(:port)
+    
+    @server = TCPServer.new(@hb.config[:host], @hb.config[:port])
+    
+    @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
+          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
+        rescue Exception => e
+          if @debug
+            STDOUT.puts Knj::Errors.error_str(e)
+            STDOUT.print "Could not accept HTTP-request - waiting 1 sec and then trying again.\n"
+          end
+          
+          raise e if e.is_a?(SystemExit) or e.is_a?(Interrupt)
+          sleep 1
+        end
+      end
+    end
+  end
+  
+  def stop
+    STDOUT.print "Stopping accept-thread.\n" if @debug
+    @thread_accept.kill if @thread_accept and @thread_accept.alive?
+    @thread_restart.kill if @thread_restart and @thread_restart.alive?
+    
+    STDOUT.print "Stopping all HTTP sessions.\n" if @debug
+    if @http_sessions
+      @http_sessions.each do |httpsession|
+        httpsession.destruct
+      end
+    end
+    
+    begin
+      STDOUT.print "Stopping TCPServer.\n" if @debug
+      @server.close if @server and !@server.closed?
+      STDOUT.print "TCPServer was closed.\n" if @debug
+    rescue Timeout::Error
+      raise "Could not close TCPserver.\n"
+    rescue IOError => e
+      if e.message == "closed stream"
+        #ignore - it should be closed.
+      else
+        raise e
+      end
+    end
+    
+    @http_sessions = nil
+    @thread_accept = nil
+    @thread_restart = nil
+    @server = nil
+    @working_count = nil
+    @hb = nil
+  end
+  
+  def spawn_httpsession(socket)
+    STDOUT.puts "Starting new HTTP-session." if @debug
+    @http_sessions << Hayabusa::Http_session.new(self, socket)
+  end
+  
+  def count_block
+    begin
+      added = false
+      @mutex_count.synchronize do
+        @working_count += 1 if @working_count != nil
+        added = true
+      end
+      
+      yield
+    ensure
+      @hb.served += 1 if @hb
+      
+      @mutex_count.synchronize do
+        @working_count -= 1 if @working_count != nil and added
+      end
+    end
+  end
+end

data/lib/hayabusa_http_session.rb

@@ -0,0 +1,361 @@
+#This class handels the HTTP-sessions.
+class Hayabusa::Http_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
+  
+  #Autoloader for subclasses.
+  def self.const_missing(name)
+    require "#{File.dirname(__FILE__)}/hayabusa_http_session_#{name.to_s.downcase}.rb"
+    raise "Still not defined: '#{name}'." if !Hayabusa::Http_session.const_defined?(name)
+    return Hayabusa::Http_session.const_get(name.to_s.to_sym)
+  end
+  
+  def initialize(httpserver, socket)
+    @data = {}
+    @socket = socket
+    @httpserver = httpserver
+    @hb = httpserver.hb
+    @types = @hb.types
+    @config = @hb.config
+    @active = true
+    @debug = @hb.debug
+    @handlers_cache = @config[:handlers_cache]
+    @httpsession_var = {}
+    
+    @eruby = Knj::Eruby.new(
+      :cache_hash => @hb.eruby_cache,
+      :binding_callback => self.method(:create_binding)
+    )
+    
+    #Set socket stuff.
+    if RUBY_PLATFORM == "java" or RUBY_ENGINE == "rbx"
+      if @hb.config[:peeraddr_static]
+        addr_peer = [0, 0, @hb.config[:peeraddr_static]]
+      else
+        addr_peer = @socket.peeraddr
+      end
+      
+      addr = @socket.addr
+    else
+      addr = @socket.addr(false)
+      addr_peer = @socket.peeraddr(false)
+    end
+    
+    @socket_meta = {
+      "REMOTE_ADDR" => addr[2],
+      "REMOTE_PORT" => addr[1],
+      "SERVER_ADDR" => addr_peer[2],
+      "SERVER_PORT" => addr_peer[1]
+    }
+    
+    @resp = Hayabusa::Http_session::Response.new(:socket => @socket)
+    @handler = Hayabusa::Http_session::Request.new(:hb => @hb, :httpsession => self)
+    @cgroup = Hayabusa::Http_session::Contentgroup.new(:socket => @socket, :hb => @hb, :resp => @resp, :httpsession => self)
+    @resp.cgroup = @cgroup
+    
+    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
+    
+    @thread_request = Thread.new(&self.method(:thread_request_run))
+  end
+  
+  def thread_request_run
+    Thread.current[:hayabusa] = {} if !Thread.current[:hayabusa]
+    Thread.current[:type] = :httpsession
+    
+    if @config.key?(:max_requests_working)
+      max_requests_working = @config[:max_requests_working].to_i
+    else
+      max_requests_working = false
+    end
+    
+    begin
+      while @active
+        begin
+          @cgroup.reset
+          @written_size = 0
+          @size_send = @config[:size_send]
+          @alert_sent = false
+          @working = false
+          break if @hb.should_restart
+          
+          STDOUT.print "#{__id__} - Waiting to parse from socket.\n" if @debug
+          Timeout.timeout(1800) do
+            @handler.socket_parse(@socket)
+          end
+          
+          STDOUT.print "#{__id__} - Done parsing from socket.\n" 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
+            sleep 0.1
+          end
+          
+          break if @hb.should_restart
+          
+          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
+              sleep 0.1
+            end
+          end
+          
+          #Reserve database connections.
+          @hb.db_handler.get_and_register_thread if @hb.db_handler.opts[:threadsafe]
+          @hb.ob.db.get_and_register_thread if @hb.ob.db.opts[:threadsafe]
+          
+          @working = true
+          STDOUT.print "#{__id__} - Serving.\n" if @debug
+          
+          @httpserver.count_block do
+            self.serve
+          end
+        ensure
+          STDOUT.print "#{__id__} - Closing request.\n" if @debug
+          @working = false
+          
+          #Free reserved database-connections.
+          @hb.db_handler.free_thread if @hb and @hb.db_handler.opts[:threadsafe]
+          @hb.ob.db.free_thread if @hb and @hb.ob.db.opts[:threadsafe]
+        end
+      end
+    rescue Timeout::Error
+      STDOUT.print "#{__id__} - Closing httpsession because of timeout.\n" if @debug
+    rescue Errno::ECONNRESET, Errno::ENOTCONN, Errno::EPIPE => e
+      STDOUT.print "#{__id__} - Connection error (#{e.inspect})...\n" if @debug
+    rescue Interrupt => e
+      raise e
+    rescue Exception => e
+      STDOUT.puts Knj::Errors.error_str(e)
+    ensure
+      self.destruct
+    end
+  end
+  
+  #Creates a new Hayabusa::Binding-object and returns the binding for that object.
+  def create_binding
+    binding_obj = Hayabusa::Http_session::Page_environment.new(:httpsession => self, :hb => @hb)
+    return binding_obj.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
+  
+  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] = {} if !Thread.current[:hayabusa]
+    Thread.current[:hayabusa][:hb] = @hb
+    Thread.current[:hayabusa][:httpsession] = self
+    Thread.current[:hayabusa][:session] = @session
+    Thread.current[:hayabusa][:get] = @get
+    Thread.current[:hayabusa][:post] = @post
+    Thread.current[:hayabusa][:meta] = @meta
+    Thread.current[:hayabusa][:cookie] = @cookie
+  end
+  
+  def self.finalize(id)
+    STDOUT.print "Http_session finalize #{id}.\n" if @debug
+  end
+  
+  def destruct
+    STDOUT.print "Http_session destruct (#{@httpserver.http_sessions.length})\n" if @debug and @httpserver and @httpserver.http_sessions
+    
+    begin
+      @socket.close if !@socket.closed?
+    rescue => e
+      STDOUT.puts e.inspect
+      STDOUT.puts e.backtrace
+      #ignore if it fails...
+    end
+    
+    @httpserver.http_sessions.delete(self) if @httpserver and @httpserver.http_sessions
+    
+    @eruby.destroy if @eruby
+    @thread_request.kill if @thread_request.alive?
+  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
+  
+  def serve
+    STDOUT.print "Generating meta, cookie, get, post and headers.\n" if @debug
+    @meta = @handler.meta.merge(@socket_meta)
+    @cookie = @handler.cookie
+    @get = @handler.get
+    @post = @handler.post
+    @headers = @handler.headers
+    
+    close = true if @meta["HTTP_CONNECTION"] == "close"
+    @resp.reset(
+      :http_version => @handler.http_version,
+      :close => close
+    )
+    if @handler.http_version == "1.1"
+      @cgroup.chunked = true
+      @resp.chunked = true
+    else
+      @cgroup.chunked = false
+      @resp.chunked = false
+    end
+    
+    @page_path = @handler.page_path
+    @ext = File.extname(@page_path).downcase[1..-1].to_s
+    
+    @ctype = @types[@ext.to_sym] if @ext.length > 0 and @types.key?(@ext.to_sym)
+    @ctype = @config[:default_filetype] if !@ctype and @config.key?(:default_filetype)
+    @resp.header("Content-Type", @ctype)
+    
+    @browser = Knj::Web.browser(@meta)
+    
+    if @meta["HTTP_X_FORWARDED_FOR"]
+      @ip = @meta["HTTP_X_FORWARDED_FOR"].split(",")[0].strip
+    elsif @meta["REMOTE_ADDR"]
+      @ip = @meta["REMOTE_ADDR"]
+    else
+      raise "Could not figure out the IP of the session."
+    end
+    
+    STDOUT.print "Figuring out session-ID, session-object and more.\n" if @debug
+    if @cookie["HayabusaSession"].to_s.length > 0
+      @session_id = @cookie["HayabusaSession"]
+    elsif @browser["browser"] == "bot"
+      @session_id = "bot"
+    else
+      @session_id = @hb.session_generate_id(@meta)
+      send_cookie = true
+    end
+    
+    begin
+      @session, @session_hash = @hb.session_fromid(@ip, @session_id, @meta)
+    rescue ArgumentError => e
+      #User should not have the session he asked for because of invalid user-agent or invalid IP.
+      @session_id = @hb.session_generate_id(@meta)
+      @session, @session_hash = @hb.session_fromid(@ip, @session_id, @meta)
+      send_cookie = true
+    end
+    
+    if send_cookie
+      @resp.cookie(
+        "name" => "HayabusaSession",
+        "value" => @session_id,
+        "path" => "/",
+        "expires" => Time.now + 32140800 #add around 12 months
+      )
+    end
+    
+    if @config.key?(:logging) and @config[:logging][:access_db]
+      STDOUT.print "Doing access-logging.\n" 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 << {
+        :session_id => @session.id,
+        :date_request => Time.now,
+        :ips => @ips,
+        :get => @get,
+        :post => @post,
+        :meta => @meta,
+        :cookie => @cookie
+      }
+    end
+    
+    STDOUT.print "Initializing thread and content-group.\n" if @debug
+    self.init_thread
+    Thread.current[:hayabusa][:contentgroup] = @cgroup
+    time_start = Time.now.to_f if @debug
+    
+    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
+          #check if we should use a handler for this request.
+          @config[:handlers].each do |handler_info|
+            if handler_info.key?(:file_ext) and handler_info[:file_ext] == @ext
+              return handler_info[:callback].call(self)
+            elsif handler_info.key?(:path) and handler_info[:mount] and @meta["SCRIPT_NAME"].slice(0, handler_info[:path].length) == handler_info[:path]
+              @page_path = "#{handler_info[:mount]}#{@meta["SCRIPT_NAME"].slice(handler_info[:path].length, @meta["SCRIPT_NAME"].length)}"
+              break
+            end
+          end
+          
+          if !File.exists?(@page_path)
+            @resp.status = 404
+            @resp.header("Content-Type", "text/html")
+            @cgroup.write("File you are looking for was not found: '#{@meta["REQUEST_URI"]}'.")
+          else
+            if @headers["cache-control"] and @headers["cache-control"][0]
+              cache_control = {}
+              @headers["cache-control"][0].scan(/(.+)=(.+)/) do |match|
+                cache_control[match[1]] = match[2]
+              end
+            end
+            
+            cache_dont = true if cache_control and cache_control.key?("max-age") and cache_control["max-age"].to_i <= 0
+            lastmod = File.mtime(@page_path)
+            
+            @resp.header("Last-Modified", lastmod.httpdate)
+            @resp.header("Expires", (Time.now + 86400).httpdate) #next day.
+            
+            if !cache_dont and @headers["if-modified-since"] and @headers["if-modified-since"][0]
+              request_mod = Datet.in(@headers["if-modified-since"].first).time
+              
+              if request_mod == lastmod
+                @resp.status = 304
+                return nil
+              end
+            end
+            
+            @cgroup.new_io(:type => :file, :path => @page_path)
+          end
+        end
+      end
+    rescue SystemExit
+      #do nothing - ignore.
+    rescue Timeout::Error
+      @resp.status = 500
+      print "The request timed out."
+    end
+    
+    @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
+    @cgroup.join
+    
+    @hb.events.call(:request_done, {
+      :httpsession => self
+    }) if @hb.events
+    @httpsession_var = {}
+  end
+end