mogilefs-client 1.0.1

data/lib/mogilefs/pool.rb

@@ -0,0 +1,50 @@
+require 'thread'
+require 'mogilefs'
+
+class MogileFS::Pool
+
+  class BadObjectError < RuntimeError; end
+
+  def initialize(klass, *args)
+    @args = args
+    @klass = klass
+    @queue = Queue.new
+    @objects = []
+  end
+
+  def get
+    begin
+      object = @queue.pop true
+    rescue ThreadError
+      object = @klass.new(*@args)
+      @objects << object
+    end
+    return object
+  end
+
+  def put(o)
+    raise BadObjectError unless @objects.include? o
+    @queue.push o
+    purge
+  end
+
+  def use
+    object = get
+    yield object
+  ensure
+    put object
+  end
+
+  def purge
+    return if @queue.length < 5
+    begin
+      until @queue.length <= 2 do
+        obj = @queue.pop true
+        @objects.delete obj
+      end
+    rescue ThreadError
+    end
+  end
+
+end
+

data/test/setup.rb

@@ -0,0 +1,55 @@
+require 'test/unit'
+
+$TESTING = true
+
+require 'mogilefs'
+
+class FakeBackend
+
+  attr_reader :lasterr, :lasterrstr
+
+  def initialize
+    @responses = {}
+    @lasterr = nil
+    @lasterrstr = nil
+  end
+
+  def method_missing(sym, *args)
+    sym = sym.to_s
+    if sym =~ /(.*)=$/ then
+      @responses[$1] = args.first
+    else
+      response = @responses[sym]
+      case response
+      when Hash then
+        return response
+      when Array then
+        @lasterr = response.first
+        @lasterrstr = response.last
+        return nil
+      end
+    end
+  end
+
+end
+
+class MogileFS::Client
+  attr_writer :readonly
+end
+
+class TestMogileFS < Test::Unit::TestCase
+
+  def setup
+    return if self.class == TestMogileFS
+    @root = '/mogilefs/test'
+    @client = @class.new :hosts => ['kaa:6001'], :domain => 'test',
+                                  :root => @root
+    @backend = FakeBackend.new
+    @client.instance_variable_set '@backend', @backend
+  end
+
+  def test_nothing
+  end
+
+end
+

data/test/test_admin.rb

@@ -0,0 +1,37 @@
+require 'test/setup'
+
+class TestMogileFS__Admin < TestMogileFS
+
+  def setup
+    @class = MogileFS::Admin
+    super
+  end
+
+  def test_clean
+    res = {"host1_remoteroot"=>"/mnt/mogilefs/rur-1",
+           "host1_hostname"=>"rur-1",
+           "host1_hostid"=>"1",
+           "host1_http_get_port"=>"",
+           "host1_altip"=>"",
+           "hosts"=>"1",
+           "host1_hostip"=>"",
+           "host1_http_port"=>"",
+           "host1_status"=>"alive",
+           "host1_altmask"=>""}
+    actual = @client.clean 'hosts', 'host', res
+  
+    expected = [{"status"=>"alive",
+                 "http_get_port"=>"",
+                 "http_port"=>"",
+                 "hostid"=>"1",
+                 "hostip"=>"",
+                 "hostname"=>"rur-1",
+                 "remoteroot"=>"/mnt/mogilefs/rur-1",
+                 "altip"=>"",
+                 "altmask"=>""}]
+
+    assert_equal expected, actual
+  end
+
+end
+

data/test/test_backend.rb

