mogilefs-client 2.2.0 → 3.0.0.rc1

data/lib/mogilefs/network.rb

@@ -1,107 +0,0 @@
-# -*- encoding: binary -*-
-require 'mogilefs'
-require 'socket'
-require 'mogilefs/util'
-
-module MogileFS::Network
-  # given an array of URIs, verify that at least one of them is accessible
-  # with the expected HTTP code within the timeout period (in seconds).
-  def verify_uris(uris = [], expect = '200', timeout = 2.00)
-    uri_socks = {}
-
-    # first, we asynchronously connect to all of them
-    uris.each do |uri|
-      sock = Socket.mogilefs_new_nonblock(uri.host, uri.port) rescue next
-      uri_socks[sock] = uri
-    end
-
-    # wait for at least one of them to finish connecting and send
-    # HTTP requests to the connected ones
-    sockets, timeout = get_writable_set(uri_socks, timeout)
-
-    # Await a response from the sockets we had written to, we only need one
-    # valid response, but we'll take more if they return simultaneously
-    sockets[0] ? get_readable_uris(sockets, uri_socks, expect, timeout) : []
-
-    ensure
-      uri_socks.keys.each { |sock| sock.close rescue nil }
-  end
-
-  private
-    include MogileFS::Util
-
-    # returns an array of writeable Sockets and leftover from timeout
-    def get_writable_set(uri_socks, timeout)
-      sockets = []
-      begin
-        t0 = Time.now
-        r = begin
-         IO.select(nil, uri_socks.keys, nil, timeout > 0 ? timeout : 0)
-        rescue
-          # get rid of bad descriptors
-          uri_socks.delete_if do |sock, uri|
-            begin
-              sock.recv_nonblock(1)
-              false # should never get here for HTTP, really...
-            rescue Errno::EAGAIN, Errno::EINTR
-              false
-            rescue
-              sock.close rescue nil
-              true
-            end
-          end
-          timeout -= (Time.now - t0)
-          retry if timeout >= 0
-        end
-
-        break unless r && r[1]
-
-        r[1].each do |sock|
-          begin
-            # we don't care about short/interrupted writes here, if the
-            # following request fails or blocks then the server is
-            # flat-out hopeless
-            sock.write_nonblock(
-              "HEAD #{uri_socks[sock].request_uri} HTTP/1.0\r\n\r\n")
-            sockets << sock
-          rescue
-            sock.close rescue nil
-          end
-        end
-
-        timeout -= (Time.now - t0)
-      end until (sockets[0] || timeout < 0)
-
-      [ sockets, timeout ]
-    end
-
-    # returns an array of URIs from uri_socks that are good
-    def get_readable_uris(sockets, uri_socks, expect, timeout)
-      ok_uris = []
-
-      begin
-        t0 = Time.now
-        r = IO.select(sockets, nil, nil, timeout > 0 ? timeout : 0) rescue nil
-
-        (r && r[0] ? r[0] : sockets).each do |sock|
-          buf = begin
-            sock.recv_nonblock(128, Socket::MSG_PEEK)
-          rescue Errno::EAGAIN, Errno::EINTR
-            next
-          rescue
-            sockets.delete(sock) # socket went bad
-            next
-          end
-
-          if buf && /\AHTTP\/[\d\.]+ #{expect} / =~ buf
-            ok_uris << uri_socks.delete(sock)
-            sock.close rescue nil
-          end
-        end
-        timeout -= (Time.now - t0)
-      end until ok_uris[0] || timeout < 0
-
-      ok_uris
-    end
-
-end # module MogileFS::Network

data/test/test_network.rb

@@ -1,56 +0,0 @@
-# -*- encoding: binary -*-
-require 'test/setup'
-require 'mogilefs'
-require 'mogilefs/network'
-
-class TestNetwork < Test::Unit::TestCase
-  include MogileFS::Network
-
-  def test_verify_uris
-    good = TempServer.new(Proc.new do |serv,port|
-      client,client_addr = serv.accept
-      client.readpartial(4096)
-      client.syswrite("HTTP/1.0 200 OK\r\nContent-Length: 0\r\n\r\n")
-    end)
-    bad = TempServer.new(Proc.new do |serv,port|
-      client, client_addr = serv.accept
-      client.close rescue nil
-    end)
-
-    good_uri = URI.parse("http://127.0.0.1:#{good.port}/")
-    bad_uri = URI.parse("http://127.0.0.1:#{bad.port}/")
-    ok = verify_uris([ good_uri, bad_uri ])
-    assert_equal [ good_uri ], ok
-    ensure
-      TempServer.destroy_all!
-  end
-
-  def test_verify_non_existent
-    good = TempServer.new(Proc.new do |serv,port|
-      client,client_addr = serv.accept
-      client.readpartial(4096)
-      client.syswrite("HTTP/1.0 200 OK\r\nContent-Length: 0\r\n\r\n")
-    end)
-    bad = TempServer.new(Proc.new { |serv,port| serv.close })
-
-    good_uri = URI.parse("http://127.0.0.1:#{good.port}/")
-    bad_uri = URI.parse("http://127.0.0.1:#{bad.port}/")
-    ok = verify_uris([ good_uri, bad_uri ])
-    assert_equal [ good_uri ], ok
-    ensure
-      TempServer.destroy_all!
-  end
-
-  def test_verify_all_bad
-    good = TempServer.new(Proc.new { |serv,port| serv.close })
-    bad = TempServer.new(Proc.new { |serv,port| serv.close })
-
-    good_uri = URI.parse("http://127.0.0.1:#{good.port}/")
-    bad_uri = URI.parse("http://127.0.0.1:#{bad.port}/")
-    ok = verify_uris([ good_uri, bad_uri ], '200', 1.0)
-    assert ok.empty?, "nothing returned"
-    ensure
-      TempServer.destroy_all!
-  end
-
-end

