mogilefs-client 3.8.0 → 3.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 65d3ada1142a27870a3926eeae7d15a13d28b016
-  data.tar.gz: 7ef65f2858cb0a130cbb7c0200946a7df05bf701
+  metadata.gz: 6485f77cf3355bd73565e09aa5955e461c7ee184
+  data.tar.gz: f3c904eb2e2801526629b3684aa7bf869736f97c
 SHA512:
-  metadata.gz: edecf8b75e5f3e218e63383c79da8ceaab6daed1890c3d51c0ca418936c30e6a613eb187ae5258137570eee8d649a612fcbaaf0cc606baa4165a817f146a681f
-  data.tar.gz: b9448f892913e8104c611badaf368e22acaa6faf60c70abf729200a6c0725efe2657a13498aeeb64b11b4701a62caa7f1f547eefff4c0652834745380dd04e8e
+  metadata.gz: 630a6d7503310c7950bf343b79c7fa0709ce31ffe452390fb1d97940a09f8a019c77aa73085186043e3d140213a23b24d8b1547b928a2a8e07ce8a91960471c1
+  data.tar.gz: 81d66c0d390b66ad170a120bf84c0f6603971296fa8da6d708c0f6c93390271850aceb64cd726338d80770b098916e32fba5168c7fac168ed1f56a9678204555

data/GIT-VERSION-GEN

@@ -2,7 +2,7 @@
 CONSTANT = "MogileFS::VERSION"
 RVF = "lib/mogilefs/version.rb"
 GVF = "GIT-VERSION-FILE"
-DEF_VER = "v3.8.0"
+DEF_VER = "v3.9.0"
 vn = DEF_VER
 
 # First see if there is a version file (included in release tarballs),

data/HACKING

@@ -7,16 +7,14 @@
 * Follow conventions set in existing code, don't add hard runtime
   dependencies outside of the standard Ruby library.
 
-* Do not hesitate to send plain-text(-only) email to Eric Wong at
-  mailto:normalperson@yhbt.net about anything not covered in
-  the documentation or mailing list archives.  General MogileFS
-  topics can go to the public mailing list at mailto:mogile@googlegroups.com
-  You may still email Wong directly if you do not trust the corporation
-  that hosts the public mailing list.
+* Do not hesitate to send plain-text(-only) email to the public list
+  at mailto:mogilefs-client-public@bogomips.org about anything not covered
+  in the documentation or mailing list archives.  General MogileFS
+  topics can go on the the mailing list at mailto:mogile@googlegroups.com
 
 * Use "git format-patch" and "git send-email" for sending patches.
 
-* Use "git request-pull" as a guideline for formatting pull-requests.
+* Use "git request-pull" as a guideline for formatting pull-request emails.
 
 * Test with the latest upstream MogileFS and Ruby versions.
 
@@ -24,10 +22,6 @@
   with a single host and device using a SQLite backend if you
   have "mogdbsetup", "mogilefsd", and "mogstored" in your PATH.
 
-* Setting MOG_TEST_TRACKERS= to a comma-delimited list of trackers
-  can enable additional integration tests against a live tracker
-  (with multiple devices/hosts).
-
 * Tests may be run in parallel using GNU make:
 
   make -j6 test

data/lib/mogilefs.rb

@@ -5,19 +5,29 @@
 # Client usage information is available in MogileFS::MogileFS.
 module MogileFS
 
+  if defined?(Process::CLOCK_MONOTONIC)
+    def self.now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  else
+    def self.now
+      Time.now.to_f
+    end
+  end
+
   # Standard error class for most MogileFS-specific errors
-  class Error < StandardError; end
+  Error = Class.new(StandardError)
 
   # Raised when a socket remains unreadable for too long.
-  class UnreadableSocketError < Error; end
+  UnreadableSocketError = Class.new(Error)
 
   # Raised when a response is truncated while reading
   # due to network/server # errors)
-  class SizeMismatchError < Error; end
+  SizeMismatchError = Class.new(Error)
 
   # Raised when checksum verification fails (only while reading deprecated
   # "bigfiles" from the deprecated mogtool(1).
-  class ChecksumMismatchError < RuntimeError; end
+  ChecksumMismatchError = Class.new(RuntimeError)
 
   # Raised when a backend is in read-only mode
   class ReadOnlyError < Error
@@ -27,27 +37,27 @@ module MogileFS
   end
 
   # Raised when an upload is impossible
-  class EmptyPathError < Error; end
+  EmptyPathError = Class.new(Error)
 
   # Raised when we are given an unsupported protocol to upload to.
   # Currently, the \MogileFS (2.XX) server only supports HTTP and
   # this library is only capable of HTTP.
-  class UnsupportedPathError < Error; end
+  UnsupportedPathError = Class.new(Error)
 
   # Raised when a request (HTTP or tracker) was truncated due to a network or
   # server error.  It may be possible to retry idempotent requests from this.
