puma-simon 3.7.1

data/test/test_tcp_rack.rb

@@ -0,0 +1,36 @@
+require "test_helper"
+
+require "puma/events"
+
+class TestTCPRack < Minitest::Test
+
+  def setup
+    @port = 3212
+    @host = "127.0.0.1"
+
+    @events = Puma::Events.new STDOUT, STDERR
+    @server = Puma::Server.new nil, @events
+  end
+
+  def teardown
+    @server.stop(true)
+  end
+
+  def test_passes_the_socket
+    @server.tcp_mode!
+
+    body = "We sell hats for a discount!\n"
+
+    @server.app = proc do |env, socket|
+      socket << body
+      socket.close
+    end
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @port
+
+    assert_equal body, sock.read
+  end
+end

data/test/test_thread_pool.rb

@@ -0,0 +1,250 @@
+require "test_helper"
+
+require "puma/thread_pool"
+
+class TestThreadPool < Minitest::Test
+
+  def teardown
+    @pool.shutdown if @pool
+  end
+
+  def new_pool(min, max, &block)
+    block = proc { } unless block
+    @pool = Puma::ThreadPool.new(min, max, &block)
+  end
+
+  def pause
+    sleep 0.2
+  end
+
+  def test_append_spawns
+    saw = []
+    thread_name = nil
+
+    pool = new_pool(0, 1) do |work|
+      saw << work
+      thread_name = Thread.current.name if Thread.current.respond_to?(:name)
+    end
+
+    pool << 1
+
+    pause
+
+    assert_equal [1], saw
+    assert_equal 1, pool.spawned
+    # Thread name is new in Ruby 2.3
+    assert_equal('puma 001', thread_name) if Thread.current.respond_to?(:name)
+  end
+
+  def test_converts_pool_sizes
+    pool = new_pool('0', '1')
+
+    assert_equal 0, pool.spawned
+
+    pool << 1
+
+    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
+
+    pause
+
+    assert_equal 2, pool.spawned
+    pool.trim
+    pause
+
+    assert_equal 1, pool.spawned
+    pool.trim
+    pause
+
+    assert_equal 1, pool.spawned
+
+  end
+
+  def test_force_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 true
+    pool.trim true
+
+    finish = true
+
+    pause
+
+    assert_equal 1, pool.spawned
+  end
+
+  def test_trim_is_ignored_if_no_waiting_threads
+    finish = false
+    pool = new_pool(1, 2) { Thread.pass until finish }
+
+    pool << 1
+    pool << 2
+
+    assert_equal 2, pool.spawned
+    pool.trim
+    pool.trim
+
+    assert_equal 0, pool.trim_requested
+
+    finish = true
+
+    pause
+  end
+
+  def test_autotrim
+    finish = false
+    pool = new_pool(1, 2) { Thread.pass until finish }
+
+    pool << 1
+    pool << 2
+
+    assert_equal 2, pool.spawned
+
+    finish = true
+
+    pause
+
+    assert_equal 2, pool.spawned
+
+    pool.auto_trim! 1
+
+    sleep 1
+
+    pause
+
+    assert_equal 1, pool.spawned
+  end
+
+  def test_cleanliness
+    values = []
+    n = 100
+    mutex = Mutex.new
+
+    finished = false
+
+    pool = new_pool(1,1) {
+      mutex.synchronize { values.push Thread.current[:foo] }
+      Thread.current[:foo] = :hai
+      Thread.pass until finished
+    }
+
+    pool.clean_thread_locals = true
+
+    n.times { pool << 1 }
+
+    finished = true
+
+    pause
+
+    assert_equal n,  values.length
+
+    assert_equal [], values.compact
+  end
+
+  def test_reap_only_dead_threads
+    pool = new_pool(2,2) { Thread.current.kill }
+
+    assert_equal 2, pool.spawned
+
+    pool << 1
+
+    pause
+
+    assert_equal 2, pool.spawned
+
+    pool.reap
+
+    assert_equal 1, pool.spawned
+
+    pool << 2
+
+    pause
+
+    assert_equal 1, pool.spawned
+
+    pool.reap
+
+    assert_equal 0, pool.spawned
+  end
+
+  def test_auto_reap_dead_threads
+    pool = new_pool(2,2) { Thread.current.kill }
+
+    assert_equal 2, pool.spawned
+
+    pool << 1
+    pool << 2
+
+    pause
+
+    assert_equal 2, pool.spawned
+
+    pool.auto_reap! 1
+
+    sleep 1
+
+    pause
+
+    assert_equal 0, pool.spawned
+  end
+
+  def test_force_shutdown_immediately
+    pool = new_pool(1, 1) {
+      begin
+        sleep 1
+      rescue Puma::ThreadPool::ForceShutdown
+      end
+    }
+
+    pool << 1
+
+    sleep 0.1
+
+    pool.shutdown(0)
+
+    assert_equal 0, pool.spawned
+  end
+end

