rhebok 0.0.1

data/lib/rack/handler/rhebok.rb

@@ -0,0 +1,210 @@
+# -*- coding: utf-8 -*-
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'rubygems'
+require 'rack'
+require 'stringio'
+require 'tempfile'
+require 'socket'
+require 'rack/utils'
+require 'io/nonblock'
+require 'prefork_engine'
+require 'rhebok'
+
+module Rack
+  module Handler
+    class Rhebok
+      MAX_MEMORY_BUFFER_SIZE = 1024 * 1024
+      DEFAULT_OPTIONS = {
+        :Host => '0.0.0.0',
+        :Port => 9292,
+        :MaxWorkers => 10,
+        :Timeout => 300,
+        :MaxRequestPerChild => 1000,
+        :MinRequestPerChild => nil,
+        :SpawnInterval => nil,
+        :ErrRespawnInterval => nil
+      }
+      NULLIO  = StringIO.new("").set_encoding('BINARY')
+
+      def self.run(app, options={})
+        slf = new(options)
+        slf.setup_listener()
+        slf.run_worker(app)
+      end
+
+      def self.valid_options
+        {
+          "Host=HOST" => "Hostname to listen on (default: 0.0.0.0)",
+          "Port=PORT" => "Port to listen on (default: 9292)",
+        }
+      end
+
+      def initialize(options={})
+        @options = DEFAULT_OPTIONS.merge(options)
+        @server = nil
+        @_is_tcp = false
+        @_using_defer_accept = false
+      end
+
+      def setup_listener()
+        if ENV["SERVER_STARTER_PORT"] then
+          hostport, fd = ENV["SERVER_STARTER_PORT"].split("=",2)
+          if m = hostport.match(/(.*):(\d+)/) then
+            @options[:Host] = m[0]
+            @options[:Port] = m[1].to_i
+          else
+            @options[:Port] = hostport
+          end
+          @server = TCPServer.for_fd(fd.to_i)
+          @_is_tcp = true if !@server.local_address.unix?
+        end
+
+        if @server == nil
+          puts "Rhebok starts Listening on #{@options[:Host]}:#{@options[:Port]} Pid:#{$$}"
+          @server = TCPServer.new(@options[:Host], @options[:Port])
+          @server.setsockopt(:SOCKET, :REUSEADDR, 1)
+          @_is_tcp = true
+        end
+
+        if RUBY_PLATFORM.match(/linux/) && @_is_tcp == true then
+          begin
+            @server.setsockopt(Socket::IPPROTO_TCP, 9, 1)
+            @_using_defer_accept = true
+          end
+        end
+      end
+
+      def run_worker(app)
+        pm_args = {
+          "max_workers" => @options[:MaxWorkers].to_i,
+          "trap_signals" => {
+            "TERM" => 'TERM',
+            "HUP"  => 'TERM',
+          },
+        }
+        if @options[:SpawnInterval] then
+          pm_args["trap_signals"]["USR1"] = ["TERM", @options[:SpawnInterval].to_i]
+          pm_args["spawn_interval"] = @options[:SpawnInterval].to_i
+        end
+        if @options[:ErrRespawnInterval] then
+          pm_args["err_respawn_interval"] = @options[:ErrRespawnInterval].to_i
+        end
+        Signal.trap('INT','SYSTEM_DEFAULT') # XXX
+
+        pe = PreforkEngine.new(pm_args)
+        while !pe.signal_received.match(/^(TERM|USR1)$/)
+          pe.start {
+           srand
+            self.accept_loop(app)
+          }
+        end
+        pe.wait_all_children
+      end
+
+      def _calc_reqs_per_child
+        max = @options[:MaxRequestPerChild].to_i
+        if min = @options[:MinRequestPerChild] then
+          return (max - (max - min.to_i + 1) * rand).to_i
+        end
+        return max.to_i
+      end
+
+      def accept_loop(app)
+        @can_exit = true
+        @term_received = 0
+        proc_req_count = 0
+        Signal.trap(:TERM) do
+          @term_received += 1
+          if @can_exit then
+            exit!(true)
+          end
+          if @can_exit || @term_received > 1 then
+            exit!(true)
+          end
+        end
+        Signal.trap(:PIPE, "IGNORE")
+        max_reqs = self._calc_reqs_per_child()
+        fileno = @server.fileno
+
+        env_template = {
+          "SERVER_NAME"       => @options[:Host],
+          "SERVER_PORT"       => @options[:Port].to_s,
+          "rack.version"      => [1,1],
+          "rack.errors"       => STDERR,
+          "rack.multithread"  => false,
+          "rack.multiprocess" => true,
+          "rack.run_once"     => false,
+          "rack.url_scheme"   => "http",
+          "rack.input"        => NULLIO
+        }
+
+        while proc_req_count < max_reqs
+          @can_exit = true
+          env = env_template.clone
+          connection, buf = ::Rhebok.accept_rack(fileno, @options[:Timeout], @_is_tcp, env)
+          if connection then
+            # for tempfile
+            buffer = nil
+            begin
+              proc_req_count += 1
+              @can_exit = false
+              # handle request
+              if env.key?("CONTENT_LENGTH") && env["CONTENT_LENGTH"].to_i > 0 then
+                cl = env["CONTENT_LENGTH"].to_i;
+                if cl > MAX_MEMORY_BUFFER_SIZE
+                  buffer = Tempfile.open('r')
+                  buffer.binmode
+                  buffer.set_encoding('BINARY')
+                else
+                  buffer = StringIO.new("").set_encoding('BINARY')
+                end
+                while cl > 0
+                  chunk = ""
+                  if buf.bytesize > 0 then
+                    chunk = buf
+                    buf = ""
+                  else
+                    readed = ::Rhebok.read_timeout(connection, chunk, cl, 0, @options[:Timeout])
+                    if readed == nil then
+                      return
+                    end
+                  end
+                  buffer << chunk
+                  cl -= chunk.bytesize
+                end
+                buffer.rewind
+                env["rack.input"] = buffer
+              end
+
+              status_code, headers, body = app.call(env)
+              if body.instance_of?(Array) then
+                ::Rhebok.write_response(connection, @options[:Timeout], status_code, headers, body);
+              else
+                ::Rhebok.write_response(connection, @options[:Timeout], status_code, headers, []);
+                body.each do |part|
+                  ret = ::Rhebok.write_all(connection, part, 0, @options[:Timeout])
+                  if ret == nil then
+                    break
+                  end
+                end #body.each
+              end
+            ensure
+              if buffer.instance_of?(Tempfile)
+                buffer.close!
+              end
+              ::Rhebok.close_rack(connection)
+            end #begin
+          end # accept
+          if @term_received > 0 then
+            exit!(true)
+          end
+        end #while max_reqs
+      end #def
+
+    end
+  end
+end
+
+
+

