knjappserver 0.0.15 → 0.0.16

data/lib/include/class_httpserver.rb

@@ -4,11 +4,15 @@ class Knjappserver::Httpserver
 	
 	def initialize(kas)
 		@kas = kas
-		@http_sessions = []
-		@working_count = 0
+		@debug = @kas.config[:debug]
 	end
 	
 	def start
+    @http_sessions = []
+    @working_count = 0
+    
+    raise "No host was given." if !@kas.config.has_key?(:host)
+    raise "No port was given." if !@kas.config.has_key?(:port)
 		@server = TCPServer.new(@kas.config[:host], @kas.config[:port])
 		
 		@thread_accept = Knj::Thread.new do
@@ -20,13 +24,13 @@ class Knjappserver::Httpserver
 				
 				begin
 					self.spawn_httpsession(@server.accept)
-					STDOUT.print "Starting new HTTP-request.\n" if @kas.config[:debug]
+					STDOUT.print "Starting new HTTP-request.\n" if @debug
 				rescue => e
 					STDOUT.puts e.inspect
 					STDOUT.puts e.backtrace
 					STDOUT.print "\n"
-					STDOUT.print "Could not accept HTTP-request - waiting 0.5 sec and then trying again.\n"
-					sleep 0.5
+					STDOUT.print "Could not accept HTTP-request - waiting 1 sec and then trying again.\n"
+					sleep 1
 				end
 			end
 		end
@@ -47,24 +51,26 @@ class Knjappserver::Httpserver
 	
 	def stop
     begin
-      STDOUT.print "Stopping accept-thread.\n" if @kas.config[:debug]
+      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?
     rescue => e
-      STDOUT.print "Could not stop accept-thread.\n" if @kas.config[:debug]
+      STDOUT.print "Could not stop threads.\n" if @debug
       STDOUT.puts e.inspect
       STDOUT.puts e.backtrace
     end
     
-    STDOUT.print "Stopping all HTTP sessions.\n" if @kas.config[:debug]
-    @http_sessions.each do |httpsession|
-      httpsession.destruct
+    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 @kas.config[:debug]
+      STDOUT.print "Stopping TCPServer.\n" if @debug
       @server.close if @server and !@server.closed?
-      STDOUT.print "TCPServer was closed.\n" if @kas.config[:debug]
+      STDOUT.print "TCPServer was closed.\n" if @debug
     rescue Timeout::Error
       raise "Could not close TCPserver.\n"
     rescue IOError => e
@@ -74,6 +80,13 @@ class Knjappserver::Httpserver
         raise e
       end
     end
+    
+    @http_sessions = nil
+    @thread_accept = nil
+    @thread_restart = nil
+    @server = nil
+    @working_count = nil
+    @kas = nil
 	end
 	
 	def spawn_httpsession(socket)
@@ -81,11 +94,11 @@ class Knjappserver::Httpserver
 	end
 	
 	def handle_request(&block)
-    @working_count += 1
+    @working_count += 1 if @working_count
     begin
       block.call
     ensure
-      @working_count -= 1
+      @working_count -= 1 if @working_count
     end
 	end
 end

data/lib/include/class_httpsession.rb

@@ -1,52 +1,66 @@
 require "digest"
 
 class Knjappserver::Httpsession
-  attr_accessor :data
-  attr_reader :session, :session_id, :session_hash, :kas, :active, :out, :eruby, :browser, :debug
+  attr_accessor :data, :size_send, :alert_sent
+  attr_reader :session, :session_id, :session_hash, :kas, :active, :out, :eruby, :browser, :debug, :resp, :page_path, :cgroup, :written_size
   
   def initialize(httpserver, socket)
     @data = {}
     @socket = socket
     @httpserver = httpserver
     @kas = httpserver.kas
+    @types = @kas.types
+    @config = @kas.config
     @active = true
     @eruby = Knj::Eruby.new(:cache_hash => @kas.eruby_cache)
-    @debug = @kas.config[:debug]
-    self.reset
+    @debug = @kas.debug
+    
+    @cgroup = Knjappserver::Httpsession::Contentgroup.new(
+      :socket => @socket,
+      :restart_proc => proc{
+        begin
+          @resp.write(@socket) if @meta["METHOD"] != "HEAD"
+        rescue Errno::ECONNRESET, Errno::ENOTCONN, Errno::EPIPE, Timeout::Error
+          #Ignore - the user probaly left.
+        end
+      }
+    )
     
