omgf 0.0.0.GIT → 0.0.1.GIT

data/.gitignore

@@ -12,3 +12,4 @@ pkg/
 /man
 /tmp
 /LATEST
+lib/omgf/version.rb

data/GIT-VERSION-GEN

@@ -1,40 +1,30 @@
-#!/bin/sh
-
-GVF=GIT-VERSION-FILE
-DEF_VER=v0.0.0.GIT
-
-LF='
-'
+#!/usr/bin/env ruby
+CONSTANT = "OMGF::VERSION"
+RVF = "lib/omgf/version.rb"
+GVF = "GIT-VERSION-FILE"
+DEF_VER = "v0.0.1.GIT"
+vn = DEF_VER
 
 # First see if there is a version file (included in release tarballs),
 # then try git-describe, then default.
-if test -f version
-then
-	VN=$(cat version) || VN="$DEF_VER"
-elif test -d .git -o -f .git &&
-	VN=$(git describe --abbrev=4 HEAD 2>/dev/null) &&
-	case "$VN" in
-	*$LF*) (exit 1) ;;
-	v[0-9]*)
-		git update-index -q --refresh
-		test -z "$(git diff-index --name-only HEAD --)" ||
-		VN="$VN-dirty" ;;
-	esac
-then
-	VN=$(echo "$VN" | sed -e 's/-/./g');
-else
-	VN="$DEF_VER"
-fi
-
-VN=$(expr "$VN" : v*'\(.*\)')
+if File.exist?(".git")
+  describe = `git describe --abbrev=4 HEAD 2>/dev/null`.strip
+  case describe
+  when /\Av[0-9]*/
+    vn = describe
+    system(*%w(git update-index -q --refresh))
+    unless `git diff-index --name-only HEAD --`.chomp.empty?
+      vn << "-dirty"
+    end
+    vn.tr!('-', '.')
+  end
+end
 
-if test -r $GVF
-then
-	VC=$(sed -e 's/^GIT_VERSION = //' <$GVF)
-else
-	VC=unset
-fi
-test "$VN" = "$VC" || {
-	echo >&2 "GIT_VERSION = $VN"
-	echo "GIT_VERSION = $VN" >$GVF
-}
+vn = vn.sub!(/\Av/, "")
+new_ruby_version = "#{CONSTANT} = '#{vn}'\n"
+cur_ruby_version = File.read(RVF) rescue nil
+if new_ruby_version != cur_ruby_version
+  File.open(GVF, "w") { |fp| fp.write("GIT_VERSION = #{vn}\n") }
+  File.open(RVF, "w") { |fp| fp.write(new_ruby_version) }
+end
+puts vn if $0 == __FILE__

data/GNUmakefile

@@ -2,4 +2,5 @@ all::
 RSYNC_DEST := bogomips.org:/srv/bogomips/omgf
 rfproject := rainbows
 rfpackage := omgf
+pkg_extra += lib/omgf/version.rb
 include pkg.mk

data/examples/verify_paths_manual_test.rb

@@ -0,0 +1,20 @@
+# -*- encoding: binary -*-
+require "omgf/verify_paths"
+require "logger"
+require "uri"
+require "pp"
+vp = OMGF::VerifyPaths.new(Logger.new($stderr))
+urls = %w(
+  http://yhbt.net/
+  http://bogomips.org/omgf.git
+  http://bogomips.org/ozZZZZmgf.git
+  http://bogomips.org/ozZZZZ
+  http://bogomips.org/
+  http://127.0.0.1:666/
+)
+uris = urls.map { |uri| URI(uri) }
+
+pp vp.verify(uris, 1, 0.1)
+uris = urls.map { |uri| URI(uri) }
+sleep 1
+pp vp.verify(uris, 1, 0.1)

data/lib/omgf.rb

@@ -4,3 +4,4 @@
 # :startdoc:
 module OMGF
 end
+require "omgf/version"

data/lib/omgf/hysterical_raisins.rb

@@ -4,6 +4,7 @@
 # License: AGPLv3 or later (https://www.gnu.org/licenses/agpl-3.0.txt)
 # :startdoc:
 require "omgf/pool"
+require "omgf/verify_paths"
 require "time"
 require "json"
 require "mogilefs"
@@ -41,7 +42,15 @@ class OMGF::HystericalRaisins
       noverify: opts[:noverify],
       pathcount: opts[:pathcount] || 0x7fffffff,
     }
