puma 0.8.0

data/test/test_rack_handler.rb

@@ -0,0 +1,10 @@
+require 'test/unit'
+
+class TestPumaUnixSocket < Test::Unit::TestCase
+  def test_handler
+    handler = Rack::Handler.get(:puma)
+    assert_equal Rack::Handler::Puma, handler
+    handler = Rack::Handler.get('Puma')
+    assert_equal Rack::Handler::Puma, handler
+  end
+end

data/test/test_rack_server.rb

@@ -0,0 +1,107 @@
+require 'test/unit'
+require 'puma'
+require 'rack/lint'
+require 'test/testhelp'
+require 'rack/commonlogger'
+require 'puma/rack_patch'
+
+class TestRackServer < Test::Unit::TestCase
+
+  class ErrorChecker
+    def initialize(app)
+      @app = app
+      @exception = nil
+      @env = nil
+    end
+
+    attr_reader :exception, :env
+
+    def call(env)
+      begin
+        @env = env
+        return @app.call(env)
+      rescue Exception => e
+        @exception = e
+
+        [
+          500,
+          { "X-Exception" => e.message, "X-Exception-Class" => e.class.to_s },
+          ["Error detected"]
+        ]
+      end
+    end
+  end
+
+  class ServerLint < Rack::Lint
+    def call(env)
+      assert("No env given") { env }
+      check_env env
+
+      @app.call(env)
+    end
+  end
+
+  def setup
+    @valid_request = "GET / HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\n\r\n"
+    
+    @simple = lambda { |env| [200, { "X-Header" => "Works" }, ["Hello"]] }
+    @server = Puma::Server.new @simple
+    @server.add_tcp_listener "127.0.0.1", 9998
+  end
+
+  def teardown
+    @server.stop(true)
+  end
+
+  def test_lint
+    @checker = ErrorChecker.new ServerLint.new(@simple)
+    @server.app = @checker
+
+    @server.run
+
+    hit(['http://localhost:9998/test'])
+
+    if exc = @checker.exception
+      raise exc
+    end
+  end
+
+  def test_path_info
+    input = nil
+    @server.app = lambda { |env| input = env; @simple.call(env) }
+    @server.run
+
+    hit(['http://localhost:9998/test/a/b/c'])
+
+    assert_equal "/test/a/b/c", input['PATH_INFO']
+  end
+
+  def test_after_reply
+    closed = false
+
+    @server.app = lambda do |env|
+      env['rack.after_reply'] << lambda { closed = true }
+      @simple.call(env)
+    end
+
+    @server.run
+
+    hit(['http://localhost:9998/test'])
+
+    assert_equal true, closed
+  end
+
+  def test_common_logger
+    log = StringIO.new
+
+    logger = Rack::CommonLogger.new(@simple, log)
+
+    @server.app = logger
+
+    @server.run
+
+    hit(['http://localhost:9998/test'])
+
+    assert_match %r!GET /test HTTP/1\.1!, log.string
+  end
+end

data/test/test_thread_pool.rb

@@ -0,0 +1,102 @@
+require 'test/unit'
+
+require 'puma/thread_pool'
+
+class TestThreadPool < Test::Unit::TestCase
+
+  def teardown
+    @pool.shutdown if @pool
+  end
+
+  def new_pool(min, max, &blk)
+    blk = proc { } unless blk
+    @pool = Puma::ThreadPool.new(min, max, &blk)
+  end
+
+  def pause
+    sleep 0.2
+  end
+
+  def test_append_spawns
+    saw = []
+
+    pool = new_pool(0, 1) do |work|
+      saw << work
+    end
+
+    pool << 1
+
+    pause
+
+    assert_equal [1], saw
+    assert_equal 1, pool.spawned
+  end
+
+  def test_append_queues_on_max
+    finish = false
+    pool = new_pool(0, 1) { Thread.pass until finish }
+
+    pool << 1
+    pool << 2
+    pool << 3
+
+    pause
+
+    assert_equal 2, pool.backlog
+
+    finish = true
+  end
+
+  def test_trim
+    pool = new_pool(0, 1)
+
+    pool << 1
+
+    pause
+
+    assert_equal 1, pool.spawned
+    pool.trim
+
+    pause
+    assert_equal 0, pool.spawned
+  end
+
+  def test_trim_leaves_min
+    finish = false
+    pool = new_pool(1, 2) { Thread.pass until finish }
+
+    pool << 1
+    pool << 2
+
+    finish = true
+
+    assert_equal 2, pool.spawned
+    pool.trim
+    pause
+
+    assert_equal 1, pool.spawned
+    pool.trim
+    pause
+
+    assert_equal 1, pool.spawned
+
+  end
+
+  def test_trim_doesnt_overtrim
+    finish = false
+    pool = new_pool(1, 2) { Thread.pass until finish }
+
+    pool << 1
+    pool << 2
+
+    assert_equal 2, pool.spawned
+    pool.trim
+    pool.trim
+
+    finish = true
+
+    pause
+
+    assert_equal 1, pool.spawned
+  end
+end