-    if @kas.config[:engine_webrick]
-      require "#{File.dirname(__FILE__)}/class_httpsession_webrick"
-      @handler = Knjappserver::Httpsession::Webrick.new(:kas => @kas)
-    elsif @kas.config[:engine_mongrel]
-      require "#{File.dirname(__FILE__)}/class_httpsession_mongrel"
-      @handler = Knjappserver::Httpsession::Mongrel.new(:kas => @kas)
-    elsif @kas.config[:engine_knjengine]
-      require "#{File.dirname(__FILE__)}/class_httpsession_knjengine"
-      @handler = Knjappserver::Httpsession::Knjengine.new(:kas => @kas)
-    else
-      raise "Unknown handler."
-    end
+    @resp = Knjappserver::Httpresp.new(:cgroup => @cgroup)
     
-    Dir.chdir(@kas.config[:doc_root])
+    require "#{File.dirname(__FILE__)}/class_httpsession_knjengine"
+    @handler = Knjappserver::Httpsession::Knjengine.new(:kas => @kas)
+    
+    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 = Knj::Thread.new do
+      Thread.current[:knjappserver] = {} if !Thread.current[:knjappserver]
+      
       @kas.db_handler.get_and_register_thread if @kas.db_handler.opts[:threadsafe]
       @kas.ob.db.get_and_register_thread if @kas.ob.db.opts[:threadsafe]
       
       begin
         while @active
           begin
+            @cgroup.reset
+            @written_size = 0
+            @size_send = @config[:size_send]
+            @alert_sent = false
+            
             Timeout.timeout(30) do
               @handler.socket_parse(@socket)
             end
             
-            sleep 0.1 while @kas.paused? #Check if we should be waiting with executing the pending request.
+            while @kas.paused? #Check if we should be waiting with executing the pending request.
+              STDOUT.print "Paused! (#{@kas.paused}) - sleeping.\n" if @debug
+              sleep 0.1
+            end
             
-            if @kas.config[:max_requests_working]
-              while @httpserver.working_count >= @kas.config[:max_requests_working]
-                STDOUT.print "Maximum amounts of requests are working (#{@httpserver.working_count}, #{@kas.config[:max_requests_working]}) - sleeping.\n" if @debug
+            if @config.key?(:max_requests_working)
+              while @httpserver.working_count >= @config[:max_requests_working]
+                STDOUT.print "Maximum amounts of requests are working (#{@httpserver.working_count}, #{@config[:max_requests_working]}) - sleeping.\n" if @debug
                 sleep 0.1
               end
             end
@@ -56,28 +70,17 @@ class Knjappserver::Httpsession
             end
           ensure
             @kas.served += 1 if @kas
-            self.reset
           end
         end
-      rescue WEBrick::HTTPStatus::RequestTimeout, WEBrick::HTTPStatus::EOFError, Errno::ECONNRESET, Errno::EPIPE, Timeout::Error => e
+      rescue Errno::ECONNRESET, Errno::ENOTCONN, Errno::EPIPE, Timeout::Error => e
         #Ignore - the user probaly left.
         #STDOUT.puts e.inspect
         #STDOUT.puts e.backtrace
       rescue SystemExit, Interrupt => e
         raise e
       rescue RuntimeError, Exception => e
-        first = e.backtrace.first
-        
-        if first.index("webrick/httprequest.rb") != nil or first.index("webrick/httpresponse.rb") != nil
-          if debug
-            STDOUT.print "Notice: Webrick error - properly faulty request - ignoring!\n"
-            STDOUT.puts e.inspect
-            STDOUT.puts e.backtrace
-          end
-        else
-          STDOUT.puts e.inspect
-          STDOUT.puts e.backtrace
-        end
+        STDOUT.puts e.inspect
+        STDOUT.puts e.backtrace
       ensure
         @kas.db_handler.free_thread if @kas and @kas.db_handler.opts[:threadsafe]
         @kas.ob.db.free_thread if @kas and @kas.ob.db.opts[:threadsafe]
@@ -88,36 +91,37 @@ class Knjappserver::Httpsession
   
   def threadded_content(block)
     raise "No block was given." if !block
