hatetepe 0.5.2 → 0.6.0.pre

data/lib/hatetepe/body.rb

@@ -1,182 +0,0 @@
-require "em-synchrony"
-require "eventmachine"
-require "stringio"
-
-module Hatetepe
-  # Thin wrapper around StringIO for asynchronous body processing.
-  class Body
-    include EM::Deferrable
-    
-    # The wrapped StringIO.
-    attr_reader :io
-    
-    # The origin Client or Server connection.
-    attr_accessor :source
-    
-    # Create a new Body instance.
-    #
-    # @param [String] data
-    #   Initial content of the StringIO object.
-    def initialize(data = "")
-      @receivers = []
-      @io = StringIO.new(data)
-    end
-    
-    # Blocks until the Body is write-closed.
-    #
-    # Use this if you want to wait until _all_ of the body has arrived before
-    # continuing. It will resume the originating connection if it's paused.
-    #
-    # @return [undefined]
-    def sync
-      source.resume if source && source.paused?
-      EM::Synchrony.sync self
-    end
-    
-    # Forwards to StringIO#length.
-    #
-    # Blocks until the Body is write-closed. Returns the current length of the
-    # underlying StringIO's content.
-    #
-    # @return [Fixnum]
-    #   The StringIO's length.
-    def length
-      sync
-      io.length
-    end
-    
-    # Returns true if the underlying StringIO is empty, false otherwise.
-    #
-    # @return [Boolean]
-    #   True if empty, false otherwise.
-    def empty?
-      length == 0
-    end
-    
-    # Forwards to StringIO#pos.
-    #
-    # Returns the underlying StringIO's current pointer position.
-    #
-    # @return [Fixnum]
-    #   The current pointer position.
-    def pos
-      io.pos
-    end
-    
-    # Forwards to StringIO#rewind.
-    #
-    # Moves the underlying StringIO's pointer back to the beginnung.
-    #
-    # @return [undefined]
-    def rewind
-      sync
-      rewind!
-    end
-
-    # Rewinds underlying IO without blocking
-    #
-    # TODO this is a hack. the whole blocking/rewinding stuff needs to be
-    #      more though out.
-    #
-    # @api protected
-    def rewind!
-      io.rewind
-    end
-    
-    # Forwards to StringIO#close_write.
-    #
-    # Write-closes the body and succeeds, thus releasing all blocking method
-    # calls like #length, #each, #read and #get.
-    #
-    # @return [undefined]
-    def close_write
-      io.close_write
-      succeed
-    end
-    
-    # Forwards to StringIO#closed_write?.
-    #
-    # Returns true if the body is write-closed, false otherwise.
-    #
-    # @return [Boolean]
-    #   True if the body is write-closed, false otherwise.
-    def closed_write?
-      io.closed_write?
-    end
-    
-    # Yields incoming body data.
-    #
-    # Immediately yields all data that has already arrived. Blocks until the
-    # Body is write-closed and yields for each call to #write until then.
-    #
-    # @yield [String] Block to execute for each incoming data chunk.
-    #
-    # @return [Enumerator,self]
-    def each(&block)
-      return to_enum(__method__) unless block
-
-      @receivers << block
-      block.call io.string.dup unless io.string.empty?
-      sync
-
-      self
-    end
-    
-    # Forwards to StringIO#read.
-    #
-    # From the Rack Spec: If given, +length+ must be a non-negative Integer
-    # (>= 0) or +nil+, and +buffer+ must be a String and may not be nil. If
-    # +length+ is given and not nil, then this method reads at most +length+
-    # bytes from the input stream. If +length+ is not given or nil, then this
-    # method reads all data until EOF. When EOF is reached, this method returns
-    # nil if +length+ is given and not nil, or "" if +length+ is not given or
-    # is nil. If +buffer+ is given, then the read data will be placed into
-    # +buffer+ instead of a newly created String object.
-    #
-    # @param [Fixnum] length (optional)
-    #   How many bytes to read.
-    # @param [String] buffer (optional)
-    #   Buffer for read data.
-    #
-    # @return [nil]
-    #   +nil+ if EOF has been reached.
-    # @return [String]
-    #   All data or at most +length+ bytes of data if +length+ is given.
-    def read(*args)
-      sync
-      io.read *args
-    end
-    
-    # Forwards to StringIO#gets.
-    #
-    # Reads one line from the IO. Returns the line or +nil+ if EOF has been
-    # reached.
-    #
-    # @return [String]
-    #   One line.
-    # @return [nil]
-    #   If has been reached.
-    def gets
-      sync
-      io.gets
-    end
-    
-    # Forwards to StringIO#write.
-    #
-    # Appends the given String to the underlying StringIO annd returns the
-    # number of bytes written.
-    #
-    # @param [String] data
-    #   The data to append.
-    #
-    # @return [Fixnum]
-    #   The number of bytes written.
-    def write(data)
-      ret = io.write data
-      @receivers.each do |r|
-        Fiber.new { r.call data }.resume
-      end
-      ret
-    end
-  end
-end

