roadworker 0.1.0 → 0.2.0

data/README.md

@@ -30,8 +30,8 @@ shell> export AWS_ACCESS_KEY_ID='...'
 shell> export AWS_SECRET_ACCESS_KEY='...'
 shell> roadwork -e -o Routefile
 shell> vi Routefile
-shell> roadwork --dry-run
-shell> roudwork
+shell> roadwork -a --dry-run
+shell> roudwork -a
 ```
 
 ## Routefile example
@@ -72,3 +72,16 @@ hosted_zone "info.winebarrel.jp." do
   end
 end
 ```
+
+## Test
+
+Routefile compares the results of a query to the DNS and DSL in the test mode.
+
+```
+shell> roadwork -t
+..F..
+info.winebarrel.jp. A:
+  expected=127.0.0.1(300),127.0.0.3(300)
+  actual=127.0.0.1(300),127.0.0.2(300)
+5 examples, 1 failure
+```

data/bin/roadwork

@@ -7,12 +7,13 @@ require 'logger'
 
 file = 'Routefile'
 output_file = '-'
-export_mode = false
+mode = nil
 logger = Logger.new($stdout)
 
 logger.formatter = proc {|severity, datetime, progname, msg|
   "#{msg}\n"
 }
+
 options = {
   :logger  => logger,
   :dry_run => false,
@@ -25,15 +26,17 @@ ARGV.options do |opt|
   access_key = nil
   secret_key = nil
 
-  opt.on('-k', '--access-key ACCESS_KEY') {|v| access_key        = v     }
-  opt.on('-s', '--secret-key SECRET_KEY') {|v| secret_key        = v     }
-  opt.on('-f', '--file FILE')             {|v| file              = v     }
-  opt.on('-e', '--export')                {|v| export_mode       = true  }
-  opt.on('-o', '--output FILE')           {|v| output_file       = v     }
-  opt.on('',   '--dry-run')               {|v| options[:dry_run] = true  }
-  opt.on(''  , '--force')                 {    options[:force]   = true  }
-  opt.on(''  , '--no-color')              {    options[:color]   = false }
-  opt.on(''  , '--debug')                 {    options[:debug]   = true  }
+  opt.on('-k', '--access-key ACCESS_KEY') {|v| access_key        = v       }
+  opt.on('-s', '--secret-key SECRET_KEY') {|v| secret_key        = v       }
+  opt.on('-f', '--file FILE')             {|v| file              = v       }
+  opt.on('-a', '--apply')                 {|v| mode              = :apply  }
+  opt.on('-e', '--export')                {|v| mode              = :export }
+  opt.on('-o', '--output FILE')           {|v| output_file       = v       }
+  opt.on('-t', '--test')                  {|v| mode              = :test   }
+  opt.on('',   '--dry-run')               {|v| options[:dry_run] = true    }
+  opt.on(''  , '--force')                 {    options[:force]   = true    }
+  opt.on(''  , '--no-color')              {    options[:color]   = false   }
+  opt.on(''  , '--debug')                 {    options[:debug]   = true    }
   opt.parse!
 
   if access_key and secret_key
@@ -41,7 +44,7 @@ ARGV.options do |opt|
       :access_key_id     => access_key,
       :secret_access_key => secret_key,
     })
-  elsif (access_key and !secret_key) or (!access_key and secret_key)
+  elsif (access_key and !secret_key) or (!access_key and secret_key) or mode.nil?
     puts opt.help
     exit 1
   end
@@ -55,19 +58,40 @@ if options[:debug]
 end
 
 begin
+  logger = options[:logger]
+  logger.level = options[:debug] ? Logger::DEBUG : Logger::INFO
+
   client = Roadworker::Client.new(options)
 
-  if export_mode
+  case mode
+  when :export
     exported = client.export
 
     if output_file == '-'
-      logger.info('Export Route53')
+      logger.info('# Export Route53')
       puts client.export
     else
       logger.info("Export Route53 to `#{output_file}`")
       open(output_file, 'wb') {|f| f.puts client.export }
     end
