elbping 0.0.1

data/bin/elbping

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+
+require 'elbping/cli.rb'
+
+$stderr.sync = true
+$stdout.sync = true
+
+ElbPing::CLI.main
+

data/lib/elbping/cli.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+
+require 'elbping/pinger.rb'
+require 'elbping/resolver.rb'
+require 'elbping/display.rb'
+
+module ElbPing
+  module CLI
+
+    # Set up default options
+    OPTIONS = {}
+    OPTIONS[:verb_len]      = ENV['PING_ELB_MAXVERBLEN']    || 128
+    OPTIONS[:nameserver]    = ENV['PING_ELB_NS']            || 'ns-941.amazon.com'
+    OPTIONS[:count]         = ENV['PING_ELB_PINGCOUNT']     || 4
+    OPTIONS[:timeout]       = ENV['PING_ELB_TIMEOUT']       || 10
+    OPTIONS[:wait]          = ENV['PING_ELB_WAIT']          || 0
+
+    # Build parser for command line options
+    PARSER = OptionParser.new do |opts|
+      opts.banner = "Usage: #{$0} [options] <elb hostname>"
+
+      opts.on("-N NAMESERVER", "--nameserver NAMESERVER", "Use NAMESERVER to perform DNS queries") do |ns|
+        OPTIONS[:nameserver] = ns
+      end
+      opts.on("-L LENGTH", "--verb-length LENGTH", Integer, "Use verb LENGTH characters long") do |n|
+        OPTIONS[:verb_len] = n
+      end
+      opts.on("-W SECONDS", "--timeout SECONDS", Integer, "Use timeout of SECONDS for HTTP requests") do |n|
+        OPTIONS[:timeout] = n
+      end
+      opts.on("-w SECONDS", "--wait SECONDS", Integer, "Wait SECONDS between pings (default: 0)") do |n|
+        OPTIONS[:wait] = n
+      end
+      opts.on("-c COUNT", "--count COUNT", Integer, "Ping each node COUNT times") do |n|
+        OPTIONS[:count] = n
+      end
+    end
+
+    # Parse options
+    def self.usage
+      puts PARSER.help
+      exit(false)
+    end
+
+    # Main entry point of the program
+    def self.main
+      PARSER.parse!(ARGV) rescue usage
+
+      if ARGV.size < 1
+        usage
+      end
+
+      target = ARGV[0]
+      nodes = ElbPing::Resolver.find_elb_nodes(target, OPTIONS[:nameserver])
+
+      # Set up summary objects
+      total_summary = {
+        :reqs_attempted =>  0,
+        :reqs_completed =>  0,
+        :latencies      => [],
+      }
+      node_summary = {}
+      nodes.each { |node| node_summary[node] = total_summary.clone }
+
+      # Catch ctrl-c
+      trap("INT") {
+        ElbPing::Display.summary(total_summary, node_summary)
+        exit
+      }
+
+      (1..OPTIONS[:count]).each { |i|
+        sleep OPTIONS[:wait] if i > 1
+
+        nodes.map { |node|
+          total_summary[:reqs_attempted] += 1
+          node_summary[node][:reqs_attempted] += 1
+          status = ElbPing::HttpPinger.ping_node(node, OPTIONS[:verb_len], OPTIONS[:timeout])
+
+          unless status[:code] == :timeout
+            total_summary[:reqs_completed] += 1
+            total_summary[:latencies] += [status[:duration]]
+            node_summary[node][:reqs_completed] += 1
+            node_summary[node][:latencies] += [status[:duration]]
+          end
+
+          ElbPing::Display.response(status)
+        }
+      }
+      ElbPing::Display.summary(total_summary, node_summary)
+    end
+  end
+end

data/lib/elbping/display.rb

@@ -0,0 +1,43 @@
+
+module ElbPing
+  module Display
+    # Format and display the ping data
+    def self.response(status)
+      node = status[:node]
+      code = status[:code]
+      duration = status[:duration]
+
+      puts "Response from #{node}: code=#{code.to_s} time=#{duration} ms"
+    end
+
+    # Display summary of results (in aggregate and per-node)
+    def self.summary(total_summary, node_summary)
+      requests = total_summary[:reqs_attempted]
+      responses = total_summary[:reqs_completed]
+      loss = (1 - (responses.to_f/requests)) * 100
+
+      latencies = total_summary[:latencies]
+      avg_latency = (latencies.inject { |sum, el| sum + el }.to_f / latencies.size).to_i # ms
+
+      node_summary.each { |node, summary|
+        requests = summary[:reqs_attempted]
+        responses = summary[:reqs_completed]
+        loss = (1 - (responses.to_f/requests)) * 100
+
+        latencies = summary[:latencies]
+        avg_latency = (latencies.inject { |sum, el| sum + el }.to_f / latencies.size).to_i # ms
+
+        puts "--- #{node} statistics ---"
+        puts "#{requests} requests, #{responses} responses, #{loss.to_i}% loss"
+        puts "min/avg/max = #{latencies.min}/#{avg_latency}/#{latencies.max} ms"
+      }
+
+      puts '--- total statistics ---'
+      puts "#{requests} requests, #{responses} responses, #{loss.to_i}% loss"
+      puts "min/avg/max = #{latencies.min}/#{avg_latency}/#{latencies.max} ms"
+
+    end
+
+  end
+end
+

data/lib/elbping/pinger.rb

@@ -0,0 +1,31 @@
+
+require "net/http"
+
+module ElbPing
+  module HttpPinger
+    # Make HTTP request to given node using custom request method
+    def self.ping_node(node, verb_len, timeout, port=80, path="/")
+
+      ping_request = Class.new(Net::HTTPRequest) do
+        const_set :METHOD, "A" * verb_len
+        const_set :REQUEST_HAS_BODY, false
+        const_set :RESPONSE_HAS_BODY, false
+      end
+
+      start = Time.now.getutc
+      http = Net::HTTP.new(node, port.to_s)
+      http.open_timeout     = timeout
+      http.read_timeout     = timeout
+      http.continue_timeout = timeout
+      http.ssl_timeout      = timeout # untested
+
+      error = nil
+      response = http.request(ping_request.new(path)) rescue error = :timeout
+
+      {:code => error || response.code,
+        :node => node,
+        :duration => ((Time.now.getutc - start) * 1000).to_i} # returns in ms
+    end
+  end
+end
+

data/lib/elbping/resolver.rb

@@ -0,0 +1,26 @@
+
+require 'net/dns'
+
+module ElbPing
+  module Resolver
+    # Resolve an ELB address to a list of node IPs
+    def self.find_elb_nodes(target, nameserver)
+
+      # First resolve our nameserver IP
+      ns_addrs = Resolver(nameserver).answer.map { |rr| rr.address.to_s }
+
+      # Now resolve our ELB nodes
+      resolver = Net::DNS::Resolver.new(
+        :use_tcp => true,
+        :nameservers => ns_addrs,
+        :retry => 5)
+
+      resp = resolver.query(target, Net::DNS::ANY)
+
+      nodes = []
+      resp.each_address { |a| nodes += [a.to_s] }
+      nodes
+    end
+  end
+end
+

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: elbping
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Charles Hooper
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: net-dns
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+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.
+email: chooper@plumata.com
+executables:
+- elbping
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/elbping/cli.rb
+- lib/elbping/display.rb
+- lib/elbping/pinger.rb
+- lib/elbping/resolver.rb
+- bin/elbping
+homepage: https://github.com/chooper/elbping
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Small tool to 'ping' the nodes that make up an Amazon Elastic Load Balancer
+test_files: []