hatetepe 0.0.4 → 0.2.0

data/lib/hatetepe/message.rb

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

data/lib/hatetepe/parser.rb

@@ -1,68 +1,51 @@
 require "http/parser"
 
+require "hatetepe/events"
+require "hatetepe/request"
+require "hatetepe/response"
+
 module Hatetepe
   class ParserError < StandardError; end
   
   class Parser
-    def self.parse(data = [], &block)
-      message = {}
-      parser = new do |p|
-        p.on_request do |*args|
-          message[:http_method] = args[0]
-          message[:request_url] = args[1]
-          message[:http_version] = args[2]
-        end
-        p.on_response do |*args|
-          message[:status] = args[0]
-          message[:http_version] = args[1]
-        end
-        p.on_header do |name, value|
-          (message[:headers] ||= {})[name] = value
-        end
-        p.on_body_chunk do |chunk|
-          (message[:body] ||= "") << chunk
-        end
-      end
-      
-      if block
-        block.arity == 0 ? parser.instance_eval(&block) : block.call(parser)
-      end
-      
-      Array(data).each {|chunk| parser << chunk }
-      message
-    end
+    include Events
+    
+    event :reset
+    event :request, :response
+    event :headers, :body
+    event :trailing_header, :trailing_headers_complete
+    event :complete
+    
+    attr_reader :message
     
     def initialize(&block)
-      @on_request, @on_response = [], []
-      @on_header, @on_headers_complete = [], []
-      @on_body_chunk, @on_complete, @on_error = [], [], []
-      @parser = HTTP::Parser.new
-      
-      @parser.on_headers_complete = proc do
-        if @parser.http_method
-          on_request.each do |r|
-            r.call(@parser.http_method, @parser.request_url, @parser.http_version.join("."))
+      @parser = HTTP::Parser.new.tap {|p|
+        p.on_headers_complete = proc {
+          version = p.http_version.join(".")
+          if p.http_method
+            @message = Request.new(p.http_method, p.request_url, version)
+            event! :request, message
+          else
+            @message = Response.new(p.status_code, version)
+            event! :response, message
           end
-        else
-          on_response.each do |r|
-            r.call(@parser.status_code, @parser.http_version.join("."))
-          end
-        end
+          
+          message.headers = p.headers
+          event! :headers, message.headers
+          
+          event! :body, message.body
+          nil
+        }
         
-        @parser.headers.each do |header|
-          on_header.each {|h| h.call(*header) }
-        end
+        p.on_body = proc {|chunk|
+          message.body << chunk unless message.body.closed_write?
+        }
         
-        on_headers_complete.each {|hc| hc.call }
-      end
-      
-      @parser.on_body = proc do |chunk|
-        on_body_chunk.each {|b| b.call(chunk) }
-      end
-      
-      @parser.on_message_complete = proc do
-        on_complete.each {|f| f.call }
-      end
+        p.on_message_complete = proc {
+          message.body.close_write unless message.body.closed_write?
+          event! :complete
+        }
+      }
       
       reset
       
@@ -73,27 +56,14 @@ module Hatetepe
     
     def reset
       @parser.reset!
-    end
-    
-    [:request, :response, :header, :headers_complete,
-     :body_chunk, :complete, :error].each do |hook|
-      define_method :"on_#{hook}" do |&block|
-        store = instance_variable_get(:"@on_#{hook}")
-        return store unless block
-        store << block
-      end
+      event! :reset
+      @message = nil
     end
     
     def <<(data)
       @parser << data
-    rescue HTTP::Parser::Error => original_error
-      error = ParserError.new(original_error.message)
-      error.set_backtrace(original_error.backtrace)
-      unless on_error.empty?
-        on_error.each {|e| e.call(error) }
-      else
-        raise(error)
-      end
+    rescue HTTP::Parser::Error => e
+      raise Hatetepe::ParserError, e.message, e.backtrace
     end
   end
 end

data/lib/hatetepe/prefork.rb