-  else
+  when :test
+    # XXX:
+    unless File.exist?(file)
+      raise "No Routefile found (looking for: #{file})"
+    end
+
+    examples, failures = client.test(file)
+    examples_message = (examples > 1 ? "%d examples" : "%d example") % examples
+    failures_message = (failures > 1 ? "%d failures" : "%d failure") % failures
+    result_message = [examples_message, failures_message].join(', ')
+
+    if failures.zero?
+      logger.info(result_message.green)
+    else
+      logger.info(result_message.red)
+      exit 1
+    end
+  when :apply
     unless File.exist?(file)
       raise "No Routefile found (looking for: #{file})"
     end
@@ -79,11 +103,14 @@ begin
     updated = client.apply(file)
 
     logger.info('No change'.intense_blue) unless updated
+  else
+    raise 'must not happen'
   end
 rescue => e
   if options[:debug]
     raise e
   else
     $stderr.puts e
+    exit 1
   end
 end

data/lib/roadworker/client.rb

@@ -19,16 +19,7 @@ module Roadworker
     end
 
     def apply(file)
-      dsl = nil
-
-      if file.kind_of?(String)
-        open(file) do |f|
-          dsl = DSL.define(f.read, file).result
-        end
-      else
-        dsl = DSL.define(file.read, file.path).result
-      end
-
+      dsl = load_file(file)
       updated = false
 
       if dsl.hosted_zones.empty? and not @options.force
@@ -48,8 +39,27 @@ module Roadworker
       DSL.convert(exported)
     end
 
+    def test(file)
+      dsl = load_file(file)
+      DSL.test(dsl, @options)
+    end
+
     private
 
+    def load_file(file)
+      dsl = nil
+
+      if file.kind_of?(String)
+        open(file) do |f|
+          dsl = DSL.define(f.read, file).result
+        end
+      else
+        dsl = DSL.define(file.read, file.path).result
+      end
+
+      return dsl
+    end
+
     def walk_hosted_zones(dsl)
       expected = collection_to_hash(dsl.hosted_zones, :name)
       actual   = collection_to_hash(@route53.hosted_zones, :name)

data/lib/roadworker/dsl-tester.rb