-  class RequestTruncatedError < Error; end
+  RequestTruncatedError = Class.new(Error)
 
   # Raised when a response from a server (HTTP or tracker) is not in a format
   # that we expected (or truncated..
-  class InvalidResponseError < Error; end
+  InvalidResponseError = Class.new(Error)
 
   # Raised when all known backends have failed.
-  class UnreachableBackendError < Error; end
+  UnreachableBackendError = Class.new(Error)
 
   # There was an error as a result of the use of the (experimental)
   # pipelining code to the tracker backend
-  class PipelineError < Error; end
+  PipelineError = Class.new(Error)
 
   # :stopdoc:
   class << self

data/lib/mogilefs/backend.rb

@@ -147,7 +147,7 @@ class MogileFS::Backend
       tries ||= Hash.new { |hash,host| hash[host] = 0 }
       nr = tries[@active_host] += 1
       if nr >= 2
-        @dead[@active_host] = [ Time.now, err ]
+        @dead[@active_host] = [ MogileFS.now, err ]
       end
       shutdown_unlocked
       retry
@@ -163,7 +163,7 @@ class MogileFS::Backend
   end
 
   def timeout_update(timeout, t0) # :nodoc:
-    timeout -= (Time.now - t0)
+    timeout -= (MogileFS.now - t0)
     timeout < 0 ? 0 : timeout
   end
 
@@ -174,12 +174,12 @@ class MogileFS::Backend
   def pipeline_drain_unlocked(io, timeout) # :nodoc:
     set = [ io ]
     while @pending.size > 0
-      t0 = Time.now
+      t0 = MogileFS.now
       r = IO.select(set, set, nil, timeout)
       timeout = timeout_update(timeout, t0)
 
       if r && r[0][0]
-        t0 = Time.now
+        t0 = MogileFS.now
         pipeline_gets_unlocked(io, timeout)
         timeout = timeout_update(timeout, t0)
       else
@@ -207,7 +207,7 @@ class MogileFS::Backend
         io.timed_write(request, timeout)
         @pending << [ request, block ]
       rescue SystemCallError, MogileFS::RequestTruncatedError => err
-        @dead[@active_host] = [ Time.now, err ]
+        @dead[@active_host] = [ MogileFS.now, err ]
         shutdown_unlocked(@pending[0])
         io = socket
         retry
@@ -343,14 +343,14 @@ class MogileFS::Backend
     return @socket if @socket and not @socket.closed?
 
     @hosts.shuffle.each do |host|
-      next if dead = @dead[host] and dead[0] > (Time.now - @fail_timeout)
+      next if dead = @dead[host] and dead[0] > (MogileFS.now - @fail_timeout)
 
       begin
         addr, port = host.split(/:/)
         @socket = MogileFS::Socket.tcp(addr, port, @timeout)
         @active_host = host
       rescue SystemCallError, MogileFS::Timeout => err
-        @dead[host] = [ Time.now, err ]
+        @dead[host] = [ MogileFS.now, err ]
         next
       end
 

data/lib/mogilefs/http_reader.rb

@@ -46,13 +46,13 @@ class MogileFS::HTTPReader < MogileFS::Socket
   # body of the response.
   def self.try(path, timeout, range) # :nodoc:
     uri = URI.parse(path)
-    expire_at = Time.now + timeout
+    expire_at = MogileFS.now + timeout
     sock = tcp(uri.host, uri.port, timeout)
     buf = "GET #{uri.request_uri} HTTP/1.0\r\n#{range}\r\n" # no chunking
     sock.timed_write(buf, timeout)
 
     begin
-      raise MogileFS::Timeout if Time.now > expire_at
+      raise MogileFS::Timeout if MogileFS.now > expire_at
       sock.timed_peek(2048, buf, timeout) or
         raise MogileFS::InvalidResponseError, "EOF while reading header", []
     end until /\r\n\r\n/ =~ buf

data/lib/mogilefs/mogilefs.rb

@@ -318,7 +318,7 @@ class MogileFS::MogileFS < MogileFS::Client
     opts[:fid] = res['fid']
     opts[:content_length] ||= bytes if bytes
     opts[:new_file_max_time] ||= @new_file_max_time
-    opts[:start_time] = Time.now
+    opts[:start_time] = MogileFS.now
     info = opts[:info] and info["class"] = klass || "default"
 
     case (dests[0][1] rescue nil)

data/lib/mogilefs/mysql.rb

@@ -21,7 +21,7 @@ class MogileFS::Mysql
   def initialize(args = {})
     @my = args[:mysql]
     @query_method = @my.respond_to?(:c_async_query) ? :c_async_query : :query
-    @last_update_device = @last_update_domain = Time.at(0)
+    @last_update_device = @last_update_domain = 0
     @cache_domain = @cache_device = nil
   end
 
