mongrel_esi 0.5.0 → 0.5.1

data/lib/esi/cache.rb

@@ -168,17 +168,14 @@ module ESI
 
     def cached?( uri, params )
       key = cache_key(uri,params)
-      @semaphore.synchronize do
-        fragment = @cache[key]
-        fragment and fragment.valid?
-      end
+      fragment = @semaphore.synchronize { @cache[key] }
+      fragment and fragment.valid?
     end
 
     def get( uri, params )
-      @semaphore.synchronize do
-        fragment = @cache[cache_key(uri,params)]
-        fragment.dup if fragment and fragment.respond_to?(:dup)
-      end
+      key = cache_key(uri,params)
+      fragment = @semaphore.synchronize { @cache[key] }
+      fragment.dup if fragment and fragment.respond_to?(:dup)
     end
  
     def put( uri, params, max_age, body )

data/lib/esi/config.rb

@@ -58,15 +58,15 @@ module ESI
       use_esi = false
       allowed_content_types = @config[:allowed_content_types]
 
-      if allowed_content_types and headers["Content-Type"] and allowed_content_types.respond_to?(:detect)
+      if allowed_content_types and headers["content-type"] and allowed_content_types.respond_to?(:detect)
         use_esi = allowed_content_types.detect do |type|
-          headers["Content-Type"].match( type )
+          headers["content-type"].match( type )
         end
         use_esi = true if use_esi
       end
 
       if @config[:enable_for_surrogate_only]
-        use_esi = headers["Surrogate-Control"] and /ESI/.match(headers["Surrogate-Control"])
+        use_esi = headers["surrogate-control"] and /ESI/.match(headers["surrogate-control"])
       end
 
       use_esi

data/lib/esi/dispatcher.rb

@@ -2,7 +2,7 @@ require 'esi/proxy'
 
 module ESI
 
-  class Dispatcher < ESI::Proxy
+  class Dispatcher < Mongrel::HttpHandler
     attr_reader :config, :router
 
     Thread.abort_on_exception = false
@@ -10,15 +10,13 @@ module ESI
     def initialize( options )
       super()
       @config = ESI::Config.new( options )
-      @router = nil
       if @config.start_invalidator?
         ESI::Invalidator.start( self )
       end
     end
 
     def process(request, response)
-      @router = @config.router
-      super
+      ESI::Proxy.new(@config).process(request,response)
     end
 
   end

data/lib/esi/parser.rb

@@ -20,28 +20,38 @@ module ESI
       @response = ESI::Response.new( output )
  
       end_tag_handler do|tag_name|
-        if self.esi_tag.name == tag_name.gsub(/esi:/,'')
-          @response.close_active_buffer
-          tag_buffer = @response.reserve_buffer
-          tag = self.esi_tag.clone
-          thread = Thread.new(tag,tag_buffer) do|tag,buffer|
-            begin
-              tag.close(tag_buffer)
-            ensure
-              tag_buffer.close_write
+        #puts "rb end #{tag_name.inspect}"
+        if self.esi_tag.name == tag_name.sub(/esi:/,'')
+
+          if tag_name.match(/try|include/) # run these in parallel
+            tag = self.esi_tag.clone
+            tag_buffer = @response.partial_buffer
+
+            #puts "start #{tag_name}"
+            thread = Thread.new(tag,tag_buffer) do|tag,buffer|
+              begin
+                tag.close(buffer)
+              ensure
+                buffer.close_write
+                #puts "finish #{tag_name}"
+              end
             end
+            @response.wait_thread( thread )
+          else
+            self.esi_tag.close( @response.active_buffer )
           end
+
           self.esi_tag = nil
 
-          @response.wait_thread( thread )
         else
           self.esi_tag.close_child(self.output,tag_name)
         end
       end
     end
 
-    def prepare( request_params, http_params, &block )
+    def prepare( request_params, http_params )
       start_tag_handler do|tag_name, attrs|