@@ -0,0 +1,208 @@
+require 'test/unit'
+
+$TESTING = true
+
+require 'mogilefs/backend'
+
+class MogileFS::Backend
+
+  attr_accessor :hosts
+  attr_reader :timeout, :dead
+  attr_writer :lasterr, :lasterrstr, :socket
+
+end
+
+class FakeSocket
+
+  def initialize
+    @closed = false
+  end
+
+  def closed?
+    @closed
+  end
+
+  def close
+    @closed = true
+    return nil
+  end
+
+end
+
+class TestBackend < Test::Unit::TestCase
+
+  def setup
+    @backend = MogileFS::Backend.new :hosts => ['localhost:6001']
+  end
+
+  def test_initialize
+    assert_raises ArgumentError do MogileFS::Backend.new end
+    assert_raises ArgumentError do MogileFS::Backend.new :hosts => [] end
+    assert_raises ArgumentError do MogileFS::Backend.new :hosts => [''] end
+
+    assert_equal ['localhost:6001'], @backend.hosts
+    assert_equal 3, @backend.timeout
+    assert_equal nil, @backend.lasterr
+    assert_equal nil, @backend.lasterrstr
+    assert_equal({}, @backend.dead)
+
+    @backend = MogileFS::Backend.new :hosts => ['localhost:6001'], :timeout => 1
+    assert_equal 1, @backend.timeout
+  end
+
+  def test_do_request
+    socket_request = ''
+    socket = Object.new
+    def socket.closed?() false end
+    def socket.send(request, flags) return request.length end
+    def @backend.select(*args) return [true] end
+    def socket.gets() return 'OK 1 you=win' end
+
+    @backend.instance_variable_set '@socket', socket
+
+    assert_equal({'you' => 'win'},
+                 @backend.do_request('go!', { 'fight' => 'team fight!' }))
+  end
+
+  def test_do_request_send_error
+    socket_request = ''
+    socket = Object.new
+    def socket.closed?() false end
+    def socket.send(request, flags) raise SystemCallError, 'dummy' end
+
+    @backend.instance_variable_set '@socket', socket
+
+    assert_raises RuntimeError do
+      @backend.do_request 'go!', { 'fight' => 'team fight!' }
+    end
+
+    assert_equal nil, @backend.instance_variable_get('@socket')
+  end
+
+  def test_do_request_truncated
+    socket_request = ''
+    socket = Object.new
+    def socket.closed?() false end
+    def socket.send(request, flags) return request.length - 1 end
+
+    @backend.instance_variable_set '@socket', socket
+
+    assert_raises RuntimeError do
+      @backend.do_request 'go!', { 'fight' => 'team fight!' }
+    end
+  end
+
+  def test_make_request
+    assert_equal "go! fight=team+fight%21\r\n",
+                 @backend.make_request('go!', { 'fight' => 'team fight!' })
+  end
+
+  def test_parse_response
+    assert_equal({'foo' => 'bar', 'baz' => 'hoge'},
+                 @backend.parse_response('OK 1 foo=bar&baz=hoge'))
+    assert_equal nil, @backend.parse_response('ERR you totally suck')
+    assert_equal 'you', @backend.lasterr
+    assert_equal 'totally suck', @backend.lasterrstr
+
+    assert_raises RuntimeError do
+      @backend.parse_response 'garbage'
+    end
+  end
+
+  def test_readable_eh_readable
+    socket = Object.new
+    def socket.closed?() false end
+    def @backend.select(*args) return [true] end
+    @backend.instance_variable_set '@socket', socket
+
+    assert_equal true, @backend.readable?
+  end
+
+  def test_readable_eh_not_readable
+    socket = Object.new
+    def socket.closed?() false end
+    def @backend.select(*args) return [] end
+    @backend.instance_variable_set '@socket', socket
+
+    assert_raises MogileFS::UnreadableSocketError do @backend.readable? end
+  end
+
+  def test_socket
+    assert_equal({}, @backend.dead)
+    assert_raises RuntimeError do @backend.socket end
+    assert_equal(['localhost:6001'], @backend.dead.keys)
+  end
+
+  def test_socket_robust
+    @backend.hosts = ['localhost:6001', 'localhost:6002']
+    def @backend.connect_to(host, port)
+      @first = (defined? @first) ? false : true
+      raise Errno::ECONNREFUSED if @first
+    end
+
+    assert_equal({}, @backend.dead)
+    @backend.socket
+    assert_equal false, @backend.dead.keys.empty?
+  end
+
+  def test_shutdown
+    fake_socket = FakeSocket.new
+    @backend.socket = fake_socket
+    assert_equal fake_socket, @backend.socket
+    @backend.shutdown
+    assert_equal nil, @backend.instance_variable_get(:@socket)
+  end
+
+  def test_url_decode
+    assert_equal({"\272z" => "\360opy", "f\000" => "\272r"},
+                 @backend.url_decode("%baz=%f0opy&f%00=%bar"))
+  end
+
+  def test_url_encode
+    params = [["f\000", "\272r"], ["\272z", "\360opy"]]
+    assert_equal "f%00=%bar&%baz=%f0opy", @backend.url_encode(params)
+  end
+
+  def test_url_escape # \n for unit_diff
+    actual = (0..255).map { |c| @backend.url_escape c.chr }.join "\n"
+
+    expected = []
+    expected.push(*(0..0x1f).map { |c| "%%%0.2x" % c })
+    expected << '+'
+    expected.push(*(0x21..0x2b).map { |c| "%%%0.2x" % c })
+    expected.push(*%w[, - . /])
+    expected.push(*('0'..'9'))
+    expected.push(*%w[: %3b %3c %3d %3e %3f %40])
+    expected.push(*('A'..'Z'))
+    expected.push(*%w[%5b \\ %5d %5e _ %60])
+    expected.push(*('a'..'z'))
+    expected.push(*(0x7b..0xff).map { |c| "%%%0.2x" % c })
+
+    expected = expected.join "\n"
+
+    assert_equal expected, actual
+  end
+
+  def test_url_unescape
+    input = []
+    input.push(*(0..0x1f).map { |c| "%%%0.2x" % c })
+    input << '+'
+    input.push(*(0x21..0x2b).map { |c| "%%%0.2x" % c })
+    input.push(*%w[, - . /])
+    input.push(*('0'..'9'))
+    input.push(*%w[: %3b %3c %3d %3e %3f %40])
+    input.push(*('A'..'Z'))
+    input.push(*%w[%5b \\ %5d %5e _ %60])
+    input.push(*('a'..'z'))
+    input.push(*(0x7b..0xff).map { |c| "%%%0.2x" % c })
+
+    actual = input.map { |c| @backend.url_unescape c }.join "\n"
+
+    expected = (0..255).map { |c| c.chr }.join "\n"
+    expected.sub! '+', ' '
+
+    assert_equal expected, actual
+  end
+
+end
+