@@ -139,7 +139,9 @@ class MogileFS::Mysql
     }.freeze
 
     def refresh_device(force = false)
-      return @cache_device if ! force && ((Time.now - @last_update_device) < 60)
+      if ! force && ((MogileFS.now - @last_update_device) < 60)
+        return @cache_device
+      end
       tmp = {}
       res = query(GET_DEVICES)
       res.each do |devid, hostip, altip, http_port, http_get_port,
@@ -154,16 +156,18 @@ class MogileFS::Mysql
           :http_get_port => http_get_port ?  http_get_port.to_i : http_port,
         }.freeze
       end
-      @last_update_device = Time.now
+      @last_update_device = MogileFS.now
       @cache_device = tmp.freeze
     end
 
     def refresh_domain(force = false)
-      return @cache_domain if ! force && ((Time.now - @last_update_domain) < 5)
+      if ! force && ((MogileFS.now - @last_update_domain) < 5)
+        return @cache_domain
+      end
       tmp = {}
       res = query(GET_DOMAINS)
       res.each { |dmid,namespace| tmp[namespace] = dmid.to_i }
-      @last_update_domain = Time.now
+      @last_update_domain = MogileFS.now
       @cache_domain = tmp.freeze
     end
 

data/lib/mogilefs/new_file/common.rb

@@ -20,7 +20,7 @@ module MogileFS::NewFile::Common
 
   def read_response(sock)
     tout = @opts[:new_file_max_time] || 3600.0
-    start_time = @opts[:start_time] and tout -= Time.now - start_time
+    start_time = @opts[:start_time] and tout -= MogileFS.now - start_time
     set_socket_options(sock)
     case line = sock.timed_read(23, "", tout > 0.0 ? tout : 0)
     when %r{^HTTP/\d\.\d\s+(2\d\d)\s} # success!

data/lib/mogilefs/socket/pure_ruby.rb

@@ -1,5 +1,6 @@
 # -*- encoding: binary -*-
 # internal implementation details here, do not rely on them in your code
+require 'io/wait'
 
 class MogileFS::Socket < Socket
   include MogileFS::SocketCommon
@@ -15,16 +16,20 @@ class MogileFS::Socket < Socket
 
   def self.tcp(host, port, timeout = 5)
     sock = start(host, port)
-    unless IO.select(nil, [ sock ], nil, timeout)
+    unless sock.wait_writable(timeout)
       sock.close
       raise MogileFS::Timeout, 'socket connect timeout'
     end
     sock
   end
 
+  def wait_writable(timeout)
+    IO.select(nil, [ self ], nil, timeout)
+  end unless self.instance_methods.include?(:wait_writable) # Ruby <2.0.0
+
   def timed_read(len, dst = "", timeout = 5)
     begin
-      IO.select([self], nil, nil, timeout) or unreadable_socket!(timeout)
+      wait_readable(timeout) or unreadable_socket!(timeout)
       return read_nonblock(len, dst)
     rescue Errno::EAGAIN
     rescue EOFError
@@ -34,7 +39,7 @@ class MogileFS::Socket < Socket
 
   def timed_peek(len, dst, timeout = 5)
     begin
-      IO.select([self], nil, nil, timeout) or unreadable_socket!(timeout)
+      wait_readable(timeout) or unreadable_socket!(timeout)
       rc = recv_nonblock(len, Socket::MSG_PEEK)
       return rc.empty? ? nil : dst.replace(rc)
     rescue Errno::EAGAIN
@@ -61,8 +66,7 @@ class MogileFS::Socket < Socket
         buf = buf.slice(rc, buf.bytesize)
       end
     rescue Errno::EAGAIN
-      IO.select(nil, [self], nil, timeout) or
-        request_truncated!(written, expect, timeout)
+      wait_writable(timeout) or request_truncated!(written, expect, timeout)
     end while true
   end
 end

data/lib/mogilefs/util.rb

@@ -24,4 +24,4 @@ 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
+MogileFS::Timeout = Class.new(Timeout::Error)

data/test/test_fresh.rb

@@ -138,7 +138,7 @@ class TestMogFresh < Test::Unit::TestCase
       if IO.respond_to?(:copy_stream)
         # ensure we match IO.copy_stream semantics
         dst = StringIO.new
-        IO.copy_stream(src, dst, *range)
+        IO.copy_stream(src.to_io, dst, *range)
         assert_equal dst.string, dst2.string
         assert_equal dst.string, client.get_file_data("key", nil, *range)
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mogilefs-client
 version: !ruby/object:Gem::Version
-  version: 3.8.0
+  version: 3.9.0
 platform: ruby
 authors:
 - mogilefs-client hackers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-10 00:00:00.000000000 Z
+date: 2015-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: olddoc
@@ -126,7 +126,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: client - MogileFS client library for Ruby