@@ -0,0 +1,177 @@
+require 'roadworker/log'
+
+require 'tempfile'
+require 'socket'
+
+# XXX:
+unless Socket.const_defined?(:AF_INET6)
+  Socket::AF_INET6 = Socket::AF_INET
+end
+
+require 'net/dns'
+
+module Roadworker
+  class DSL
+    class Tester
+      include Roadworker::Log
+
+      DEFAULT_NAMESERVERS = '8.8.8.8'
+      ASTERISK_PREFIX = 'asterisk-of-wildcard'
+
+      class << self
+        def test(dsl, options)
+          self.new(options).test(dsl)
+        end
+      end # of class method
+
+      def initialize(options)
+        @options = options
+        @resolver = create_resolver
+      end
+
+      def test(dsl)
+        records = fetch_records(dsl)
+        failures = 0
+        error_messages = []
+
+        records.each do |key, rrs|
+          errors = []
+
+          name = asterisk_to_anyname(key[0])
+          type = key[1]
+
+          log(:debug, 'Check DNS', :white, "#{name} #{type}")
+
+          response = query(name, type)
+
+          unless response
+            failures += 1
+            print_failure
+            next
+          end
+
+          is_valid = rrs.any? {|record|
+            expected_value = (record.resource_records || []).map {|i| i[:value].strip }.sort
+            expected_ttl = record.dns_name ? 60 : record.ttl
+
+            actual_value = response.answer.map {|i| (type == 'TXT' ? i.txt : i.value).strip }.sort
+            actual_ttls = response.answer.map {|i| i.ttl }
+
+            case type
+            when 'NS', 'PTR', 'MX', 'CNAME'
+              expected_value = expected_value.map {|i| i.downcase.sub(/\.\Z/, '') }
+              actual_value = actual_value.map {|i| i.downcase.sub(/\.\Z/, '') }
+            when 'TXT'
+              expected_value = expected_value.map {|i| i.scan(/"([^"]+)"/).join.strip.gsub(/\s+/, ' ') }
+              actual_value = actual_value.map {|i| i.strip.gsub(/\s+/, ' ') }
+            end
+
+            expected_message = record.resource_records ? expected_value.map {|i| "#{i}(#{expected_ttl})" }.join(',') : "#{record.dns_name}(#{expected_ttl})"
+            actual_message = actual_value.zip(actual_ttls).map {|v, t| "#{v}(#{t})" }.join(',')
+            logmsg_expected = "expected=#{expected_message}"
+            logmsg_actual = "actual=#{actual_message}"
+            log(:debug, "  #{logmsg_expected}\n  #{logmsg_actual}", :white, "#{name} #{type}")
+
+            is_same = false
+
+            if record.dns_name
+              # A(Alias)
+              is_same = response.answer.all? {|a|
+                query(a.value, 'PTR').answer.all? do |ptr|
+                  ptr.value =~ /\.compute\.amazonaws\.com\.\Z/
+                end
+              }
+            else
+              is_same = (expected_value == actual_value)
+            end
+
+            if is_same
+              unless actual_ttls.all? {|i| i <= expected_ttl }
+                is_same = false
+              end
+            end
+
+            errors << [logmsg_expected, logmsg_actual] unless is_same
+            is_same
+          }
+
+          if is_valid
+            print_success
+          else
+            failures += 1
+            print_failure
+
+            errors.each do |logmsg_expected, logmsg_actual|
+              error_messages << "#{name} #{type}:\n  #{logmsg_expected}\n  #{logmsg_actual}"
+            end
+          end
+
+          result &&= is_valid
+        end
+
+        puts unless @options.debug
+
+        error_messages.each do |msg|
+          log(:warn, msg, :intense_red)
+        end
+
+        [records.length, failures]
+      end
+
+      private
+
+      def create_resolver
+        log_file = @options.debug ? Net::DNS::Resolver::Defaults[:log_file] : '/dev/null'
+
+        if File.exist?(Net::DNS::Resolver::Defaults[:config_file])
+          Net::DNS::Resolver.new(:log_file => log_file)
+        else
+          Tempfile.open(File.basename(__FILE__)) do |f|
+            Net::DNS::Resolver.new(:config_file => f.path, :nameservers => DEFAULT_NAMESERVERS, :log_file => log_file)
+          end
+        end
+      end
+
+      def fetch_records(dsl)
+        record_list = {}
+
+        dsl.hosted_zones.each do |zone|
+          zone.rrsets.each do |record|
+            key = [record.name, record.type]
+            record_list[key] ||= []
+            record_list[key] << record
+          end
+        end
+
+        return record_list
+      end
+
+      def asterisk_to_anyname(name)
+        rand_str = (("a".."z").to_a + ("A".."Z").to_a + (0..9).to_a).shuffle[0..7].join
+        name.gsub('*', "#{ASTERISK_PREFIX}-#{rand_str}")
+      end
+
+      def query(name, type)
+        ctype = Net::DNS.const_get(type)
+        response = nil
+
+        begin
+          response = @resolver.query(name, ctype)
+        rescue => e
+          log(:warn, "WARNING #{e.message}", :yellow, "#{name} #{type}")
+        end
+
+        return response
+      end
+
+      def print_success
+        print '.'.intense_green unless @options.debug
+      end
+
+      def print_failure
+        print 'F'.intense_red unless @options.debug
+      end
+
+    end # Tester
+  end # DSL
+end # Roadworker

data/lib/roadworker/dsl.rb

@@ -1,4 +1,5 @@
 require 'roadworker/dsl-converter'
+require 'roadworker/dsl-tester'
 
 require 'ostruct'
 
@@ -15,6 +16,11 @@ module Roadworker
       def convert(hosted_zones)
         Converter.convert(hosted_zones)
       end
+
+
+      def test(dsl, options)
+        Tester.test(dsl, options)
+      end
     end # of class method
 
     attr_reader :result

data/lib/roadworker/version.rb

@@ -1,5 +1,5 @@
 module Roadworker
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end
 
 Version = Roadworker::VERSION

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: roadworker
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-29 00:00:00.000000000 Z
+date: 2013-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -43,6 +43,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 1.2.2
+- !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
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -104,6 +120,7 @@ files:
 - lib/roadworker/client.rb
 - lib/roadworker/collection.rb
 - lib/roadworker/dsl-converter.rb
+- lib/roadworker/dsl-tester.rb
 - lib/roadworker/dsl.rb
 - lib/roadworker/log.rb
 - lib/roadworker/route53-exporter.rb