hayabusa 0.0.1

data/lib/hayabusa_http_session_contentgroup.rb

@@ -0,0 +1,176 @@
+#encoding: utf-8
+
+#This class handels the adding of content and writing to socket. Since this can be done with multiple threads and multiple IO's it can get complicated.
+class Hayabusa::Http_session::Contentgroup
+  attr_reader :done, :cur_data
+  attr_accessor :chunked, :socket
+  NL = "\r\n"
+  
+  def initialize(args = {})
+    @socket = args[:socket]
+    @chunked = args[:chunked]
+    @resp = args[:resp]
+    @httpsession = args[:httpsession]
+    @mutex = Mutex.new
+    @debug = false
+  end
+  
+  def init
+    @done = false
+    @thread = nil
+    @cur_data = {
+      :str => "",
+      :done => false
+    }
+    @ios = [@cur_data]
+  end
+  
+  def reset
+    @ios = []
+    @done = false
+    @thread = nil
+    @forced = false
+    
+    @mutex.synchronize do
+      self.new_io
+    end
+    
+    self.register_thread
+  end
+  
+  def new_io(obj = "")
+    @cur_data[:done] = true if @cur_data
+    @cur_data = {:str => obj, :done => false}
+    @ios << @cur_data
+  end
+  
+  #Forces the content to be the input - nothing else can be added after calling this.
+  def force_content(newcont)
+    @ios = [{:str => newcont, :done => true}]
+  end
+  
+  def register_thread
+    Thread.current[:hayabusa] = {} if !Thread.current[:hayabusa]
+    Thread.current[:hayabusa][:contentgroup] = self
+  end
+  
+  def new_thread
+    cgroup = Hayabusa::Http_session::Contentgroup.new(:socket => @socket, :chunked => @chunked)
+    cgroup.init
+    
+    @mutex.synchronize do
+      @ios << cgroup
+      self.new_io
+    end
+    
+    self.register_thread
+    return cgroup
+  end
+  
+  def write_begin
+    begin
+      @resp.write if @httpsession.meta["METHOD"] != "HEAD"
+    rescue Errno::ECONNRESET, Errno::ENOTCONN, Errno::EPIPE
+      #Ignore - the user probaly left.
+    end
+  end
+  
+  def write(cont)
+    @mutex.synchronize do
+      @cur_data[:str] << cont
+    end
+  end
+  
+  def write_output
+    return nil if @thread
+    
+    @mutex.synchronize do
+      @thread = Thread.new do
+        begin
+          self.write_begin
+        rescue => e
+          STDERR.puts "Error while writing."
+          STDERR.puts e.inspect
+          STDERR.puts e.backtrace
+        end
+      end
+    end
+  end
+  
+  def write_force
+    @mutex.synchronize do
+      @forced = true if !@thread
+    end
+    
+    if @thread
+      @thread.join
+    else
+      self.write_begin
+    end
+  end
+  
+  def mark_done
+    @cur_data[:done] = true
+    @done = true
+  end
+  
+  def join
+    return nil if @forced
+    sleep 0.1 while !@thread
+    @thread.join
+  end
+  
+  def write_to_socket
+    count = 0
+    
+    @ios.each do |data|
+      if data.is_a?(Hayabusa::Http_session::Contentgroup)
+        data.write_to_socket
+      elsif data.key?(:str)
+        if data[:str].is_a?(Hash) and data[:str][:type] == :file
+          File.open(data[:str][:path], "r") do |file|
+            loop do
+              begin
+                buf = file.sysread(16384)
+              rescue EOFError
+                break
+              end
+              
+              if @chunked
+                @socket.write("#{buf.length.to_s(16)}#{NL}#{buf}#{NL}")
+              else
+                @socket.write(buf)
+              end
+            end
+          end
+        else
+          loop do
+            break if data[:done] and data[:str].size <= 0 
+            sleep 0.1 while data[:str].size < 512 and !data[:done]
+            
+            str = nil
+            @mutex.synchronize do
+              str = data[:str].bytes
+              data[:str] = ""
+            end
+            
+            #512 could take a long time for big pages. 16384 seems to be an optimal number.
+            str.each_slice(16384) do |slice|
+              buf = slice.pack("C*")
+              
+              if @chunked
+                @socket.write("#{buf.length.to_s(16)}#{NL}#{buf}#{NL}")
+              else
+                @socket.write(buf)
+              end
+            end
+          end
+        end
+      else
+        raise "Unknown object: '#{data.class.name}'."
+      end
+    end
+    
+    count += 1
+  end
+end