-    @out = StringIO.new
+    cgroup_data = Thread.current[:knjappserver][:contentgroup].new_thread
     
-    thread_out = StringIO.new
-    thread = Thread.new(Thread.current[:knjappserver].clone) do |data|
-      Thread.current[:knjappserver] = data
-      Thread.current[:knjappserver][:stringio] = thread_out
-      Thread.current[:knjappserver][:db] = @kas.db_handler
-      
-      @kas.db_handler.get_and_register_thread  if @kas.db_handler.opts[:threadsafe]
-      @kas.ob.db.get_and_register_thread if @kas.ob.db.opts[:threadsafe]
-      
+    cgroup_data[:thread] = Thread.new(Thread.current[:knjappserver].clone) do |data|
       begin
+        self.init_thread
+        cgroup_data[:cgroup].register_thread
+        
+        @kas.db_handler.get_and_register_thread if @kas and @kas.db_handler.opts[:threadsafe]
+        @kas.ob.db.get_and_register_thread if @kas and @kas.ob.db.opts[:threadsafe]
+        
         block.call
+      rescue Exception => e
+        Thread.current[:knjappserver][:contentgroup].write Knj::Errors.error_str(e, {:html => true})
+        _kas.handle_error(e)
       ensure
-        @kas.ob.db.free_thread if @kas.ob.db.opts[:threadsafe]
-        @kas.db_handler.free_thread if @kas.db_handler.opts[:threadsafe]
+        Thread.current[:knjappserver][:contentgroup].mark_done
+        @kas.ob.db.free_thread if @kas and @kas.ob.db.opts[:threadsafe]
+        @kas.db_handler.free_thread if @kas and @kas.db_handler.opts[:threadsafe]
       end
     end
-    
-    @parts << {
-      :thread => thread,
-      :stringio => thread_out
-    }
-    @parts << @out
   end
   
-  def reset
-    @out.close if @out
-    @out = StringIO.new
-    @parts = [@out]
+  def init_thread
+    Thread.current[:knjappserver] = {} if !Thread.current[:knjappserver]
+    Thread.current[:knjappserver][:kas] = @kas
+    Thread.current[:knjappserver][:httpsession] = self
+    Thread.current[:knjappserver][:session] = @session
+    Thread.current[:knjappserver][:get] = @get
+    Thread.current[:knjappserver][:post] = @post
+    Thread.current[:knjappserver][:meta] = @meta
+    Thread.current[:knjappserver][:cookie] = @cookie
   end
   
   def self.finalize(id)
@@ -125,7 +129,7 @@ class Knjappserver::Httpsession
   end
   
   def destruct
-    STDOUT.print "Httpsession destruct (#{@httpserver.http_sessions.length})\n" if @debug and @httpserver
+    STDOUT.print "Httpsession destruct (#{@httpserver.http_sessions.length})\n" if @debug and @httpserver and @httpserver.http_sessions
     
     begin
       @socket.close if @socket and !@socket.closed?
@@ -135,7 +139,7 @@ class Knjappserver::Httpsession
       #ignore if it fails...
     end
     
-    @httpserver.http_sessions.delete(self) if @httpserver
+    @httpserver.http_sessions.delete(self) if @httpserver and @httpserver.http_sessions
     @httpserver = nil
     
     @data = nil
@@ -147,204 +151,149 @@ class Knjappserver::Httpsession
     @out = nil
     @socket = nil
     @browser = nil
+    @resp = nil
+    @cgroup = nil
+    @handler = nil
     
     @eruby.destroy if @eruby
     @eruby = nil
     
-    @handler.destroy if @handler
-    @handler = nil
-    
     thread = @thread_request
     @thread_request = nil
     thread.kill if thread and thread.alive?
   end
   
   def serve
-    resp = Knjappserver::Httpresp.new
+    @meta = @handler.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
+    else
+      @cgroup.chunked = false
+    end
     
-    meta = @handler.meta
-    cookie = @handler.cookie
-    page_path = @handler.page_path
+    @page_path = @handler.page_path
+    @ext = File.extname(@page_path).downcase[1..-1].to_s
     
-    pinfo = Knj::Php.pathinfo(page_path)
-    ext = pinfo["extension"].downcase
+    @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)
     