+    @new_file_opts = {
+      content_md5: opts[:content_md5], # :trailer is acceptable here
+
+      # largefile: auto-selects based on env["CONTENT_LENGTH"]
+      largefile: opts[:largefile] || :stream,
+    }
     @put_overwrite_header = opts[:put_overwrite_header] || "HTTP_X_OMGF_FORCE"
+    @vp = OMGF::VerifyPaths.new(opts[:logger])
+    @verify_timeout = opts[:verify_timeout] || 0.5
     pool_init(mg_opts)
   end
 
@@ -98,13 +107,16 @@ class OMGF::HystericalRaisins
 
   # HEAD /$DOMAIN/$KEY
   def stat_key(env, domain, key)
-    size, paths = mg_size_and_paths(domain, key, @get_paths_opts)
-    return r(503, "") unless paths && location = paths[0]
+    size, uris = mg_size_and_uris(domain, key, @get_paths_opts)
+    uris = @vp.verify(uris, 1, @verify_timeout).flatten!
+
+    return r(503, "") unless uris && uris[0]
+
     h = { "Content-Length" => size.to_s }
     fn = filename(h, query(env)) || key
     h["Content-Type"] = key_mime_type(fn)
-    unless reproxy?(env, key, h, location)
-      paths.each_with_index { |path,i| h["X-URL-#{i}"] = path }
+    unless reproxy?(env, key, h, uris[0].to_s)
+      uris.each_with_index { |uri,i| h["X-URL-#{i}"] = uri.to_s }
     end
     [ 200, h, [] ]
   end
@@ -112,6 +124,7 @@ class OMGF::HystericalRaisins
   # GET /$DOMAIN/$KEY
   def redirect_key(env, domain, key)
     uris = mg_get_uris(domain, key, @get_paths_opts)
+    uris = @vp.verify(uris, 1, @verify_timeout).flatten!
 
     return r(503, "") unless uris && dest = uris.shift
 
@@ -123,7 +136,6 @@ class OMGF::HystericalRaisins
     }
 
     unless reproxy?(env, key, h, location)
-      uris -= [ dest ]
       uris.each_with_index { |uri,i| h["X-Alt-Location-#{i}"] = uri.to_s }
     end
     [ 302, h, [] ]
@@ -252,16 +264,39 @@ class OMGF::HystericalRaisins
     return r(406, "key `#{key}' is not URI-friendly") if bad_key?(key)
     return r(406, "key is too long") if key.size > 128
 
+    clen = env["CONTENT_LENGTH"]
+
     # this was written before MogileFS supported empty files,
     # but empty files waste DB space so we don't support them
     # Not bothering with Transfer-Encoding: chunked, though...
-    return r(403, "empty files forbidden") if env["CONTENT_LENGTH"] == "0"
+    return r(403, "empty files forbidden") if "0" == clen
 
     params = query(env)
     input = env["rack.input"]
     paths = nil
     retried = false
 
+    # prepare options for create_open/create_close:
+    new_file_opts = @new_file_opts.dup
+
+    # the original deployment of this created a class for every
+    # domain with the same class having the same name as the domain
+    new_file_opts[:class] = params['class'] || @default_class_cb[domain]
+
+    # try to give a Content-Length to the tracker
+    clen and new_file_opts[:content_length] = clen.to_i
+
+    if /\bContent-MD5\b/i =~ env["HTTP_TRAILER"]
+      # if the client will give the Content-MD5 as the trailer,
+      # we must lazily populate it since we're not guaranteed to
+      # have the trailer, yet (rack.input is lazily read on unicorn)
+      new_file_opts[:content_md5] = lambda { env["HTTP_CONTENT_MD5"] }
+    elsif cmd5 = env["HTTP_CONTENT_MD5"]
+      # maybe the client gave the Content-MD5 in the header
+      new_file_opts[:content_md5] = cmd5
+    end
+
+    buf = ""
     begin
       pool_use(domain) do |mg|
         begin
@@ -281,14 +316,17 @@ class OMGF::HystericalRaisins
           # good, not clobbering anything
         end
 
-        # the original deployment of this created a class for every
-        # domain with the same class having the same name as the domain
-        klass = params['class'] || @default_class_cb[domain] || "default"
-        mg.store_file(key, klass, input)
+        # finally, upload the file
+        mg.new_file(key, new_file_opts) do |io|
+          while input.read(16384, buf)
+            io.write(buf)
+          end
+        end
       end # pool_use
 
       # should always return 201 if ! found, but we keep 200 for legacy
       # compat if they're not logged in (via REMOTE_USER)