data/lib/hayabusa_http_session_page_environment.rb

@@ -0,0 +1,66 @@
+#This class handels all the magic-methods in a different way - by defining them as methods on the binding for the .rhtml-pages.
+class Hayabusa::Http_session::Page_environment
+  def initialize(args = {})
+    @args = args
+  end
+  
+  def get_binding
+    return binding
+  end
+  
+  def _buf
+    return $stdout
+  end
+  
+  def _cookie
+    return @args[:httpsession].cookie
+  end
+  
+  def _db
+    return @args[:hb].db_handler
+  end
+  
+  def _get
+    return @args[:httpsession].get
+  end
+  
+  def _hb
+    return @args[:hb]
+  end
+  
+  alias _requestdata _hb
+  
+  def _hb_vars
+    return @args[:hb].vars
+  end
+  
+  def _httpsession
+    return @args[:httpsession]
+  end
+  
+  def _httpsession_var
+    return @args[:httpsession].httpsession_var
+  end
+  
+  def _post
+    return @args[:httpsession].post
+  end
+  
+  def _meta
+    return @args[:httpsession].meta
+  end
+  
+  alias _server _meta
+  
+  def _session
+    return @args[:httpsession].session.sess_data
+  end
+  
+  def _session_hash
+    return @args[:httpsession].session_hash
+  end
+  
+  def _session_obj
+    return @args[:httpsession].session
+  end
+end

data/lib/hayabusa_http_session_post_multipart.rb

