hatetepe 0.0.4 → 0.2.0

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+rvm:
+  - 1.9.2
+  - 1.9.3

data/README.md

@@ -1,13 +1,29 @@
-Builds and parses HTTP messages
-===============================
+The HTTP toolkit
+================
 
-Hatetepe combines its own builder with http_parser.rb to make dealing with HTTP
-messages as comfortable as possible.
+Documentation is asking why you don't write it.
 
 TODO
 ----
 
+- Proxy
+- Code reloading
+- Client
+- Keep-alive
+- Preforking
+- Native file sending/receiving
+- MVM support via Thread Pool
+- Support for SPDY
+- Serving via filesystem or in-memory
+- Foreman support
+- Daemonizing and dropping privileges
+- Trailing headers
+- Propagating connection errors to the app
+
+Things to check out
+-------------------
+
 - Fix http_parser.rb's parsing of chunked bodies
 - Does http_parser.rb recognize trailing headers?
-- Support for pausing and resuming parsing/building
 - Encoding support (see https://github.com/tmm1/http_parser.rb/pull/1)
+- Are there any good C libs for building HTTP messages?

data/Rakefile

@@ -1,11 +1,4 @@
-require "bundler"
-Bundler.setup :default
+task :default => :spec
 
-task :default => :test
-
-require "rake/testtask"
-Rake::TestTask.new :test do |t|
-  t.test_files = FileList["test/*_test.rb"]
-end
-
-Bundler::GemHelper.install_tasks
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new :spec

data/bin/hatetepe

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require "hatetepe/cli"
+Hatetepe::CLI.start

data/hatetepe.gemspec

@@ -9,12 +9,19 @@ Gem::Specification.new do |s|
   s.authors     = ["Lars Gierth"]
   s.email       = ["lars.gierth@gmail.com"]
   s.homepage    = "https://github.com/lgierth/hatetepe"
-  s.summary     = %q{Builds and parses HTTP messages}
-  s.description = %q{Hatetepe combines its own builder with http_parser.rb to make dealing with HTTP messages as comfortable as possible.}
+  s.summary     = %q{The HTTP toolkit}
+  #s.description = %q{TODO: write description}
 
   s.add_dependency "http_parser.rb"
+  s.add_dependency "eventmachine"
+  s.add_dependency "em-synchrony"
+  s.add_dependency "rack"
+  s.add_dependency "async-rack"
+  s.add_dependency "thor"
   
-  s.add_development_dependency "test-unit"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "fakefs"
+  s.add_development_dependency "em-http-request"
 
   s.files         = `git ls-files`.split("\n") - [".gitignore"]
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/hatetepe.rb

@@ -1,3 +1,8 @@
 require "hatetepe/builder"
+require "hatetepe/client"
 require "hatetepe/parser"
+require "hatetepe/proxy"
+require "hatetepe/request"
+require "hatetepe/response"
+require "hatetepe/server"
 require "hatetepe/version"

data/lib/hatetepe/app.rb

@@ -0,0 +1,44 @@
+require "async-rack"
+require "rack"
+
+Rack::STREAMING = "Rack::STREAMING"
+
+module Hatetepe
+  ASYNC_RESPONSE = [-1, {}, []].freeze
+  
+  ERROR_RESPONSE = [500, {"Content-Type" => "text/html"},
+                    ["Internal Server Error"]].freeze
+  
+  class App
+    attr_reader :app
+    
+    def initialize(app)
+      @app = app
+    end
+    
+    def call(env)
+      env["async.callback"] = proc {|response|
+        postprocess env, response
+      }
+      
+      response = ASYNC_RESPONSE
+      catch(:async) {
+        response = app.call(env) rescue ERROR_RESPONSE
+      }
+      postprocess env, response
+    end
+    
+    def postprocess(env, response)
+      return if response[0] == ASYNC_RESPONSE[0]
+      
+      env["stream.start"].call response[0..1]
+      return if response[2] == Rack::STREAMING
+      
+      begin
+        response[2].each {|chunk| env["stream.send"].call chunk }
+      ensure
+        env["stream.close"].call
+      end
+    end
+  end
+end

data/lib/hatetepe/body.rb

@@ -0,0 +1,79 @@
+require "em-synchrony"
+require "eventmachine"
+require "stringio"
+
+module Hatetepe
+  class Body
+    include EM::Deferrable
+    
+    attr_reader :io
+    attr_accessor :source
+    
+    def initialize(string = "")
+      @receivers = []
+      @io = StringIO.new(string)
+    end
+    
+    def sync
+      source.resume if source && source.paused?
+      EM::Synchrony.sync self
+    end
+    
+    def length
+      # TODO maybe I want to #sync here
+      @io.length
+    end
+    
+    def empty?
+      length == 0
+    end
+    
+    def pos
+      @io.pos
+    end
+    
+    def rewind
+      @io.rewind
+    end
+    
+    def close_write
+      ret = @io.close_write
+      succeed
+      ret
+    end
+    
+    def closed_write?
+      @io.closed_write?
+    end
+    
+    def each(&block)
+      @receivers << block
+      block.call @io.string.dup unless @io.string.empty?
+      sync
+    end
+    
+    def read(*args)
+      sync
+      rewind
+      @io.read *args
+    end
+    
+    def gets
+      sync
+      rewind
+      @io.gets
+    end
+    
+    def write(chunk)
+      ret = @io.write chunk
+      @receivers.each {|r| r.call chunk }
+      ret
+    end
+    
+    def <<(chunk)
+      ret = @io << chunk
+      @receivers.each {|r| r.call chunk }
+      ret
+    end
+  end
+end

data/lib/hatetepe/builder.rb

@@ -29,7 +29,7 @@ module Hatetepe
     
     def reset
       @state = :ready
-      @chunked = true
+      @chunked = nil
     end
     
     [:write, :complete, :error].each do |hook|
@@ -90,6 +90,12 @@ module Hatetepe
       raw_header "#{name}: #{value}#{charset}"
     end
     
+    def headers(hash)
+      # wrong number of arguments (1 for 2)
+      #hash.each_pair &method(:header)
+      hash.each_pair {|name, value| header name, value }
+    end
+    
     def raw_header(header)
       if ready?
         error "A request or response line is required before writing headers"
@@ -101,24 +107,33 @@ module Hatetepe
       
       if header[0..13] == "Content-Length"
         @chunked = false
+      elsif header[0..16] == "Transfer-Encoding"
+        @chunked = true
       end
       
       write "#{header}\r\n"
     end
     
     def body(chunk)
+      if Body === chunk
+        chunk.each &method(:body)
+        return
+      end
+      
       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?
-        header "Transfer-Encoding", "chunked" if chunked?
+        if @chunked.nil?
+          header "Transfer-Encoding", "chunked"
+        end
         write "\r\n"
         @state = :writing_body
       end
       
       if chunked?
-        write "#{chunk.length.to_s(16)}\r\n#{chunk}\r\n"
+        write "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n"
       else
         write chunk
       end
@@ -129,6 +144,7 @@ module Hatetepe
       
       if writing_body? && chunked?
         write "0\r\n"
+        write "\r\n"
       elsif writing_headers? || writing_trailing_headers?
         write "\r\n"
       end

data/lib/hatetepe/cli.rb

@@ -0,0 +1,50 @@
+require "thor"
+
+require "hatetepe"
+
+module Hatetepe
+  class CLI < Thor
+    map "--version" => :version
+    map "-v" => :version
+    
+    default_task :start
+    
+    desc :version, "Print version information"
+    def version
+      say Rity::VERSION
+    end
+    
+    desc :start, "Start an instance of Rity"
+    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)"
+    def start
+      rackup = options[:rackup] || "config.ru"
+      $stderr << "Booting from #{File.expand_path rackup}\n"
+      $stderr.flush
+      app = Rack::Builder.parse_file(rackup)[0]
+
+      EM.synchrony do
+        trap("INT") { EM.stop }
+        trap("TERM") { EM.stop }
+        
+        EM.epoll
+        
+        host = options[:bind] || "127.0.0.1"
+        port = options[:port] || 3000
+        
+        $stderr << "Binding to #{host}:#{port}\n"
+        $stderr.flush
+        Server.start({
+          :app => app,
+          :errors => $stderr,
+          :host => host,
+          :port => port
+        })
+      end
+    end
+  end
+end

