mogilefs-client 3.10.0 → 3.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d02264aa8b34f8fab16add61f2e81ee0643127cf
-  data.tar.gz: 5b333aa4abe0f863d819a9a480fa11180b902f1b
+  metadata.gz: df67ca0268814f324ab52a02700ead9303cb7ce1
+  data.tar.gz: f593fa4c418f462993efe066cdd937012f23df9f
 SHA512:
-  metadata.gz: c6d650e02544bf8b432c80d50c21b13fbdca9169cd69b5513b534e66b7dc279f25a81a7b8823233e7e2b844d4624dd7d8c06ed38f74212d79a386884b8621f30
-  data.tar.gz: bd840975cb4154cc4aa6a0370765a7ff48dbf5374daa8aef079a48a2de9b27c4c3a96a543c9c52c6a2de95324fe8271b3a98818d41cc9d55edf8dc03890c0b09
+  metadata.gz: c6da0266d991711aee0b33fd1e93e90cf501407f9d4d7559a00ea9fc3e83923ad345ea32f0c0982febfdd3d54a3a605d9d3b0be004704681e3fb2746740471ba
+  data.tar.gz: 4f6d66be2a618be1831d6b83835452397cbce8c434bd26537ac5bf42901eeaf1f78835cccf07d35523819cf8c1e6fa16b3999b7ef85fe2ef09a6f2b157c1bbba

data/.olddoc.yml

@@ -1,9 +1,8 @@
 ---
-cgit_url: http://bogomips.org/mogilefs-client.git
+cgit_url: https://bogomips.org/mogilefs-client.git
 git_url: git://bogomips.org/mogilefs-client.git
-rdoc_url: http://bogomips.org/mogilefs-client
+rdoc_url: https://bogomips.org/mogilefs-client
 changelog_start: v1.2.1
-private_email: e@80x24.org
 public_email: mogilefs-client-public@bogomips.org
 nntp_url: nntp://news.public-inbox.org/inbox.comp.file-systems.mogilefs.ruby
-ml_url: http://bogomips.org/mogilefs-client-public/
+ml_url: https://bogomips.org/mogilefs-client-public/

data/GIT-VERSION-GEN

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

data/README

@@ -1,22 +1,21 @@
 = mogilefs-client - MogileFS client library for Ruby
 
 A MogileFS client library for Ruby.  MogileFS is an open source
-distributed filesystem, see: http://mogilefs.org for more details.  This
-library allows any Ruby application to read, write and delete files in a
-MogileFS instance.
+distributed filesystem, see: http://mogilefs.org for more details.
+This library allows any Ruby application to read, write and delete
+files in a MogileFS instance.
 
 == Links
 
-rdoc :: http://bogomips.org/mogilefs-client
+rdoc :: https://bogomips.org/mogilefs-client
 mogilefs :: http://mogilefs.org/
 list :: mailto:mogilefs-client-public@bogomips.org
 list-cc :: mailto:mogile@googlegroups.com
-list-archive :: http://bogomips.org/mogilefs-client-public
-email :: mailto:e@80x24.org
+list-archive :: https://bogomips.org/mogilefs-client-public
 repo :: git://bogomips.org/mogilefs-client.git
-	http://bogomips.org/mogilefs-client.git
+	https://bogomips.org/mogilefs-client.git
 gitweb :: http://repo.or.cz/w/ruby-mogilefs-client.git
-download :: http://bogomips.org/mogilefs-client/files/
+download :: https://bogomips.org/mogilefs-client/files/
 
 == Install
 
@@ -43,20 +42,19 @@ is required or available to post:
 
 	mogilefs-client-public@bogomips.org
 
-List archives: http://bogomips.org/mogilefs-client-public/
+Users of anonymous remailers and other anonymity tools are welcome.
+Participants will never be asked to reveal their identity.
+
+List archives: https://bogomips.org/mogilefs-client-public/
 
 We may also piggy-back onto the public MogileFS mailing list at
 mogile@googlegroups.com for feedback (subscription required,
 unfortunately)
 
-If you wish to keep your issue secret, feel free to email the author at:
-
-		e@80x24.org
-
 Do not expect us to read HTML mail under any circumstances.
 
 == WARNING!
 
 This client is only supported in HTTP mode.  NFS mode was previously
