knjappserver 0.0.16 → 0.0.17

data/lib/include/class_httpsession_contentgroup.rb

@@ -1,3 +1,5 @@
+#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 Knjappserver::Httpsession::Contentgroup
   attr_reader :done, :cur_data
@@ -5,9 +7,10 @@ class Knjappserver::Httpsession::Contentgroup
   NL = "\r\n"
   
   def initialize(args = {})
-    @block = args[:restart_proc]
     @socket = args[:socket]
     @chunked = args[:chunked]
+    @resp = args[:resp]
+    @httpsession = args[:httpsession]
     @mutex = Mutex.new
     @debug = false
   end
@@ -26,6 +29,7 @@ class Knjappserver::Httpsession::Contentgroup
     @ios = []
     @done = false
     @thread = nil
+    @forced = false
     
     @mutex.synchronize do
       self.new_io
@@ -40,66 +44,89 @@ class Knjappserver::Httpsession::Contentgroup
     @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[:knjappserver] = {} if !Thread.current[:knjappserver]
     Thread.current[:knjappserver][:contentgroup] = self
   end
   
   def new_thread
+    cgroup = Knjappserver::Httpsession::Contentgroup.new(:socket => @socket, :chunked => @chunked)
+    cgroup.init
+    
     @mutex.synchronize do
-      cgroup = Knjappserver::Httpsession::Contentgroup.new(:socket => @socket, :chunked => @chunked)
-      cgroup.init
-      
-      data = {:cgroup => cgroup}
-      @ios << data
+      @ios << cgroup
       self.new_io
-      self.register_thread
-      
-      return data
+    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, Timeout::Error
+      #Ignore - the user probaly left.
     end
   end
   
   def write(cont)
     @mutex.synchronize do
-      @cur_data[:str] << cont.to_s
+      @cur_data[:str] << cont
     end
   end
   
   def write_output
-    if @block and !@thread
-      @mutex.synchronize do
-        @thread = Knj::Thread.new do
-          @block.call
-        end
+    return nil if @thread
+    
+    @mutex.synchronize do
+      @thread = Thread.new do
+        self.write_begin
       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
-    if @block
-      sleep 0.1 while !@thread
-      @thread.join
-    end
+    return nil if @forced
+    sleep 0.1 while !@thread
+    @thread.join
   end
   
   def write_to_socket
     count = 0
     
     @ios.each do |data|
-      if data.key?(:cgroup)
-        data[:cgroup].write_to_socket
+      if data.is_a?(Knjappserver::Httpsession::Contentgroup)
+        data.write_to_socket
       elsif data.key?(:str)
         if data[:str].is_a?(File)
           file = data[:str]
           
           loop do
             begin
-              buf = file.sysread(4096)
+              buf = file.sysread(16384)
             rescue EOFError
               break
             end
@@ -115,7 +142,7 @@ class Knjappserver::Httpsession::Contentgroup
         else
           loop do
             break if data[:done] and data[:str].size <= 0 
-            sleep 0.1 while data[:str].size <= 512 and !data[:done]
+            sleep 0.1 while data[:str].size < 512 and !data[:done]
             
             str = nil
             @mutex.synchronize do
@@ -123,7 +150,8 @@ class Knjappserver::Httpsession::Contentgroup
               data[:str] = ""
             end
             
-            str.each_slice(512) do |slice|
+            #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

data/lib/include/class_httpsession_http_request.rb