data/test/test_unix_socket.rb

@@ -0,0 +1,35 @@
+require "test_helper"
+
+# UNIX sockets are not recommended on JRuby
+# (or Windows)
+unless Puma.jruby? || Puma.windows?
+  class TestPumaUnixSocket < Minitest::Test
+
+    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.exist? 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\nContent-Length: 5\r\n\r\nWorks"
+
+      assert_equal expected, sock.read(expected.size)
+
+      sock.close
+    end
+  end
+end

data/test/test_web_server.rb

@@ -0,0 +1,88 @@
+# Copyright (c) 2011 Evan Phoenix
+# Copyright (c) 2005 Zed A. Shaw
+
+require "test_helper"
+
+require "puma/server"
+
+class TestHandler
+  attr_reader :ran_test
+
+  def call(env)
+    @ran_test = true
+
+    [200, {"Content-Type" => "text/plain"}, ["hello!"]]
+  end
+end
+
+class WebServerTest < Minitest::Test
+
+  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 = Puma::Server.new @tester, Puma::Events.strings
+    @server.add_tcp_listener "127.0.0.1", 0
+
+    @server.run
+  end
+
+  def teardown
+    @server.stop(true)
+  end
+
+  def test_simple_server
+    hit(["http://127.0.0.1:#{ @server.connected_port }/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", @server.connected_port);
+    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
+    do_test("GET /test HTTP/BAD", 3)
+  end
+
+  def test_header_is_too_long
+    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
+
+  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/tools/jungle/README.md

@@ -0,0 +1,9 @@
+# Puma as a service
+
+## Init.d
+
+See `/tools/jungle/init.d` for tools to use with init.d and start-stop-daemon.
+
+## Upstart
+
+See `/tools/jungle/upstart` for Ubuntu's upstart scripts.

data/tools/jungle/init.d/README.md

@@ -0,0 +1,59 @@
+# Puma daemon service
+
+Init script to manage multiple Puma servers on the same box using start-stop-daemon.
+
+## Installation 
+
+    # Copy the init script to services directory 
+    sudo cp puma /etc/init.d
+    sudo chmod +x /etc/init.d/puma
+    
+    # Make it start at boot time. 
+    sudo update-rc.d -f puma defaults
+
+    # Copy the Puma runner to an accessible location
+    sudo cp run-puma /usr/local/bin
+    sudo chmod +x /usr/local/bin/run-puma
+
+    # Create an empty configuration file
+    sudo touch /etc/puma.conf
+
+## Managing the jungle 
+
+Puma apps are held in /etc/puma.conf by default. It's mainly a CSV file and every line represents one app. Here's the syntax:
+
+    app-path,user,config-file-path,log-file-path,environment-variables
+
+You can add an instance by editing the file or running the following command:
+
+    sudo /etc/init.d/puma add /path/to/app user /path/to/app/config/puma.rb /path/to/app/log/puma.log
+
+The config and log paths, as well as the environment variables, are optional parameters and default to:
+
+* config: /path/to/app/*config/puma.rb*
+* log: /path/to/app/*log/puma.log*
+* environment: (empty)
+
+Multiple environment variables need to be separated by a semicolon, e.g.
+
+    FOO=1;BAR=2
+
+To remove an app, simply delete the line from the config file or run:
+
+    sudo /etc/init.d/puma remove /path/to/app
+
+The command will make sure the Puma instance stops before removing it from the jungle.
+
+## Assumptions 
+
+* The script expects a temporary folder named /path/to/app/*tmp/puma* to exist. Create it if it's not there by default.
+The pid and state files should live there and must be called: *tmp/puma/pid* and *tmp/puma/state*.
+You can change those if you want but you'll have to adapt the script for it to work.
+
+* Here's what a minimal app's config file should have:
+
+```
+pidfile "/path/to/app/tmp/puma/pid"
+state_path "/path/to/app/tmp/puma/state"
+activate_control_app
+```