mogilefs-client 1.3.1 → 2.0.0

data/lib/mogilefs/network.rb

@@ -0,0 +1,64 @@
+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 = {}
+    ok_uris = []
+    sockets = []
+
+    # 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
+    begin
+      t0 = Time.now
+      r = IO.select(nil, uri_socks.keys, nil, timeout > 0 ? timeout : 0)
+      timeout -= (Time.now - t0)
+      break unless r && r[1]
+      r[1].each do |sock|
+        begin
+          # we don't about short/interrupted writes here, if the following
+          # request fails or blocks then the server is flat-out hopeless
+          sock.syswrite "HEAD #{uri_socks[sock].request_uri} HTTP/1.0\r\n\r\n"
+          sockets << sock
+        rescue
+          sock.close rescue nil
+        end
+      end
+    end until sockets[0] || timeout < 0
+
+    # 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
+    if sockets[0]
+      begin
+        t0 = Time.now
+        r = IO.select(sockets, nil, nil, timeout > 0 ? timeout : 0)
+        timeout -= (Time.now - t0)
+        break unless r && r[0]
+        r[0].each do |sock|
+          buf = sock.recv_nonblock(128, Socket::MSG_PEEK) rescue next
+          if buf && /\AHTTP\/[\d\.]+ #{expect} / =~ buf
+            ok_uris << uri_socks.delete(sock)
+            sock.close rescue nil
+          end
+        end
+      end
+    end until ok_uris[0] || timeout < 0
+
+    ok_uris
+    ensure
+      uri_socks.keys.each { |sock| sock.close rescue nil }
+  end
+
+  private
+    include MogileFS::Util
+
+end # module MogileFS::Network

data/lib/mogilefs/pool.rb

@@ -19,7 +19,7 @@ class MogileFS::Pool
       object = @klass.new(*@args)
       @objects << object
     end
-    return object
+    object
   end
 
   def put(o)

data/lib/mogilefs/util.rb

@@ -1,30 +1,161 @@
+require 'mogilefs'
+require 'socket'
+
 module MogileFS::Util
 
   CHUNK_SIZE = 65536
 
   # for copying large files while avoiding GC thrashing as much as possible
-  def sysrwloop(io_rd, io_wr)
+  # writes the contents of io_rd into io_wr, running through filter if
+  # it is a Proc object.  The filter proc must respond to a string
+  # argument (and return a string) and to nil (possibly returning a
+  # string or nil).  This can be used to filter I/O through an
+  # Zlib::Inflate or Digest::MD5 object
+  def sysrwloop(io_rd, io_wr, filter = nil)
     copied = 0
     # avoid making sysread repeatedly allocate a new String
     # This is not well-documented, but both read/sysread can take
     # an optional second argument to use as the buffer to avoid
     # GC overhead of creating new strings in a loop
     buf = ' ' * CHUNK_SIZE # preallocate to avoid GC thrashing
-    io_wr.sync = true
+    io_rd.flush rescue nil # flush may be needed for sockets/pipes, be safe
+    io_wr.flush
+    io_rd.sync = io_wr.sync = true
     loop do
-      begin
+      b = begin
         io_rd.sysread(CHUNK_SIZE, buf)
-        loop do
-          w = io_wr.syswrite(buf)
-          copied += w
-          break if w == buf.size
-          buf = buf[w..-1]
-        end
+      rescue Errno::EAGAIN, Errno::EINTR
+        IO.select([io_rd], nil, nil, nil)
+        retry
       rescue EOFError
         break
       end
+      b = filter.call(b) if filter
+      copied += syswrite_full(io_wr, b)
+    end
+
+    # filter must take nil as a possible argument to indicate EOF
+    if filter
+      b = filter.call(nil)
+      copied += syswrite_full(io_wr, b) if b && b.length > 0
     end
     copied
   end # sysrwloop
 