data/lib/hatetepe/builder.rb

@@ -1,171 +0,0 @@
-require "rack/utils"
-
-module Hatetepe
-  class BuilderError < StandardError; end
-  
-  class Builder
-    def self.build(&block)
-      message = ""
-      builder = new do |b|
-        b.on_write {|data| message << data }
-      end
-      
-      block.arity == 0 ? builder.instance_eval(&block) : block.call(builder)
-      
-      builder.complete
-      return message.empty? ? nil : message
-    end
-    
-    attr_reader :state
-    
-    def initialize(&block)
-      reset
-      @on_write, @on_complete, @on_error = [], [], []
-      
-      if block
-        block.arity == 0 ? instance_eval(&block) : block.call(self)
-      end
-    end
-    
-    def reset
-      @state = :ready
-      @chunked = nil
-    end
-    
-    [:write, :complete, :error].each do |hook|
-      define_method :"on_#{hook}" do |&block|
-        store = instance_variable_get(:"@on_#{hook}")
-        return store unless block
-        store << block
-      end
-    end
-    
-    def ready?
-      state == :ready
-    end
-    
-    def writing_headers?
-      state == :writing_headers
-    end
-    
-    def writing_body?
-      state == :writing_body
-    end
-    
-    def writing_trailing_headers?
-      state == :writing_trailing_headers
-    end
-    
-    def chunked?
-      @chunked
-    end
-    
-    def request(req)
-      request_line req[0], req[1], (req[4] || "1.1")
-      headers req[2]
-      body req[3] if req[3]
-      complete
-    end
-    
-    def request_line(verb, uri, version = "1.1")
-      complete unless ready?
-      write "#{verb.upcase} #{uri} HTTP/#{version}\r\n"
-      @state = :writing_headers
-    end
-    
-    def response(res)
-      response_line res[0], (res[3] || "1.1")
-      headers res[1]
-      body res[2] if res[2]
-      complete
-    end
-    
-    def response_line(code, version = "1.1")
-      complete unless ready?
-      unless status = Rack::Utils::HTTP_STATUS_CODES[code]
-        error "Unknown status code: #{code}"
-      end
-      
-      write "HTTP/#{version} #{code} #{status}\r\n"
-      @state = :writing_headers
-    end
-    
-    def header(name, value)
-      value = String(value)
-      raw_header "#{name}: #{value}" unless value.empty?
-    end
-    
-    def headers(hash)
-      hash.each {|k, v| header k, v }
-    end
-    
-    def raw_header(header)
-      if ready?
-        error "A request or response line is required before writing headers"
-      elsif writing_body?
-        error "Trailing headers require chunked transfer encoding" unless chunked?
-        write "0\r\n"
-        @state = :writing_trailing_headers
-      end
-      
-      if @chunked.nil? && header[0..13] == "Content-Length"
-        @chunked = false
-      elsif @chunked.nil? && header[0..16] == "Transfer-Encoding"
-        @chunked = true
-      end
-      
-      write "#{header}\r\n"
-    end
-    
-    def body(body)
-      body.each {|c| body_chunk c }
-      # XXX complete here?
-    end
-    
-    def body_chunk(chunk)
-      if ready?
-        error "A request or response line and headers are required before writing body"
-      elsif writing_trailing_headers?
-        error "Cannot write body after trailing headers"
-      elsif writing_headers?
-        if @chunked.nil?
-          header "Transfer-Encoding", "chunked"
-        end
-        write "\r\n"
-        @state = :writing_body
-      end
-      
-      chunk = chunk.to_s
-      if chunked?
-        write "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n"
-      else
-        write chunk unless chunk.empty?
-      end
-    end
-    
-    def complete
-      if ready?
-        return
-      elsif writing_headers? && @chunked.nil?
-        header "Content-Length", "0"
-      end
-      body_chunk ""
-
-      on_complete.each {|blk| blk.call }
-      reset
-    end
-    
-    def write(data)
-      on_write.each {|blk| blk.call data }
-    end
-    
-    def error(message)
-      exception = BuilderError.new(message)
-      unless on_error.empty?
-        on_error.each {|blk| blk.call exception }
-      else
-        raise exception
-      end
-    end
-  end
-end

data/lib/hatetepe/cli.rb