+      buf.clear
       status = paths ? 204 : (env["REMOTE_USER"] ? 201 : 200)
       r(status, "")
     rescue MogileFS::Backend::UnregDomainError,

data/lib/omgf/pool.rb

@@ -40,9 +40,9 @@ module OMGF::Pool
     pool_use(domain) { |mg| mg.get_uris(key, opts) }
   end
 
-  def mg_size_and_paths(domain, key, opts) # :nodoc:
+  def mg_size_and_uris(domain, key, opts) # :nodoc:
     pool_use(domain) do |mg|
-      [ mg.size(key), mg.get_paths(key, opts) ]
+      [ mg.size(key), mg.get_uris(key, opts) ]
     end
   end
 end

data/lib/omgf/verify_paths.rb

@@ -0,0 +1,241 @@
+# -*- encoding: binary -*-
+# :stopdoc:
+# Copyright (C) 2008-2012, Eric Wong <normalperson@yhbt.net>
+# License: AGPLv3 or later (https://www.gnu.org/licenses/agpl-3.0.txt)
+# :startdoc:
+require "thread"
+require "omgf"
+require "kcar"
+require "kgio"
+
+# This module makes HEAD requests with reusable HTTP connections to
+# verify paths.  This is faster than having the mogilefsd tracker
+# verifying paths, and the client could have broken routing to some
+# the storage nodes the mogilefsd tracker/monitor can see.
+class OMGF::VerifyPaths
+
+  # private class
+  class HeadSock < Kgio::Socket # :nodoc:
+    VERSION = '1.0.0'
+
+    attr_reader :uri
+    attr_writer :retry_ok
+
+    def self.start(uri)
+      super(Socket.pack_sockaddr_in(uri.port, uri.host))
+    end
+
+    # returns true if the HTTP connection is reusable
+    def http_reusable?
+      rv = @kcar.keepalive?
+      @kcar.reset
+      @headers.clear
+      @buf.clear
+      @uri = nil
+      rv ? setsockopt(:SOL_SOCKET, :SO_KEEPALIVE, 1) : close
+      rv
+    end
+
+    def http_init(uri, retry_ok = true)
+      @uri = uri
+      unless defined?(@kcar)
+        @kcar = Kcar::Parser.new
+        @headers = {}
+        @buf = ""
+      end
+      @retry_ok = retry_ok
+
+      # prepare the HTTP request
+      @req = "HEAD #{@uri.request_uri} HTTP/1.1\r\n" \
+             "User-Agent: #{self.class}/#{VERSION}\r\n" \
+             "Host: #{@uri.host}:#{@uri.port}\r\n" \
+             "\r\n"
+    end
+
+    # returns an array result if successful
+    # returns :wait_readable or :wait_writable if incomplete
+    # returns a subclass of Exception on errors
+    # returns nil on premature EOF (twice)
+    def poll_iter(pollset)
+      case rv = kgio_trywrite(@req)
+      when nil, # done writing, start reading
+           String # partial write
+        @req = rv # continue looping
+      when Symbol
+        return pollset[self] = rv # busy
+      end while @req
+
+      case rv = kgio_tryread(666)
+      when String
+        if ary = @kcar.headers(@headers, @buf << rv)
+          pollset.delete(self)
+          return ary # success
+        end
+        # continue looping if incomplete
+      when Symbol
+        return pollset[self] = rv # busy
+      when nil # EOF (premature)
+        return maybe_retry(nil, pollset)
+      end while true
+    rescue => err
+      maybe_retry(err, pollset)
+    end
+
+    # returns the err object if we've already retried, nil otherwise
+    def maybe_retry(err, pollset)
+      pollset.delete(self)
+      return err unless @retry_ok
+
+      # always start a fresh connection on socket errors
+      sock = self.class.start(@uri)
+      sock.http_init(@uri, false)
+      pollset[sock] = :wait_writable
+    end
+  end
+
+  def initialize(logger)
+    @pool = Hash.new { |hash,host_port| hash[host_port] = [] }
+    @logger = logger
+    @finishq = Queue.new
+    @finisher = nil
+    @lock = Mutex.new
+    @pid = $$
+  end
+
+  def error(msg)
+    @logger.error(msg) if @logger
+  end
+
+  def iter_check(ok, sock, pollset)
+    rv = sock.poll_iter(pollset)
+    case rv
+    when Symbol # in progress
+    when Array
+      code = rv[0].to_i
+      if 200 == code
+        ok << sock.uri
+      elsif code >= 100 && code <= 999
+        error("HEAD #{sock.uri} returned HTTP code: #{code}")
+      else
+        error("HEAD #{sock.uri} returned #{rv.inspect} (kcar bug?)")
+      end
+      sock_put(sock)
+    when nil # premature EOF
+      error("HEAD #{sock.uri} hit socket EOF")
+    else
+      # exception or some other error return value...
+      if rv.respond_to?(:message)
+        error("HEAD #{sock.uri} error: #{rv.message} (#{rv.class})")
+      else
+        error("HEAD #{sock.uri} error (#{rv.class}): #{rv.inspect}")
+      end
+    end
+    rv
+  end
+
+  # this runs in a background thread to cleanup all the requests
+  # that didn't finish quickly enough
+  def finisher(timeout = 10000)
+    begin
+      pollset = @finishq.pop # park here when idle
+
+      while ready = Kgio.poll(pollset.dup, timeout)
+        ready.each_key do |sock|
+          sock.retry_ok = false
+          # try to return good sockets back to the pool
+          iter_check([], sock, pollset)
+        end
+
+        # try to stuff the pollset as much as possible for further looping
+        while more = (@finishq.pop(true) rescue nil)
+          pollset.merge!(more)
+        end
+      end
+
+      # connections timed out, kill them
+      pollset.each_key { |sock| sock.close }
+    rescue => err
+      error("#{err.message} (#{err.class})")
+    end while true
+  end
+
+  # reorders URIs based on response time
+  # This is the main method of this class
+  def verify(uris, count, timeout)
+    tout = (timeout * 1000).to_i
+    pollset = {}
+    ok = []
+
+    uris.each do |uri|
+      sock = sock_get(uri) and iter_check(ok, sock, pollset)
+    end
+
+    while ok.size < count && tout > 0 && ! pollset.empty?
+      t0 = Time.now
+      ready = Kgio.poll(pollset.dup, tout) or break
+      tout -= ((Time.now - t0) * 1000).to_i
+
+      ready.each_key do |sock|
+        iter_check(ok, sock, pollset)
+      end
+    end
+
+    finish(pollset) unless pollset.empty?
+    [ok, uris - ok] # good URLs first
+  end
+
+  # recover any unfinished URLs in pollset asynchronously in the background
+  def finish(pollset) # :nodoc:
+    @finishq.push(pollset)
+    @lock.synchronize do
+      unless @finisher && @finisher.alive?
+        @finisher = Thread.new { finisher }
+      end
+    end
+  end
+
+  # returns a string key for the connection pool
+  def key_for(uri)
+    "#{uri.host}:#{uri.port}"
+  end
+
+  # initializes a cached connection for +uri+ or creates a new one
+  def sock_get(uri)
+    key = key_for(uri)
+
+    # detect forks and prevent sharing of connected sockets across processes
+    @lock.synchronize do
+      if @pid != $$
+        @pid = $$
+        @pool.clear
+      end
+    end
+
+    while sock = @lock.synchronize { @pool[key].pop }
+      begin
+        # check if sock is still alive and idle
+        # :wait_readable is good here
+        break if sock.kgio_tryread(1) == :wait_readable
+      rescue
+        # ignore socket errors, we'll just give them a new socket
+        # socket should've been idle, but it was not (or EOFed on us)
+        # give them a new one
+      end
+      sock.close
+    end
+
+    sock ||= HeadSock.start(uri)
+    sock.http_init(uri)
+    sock
+  rescue
+    # we'll return nil on any errors
+  end
+
+  # returns an idle socket to the pool
+  def sock_put(sock)
+    key = key_for(sock.uri)
+    sock.http_reusable? and @lock.synchronize { @pool[key] << sock }
+  rescue => err
+    error("HTTP reuse check failed: #{err.message} (#{err.class})")
+  end
+end