data/test/test_unix_socket.rb

@@ -0,0 +1,34 @@
+require 'test/unit'
+require 'puma/server'
+
+require 'socket'
+
+class TestPumaUnixSocket < Test::Unit::TestCase
+
+  App = lambda { |env| [200, {}, ["Works"]] }
+
+  Path = "test/puma.sock"
+
+  def setup
+    @server = Puma::Server.new App
+    @server.add_unix_listener Path
+    @server.run
+  end
+
+  def teardown
+    @server.stop(true)
+    File.unlink Path if File.exists? Path
+  end
+
+  def test_server
+    sock = UNIXSocket.new Path
+
+    sock << "GET / HTTP/1.0\r\nHost: blah.com\r\n\r\n"
+
+    expected = "HTTP/1.0 200 OK\r\nConnection: close\r\nContent-Length: 5\r\n\r\nWorks"
+
+    assert_equal expected, sock.read(expected.size)
+
+    sock.close
+  end
+end

data/test/test_ws.rb

@@ -0,0 +1,97 @@
+# Copyright (c) 2011 Evan Phoenix
+# Copyright (c) 2005 Zed A. Shaw 
+
+require 'test/testhelp'
+
+include Puma
+
+class TestHandler
+  attr_reader :ran_test
+
+  def call(env)
+    @ran_test = true
+
+    [200, {"Content-Type" => "text/plain"}, ["hello!"]]
+  end
+end
+
+class WebServerTest < Test::Unit::TestCase
+
+  def setup
+    @valid_request = "GET / HTTP/1.1\r\nHost: www.zedshaw.com\r\nContent-Type: text/plain\r\n\r\n"
+    
+    @tester = TestHandler.new
+
+    @server = Server.new @tester, Events.strings
+    @server.add_tcp_listener "127.0.0.1", 9998
+
+    redirect_test_io do
+      @server.run 
+    end
+  end
+
+  def teardown
+    redirect_test_io do
+      @server.stop(true)
+    end
+  end
+
+  def test_simple_server
+    hit(['http://localhost:9998/test'])
+    assert @tester.ran_test, "Handler didn't really run"
+  end
+
+
+  def do_test(string, chunk, close_after=nil, shutdown_delay=0)
+    # Do not use instance variables here, because it needs to be thread safe
+    socket = TCPSocket.new("127.0.0.1", 9998);
+    request = StringIO.new(string)
+    chunks_out = 0
+
+    while data = request.read(chunk)
+      chunks_out += socket.write(data)
+      socket.flush
+      sleep 0.2
+      if close_after and chunks_out > close_after
+        socket.close
+        sleep 1
+      end
+    end
+    sleep(shutdown_delay)
+    socket.write(" ") # Some platforms only raise the exception on attempted write
+    socket.flush
+  end
+
+  def test_trickle_attack
+    do_test(@valid_request, 3)
+  end
+
+  def test_close_client
+    assert_raises IOError do
+      do_test(@valid_request, 10, 20)
+    end
+  end
+
+  def test_bad_client
+    redirect_test_io do
+      do_test("GET /test HTTP/BAD", 3)
+    end
+  end
+
+  def test_header_is_too_long
+    redirect_test_io do
+      long = "GET /test HTTP/1.1\r\n" + ("X-Big: stuff\r\n" * 15000) + "\r\n"
+      assert_raises Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, Errno::EINVAL, IOError do
+        do_test(long, long.length/2, 10)
+      end
+    end
+  end
+
+  def test_file_streamed_request
+    body = "a" * (Puma::Const::MAX_BODY * 2)
+    long = "GET /test HTTP/1.1\r\nContent-length: #{body.length}\r\n\r\n" + body
+    do_test(long, Puma::Const::CHUNK_SIZE * 2 -400)
+  end
+
+end
+

data/test/testhelp.rb

@@ -0,0 +1,41 @@
+# Copyright (c) 2011 Evan Phoenix
+# Copyright (c) 2005 Zed A. Shaw 
+
+
+%w(lib ext bin test).each do |dir| 
+  $LOAD_PATH.unshift File.expand_path("../../#{dir}", __FILE__)
+end
+
+require 'rubygems'
+require 'test/unit'
+require 'net/http'
+require 'digest/sha1'
+require 'uri'
+require 'stringio'
+
+require 'puma'
+
+def redirect_test_io
+  yield
+end
+    
+# Either takes a string to do a get request against, or a tuple of [URI, HTTP] where
+# HTTP is some kind of Net::HTTP request object (POST, HEAD, etc.)
+def hit(uris)
+  results = []
+  uris.each do |u|
+    res = nil
+
+    if u.kind_of? String
+      res = Net::HTTP.get(URI.parse(u))
+    else
+      url = URI.parse(u[0])
+      res = Net::HTTP.new(url.host, url.port).start {|h| h.request(u[1]) }
+    end
+
+    assert res != nil, "Didn't get a response: #{u}"
+    results << res
+  end
+
+  return results
+end