@@ -1,61 +0,0 @@
-require "thor"
-
-module Hatetepe
-  class CLI < Thor
-    map "--version" => :version
-    map "-v" => :version
-    
-    default_task :start
-    
-    desc :version, "Print version information"
-    def version
-      require "hatetepe/version"
-      say Hatetepe::VERSION
-    end
-    
-    desc "[start]", "Start a server"
-    method_option :bind, :aliases => "-b", :type => :string,
-      :banner => "Bind to the specified TCP interface (default: 127.0.0.1)"
-    method_option :port, :aliases => "-p", :type => :numeric,
-      :banner => "Bind to the specified port (default: 3000)"
-    method_option :rackup, :aliases => "-r", :type => :string,
-      :banner => "Load specified rackup (.ru) file (default: config.ru)"
-    method_option :env, :aliases => "-e", :type => :string,
-      :banner => "Boot the app in the specified environment (default: development)"
-    method_option :timeout, :aliases => "-t", :type => :numeric,
-      :banner => "Time out connections after the specified admount of seconds (default: see Hatetepe::Server::CONFIG_DEFAULTS)"
-    def start
-      require "hatetepe/server"
-      require "rack"
-
-      config          = config_for(options)
-      ENV["RACK_ENV"] = config[:env]
-
-      $stderr << "We're in #{config[:env]}\n"
-      $stderr << "Booting from #{config[:rackup]}\n"
-
-      EM.epoll
-      EM.synchrony do
-        $stderr << "Binding to #{config[:host]}:#{config[:port]}\n"
-
-        trap("INT") { EM.stop }
-        trap("TERM") { EM.stop }
-        Server.start(config)
-      end
-    end
-
-    private
-
-    def config_for(options)
-      rackup = File.expand_path(options[:rackup] || "config.ru")
-      {
-        env:     options[:env]  || ENV["RACK_ENV"] || "development",
-        host:    options[:bind] || "127.0.0.1",
-        port:    options[:port] || 3000,
-        timeout: options[:timeout],
-        app:     Rack::Builder.parse_file(rackup)[0],
-        rackup:  rackup
-      }
-    end
-  end
-end

data/lib/hatetepe/connection.rb

@@ -1,73 +0,0 @@
-module Hatetepe
-  module Connection
-    attr_accessor :processing_enabled
-    alias_method :processing_enabled?, :processing_enabled
-
-    def remote_address
-      sockaddr && sockaddr[1]
-    end
-    
-    def remote_port
-      sockaddr && sockaddr[0]
-    end
-    
-    def sockaddr
-      @sockaddr ||= Socket.unpack_sockaddr_in(get_peername) rescue nil
-    end
-
-    def connection_completed
-      @connected = true
-    end
-
-    def connected?
-      defined?(@connected) && @connected
-    end
-    
-    def closed?
-      !!defined?(@closed_by)
-    end
-    
-    def closed_by_remote?
-      @closed_by == :remote
-    end
-    
-    def closed_by_self?
-      @closed_by == :self
-    end
-
-    def closed_by_timeout?
-      connected? && @closed_by == :timeout
-    end
-
-    def closed_by_connect_timeout?
-      !connected? && @closed_by == :timeout
-    end
-    
-    def close_connection(after_writing = false)
-      @closed_by = :self unless closed?
-      super
-    end
-    
-    def unbind(reason)
-      unless closed?
-        @closed_by = if reason == Errno::ETIMEDOUT
-          :timeout
-        else
-          :remote
-        end
-      end
-    end
-
-    def comm_inactivity_timeout=(seconds)
-      unless defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
-        super
-      end
-    end
-
-    def pending_connect_timeout=(seconds)
-      unless defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
-        super
-      end
-    end
-  end
-end

data/lib/hatetepe/events.rb

@@ -1,35 +0,0 @@
-module Hatetepe
-  module Events
-    def self.included(klass)
-      klass.extend ClassMethods
-    end
-    
-    attr_reader :state
-    
-    def event(name, *args)
-      send(:"on_#{name}").each {|blk| blk.call *args }
-    end
-    
-    def event!(name, *args)
-      @state = name
-      event name, *args
-    end
-    
-    module ClassMethods
-      def event(name, *more_names)
-        define_method :"on_#{name}" do |&block|
-          ivar = :"@on_#{name}"
-          store = instance_variable_get(ivar)
-          store ||= instance_variable_set(ivar, [])
-          
-          return store unless block
-          store << block
-        end
-        
-        define_method(:"#{name}?") { state == name }
-        
-        more_names.each &method(:event)
-      end
-    end
-  end
-end

data/lib/hatetepe/message.rb

@@ -1,13 +0,0 @@
-require "hatetepe/body"
-
-module Hatetepe
-  class Message
-    attr_accessor :http_version, :headers, :body
-    attr_accessor :connection
-    
-    def initialize(headers = {}, body = nil, http_version = "1.1")
-      @headers, @http_version = headers, http_version
-      @body = body || Body.new
-    end
-  end
-end

