test/test_mogstored_rack.rb

   1 # -*- encoding: binary -*-
   2 require "./test/fresh"
   3 begin
   4   require 'mogstored_rack'
   5   require 'unicorn'
   6   ok = true
   7 rescue LoadError
   8   ok = false
   9 end
  10
  11 class TestMogstoredRack < Test::Unit::TestCase
  12   include TestFreshSetup
  13   def setup
  14     setup_mogilefs
  15   end
  16
  17   def test_range_put_new_file
  18     add_host_device_domain
  19     client = MogileFS::MogileFS.new :hosts => @hosts, :domain => @domain
  20
  21     io = client.new_file "range0", :largefile => :content_range
  22     assert_nil io.close
  23     assert_equal "", client.get_file_data("range0")
  24
  25     io = client.new_file "writes", :largefile => :content_range
  26     %w(a b c d e).each { |x| io.write(x) }
  27     assert_nil io.close
  28     assert_equal "abcde", client.get_file_data("writes")
  29
  30     io = client.new_file "puts", :largefile => :content_range
  31     %w(a b c d e).each { |x| io.puts(x) }
  32     assert ! client.exist?("puts")
  33     assert_nil io.close
  34     assert_equal "a\nb\nc\nd\ne\n", client.get_file_data("puts")
  35   end
  36
  37   def test_stream_new_file
  38     add_host_device_domain
  39     client = MogileFS::MogileFS.new :hosts => @hosts, :domain => @domain
  40     client.new_file("chunky", :largefile => :stream) do |io|
  41       assert_instance_of MogileFS::NewFile::Stream, io
  42       assert_equal(5, io.write("HELLO"))
  43       assert_nil io.md5
  44     end
  45     assert_equal "HELLO", client.get_file_data("chunky")
  46
  47     io = client.new_file("puts", :largefile => :stream)
  48     assert_instance_of MogileFS::NewFile::Stream, io
  49     assert_equal io, IO.select(nil, [io])[1][0], "IO.select-able"
  50
  51     assert_nil(io.puts("PUTS!"))
  52     assert_nil(io.puts("PUTZ"))
  53     assert_nil io.close
  54     assert_equal "PUTS!\nPUTZ\n", client.get_file_data("puts")
  55
  56     io = client.new_file("putc", :largefile => :stream)
  57     assert_equal(0x20, io.putc(0x20))
  58     assert_nil io.close
  59     assert_equal " ", client.get_file_data("putc")
  60
  61     io = client.new_file("print splat", :largefile => :stream)
  62     io.print(1, 2, 3)
  63     assert_nil io.close
  64     assert_equal "123", client.get_file_data("print splat")
  65
  66     io = client.new_file("printf", :largefile => :stream)
  67     assert_nil io.printf("%x", 1638)
  68     assert_nil io.close
  69     assert_equal "666", client.get_file_data("printf")
  70
  71     io = client.new_file("syswrite", :largefile => :stream)
  72     assert_equal 4, io.syswrite("good")
  73     assert_equal 7, io.syswrite("morning")
  74     assert_nil io.close
  75     assert_equal "goodmorning", client.get_file_data("syswrite")
  76
  77     io = client.new_file("md5", :largefile=>:stream, :content_md5=>:trailer)
  78     assert_instance_of Digest::MD5, io.md5
  79     assert_nil io.puts("HIHI")
  80     assert_nil io.close
  81     assert_equal "HIHI\n", client.get_file_data("md5")
  82     assert_equal Digest::MD5.hexdigest("HIHI\n"), io.md5.hexdigest
  83
  84     io = client.new_file("<<", :largefile=>:stream)
  85     assert_equal(io, io << ">>")
  86     assert_nil io.close
  87     assert_equal ">>", client.get_file_data("<<")
  88   end
  89
  90   def test_stream_new_file_with_content_length
  91     add_host_device_domain
  92     client = MogileFS::MogileFS.new :hosts => @hosts, :domain => @domain
  93     io = client.new_file("clen", :largefile=>:stream,:content_length=>6)
  94     io << "HIHIHI"
  95     assert_nil io.close
  96     assert_equal "HIHIHI", client.get_file_data("clen")
  97
  98     io = client.new_file("clen", :largefile=>:stream,:content_length=>1)
  99     io << "FAIL"
 100     assert_raises(MogileFS::SizeMismatchError) { io.close }
 101     assert_equal "HIHIHI", client.get_file_data("clen")
 102
 103     io = client.new_file("md5", :largefile=>:stream,
 104                                 :content_length=>6, :content_md5=>:trailer)
 105     assert_equal(io, io << "MD5MD5")
 106     assert_nil io.close
 107     assert_equal "MD5MD5", client.get_file_data("md5")
 108     assert_equal Digest::MD5.hexdigest("MD5MD5"), io.md5.hexdigest
 109
 110     io = client.new_file("md5", :largefile=>:stream,
 111                                 :content_length=>6, :content_md5=>:trailer)
 112     assert_equal(io, io << "MD5MD")
 113     assert_raises(MogileFS::SizeMismatchError) { io.close }
 114     assert_equal Digest::MD5.hexdigest("MD5MD"), io.md5.hexdigest
 115   end
 116
 117   def test_md5_check
 118     add_host_device_domain
 119     client = MogileFS::MogileFS.new :hosts => @hosts, :domain => @domain
 120     node = "#@test_host:#@mogstored_http_port"
 121     pid = fork do
 122       # not modifying this hash in the same process
 123       MogileFS::HTTPFile::MD5_TRAILER_NODES[node] = true
 124       client.store_content("md5_me", nil, "HELLO WORLD")
 125     end
 126     _, status = Process.waitpid2(pid)
 127     assert status.success?, status.inspect
 128     assert_equal "HELLO WORLD", client.get_file_data("md5_me")
 129   end
 130
 131   def setup_mogstored
 132     @docroot = Dir.mktmpdir(["mogfresh", "docroot"])
 133     Dir.mkdir("#@docroot/dev1")
 134     Dir.mkdir("#@docroot/dev2")
 135     @mogstored_mgmt = TCPServer.new(@test_host, 0)
 136     @mogstored_http = TCPServer.new(@test_host, 0)
 137     @mogstored_mgmt_port = @mogstored_mgmt.addr[1]
 138     @mogstored_http_port = @mogstored_http.addr[1]
 139     @mogstored_conf = Tempfile.new(["mogstored", "conf"])
 140     @mogstored_pid = Tempfile.new(["mogstored", "pid"])
 141     @mogstored_conf.write <<EOF
 142 pidfile = #{@mogstored_pid.path}
 143 maxconns = 1000
 144 mgmtlisten = #@test_host:#{@mogstored_mgmt_port}
 145 server = none
 146 docroot = #@docroot
 147 EOF
 148     @mogstored_conf.flush
 149     @mogstored_mgmt.close
 150
 151     unicorn_setup
 152
 153     x!("mogstored", "--daemon", "--config=#{@mogstored_conf.path}")
 154     wait_for_port @mogstored_mgmt_port
 155   end
 156
 157   # I would use Rainbows! + *Threads + Ruby 1.9.3 in production
 158   def unicorn_setup
 159     @ru = Tempfile.new(%w(mogstored_rack .ru))
 160     @ru.write <<EOF
 161 run MogstoredRack.new("#@docroot")
 162 EOF
 163     @ru.flush
 164
 165     @unicorn_pid = Tempfile.new(%w(unicorn .pid))
 166     @unicorn_conf = Tempfile.new(%w(unicorn.conf .rb))
 167     @unicorn_stderr = Tempfile.new(%w(unicorn .stderr))
 168     @unicorn_stdout = Tempfile.new(%w(unicorn .stdout))
 169     @unicorn_conf.write <<EOF
 170 require "mogstored_rack"
 171 listen "#@test_host:#{@mogstored_http_port}"
 172 pid "#{@unicorn_pid.path}"
 173 stderr_path "#{@unicorn_stderr.path}"
 174 stdout_path "#{@unicorn_stdout.path}"
 175 rewindable_input false
 176 EOF
 177     @unicorn_conf.flush
 178
 179     @mogstored_http.close
 180     x!("unicorn", "-E", "deployment",
 181        "--daemon", "--config", @unicorn_conf.path, @ru.path)
 182     wait_for_port @mogstored_http_port
 183     40.times do
 184       break if File.size(@unicorn_pid.path) > 0
 185       sleep 0.1
 186     end
 187   end
 188
 189   def teardown
 190     pid = File.read(@unicorn_pid.path).to_i
 191     Process.kill(:QUIT, pid) if pid > 0
 192     teardown_mogilefs
 193     puts(@unicorn_stderr.read) if $DEBUG
 194   end
 195 end if ok && `which unicorn`.chomp.size > 0