mongrel_esi 0.4.1 → 0.5.0

data/ext/esi/parser.rb

@@ -1,49 +0,0 @@
-require 'esi/machine'
-
-module ESI
-  class Parser < ESI::ParserMachine
-    # Provides a stream like interface to a single parameter block
-    class StreamCallBack
-      def initialize(callback)
-        @callback = callback
-      end
-      def << (output) 
-        @callback.call( output )
-      end
-    end
-    attr_accessor :esi_tag, :output, :depth
-
-    def initialize( options = {} )
-      super()
-      @data = nil
-      @prev_buffer = ""
-      @start_tag = nil # call back for when we encounter a start tag
-      @end_tag = nil # call back for when we encounter an end tag
-      @esi_tag = nil # the current active esi tag
-      @output = nil
-      @depth = options[:depth] || 0 # used to track the depth of requests include tags should be initialized with this depth
-    end
-
-    def start_tag_handler(&block)
-      @start_tag = block
-    end
-
-    def end_tag_handler(&block)
-      @end_tag = block
-    end
-
-    def output_handler(&block)
-      @output = StreamCallBack.new(block)
-    end
-
-  private
-    def stream_buffer(string)
-      if @esi_tag
-        @esi_tag.buffer( @output, string )# unless string.strip.empty?
-      else
-        @output << string
-      end
-    end
-
-  end
-end

data/ext/esi/ruby_esi.rl