data/lib/hatetepe/parser.rb

@@ -1,83 +0,0 @@
-require "http/parser"
-
-require "hatetepe/events"
-require "hatetepe/request"
-require "hatetepe/response"
-
-module Hatetepe
-  class ParserError < StandardError; end
-  
-  class Parser
-    include Events
-    
-    event :reset
-    event :request, :response
-    event :headers, :body
-    event :trailing_header, :trailing_headers_complete
-    event :complete
-    
-    attr_reader :message
-    
-    def initialize(&block)
-      initialize_parser
-      reset
-
-      if block
-        block.arity == 0 ? instance_eval(&block) : block.call(self)
-      end
-    end
-
-    def initialize_parser
-      @parser = HTTP::Parser.new.tap do |p|
-        p.on_headers_complete = proc do |headers|
-          headers_complete(p) if @headers_counter.even?
-          @headers_counter += 1
-          nil
-        end
-        
-        p.on_body             = method(:body)
-        p.on_message_complete = method(:complete)
-      end
-    end
-    
-    def reset
-      @parser.reset!
-      event! :reset
-      @message = nil
-      @headers_counter = 0
-    end
-    
-    def <<(data)
-      @parser << data
-    rescue HTTP::Parser::Error => e
-      raise Hatetepe::ParserError, e.message, e.backtrace
-    end
-
-    private
-
-    def headers_complete(parser)
-      args = [ parser.headers, Body.new, parser.http_version.join(".") ]
-      if parser.http_method
-        @message = Request.new(parser.http_method, parser.request_url, *args)
-        event! :request, @message
-      else
-        @message = Response.new(parser.status_code, *args)
-        event! :response, @message
-      end
-
-      event! :headers, message.headers
-      event! :body, message.body
-    end
-
-    def body(chunk)
-      message.body.write chunk unless message.body.closed_write?
-    end
-
-    def complete
-      message.body.rewind!
-      message.body.close_write unless message.body.closed_write?
-      event! :complete
-      @headers_counter += 1 if @headers_counter.odd?
-    end
-  end
-end

data/lib/hatetepe/server/pipeline.rb

@@ -1,20 +0,0 @@
-module Hatetepe::Server
-  class Pipeline
-    def initialize(app, connection)
-      @requests, @app = [], app
-    end
-
-    def call(request, &respond)
-      begin
-        previous  =  @requests.last
-        @requests << request
-        @app.call(request) do |response|
-          EM::Synchrony.sync(previous) if previous
-          respond.call(response)
-        end
-      ensure
-        @requests.delete(request)
-      end
-    end
-  end
-end

data/lib/hatetepe/server/rack_app.rb

@@ -1,39 +0,0 @@
-module Hatetepe::Server
-  class RackApp
-    def initialize(app, connection)
-      @app, @connection = app, connection
-    end
-
-    def call(request, &respond)
-      env = env_for(request)
-      env["async.callback"] = proc do |response|
-        async_callback(response, &respond)
-      end
-
-      response = [ -1 ]
-      catch :async do
-        response = @app.call(env)
-      end
-
-      async_callback(response, &respond)
-    end
-
-    def async_callback(response, &respond)
-      if response[0] >= 0
-        respond.call(Hatetepe::Response.new(*response))
-      end
-    end
-
-    def env_for(request)
-      request.to_h.merge({
-        "SERVER_NAME"       => @connection.config[:host],
-        "SERVER_PORT"       => @connection.config[:port].to_s,
-        "rack.errors"       => $stderr,
-        "rack.multithread"  => false,
-        "rack.multiprocess" => false,
-        "rack.run_once"     => false,
-        "rack.url_scheme"   => "http"
-      })
-    end
-  end
-end

data/lib/rack/handler/hatetepe.rb

@@ -1,33 +0,0 @@
-require "eventmachine"
-require "em-synchrony"
-require "hatetepe/server"
-require "rack"
-
-module Rack
-  module Handler
-    class Hatetepe
-      def self.run(app, options = {})
-        options = {
-          :host => options[:Host] || "0.0.0.0",
-          :port => options[:Port] || 8080,
-          :app => app
-        }
-        
-        Signal.trap("INT") { EM.stop }
-        Signal.trap("TERM") { EM.stop }
-        
-        EM.epoll
-        EM.synchrony { ::Hatetepe::Server.start options }
-      end
-
-      def self.valid_options
-        {
-          "Host=HOST" => "Hostname to listen on (default: 0.0.0.0 / all interfaces)",
-          "Port=PORT" => "Port to listen on (default: 8080)",
-        }
-      end
-    end
-    
-    register "hatetepe", Rack::Handler::Hatetepe
-  end
-end