+  # writes the contents of buf to io_wr in full w/o blocking
+  def syswrite_full(io_wr, buf, timeout = nil)
+    written = 0
+    loop do
+      begin
+        w = io_wr.syswrite(buf)
+        written += w
+        return written if w == buf.size
+        buf = buf[w..-1]
+
+        # a short syswrite means the next syswrite will likely block
+        # inside the interpreter.  so force an IO.select on it so we can
+        # timeout there if one was specified
+        raise Errno::EAGAIN if timeout
+      rescue Errno::EAGAIN, Errno::EINTR
+        t0 = Time.now if timeout
+        IO.select(nil, [io_wr], nil, timeout)
+        if timeout && ((timeout -= (Time.now - t0)) < 0)
+          raise MogileFS::Timeout, 'syswrite_full timeout'
+        end
+      end
+    end
+    # should never get here
+  end
+
+end
+
+require 'timeout'
+##
+# Timeout error class.  Subclassing it from Timeout::Error is the only
+# reason we require the 'timeout' module, otherwise that module is
+# broken and worthless to us.
+class MogileFS::Timeout < Timeout::Error; end
+
+class Socket
+  attr_accessor :mogilefs_addr, :mogilefs_connected
+
+  TCP_CORK = 3 if ! defined?(TCP_CORK) && RUBY_PLATFORM =~ /linux/
+
+  def mogilefs_tcp_cork=(set)
+    if defined?(TCP_CORK)
+      self.setsockopt(SOL_TCP, TCP_CORK, set ? 1 : 0) rescue nil
+    end
+    set
+  end
+
+  # Socket lacks peeraddr method of the IPSocket/TCPSocket classes
+  def mogilefs_peername
+    Socket.unpack_sockaddr_in(getpeername).reverse.map {|x| x.to_s }.join(':')
+  end
+
+  def mogilefs_init(host = nil, port = nil)
+    return true if defined?(@mogilefs_connected)
+
+    @mogilefs_addr = Socket.sockaddr_in(port, host).freeze if port && host
+
+    begin
+      connect_nonblock(@mogilefs_addr)
+      @mogilefs_connected = true
+    rescue Errno::EINPROGRESS
+      nil
+    rescue Errno::EISCONN
+      @mogilefs_connected = true
+    end
+  end
+
+  class << self
+
+    # Creates a new (TCP) Socket and initiates (but does not wait for) the
+    # connection
+    def mogilefs_new_nonblock(host, port)
+      sock = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+      sock.sync = true
+      if defined?(Socket::TCP_NODELAY)
+        sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+      end
+      sock.mogilefs_init(host, port)
+      sock
+    end
+
+    # Like TCPSocket.new(host, port), but with an explicit timeout
+    # (and we don't care for local address/port we're binding to).
+    # This raises MogileFS::Timeout if timeout expires
+    def mogilefs_new(host, port, timeout = 5.0)
+      sock = mogilefs_new_nonblock(host, port) or return sock
+
+      while timeout > 0
+        t0 = Time.now
+        r = IO.select(nil, [sock], nil, timeout)
+        return sock if r && r[1] && sock.mogilefs_init
+        timeout -= (Time.now - t0)
+      end
+
+      sock.close rescue nil
+      raise MogileFS::Timeout, 'socket write timeout'
+    end
+
+    include MogileFS::Util
+
+    # Makes a request on a new TCP Socket and returns with a readble socket
+    # within the given timeout.
+    # This raises MogileFS::Timeout if timeout expires
+    def mogilefs_new_request(host, port, request, timeout = 5.0)
+      t0 = Time.now
+      sock = mogilefs_new(host, port, timeout)
+      syswrite_full(sock, request, timeout)
+      timeout -= (Time.now - t0)
+      raise MogileFS::Timeout, 'socket read timeout' if timeout < 0
+      r = IO.select([sock], nil, nil, timeout)
+      return sock if r && r[0]
+      raise MogileFS::Timeout, 'socket read timeout'
+    end
+
+  end
+
 end
+

data/test/.gitignore

@@ -0,0 +1,2 @@
+*.log
+*.log+

data/test/aggregate.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/ruby -n
+BEGIN { $tests = $assertions = $failures = $errors = 0 }
+
+$_ =~ /(\d+) tests, (\d+) assertions, (\d+) failures, (\d+) errors/ or next
+$tests += $1.to_i
+$assertions += $2.to_i
+$failures += $3.to_i
+$errors += $4.to_i
+
+END {
+  printf("\n%d tests, %d assertions, %d failures, %d errors\n",
+         $tests, $assertions, $failures, $errors)
+}

data/test/setup.rb

@@ -1,12 +1,10 @@
+STDIN.sync = STDOUT.sync = STDERR.sync = true
 require 'test/unit'
 
 require 'fileutils'
 require 'tmpdir'
 require 'stringio'
 
-require 'rubygems'
-require 'test/zentest_assertions'
-
 $TESTING = true
 
 require 'mogilefs'
@@ -21,6 +19,14 @@ class FakeBackend
     @lasterrstr = nil
   end
 
+  def error(err_snake)
+    err_camel = err_snake.gsub(/(?:^|_)([a-z])/) { $1.upcase } << 'Error'
+    unless MogileFS::Backend.const_defined?(err_camel)
+      MogileFS::Backend.class_eval("class #{err_camel} < MogileFS::Error; end")
+    end
+    MogileFS::Backend.const_get(err_camel)
+  end
+
   def method_missing(meth, *args)
     meth = meth.to_s
     if meth =~ /(.*)=$/ then
@@ -31,6 +37,7 @@ class FakeBackend
       when Array then
         @lasterr = response.first
         @lasterrstr = response.last