+        #puts "rb start #{tag_name.inspect}"
         tag = ESI::Tag::Base.create( @router,
                                      request_params,
                                      http_params,
@@ -52,13 +62,16 @@ module ESI
         tag.depth = self.depth if tag.respond_to?(:depth=)
         tag.max_depth = @max_depth if tag.respond_to?(:max_depth=)
 
-        if self.esi_tag
+        if self.esi_tag and self.esi_tag.respond_to?(:add_child)
           self.esi_tag.add_child(tag)
         else
           self.esi_tag = tag
         end
       end
-      self.output=block if block_given?
+      self.output_handler do|chars|
+        @response.active_buffer << chars
+        @response.send
+      end
     end
 
     def finish

data/lib/esi/processor.rb

@@ -8,43 +8,29 @@ module ESI
 
     include ESI::Log
 
-    def initialize( config, router )
+    def initialize( config, router, cache_buffer = nil )
       @config = config
       @router = router
       @chunk_count = 0
       @chunk_size = @config[:chunk_size] || 4096
+      @bytes_sent = 0
       @max_depth = @config[:max_depth] || 3
       @chunk_buffer = StringIO.new # when buffer reaches chunk_size write to the http_response socket
       @parser = ESI::Parser.new( @chunk_buffer, @router, @config.cache, @max_depth )
+      @cache_buffer = cache_buffer
     end
-    
-    def send_head( http_response, status )
-
-      http_response.header["Transfer-Encoding"] = "chunked"
-      # this is the important part, rather then send the whole document back we send in chunks
-      # each fragment is roughly in it's own chunk, this does mean we require http 1.1, chunk size is still a limit
-      header = Mongrel::Const::STATUS_FORMAT % [status, Mongrel::HTTP_STATUS_CODES[status]]
-      header.gsub!(/Connection: close\r\n/,'')
-      http_response.header.out.rewind
-      header << http_response.header.out.read + Mongrel::Const::LINE_END
-      header.gsub!(/Status:.*?\r\n/,'')
-      http_response.write( header )
-
-      #print header
-
-    end
-
+ 
     def send_body( http_request, params, http_response, proxy_response )
       
       @http_response = http_response
 
       # prepare the parser given the raw request params and the preprocessed request params
-      @parser.prepare( http_request.params, params ) do|chars|
-        if @parser.response.active_buffer.closed_write?
-          @parser.response.open_active_buffer
-          @parser.response.send
-        end
-        @parser.response.active_buffer << chars
+      @parser.prepare( http_request.params, params )
+
+      # feed data to the parser
+      proxy_response.read_body do |data|
+        @parser.process data
+        @cache_buffer << data if @cache_buffer
         if @chunk_buffer.size > @chunk_size
           send_chunk
           @chunk_buffer = StringIO.new
@@ -52,19 +38,11 @@ module ESI
         end
       end
 
-      #timer = Time.now
-      # feed data to the parser
-      proxy_response.read_body { |data| @parser.process data }
-      #puts "processing time: #{Time.now - timer}"
-
-      #timer = Time.now
-      # finish the request
       @parser.finish 
-      #puts "finish time: #{Time.now - timer}"
 
       send_chunk
 
-      @chunk_count
+      [@chunk_count,@bytes_sent]
     rescue => e
       STDERR.puts "\n#{e.message}: #{e.backtrace.join("\n")}\n"
     ensure 
@@ -76,10 +54,10 @@ module ESI
       @chunk_buffer.rewind
       size = @chunk_buffer.size
       chunk_header = "#{"%x" % size}" + Mongrel::Const::LINE_END
-      #puts chunk_header.inspect
+      #print chunk_header
       @http_response.write( chunk_header )  # write the chunk size
-      #puts buffer.inspect
       @http_response.write( @chunk_buffer.read + Mongrel::Const::LINE_END )  # write the chunk
+      @bytes_sent += size
 
       @chunk_count += 1
     end

data/lib/esi/proxy.rb

@@ -9,63 +9,131 @@ require 'esi/cache'
 require 'esi/config'
 require 'esi/router'
 require 'esi/processor'
+require 'esi/version'
 
 module ESI
 
-  class Proxy < Mongrel::HttpHandler
-    attr_reader :config, :router
+  class Proxy 
+    attr_reader :config, :router, :cache_buffer
     include ESI::Log
+    SERVER="mongrel-esi/#{ESI::VERSION::STRING}"
+
+    def initialize( config )
+      @config = config
+      @router = config.router
+      @cache_buffer = nil
+    end
 
     def process(request, response)
  
       start = Time.now
       status = 200
-      url = @router.url_for(request.params["REQUEST_URI"])
 
-      params = http_params(request.params)
+      http_params = http_params(request.params)
 
-      log_debug "#{request.params["REQUEST_METHOD"]} => #{url}"
+      url = @router.url_for(request.params["REQUEST_URI"])
+      #log_debug "#{request.params["REQUEST_METHOD"]} => #{url}"
       chunk_count = 0
+      bytes_sent = 0
       uri = URI.parse(url)
 
       path_with_query = uri.query ? "#{uri.path}?#{uri.query}" :  uri.path
+ 
+      if @config.cache.cached?( path_with_query, http_params )
+        cache_buffer = @config.cache.get( path_with_query, http_params ).body
+        bytes_sent = send_esi_buffered( status, response, request, http_params, cache_buffer )
+      else
+        proxy_request = (request.params["REQUEST_METHOD"] == "POST") ?
+                            Net::HTTP::Post.new( path_with_query, http_params ) :
+                            Net::HTTP::Get.new( path_with_query, http_params )
+
+        # open the conneciton up so we can start to stream the connection
+        Net::HTTP.start(uri.host, uri.port).request(proxy_request,request.body.read) do|proxy_response|
+          chunk_count,bytes_sent = send_response( request, response, http_params, proxy_response )
+        end # end request
+ 
+        if !@control.nil? and !@cache_buffer.nil? and @control['max-age'].to_i > 0 and @cache_buffer.size > 0
+          @cache_buffer.rewind
+          @config.cache.put(path_with_query, http_params, @control['max-age'].to_i, @cache_buffer.read )
+        end
 
-      proxy_request = (request.params["REQUEST_METHOD"] == "POST") ?
-                          Net::HTTP::Post.new( path_with_query, params ) :
-                          Net::HTTP::Get.new( path_with_query, params )
-
-      proxy_connection = Net::HTTP.start(uri.host, uri.port)
+      end
 
-      # open the conneciton up so we can start to stream the connection
-      proxy_connection.request(proxy_request,request.body.read) do|proxy_response|
+    rescue => e
+      STDERR.puts "\n#{e.message}: error at #{e.backtrace.first} msg at #{__FILE__}:#{__LINE__}\n"
+    ensure
+      log_request "\n#{url}, #{Time.now - start} seconds with status #{status} and #{chunk_count} chunks, #{bytes_sent} bytes\n"
+    end
 
-        status = read_status( proxy_response )
+  protected
+    def send_response( http_request, http_response, http_params, proxy_response )
+      status = read_status( proxy_response )
+
+      headers = copy_headers( proxy_response )
+      
+      if proxy_response.header["Surrogate-Control"]
+        @control = {}
+        proxy_response.header["Surrogate-Control"].split(',').each do |pair|
+          k,v = pair.strip.split('=')
+          @control[k] = v
+        end
+        if @control['max-age'].to_i > 0
+          @cache_buffer = StringIO.new
+        end
+      end
 
-        copy_headers( response.header, proxy_response ) unless status >= 500
 
-        if status >= 500 or !@config.enable_esi_processor?( proxy_response )
-          response.start(status, true) do|head,out|
+      if status >= 500 or !@config.enable_esi_processor?( proxy_response )
+        headers.each do|k,v|
+          http_response.header[k] = v
+        end
+        proxy_direct( http_response, status, proxy_response )
+      else
+        if http_request.params["HTTP_VERSION"].match(/1.0/)
+          buffer = proxy_response.read_body
+          bytes=send_esi_buffered( status, http_response, http_request, http_params, buffer )
+          @cache_buffer << buffer if @cache_buffer
+          [0,bytes]
+        else
+          header = Mongrel::Const::STATUS_FORMAT % [status, Mongrel::HTTP_STATUS_CODES[status]]
+          headers.each {|k,v| header << "#{k}: #{v}\r\n" }
+          header << "Transfer-Encoding: chunked\r\n\r\n"
+          http_response.write( header )
+          proxy_filter_esi( http_request, http_response, http_params, proxy_response )
+        end
+      end
 
-            # proxy the 500 response
-            proxy_response.read_body do|fragment|
-              out << fragment
-            end
+    end
 
-          end
-        else
-          processor = Processor.new( @config, @router )
-          processor.send_head( response, status )
-          chunk_count = processor.send_body( request, params, response, proxy_response )
+    def proxy_direct( http_response, status, proxy_response )
+      bytes_sent = 0
+      http_response.start(status, true) do|head,out|
+        proxy_response.read_body do|fragment|
+          out << fragment
+          bytes_sent += fragment.size
         end
-      end # end request
+      end
+      return [0,bytes_sent]
+    end
 
-    rescue => e
-      STDERR.puts "\n#{e.message}: error at #{e.backtrace.first} msg at #{__FILE__}:#{__LINE__}\n"
-    ensure
-      log_request "\nCompleted => #{url}, #{Time.now - start} seconds with status #{status} and #{chunk_count} chunks\n"
+    def proxy_filter_esi( http_request, http_response, http_params, proxy_response )
+      processor = Processor.new( @config, @router, @cache_buffer )
+      processor.send_body( http_request, http_params, http_response, proxy_response )
+    end
+    
+    def send_esi_buffered( status, response, request, http_params, buffer )
+      bytes = 0
+      response.start(status, true) do|head,out|
+        head["Server"] = SERVER
+        parser = ESI::Parser.new( out, @router, @config.cache, 3 )
+        parser.prepare( request.params, http_params )
+        parser.process buffer
+        parser.finish
+        bytes = out.size
+      end
+      bytes
     end
 
-  protected
 
     def read_status(response)
       Net::HTTPResponse::CODE_TO_OBJ.select { |k,v| v == response.class }.first[0].to_i rescue 500
@@ -74,29 +142,30 @@ module ESI
     def http_params(params)
       updated_params = {}
       params.each do|k,v|
-        k = k.split('_').collect { |t| t.capitalize }.join('-')
-        if k[0,5] =='Http-'
-          k[0,5] = ''
-          updated_params[k] = v
+        if k.match(/HTTP/i)
+          k = k.split('_').collect { |t| t.capitalize }.join('-')
+          if k[0,5] =='Http-'
+            k[0,5] = ''
+            updated_params[k] = v
+          end
         end
       end
       updated_params
     end
 
-    def copy_headers(head,response)
+    def copy_headers(response)
+      headers = {}
       response.to_hash.each do |k,v|
         # for Set-Cookie we need to split on ,
         # some edge cases with , since things like expires might be a date with , in them.
         k = k.split(/-/).map{|s| s.capitalize }.join('-')
-        if k == "Set-Cookie"
-          v.each do|cookie|
-            head["Set-Cookie"] = cookie.strip # mongrel is case sensitive about handling duplicates
-          end
-        else
-          head[k] = v unless k == "Content-Length" or k == "Surrogate-Control" or k == "Server"
-        end
+
+        next if k.match(/Content-Length|Surrogate-Control|Server|Connection|Status/i)
+
+        headers[k] = v
       end
-      head["Server"] = "MongrelESI 0.4"
+      headers["Server"] = SERVER
+      headers
     end
 
   end # Handler

data/lib/esi/response.rb

@@ -1,81 +1,49 @@
+# Copyright (c) 2008 Todd A. Fisher
+# see LICENSE
 require 'fastthread'
 require 'thread'
 require 'stringio'
 
-
 module ESI
   class Response
     attr_reader :active_buffer
     attr_accessor :output
 
     def initialize( output )
-      @lock = Mutex.new
       @count = 0
       @back_buffer = []
       @output = output
-      @last_out = -1
+      @last_out = 0
       @threads = []
-      @active_buffer = reserve_buffer 
+      @active_buffer = reserve_buffer
     end
 
     def update_output(output)
-      @lock.synchronize do
-        @output = output
-      end
-    end
-
-    def close_active_buffer
-      @lock.synchronize do
-        if !@active_buffer.closed_write?
-          @active_buffer.close_write
-        end
-      end
-    end
-
-    def back_buffer_ready?
-      @lock.synchronize do
-        @back_buffer[@last_out+1..@count].size > 2
-      end
+      @output = output
     end
 
-    def open_active_buffer
-      @lock.synchronize do
-        if @active_buffer.closed_write?
-          begin
-            @lock.unlock
-            @active_buffer = reserve_buffer
-          ensure
-            @lock.lock
-          end
-        end
-      end
+    def partial_buffer
+      @active_buffer.close_write
+      temp = reserve_buffer
+      @active_buffer = reserve_buffer
+      temp
     end
 
     # return's new buffer
     def reserve_buffer
-      @lock.synchronize do
-        buffer = @back_buffer[@count] = StringIO.new
-        @count += 1
-        buffer
-      end
+      buffer = @back_buffer[@count] = StringIO.new
+      @count += 1
+      buffer
     end
 
     def send
-      @lock.synchronize do
-        # roll up requests
-        until @last_out == @count
-          o = @back_buffer[@last_out+1]
-          if o.nil? or !o.closed_write?
-            #puts "#{self} buffering...#{@last_out} to #{@count} #{@back_buffer[@last_out+1..@count].map{|b| b ? b.closed_write? : 'nil' }.join(',')}"
-            break
-          end
-          o.rewind
-          buf = o.read
-          #puts "#{Thread.current} #{self} sending: #{@last_out+1} #{buf.inspect}"
-          @back_buffer[@last_out+1] = nil # clear it out, release memory
-          @output << buf
-          @last_out += 1
-        end
+      check_buffers = @back_buffer[@last_out..@count]
+
+      for buffer in check_buffers do
+        break if buffer.nil? or !buffer.closed_write?
+        buffer.rewind
+        @output << buffer.read
+        @last_out += 1
       end
     end
 
@@ -85,17 +53,17 @@ module ESI
 
     def flush
       @threads.each{|t| t.join }
-      @active_buffer.close_write
+      @active_buffer.close_write if !@active_buffer.closed_write?
       # roll up requests
       @last_out = 0 if @last_out == -1
       tail_buffer = (@back_buffer[@last_out..@back_buffer.size]||[])
-      #puts "\nflushing:#{Thread.current} #{self} with #{tail_buffer.inspect}"
+      #puts "\nflushing: #{tail_buffer.inspect} from #{@back_buffer.inspect}"
       while !tail_buffer.empty?
         o = tail_buffer.shift
         unless o.nil?
           o.rewind
           buf = o.read
-          #puts "#{Thread.current} #{self} flush : #{buf.inspect}"
+          #puts "flush : #{buf.inspect}"
           @output << buf
         end
         #puts "#{self} sending: #{@count-tail_buffer.size}"