t/test-lib.sh

   1 #!/bin/sh
   2 # Copyright (c) 2009 Rainbows! developers
   3 . ./my-tap-lib.sh
   4
   5 set +u
   6 if test -z "$model"
   7 then
   8         # defaulting to Base would unfortunately fail some concurrency tests
   9         model=ThreadSpawn
  10         t_info "model undefined, defaulting to $model"
  11 fi
  12
  13 set -e
  14 RUBY="${RUBY-ruby}"
  15 RUBY_VERSION=${RUBY_VERSION-$($RUBY -e 'puts RUBY_VERSION')}
  16 t_pfx=$PWD/trash/$model.$T-$RUBY_VERSION
  17 set -u
  18
  19 PATH=$PWD/bin:$PATH
  20 export PATH
  21
  22 test -x $PWD/bin/unused_listen || die "must be run in 't' directory"
  23
  24 wait_for_pid () {
  25         path="$1"
  26         nr=30
  27         while ! test -s "$path" && test $nr -gt 0
  28         do
  29                 nr=$(($nr - 1))
  30                 sleep 1
  31         done
  32 }
  33
  34 # requires $1 and prints out the value of $2
  35 require_check () {
  36         lib=$1
  37         const=$2
  38         if ! $RUBY -r$lib -e "puts $const" >/dev/null 2>&1
  39         then
  40                 t_info "skipping $T since we don't have $lib"
  41                 exit 0
  42         fi
  43 }
  44
  45 # given a list of variable names, create temporary files and assign
  46 # the pathnames to those variables
  47 rtmpfiles () {
  48         for id in "$@"
  49         do
  50                 name=$id
  51                 _tmp=$t_pfx.$id
  52                 eval "$id=$_tmp"
  53
  54                 case $name in
  55                 *fifo)
  56                         rm -f $_tmp
  57                         mkfifo $_tmp
  58                         T_RM_LIST="$T_RM_LIST $_tmp"
  59                         ;;
  60                 *socket)
  61                         rm -f $_tmp
  62                         T_RM_LIST="$T_RM_LIST $_tmp"
  63                         ;;
  64                 *)
  65                         > $_tmp
  66                         T_OK_RM_LIST="$T_OK_RM_LIST $_tmp"
  67                         ;;
  68                 esac
  69         done
  70 }
  71
  72 dbgcat () {
  73         id=$1
  74         eval '_file=$'$id
  75         echo "==> $id <=="
  76         sed -e "s/^/$id:/" < $_file
  77 }
  78
  79 check_stderr () {
  80         set +u
  81         _r_err=${1-${r_err}}
  82         set -u
  83         if grep -i Error $_r_err
  84         then
  85                 die "Errors found in $_r_err"
  86         elif grep SIGKILL $_r_err
  87         then
  88                 die "SIGKILL found in $_r_err"
  89         fi
  90 }
  91
  92 # rainbows_setup [ MODEL [ WORKER_CONNECTIONS ] ]
  93 rainbows_setup () {
  94         eval $(unused_listen)
  95         rtmpfiles unicorn_config pid r_err r_out fifo tmp ok
  96         cat > $unicorn_config <<EOF
  97 listen "$listen"
  98 pid "$pid"
  99 stderr_path "$r_err"
 100 stdout_path "$r_out"
 101
 102 # close my-tap-lib.sh FDs
 103 unless ENV['UNICORN_FD']
 104   IO.for_fd(3).close rescue nil
 105   IO.for_fd(4).close rescue nil
 106 end
 107
 108 before_fork do |server, worker|
 109   # test script will block while reading from $fifo,
 110   # so notify the script on the first worker we spawn
 111   # by opening the FIFO
 112   if worker.nr == 0
 113     File.open("$fifo", "wb") { |fp| fp.syswrite "START" }
 114   end
 115 end
 116 EOF
 117         {
 118                 # set a higher default for tests since we run heavily-loaded
 119                 # boxes and sometimes sleep 1s in tests
 120                 kato=5
 121                 echo 'Rainbows! do'
 122                 if test $# -ge 1
 123                 then
 124                         echo "  use :$1"
 125                         test $# -eq 2 && echo "  worker_connections $2"
 126                         if test $# -eq 3
 127                         then
 128                                 echo "  keepalive_timeout $3"
 129                         else
 130                                 echo "  keepalive_timeout $kato"
 131                         fi
 132                 else
 133                         echo "  use :$model"
 134                         echo "  keepalive_timeout $kato"
 135                 fi
 136                 echo end
 137         } >> $unicorn_config
 138 }
 139
 140 rainbows_wait_start () {
 141         # "cat $fifo" will block until the before_fork hook is called in
 142         # the Unicorn config file
 143         test xSTART = x"$(cat $fifo)"
 144         rainbows_pid=$(cat $pid)
 145 }
 146
 147 rsha1 () {
 148         _cmd="$(which sha1sum 2>/dev/null || :)"
 149         test -n "$_cmd" || _cmd="$(which openssl 2>/dev/null || :) sha1"
 150         test "$_cmd" != " sha1" || _cmd="$(which gsha1sum 2>/dev/null || :)"
 151
 152         # last resort, see comments in sha1sum.rb for reasoning
 153         test -n "$_cmd" || _cmd=sha1sum.rb
 154         expr "$($_cmd < random_blob)" : '\([a-f0-9]\{40\}\)'
 155 }
 156
 157 case $model in
 158 Rev) require_check rev Rev::VERSION ;;
 159 Revactor) require_check revactor Revactor::VERSION ;;
 160 EventMachine) require_check eventmachine EventMachine::VERSION ;;
 161 esac