elbping 0.0.12 → 0.0.13

data/.gitignore

@@ -0,0 +1,6 @@
+bundle
+vendor
+*.gem
+*.ign.sh
+Gemfile.lock
+.bundle

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Charles Hooper
+
+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,74 @@
+# elbping
+
+[![Build Status](https://travis-ci.org/chooper/elbping.png?branch=master)](https://travis-ci.org/chooper/elbping)
+
+`elbping` is a tool to ping all of the nodes that make up an Amazon Elastic
+Load Balancer. It only works for ELBs in HTTP and HTTPS mode and works by
+triggering an HTTP 405 (METHOD NOT ALLOWED) error caused when the ELB
+receives a HTTP verb that is too long. This ensures that only the round
+trip time between `elbping` and the elastic load balancer itself is
+being measured.
+
+## Installation
+
+Installation is as easy as:
+
+```
+  $ gem install elbping
+```
+
+If you want to build a development version or your own branch or fork,
+something like the following will work:
+
+```
+  $ git clone git@github.com:chooper/elbping.git
+  $ cd elbping
+  $ bundle install
+```
+
+## Usage
+
+```
+  $ elbping
+  Usage: ./bin/elbping [options] <elb uri>
+      -N, --nameserver NAMESERVER      Use NAMESERVER to perform DNS queries (default: ns-941.amazon.com)
+      -L, --verb-length LENGTH         Use verb LENGTH characters long (default: 128)
+      -W, --timeout SECONDS            Use timeout of SECONDS for HTTP requests (default: 10)
+      -w, --wait SECONDS               Wait SECONDS between pings (default: 0)
+      -c, --count COUNT                Ping each node COUNT times (default: 0)
+  $ elbping -c 4 http://test-elb-868888812.us-east-1.elb.amazonaws.com
+  Response from 54.243.63.96: code=405 time=210 ms
+  Response from 23.21.73.53: code=405 time=189 ms
+  Response from 54.243.63.96: code=405 time=191 ms
+  Response from 23.21.73.53: code=405 time=188 ms
+  Response from 54.243.63.96: code=405 time=190 ms
+  Response from 23.21.73.53: code=405 time=192 ms
+  Response from 54.243.63.96: code=405 time=187 ms
+  Response from 23.21.73.53: code=405 time=189 ms
+  --- 54.243.63.96 statistics ---
+  4 requests, 4 responses, 0% loss
+  min/avg/max = 187/163/210 ms
+  --- 23.21.73.53 statistics ---
+  4 requests, 4 responses, 0% loss
+  min/avg/max = 188/189/192 ms
+  --- total statistics ---
+  8 requests, 8 responses, 0% loss
+  min/avg/max = 188/189/192 ms
+```
+
+### Configuration
+
+In addition to the command line arguments, `elbping` can also be
+configured through the use of environment variables. The following
+enviromment variables are checked and, if no command line argument
+overrides it, its value is used in place of the default:
+
+* ``PING_ELB_VERBLEN`` - Size of the HTTP verb to use when pinging an ELB
+* ``PING_ELB_NS`` - DNS server to query the list of ELB nodes from
+* ``PING_ELB_PINGCOUNT`` - The number of pings to send before exiting.  Zero means never quit.
+* ``PING_ELB_TIMEOUT`` - The connect and read timeouts to use when sending the request to the ELB node (in seconds)
+* ``PING_ELB_WAIT`` - The amount of time (in seconds) to wait between volleys of pings
+
+Note that none of these *need* to be set as `elbping` uses some pretty
+reasonable defaults. See `elbping`'s usage for more details on that.
+

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/bin/elbping

@@ -1,8 +1,5 @@
 #!/usr/bin/env ruby
 
-require 'rubygems'
-require 'bundler/setup'
-
 require 'elbping/cli.rb'
 
 $stderr.sync = true

data/elbping.gemspec

@@ -0,0 +1,22 @@
+Gem::Specification.new do |s|
+  s.name          = 'elbping'
+  s.version       = '0.0.13'
+  s.date          = '2013-08-13'
+  s.summary       = "Small tool to 'ping' the nodes that make up an Amazon Elastic Load Balancer"
+  s.description   = "elbping is a tool to ping all of the nodes behind an Amazon Elastic Load Balancer. It only works for ELBs in HTTP mode and works by triggering an HTTP 405 (METHOD NOT ALLOWED) error caused when the ELB receives a HTTP verb that is too long."
+  s.authors       = ["Charles Hooper"]
+  s.email         = 'chooper@plumata.com'
+  s.homepage      = 'https://github.com/chooper/elbping'
+  s.license       = 'MIT'
+
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rake", "~> 10.0.4"
+
+  s.homepage    =
+    'https://github.com/chooper/elbping'
+  s.license       = 'MIT'
+end

data/lib/elbping.rb

@@ -0,0 +1,3 @@
+# Library to discover and ping HTTP and HTTPS ELB nodes
+module ElbPing
+end

data/lib/elbping/latency_bucket.rb

@@ -0,0 +1,15 @@
+
+# An array for doing some basic stats on latencies (currently only mean)
+class LatencyBucket < Array
+  def sum
+    self.inject { |sum, el| sum + el} || 0
+  end
+
+  def mean
+    if self.size == 0
+      0
+    else
+      (self.sum.to_f / self.size).to_i
+    end
+  end
+end

data/lib/elbping/tcp_dns.rb

@@ -0,0 +1,44 @@
+
+require 'resolv'
+
+# A TCP-only resolver built from `Resolv::DNS`. See the docs for what it's about.
+# http://ruby-doc.org/stdlib-1.9.3/libdoc/resolv/rdoc/Resolv/DNS.html
+class TcpDNS < Resolv::DNS
+  # Override fetch_resource to use a TCP requester instead of a UDP requester. This
+  # is mostly borrowed from `lib/resolv.rb` with the UDP->TCP fallback logic removed.
+  def each_resource(name, typeclass, &proc)
+    lazy_initialize
+    senders = {}
+    requester = nil
+    begin
+      @config.resolv(name) { |candidate, tout, nameserver, port|
+        requester = make_tcp_requester(nameserver, port)
+        msg = Message.new
+        msg.rd = 1
+        msg.add_question(candidate, typeclass)
+        unless sender = senders[[candidate, nameserver, port]]
+          sender = senders[[candidate, nameserver, port]] =
+            requester.sender(msg, candidate, nameserver, port)
+        end
+
+        begin # HACK
+          reply, reply_name = requester.request(sender, tout)
+        rescue
+          return
+        end
+
+        case reply.rcode
+        when RCode::NoError
+          extract_resources(reply, reply_name, typeclass, &proc)
+          return
+        when RCode::NXDomain
+          raise Config::NXDomain.new(reply_name.to_s)
+        else
+          raise Config::OtherResolvError.new(reply_name.to_s)
+        end
+      }
+    ensure
+      requester.close
+    end
+  end
+end

data/test/test_latencybucket.rb

@@ -0,0 +1,42 @@
+require 'test/unit'
+require 'elbping/latency_bucket.rb'
+
+class TestLatencyBucket < Test::Unit::TestCase
+  def test_init
+    bucket = nil
+    assert_nothing_raised do
+      bucket = LatencyBucket.new
+      assert_not_nil bucket
+      bucket << 1
+      bucket << 2
+    end
+    assert_equal bucket.to_a, [1, 2]
+  end
+  def test_sum
+    bucket = LatencyBucket.new
+    bucket << 0
+    assert_nothing_raised do
+      assert_equal bucket.sum, 0
+    end
+    bucket << 100
+    bucket << 200
+    bucket << 300
+    bucket << 3
+    assert_equal bucket.sum, (0 + 100 + 200 + 300 + 3)
+  end
+  def test_mean
+    bucket = LatencyBucket.new
+    bucket << 100
+    bucket << 200
+    bucket << 300
+    bucket << 0
+    bucket << 3
+    assert_equal bucket.mean, ((100 + 200 + 300 + 0 + 3)/5).to_i
+  end
+  def test_mean_divide_by_zero
+    bucket = LatencyBucket.new
+    assert_nothing_raised do
+      assert_equal bucket.mean, 0
+    end
+  end
+end

data/test/test_pinger.rb

@@ -0,0 +1,35 @@
+require 'test/unit'
+require 'elbping/pinger.rb'
+
+DEFAULT_NODE    = ENV['TEST_NODE']     || '127.0.0.1'
+DEFAULT_PORT    = ENV['TEST_PORT']     || '80'
+DEFAULT_PATH    = ENV['TEST_PATH']     || '/'
+DEFAULT_SSL     = ENV['TEST_SSL']      || false
+DEFAULT_VERBLEN = ENV['TEST_VERBLEN']  || 128
+DEFAULT_TIMEOUT = ENV['TEST_TIMEOUT']  || 3
+
+class TestHttpPinger < Test::Unit::TestCase
+  def test_ping_node
+    # ping_node(node, port, path, use_ssl, verb_len, timeout)
+    # -> hash
+    resp = nil
+    assert_nothing_raised do
+      resp = ElbPing::HttpPinger.ping_node(
+        DEFAULT_NODE,
+        DEFAULT_PORT,
+        DEFAULT_PATH,
+        DEFAULT_SSL,
+        DEFAULT_VERBLEN,
+        DEFAULT_TIMEOUT)
+    end
+    #  {:code => error |||| response.code,
+    #    :exception => exc,
+    #    :node => node,
+    #    :duration => ((Time.now.getutc - start) * 1000).to_i} # returns in ms
+    assert_equal resp.class, Hash
+    assert_equal resp[:node], DEFAULT_NODE
+    assert_equal resp[:duration].class, Fixnum
+    assert_not_equal resp[:code], nil
+  end
+end
+

data/test/test_resolver.rb

@@ -0,0 +1,30 @@
+
+require 'test/unit'
+require 'elbping/resolver.rb'
+
+DEFAULT_NS = ENV['TEST_NS'] || 'ns-941.amazon.com'
+DEFAULT_GOOD_ELB = ENV['TEST_GOOD_ELB'] || 'test-elb-868888812.us-east-1.elb.amazonaws.com' # feels dirty
+
+class TestResolver< Test::Unit::TestCase
+  def test_bad_queries
+    ["fake.amazonaws.com", "google.com", "nxdomain.asdf"].each { |tgt|
+      assert_equal [], ElbPing::Resolver.find_elb_nodes(tgt, DEFAULT_NS)
+
+      # I think something internal to Resolv is returning nil in tcp mode
+      #assert_raise Timeout::Error do
+      #  ElbPing::Resolver.find_elb_nodes(tgt, DEFAULT_NS)
+      #end
+    }
+  end
+
+  # This might still fail from time to time :-\ Been seeing lots of failures to connect to AWS DNS
+  def test_good_query
+    resp = nil
+    assert_nothing_raised do
+      resp = ElbPing::Resolver.find_elb_nodes(DEFAULT_GOOD_ELB, DEFAULT_NS)
+    end
+    # I don't actually care what the results are, only that they are a list
+    assert_equal resp.class, Array
+  end
+end
+

data/test/test_stats.rb

@@ -0,0 +1,75 @@
+require 'test/unit'
+require 'elbping/stats.rb'
+
+class TestStats < Test::Unit::TestCase
+
+  STATS_KEYS = [:requests, :responses, :latencies]
+  TEST_NODES = ["1.1.1.1", "2.2.2.2", "3.3.3.3"]
+
+  def test_always_pass
+    assert_equal true, true
+  end
+
+  def test_init
+    stats = nil
+    assert_nothing_raised do
+      stats = ElbPing::Stats.new
+    end
+    assert_not_nil stats
+
+    # Validate stats.total
+    assert_equal stats.total.class, Hash
+
+    STATS_KEYS.each do |key|
+      assert_equal stats.total.keys.include?(key), true
+    end
+
+    # Validate stats.nodes
+    assert_equal stats.nodes.class, Hash
+    assert_equal stats.nodes.size, 0
+  end
+
+  def test_add_node
+    stats = ElbPing::Stats.new
+
+    TEST_NODES.each do |node|
+      assert_nothing_raised do
+        stats.add_node node
+      end
+      assert_equal stats.nodes.keys.include?(node), true
+      STATS_KEYS.each do |key|
+        assert_equal stats.nodes[node].keys.include?(key), true
+      end
+    end
+  end
+
+  # TODO: Make this more maintainable
+  def test_register
+    ping_statuses = [
+      {:code => 200, :exception => nil, :node => "1.1.1.1", :duration => 100},
+      {:code => 400, :exception => nil, :node => "2.2.2.2", :duration => 100},
+      {:code => 405, :exception => nil, :node => "1.1.1.1", :duration => 100},
+      {:code => 302, :exception => nil, :node => "2.2.2.2", :duration => 100},
+      {:code => :timeout, :exception => nil, :node => "1.1.1.1", :duration => 100},
+      {:code => :econnrefused, :exception => nil, :node => "2.2.2.2", :duration => 100},
+      {:code => :exception, :exception => "TEST", :node => "1.1.1.1", :duration => 100},
+    ]
+    
+    stats = ElbPing::Stats.new
+    ping_statuses.each do |status|
+      stats.register status
+    end
+
+    assert_equal stats.total[:requests], ping_statuses.size
+    assert_equal stats.total[:responses], 4
+    assert_equal stats.total[:latencies].size, 4
+    assert_equal stats.total_loss, (1 - (4.to_f / ping_statuses.size))
+
+    assert_equal stats.nodes.size, 2
+    assert_equal stats.nodes.keys.include?("1.1.1.1"), true
+    assert_equal stats.nodes.keys.include?("2.2.2.2"), true
+    assert_equal stats.node_loss("1.1.1.1"), (1 - (2.to_f/4))
+    assert_equal stats.node_loss("2.2.2.2"), (1 - (2.to_f/3))
+  end
+end
+

data/test/test_tests.rb

@@ -0,0 +1,12 @@
+require 'test/unit'
+require 'elbping'
+
+# Basic test to ensure testing works at all.
+# Quis custodiet ipsos custodes?
+
+class TestTests < Test::Unit::TestCase
+  def test_always_pass
+    assert_equal true, true
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elbping
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.0.13
   prerelease: 
 platform: ruby
 authors:
@@ -19,7 +19,7 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 10.0.4
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
@@ -37,12 +37,27 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/elbping
+- elbping.gemspec
+- lib/elbping.rb
 - lib/elbping/cli.rb
 - lib/elbping/display.rb
+- lib/elbping/latency_bucket.rb
 - lib/elbping/pinger.rb
 - lib/elbping/resolver.rb
 - lib/elbping/stats.rb
-- bin/elbping
+- lib/elbping/tcp_dns.rb
+- test/test_latencybucket.rb
+- test/test_pinger.rb
+- test/test_resolver.rb
+- test/test_stats.rb
+- test/test_tests.rb
 homepage: https://github.com/chooper/elbping
 licenses:
 - MIT