data/omgf.gemspec

@@ -20,6 +20,8 @@ Gem::Specification.new do |s|
   s.rdoc_options = rdoc_options
   s.test_files = Dir['test/test_*.rb']
   s.add_dependency('rack', ['~> 1.3'])
+  s.add_dependency('kgio', ['~> 2.7'])
+  s.add_dependency('kcar', ['~> 0.3'])
   s.add_dependency('mogilefs-client', ['~> 3.1'])
 
   s.licenses = %w(AGPLv3+)

data/test/integration.rb

@@ -67,9 +67,9 @@ module TestMogileFSIntegration
     [ status, out, err ]
   end
 
-  def setup_mogilefs(plugins = nil)
+  def setup_mogilefs(plugins = nil, mogstored = "mogstored")
     @test_host = "127.0.0.1"
-    setup_mogstored
+    setup_mogstored(mogstored)
     @tracker = TCPServer.new(@test_host, 0)
     @tracker_port = @tracker.addr[1]
 
@@ -173,7 +173,7 @@ EOF
     raise "#{uri} failed to appear: #{res.inspect}"
   end
 
-  def setup_mogstored
+  def setup_mogstored(mogstored = "mogstored")
     @docroot = Dir.mktmpdir(["mogfresh", "docroot"])
     Dir.mkdir("#@docroot/dev1")
     Dir.mkdir("#@docroot/dev2")