data/tools/trickletest.rb

@@ -0,0 +1,45 @@
+require 'socket'
+require 'stringio'
+
+def do_test(st, chunk)
+  s = TCPSocket.new('127.0.0.1',ARGV[0].to_i);
+  req = StringIO.new(st)
+  nout = 0
+  randstop = rand(st.length / 10)
+  STDERR.puts "stopping after: #{randstop}"
+
+  begin
+    while data = req.read(chunk)
+      nout += s.write(data)
+      s.flush
+      sleep 0.1
+      if nout > randstop
+        STDERR.puts "BANG! after #{nout} bytes."
+        break
+      end
+    end
+  rescue Object => e
+    STDERR.puts "ERROR: #{e}"
+  ensure
+    s.close
+  end
+end
+
+content = "-" * (1024 * 240)
+st = "GET / HTTP/1.1\r\nHost: www.zedshaw.com\r\nContent-Type: text/plain\r\nContent-Length: #{content.length}\r\n\r\n#{content}"
+
+puts "length: #{content.length}"
+
+threads = []
+ARGV[1].to_i.times do 
+  t = Thread.new do
+    size = 100
+    puts ">>>> #{size} sized chunks"
+    do_test(st, size)
+  end
+
+  t.abort_on_exception = true
+  threads << t
+end
+
+threads.each {|t|  t.join}

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification 
+name: puma
+version: !ruby/object:Gem::Version 
+  hash: 63
+  prerelease: 
+  segments: 
+  - 0
+  - 8
+  - 0
+  version: 0.8.0
+platform: ruby
+authors: 
+- Evan Phoenix
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-25 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake-compiler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        - 7
+        - 0
+        version: 0.7.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 2
+        - 10
+        version: "2.10"
+  type: :development
+  version_requirements: *id002
+description: |-
+  Puma is a small library that provides a very fast and concurrent HTTP 1.1 server for Ruby web applications.  It is designed for running rack apps only.
+  
+  What makes Puma so fast is the careful use of an Ragel extension to provide fast, accurate HTTP 1.1 protocol parsing. This makes the server scream without too many portability issues.
+email: 
+- evan@phx.io
+executables: 
+- puma
+extensions: 
+- ext/puma_http11/extconf.rb
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+files: 
+- COPYING
+- History.txt
+- LICENSE
+- Manifest.txt
+- README.md
+- Rakefile
+- TODO
+- bin/puma
+- examples/builder.rb
+- examples/camping/README
+- examples/camping/blog.rb
+- examples/camping/tepee.rb
+- examples/httpd.conf
+- examples/mime.yaml
+- examples/mongrel.conf
+- examples/monitrc
+- examples/random_thrash.rb
+- examples/simpletest.rb
+- examples/webrick_compare.rb
+- ext/puma_http11/Http11Service.java
+- ext/puma_http11/ext_help.h
+- ext/puma_http11/extconf.rb
+- ext/puma_http11/puma_http11.c
+- ext/puma_http11/http11_parser.c
+- ext/puma_http11/http11_parser.h
+- ext/puma_http11/http11_parser.java.rl
+- ext/puma_http11/http11_parser.rl
+- ext/puma_http11/http11_parser_common.rl
+- ext/puma_http11/org/jruby/mongrel/Http11.java
+- ext/puma_http11/org/jruby/mongrel/Http11Parser.java
+- lib/puma.rb
+- lib/puma/cli.rb
+- lib/puma/const.rb
+- lib/puma/events.rb
+- lib/puma/gems.rb
+- lib/puma/mime_types.yml
+- lib/puma/server.rb
+- lib/puma/thread_pool.rb
+- lib/puma/utils.rb
+- lib/rack/handler/puma.rb
+- puma.gemspec
+- tasks/gem.rake
+- tasks/java.rake
+- tasks/native.rake
+- tasks/ragel.rake
+- test/lobster.ru
+- test/mime.yaml
+- test/test_http10.rb
+- test/test_http11.rb
+- test/test_persistent.rb
+- test/test_rack_handler.rb
+- test/test_rack_server.rb
+- test/test_thread_pool.rb
+- test/test_unix_socket.rb
+- test/test_ws.rb
+- test/testhelp.rb
+- tools/trickletest.rb
+- .gemtest
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.md
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: puma
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Puma is a small library that provides a very fast and concurrent HTTP 1.1 server for Ruby web applications
+test_files: 
+- test/test_http10.rb
+- test/test_http11.rb
+- test/test_persistent.rb
+- test/test_rack_handler.rb
+- test/test_rack_server.rb
+- test/test_thread_pool.rb
+- test/test_unix_socket.rb
+- test/test_ws.rb