srvy 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 720038b1f82de00846abd452dcacb9e847c5467f
+  data.tar.gz: 4a6b6e85214b477add94f062b7a50c66272922fd
+SHA512:
+  metadata.gz: 6e498289f089c7ae9fc73cc587db8cf6638d03c6dc1ad739a572fcf3901af34c82b3fe240b0922a6f9504e2139f52465a3d2a40c8a385bd2de14802a3de2f76a
+  data.tar.gz: 2f9579278a60f8b8e115238430516477a6d19ecc585a43a821943a325acbfa026a661d28fa975d9456af41a97971a8c8b9bbcd073f6fd4ba3f4f16b262e5c787

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.DS_Store

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.1.0
+  - 2.0.0
+  - 1.9.3
+  - jruby

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in srvy.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Scott Fleckenstein
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,50 @@
+# Srvy
+[![Build Status](https://travis-ci.org/nullstyle/srvy.png?branch=master)](https://travis-ci.org/nullstyle/srvy)
+[![Coverage Status](https://coveralls.io/repos/nullstyle/srvy/badge.png)](https://coveralls.io/r/nullstyle/srvy)
+[![Code Climate](https://codeclimate.com/github/nullstyle/srvy.png)](https://codeclimate.com/github/nullstyle/srvy)
+
+A rubygem to integrate SRV-based service discovery into your application
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'srvy'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install srvy
+
+## Usage
+
+```ruby
+$srvy = Srvy::Resolver.new # default configuration, using the locally configured resolver
+
+# picks a single server by randomized with weight in the highest priority group
+$srvy.get_single("db-slaves.mydomain.com") # => "mysql01.mydomain.com:3306"
+
+# to get all services in the highest priority group 
+$srvy.get_many("memcache.mydomain.com") # => ["memcache01.mydomain.com:11211", "memcache02.mydomain.com:11211"]
+
+# get all records, including lower priority (e.g. backup) services
+$srvy.get_all("db.mydomain.com") # => ["db01.mydomain.com:3306", "db01-failover.mydomain.com:3306"]
+
+```
+
+
+
+#TODO
+
+I havent currently thought of a good api to signal to Srvy that you want to use lower priority services... currently the only way is to use `get_all` and pick the services out yourself.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ["-c", "-f progress", "-r ./spec/spec_helper.rb"]
+end
+
+task :default => [:spec]
+

data/lib/lru_redux/has_key_monkey_patch.rb

@@ -0,0 +1,10 @@
+require 'lru_redux'
+
+module HasKey
+  def has_key?(key)
+    @data.has_key?(key)
+  end
+end
+
+
+LruRedux::Cache.send(:include, HasKey)

data/lib/net/dns/ext/resolver_nameserver_monkey_patch.rb

@@ -0,0 +1,36 @@
+require 'net/dns'
+
+Net::DNS::Resolver.class_eval do
+  def nameservers=(arg)
+    @config[:nameservers] = convert_nameservers_arg_to_ips(arg)
+    @logger.info "Nameservers list changed to value #{@config[:nameservers].inspect}"
+  end
+
+  private
+  def convert_nameservers_arg_to_ips(arg)
+    case arg
+    when IPAddr ; [arg]
+    when String ;
+      begin
+      [IPAddr.new(arg)]
+      rescue ArgumentError # arg is in the name form, not IP
+        nameservers_from_name(arg)
+      end
+    when Array ;
+      arg.map{|x| convert_nameservers_arg_to_ips(x) }.flatten
+    else
+      raise ArgumentError, "Wrong argument format, neither String, Array nor IPAddr"
+    end
+  end
+
+  def nameservers_from_name(arg)
+    arr = []
+    arg.split(" ").each do |name|
+      Net::DNS::Resolver.new.search(name).each_address do |ip|
+        arr << ip
+      end
+    end
+    arr
+  end
+
+end

data/lib/srvy.rb

@@ -0,0 +1,10 @@
+require "srvy/version"
+require "net/dns/ext/resolver_nameserver_monkey_patch"
+
+module Srvy
+  autoload :Resolver, "srvy/resolver"
+  autoload :Result,   "srvy/result"
+  autoload :Host,     "srvy/host"
+
+  autoload :Formatters, "srvy/formatters"
+end

data/lib/srvy/formatters.rb

@@ -0,0 +1,23 @@
+module Srvy
+  module Formatters
+    autoload :Base,     "srvy/formatters/base"
+    autoload :HostPort, "srvy/formatters/host_port"
+    autoload :Dalli,    "srvy/formatters/dalli"
+
+    def self.from_name(name)
+      case name.to_sym
+      when :host_port ; HostPort.new
+      when :dalli ;     Dalli.new
+      else ;            raise ArgumentError, "Unknown formatter name: #{name}"
+      end
+    end
+
+    def self.format_single(format_name, result)
+      from_name(format_name).format_single(result)
+    end
+
+    def self.format_many(format_name, result)
+      from_name(format_name).format_many(result)
+    end
+  end
+end

data/lib/srvy/formatters/base.rb

@@ -0,0 +1,17 @@
+module Srvy
+  module Formatters
+    class Base
+
+      def format_single(host)
+        raise NotImplementedError
+      end
+
+      def format_many(hosts)
+        # default to mapping over the collection with the format_single form
+        # by having a separate format_many call, we can build formatters
+        # that aggregate results in some way (such as producing a map of the hosts)
+        hosts.map{|h| format_single h}
+      end
+    end
+  end
+end

data/lib/srvy/formatters/dalli.rb

@@ -0,0 +1,11 @@
+module Srvy
+  module Formatters
+    class Dalli < Base
+
+      def format_single(host)
+        "#{host.host}:#{host.port}:#{host.weight}"
+      end
+      
+    end
+  end
+end

data/lib/srvy/formatters/host_port.rb

@@ -0,0 +1,11 @@
+module Srvy
+  module Formatters
+    class HostPort < Base
+
+      def format_single(host)
+        "#{host.host}:#{host.port}"
+      end
+      
+    end
+  end
+end

data/lib/srvy/host.rb

@@ -0,0 +1,18 @@
+module Srvy
+  class Host
+
+    attr_reader :host
+    attr_reader :port
+    attr_reader :weight
+    attr_reader :priority
+    attr_reader :ttl
+
+    def initialize(host, port, weight, priority, ttl)
+      @host     = host
+      @port     = port
+      @weight   = weight
+      @priority = priority
+      @ttl      = ttl
+    end
+  end
+end

data/lib/srvy/resolver.rb

@@ -0,0 +1,61 @@
+require "net/dns/ext/resolver_nameserver_monkey_patch"
+require 'lru_redux/has_key_monkey_patch'
+
+module Srvy
+  class Resolver
+    attr_reader :cache
+
+    def initialize(options={})
+      @dns       = Net::DNS::Resolver.new
+
+      if options[:nameserver]
+        @dns.nameservers = options[:nameserver] 
+      end
+
+      cache_size = options[:cache_size] || 100
+      @cache     = LruRedux::Cache.new(cache_size) #cache of host -> result kv pairs
+    end
+
+    def inspect
+      "#<Srvy::Resolver:#{object_id} dns=#{@dns.nameservers.inspect}>"
+    end
+
+    def get_single(host, format=:host_port)
+      result = get(host).get_single
+
+      Srvy::Formatters.format_single(format, result)
+    end
+
+    def get_many(host, format=:host_port)
+      result = get(host).get_many
+      Srvy::Formatters.format_many(format, result)
+    end
+
+    def get_all(host, format=:host_port)
+      result = get(host).get_all
+      Srvy::Formatters.format_many(format, result)
+    end
+
+    def get_dns(host)
+      @dns.search(host, Net::DNS::SRV)
+    end
+
+    # Gets the Srvy::Result from the cache or from dns.
+    #
+    # host  - The String hostname to query for SRV records.
+    #
+    #
+    # Returns the Srvy::Result for that hostname
+    def get(host)
+      result = @cache[host]
+
+      if !result || result.expired?
+        result = Srvy::Result.from_dns get_dns(host)
+        @cache[host] = result
+      end
+     
+      result
+    end
+
+  end
+end

data/lib/srvy/result.rb

@@ -0,0 +1,61 @@
+module Srvy
+  class Result
+    EMPTY_RESULT_TTL = 10
+
+    def self.from_dns(dns_result)
+      # for each SRV record
+      srvs = dns_result.answer.select{|rr| rr.is_a?(Net::DNS::RR::SRV) }
+      hosts = srvs.map do |srv|
+        Srvy::Host.new(srv.host, srv.port, srv.weight, srv.priority, srv.ttl)
+      end
+
+      new(Time.now, hosts)
+    end
+
+    def initialize(created_at, hosts)
+      @created_at = created_at
+      @hosts      = hosts
+    end
+
+    def get_single
+      return nil if @hosts.empty?
+
+      roll = rand(best_priority_cumulative_weight)
+      acc = 0
+
+      best_priority_hosts_by_weight.each do |host|
+        acc += host.weight
+        return host if roll < acc
+      end
+    end
+
+    def get_many
+      best_priority_hosts_by_weight
+    end
+
+    def get_all
+      @hosts
+    end
+
+    def expired?
+      now = Time.now
+      min_ttl = @hosts.map(&:ttl).min
+      min_ttl ||= EMPTY_RESULT_TTL # in case there are no hosts
+      @created_at + min_ttl < now
+    end
+
+    private
+    def best_priority_hosts_by_weight
+      # sorted weight descending
+      best_priority_hosts_by_weight ||= @hosts.select{|s| s.priority <= best_priority }.sort_by(&:weight).reverse
+    end
+
+    def best_priority_cumulative_weight
+      best_priority_hosts_by_weight.map(&:weight).inject(0, :+)
+    end
+
+    def best_priority
+      @best_priority ||= @hosts.map(&:priority).min
+    end
+  end
+end

data/lib/srvy/version.rb

@@ -0,0 +1,3 @@
+module Srvy
+  VERSION = "0.0.1"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+  require 'rspec'
+  require 'rspec/given'
+  require 'srvy'
+  require 'coveralls'
+  require 'timecop'
+  require 'active_support/all'
+  
+  Coveralls.wear!
+
+  RSpec.configure do |config|
+  
+
+  end

data/spec/srvy/formatters/base_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Srvy::Formatters::Base, "format_single" do
+  Given(:host)      { Srvy::Host.new("test01.host.com", 11211, 0, 0, 100) }
+
+  When(:result){ subject.format_single(host) }
+
+  Then { expect(result).to have_failed(NotImplementedError) }
+end
+

data/spec/srvy/formatters/dalli_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Srvy::Formatters::Dalli, "format_single" do
+  Given(:host) { Srvy::Host.new("test01.host.com", 11211, 10, 0, 100) }
+
+  When(:result){ subject.format_single(host) }
+
+  Then{ expect(result).to eq("test01.host.com:11211:10") }
+end
+
+
+describe Srvy::Formatters::Dalli, "format_many" do
+  Given(:hosts) { [
+    Srvy::Host.new("test01.host.com", 11211, 10, 0, 100),
+    Srvy::Host.new("test02.host.com", 11211, 5,  0, 100),
+  ] }
+
+  When(:result){ subject.format_many(hosts) }
+
+  Then{ expect(result).to eq(["test01.host.com:11211:10", "test02.host.com:11211:5"]) }
+end

data/spec/srvy/formatters/host_port_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Srvy::Formatters::HostPort, "format_single" do
+  Given(:host)      { Srvy::Host.new("test01.host.com", 11211, 0, 0, 100) }
+
+  When(:result){ subject.format_single(host) }
+
+  Then{ expect(result).to eq("test01.host.com:11211") }
+end
+
+
+describe Srvy::Formatters::HostPort, "format_many" do
+  Given(:hosts)      { [Srvy::Host.new("test01.host.com", 11211, 0, 0, 100)] * 2 }
+
+  When(:result){ subject.format_many(hosts) }
+
+  Then{ expect(result).to eq(["test01.host.com:11211", "test01.host.com:11211"]) }
+end

data/spec/srvy/formatters_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Srvy::Formatters, "#from_name" do
+  
+  context "with an invalid name" do
+    Given(:name){ "some_formatter" }
+    When(:result) { Srvy::Formatters.from_name(name) }
+    Then { expect(result).to have_failed(ArgumentError, /Unknown/) }
+  end
+
+
+  context "with host_port" do
+    Given(:name){ "host_port" }
+    When(:result) { Srvy::Formatters.from_name(name) }
+    Then { expect(result).to be_kind_of(Srvy::Formatters::HostPort) }
+  end
+end
+
+describe Srvy::Formatters, "#format_single" do
+  Given(:formatter) { double("Formatter", :format_single => true)}
+  Given(:name)      { "host_port" }
+  Given(:host)      { Srvy::Host.new("test01.host.com", 11211, 0, 0, 100) }
+  Given             { Srvy::Formatters.stub(:from_name){ formatter } }
+
+  When(:result) { Srvy::Formatters.format_single(name, host) }
+
+  Then{ expect(formatter).to have_received(:format_single).with(host) }
+end
+
+
+describe Srvy::Formatters, "#format_many" do
+  Given(:formatter) { double("Formatter", :format_many => true)}
+  Given(:name)      { "host_port" }
+  Given(:hosts)     { [Srvy::Host.new("test01.host.com", 11211, 0, 0, 100)] }
+  Given             { Srvy::Formatters.stub(:from_name){ formatter } }
+
+  When(:result) { Srvy::Formatters.format_many(name, hosts) }
+
+  Then{ expect(formatter).to have_received(:format_many).with(hosts) }
+end

data/spec/srvy/resolver_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Srvy::Resolver do
+  describe "cache setting" do
+    Given(:host)   {  "google.com"}
+
+    When{ subject.get host }
+
+    Then{ expect(subject.cache).to have_key(host) }
+
+  end
+
+  describe "cache usage" do
+
+    Given(:host)        { "google.com"}
+    Given(:srvy_result) { Srvy::Result.new(Time.now, [Srvy::Host.new("test01.host.com", 11211, 10,  0, 100)])  }
+
+    Given               { subject.cache[host] = srvy_result }
+
+    When(:result){ subject.get host }
+
+    Then{ expect(result).to eq(srvy_result) }
+
+  end
+end

data/spec/srvy/result_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+describe Srvy::Result do
+  Given(:now)         { Time.at(Time.now.to_i) } # round to nearest second so jruby stops complaining on boundary cases
+  Given(:ttl)         { 100 }
+  Given(:call_count)  { 10000 }
+  Given(:allowance)   { 0.02 }
+
+  # different hosts definitions
+  Given(:hosts_with_equal_weight) { [
+    Srvy::Host.new("test01.host.com", 11211, 10,  0, ttl),
+    Srvy::Host.new("test02.host.com", 11211, 10,  0, ttl),
+  ] }
+
+  Given(:hosts_with_unequal_weight) { [
+    Srvy::Host.new("test01.host.com", 11211, 30,  0, ttl),
+    Srvy::Host.new("test02.host.com", 11211, 10,  0, ttl),
+  ] }
+
+  Given(:hosts_with_unequal_priorities) { [
+    Srvy::Host.new("test01.host.com", 11211, 10,  0, ttl),
+    Srvy::Host.new("test02.host.com", 11211, 10,  1, ttl),
+  ] }
+  Given(:no_hosts) { [ ] }
+
+
+  describe "#expired?" do
+
+
+    context "with data" do
+      subject{ Srvy::Result.new(now, hosts_with_equal_weight) }
+
+      Then{ Timecop.freeze(now)             { expect(subject).to_not be_expired } }
+      Then{ Timecop.freeze(now + ttl)       { expect(subject).to_not be_expired } }
+      Then{ Timecop.freeze(now + ttl + 1)   { expect(subject).to be_expired     } }
+      Then{ Timecop.freeze(now - ttl)       { expect(subject).to_not be_expired } }
+      Then{ Timecop.freeze(now - (ttl + 1)) { expect(subject).to_not be_expired } }
+    end
+
+    context "with no data" do
+      subject{ Srvy::Result.new(now, []) }
+
+      Then{ Timecop.freeze(now)       { expect(subject).to_not be_expired } }
+      Then{ Timecop.freeze(now + 10)  { expect(subject).to_not be_expired } }
+      Then{ Timecop.freeze(now + 11)  { expect(subject).to be_expired     } }
+      Then{ Timecop.freeze(now - 10)  { expect(subject).to_not be_expired } }
+      Then{ Timecop.freeze(now - 11)  { expect(subject).to_not be_expired } }
+    end
+  end
+
+  describe "#from_dns" do
+    subject{ Srvy::Result.from_dns(dns_result) }
+
+    Given(:dns_result) { Net::DNS::Resolver.new(:nameservers => "8.8.8.8").search("_xmpp-server._tcp.gmail.com", Net::DNS::SRV) }
+    Given(:srvs)       { dns_result.answer.select{|rr| rr.is_a?(Net::DNS::RR::SRV) }}
+    Given(:dns_hosts)  { srvs.map(&:host).sort }
+    Given(:srvys)      { subject.get_all }
+    Given(:srvy_hosts) { srvys.map(&:host).sort }
+
+    Then{ expect(subject).to be_kind_of(Srvy::Result) }
+    Then{ expect(srvy_hosts).to eq(dns_hosts) }
+
+
+    Then do
+      srvys.each do |srvy|
+        dns = srvs.find{|d| d.host == srvy.host}
+
+        expect(dns).to_not be_nil
+
+        expect(srvy.host).to      eq(dns.host)
+        expect(srvy.port).to      eq(dns.port)
+        expect(srvy.weight).to    eq(dns.weight)
+        expect(srvy.priority).to  eq(dns.priority)
+      end
+    end
+  end
+
+
+  describe "#get_many" do
+    subject{ Srvy::Result.new(Time.now, hosts) }
+
+    When(:result){ subject.get_many }
+
+    context "hosts with equal priorities" do
+      Given(:hosts) { hosts_with_equal_weight.sort_by(&:host) }
+      Then{ expect(result.sort_by(&:host)).to eq(hosts) }
+    end
+
+    context "hosts with unequal priorities" do
+      Given(:hosts) { hosts_with_unequal_priorities }
+      # should only have the best (i.e. lowest) priority
+      Then{ expect(result).to eq([hosts[0]]) }
+    end
+    
+    context "no hosts" do
+      Given(:hosts) { no_hosts }
+      Then{ expect(result).to eq([]) }
+    end 
+  end
+
+  describe "#get_all" do
+    subject{ Srvy::Result.new(Time.now, hosts) }
+
+    When(:result){ subject.get_all }
+
+    context "with some hosts" do  
+      Given(:hosts) { hosts_with_unequal_priorities }
+      Then{ expect(result).to eq(hosts) }
+    end
+
+    context "with no hosts" do
+      Given(:hosts) { [ ] }
+      Then{ expect(result).to eq(hosts) }
+    end
+  end
+
+  describe "#get_single" do
+    subject{ Srvy::Result.new(Time.now, hosts) }
+
+    When(:result_percentages) do 
+      calls = call_count.times.map{ subject.get_single }
+      
+      result_counts = calls.each_with_object({}) do |call_result, acc|
+        acc[call_result] ||= 0
+        acc[call_result] += 1
+      end
+      all_hosts_and_results = result_counts.keys | hosts
+      all_hosts_and_results.each_with_object({}) do |host, acc|
+        count = result_counts[host] || 0
+        acc[host] = count / call_count.to_f
+      end
+    end
+
+    context "When the result has hosts with equal weights" do
+      Given(:hosts){ hosts_with_equal_weight }
+
+      Then do
+        result_percentages.values.each do |percentage|
+          expect(percentage).to be_within(allowance).of(0.5)
+        end
+      end 
+    end
+
+    context "hosts with unequal priority" do
+      Given(:hosts){ hosts_with_unequal_priorities }
+
+      Then do
+        expect(result_percentages[hosts[0]]).to be_within(allowance).of(1.0)
+        expect(result_percentages[hosts[1]]).to be_within(allowance).of(0.0)
+      end 
+    end
+
+
+    context "hosts with unequal weights" do
+      Given(:hosts){ hosts_with_unequal_weight }
+
+      Then do
+        expect(result_percentages[hosts[0]]).to be_within(allowance).of(0.75)
+        expect(result_percentages[hosts[1]]).to be_within(allowance).of(0.25)
+      end 
+    end
+
+    context "no hosts" do
+      Given(:hosts){ no_hosts }
+
+      Then do
+        expect(result_percentages[nil]).to be_within(allowance).of(1.0)
+      end 
+    end
+  end
+end
+
+
+
+
+
+
+

data/srvy.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'srvy/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "srvy"
+  spec.version       = Srvy::VERSION
+  spec.authors       = ["Scott Fleckenstein"]
+  spec.email         = ["nullstyle@gmail.com"]
+  spec.description   = %q{SRV-based service discovery}
+  spec.summary       = %q{SRV-based service discovery}
+  spec.homepage      = "https://github.com/nullstyle/srvy"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "net-dns",        "= 0.8.0" # pin this version of net-dns because our monkey patch only applies to it.
+  spec.add_dependency "lru_redux",      "~> 0.8.1"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "pry"
+
+  spec.add_development_dependency "rspec",          ">= 2.14.1"
+  spec.add_development_dependency "rspec-given",    ">= 3.5.0"
+  spec.add_development_dependency "coveralls",      "~> 0.7.0"
+  spec.add_development_dependency "timecop",        "~> 0.7.1"
+  spec.add_development_dependency "activesupport",  ">= 4.0.0"
+end

metadata

@@ -0,0 +1,218 @@
+--- !ruby/object:Gem::Specification
+name: srvy
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Scott Fleckenstein
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: net-dns
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+- !ruby/object:Gem::Dependency
+  name: lru_redux
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+- !ruby/object:Gem::Dependency
+  name: rspec-given
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+description: SRV-based service discovery
+email:
+- nullstyle@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .coveralls.yml
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/lru_redux/has_key_monkey_patch.rb
+- lib/net/dns/ext/resolver_nameserver_monkey_patch.rb
+- lib/srvy.rb
+- lib/srvy/formatters.rb
+- lib/srvy/formatters/base.rb
+- lib/srvy/formatters/dalli.rb
+- lib/srvy/formatters/host_port.rb
+- lib/srvy/host.rb
+- lib/srvy/resolver.rb
+- lib/srvy/result.rb
+- lib/srvy/version.rb
+- spec/spec_helper.rb
+- spec/srvy/formatters/base_spec.rb
+- spec/srvy/formatters/dalli_spec.rb
+- spec/srvy/formatters/host_port_spec.rb
+- spec/srvy/formatters_spec.rb
+- spec/srvy/resolver_spec.rb
+- spec/srvy/result_spec.rb
+- srvy.gemspec
+homepage: https://github.com/nullstyle/srvy
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: SRV-based service discovery
+test_files:
+- spec/spec_helper.rb
+- spec/srvy/formatters/base_spec.rb
+- spec/srvy/formatters/dalli_spec.rb
+- spec/srvy/formatters/host_port_spec.rb
+- spec/srvy/formatters_spec.rb
+- spec/srvy/resolver_spec.rb
+- spec/srvy/result_spec.rb
+has_rdoc: