puma 2.7.0 → 3.1.1

data/COPYING

@@ -1,55 +0,0 @@
-Mongrel Web Server (Mongrel) is copyrighted free software by Zed A. Shaw
-<zedshaw at zedshaw dot com> You can redistribute it and/or modify it under
-either the terms of the GPL or the conditions below:
-
-1. You may make and give away verbatim copies of the source form of the
-   software without restriction, provided that you duplicate all of the
-   original copyright notices and associated disclaimers.
-
-2. You may modify your copy of the software in any way, provided that
-   you do at least ONE of the following:
-
-     a) place your modifications in the Public Domain or otherwise make them
-     Freely Available, such as by posting said modifications to Usenet or an
-     equivalent medium, or by allowing the author to include your
-     modifications in the software.
-
-     b) use the modified software only within your corporation or
-        organization.
-
-     c) rename any non-standard executables so the names do not conflict with
-     standard executables, which must also be provided.
-
-     d) make other distribution arrangements with the author.
-
-3. You may distribute the software in object code or executable
-   form, provided that you do at least ONE of the following:
-
-     a) distribute the executables and library files of the software,
-     together with instructions (in the manual page or equivalent) on where
-     to get the original distribution.
-
-     b) accompany the distribution with the machine-readable source of the
-     software.
-
-     c) give non-standard executables non-standard names, with
-        instructions on where to get the original software distribution.
-
-     d) make other distribution arrangements with the author.
-
-4. You may modify and include the part of the software into any other
-   software (possibly commercial).  But some files in the distribution
-   are not written by the author, so that they are not under this terms.
-
-5. The scripts and library files supplied as input to or produced as 
-   output from the software do not automatically fall under the
-   copyright of the software, but belong to whomever generated them, 
-   and may be sold commercially, and may be aggregated with this
-   software.
-
-6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
-   IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
-   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-   PURPOSE.
-
-

data/TODO

@@ -1,5 +0,0 @@
-
-v1.2. Rewrite and merge mongrel cluster and mongrel_rails into something small and maintainable. Remove gem_plugin entirely.
-
-v1.1.1. See if Java is setting the server version string in the request properly.
-

data/lib/puma/rack_patch.rb

@@ -1,45 +0,0 @@
-require 'rack/commonlogger'
-
-module Rack
-  # Patch CommonLogger to use after_reply.
-  #
-  # Simply request this file and CommonLogger will be a bit more 
-  # efficient.
-  class CommonLogger
-    remove_method :call
-
-    def call(env)
-      began_at = Time.now
-      status, header, body = @app.call(env)
-      header = Utils::HeaderHash.new(header)
-
-      # If we've been hijacked, then output a special line
-      if env['rack.hijack_io']
-        log_hijacking(env, 'HIJACK', header, began_at)
-      elsif ary = env['rack.after_reply']
-        ary << lambda { log(env, status, header, began_at) }
-      else
-        body = BodyProxy.new(body) { log(env, status, header, began_at) }
-      end
-
-      [status, header, body]
-    end
-
-    HIJACK_FORMAT = %{%s - %s [%s] "%s %s%s %s" HIJACKED -1 %0.4f\n}
-
-    def log_hijacking(env, status, header, began_at)
-      now = Time.now
-
-      logger = @logger || env['rack.errors']
-      logger.write HIJACK_FORMAT % [
-        env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-",
-        env["REMOTE_USER"] || "-",
-        now.strftime("%d/%b/%Y %H:%M:%S"),
-        env["REQUEST_METHOD"],
-        env["PATH_INFO"],
-        env["QUERY_STRING"].empty? ? "" : "?"+env["QUERY_STRING"],
-        env["HTTP_VERSION"],
-        now - began_at ]
-    end
-  end
-end

data/test/test_app_status.rb

@@ -1,92 +0,0 @@
-require 'test/unit'
-require 'rack'
-require 'puma/app/status'
-
-class TestAppStatus < Test::Unit::TestCase
-  class FakeServer
-    def initialize
-      @status = :running
-      @backlog = 0
-      @running = 0
-    end
-
-    attr_reader :status
-    attr_accessor :backlog, :running
-
-    def stop
-      @status = :stop
-    end
-
-    def halt
-      @status = :halt
-    end
-
-    def stats
-      "{}"
-    end
-  end
-
-  def setup
-    @server = FakeServer.new
-    @app = Puma::App::Status.new(@server)
-    @app.auth_token = nil
-  end
-
-  def lint(uri)
-    app = Rack::Lint.new @app
-    mock_env = Rack::MockRequest.env_for uri
-    app.call mock_env
-  end
-
-  def test_bad_token
-    @app.auth_token = "abcdef"
-
-    status, _, _ = lint('/whatever')
-
-    assert_equal 403, status
-  end
-
-  def test_good_token
-    @app.auth_token = "abcdef"
-
-    status, _, _ = lint('/whatever?token=abcdef')
-
-    assert_equal 404, status
-  end
-
-  def test_unsupported
-    status, _, _ = lint('/not-real')
-
-    assert_equal 404, status
-  end
-
-  def test_stop
-    status, _ , app = lint('/stop')
-
-    assert_equal :stop, @server.status
-    assert_equal 200, status
-    assert_equal ['{ "status": "ok" }'], app.enum_for.to_a
-  end
-
-  def test_halt
-    status, _ , app = lint('/halt')
-
-    assert_equal :halt, @server.status
-    assert_equal 200, status
-    assert_equal ['{ "status": "ok" }'], app.enum_for.to_a
-  end
-
-  def test_stats
-    @server.backlog = 1
-    @server.running = 9
-    status, _ , app = lint('/stats')
-
-    assert_equal 200, status
-    assert_equal ['{}'], app.enum_for.to_a
-  end
-
-  def test_alternate_location
-    status, _ , _ = lint('__alternatE_location_/stats')
-    assert_equal 200, status
-  end
-end

data/test/test_cli.rb

@@ -1,173 +0,0 @@
-require "rbconfig"
-require 'test/unit'
-require 'puma/cli'
-require 'tempfile'
-
-class TestCLI < Test::Unit::TestCase
-  def setup
-    @environment = 'production'
-    @tmp_file = Tempfile.new("puma-test")
-    @tmp_path = @tmp_file.path
-    @tmp_file.close!
-
-    @tmp_path2 = "#{@tmp_path}2"
-
-    File.unlink @tmp_path if File.exist? @tmp_path
-    File.unlink @tmp_path2 if File.exist? @tmp_path2
-
-    @wait, @ready = IO.pipe
-
-    @events = Events.strings
-    @events.on_booted { @ready << "!" }
-  end
-
-  def wait_booted
-    @wait.sysread 1
-  end
-
-  def teardown
-    File.unlink @tmp_path if File.exist? @tmp_path
-    File.unlink @tmp_path2 if File.exist? @tmp_path2
-
-    @wait.close
-    @ready.close
-  end
-
-  def test_pid_file
-    cli = Puma::CLI.new ["--pidfile", @tmp_path]
-    cli.parse_options
-    cli.write_pid
-
-    assert_equal File.read(@tmp_path).strip.to_i, Process.pid
-  end
-
-  def test_control_for_tcp
-    url = "tcp://127.0.0.1:9877/"
-    cli = Puma::CLI.new ["-b", "tcp://127.0.0.1:9876",
-                         "--control", url,
-                         "--control-token", "",
-                         "test/lobster.ru"], @events
-
-    cli.parse_options
-
-    thread_exception = nil
-    t = Thread.new do
-      begin
-        cli.run
-      rescue Exception => e
-        thread_exception = e
-      end
-    end 
-
-    wait_booted
-
-    s = TCPSocket.new "127.0.0.1", 9877
-    s << "GET /stats HTTP/1.0\r\n\r\n"
-    body = s.read
-    assert_equal '{ "backlog": 0, "running": 0 }', body.split("\r\n").last
-
-    cli.stop
-    t.join
-    assert_equal nil, thread_exception
-  end
-
-  unless defined?(JRUBY_VERSION) || RbConfig::CONFIG["host_os"] =~ /mingw|mswin/
-  def test_control
-    url = "unix://#{@tmp_path}"
-
-    cli = Puma::CLI.new ["-b", "unix://#{@tmp_path2}",
-                         "--control", url,
-                         "--control-token", "",
-                         "test/lobster.ru"], @events
-    cli.parse_options
-
-    t = Thread.new { cli.run }
-
-    wait_booted
-
-    s = UNIXSocket.new @tmp_path
-    s << "GET /stats HTTP/1.0\r\n\r\n"
-    body = s.read
-
-    assert_equal '{ "backlog": 0, "running": 0 }', body.split("\r\n").last
-
-    cli.stop
-    t.join
-  end
-
-  def test_control_stop
-    url = "unix://#{@tmp_path}"
-
-    cli = Puma::CLI.new ["-b", "unix://#{@tmp_path2}",
-                         "--control", url,
-                         "--control-token", "",
-                         "test/lobster.ru"], @events
-    cli.parse_options
-
-    t = Thread.new { cli.run }
-
-    wait_booted
-
-    s = UNIXSocket.new @tmp_path
-    s << "GET /stop HTTP/1.0\r\n\r\n"
-    body = s.read
-
-    assert_equal '{ "status": "ok" }', body.split("\r\n").last
-
-    t.join
-  end
-
-  def test_tmp_control
-    url = "tcp://127.0.0.1:8232"
-    cli = Puma::CLI.new ["--state", @tmp_path, "--control", "auto"]
-    cli.parse_options
-    cli.write_state
-
-    data = YAML.load File.read(@tmp_path)
-
-    assert_equal Process.pid, data["pid"]
-
-    url = data["config"].options[:control_url]
-
-    m = %r!unix://(.*)!.match(url)
-
-    assert m, "'#{url}' is not a URL"
-  end
-  end # JRUBY or Windows
-
-  def test_state
-    url = "tcp://127.0.0.1:8232"
-    cli = Puma::CLI.new ["--state", @tmp_path, "--control", url]
-    cli.parse_options
-    cli.write_state
-
-    data = YAML.load File.read(@tmp_path)
-
-    assert_equal Process.pid, data["pid"]
-    assert_equal url, data["config"].options[:control_url]
-  end
-
-  def test_load_path
-    cli = Puma::CLI.new ["--include", 'foo/bar']
-    cli.parse_options
-
-    assert_equal 'foo/bar', $LOAD_PATH[0]
-    $LOAD_PATH.shift
-
-    cli = Puma::CLI.new ["--include", 'foo/bar:baz/qux']
-    cli.parse_options
-
-    assert_equal 'foo/bar', $LOAD_PATH[0]
-    $LOAD_PATH.shift
-    assert_equal 'baz/qux', $LOAD_PATH[0]
-    $LOAD_PATH.shift
-  end
-
-  def test_environment
-    cli = Puma::CLI.new ["--environment", @environment]
-    cli.parse_options
-    cli.set_rack_environment
-
-    assert_equal ENV['RACK_ENV'], @environment 
-  end
-end