@@ -0,0 +1,11 @@
+module Hatetepe
+  class Prefork
+    def self.run(server)
+      prefork = new(server)
+      fork {
+        prefork.serve
+      }
+      prefork.manage
+    end
+  end
+end

data/lib/hatetepe/proxy.rb

@@ -0,0 +1,58 @@
+require "eventmachine"
+require "uri"
+
+require "hatetepe/client"
+
+module Hatetepe
+  class Proxy
+    attr_reader :app, :env
+    
+    def initialize(app)
+      @app = app
+    end
+    
+    def call(env)
+      @env = env
+      env["proxy.start"] = method(:start)
+      
+      app.call env
+    end
+    
+    def start(target)
+      uri = build_uri(target)
+      
+      env.delete "proxy.start"
+      env["proxy.callback"] ||= method(:callback)
+      
+      response = Client.request(verb, uri, headers)
+      env["proxy.callback"].call @response, env
+    end
+    
+    def callback(response, env)
+      response
+    end
+  end
+end
+
+module Hatetepe
+  class OldProxy
+    attr_reader :env, :target
+    
+    def initialize(env, target)
+      client = EM.connect target.host, target.port, Client
+      client.request env["rity.request"].verb, env["rity.request"].uri
+      
+      env["proxy.callback"] ||= proc {|response|
+        env["proxy.start_reverse"].call response
+      }
+      env["proxy.start_reverse"] = proc {|response|
+        env["stream.start"].call *response[0..1]
+        env["stream.send_raw"].call client.requests
+      }
+    end
+    
+    def initialize(env, target)
+      response = Client.request(env["rity.request"])
+    end
+  end
+end

data/lib/hatetepe/request.rb

@@ -0,0 +1,31 @@
+require "hatetepe/message"
+
+module Hatetepe
+  class Request < Message
+    include EM::Deferrable
+    
+    attr_accessor :verb, :uri, :response
+    
+    def initialize(verb, uri, http_version = "1.1")
+      @verb, @uri = verb, uri
+      super http_version
+    end
+    
+    def to_hash
+      {
+        "rack.version" => [1, 0],
+        "hatetepe.request" => self,
+        "rack.input" => body,
+        "REQUEST_METHOD" => verb.dup,
+        "REQUEST_URI" => uri.dup
+      }.tap {|h|
+        headers.each {|key, value|
+          h["HTTP_#{key.upcase.gsub(/[^A-Z_]/, "_")}"] = value
+        }
+        
+        h["REQUEST_PATH"], qm, h["QUERY_STRING"] = uri.partition("?")
+        h["PATH_INFO"], h["SCRIPT_NAME"] = h["REQUEST_PATH"].dup, ""
+      }
+    end
+  end
+end

data/lib/hatetepe/response.rb

@@ -0,0 +1,20 @@
+require "hatetepe/message"
+
+module Hatetepe
+  class Response < Message
+    attr_accessor :status
+    
+    def initialize(status, http_version = "1.1")
+      @status = status
+      super http_version
+    end
+    
+    def to_a
+      [status, headers, body]
+    end
+    
+    def [](i)
+      to_a[i]
+    end
+  end
+end

data/lib/hatetepe/server.rb