-supported in 1.3.x, but since MogileFS 2.x has dropped support for
-NFS, this client has removed support for it.
+supported in 1.3.x, but since MogileFS 2.x dropped support for NFS
+in in 2006, this client does not support it.

data/examples/stale_fid_checker.rb

@@ -34,7 +34,9 @@
 end
 
 adm = MogileFS::Admin.new(:hosts => trackers)
-NHP = Net::HTTP::Persistent.new(File.basename($0))
+name = File.basename($0)
+Net::HTTP::Persistent::VERSION >= 3.0 and name = { :name => name }
+NHP = Net::HTTP::Persistent.new(name)
 client = MogileFS::MogileFS.new(:hosts => trackers, :domain => "none")
 
 def start_perdev_thread(pfx)

data/lib/mogilefs/admin.rb

@@ -1,4 +1,5 @@
 # -*- encoding: binary -*-
+# frozen_string_literal: true
 
 # \MogileFS administration client, this has little real-world usage
 # and is considered a work-in-progress

data/lib/mogilefs/http_file.rb

@@ -54,7 +54,7 @@ def request_put(sock, uri, file_size, input = nil)
                  "Content-Length: #{file_size}\r\n\r\n")
       rv = input ? MogileFS.io.copy_stream(@active = input, sock) : yield(sock)
     else
-      trailers = @md5 ? "Trailer: Content-MD5\r\n" : ""
+      trailers = @md5 ? "Trailer: Content-MD5\r\n".freeze : "".freeze
       sock.write("PUT #{uri.request_uri} HTTP/1.1\r\n" \
                  "Host: #{host_with_port}\r\n#{trailers}" \
                  "Transfer-Encoding: chunked\r\n\r\n")
@@ -143,14 +143,14 @@ def nhp_put(devid, uri)
     end
 
     put = Net::HTTP::Put.new(uri.path)
-    put["Content-Type"] = "application/octet-stream"
+    put["Content-Type".freeze] = "application/octet-stream".freeze
     if md5 = @opts[:content_md5]
       if md5.respond_to?(:call)
         md5 = md5.call.strip
       elsif md5 == :trailer
-        md5 = [ Digest::MD5.digest(string) ].pack("m").chomp!
+        md5 = [ Digest::MD5.digest(string) ].pack("m".freeze).chomp!
       end
-      put["Content-MD5"] = md5
+      put["Content-MD5".freeze] = md5
     end
     put.body = string
     res = @opts[:nhp_put].request(uri, put)

data/lib/mogilefs/mogilefs.rb

@@ -73,9 +73,9 @@ def initialize(args = {})
 
     @get_file_data_timeout = args[:get_file_data_timeout] || 5
     @new_file_max_time = args[:new_file_max_time] || 3600.0
-    @nhp_get = MogileFS::NHP.new('get')
+    @nhp_get = nhp_new('get')
     @nhp_get.open_timeout = @nhp_get.read_timeout = @get_file_data_timeout
-    @nhp_put = MogileFS::NHP.new('put')
+    @nhp_put = nhp_new('put')
     @nhp_put.open_timeout = @nhp_put.read_timeout = @new_file_max_time
 
     raise ArgumentError, "you must specify a domain" unless @domain
@@ -548,4 +548,11 @@ def file_debug(args)
       end
     end
   end
+
+  def nhp_new(name) # :nodoc:
+    Net::HTTP::Persistent::VERSION.to_f >= 3.0 and name = { :name => name }
+    MogileFS::NHP.new(name)
+  rescue NameError
+    MogileFS::NHP.new(name)
+  end
 end

data/lib/mogilefs/mysql.rb

@@ -28,7 +28,7 @@ def initialize(args = {})
   ##
   # Lists keys starting with +prefix+ follwing +after+ up to +limit+.  If
   # +after+ is nil the list starts at the beginning.
-  def _list_keys(domain, prefix = '', after = '', limit = 1000)
+  def _list_keys(domain, prefix = ''.freeze, after = ''.freeze, limit = 1000)
     # this code is based on server/lib/MogileFS/Worker/Query.pm
     dmid = get_dmid(domain)
 