data/test/test_client.rb

@@ -0,0 +1,49 @@
+require 'test/unit'
+
+$TESTING = true
+
+require 'mogilefs'
+
+class TestClient < Test::Unit::TestCase
+
+  def setup
+    @client = MogileFS::Client.new :hosts => ['kaa:6001']
+  end
+
+  def test_initialize
+    assert_not_nil @client
+    assert_instance_of MogileFS::Backend, @client.backend
+    assert_equal ['kaa:6001'], @client.hosts
+  end
+
+  def test_err
+    @client.backend.lasterr = 'you'
+    assert_equal 'you', @client.err
+  end
+
+  def test_errstr
+    @client.backend.lasterrstr = 'totally suck'
+    assert_equal 'totally suck', @client.errstr
+  end
+
+  def test_reload
+    orig_backend = @client.backend
+
+    @client.hosts = ['ziz:6001']
+    @client.reload
+
+    assert_not_same @client.backend, orig_backend
+    assert_equal ['ziz:6001'], @client.backend.hosts
+  end
+
+  def test_readonly_eh_readonly
+    client = MogileFS::Client.new :hosts => ['kaa:6001'], :readonly => true
+    assert_equal true, client.readonly?
+  end
+
+  def test_readonly_eh_readwrite
+    assert_equal false, @client.readonly?
+  end
+
+end
+

data/test/test_mogilefs.rb

@@ -0,0 +1,123 @@
+require 'test/setup'
+
+class TestMogileFS__MogileFS < TestMogileFS
+
+  def setup
+    @class = MogileFS::MogileFS
+    super
+  end
+
+  def test_initialize
+    assert_equal 'test', @client.domain
+    assert_equal '/mogilefs/test', @client.root
+
+    assert_raises ArgumentError do
+      MogileFS::MogileFS.new :hosts => ['kaa:6001'], :root => '/mogilefs/test'
+    end
+  end
+
+  def test_get_paths
+    path1 = 'rur-1/dev1/0/000/000/0000000062.fid'
+    path2 = 'rur-2/dev2/0/000/000/0000000062.fid'
+
+    @backend.get_paths = { 'paths' => 2, 'path1' => path1, 'path2' => path2 }
+
+    expected = ["#{@root}/#{path1}", "#{@root}/#{path2}"]
+
+    assert_equal expected, @client.get_paths('key').sort
+  end
+
+  def test_get_paths_unknown_key
+    @backend.get_paths = ['unknown_key', '']
+
+    assert_equal nil, @client.get_paths('key')
+  end
+
+  def test_delete_existing
+    @backend.delete = { }
+    assert_nothing_raised do
+      @client.delete 'no_such_key'
+    end
+  end
+
+  def test_delete_nonexisting
+    @backend.delete = 'unknown_key', ''
+    assert_nothing_raised do
+      assert_equal nil, @client.delete('no_such_key')
+    end
+  end
+
+  def test_delete_readonly
+    @client.readonly = true
+    assert_raises RuntimeError do
+      @client.delete 'no_such_key'
+    end
+  end
+
+  def test_list_keys
+    @backend.list_keys = { 'key_count' => 2, 'next_after' => 'new_key_2',
+                           'key_1' => 'new_key_1', 'key_2' => 'new_key_2' }
+
+    keys, next_after = @client.list_keys 'new'
+    assert_equal ['new_key_1', 'new_key_2'], keys.sort
+    assert_equal 'new_key_2', next_after
+  end
+
+  def test_new_file_http
+    @client.readonly = true
+    assert_raises RuntimeError do
+      @client.new_file 'new_key', 'test'
+    end
+  end
+
+  def test_new_file_readonly
+    @client.readonly = true
+    assert_raises RuntimeError do
+      @client.new_file 'new_key', 'test'
+    end
+  end
+
+  def test_store_content_readonly
+    @client.readonly = true
+    assert_raises RuntimeError do
+      @client.store_content 'new_key', 'test', nil
+    end
+  end
+
+  def test_store_file_readonly
+    @client.readonly = true
+    assert_raises RuntimeError do
+      @client.store_file 'new_key', 'test', nil
+    end
+  end
+
+  def test_rename_existing
+    @backend.rename = {}
+    assert_nothing_raised do
+      assert_equal(nil, @client.rename('from_key', 'to_key'))
+    end
+  end
+
+  def test_rename_nonexisting
+    @backend.rename = 'unknown_key', ''
+    assert_nothing_raised do
+      assert_equal(nil, @client.rename('from_key', 'to_key'))
+    end
+  end
+
+  def test_rename_readonly
+    @client.readonly = true
+    assert_raises RuntimeError do
+      @client.rename 'new_key', 'test'
+    end
+  end
+
+  def test_sleep
+    @backend.sleep = {}
+    assert_nothing_raised do
+      assert_equal({}, @client.sleep(2))
+    end
+  end
+
+end
+