data/lib/rhebok.rb

@@ -0,0 +1,7 @@
+require "rhebok/version"
+require "rhebok/rhebok"
+
+class Rhebok
+  # see Rack::Handler::Rhebok
+end
+

data/lib/rhebok/version.rb

@@ -0,0 +1,3 @@
+class Rhebok
+  VERSION = "0.0.1"
+end

data/rhebok.gemspec

@@ -0,0 +1,51 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rhebok/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rhebok"
+  spec.version       = Rhebok::VERSION
+  spec.authors       = ["Masahiro Nagano"]
+  spec.email         = ["kazeburo@gmail.com"]
+  spec.summary       = %q{High Perfomance Perforked Rack Handler}
+  spec.description   = %q{High Perfomance and Optimized Perforked Rack Handler}
+  spec.homepage      = "https://github.com/kazeburo/rhebok"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "bacon"
+  spec.add_dependency "rack", "~> 1.5.2"
+  spec.add_dependency "prefork_engine", "~> 0.0.4"
+
+  # get an array of submodule dirs by executing 'pwd' inside each submodule
+  `git submodule --quiet foreach pwd`.split($\).each do |submodule_path|
+    # for each submodule, change working directory to that submodule
+    Dir.chdir(submodule_path) do
+ 
+      # issue git ls-files in submodule's directory
+      submodule_files = `git ls-files`.split($\)
+ 
+      # prepend the submodule path to create absolute file paths
+      submodule_files_fullpaths = submodule_files.map do |filename|
+        "#{submodule_path}/#{filename}"
+      end
+ 
+      # remove leading path parts to get paths relative to the gem's root dir
+      # (this assumes, that the gemspec resides in the gem's root dir)
+      submodule_files_paths = submodule_files_fullpaths.map do |filename|
+        filename.gsub "#{File.dirname(__FILE__)}/", ""
+      end
+ 
+      # add relative paths to gem.files
+      spec.files += submodule_files_paths
+    end
+  end
+
+end

data/test/spec_02_basic.rb

@@ -0,0 +1,7 @@
+require 'rack/handler/rhebok'
+
+describe Rhebok do
+  should 'has a version number' do
+    Rhebok::VERSION.should.not.equal nil
+  end
+end

data/test/spec_02_server.rb

