mogilefs-client 1.3.1 → 2.0.0

data/test/test_mysql.rb

@@ -0,0 +1,94 @@
+require 'test/setup'
+require 'mogilefs/mysql'
+
+class MogileFS::Mysql
+  public :refresh_device
+  public :refresh_domain
+end
+
+class TestMogileFS__Mysql < Test::Unit::TestCase
+
+  def setup
+    @my = FakeMysql.new
+    @mg = MogileFS::Mysql.new(:mysql => @my)
+    super
+  end
+
+  def test_refresh_device
+    expect = {
+     1=>
+      {:hostip=>"10.0.0.1",
+       :http_get_port=>7600,
+       :http_port=>7500,
+       :altip=>"192.168.0.1"},
+     2=>
+      {:hostip=>"10.0.0.2",
+       :http_get_port=>7600,
+       :http_port=>7500,
+       :altip=>"192.168.0.2"},
+     3=>
+      {:hostip=>"10.0.0.3",
+       :http_get_port=>7500,
+       :http_port=>7500,
+       :altip=>"10.0.0.3"},
+     4=>
+      {:hostip=>"10.0.0.4",
+       :http_get_port=>7500,
+       :http_port=>7500,
+       :altip=>"10.0.0.4"}
+    }
+    assert_equal expect, @mg.refresh_device
+  end
+
+  def test_refresh_domain
+    expect = { 'test' => 1, 'foo' => 2 }
+    assert_equal expect, @mg.refresh_domain
+  end
+
+  def test_get_paths
+    @my.expect << [ [ 12 ] ] # fid
+    @my.expect << [ [ 1 ], [ 3 ] ] # devids
+    expect = [ "http://10.0.0.1:7600/dev1/0/000/000/0000000012.fid",
+               "http://10.0.0.3:7500/dev3/0/000/000/0000000012.fid" ]
+    assert_equal expect, @mg._get_paths(:domain => 'test', :key => 'fookey')
+  end
+
+  def test_get_paths_alt
+    @my.expect <<  [ [ 12 ] ] # fid
+    @my.expect << [ [ 1 ], [ 3 ] ] # devids
+    expect = [ "http://192.168.0.1:7600/dev1/0/000/000/0000000012.fid",
+               "http://10.0.0.3:7500/dev3/0/000/000/0000000012.fid"]
+    params = { :domain => 'test', :key => 'fookey', :zone => 'alt' }
+    assert_equal expect, @mg._get_paths(params)
+  end
+
+  def test_list_keys
+    expect_full = [ [ 'foo', 123, 2 ], [ 'bar', 456, 1 ] ]
+    expect_keys = [ [ 'foo', 'bar' ], 'bar' ]
+    @my.expect << expect_full
+    full = []
+    keys = @mg._list_keys('test') do |dkey,length,devcount|
+      full << [ dkey, length, devcount ]
+    end
+    assert_equal expect_keys, keys
+    assert_equal expect_full, full
+  end
+
+  def test_list_keys_empty
+    @my.expect << []
+    assert_nil @mg._list_keys('test')
+  end
+
+  def test_size
+    @my.expect << [ [ '123' ] ]
+    assert_equal 123, @mg._size('test', 'foo')
+
+    @my.expect << [ [ '456' ] ]
+    assert_equal 456, @mg._size('test', 'foo')
+  end
+
+  def test_sleep
+    assert_nothing_raised { assert_equal({}, @mg.sleep(:duration => 1)) }
+  end
+
+end

data/test/test_network.rb

@@ -0,0 +1,27 @@
+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
+
+end

data/test/test_util.rb

@@ -0,0 +1,59 @@
+require 'test/setup'
+require 'tempfile'
+
+class TestMogileFS__Util < Test::Unit::TestCase
+  include MogileFS::Util
+
+  def test_mogilefs_write
+    done = Queue.new
+
+    svr = Proc.new do |serv, port|
+      client, client_addr = serv.accept
+      client.sync = true
+      readed = 0
+      loop do
+        begin
+          readed += client.readpartial(16384).length
+        rescue EOFError
+          break
+        end
+      end
+      done << readed
+      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
+    readed = done.pop
+
+    assert_equal((sent + big_string.length), readed)
+  end
+
+  def test_write_timeout
+    done = Queue.new
+
+    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
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mogilefs-client
 version: !ruby/object:Gem::Version 
