test/test_helper.rb

   1 # -*- encoding: binary -*-
   2
   3 # Copyright (c) 2005 Zed A. Shaw
   4 # You can redistribute it and/or modify it under the same terms as Ruby 1.8 or
   5 # the GPLv3
   6 #
   7 # Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html
   8 # for more information.
   9
  10 STDIN.sync = STDOUT.sync = STDERR.sync = true # buffering makes debugging hard
  11
  12 # FIXME: move curl-dependent tests into t/
  13 ENV['NO_PROXY'] ||= ENV['UNICORN_TEST_ADDR'] || '127.0.0.1'
  14
  15 # Some tests watch a log file or a pid file to spring up to check state
  16 # Can't rely on inotify on non-Linux and logging to a pipe makes things
  17 # more complicated
  18 DEFAULT_TRIES = 1000
  19 DEFAULT_RES = 0.2
  20
  21 require 'test/unit'
  22 require 'net/http'
  23 require 'digest/sha1'
  24 require 'uri'
  25 require 'stringio'
  26 require 'pathname'
  27 require 'tempfile'
  28 require 'fileutils'
  29 require 'logger'
  30 require 'unicorn'
  31
  32 if ENV['DEBUG']
  33   require 'ruby-debug'
  34   Debugger.start
  35 end
  36
  37 def redirect_test_io
  38   orig_err = STDERR.dup
  39   orig_out = STDOUT.dup
  40   STDERR.reopen("test_stderr.#{$$}.log", "a")
  41   STDOUT.reopen("test_stdout.#{$$}.log", "a")
  42   STDERR.sync = STDOUT.sync = true
  43
  44   at_exit do
  45     File.unlink("test_stderr.#{$$}.log") rescue nil
  46     File.unlink("test_stdout.#{$$}.log") rescue nil
  47   end
  48
  49   begin
  50     yield
  51   ensure
  52     STDERR.reopen(orig_err)
  53     STDOUT.reopen(orig_out)
  54   end
  55 end
  56
  57 # which(1) exit codes cannot be trusted on some systems
  58 # We use UNIX shell utilities in some tests because we don't trust
  59 # ourselves to write Ruby 100% correctly :)
  60 def which(bin)
  61   ex = ENV['PATH'].split(/:/).detect do |x|
  62     x << "/#{bin}"
  63     File.executable?(x)
  64   end or warn "`#{bin}' not found in PATH=#{ENV['PATH']}"
  65   ex
  66 end
  67
  68 # Either takes a string to do a get request against, or a tuple of [URI, HTTP] where
  69 # HTTP is some kind of Net::HTTP request object (POST, HEAD, etc.)
  70 def hit(uris)
  71   results = []
  72   uris.each do |u|
  73     res = nil
  74
  75     if u.kind_of? String
  76       u = 'http://127.0.0.1:8080/' if u == 'http://0.0.0.0:8080/'
  77       res = Net::HTTP.get(URI.parse(u))
  78     else
  79       url = URI.parse(u[0])
  80       res = Net::HTTP.new(url.host, url.port).start {|h| h.request(u[1]) }
  81     end
  82
  83     assert res != nil, "Didn't get a response: #{u}"
  84     results << res
  85   end
  86
  87   return results
  88 end
  89
  90 # unused_port provides an unused port on +addr+ usable for TCP that is
  91 # guaranteed to be unused across all unicorn builds on that system.  It
  92 # prevents race conditions by using a lock file other unicorn builds
  93 # will see.  This is required if you perform several builds in parallel
  94 # with a continuous integration system or run tests in parallel via
  95 # gmake.  This is NOT guaranteed to be race-free if you run other
  96 # processes that bind to random ports for testing (but the window
  97 # for a race condition is very small).  You may also set UNICORN_TEST_ADDR
  98 # to override the default test address (127.0.0.1).
  99 def unused_port(addr = '127.0.0.1')
 100   retries = 100
 101   base = 5000
 102   port = sock = nil
 103   begin
 104     begin
 105       port = base + rand(32768 - base)
 106       while port == Unicorn::Const::DEFAULT_PORT
 107         port = base + rand(32768 - base)
 108       end
 109
 110       sock = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
 111       sock.bind(Socket.pack_sockaddr_in(port, addr))
 112       sock.listen(5)
 113     rescue Errno::EADDRINUSE, Errno::EACCES
 114       sock.close rescue nil
 115       retry if (retries -= 1) >= 0
 116     end
 117
 118     # since we'll end up closing the random port we just got, there's a race
 119     # condition could allow the random port we just chose to reselect itself
 120     # when running tests in parallel with gmake.  Create a lock file while
 121     # we have the port here to ensure that does not happen .
 122     lock_path = "#{Dir::tmpdir}/unicorn_test.#{addr}:#{port}.lock"
 123     File.open(lock_path, File::WRONLY|File::CREAT|File::EXCL, 0600).close
 124     at_exit { File.unlink(lock_path) rescue nil }
 125   rescue Errno::EEXIST
 126     sock.close rescue nil
 127     retry
 128   end
 129   sock.close rescue nil
 130   port
 131 end
 132
 133 def try_require(lib)
 134   begin
 135     require lib
 136     true
 137   rescue LoadError
 138     false
 139   end
 140 end
 141
 142 # sometimes the server may not come up right away
 143 def retry_hit(uris = [])
 144   tries = DEFAULT_TRIES
 145   begin
 146     hit(uris)
 147   rescue Errno::EINVAL, Errno::ECONNREFUSED => err
 148     if (tries -= 1) > 0
 149       sleep DEFAULT_RES
 150       retry
 151     end
 152     raise err
 153   end
 154 end
 155
 156 def assert_shutdown(pid)
 157   wait_master_ready("test_stderr.#{pid}.log")
 158   Process.kill(:QUIT, pid)
 159   pid, status = Process.waitpid2(pid)
 160   assert status.success?, "exited successfully"
 161 end
 162
 163 def wait_workers_ready(path, nr_workers)
 164   tries = DEFAULT_TRIES
 165   lines = []
 166   while (tries -= 1) > 0
 167     begin
 168       lines = File.readlines(path).grep(/worker=\d+ ready/)
 169       lines.size == nr_workers and return
 170     rescue Errno::ENOENT
 171     end
 172     sleep DEFAULT_RES
 173   end
 174   raise "#{nr_workers} workers never became ready:" \
 175         "\n\t#{lines.join("\n\t")}\n"
 176 end
 177
 178 def wait_master_ready(master_log)
 179   tries = DEFAULT_TRIES
 180   while (tries -= 1) > 0
 181     begin
 182       File.readlines(master_log).grep(/master process ready/)[0] and return
 183     rescue Errno::ENOENT
 184     end
 185     sleep DEFAULT_RES
 186   end
 187   raise "master process never became ready"
 188 end
 189
 190 def reexec_usr2_quit_test(pid, pid_file)
 191   assert File.exist?(pid_file), "pid file OK"
 192   assert ! File.exist?("#{pid_file}.oldbin"), "oldbin pid file"
 193   Process.kill(:USR2, pid)
 194   retry_hit(["http://#{@addr}:#{@port}/"])
 195   wait_for_file("#{pid_file}.oldbin")
 196   wait_for_file(pid_file)
 197
 198   old_pid = File.read("#{pid_file}.oldbin").to_i
 199   new_pid = File.read(pid_file).to_i
 200
 201   # kill old master process
 202   assert_not_equal pid, new_pid
 203   assert_equal pid, old_pid
 204   Process.kill(:QUIT, old_pid)
 205   retry_hit(["http://#{@addr}:#{@port}/"])
 206   wait_for_death(old_pid)
 207   assert_equal new_pid, File.read(pid_file).to_i
 208   retry_hit(["http://#{@addr}:#{@port}/"])
 209   Process.kill(:QUIT, new_pid)
 210 end
 211
 212 def reexec_basic_test(pid, pid_file)
 213   results = retry_hit(["http://#{@addr}:#{@port}/"])
 214   assert_equal String, results[0].class
 215   Process.kill(0, pid)
 216   master_log = "#{@tmpdir}/test_stderr.#{pid}.log"
 217   wait_master_ready(master_log)
 218   File.truncate(master_log, 0)
 219   nr = 50
 220   kill_point = 2
 221   nr.times do |i|
 222     hit(["http://#{@addr}:#{@port}/#{i}"])
 223     i == kill_point and Process.kill(:HUP, pid)
 224   end
 225   wait_master_ready(master_log)
 226   assert File.exist?(pid_file), "pid=#{pid_file} exists"
 227   new_pid = File.read(pid_file).to_i
 228   assert_not_equal pid, new_pid
 229   Process.kill(0, new_pid)
 230   Process.kill(:QUIT, new_pid)
 231 end
 232
 233 def wait_for_file(path)
 234   tries = DEFAULT_TRIES
 235   while (tries -= 1) > 0 && ! File.exist?(path)
 236     sleep DEFAULT_RES
 237   end
 238   assert File.exist?(path), "path=#{path} exists #{caller.inspect}"
 239 end
 240
 241 def xfork(&block)
 242   fork do
 243     ObjectSpace.each_object(Tempfile) do |tmp|
 244       ObjectSpace.undefine_finalizer(tmp)
 245     end
 246     yield
 247   end
 248 end
 249
 250 # can't waitpid on detached processes
 251 def wait_for_death(pid)
 252   tries = DEFAULT_TRIES
 253   while (tries -= 1) > 0
 254     begin
 255       Process.kill(0, pid)
 256       begin
 257         Process.waitpid(pid, Process::WNOHANG)
 258       rescue Errno::ECHILD
 259       end
 260       sleep(DEFAULT_RES)
 261     rescue Errno::ESRCH
 262       return
 263     end
 264   end
 265   raise "PID:#{pid} never died!"
 266 end
 267
 268 # executes +cmd+ and chunks its STDOUT
 269 def chunked_spawn(stdout, *cmd)
 270   fork {
 271     crd, cwr = IO.pipe
 272     crd.binmode
 273     cwr.binmode
 274     crd.sync = cwr.sync = true
 275
 276     pid = fork {
 277       STDOUT.reopen(cwr)
 278       crd.close
 279       cwr.close
 280       exec(*cmd)
 281     }
 282     cwr.close
 283     begin
 284       buf = crd.readpartial(16384)
 285       stdout.write("#{'%x' % buf.size}\r\n#{buf}")
 286     rescue EOFError
 287       stdout.write("0\r\n")
 288       pid, status = Process.waitpid(pid)
 289       exit status.exitstatus
 290     end while true
 291   }
 292 end
 293
 294 def reset_sig_handlers
 295   sigs = %w(CHLD).concat(Unicorn::HttpServer::QUEUE_SIGS)
 296   sigs.each { |sig| trap(sig, "DEFAULT") }
 297 end