-    ctype = @kas.types[ext.to_sym] if @kas.types[ext.to_sym]
-    ctype = @kas.config[:default_filetype] if !ctype and @kas.config.has_key?(:default_filetype)
-    resp.header("Content-Type", ctype)
+    @browser = Knj::Web.browser(@meta)
     
-    @browser = Knj::Web.browser(meta)
-    @ip = nil
-    @ip = meta["HTTP_X_FORWARDED_FOR"].split(",")[0].strip if !@ip and meta["HTTP_X_FORWARDED_FOR"]
-    @ip = meta["REMOTE_ADDR"] if !@ip and meta["REMOTE_ADDR"]
+    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
     
-    @ips = [meta["REMOTE_ADDR"]]
-    @ips << meta["HTTP_X_FORWARDED_FOR"].split(",")[0].strip if meta["HTTP_X_FORWARDED_FOR"]
+    if @cookie["KnjappserverSession"].to_s.length > 0
+      @session_id = @cookie["KnjappserverSession"]
+    elsif @browser["browser"] == "bot"
+      @session_id = "bot"
+    else
+      @session_id = @kas.session_generate_id(:meta => @meta)
+      send_cookie = true
+    end
     
-    @session_id = nil
-    @session_id = "bot"  if @browser["browser"] == "bot"
-    @session_id = cookie["KnjappserverSession"] if cookie["KnjappserverSession"].to_s.length > 0
+    begin
+      session = @kas.session_fromid(:idhash => @session_id, :ip => @ip, :meta => @meta)
+    rescue Knj::Errors::InvalidData => e
+      #User should not have the session he asked for because of invalid user-agent or invalid IP.
+      @session_id = @kas.session_generate_id(:meta => meta)
+      session = @kas.session_fromid(:idhash => @session_id, :ip => @ip, :meta => meta)
+      send_cookie = true
+    end
     
-    if !@session_id
-      @session_id = Digest::MD5.hexdigest("#{Time.new.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"]}")
-      
-      resp.cookie(CGI::Cookie.new(
+    if send_cookie
+      @resp.cookie(
         "name" => "KnjappserverSession",
         "value" => @session_id,
         "path" => "/",
-        "expires" => (Knj::Datet.new.months + 12).time
-      ).to_s)
+        "expires" => Time.now + 32140800 #add around 12 months
+      )
     end
     
-    session = @kas.session_fromid(:idhash => @session_id, :ip => @ip)
-    
     @session = session[:dbobj]
     @session_hash = session[:hash]
     
-    if @kas.config[:logging] and @kas.config[:logging][:access_db]
+    if @config.key?(:logging) and @config[:logging][:access_db]
+      @ips = [@meta["REMOTE_ADDR"]]
+      @ips << @meta["HTTP_X_FORWARDED_FOR"].split(",")[0].strip if @meta["HTTP_X_FORWARDED_FOR"]
       @kas.logs_access_pending << {
         :session_id => @session.id,
-        :date_request => Knj::Datet.new.dbstr,
+        :date_request => Time.now,
         :ips => @ips,
-        :get => @handler.get,
-        :post => @handler.post,
-        :meta => meta,
-        :cookie => cookie
+        :get => @get,
+        :post => @post,
+        :meta => @meta,
+        :cookie => @cookie
       }
     end
     