data/test/test_config.rb

@@ -1,16 +0,0 @@
-require 'test/unit'
-
-require 'puma'
-require 'puma/configuration'
-
-class TestConfigFile < Test::Unit::TestCase
-  def test_app_from_app_DSL
-    opts = { :config_file => "test/config/app.rb" }
-    conf = Puma::Configuration.new opts
-    conf.load
-
-    app = conf.app
-
-    assert_equal [200, {}, ["embedded app"]], app.call({})
-  end
-end

data/test/test_http10.rb

@@ -1,27 +0,0 @@
-require 'test/testhelp'
-
-class Http10ParserTest < Test::Unit::TestCase
-  include Puma
-
-  def test_parse_simple
-    parser = HttpParser.new
-    req = {}
-    http = "GET / HTTP/1.0\r\n\r\n"
-    nread = parser.execute(req, http, 0)
-
-    assert nread == http.length, "Failed to parse the full HTTP request"
-    assert parser.finished?, "Parser didn't finish"
-    assert !parser.error?, "Parser had error"
-    assert nread == parser.nread, "Number read returned from execute does not match"
-
-    assert_equal '/', req['REQUEST_PATH']
-    assert_equal 'HTTP/1.0', req['HTTP_VERSION']
-    assert_equal '/', req['REQUEST_URI']
-    assert_equal 'GET', req['REQUEST_METHOD']    
-    assert_nil req['FRAGMENT']
-    assert_nil req['QUERY_STRING']
-    
-    parser.reset
-    assert parser.nread == 0, "Number read after reset should be 0"
-  end
-end

data/test/test_http11.rb