@@ -0,0 +1,87 @@
+require 'rack'
+require File.expand_path('../testrequest', __FILE__)
+require 'timeout'
+require 'rack/handler/rhebok'
+
+describe Rhebok do
+  extend TestRequest::Helpers
+  begin
+
+    @host = '127.0.0.1'
+    @port = 9202
+    @app = Rack::Lint.new(TestRequest.new)
+    @pid = fork
+    if @pid == nil
+      #child
+      Rack::Handler::Rhebok.run(@app, :Host=>'127.0.0.1', :Port=>9202, :MaxWorkers=>1)
+      exit!(true)
+    end
+    sleep 1
+
+  # test
+  should "respond" do
+    GET("/")
+    response.should.not.be.nil
+  end
+
+  should "be a Rhebok" do
+    GET("/")
+    status.should.equal 200
+    response["SERVER_PROTOCOL"].should.equal "HTTP/1.1"
+    response["SERVER_PORT"].should.equal "9202"
+    response["SERVER_NAME"].should.equal "127.0.0.1"
+  end
+
+  should "have rack headers" do
+    GET("/")
+    response["rack.version"].should.equal [1,1]
+    response["rack.multithread"].should.equal false
+    response["rack.multiprocess"].should.equal true
+    response["rack.run_once"].should.equal false
+  end
+
+  should "have CGI headers on GET" do
+    GET("/")
+    response["REQUEST_METHOD"].should.equal "GET"
+    response["PATH_INFO"].should.be.equal "/"
+    response["QUERY_STRING"].should.equal ""
+    response["test.postdata"].should.equal ""
+
+    GET("/test/foo?quux=1")
+    response["REQUEST_METHOD"].should.equal "GET"
+    response["PATH_INFO"].should.equal "/test/foo"
+    response["QUERY_STRING"].should.equal "quux=1"
+  end
+
+  should "have CGI headers on POST" do
+    POST("/", {"rack-form-data" => "23"}, {'X-test-header' => '42'})
+    status.should.equal 200
+    response["REQUEST_METHOD"].should.equal "POST"
+    response["QUERY_STRING"].should.equal ""
+    response["HTTP_X_TEST_HEADER"].should.equal "42"
+    response["test.postdata"].should.equal "rack-form-data=23"
+  end
+
+  should "support HTTP auth" do
+    GET("/test", {:user => "ruth", :passwd => "secret"})
+    response["HTTP_AUTHORIZATION"].should.equal "Basic cnV0aDpzZWNyZXQ="
+  end
+
+  should "set status" do
+    GET("/test?secret")
+    status.should.equal 403
+    response["rack.url_scheme"].should.equal "http"
+  end
+
+
+  ensure
+   sleep 1
+   if @pid != nil
+     Process.kill(:TERM, @pid)
+     Process.wait()
+   end
+  end
+
+end
+
+

data/test/testrequest.rb

@@ -0,0 +1,79 @@
+require 'yaml'
+require 'net/http'
+require 'rack/lint'
+
+class TestRequest
+  NOSERIALIZE = [Method, Proc, Rack::Lint::InputWrapper]
+
+  def call(env)
+    status = env["QUERY_STRING"] =~ /secret/ ? 403 : 200
+    env["test.postdata"] = env["rack.input"].read
+    minienv = env.dup
+    # This may in the future want to replace with a dummy value instead.
+    minienv.delete_if { |k,v| NOSERIALIZE.any? { |c| v.kind_of?(c) } }
+    body = minienv.to_yaml
+    size = body.respond_to?(:bytesize) ? body.bytesize : body.size
+    [status, {"Content-Type" => "text/yaml", "Content-Length" => size.to_s}, [body]]
+  end
+
+  module Helpers
+    attr_reader :status, :response
+
+    ROOT = File.expand_path(File.dirname(__FILE__) + "/..")
+    ENV["RUBYOPT"] = "-I#{ROOT}/lib -rubygems"
+
+    def root
+      ROOT
+    end
+
+    def rackup
+      "#{ROOT}/bin/rackup"
+    end
+
+    def GET(path, header={})
+      Net::HTTP.start(@host, @port) { |http|
+        user = header.delete(:user)
+        passwd = header.delete(:passwd)
+
+        get = Net::HTTP::Get.new(path, header)
+        get.basic_auth user, passwd  if user && passwd
+        http.request(get) { |response|
+          @status = response.code.to_i
+          begin
+            @response = YAML.load(response.body)
+          rescue TypeError, ArgumentError
+            @response = nil
+          end
+        }
+      }
+    end
+
+    def POST(path, formdata={}, header={})
+      Net::HTTP.start(@host, @port) { |http|
+        user = header.delete(:user)
+        passwd = header.delete(:passwd)
+
+        post = Net::HTTP::Post.new(path, header)
+        post.form_data = formdata
+        post.basic_auth user, passwd  if user && passwd
+        http.request(post) { |response|
+          @status = response.code.to_i
+          @response = YAML.load(response.body)
+        }
+      }
+    end
+  end
+end
+
+class StreamingRequest
+  def self.call(env)
+    [200, {"Content-Type" => "text/plain"}, new]
+  end
+
+  def each
+    yield "hello there!\n"
+    sleep 5
+    yield "that is all.\n"
+  end
+end
+