raindrops-maintained 0.21.0

data/test/test_linux_ipv6.rb

@@ -0,0 +1,166 @@
+# -*- encoding: binary -*-
+require 'test/unit'
+require 'tempfile'
+require 'raindrops'
+require 'socket'
+require 'pp'
+require "./test/ipv6_enabled"
+$stderr.sync = $stdout.sync = true
+
+class TestLinuxIPv6 < Test::Unit::TestCase
+  include Raindrops::Linux
+
+  TEST_ADDR = ENV["TEST_HOST6"] || "::1"
+
+  def setup
+    @to_close = []
+  end
+
+  def teardown
+    @to_close.each { |io| io.close unless io.closed? }
+  end
+
+  def test_tcp
+    s = TCPServer.new(TEST_ADDR, 0)
+    port = s.addr[1]
+    addr = "[#{TEST_ADDR}]:#{port}"
+    addrs = [ addr ]
+    stats = tcp_listener_stats(addrs)
+    assert_equal 1, stats.size
+    assert_equal 0, stats[addr].queued
+    assert_equal 0, stats[addr].active
+
+    @to_close << TCPSocket.new(TEST_ADDR, port)
+    stats = tcp_listener_stats(addrs)
+    assert_equal 1, stats.size
+    assert_equal 1, stats[addr].queued
+    assert_equal 0, stats[addr].active
+
+    @to_close << s.accept
+    stats = tcp_listener_stats(addrs)
+    assert_equal 1, stats.size
+    assert_equal 0, stats[addr].queued
+    assert_equal 1, stats[addr].active
+  end
+
+  def test_tcp_multi
+    s1 = TCPServer.new(TEST_ADDR, 0)
+    s2 = TCPServer.new(TEST_ADDR, 0)
+    port1, port2 = s1.addr[1], s2.addr[1]
+    addr1, addr2 = "[#{TEST_ADDR}]:#{port1}", "[#{TEST_ADDR}]:#{port2}"
+    addrs = [ addr1, addr2 ]
+    stats = tcp_listener_stats(addrs)
+    assert_equal 2, stats.size
+    assert_equal 0, stats[addr1].queued
+    assert_equal 0, stats[addr1].active
+    assert_equal 0, stats[addr2].queued
+    assert_equal 0, stats[addr2].active
+
+    @to_close << TCPSocket.new(TEST_ADDR, port1)
+    stats = tcp_listener_stats(addrs)
+    assert_equal 2, stats.size
+    assert_equal 1, stats[addr1].queued
+    assert_equal 0, stats[addr1].active
+    assert_equal 0, stats[addr2].queued
+    assert_equal 0, stats[addr2].active
+
+    sc1 = s1.accept
+    stats = tcp_listener_stats(addrs)
+    assert_equal 2, stats.size
+    assert_equal 0, stats[addr1].queued
+    assert_equal 1, stats[addr1].active
+    assert_equal 0, stats[addr2].queued
+    assert_equal 0, stats[addr2].active
+
+    @to_close << TCPSocket.new(TEST_ADDR, port2)
+    stats = tcp_listener_stats(addrs)
+    assert_equal 2, stats.size
+    assert_equal 0, stats[addr1].queued
+    assert_equal 1, stats[addr1].active
+    assert_equal 1, stats[addr2].queued
+    assert_equal 0, stats[addr2].active
+
+    @to_close << TCPSocket.new(TEST_ADDR, port2)
+    stats = tcp_listener_stats(addrs)
+    assert_equal 2, stats.size
+    assert_equal 0, stats[addr1].queued
+    assert_equal 1, stats[addr1].active
+    assert_equal 2, stats[addr2].queued
+    assert_equal 0, stats[addr2].active
+
+    @to_close << s2.accept
+    stats = tcp_listener_stats(addrs)
+    assert_equal 2, stats.size
+    assert_equal 0, stats[addr1].queued
+    assert_equal 1, stats[addr1].active
+    assert_equal 1, stats[addr2].queued
+    assert_equal 1, stats[addr2].active
+
+    sc1.close
+    stats = tcp_listener_stats(addrs)
+    assert_equal 0, stats[addr1].queued
+    assert_equal 0, stats[addr1].active
+    assert_equal 1, stats[addr2].queued
+    assert_equal 1, stats[addr2].active
+  end
+
+  def test_invalid_addresses
+    assert_raises(ArgumentError) { tcp_listener_stats(%w([1:::5)) }
+    assert_raises(ArgumentError) { tcp_listener_stats(%w([1:::]5)) }
+  end
+
+  # tries to overflow buffers
+  def test_tcp_stress_test
+    nr_proc = 32
+    nr_sock = 500
+    s = TCPServer.new(TEST_ADDR, 0)
+    port = s.addr[1]
+    addr = "[#{TEST_ADDR}]:#{port}"
+    addrs = [ addr ]
+    rda, wra = IO.pipe
+    rdb, wrb = IO.pipe
+
+    nr_proc.times do
+      fork do
+        rda.close
+        wrb.close
+        @to_close.concat((1..nr_sock).map { s.accept })
+        wra.syswrite('.')
+        wra.close
+        rdb.sysread(1) # wait for parent to nuke us
+      end
+    end
+
+    nr_proc.times do
+      fork do
+        rda.close
+        wrb.close
+        @to_close.concat((1..nr_sock).map { TCPSocket.new(TEST_ADDR, port) })
+        wra.syswrite('.')
+        wra.close
+        rdb.sysread(1) # wait for parent to nuke us
+      end
+    end
+
+    assert_equal('.' * (nr_proc * 2), rda.read(nr_proc * 2))
+
+    rda.close
+    stats = tcp_listener_stats(addrs)
+    expect = { addr => Raindrops::ListenStats[nr_sock * nr_proc, 0] }
+    assert_equal expect, stats
+
+    @to_close << TCPSocket.new(TEST_ADDR, port)
+    stats = tcp_listener_stats(addrs)
+    expect = { addr => Raindrops::ListenStats[nr_sock * nr_proc, 1] }
+    assert_equal expect, stats
+
+    if ENV["BENCHMARK"].to_i != 0
+      require 'benchmark'
+      puts(Benchmark.measure{1000.times { tcp_listener_stats(addrs) }})
+    end
+
+    wrb.syswrite('.' * (nr_proc * 2)) # broadcast a wakeup
+    statuses = Process.waitall
+    statuses.each { |(_,status)| assert status.success?, status.inspect }
+  end if ENV["STRESS"].to_i != 0
+end if RUBY_PLATFORM =~ /linux/ && ipv6_enabled?

data/test/test_linux_middleware.rb

@@ -0,0 +1,64 @@
+# -*- encoding: binary -*-
+require 'test/unit'
+require 'tempfile'
+require 'raindrops'
+require 'socket'
+$stderr.sync = $stdout.sync = true
+
+class TestLinuxMiddleware < Test::Unit::TestCase
+
+  def setup
+    @resp_headers = { 'Content-Type' => 'text/plain', 'Content-Length' => '0' }
+    @response = [ 200, @resp_headers, [] ]
+    @app = lambda { |env| @response }
+    @to_close = []
+  end
+
+  def teardown
+    @to_close.each { |io| io.close unless io.closed? }
+  end
+
+  def test_unix_listener
+    tmp = Tempfile.new("")
+    File.unlink(tmp.path)
+    @to_close << UNIXServer.new(tmp.path)
+    app = Raindrops::Middleware.new(@app, :listeners => [tmp.path])
+    linux_extra = "#{tmp.path} active: 0\n#{tmp.path} queued: 0\n"
+    response = app.call("PATH_INFO" => "/_raindrops")
+
+    expect = [
+      200,
+      {
+        "Content-Type" => "text/plain",
+        "Content-Length" => (22 + linux_extra.size).to_s
+      },
+      [
+        "calling: 0\nwriting: 0\n#{linux_extra}" \
+      ]
+    ]
+    assert_equal expect, response
+  end
+
+  def test_unix_listener_queued
+    tmp = Tempfile.new("")
+    File.unlink(tmp.path)
+    @to_close << UNIXServer.new(tmp.path)
+    @to_close << UNIXSocket.new(tmp.path)
+    app = Raindrops::Middleware.new(@app, :listeners => [tmp.path])
+    linux_extra = "#{tmp.path} active: 0\n#{tmp.path} queued: 1\n"
+    response = app.call("PATH_INFO" => "/_raindrops")
+
+    expect = [
+      200,
+      {
+        "Content-Type" => "text/plain",
+        "Content-Length" => (22 + linux_extra.size).to_s
+      },
+      [
+        "calling: 0\nwriting: 0\n#{linux_extra}" \
+      ]
+    ]
+    assert_equal expect, response
+  end
+
+end if RUBY_PLATFORM =~ /linux/

data/test/test_linux_reuseport_tcp_listen_stats.rb

@@ -0,0 +1,51 @@
+# -*- encoding: binary -*-
+require "./test/rack_unicorn"
+require 'test/unit'
+require 'socket'
+require 'raindrops'
+$stderr.sync = $stdout.sync = true
+
+class TestLinuxReuseportTcpListenStats < Test::Unit::TestCase
+  include Raindrops::Linux
+  include Unicorn::SocketHelper
+  TEST_ADDR = ENV['UNICORN_TEST_ADDR'] || '127.0.0.1'
+  DEFAULT_BACKLOG = 10
+
+  def setup
+    @socks = []
+  end
+
+  def teardown
+    @socks.each { |io| io.closed? or io.close }
+  end
+
+  def new_socket_server(**kwargs)
+    s = new_tcp_server TEST_ADDR, kwargs[:port] || 0, kwargs
+    s.listen(kwargs[:backlog] || DEFAULT_BACKLOG)
+    @socks << s
+    [ s, s.addr[1] ]
+  end
+
+  def new_client(port)
+    s = TCPSocket.new("127.0.0.1", port)
+    @socks << s
+    s
+  end
+
+  def test_reuseport_queue_stats
+    listeners = 10
+    _, port = new_socket_server(reuseport: true)
+    addr = "#{TEST_ADDR}:#{port}"
+    (listeners - 1).times do
+      new_socket_server(reuseport: true, port: port)
+    end
+
+    listeners.times do |i|
+      all = Raindrops::Linux.tcp_listener_stats
+      assert_equal [0, i], all[addr].to_a
+      new_client(port)
+      all = Raindrops::Linux.tcp_listener_stats
+      assert_equal [0, i+1], all[addr].to_a
+    end
+  end
+end if RUBY_PLATFORM =~ /linux/ && Object.const_defined?(:Unicorn)

data/test/test_middleware.rb

@@ -0,0 +1,128 @@
+# -*- encoding: binary -*-
+require 'test/unit'
+require 'raindrops'
+
+class TestMiddleware < Test::Unit::TestCase
+
+  def setup
+    @resp_headers = { 'Content-Type' => 'text/plain', 'Content-Length' => '0' }
+    @response = [ 200, @resp_headers, [] ]
+    @app = lambda { |env| @response }
+  end
+
+  def test_setup
+    app = Raindrops::Middleware.new(@app)
+    response = app.call({})
+    assert_equal @response[0,2], response[0,2]
+    assert response.last.kind_of?(Raindrops::Middleware::Proxy)
+    assert response.last.object_id != app.object_id
+    tmp = []
+    response.last.each { |y| tmp << y }
+    assert tmp.empty?
+  end
+
+  def test_alt_stats
+    stats = Raindrops::Middleware::Stats.new
+    app = lambda { |env|
+      if (stats.writing == 0 && stats.calling == 1)
+        @app.call(env)
+      else
+        [ 500, @resp_headers, [] ]
+      end
+    }
+    app = Raindrops::Middleware.new(app, :stats => stats)
+    response = app.call({})
+    assert_equal 0, stats.calling
+    assert_equal 1, stats.writing
+    assert_equal 200, response[0]
+    assert response.last.kind_of?(Raindrops::Middleware::Proxy)
+    tmp = []
+    response.last.each do |y|
+      assert_equal 1, stats.writing
+      tmp << y
+    end
+    assert tmp.empty?
+  end
+
+  def test_default_endpoint
+    app = Raindrops::Middleware.new(@app)
+    response = app.call("PATH_INFO" => "/_raindrops")
+    expect = [
+      200,
+      { "Content-Type" => "text/plain", "Content-Length" => "22" },
+      [ "calling: 0\nwriting: 0\n" ]
+    ]
+    assert_equal expect, response
+  end
+
+  def test_alt_endpoint
+    app = Raindrops::Middleware.new(@app, :path => "/foo")
+    response = app.call("PATH_INFO" => "/foo")
+    expect = [
+      200,
+      { "Content-Type" => "text/plain", "Content-Length" => "22" },
+      [ "calling: 0\nwriting: 0\n" ]
+    ]
+    assert_equal expect, response
+  end
+
+  def test_concurrent
+    rda, wra = IO.pipe
+    rdb, wrb = IO.pipe
+    app = lambda do |env|
+      wrb.close
+      wra.syswrite('.')
+      wra.close
+
+      # wait until parent has run app.call for stats endpoint
+      rdb.read
+      @app.call(env)
+    end
+    app = Raindrops::Middleware.new(app)
+
+    pid = fork { app.call({}) }
+    rdb.close
+
+    # wait til child is running in app.call
+    assert_equal '.', rda.sysread(1)
+    rda.close
+
+    response = app.call("PATH_INFO" => "/_raindrops")
+    expect = [
+      200,
+      { "Content-Type" => "text/plain", "Content-Length" => "22" },
+      [ "calling: 1\nwriting: 0\n" ]
+    ]
+    assert_equal expect, response
+    wrb.close # unblock child process
+    assert Process.waitpid2(pid).last.success?
+
+    # we didn't call close the body in the forked child, so it'll always be
+    # marked as writing, a real server would close the body
+    response = app.call("PATH_INFO" => "/_raindrops")
+    expect = [
+      200,
+      { "Content-Type" => "text/plain", "Content-Length" => "22" },
+      [ "calling: 0\nwriting: 1\n" ]
+    ]
+    assert_equal expect, response
+  end
+
+  def test_middleware_proxy_to_path_missing
+    app = Raindrops::Middleware.new(@app)
+    response = app.call({})
+    body = response[2]
+    assert_kind_of Raindrops::Middleware::Proxy, body
+    assert ! body.respond_to?(:to_path)
+    assert body.respond_to?(:close)
+    orig_body = @response[2]
+
+    def orig_body.to_path; "/dev/null"; end
+    assert body.respond_to?(:to_path)
+    assert_equal "/dev/null", body.to_path
+
+    def orig_body.body; "this is a body"; end
+    assert body.respond_to?(:body)
+    assert_equal "this is a body", body.body
+  end
+end

data/test/test_middleware_unicorn.rb

@@ -0,0 +1,37 @@
+# -*- encoding: binary -*-
+require "./test/rack_unicorn"
+$stderr.sync = $stdout.sync = true
+
+class TestMiddlewareUnicorn < Test::Unit::TestCase
+
+  def setup
+    @host = ENV["UNICORN_TEST_ADDR"] || "127.0.0.1"
+    @sock = TCPServer.new @host, 0
+    @port = @sock.addr[1]
+    ENV["UNICORN_FD"] = @sock.fileno.to_s
+    @host_with_port = "#@host:#@port"
+    @opts = { :listeners => [ @host_with_port ] }
+    @addr_regexp = Regexp.escape @host_with_port
+  end
+
+  def test_auto_listener
+    @app = Rack::Builder.new do
+      use Raindrops::Middleware
+      run Rack::Lobster.new
+    end
+    @srv = fork { Unicorn::HttpServer.new(@app, @opts).start.join }
+
+    s = TCPSocket.new @host, @port
+    s.write "GET /_raindrops HTTP/1.0\r\n\r\n"
+    resp = s.read
+    _, body = resp.split(/\r\n\r\n/, 2)
+    assert_match %r{^#@addr_regexp active: 1$}, body
+    assert_match %r{^#@addr_regexp queued: 0$}, body
+  end
+
+  def teardown
+    Process.kill :QUIT, @srv
+    _, status = Process.waitpid2 @srv
+    assert status.success?
+  end
+end if defined?(Unicorn) && RUBY_PLATFORM =~ /linux/

data/test/test_middleware_unicorn_ipv6.rb

@@ -0,0 +1,37 @@
+# -*- encoding: binary -*-
+require "./test/rack_unicorn"
+require "./test/ipv6_enabled"
+$stderr.sync = $stdout.sync = true
+
+class TestMiddlewareUnicornIPv6 < Test::Unit::TestCase
+
+  def setup
+    @host = ENV["TEST_HOST6"] || "::1"
+    sock = TCPServer.new @host, 0
+    @port = sock.addr[1]
+    ENV["UNICORN_FD"] = sock.fileno.to_s
+    @host_with_port = "[#@host]:#@port"
+    @opts = { :listeners => [ @host_with_port ] }
+    @addr_regexp = Regexp.escape @host_with_port
+  end
+
+  def test_auto_listener
+    @app = Rack::Builder.new do
+      use Raindrops::Middleware
+      run Rack::Lobster.new
+    end
+    @srv = fork { Unicorn::HttpServer.new(@app, @opts).start.join }
+    s = TCPSocket.new @host, @port
+    s.write "GET /_raindrops HTTP/1.0\r\n\r\n"
+    resp = s.read
+    _, body = resp.split(/\r\n\r\n/, 2)
+    assert_match %r{^#@addr_regexp active: 1$}, body
+    assert_match %r{^#@addr_regexp queued: 0$}, body
+  end
+
+  def teardown
+    Process.kill :QUIT, @srv
+    _, status = Process.waitpid2 @srv
+    assert status.success?
+  end
+end if defined?(Unicorn) && RUBY_PLATFORM =~ /linux/ && ipv6_enabled?

data/test/test_raindrops.rb

@@ -0,0 +1,207 @@
+# -*- encoding: binary -*-
+require 'test/unit'
+require 'raindrops'
+require 'tempfile'
+
+class TestRaindrops < Test::Unit::TestCase
+
+  def test_raindrop_counter_max
+    assert_kind_of Integer, Raindrops::MAX
+    assert Raindrops::MAX > 0
+    printf "Raindrops::MAX = 0x%x\n", Raindrops::MAX
+  end
+
+  def test_raindrop_size
+    assert_kind_of Integer, Raindrops::SIZE
+    assert Raindrops::SIZE > 0
+    puts "Raindrops::SIZE = #{Raindrops::SIZE}"
+  end
+
+  def test_page_size
+    assert_kind_of Integer, Raindrops::PAGE_SIZE
+    assert Raindrops::PAGE_SIZE > Raindrops::SIZE
+  end
+
+  def test_size_and_capa
+    rd = Raindrops.new(4)
+    assert_equal 4, rd.size
+    assert rd.capa >= rd.size
+  end
+
+  def test_ary
+    rd = Raindrops.new(4)
+    assert_equal [0, 0, 0, 0] , rd.to_ary
+  end
+
+  def test_incr_no_args
+    rd = Raindrops.new(4)
+    assert_equal 1, rd.incr(0)
+    assert_equal [1, 0, 0, 0], rd.to_ary
+  end
+
+  def test_incr_args
+    rd = Raindrops.new(4)
+    assert_equal 6, rd.incr(3, 6)
+    assert_equal [0, 0, 0, 6], rd.to_ary
+  end
+
+  def test_decr_args
+    rd = Raindrops.new(4)
+    rd[3] = 6
+    assert_equal 5, rd.decr(3, 1)
+    assert_equal [0, 0, 0, 5], rd.to_ary
+  end
+
+  def test_incr_shared
+    rd = Raindrops.new(2)
+    5.times do
+      pid = fork { rd.incr(1) }
+      _, status = Process.waitpid2(pid)
+      assert status.success?
+    end
+    assert_equal [0, 5], rd.to_ary
+  end
+
+  def test_incr_decr
+    rd = Raindrops.new(1)
+    fork { 1000000.times { rd.incr(0) } }
+    1000.times { rd.decr(0) }
+    statuses = Process.waitall
+    statuses.each { |pid, status| assert status.success? }
+    assert_equal [999000], rd.to_ary
+  end
+
+  def test_bad_incr
+    rd = Raindrops.new(1)
+    assert_raises(ArgumentError) { rd.incr(-1) }
+    assert_raises(ArgumentError) { rd.incr(2) }
+    assert_raises(ArgumentError) { rd.incr(0xffffffff) }
+  end
+
+  def test_dup
+    @rd = Raindrops.new(1)
+    rd = @rd.dup
+    assert_equal 1, @rd.incr(0)
+    assert_equal 1, rd.incr(0)
+    assert_equal 2, rd.incr(0)
+    assert_equal 2, rd[0]
+    assert_equal 1, @rd[0]
+  end
+
+  def test_clone
+    @rd = Raindrops.new(1)
+    rd = @rd.clone
+    assert_equal 1, @rd.incr(0)
+    assert_equal 1, rd.incr(0)
+    assert_equal 2, rd.incr(0)
+    assert_equal 2, rd[0]
+    assert_equal 1, @rd[0]
+  end
+
+  def test_big
+    expect = (1..256).map { 0 }
+    rd = Raindrops.new(256)
+    assert_equal expect, rd.to_ary
+    assert_nothing_raised { rd[255] = 5 }
+    assert_equal 5, rd[255]
+    assert_nothing_raised { rd[2] = 2 }
+
+    expect[255] = 5
+    expect[2] = 2
+    assert_equal expect, rd.to_ary
+  end
+
+  def test_resize
+    rd = Raindrops.new(4)
+    assert_equal 4, rd.size
+    assert_equal rd.capa, rd.size = rd.capa
+    assert_equal rd.capa, rd.to_ary.size
+    assert_equal 0, rd[rd.capa - 1]
+    assert_equal 1, rd.incr(rd.capa - 1)
+    assert_raises(ArgumentError) { rd[rd.capa] }
+  end
+
+  def test_resize_mremap
+    rd = Raindrops.new(4)
+    assert_equal 4, rd.size
+    old_capa = rd.capa
+    rd.size = rd.capa + 1
+    assert_equal old_capa * 2, rd.capa
+
+    # mremap() is currently broken with MAP_SHARED
+    # https://bugzilla.kernel.org/show_bug.cgi?id=8691
+    assert_equal 0, rd[old_capa]
+    assert_equal rd.capa, rd.to_ary.size
+    assert_equal 0, rd[rd.capa - 1]
+    assert_equal 1, rd.incr(rd.capa - 1)
+    assert_raises(ArgumentError) { rd[rd.capa] }
+  rescue RangeError
+  end # if RUBY_PLATFORM =~ /linux/
+
+  def test_evaporate
+    rd = Raindrops.new 1
+    assert_nil rd.evaporate!
+    assert_raises(StandardError) { rd.evaporate! }
+  end
+
+  def test_evaporate_with_fork
+    tmp = Raindrops.new 2
+    pid = fork do
+      tmp.incr 0
+      exit(tmp.evaporate! == nil)
+    end
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    assert_equal [ 1, 0 ], tmp.to_ary
+    tmp.incr 1
+    assert_equal [ 1, 1 ], tmp.to_ary
+    pid = fork do
+      tmp.incr 1
+      exit([ 1, 2 ] == tmp.to_ary)
+    end
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    assert_equal [ 1, 2 ], tmp.to_ary
+  end
+
+  def test_io_backed
+    file = Tempfile.new('test_io_backed')
+    rd = Raindrops.new(4, io: file, zero: true)
+    rd[0] = 123
+    rd[1] = 456
+
+    assert_equal 123, rd[0]
+    assert_equal 456, rd[1]
+
+    rd.evaporate!
+
+    file.rewind
+    data = file.read
+    assert_equal 123, data.unpack('L!')[0]
+    assert_equal 456, data[Raindrops::SIZE..data.size].unpack('L!')[0]
+  end
+
+  def test_io_backed_reuse
+    file = Tempfile.new('test_io_backed')
+    rd = Raindrops.new(4, io: file, zero: true)
+    rd[0] = 123
+    rd[1] = 456
+    rd.evaporate!
+
+    rd = Raindrops.new(4, io: file, zero: false)
+    assert_equal 123, rd[0]
+    assert_equal 456, rd[1]
+  end
+
+  def test_iobacked_noreuse
+    file = Tempfile.new('test_io_backed')
+    rd = Raindrops.new(4, io: file, zero: true)
+    rd[0] = 123
+    rd[1] = 456
+    rd.evaporate!
+
+    rd = Raindrops.new(4, io: file, zero: true)
+    assert_equal 0, rd[0]
+    assert_equal 0, rd[1]
+  end
+end