@@ -0,0 +1,203 @@
+require "uri"
+
+#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 Knjappserver::Httpsession::Http_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. Knjappserver, crlf and arguments.
+	def initialize(args)
+		@args = args
+		@kas = @args[:kas]
+		@crlf = "\r\n"
+	end
+	
+	#Reads content from the socket until the end of headers. Also does various error-checks.
+	def read_socket
+		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
+	
+	#Generates data on object from the given socket.
+	def socket_parse(socket)
+    @modified_since = nil
+		@cont = ""
+		@socket = socket
+		self.read_socket
+		
+		#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 = URI.parse(match[2])
+		
+		page_filepath = Knj::Web.urldec(uri.path)
+		if page_filepath.length <= 0 or page_filepath == "/" or File.directory?("#{@kas.config[:doc_root]}/#{page_filepath}")
+			page_filepath = "#{page_filepath}/#{@kas.config[:default_page]}"
+		end
+		
+		@page_path = "#{@kas.config[:doc_root]}/#{page_filepath}"
+		@get = Knj::Web.parse_urlquery(uri.query.to_s, {:urldecode => true, :force_utf8 => true})
+		
+    if @get["_kas_httpsession_id"]
+      @kas.httpsessions_ids[@get["_kas_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 @kas
+              @kas.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 = Knjappserver::Httpsession::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["_kas_httpsession_id"]
+        @kas.httpsessions_ids.delete(@get["_kas_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 = Knj::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

data/lib/include/{class_httpresp.rb → class_httpsession_http_response.rb}

@@ -1,7 +1,8 @@
 require "time"
 
-class Knjappserver::Httpresp
-  attr_accessor :nl, :status, :http_version, :headers, :headers_trailing, :headers_sent
+#This object writes headers, trailing headers, status headers and more for HTTP-sessions.
+class Knjappserver::Httpsession::Http_response
+  attr_accessor :chunked, :cgroup, :nl, :status, :http_version, :headers, :headers_trailing, :headers_sent, :socket
   
   STATUS_CODES = {
     100 => "Continue",
@@ -25,7 +26,8 @@ class Knjappserver::Httpresp
   NL = "\r\n"
   
   def initialize(args)
-    @cgroup = args[:cgroup]
+    @chunked = false
+    @socket = args[:socket]
   end
   
   def reset(args)
@@ -73,57 +75,54 @@ class Knjappserver::Httpresp
     end
     
     code = STATUS_CODES[@status]
-    res += " #{code}" if code
-    res += NL
+    res << " #{code}" if code
+    res << NL
     
     @headers.each do |key, val|
-      res += "#{val[0]}: #{val[1]}#{NL}"
+      res << "#{val[0]}: #{val[1]}#{NL}"
     end
     
     if @http_version == "1.1"
       @headers_11.each do |key, val|
-        res += "#{key}: #{val}#{NL}"
+        res << "#{key}: #{val}#{NL}"
       end
       
       @trailers.each do |trailer|
-        res += "Trailer: #{trailer}#{NL}"
+        res << "Trailer: #{trailer}#{NL}"
       end
     end
     
     @cookies.each do |cookie|
-      res += "Set-Cookie: #{Knj::Web.cookie_str(cookie)}#{NL}"
+      res << "Set-Cookie: #{Knj::Web.cookie_str(cookie)}#{NL}"
     end
     
-    res += NL
+    res << NL
     
     return res
   end
   
-  def write(socket)
+  def write
     @headers_sent = true
-    socket.write(self.header_str)
+    @socket.write(self.header_str)
     
     if @status == 304
       #do nothing.
     else
-      case @http_version
-        when "1.0"
-          @cgroup.write_to_socket
-          socket.write("#{NL}#{NL}")
-        when "1.1"
-          @cgroup.write_to_socket
-          socket.write("0#{NL}")
-          
-          @headers_trailing.each do |header_id_str, header|
-            socket.write("#{header[0]}: #{header[1]}#{NL}")
-          end
-          
-          socket.write(NL)
-        else
-          raise "Could not figure out of HTTP version: '#{@http_version}'."
+      if @chunked
+        @cgroup.write_to_socket
+        @socket.write("0#{NL}")
+        
+        @headers_trailing.each do |header_id_str, header|
+          @socket.write("#{header[0]}: #{header[1]}#{NL}")
+        end
+        
+        @socket.write(NL)
+      else
+        @cgroup.write_to_socket
+        @socket.write("#{NL}#{NL}")
       end
     end
     
-    socket.close if @close
+    @socket.close if @close
   end
 end