@@ -43,7 +43,7 @@ def _list_keys(domain, prefix = '', after = '', limit = 1000)
     end
 
     raise MogileFS::Backend::InvalidCharsError if /[%\\]/ =~ prefix
-    prefix.gsub!(/_/, '\_') # not sure why MogileFS::Worker::Query does this...
+    prefix.gsub!(/_/, '\_'.freeze)
 
     sql = <<-EOS
     SELECT dkey,length,devcount FROM file
@@ -150,7 +150,7 @@ def refresh_device(force = false)
         tmp[devid.to_i] = {
           :hostip => hostip.freeze,
           :altip => (altip || hostip).freeze,
-          :readable => (host_status == "alive" &&
+          :readable => (host_status == "alive".freeze &&
                         DEV_STATUS_READABLE.include?(dev_status)),
           :http_port => http_port,
           :http_get_port => http_get_port ?  http_get_port.to_i : http_port,

data/lib/mogilefs/new_file/common.rb

@@ -7,14 +7,14 @@
 
 module MogileFS::NewFile::Common
   # :stopdoc:
-  class RetryableError < MogileFS::Error; end
-  class EmptyResponseError < RetryableError; end
-  class BadResponseError < RetryableError; end
-  class UnparseableResponseError < RetryableError; end
+  RetryableError = Class.new(MogileFS::Error)
+  EmptyResponseError = Class.new(RetryableError)
+  BadResponseError = Class.new(RetryableError)
+  UnparseableResponseError = Class.new(RetryableError)
   class NoStorageNodesError < MogileFS::Error
     def message; 'Unable to open socket to storage node'; end
   end
-  class NonRetryableError < MogileFS::Error; end
+  NonRetryableError = Class.new(MogileFS::Error)
 
   MD5_TRAILER_NODES = {} # :nodoc: # EXPERIMENTAL
 
@@ -23,7 +23,7 @@ def read_response(sock)
     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!
+    when %r{^HTTP/\d\.\d\s+(?:2\d\d)\s} # success!
     when nil
       raise EmptyResponseError, 'Unable to read response line from server'
     when %r{^HTTP/\d\.\d\s+(\d+)}

data/lib/mogilefs/new_file/stream.rb

@@ -66,7 +66,7 @@ def commit
   def start_sock(sock, uri)
     host_with_port = "#{uri.host}:#{uri.port}"
     headers = "PUT #{uri.request_uri} HTTP/1.1\r\n" \
-              "Host: #{host_with_port}\r\n" \
+              "Host: #{host_with_port}\r\n"
 
     content_md5 = @opts[:content_md5]
     if String === content_md5
@@ -75,16 +75,16 @@ def start_sock(sock, uri)
           :trailer == content_md5 ||
           MD5_TRAILER_NODES[host_with_port]
       @md5 = Digest::MD5.new
-      headers << "Trailer: Content-MD5\r\n"
+      headers << "Trailer: Content-MD5\r\n".freeze
     end
 
     if ! @md5 && clen = @opts[:content_length]
       headers << "Content-Length: #{clen}\r\n"
     else
-      headers << "Transfer-Encoding: chunked\r\n"
+      headers << "Transfer-Encoding: chunked\r\n".freeze
     end
 
-    sock.write(headers << "\r\n")
+    sock.write(headers << "\r\n".freeze)
   end
 
   alias syswrite write

data/lib/mogilefs/new_file/writer.rb

@@ -9,7 +9,7 @@ module MogileFS::NewFile::Writer
   def puts(*args)
     args.each do |obj|
       write(obj)
-      write("\n")
+      write("\n".freeze)
     end
     nil
   end

data/lib/mogilefs/paths_size.rb

@@ -10,7 +10,7 @@ def self.call(paths)
       begin
         case r = Net::HTTP.start(uri.host, uri.port) { |x| x.head(uri.path) }
         when Net::HTTPOK
-          return r["Content-Length"].to_i
+          return r['Content-Length'.freeze].to_i
         else
           errors[path] = r
         end

data/lib/mogilefs/socket_common.rb

@@ -23,18 +23,17 @@ def request_truncated!(written, expect, timeout)
      "request truncated (sent #{written} expected #{expect} timeout=#{timeout})"
   end
 
-  SEP_RE = /\A(.*?#{Regexp.escape("\n")})/
   def timed_gets(timeout = 5)
     unless defined?(@rbuf) && @rbuf
       @rbuf = timed_read(1024, "", timeout) or return # EOF
     end
     begin
-      @rbuf.sub!(SEP_RE, "") and return $1
+      @rbuf.sub!(/\A(.*\n)/o, "".freeze) and return $1
       tmp ||= ""
       if timed_read(1024, tmp, timeout)
         @rbuf << tmp
       else
-        # EOF, return the last buffered bit even without SEP_RE matching
+        # EOF, return the last buffered bit even without separatar matching
         # (not ideal for MogileFS, this is an error)
         return @rbuf.empty? ? nil : @rbuf.slice!(0, @rbuf.size)
       end
@@ -56,4 +55,16 @@ def read(size, buf = "", timeout = 5)
   def readpartial(size, buf = "", timeout = 5)
     timed_read(size, buf, timeout) or raise EOFError, "end of file reached"
   end
+
+  # Workaround for https://bugs.ruby-lang.org/issues/13085
+  # (excessive garbage from IO#write)
+  # This looks like it will be fixed in Ruby 2.5 final.
+  if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby' &&
+     RUBY_VERSION.to_f >= 2.2 && RUBY_VERSION.to_f <= 2.4
+    def write(buf)
+      # Blocking TCP writes would error out long before one day,
+      # and MogileFS won't allow file creations which take over a day.
+      timed_write(buf, 86400)
+    end
+  end
 end

data/mogilefs-client.gemspec

@@ -1,20 +1,20 @@
-ENV["VERSION"] or abort "VERSION= must be specified"
-require 'olddoc'
 $LOAD_PATH << 'lib'
-require 'mogilefs'
-extend Olddoc::Gemspec
-name, summary, title = readme_metadata
+require 'mogilefs' # for MogileFS::VERSION
 Gem::Specification.new do |s|
   manifest = File.read('.manifest').split(/\n/)
   s.name = 'mogilefs-client'
   s.version = MogileFS::VERSION
   s.executables = %w(mog)
   s.authors = ["#{s.name} hackers"]
-  s.summary = summary
-  s.description = readme_description
-  s.email = Olddoc.config['private_email']
+  s.summary = 'MogileFS client library for Ruby'
+  s.description = <<EOF
+A MogileFS client library for Ruby.  MogileFS is an open source
+distributed filesystem, see: http://mogilefs.org for more details.
+This library allows any Ruby application to read, write and delete
+files in a MogileFS instance.
+EOF
+  s.email = 'mogilefs-client-public@bogomips.org'
   s.files = manifest
-  s.add_development_dependency('olddoc', '~> 1.0')
-  s.homepage = Olddoc.config['rdoc_url']
+  s.homepage = 'https://bogomips.org/mogilefs-client/'
   s.license = 'BSD-3-Clause'
 end

data/test/fresh.rb

@@ -42,7 +42,7 @@ def setup_mogilefs(plugins = nil)
     50.times do
       break if File.size(@mogstored_pid.path) > 0
       sleep 0.1
-    end
+    end unless Integer === @mogstored_pid
   end
 
   def start_tracker
@@ -108,10 +108,12 @@ def add_host_device_domain
 
   def teardown_mogilefs
     return if $$ != @teardown_pid
-    if @mogstored_pid
+    if Integer === @mogstored_pid
+      pid = @mogstored_pid
+    else
       pid = File.read(@mogstored_pid.path).to_i
-      Process.kill(:TERM, pid) if pid > 0
     end
+    Process.kill(:TERM, pid) if pid > 0
     if @mogilefsd_pid
       s = TCPSocket.new(@test_host, @tracker_port)
       s.write "!shutdown\r\n"

data/test/{test_mogstored_rack.rb → test_cmogstored.rb}

@@ -1,18 +1,11 @@
 # -*- encoding: binary -*-
 require "./test/fresh"
-begin
-  require 'mogstored_rack'
-  require 'unicorn'
-  ok = true
-rescue LoadError
-  ok = false
-end
-
-class TestMogstoredRack < Test::Unit::TestCase
+
+# cmogstored allows Content-Range on PUT, unlike the original mogstored
+class Test_cmogstored < Test::Unit::TestCase
   include TestFreshSetup
-  def setup
-    setup_mogilefs
-  end
+  alias setup setup_mogilefs
+  alias teardown teardown_mogilefs
 
   def test_range_put_new_file
     add_host_device_domain
@@ -34,6 +27,25 @@ def test_range_put_new_file
     assert_equal "a\nb\nc\nd\ne\n", client.get_file_data("puts")
   end
 
+  def test_garbage
+    add_host_device_domain
+    client = MogileFS::MogileFS.new :hosts => @hosts, :domain => @domain,
+                                    :timeout => 60
+    nr = 1024 * 1024 * 1024
+    client.new_file('giant', :largefile => :stream,
+                    :content_length => nr) do |io|
+      assert_instance_of MogileFS::NewFile::Stream, io
+      zero = Zero.new
+      before = GC.count
+      wr = IO.copy_stream(zero, io, nr)
+      after = GC.count
+      assert_equal nr, wr
+      assert_in_delta before, after, 1
+    end
+  end if IO.respond_to?(:copy_stream) && defined?(Zero) &&
+         GC.respond_to?(:count) && defined?(RUBY_ENGINE) &&
+         RUBY_ENGINE == 'ruby' && ENV['TEST_EXPENSIVE'].to_i != 0
+
   def test_stream_new_file
     add_host_device_domain
     client = MogileFS::MogileFS.new :hosts => @hosts, :domain => @domain
@@ -136,60 +148,34 @@ def setup_mogstored
     @mogstored_http = TCPServer.new(@test_host, 0)
     @mogstored_mgmt_port = @mogstored_mgmt.addr[1]
     @mogstored_http_port = @mogstored_http.addr[1]
-    @mogstored_conf = Tempfile.new(["mogstored", "conf"])
-    @mogstored_pid = Tempfile.new(["mogstored", "pid"])
-    @mogstored_conf.write <<EOF
-pidfile = #{@mogstored_pid.path}
-maxconns = 1000
-mgmtlisten = #@test_host:#{@mogstored_mgmt_port}
-server = none
-docroot = #@docroot
-EOF
-    @mogstored_conf.flush
-    @mogstored_mgmt.close
-
-    unicorn_setup
-
-    x!("mogstored", "--daemon", "--config=#{@mogstored_conf.path}")
-    wait_for_port @mogstored_mgmt_port
-  end
 
-  # I would use Rainbows! + *Threads + Ruby 1.9.3 in production
-  def unicorn_setup
-    @ru = Tempfile.new(%w(mogstored_rack .ru))
-    @ru.write <<EOF
-run MogstoredRack.new("#@docroot")
-EOF
-    @ru.flush
-
-    @unicorn_pid = Tempfile.new(%w(unicorn .pid))
-    @unicorn_conf = Tempfile.new(%w(unicorn.conf .rb))
-    @unicorn_stderr = Tempfile.new(%w(unicorn .stderr))
-    @unicorn_stdout = Tempfile.new(%w(unicorn .stdout))
-    @unicorn_conf.write <<EOF
-require "mogstored_rack"
-listen "#@test_host:#{@mogstored_http_port}"
-pid "#{@unicorn_pid.path}"
-stderr_path "#{@unicorn_stderr.path}"
-stdout_path "#{@unicorn_stdout.path}"
-rewindable_input false
-EOF
-    @unicorn_conf.flush
-
-    @mogstored_http.close
-    x!("unicorn", "-E", "deployment",
-       "--daemon", "--config", @unicorn_conf.path, @ru.path)
-    wait_for_port @mogstored_http_port
-    40.times do
-      break if File.size(@unicorn_pid.path) > 0
-      sleep 0.1
+    @mogstored_pid = fork do
+      mgmt_fd = @mogstored_mgmt.fileno
+      http_fd = @mogstored_http.fileno
+      args = []
+      ENV["CMOGSTORED_FD"] = "#{mgmt_fd},#{http_fd}"
+      if @mogstored_mgmt.respond_to?(:close_on_exec=)
+        @mogstored_mgmt.close_on_exec = @mogstored_http.close_on_exec = false
+        args << { mgmt_fd => mgmt_fd, http_fd => http_fd }
+      end
+      $stderr.reopen('/dev/null', 'a')
+      exec "cmogstored", "--httplisten=#@test_host:#@mogstored_http_port",
+           "--mgmtlisten=#@test_host:#@mogstored_mgmt_port",
+           "--maxconns=1000", "--docroot=#@docroot", *args
     end
   end
+end if `which cmogstored`.chomp.size > 0
+
+# The goal of this is to use a synthetic (non-IO) reader
+# to trigger the read/write loop of IO.copy_stream,
+# bypassing in-kernel mechanisms like sendfile for zero copy,
+# so we wrap the /dev/zero IO object:
+class Zero
+  def initialize
+    @in = File.open('/dev/zero', 'rb')
+  end
 
-  def teardown
-    pid = File.read(@unicorn_pid.path).to_i
-    Process.kill(:QUIT, pid) if pid > 0
-    teardown_mogilefs
-    puts(@unicorn_stderr.read) if $DEBUG
+  def read(len, buf)
+    @in.read(len, buf)
   end
-end if ok && `which unicorn`.chomp.size > 0
+end if File.readable?('/dev/zero')

data/test/test_nhp_compat.rb

@@ -0,0 +1,25 @@
+require 'test/unit'
+
+class TestNhpCompat < Test::Unit::TestCase
+
+  def test_nhp_compat
+    ver_test_nhp('~> 2.9')
+    ver_test_nhp('~> 3.0')
+  end
+
+  def ver_test_nhp(verspec)
+    pid = fork do
+      begin
+        gem 'net-http-persistent', verspec
+      rescue LoadError => e
+        warn "SKIPPING net-http-persistent #{verspec}\n" \
+             "#{e.message} (#{e.class})\n"
+      end
+      require 'mogilefs'
+      mg = MogileFS::MogileFS.new :hosts => %w(127.0.0.1:7500), :domain => 'x'
+      exit!(Net::HTTP::Persistent === mg.nhp_new('foo'))
+    end
+    _, status = Process.waitpid2(pid)
+    assert status.success?, status.inspect
+  end
+end

metadata

@@ -1,35 +1,21 @@
 --- !ruby/object:Gem::Specification
 name: mogilefs-client
 version: !ruby/object:Gem::Version
-  version: 3.10.0
+  version: 3.11.0
 platform: ruby
 authors:
 - mogilefs-client hackers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-31 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: olddoc
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-description: |-
+date: 2017-01-31 00:00:00.000000000 Z
+dependencies: []
+description: |
   A MogileFS client library for Ruby.  MogileFS is an open source
-  distributed filesystem, see: http://mogilefs.org for more details.  This
-  library allows any Ruby application to read, write and delete files in a
-  MogileFS instance.
-email: e@80x24.org
+  distributed filesystem, see: http://mogilefs.org for more details.
+  This library allows any Ruby application to read, write and delete
+  files in a MogileFS instance.
+email: mogilefs-client-public@bogomips.org
 executables:
 - mog
 extensions: []
@@ -94,6 +80,7 @@ files:
 - test/test_backend.rb
 - test/test_bigfile.rb
 - test/test_client.rb
+- test/test_cmogstored.rb
 - test/test_db_backend.rb
 - test/test_fresh.rb
 - test/test_http_reader.rb
@@ -103,11 +90,11 @@ files:
 - test/test_mogilefs_integration_list_keys.rb
 - test/test_mogilefs_socket_kgio.rb
 - test/test_mogilefs_socket_pure.rb
-- test/test_mogstored_rack.rb
 - test/test_mogtool_bigfile.rb
 - test/test_mysql.rb
+- test/test_nhp_compat.rb
 - test/test_pool.rb
-homepage: http://bogomips.org/mogilefs-client
+homepage: https://bogomips.org/mogilefs-client/
 licenses:
 - BSD-3-Clause
 metadata: {}
@@ -127,8 +114,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.6
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
-summary: client - MogileFS client library for Ruby
+summary: MogileFS client library for Ruby
 test_files: []