@@ -194,7 +194,7 @@ EOF
     @mogstored_mgmt.close
     @mogstored_http.close
 
-    x!("mogstored", "--daemon", "--config=#{@mogstored_conf.path}")
+    x!(mogstored, "--daemon", "--config=#{@mogstored_conf.path}")
     wait_for_port @mogstored_mgmt_port
     wait_for_port @mogstored_http_port
   end

data/test/test_hysterical_raisins.rb

@@ -4,15 +4,17 @@ require './test/integration'
 require 'rack/mock'
 require 'open-uri'
 require 'omgf/hysterical_raisins'
+require 'digest/md5'
 
 class TestHystericalRaisins < Test::Unit::TestCase
   include TestMogileFSIntegration
   def setup
     setup_mogilefs
-    @app = OMGF::HystericalRaisins.new(:hosts => @hosts)
-    @req = Rack::MockRequest.new(@app)
     @err = StringIO.new
-    @opts = { "rack.logger" => Logger.new(@err) }
+    logger = Logger.new(@err)
+    @opts = { "rack.logger" => logger }
+    @app = OMGF::HystericalRaisins.new(:hosts => @hosts, :logger => logger)
+    @req = Rack::MockRequest.new(@app)
     @admin.create_domain("testdom")
   end
 
@@ -186,13 +188,21 @@ class TestHystericalRaisins < Test::Unit::TestCase
 
     # wait for replication
     if ENV["EXPENSIVE"]
-      200.times do
-        resp["X-URL-1"] and break
-        sleep 0.1
+      50.times do
         resp = @req.head("/testdom/key", @opts)
+        assert_equal 200, resp.status, resp.inspect
+        resp["X-URL-1"] and break
+        sleep 0.5
       end
-      assert_kind_of String, resp["X-URL-1"]
+      assert_kind_of String, resp["X-URL-1"], resp.inspect
       assert_equal "BLAH", open(resp["X-URL-1"]).read
+
+      # Location should not be in X-Alt-Location, too
+      resp = @req.get("/testdom/key", @opts)
+      assert_equal 302, resp.status, resp.inspect
+      assert_kind_of URI, URI(resp["Location"])
+      assert_kind_of URI, URI(resp["X-Alt-Location-0"])
+      assert_nil resp["X-Alt-Location-1"]
     end
 
     reproxy_test
@@ -232,6 +242,24 @@ class TestHystericalRaisins < Test::Unit::TestCase
     @app.instance_variable_set(:@reproxy_path, nil)
   end
 
+  def test_checksums
+    mogadm!("class", "add", "testdom", "md5", "--hashtype=MD5")
+    100.times do
+      @admin.get_domains["testdom"]["md5"] and break
+      sleep 0.5
+    end
+    assert_equal "MD5", @admin.get_domains["testdom"]["md5"]["hashtype"]
+    sio = StringIO.new("HELLO")
+    md5 = [ Digest::MD5.digest(sio.string) ].pack('m0')
+    opts = @opts.merge(input: sio, method: "PUT", "HTTP_CONTENT_MD5" => md5)
+    resp = @req.put("/testdom/cc?class=md5", opts)
+    assert_equal 200, resp.status
+    @mg = MogileFS::MogileFS.new(hosts: @hosts, domain: "testdom")
+    info = @mg.file_info("cc")
+    assert_equal "md5", info["class"]
+    assert_equal "MD5:#{Digest::MD5.hexdigest(sio.string)}", info["checksum"]
+  end
+
   def teardown
     teardown_mogilefs
   end

data/test/test_hysterical_raisins_cmogstored.rb