data/test/test_util.rb

@@ -1,121 +0,0 @@
-# -*- encoding: binary -*-
-require 'test/setup'
-
-class TestMogileFS__Util < Test::Unit::TestCase
-  include MogileFS::Util
-
-  def test_mogilefs_write
-    rd, wr = IO.pipe
-
-    svr = Proc.new do |serv, port|
-      client, client_addr = serv.accept
-      client.sync = true
-      nr = 0
-      loop do
-        begin
-          nr += client.readpartial(16384).length
-        rescue EOFError
-          break
-        end
-      end
-      wr.syswrite("#{nr}\n")
-      client.close rescue nil
-    end
-    t = TempServer.new(svr)
-    s = Socket.mogilefs_new('127.0.0.1', t.port)
-    tmp = s.getsockopt(Socket::SOL_SOCKET, Socket::SO_SNDBUF)
-    sndbuf_bytes = tmp.unpack('i')[0]
-    big_string = ' ' * (sndbuf_bytes * 10)
-
-    sent = s.send(big_string, 0)
-    assert(sent < big_string.length)
-
-    syswrite_full(s, big_string)
-    s.close rescue nil
-    IO.select([rd])
-    assert_equal((sent + big_string.length), rd.sysread(4096).to_i)
-    ensure
-      t.destroy!
-  end
-
-  def test_write_timeout
-    svr = Proc.new do |serv, port|
-      client, client_addr = serv.accept
-      client.sync = true
-      readed = client.readpartial(16384)
-      sleep
-    end
-    t = TempServer.new(svr)
-    s = Socket.mogilefs_new('127.0.0.1', t.port)
-    tmp = s.getsockopt(Socket::SOL_SOCKET, Socket::SO_SNDBUF)
-    sndbuf_bytes = tmp.unpack('i')[0]
-    big_string = ' ' * (sndbuf_bytes * 10)
-
-    assert_raises(MogileFS::Timeout) { syswrite_full(s, big_string, 0.1) }
-    s.close rescue nil
-    ensure
-      t.destroy!
-  end
-
-  def test_sysread_slowly
-    nr = 10
-    str = 'abcde'
-    expect = str * nr
-    rd, wr = IO.pipe
-    pid = fork do
-      rd.close
-      nr.times do
-        syswrite_full(wr, str)
-        sleep(0.1)
-      end
-    end
-    wr.close
-    buf = sysread_full(rd, expect.size)
-    assert_equal expect, buf
-    rd.close
-    ensure
-      Process.kill('TERM', pid) rescue nil
-      Process.waitpid(pid) rescue nil
-  end
-
-  def test_sysread_timeout
-    nr = 10
-    str = 'abcde'
-    expect = str * nr
-    rd, wr = IO.pipe
-    pid = fork do
-      rd.close
-      nr.times do
-        syswrite_full(wr, str)
-        sleep 1
-      end
-    end
-    wr.close
-    assert_raises(MogileFS::Timeout) { sysread_full(rd, expect.size, 0.1) }
-    rd.close
-    ensure
-      Process.kill('TERM', pid) rescue nil
-      Process.waitpid(pid) rescue nil
-  end
-
-  def test_sysread_full_timeout
-    nr = 100
-    str = 'abcde'
-    expect = str * nr
-    rd, wr = IO.pipe
-    pid = fork do
-      rd.close
-      nr.times do
-        syswrite_full(wr, str)
-        sleep 0.01
-      end
-    end
-    wr.close
-    assert_raises(MogileFS::Timeout) { sysread_full(rd,expect.size,0.1,true) }
-    rd.close
-    ensure
-      Process.kill('TERM', pid) rescue nil
-      Process.waitpid(pid) rescue nil
-  end
-
-end