data/lib/hatetepe/client.rb

@@ -0,0 +1,95 @@
+require "em-synchrony"
+require "eventmachine"
+require "uri"
+
+require "hatetepe/body"
+require "hatetepe/builder"
+require "hatetepe/parser"
+require "hatetepe/request"
+require "hatetepe/response"
+
+module Hatetepe
+  class Client < EM::Connection
+    def self.start(config)
+      EM.connect config[:host], config[:port], self, config
+    end
+    
+    def self.request(verb, uri, headers = {}, body = nil)
+      uri = URI.parse(uri)
+      client = start(:host => uri.host, :port => uri.port)
+      
+      headers["User-Agent"] ||= "hatetepe/#{VERSION}"
+      
+      EM::Synchrony.sync Request.new(verb, uri.request_uri).tap {|req|
+        req.headers = headers
+        req.body = body || Body.new.tap {|b| b.close_write }
+        client << req
+      }
+    end
+    
+    class << self
+      [:get, :head].each {|verb|
+        define_method(verb) {|uri, headers = {}|
+          request verb.to_s.upcase, uri, headers
+        }
+      }
+      [:options, :post, :put, :delete, :trace, :connect].each {|verb|
+        define_method(verb) {|uri, headers = {}, body = nil|
+          request verb.to_s.upcase, uri, headers, body
+        }
+      }
+    end
+    
+    attr_reader :config
+    attr_reader :requests, :parser, :builder
+    
+    def initialize(config)
+      @config = config
+      @requests = []
+      @parser, @builder = Parser.new, Builder.new
+      super
+    end
+    
+    def post_init
+      parser.on_response {|response|
+        requests.find {|req| !req.response }.response = response
+      }
+      
+      parser.on_headers {
+        requests.reverse.find {|req| !!req.response }.tap {|req|
+          req.succeed req.response
+        }
+      }
+      
+      #builder.on_write {|chunk|
+      # ap "-> #{chunk}"
+      #}
+      builder.on_write << method(:send_data)
+    end
+    
+    def <<(request)
+      request.headers["Host"] = "#{config[:host]}:#{config[:port]}"
+
+      requests << request
+      Fiber.new {
+        builder.request request.verb, request.uri
+        builder.headers request.headers
+        builder.body request.body unless request.body.empty?
+        builder.complete
+      }.resume
+    end
+    
+    def receive_data(data)
+      #ap "<- #{data}"
+      parser << data
+    end
+    
+    def stop
+      close_connection_after_writing
+    end
+    
+    def responses
+      requests.map(&:response).compact
+    end
+  end
+end

data/lib/hatetepe/events.rb

@@ -0,0 +1,35 @@
+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}") {|&block|
+          ivar = :"@on_#{name}"
+          store = instance_variable_get(ivar)
+          store ||= instance_variable_set(ivar, [])
+          
+          return store unless block
+          store << block
+        }
+        
+        define_method(:"#{name}?") { state == name }
+        
+        more_names.each {|n| event n }
+      end
+    end
+  end
+end