-  version: 1.3.1
+  version: 2.0.0
 platform: ruby
 authors: 
 - Eric Wong
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-02 00:00:00 -07:00
+date: 2009-02-02 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -31,9 +31,9 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.7.0
+        version: 1.8.2
     version: 
-description: A Ruby MogileFS client.  MogileFS is a distributed filesystem written by Danga Interactive.  This client supports NFS and HTTP modes.
+description: git://git.bogomips.org/mogilefs-client.git
 email: normalperson@yhbt.net
 executables: 
 - mog
@@ -45,6 +45,8 @@ extra_rdoc_files:
 - Manifest.txt
 - README.txt
 files: 
+- .gitignore
+- GNUmakefile
 - History.txt
 - LICENSE.txt
 - Manifest.txt
@@ -54,18 +56,27 @@ files:
 - lib/mogilefs.rb
 - lib/mogilefs/admin.rb
 - lib/mogilefs/backend.rb
+- lib/mogilefs/bigfile.rb
 - lib/mogilefs/client.rb
 - lib/mogilefs/httpfile.rb
 - lib/mogilefs/mogilefs.rb
-- lib/mogilefs/nfsfile.rb
+- lib/mogilefs/mysql.rb
+- lib/mogilefs/network.rb
 - lib/mogilefs/pool.rb
 - lib/mogilefs/util.rb
+- test/.gitignore
+- test/aggregate.rb
 - test/setup.rb
 - test/test_admin.rb
 - test/test_backend.rb
+- test/test_bigfile.rb
 - test/test_client.rb
+- test/test_db_backend.rb
 - test/test_mogilefs.rb
+- test/test_mysql.rb
+- test/test_network.rb
 - test/test_pool.rb
+- test/test_util.rb
 has_rdoc: true
 homepage: http://seattlerb.org/mogilefs-client
 post_install_message: 
@@ -89,13 +100,18 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: seattlerb
-rubygems_version: 1.2.0
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
 summary: A Ruby MogileFS client
 test_files: 
+- test/test_bigfile.rb
 - test/test_pool.rb
+- test/test_db_backend.rb
 - test/test_mogilefs.rb
+- test/test_network.rb
+- test/test_mysql.rb
 - test/test_client.rb
 - test/test_admin.rb
+- test/test_util.rb
 - test/test_backend.rb

data/lib/mogilefs/nfsfile.rb

@@ -1,81 +0,0 @@
-require 'mogilefs/backend'
-
-##
-# NFSFile wraps up the new file operations for storing files onto an NFS
-# storage node.
-#
-# You really don't want to create an NFSFile by hand.  Instead you want to
-# create a new file using MogileFS::MogileFS.new_file.
-
-class MogileFS::NFSFile < File
-
-  ##
-  # The path of this file not including the local mount point.
-
-  attr_reader :path
-
-  ##
-  # The key for this file.  This key won't represent a real file until you've
-  # called #close.
-
-  attr_reader :key
-
-  ##
-  # The class of this file.
-
-  attr_reader :class
-
-  class << self
-
-    ##
-    # Wraps up File.new with MogileFS-specific data.  Use
-    # MogileFS::MogileFS#new_file instead of this method.
-
-    def new(mg, fid, path, devid, klass, key)
-      fp = super join(mg.root, path), 'w+'
-      fp.send :setup, mg, fid, path, devid, klass, key
-      return fp
-    end
-
-    ##
-    # Wraps up File.open with MogileFS-specific data.  Use
-    # MogileFS::MogileFS#new_file instead of this method.
-
-    def open(mg, fid, path, devid, klass, key, &block)
-      fp = new mg, fid, path, devid, klass, key
-
-      return fp if block.nil?
-
-      begin
-        yield fp
-      ensure
-        fp.close
-      end
-    end
-
-  end
-
-  ##
-  # Closes the file handle and marks it as closed in MogileFS.
-
-  def close
-    super
-    @mg.backend.create_close(:fid => @fid, :devid => @devid,
-                             :domain => @mg.domain, :key => @key,
-                             :path => @path)
-    return nil
-  end
-
-  private
-
-  def setup(mg, fid, path, devid, klass, key)
-    @mg = mg
-    @fid = fid
-    @path = path
-    @devid = devid
-    @klass = klass
-    @key = key
-  end
-
-end
-