@@ -1,145 +0,0 @@
-# Copyright (c) 2011 Evan Phoenix
-# Copyright (c) 2005 Zed A. Shaw 
-
-require 'test/testhelp'
-
-include Puma
-
-class Http11ParserTest < Test::Unit::TestCase
-
-  def test_parse_simple
-    parser = HttpParser.new
-    req = {}
-    http = "GET / HTTP/1.1\r\n\r\n"
-    nread = parser.execute(req, http, 0)
-
-    assert nread == http.length, "Failed to parse the full HTTP request"
-    assert parser.finished?, "Parser didn't finish"
-    assert !parser.error?, "Parser had error"
-    assert nread == parser.nread, "Number read returned from execute does not match"
-
-    assert_equal '/', req['REQUEST_PATH']
-    assert_equal 'HTTP/1.1', req['HTTP_VERSION']
-    assert_equal '/', req['REQUEST_URI']
-    assert_equal 'GET', req['REQUEST_METHOD']
-    assert_nil req['FRAGMENT']
-    assert_nil req['QUERY_STRING']
-    
-    parser.reset
-    assert parser.nread == 0, "Number read after reset should be 0"
-  end
- 
-  def test_parse_dumbfuck_headers
-    parser = HttpParser.new
-    req = {}
-    should_be_good = "GET / HTTP/1.1\r\naaaaaaaaaaaaa:++++++++++\r\n\r\n"
-    nread = parser.execute(req, should_be_good, 0)
-    assert_equal should_be_good.length, nread
-    assert parser.finished?
-    assert !parser.error?
-  end
-  
-  def test_parse_error
-    parser = HttpParser.new
-    req = {}
-    bad_http = "GET / SsUTF/1.1"
-
-    error = false
-    begin
-      parser.execute(req, bad_http, 0)
-    rescue
-      error = true
-    end
-
-    assert error, "failed to throw exception"
-    assert !parser.finished?, "Parser shouldn't be finished"
-    assert parser.error?, "Parser SHOULD have error"
-  end
-
-  def test_fragment_in_uri
-    parser = HttpParser.new
-    req = {}
-    get = "GET /forums/1/topics/2375?page=1#posts-17408 HTTP/1.1\r\n\r\n"
-    assert_nothing_raised do
-      parser.execute(req, get, 0)
-    end
-    assert parser.finished?
-    assert_equal '/forums/1/topics/2375?page=1', req['REQUEST_URI']
-    assert_equal 'posts-17408', req['FRAGMENT']
-  end
-
-  # lame random garbage maker
-  def rand_data(min, max, readable=true)
-    count = min + ((rand(max)+1) *10).to_i
-    res = count.to_s + "/"
-    
-    if readable
-      res << Digest::SHA1.hexdigest(rand(count * 100).to_s) * (count / 40)
-    else
-      res << Digest::SHA1.digest(rand(count * 100).to_s) * (count / 20)
-    end
-
-    return res
-  end
-
-  def test_max_uri_path_length
-    parser = HttpParser.new
-    req = {}
-
-    # Support URI path length to a max of 2048
-    path = "/" + rand_data(1000, 100)
-    http = "GET #{path} HTTP/1.1\r\n\r\n"
-    parser.execute(req, http, 0)
-    assert_equal path, req['REQUEST_PATH']
-    parser.reset
-
-    # Raise exception if URI path length > 2048
-    path = "/" + rand_data(2048, 100)
-    http = "GET #{path} HTTP/1.1\r\n\r\n"
-    assert_raises Puma::HttpParserError do
-      parser.execute(req, http, 0)
-      parser.reset
-    end
-  end
-
-  def test_horrible_queries
-    parser = HttpParser.new
-
-    # then that large header names are caught
-    10.times do |c|
-      get = "GET /#{rand_data(10,120)} HTTP/1.1\r\nX-#{rand_data(1024, 1024+(c*1024))}: Test\r\n\r\n"
-      assert_raises Puma::HttpParserError do
-        parser.execute({}, get, 0)
-        parser.reset
-      end
-    end
-
-    # then that large mangled field values are caught
-    10.times do |c|
-      get = "GET /#{rand_data(10,120)} HTTP/1.1\r\nX-Test: #{rand_data(1024, 1024+(c*1024), false)}\r\n\r\n"
-      assert_raises Puma::HttpParserError do
-        parser.execute({}, get, 0)
-        parser.reset
-      end
-    end
-
-    # then large headers are rejected too
-    get = "GET /#{rand_data(10,120)} HTTP/1.1\r\n"
-    get << "X-Test: test\r\n" * (80 * 1024)
-    assert_raises Puma::HttpParserError do
-      parser.execute({}, get, 0)
-      parser.reset
-    end
-
-    # finally just that random garbage gets blocked all the time
-    10.times do |c|
-      get = "GET #{rand_data(1024, 1024+(c*1024), false)} #{rand_data(1024, 1024+(c*1024), false)}\r\n\r\n"
-      assert_raises Puma::HttpParserError do
-        parser.execute({}, get, 0)
-        parser.reset
-      end
-    end
-
-  end
-end
-