+        raise error(@lasterr), @lasterrstr
         return nil
       end
       return response
@@ -39,90 +46,36 @@ class FakeBackend
 
 end
 
-class FakeSocket
-
-  attr_reader :read_s
-  attr_reader :write_s
-  attr_reader :sync
-
-  def initialize(read = '', write = StringIO.new)
-    @read_s = read.class.method_defined?(:sysread) ? read : StringIO.new(read)
-    @write_s = write
-    @closed = false
-    @sync = false
-  end
-
-  def sync=(do_sync)
-    @write_s.sync = do_sync
-    @read_s.sync = do_sync
-  end
-
-  def closed?
-    @closed
-  end
-
-  def close
-    @closed = true
-    return nil
-  end
-
-  def gets
-    @read_s.gets
-  end
-
-  def peeraddr
-    ['AF_INET', 6001, 'localhost', '127.0.0.1']
-  end
-
-  def read(bytes)
-    @read_s.read bytes
-  end
-
-  def sysread(bytes, buf = '')
-    @read_s.sysread bytes, buf
-  end
-
-  def recv_nonblock(bytes, flags = 0)
-    ret = @read_s.sysread(bytes)
-    # Ruby doesn't expose pread(2)
-    if (flags & Socket::MSG_PEEK) != 0
-      @read_s.sysseek(-ret.size, IO::SEEK_CUR)
-    end
-    ret
-  end
-  alias_method :recv, :recv_nonblock
-
-  def write(data)
-    @write_s.write data
-  end
-
-  def syswrite(data)
-    @write_s.syswrite data
-  end
-
-end
-
 class MogileFS::Client
   attr_writer :readonly
 end
 
-class TCPSocket
-
-  class << self
-
-    attr_accessor :connections
-    attr_accessor :sockets
-
-    alias old_new new
-
-    def new(host, port)
-      raise Errno::ECONNREFUSED if @sockets.empty?
-      @connections << [host, port]
-      @sockets.pop
+require 'socket'
+class TempServer
+  attr_reader :port
+
+  def self.destroy_all!
+    ObjectSpace.each_object(TempServer) { |t| t.destroy! }
+  end
+
+  def initialize(server_proc)
+    @thr = @port = @sock = nil
+    retries = 0
+    begin
+      @port = 1024 + rand(32768 - 1024)
+      @sock = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+      @sock.bind(Socket.pack_sockaddr_in(@port, '127.0.0.1'))
+      @sock.listen(5)
+    rescue Errno::EADDRINUSE, Errno::EACCES
+      @sock.close rescue nil
+      retry if (retries += 1) < 10
     end
+    @thr = Thread.new(@sock, @port) { |s,p| server_proc.call(s, p) }
+  end
 
-    alias open new
-
+  def destroy!
+    @sock.close rescue nil
+    Thread.kill(@thr) rescue nil
   end
 
 end
@@ -132,22 +85,50 @@ class TestMogileFS < Test::Unit::TestCase
   undef_method :default_test
 
   def setup
-    @tempdir = File.join Dir.tmpdir, "test_mogilefs_#{$$}"
-    @root = File.join @tempdir, 'root'
-    FileUtils.mkdir_p @root
-
-    @client = @klass.new :hosts => ['kaa:6001'], :domain => 'test',
-                                  :root => @root
+    @client = @klass.new :hosts => ['kaa:6001'], :domain => 'test'
     @backend = FakeBackend.new
     @client.instance_variable_set '@backend', @backend
+  end
+
+end
+
+# for our mock results
+class Array
+  alias_method :fetch_row, :shift
+end
+
+class FakeMysql
+  attr_reader :expect
+  TBL_DEVICES = [
+    # devid, hostip,    altip,         http_port, http_get_port
+    [ 1,    '10.0.0.1', '192.168.0.1', 7500,      7600 ],
+    [ 2,    '10.0.0.2', '192.168.0.2', 7500,      7600 ],
+    [ 3,    '10.0.0.3', nil,           7500,      nil ],
+    [ 4,    '10.0.0.4', nil,           7500,      nil ],
+  ]
+  TBL_DOMAINS = [
+    # dmid, namespace
+    [ 1, 'test' ],
+    [ 2, 'foo' ],
+  ]
 
-    TCPSocket.sockets = []
-    TCPSocket.connections = []
+  def initialize
+    @expect = []
+  end
+
+  def quote(str)
+    str.to_s.gsub(/\\/, '\&\&').gsub(/'/, "''")
   end
 
-  def teardown
-    FileUtils.rm_rf @tempdir
+  def query(sql = '')
+    case sql
+    when MogileFS::Mysql::GET_DEVICES then TBL_DEVICES
+    when MogileFS::Mysql::GET_DOMAINS then TBL_DOMAINS
+    else
+      @expect.shift
+    end
   end
 
 end
 
+