@@ -0,0 +1,98 @@
+require "eventmachine"
+require "em-synchrony"
+require "rack"
+
+require "hatetepe/app"
+require "hatetepe/builder"
+require "hatetepe/parser"
+require "hatetepe/request"
+
+module Hatetepe
+  class Server < EM::Connection
+    def self.start(config)
+      server = EM.start_server(config[:host], config[:port], self, config)
+      #Prefork.run server if config[:prefork]
+    end
+    
+    attr_reader :app, :config, :errors
+    attr_reader :requests, :parser, :builder
+    
+    def initialize(config)
+      @config = config
+      @errors = config[:errors] || $stderr
+      
+      @app = Rack::Builder.new.tap {|b|
+        b.use Hatetepe::App
+        #b.use Hatetepe::Proxy
+        b.run config[:app]
+      }
+
+      super
+    end
+    
+    def post_init
+      @requests = []
+      @parser, @builder = Parser.new, Builder.new
+      
+      parser.on_request << requests.method(:<<)
+      parser.on_headers << method(:process)
+
+      builder.on_write << method(:send_data)
+    end
+    
+    def receive_data(data)
+      parser << data
+    rescue ParserError
+      close_connection
+    rescue Exception => ex
+      close_connection_after_writing
+      backtrace = ex.backtrace.map {|line| "\t#{line}" }.join("\n")
+      errors << "#{ex.class}: #{ex.message}\n#{backtrace}\n"
+      errors.flush
+    end
+    
+    def process(*)
+      previous, request = requests.values_at(-2, -1)
+      
+      env = request.to_hash.tap {|e|
+        e["hatetepe.connection"] = self
+        e["rack.url_scheme"] = "http"
+        e["rack.input"].source = self
+        e["rack.errors"] = errors
+        
+        e["rack.multithread"] = false
+        e["rack.multiprocess"] = false
+        e["rack.run_once"] = false
+        
+        e["SERVER_NAME"] = config[:host].dup
+        e["SERVER_PORT"] = String(config[:port])
+        
+        host = e["HTTP_HOST"] || config[:host].dup
+        host += ":#{config[:port]}" unless host.include? ":"
+        e["HTTP_HOST"] = host
+        
+        e["stream.start"] = proc {|response|
+          e.delete "stream.start"
+          EM::Synchrony.sync previous if previous
+          response[1]["Server"] = "hatetepe/#{VERSION}"
+          builder.response response[0..1]
+        }
+        
+        e["stream.send"] = builder.method(:body)
+        
+        e["stream.close"] = proc {
+          e.delete "stream.send"
+          e.delete "stream.close"
+          
+          builder.complete
+          requests.delete request
+          request.succeed
+          
+          close_connection_after_writing if requests.empty?
+        }
+      }
+      
+      Fiber.new { app.call env }.resume
+    end
+  end
+end

data/lib/hatetepe/thread_pool.rb

@@ -0,0 +1,4 @@
+module Hatetepe
+  class ThreadPool
+  end
+end

data/lib/hatetepe/version.rb

@@ -1,3 +1,3 @@
 module Hatetepe
-  VERSION = "0.0.4"
+  VERSION = "0.2.0"
 end

data/lib/rack/handler/hatetepe.rb

@@ -0,0 +1,33 @@
+require "eventmachine"
+require "hatetepe/server"
+
+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.run {
+          EM.epoll
+          
+          server = ::Hatetepe::Server.start options
+          yield server if block_given?
+        }
+      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
+  end
+end

data/spec/integration/cli/start_spec.rb