-    time_start = Time.now if @debug
-    serv_data = self.serve_real(
-      :filepath => page_path,
-      :get => @handler.get,
-      :post => @handler.post,
-      :cookie => cookie,
-      :meta => meta,
-      :headers => {},
-      :ctype => ctype,
-      :ext => ext,
-      :session => @session,
-      :session_id => @session_id,
-      :session_hash => @session_hash,
-      :httpsession => self,
-      :db => @kas.db_handler,
-      :kas => @kas
-    )
-    
-    serv_data[:headers].each do |header|
-      key = header[0]
-      val = header[1]
-      keystr = key.to_s.strip.downcase
-      
-      if keystr.match(/^set-cookie/)
-        WEBrick::Cookie.parse_set_cookies(val).each do |cookie|
-          resp.cookie(cookie.to_s)
-        end
-      else
-        resp.header(key, val)
-      end
-    end
-    
-    body_parts = []
-    @parts.each do |part|
-      if part.is_a?(Hash) and part[:thread]
-        part[:thread].join
-        part[:stringio].rewind
-        body_parts << part[:stringio]
-      elsif part.is_a?(StringIO) or part.is_a?(File)
-        part.rewind
-        body_parts << part
-      else
-        raise "Unknown object: '#{part.class.name}'."
-      end
-    end
-    resp.body = body_parts
-    
-    if serv_data[:lastmod]
-      resp.header("Last-Modified", serv_data[:lastmod].time)
-      resp.header("Expires", Time.now + (3600 * 24))
-    end
-    
-    if serv_data[:cache]
-      resp.status = 304
-      resp.header("Last-Modified", serv_data[:lastmod].time)
-      resp.header("Expires", Time.now + (3600 * 24))
-    end
-    
-    resp.status = serv_data[:statuscode] if serv_data[:statuscode]
-    STDOUT.print "Served '#{meta["REQUEST_URI"]}' in #{Time.now.to_f - time_start.to_f} secs.\n" if @debug
-    
-    resp.write_chunked(@socket) if meta["METHOD"] != "HEAD"
-    resp.destroy
-    
-    #Letting them be nil is simply not enough (read that on a forum) - knj.
-    serv_data.clear
+    self.init_thread
+    Thread.current[:knjappserver][:contentgroup] = @cgroup
+    time_start = Time.now.to_f if @debug
+    self.serve_real
+    @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
   end
   
-  def serve_real(details)
-    request = details[:request]
-    headers = {}
-    cont = ""
-    statuscode = nil
-    lastmod = false
-    max_age = 365 * 24
+  def serve_real
+    #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
     
-    cache = false
     cache_control = {}
     cache_use = true
     
-    if @handler.headers["cache-control"] and @handler.headers["cache-control"][0]
-      @handler.headers["cache-control"][0].scan(/(.+)=(.+)/) do |match|
+    if @headers["cache-control"] and @headers["cache-control"][0]
+      @headers["cache-control"][0].scan(/(.+)=(.+)/) do |match|
         cache_control[match[1]] = match[2]
       end
     end
     
-    cache_use = false if cache_control["max-age"].to_i <= 0
+    cache_use = false if cache_control.key?("max-age") and cache_control["max-age"].to_i <= 0
     
-    #check if we should use a handler for this request.
-    handler_use = false
-    @kas.config[:handlers].each do |handler_info|
-      if handler_info[:file_ext] and handler_info[:file_ext] == details[:ext]
-        handler_use = true
-        ret = handler_info[:callback].call(details)
-        cont = ret[:content] if ret[:content]
-        headers = ret[:headers] if ret[:headers]
-        break
-      elsif handler_info[:path] and handler_info[:mount] and details[:meta]["SCRIPT_NAME"].slice(0, handler_info[:path].length) == handler_info[:path]
-        details[:filepath] = "#{handler_info[:mount]}#{details[:meta]["SCRIPT_NAME"].slice(handler_info[:path].length, details[:meta]["SCRIPT_NAME"].length)}"
-        break
-      end
-    end
-    
-    if !handler_use
-      if !File.exists?(details[:filepath])
-        statuscode = 404
-        headers["Content-Type"] = "text/html"
-        @parts << StringIO.new("File you are looking for was not found: '#{details[:meta]["REQUEST_URI"]}'.")
-      else
-        lastmod = Knj::Datet.new(File.new(details[:filepath]).mtime)
-        
-        if cache_use and @handler.headers["if-modified-since"] and @handler.headers["if-modified-since"][0]
-          request_mod = Knj::Datet.parse(@handler.headers["if-modified-since"][0])
-          if request_mod == lastmod
-            cache = true
-          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
+      lastmod = File.mtime(@page_path)
+      
+      @resp.header("Last-Modified", lastmod.httpdate)
+      @resp.header("Expires", (Time.now + 86400).httpdate) #next day.
+      
+      if cache_use and @headers["if-modified-since"] and @headers["if-modified-since"][0]
+        request_mod = Knj::Datet.parse(@headers["if-modified-since"][0]).time
         
-        if !cache
-          @parts << File.new(details[:filepath]) #get plain content from file.
+        if request_mod == lastmod
+          @resp.status = 304
+          return nil
         end
       end
+      
+      @cgroup.new_io(File.new(@page_path))
     end
-    
-    details.clear
-    
-    return {
-      :statuscode => statuscode,
-      :content => cont,
-      :headers => headers,
-      :lastmod => lastmod,
-      :cache => cache
-    }
   end
 end