@@ -1,135 +0,0 @@
-module ESI
-  class ParserMachine
-
-%%{
-  machine esi;
-
-  action begin {
-    @mark = p
-  }
-  action finish {
-  }
-
-  # record the position of the start tag
-  action see_start_tag {
-    @tag_text = data[@mark,p-@mark]
-    @tag_info = {} # store the tag attributes
-    @tag_info[:name] = @tag_text.sub('<','').strip
-    @tag_info[:attributes] = {}
-#    puts "have esi tag at #{p}=>#{@mark}:#{data[p,1].inspect} with data #{@tag_text.inspect}"
-    @mark = p
-  }
-
-  action see_end_tag {
-#    puts "parsed esi tag at #{p}=>#{@mark}:#{data[p,1].inspect} with data #{@tag_text.inspect}"
-    @start_tag.call @tag_info[:name], @tag_info[:attributes] if @start_tag
-    @end_tag.call @tag_info[:name] if @end_tag
-    @attr_key = nil
-    @attr_value = nil
-    @tag_text = nil
-    @tag_info = nil
-  }
-  
-  action see_block_start_with_attributes {
-#    puts "parsed esi tag at #{p}=>#{@mark}:#{data[p,1].inspect} with data #{@tag_text.inspect}"
-    @start_tag.call @tag_info[:name], @tag_info[:attributes] if @start_tag
-    @attr_key = nil
-    @attr_value = nil
-    @tag_text = nil
-    @tag_info = nil
-  }
-
-  action see_attribute_key {
-    @attr_key = data[@mark,p-@mark]
-    @mark += (@attr_key.size)
-    @attr_key.gsub!(/^['"]/,'')
-    @attr_key.strip!
-#    puts "SeeAttributeKey: #{data[@mark,1].inspect}: #{data[p,1].inspect} #{@attr_key.inspect}"
-  }
-
-  action see_attribute_value {
-    @attr_value = data[@mark,p-@mark]
-    @attr_value.strip!
-    @attr_value.gsub!(/^=?\s*['"]/,'')
-    @attr_value.gsub!(/['"]$/,'')
-
-    @tag_info[:attributes][@attr_key] = @attr_value
-#    puts "SeeAttributeValue: #{p} #{data[@mark,1].inspect}: #{data[p,1].inspect} #{@attr_key.inspect} => #{@attr_value.inspect}"
-    @mark = p
-  }
-
-  action block_start_tag {
-    tag_text = data[@mark+1,p-@mark-1]
-    @start_tag.call tag_text, {} if @start_tag
-#    puts "Block start: #{p} #{tag_text}"
-  }
-
-  action block_end_tag {
-    tag_text = data[@mark+2,p-@mark-2]
-    @end_tag.call tag_text if @end_tag
-#    puts "Block end: #{p} #{tag_text}"
-  }
-
-  action echo {
-#    print " [#{data[p,1].inspect}:#{cs}] " if $debug
-
-    case cs
-    when 0
-      # NOTE: state 12 is the character state before <esi:try>, state 7 is the character before </esi:try>
-      #                                                     |                                           |
-      #                                                     - state 12                                  - state 7
-      # state 60 is for empty inline tags e.g.
-      # <esi:include/>
-      #              |
-      #              - 60
-
-      if @prev_state != 12 and @prev_state != 7
-        if !@prev_buffer.empty? and (@prev_state != (esi_en_main + 1)) and @prev_state != 60
-          stream_buffer @prev_buffer
-        end
-        stream_buffer data[p,1]
-      end
-      @prev_buffer = ""
-    else
-      @prev_buffer << data[p,1]
-    end
-    @prev_state = cs
-  }
-
-  include esi_common_parser "common.rl";
-}%%
-
-    def initialize
-      %% write data;
-    end
-
-    # process a block of esi tags
-    def process(data)
-      if @data
-  #      puts "append : #{@mark} : #{p}"
-        data = @data + data
-        p = @data.length
-      end
-      @mark ||= 0
-      p ||= 0
-      pe ||= data.length
-      @cs ||= esi_start
-      cs = @cs
-  #    puts "process: #{cs.inspect} :start #{data.inspect}, #{p}"
-      %% write exec;
-      @cs = cs
-      if( @cs != esi_start && @cs != 0 )
-  #    puts "append process: #{@cs.inspect}"
-        @data = data
-      else
-        @data = nil
-      end
-    end
-
-    def finish
-      %% write eof;
-    end
-
-  end
-
-end

data/lib/esi/handler.rb

@@ -1,221 +0,0 @@
-require 'uri'
-require 'timeout'
-require 'net/http'
-
-require 'esi/logger'
-require 'esi/cache'
-require 'esi/config'
-require 'esi/router'
-require 'esi/esi'
-require 'esi/tag/base'
-require 'esi/tag/include'
-require 'esi/tag/invalidate'
-require 'esi/tag/attempt'
-require 'esi/tag/except'
-require 'esi/tag/try'
-
-module ESI
-
-  class Handler
-    attr_reader :config
-    include ESI::Log
-
-    def initialize(dispatcher)
-      @config = dispatcher.config
-      @router = dispatcher.router
-    end
-
-    def process(request, response)
- 
-      start = Time.now
-      status = 200
-      url = @router.url_for(request.params["REQUEST_URI"])
-
-      params = http_params(request.params)
-
-      proxy_error = nil
-
-
-      log_debug "#{request.params["REQUEST_METHOD"]} => #{url}"
-      chunk_count = 0
-			uri = URI.parse(url)
-
-			path_with_query = uri.query ? "#{uri.path}?#{uri.query}" :  uri.path
-
-			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)
-
-			# open the conneciton up so we can start to stream the connection
-			proxy_connection.request(proxy_request,request.body.read) do|proxy_response|
-
-				status = read_status( proxy_response )
-
-				copy_headers( response.header, proxy_response ) unless status >= 500
-
-				if status >= 500 or (status < 400 and status >= 300) or !@config.enable_esi_processor?( proxy_response )
-					response.start(status, true) do|head,out|
-
-						if status >= 500
-							# TODO: only report this if configured to expose it
-							out << proxy_error
-						end
-
-						# proxy the 500 response
-						proxy_response.read_body do|fragment|
-							out << fragment
-						end
-
-					end
-				else
-          # NOTE: It's very important that surrogate control headers are set to parse only if the 
-          # page has esi:include tags.  Because of the nature of Transfer-Encoding: chunked if we keep
-          # everything in memory until we reach an esi tag.  Then we load the tag into memory and send the next
-          # chunk and so on.  This means that the density of tags to markup will result in more or less of the document
-          # being stored in memory.  A way we can get around this and attempt to keep a fixed size of the document in 
-          # memory at all time is by setting a buffer size of say 1024.  Then no matter what we'll always chunk the document
-          # by 1024 or some other size chunk.
-					begin
-						# Use the ESI Parser
-
-						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/,'')
-						response.header.out.rewind
-						header << response.header.out.read + Mongrel::Const::LINE_END
-						header.gsub!(/Status:.*?\r\n/,'')
-						response.write( header )
-
-						#print header
- 
-            parser = ESI::CParser.new
-            chunk_size = @config[:chunk_size] || 4096
-            max_depth = @config[:max_depth] || 3
-            buffer = "" # when buffer reaches chunk_size write to the response socket
-
-            # handle start tags
-            parser.start_tag_handler do|tag_name, attrs|
-              tag = ESI::Tag::Base.create( @router,
-                                           request.params,
-                                           params,
-                                           tag_name.gsub(/esi:/,''),
-                                           attrs,
-                                           @config.cache )
-              # set the tag depth
-              tag.depth = parser.depth if tag.respond_to?(:depth=)
-              tag.max_depth = max_depth if tag.respond_to?(:max_depth=)
-
-              if parser.esi_tag
-                parser.esi_tag.add_child(tag)
-              else
-                parser.esi_tag = tag
-              end
-            end
-
-            # handle end tags
-            parser.end_tag_handler do|tag_name|
-              #ct = Time.now
-              if parser.esi_tag.name == tag_name.gsub(/esi:/,'')
-                parser.esi_tag.close(parser.output)
-                parser.esi_tag = nil
-              else
-                parser.esi_tag.close_child(parser.output,tag_name)
-              end
-              #puts "\t[#{tag_name}] Time to close: #{Time.now - ct}"
-            end
- 
-            # handle data streaming
-            parser.output_handler do|chars|
-              buffer << chars
-              if buffer.size >= chunk_size
-                #print buffer
-                send_chunk( response, buffer )
-                chunk_count += 1
-                buffer = ""
-              end
-            end
-
-            #t = Time.now
-            proxy_response.read_body do|data|
-              #pt = Time.now
-              parser.process data
-              #puts "Time in process: #{Time.now - pt}"
-            end
-            #puts "Response Time: #{Time.now - t}"
-
-            parser.finish 
-            parser = nil
-
-            if buffer.size > 0
-              #print buffer
-							send_chunk( response, buffer )
-              chunk_count += 1
-            end
-
-					rescue => e
-            STDERR.puts "\n#{e.class}: error in #{__FILE__}:#{__LINE__}\n"
-					end
-					response.write( "0\r\n\r\n" )
-					response.done = true
-				end
-			end # end request
-
-		rescue => e
-      STDERR.puts "\n#{e.class}: error in #{__FILE__}:#{__LINE__}\n"
-		ensure
-
-      log_request "\nCompleted => #{url}, #{Time.now - start} seconds with status #{status} and #{chunk_count} chunks\n"
-
-    end
-
-protected
-
-    def send_chunk( response, buffer )
-      # send a new chunk
-      size = buffer.size
-      chunk_header = "#{"%x" % size}" + Mongrel::Const::LINE_END
-      #puts chunk_header.inspect
-      response.write( chunk_header )  # write the chunk size
-      #puts buffer.inspect
-      response.write( buffer + Mongrel::Const::LINE_END )  # write the chunk
-    end
-
-    def read_status(response)
-      Net::HTTPResponse::CODE_TO_OBJ.select { |k,v| v == response.class }.first[0].to_i rescue 500
-    end
-
-    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
-        end
-      end
-      updated_params
-    end
-
-    def copy_headers(head,response)
-      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
-      end
-      head["Server"] = "MongrelESI 0.4"
-    end
-
-  end # Handler
-
-end # ESI

data/lib/net/ahttp.rb

@@ -1,36 +0,0 @@
-# Non-blocking HTTP Client/Server Library
-# The idea is to use Ruby 1.8.5's non blocking IO methods to provide an interface
-# to HTTP client and server that can be more efficient then the standard Net::HTTP 
-
-module Net
-  module An
-    class HTTP
-      def self.select
-      end
-    end
-
-    class IOSocket < Socket
-      def process
-      end
-    end
-
-    class IORequest < IOSocket
-      def process
-      end
-    end
-
-    class IOResponse < IOSocket
-      def process
-      end
-    end
-
-  end
-end
-
-
-#
-# emits io handles, these objects have a
-# process method
-Net::An::HTTP.select do|io|
-  io.process
-end