@@ -0,0 +1,169 @@
+require "spec_helper"
+require "hatetepe/cli"
+require "socket"
+
+describe "start command" do
+  def hook_event_loop(&block)
+    EM.spec_hooks << block
+  end
+  
+  def add_stop_timer(timeout)
+    hook_event_loop do
+      EM.add_timer(timeout) { EM.stop }
+    end
+  end
+  
+  before do
+    $stderr = StringIO.new ""
+    
+    FakeFS.activate!
+    File.open("config.ru", "w") do |f|
+      f.write %q{run proc {|e| [200, {"Content-Type" => "text/plain"}, [e["REQUEST_URI"]]] }}
+    end
+    File.open("config2.ru", "w") do |f|
+      f.write %q{run proc {|e| [200, {"Content-Type" => "text/plain"}, ["config2.ru loaded"]] }}
+    end
+  end
+  
+  after do
+    $stderr = STDERR
+    
+    FakeFS.deactivate!
+    FakeFS::FileSystem.clear
+  end
+  
+  it "starts an instance of Rity" do
+    add_stop_timer 0.05
+    hook_event_loop do
+      Socket.tcp("127.0.0.1", 3000) {|*| }
+    end
+    Hatetepe::CLI.start %w{}
+
+    $stderr.string.should include("127.0.0.1:3000")
+  end
+  
+  it "answers HTTP requests" do
+    add_stop_timer 0.02
+    hook_event_loop do
+      request = EM::HttpRequest.new("http://127.0.0.1:3000").aget
+      response = EM::Synchrony.sync(request)
+      
+      response.response_header.status.should == 200
+      response.response_header["CONTENT_TYPE"].should == "text/plain"
+      response.response.should == "/"
+    end
+    Hatetepe::CLI.start %w{}
+  end
+  
+  describe "--port option" do
+    it "changes the listen port" do
+      add_stop_timer 0.05
+      hook_event_loop do
+        Socket.tcp("127.0.0.1", 3001) {|*| }
+      end
+      Hatetepe::CLI.start %w{--port=3001}
+      
+      $stderr.string.should include(":3001")
+    end
+    
+    it "has an alias: -p" do
+      add_stop_timer 0.05
+      hook_event_loop do
+        Socket.tcp("127.0.0.1", 3002) {|*| }
+      end
+      Hatetepe::CLI.start %w{-p 3002}
+      
+      $stderr.string.should include(":3002")
+    end
+  end
+  
+  describe "--bind option" do
+    it "changes the listen interface" do
+      add_stop_timer 0.05
+      hook_event_loop do
+        Socket.tcp("127.0.0.2", 3000) {|*| }
+      end
+      Hatetepe::CLI.start %w{--bind=127.0.0.2}
+      
+      $stderr.string.should include("127.0.0.2:")
+    end
+    
+    it "has an alias: -b" do
+      add_stop_timer 0.05
+      hook_event_loop do
+        Socket.tcp("127.0.0.3", 3000) {|*| }
+      end
+      Hatetepe::CLI.start %w{-b 127.0.0.3}
+      
+      $stderr.string.should include("127.0.0.3:")
+    end
+  end
+  
+  describe "--rackup option" do
+    it "changes the rackup file that'll be loaded" do
+      add_stop_timer 0.05
+      hook_event_loop do
+        request = EM::HttpRequest.new("http://127.0.0.1:3000").aget
+        response = EM::Synchrony.sync(request)
+        response.response.should include("config2.ru")
+      end
+      Hatetepe::CLI.start %w{--rackup=config2.ru}
+    end
+    
+    it "has an alias: -r" do
+      add_stop_timer 0.05
+      hook_event_loop do
+        request = EM::HttpRequest.new("http://127.0.0.1:3000").aget
+        response = EM::Synchrony.sync(request)
+        response.response.should include("config2.ru")
+      end
+      Hatetepe::CLI.start %w{-r config2.ru}
+    end
+  end
+  
+  describe "--quiet option" do
+    it "discards all output" do
+      pending
+      
+      add_stop_timer 0.05
+      Hatetepe::CLI.start %w{--quiet}
+      
+      $stderr.string.should be_empty
+    end
+    
+    it "has an alias: -q" do
+      pending
+      
+      add_stop_timer 0.05
+      Hatetepe::CLI.start %w{-q}
+      
+      $stderr.string.should be_empty
+    end
+  end
+  
+  describe "--verbose option" do
+    it "prints debugging data" do
+      pending
+      
+      add_stop_timer 0.05
+      hook_event_loop do
+        request = EM::HttpRequest.new("http://127.0.0.1:3000").aget
+      end
+      Hatetepe::CLI.start %w{--verbose}
+      
+      $stderr.string.split("\n").size.should > 10
+    end
+
+    it "has an alias: -V" do
+      pending
+      
+      add_stop_timer 0.05
+      hook_event_loop do
+        request = EM::HttpRequest.new("http://127.0.0.1:3000").aget
+      end
+      Hatetepe::CLI.start %w{-V}
+      
+      $stderr.string.split("\n").size.should > 10
+    end
+  end
+end