@@ -0,0 +1,54 @@
+# Copyright (C) 2008-2012, Eric Wong <normalperson@yhbt.net>
+# License: AGPLv3 or later (https://www.gnu.org/licenses/agpl-3.0.txt)
+require './test/integration'
+require 'rack/mock'
+require 'open-uri'
+require 'omgf/hysterical_raisins'
+require 'digest/md5'
+
+class TestHystericalRaisinsCmogstored < Test::Unit::TestCase
+  include TestMogileFSIntegration
+  def setup
+    setup_mogilefs(nil, "cmogstored")
+    @err = StringIO.new
+    logger = Logger.new(@err)
+    @opts = { "rack.logger" => logger }
+    @app = OMGF::HystericalRaisins.new(:hosts => @hosts, :logger => logger)
+    @req = Rack::MockRequest.new(@app)
+    @admin.create_domain("testdom")
+  end
+
+  def test_checksums_trailer
+    mogadm!("class", "add", "testdom", "md5", "--hashtype=MD5")
+    100.times do
+      @admin.get_domains["testdom"]["md5"] and break
+      sleep 0.5
+    end
+    assert_equal "MD5", @admin.get_domains["testdom"]["md5"]["hashtype"]
+
+    sio = StringIO.new("HELLO")
+    def sio.read(*_)
+      rv = super
+      if rv == nil
+        md5 = [ Digest::MD5.digest(string) ].pack('m0')
+        @rack_env["HTTP_CONTENT_MD5"] = md5
+      end
+      rv
+    end
+
+    opts = @opts.merge(input: sio, method: "PUT")
+    opts["HTTP_TRAILER"] = "Content-MD5"
+    env = @req.class.env_for("/testdom/cc?class=md5", opts)
+    sio.instance_variable_set(:@rack_env, env)
+    status, _, _ = @app.call(env)
+    assert_equal 200, status, @err.string
+    @mg = MogileFS::MogileFS.new(hosts: @hosts, domain: "testdom")
+    info = @mg.file_info("cc")
+    assert_equal "md5", info["class"]
+    assert_equal "MD5:#{Digest::MD5.hexdigest(sio.string)}", info["checksum"]
+  end
+
+  def teardown
+    teardown_mogilefs
+  end
+end if `which cmogstored 2>/dev/null` =~ /\bcmogstored\b/

metadata

@@ -2,7 +2,7 @@
 name: !binary |-
   b21nZg==
 version: !ruby/object:Gem::Version
-  version: 0.0.0.GIT
+  version: 0.0.1.GIT
   prerelease: 6
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-20 00:00:00.000000000 Z
+date: 2012-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: !binary |-
@@ -34,6 +34,48 @@ dependencies:
       - !ruby/object:Gem::Version
         version: !binary |-
           MS4z
+- !ruby/object:Gem::Dependency
+  name: !binary |-
+    a2dpbw==
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - !binary |-
+        fj4=
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          Mi43
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - !binary |-
+        fj4=
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          Mi43
+- !ruby/object:Gem::Dependency
+  name: !binary |-
+    a2Nhcg==
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - !binary |-
+        fj4=
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MC4z
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - !binary |-
+        fj4=
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MC4z
 - !ruby/object:Gem::Dependency
   name: !binary |-
     bW9naWxlZnMtY2xpZW50
@@ -71,6 +113,8 @@ extra_rdoc_files:
 - lib/omgf.rb
 - lib/omgf/hysterical_raisins.rb
 - lib/omgf/pool.rb
+- lib/omgf/verify_paths.rb
+- lib/omgf/version.rb
 - NEWS
 - README
 files:
@@ -88,14 +132,18 @@ files:
 - README
 - examples/hyst.README
 - examples/hyst.bash
+- examples/verify_paths_manual_test.rb
 - lib/omgf.rb
 - lib/omgf/hysterical_raisins.rb
 - lib/omgf/pool.rb
+- lib/omgf/verify_paths.rb
+- lib/omgf/version.rb
 - omgf.gemspec
 - pkg.mk
 - test/integration.rb
 - test/test_hyst.rb
 - test/test_hysterical_raisins.rb
+- test/test_hysterical_raisins_cmogstored.rb
 homepage: http://bogomips.org/omgf/
 licenses:
 - !binary |-
@@ -127,6 +175,8 @@ signing_key:
 specification_version: 3
 summary: hysterical REST API for MogileFS using Rack
 test_files:
+- !binary |-
+  dGVzdC90ZXN0X2h5c3RlcmljYWxfcmFpc2luc19jbW9nc3RvcmVkLnJi
 - !binary |-
   dGVzdC90ZXN0X2h5c3QucmI=
 - !binary |-