@@ -0,0 +1,135 @@
+#This class parses and handels post-multipart requests.
+class Hayabusa::Http_session::Post_multipart
+  attr_reader :return
+  
+  def initialize(args)
+    @args = args
+    boundary_regexp = /\A--#{@args["boundary"]}(--)?#{@args["crlf"]}\z/
+    @return = {}
+    @data = nil
+    @mode = nil
+    @headers = {}
+    @counts = {}
+    
+    @args["io"].each do |line|
+      if boundary_regexp =~ line
+        #Finish the data we were writing.
+        self.finish_data if @data
+        
+        @data = ""
+        @mode = "headers"
+      elsif @mode == "headers"
+        if match = line.match(/^(.+?):\s+(.+)#{@args["crlf"]}$/)
+          @headers[match[1].to_s.downcase] = match[2]
+        elsif line == @args["crlf"]
+          @mode = "body"
+        else
+          raise "Could not match header from: '#{line}'."
+        end
+      elsif @mode == "body"
+        @data << line
+      else
+        raise "Invalid mode: '#{@mode}'."
+      end
+    end
+    
+    self.finish_data if @data and @data.to_s.length > 0
+    
+    @data = nil
+    @headers = nil
+    @mode = nil
+    @args = nil
+  end
+  
+  #Add the current treated data to the return-hash.
+  def finish_data
+    @data.chop!
+    name = nil
+    
+    disp = @headers["content-disposition"]
+    raise "No 'content-disposition' was given." if !disp
+    
+    
+    #Figure out value-name in post-hash.
+    match_name = disp.match(/name=\"(.+?)\"/)
+    raise "Could not match name." if !match_name
+    name = match_name[1]
+    
+    
+    #Fix count with name if given as increamental [].
+    if match = name.match(/^(.+)\[\]$/)
+      if !@counts.key?(match[1])
+        @counts[match[1]] = 0
+      else
+        @counts[match[1]] += 1
+      end
+      
+      name = "#{match[1]}[#{@counts[match[1]]}]"
+    end
+    
+    
+    #Figure out actual filename.
+    match_fname = disp.match(/filename=\"(.+?)\"/)
+    
+    if match_fname
+      obj = Hayabusa::Http_session::Post_multipart::File_upload.new(
+        "fname" => match_fname[1],
+        "headers" => @headers,
+        "data" => @data
+      )
+      @return[name] = obj
+      @data = nil
+      @headers = {}
+      @mode = nil
+    else
+      @return[name] = @data
+      @data = nil
+      @headers = {}
+      @mode = nil
+    end
+  end
+end
+
+#This is the actual returned object for fileuploads. It is able to do various user-friendly things like save the content to a given path, return the filename, returns the content to a string and more.
+class Hayabusa::Http_session::Post_multipart::File_upload
+  def initialize(args)
+    @args = args
+  end
+  
+  #Returns the size of the upload.
+  def size
+    return @args["data"].length
+  end
+  
+  #Returns the size of the fileupload.
+  def length
+    return @args["data"].length
+  end
+  
+  #Returns the filename given for the fileupload.
+  def filename
+    return @args["fname"]
+  end
+  
+  #Returns the headers given for the fileupload. Type and more should be here.
+  def headers
+    return @args["headers"]
+  end
+  
+  #Returns the content of the file-upload as a string.
+  def to_s
+    return @args["data"]
+  end
+  
+  #Saves the content of the fileupload to a given path.
+  def save_to(filepath)
+    File.open(filepath, "w") do |fp|
+      fp.write(self.to_s)
+    end
+  end
+  
+  #This methods prevents the object from being converted to JSON. This can make some serious bugs.
+  def to_json(*args)
+    raise "File_upload-objects should not be converted to json."
+  end
+end

data/lib/hayabusa_http_session_request.rb

@@ -0,0 +1,219 @@
+require "knj/web"
+
+#If we are running on JRuby or Rubinius this will seriously speed things up if we are behind a proxy.
+if RUBY_PLATFORM == "java" or RUBY_ENGINE == "rbx"
+  BasicSocket.do_not_reverse_lookup = true
+end
+
+#This class parses the various HTTP requests into easy programmable objects. Get, post, cookie, meta and so on...
+class Hayabusa::Http_session::Request
+  attr_reader :get, :post, :cookie, :meta, :page_path, :headers, :http_version, :read, :clength, :speed, :percent, :secs_left
+  
+  #Sets the various required data on the object. Hayabusa, crlf and arguments.
+  def initialize(args)
+    @args = args
+    @hb = @args[:hb]
+    @crlf = "\r\n"
+  end
+  
+  #Reads content from the socket until the end of headers. Also does various error-checks.
+  def read_socket(socket, cont)
+    loop do
+      raise Errno::ECONNRESET, "Socket closed." if socket.closed?
+      read = socket.gets
+      raise Errno::ECONNRESET, "Socket returned non-string: '#{read.class.name}'." if !read.is_a?(String)
+      cont << read
+      break if cont[-4..-1] == "\r\n\r\n" or cont[-2..-1] == "\n\n"
+    end
+  end
+  
+  def reset
+    @modified_since = nil
+    @get = nil
+    @post = nil
+    @cookie = nil
+    @meta = nil
+    @page_path = nil
+    @headers = nil
+    @http_version = nil
+    @read = nil
+    @clength = nil
+    @speec = nil
+    @percent = nil
+    @secs_left = nil
+  end
+  
+  #Generates data on object from the given socket.
+  def socket_parse(socket)
+    self.reset
+    cont = ""
+    self.read_socket(socket, cont)
+    
+    #Parse URI (page_path and get).
+    match = cont.match(/^(GET|POST|HEAD)\s+(.+)\s+HTTP\/1\.(\d+)\s*/)
+    raise "Could not parse request: '#{cont.split("\n").first}'." if !match
+    
+    @http_version = "1.#{match[3]}"
+    
+    method = match[1]
+    cont = cont.gsub(match[0], "")
+    
+    uri = Knj::Web.parse_uri(match[2])
+    
+    page_filepath = Knj::Web.urldec(uri[:path])
+    if page_filepath.length <= 0 or page_filepath == "/" or File.directory?("#{@hb.config[:doc_root]}/#{page_filepath}")
+      page_filepath = "#{page_filepath}/#{@hb.config[:default_page]}"
+    end
+    
+    @page_path = "#{@hb.config[:doc_root]}/#{page_filepath}"
+    @get = Knj::Web.parse_urlquery(uri[:query], {:urldecode => true, :force_utf8 => true})
+    
+    if @get["_hb_httpsession_id"]
+      @hb.httpsessions_ids[@get["_hb_httpsession_id"]] = @args[:httpsession]
+    end
+    
+    begin
+      #Parse headers, cookies and meta.
+      @headers = {}
+      @cookie = {}
+      @meta = {
+        "REQUEST_METHOD" => method,
+        "QUERY_STRING" => uri[:query],
+        "REQUEST_URI" => match[2],
+        "SCRIPT_NAME" => uri[:path]
+      }
+      
+      cont.scan(/^(\S+):\s*(.+)\r\n/) do |header_match|
+        key = header_match[0].downcase
+        val = header_match[1]
+        
+        @headers[key] = [] if !@headers.has_key?(key)
+        @headers[key] << val
+        
+        case key
+          when "cookie"
+            Knj::Web.parse_cookies(val).each do |key, val|
+              @cookie[key] = val
+            end
+          when "content-length"
+            @clength = val.to_i
+          else
+            key = key.upcase.gsub("-", "_")
+            @meta["HTTP_#{key}"] = val
+        end
+      end
+      
+      
+      #Parse post
+      @post = {}
+      
+      if method == "POST"
+        post_treated = {}
+        
+        @speed = nil
+        @read = 0
+        post_data = ""
+        
+        Thread.new do
+          begin
+            time_cur = Time.now
+            read_last = 0
+            sleep 0.1
+            
+            while @clength and @read != nil and @read < @clength
+              break if !@clength or !@read
+              
+              time_now = Time.now
+              time_betw = time_now.to_f - time_cur.to_f
+              read_betw = @read - read_last
+              
+              time_cur = time_now
+              read_last = @read
+              
+              @percent = @read.to_f / @clength.to_f
+              @speed = read_betw.to_f / time_betw.to_f
+              
+              bytes_left = @clength - read
+              
+              if @speed > 0 and bytes_left > 0
+                @secs_left = bytes_left.to_f / @speed
+              else
+                @secs_left = false
+              end
+              
+              sleep 2
+            end
+          rescue => e
+            if @hb
+              @hb.handle_error(e)
+            else
+              STDOUT.print Knj::Errors.error_str(e)
+            end
+          end
+        end
+        
+        while @read < @clength
+          read_size = @clength - @read
+          read_size = 4096 if read_size > 4096
+          
+          raise Errno::ECONNRESET, "Socket closed." if socket.closed?
+          read = socket.read(read_size)
+          raise Errno::ECONNRESET, "Socket returned non-string: '#{read.class.name}'." if !read.is_a?(String)
+          post_data << read
+          @read += read.length
+        end
+        
+        if @headers["content-type"] and match = @headers["content-type"].first.match(/^multipart\/form-data; boundary=(.+)\Z/)
+          post_treated = Hayabusa::Http_session::Post_multipart.new(
+            "io" => StringIO.new("#{post_data}"),
+            "boundary" => match[1],
+            "crlf" => @crlf
+          ).return
+          
+          self.convert_post(@post, post_treated, {:urldecode => false})
+        else
+          post_data.split("&").each do |splitted|
+            splitted = splitted.split("=")
+            key = Knj::Web.urldec(splitted[0]).to_s.encode("utf-8")
+            val = splitted[1].to_s.encode("utf-8")
+            post_treated[key] = val
+          end
+          
+          self.convert_post(@post, post_treated, {:urldecode => true})
+        end
+      end
+    ensure
+      @read = nil
+      @speed = nil
+      @clength = nil
+      @percent = nil
+      @secs_left = nil
+      
+      #If it doesnt get unset we could have a serious memory reference GC problem.
+      if @get["_hb_httpsession_id"]
+        @hb.httpsessions_ids.delete(@get["_hb_httpsession_id"])
+      end
+    end
+  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
+  
+  #Converts post-result to the right type of hash.
+  def convert_post(seton, post_val, args = {})
+    post_val.each do |varname, value|
+      Knj::Web.parse_name(seton, varname, value, args)
+    end
+  end
+end