roadworker 0.5.12 → 0.5.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 954087eeb0c2336152bcc1b2e5508ab1ac508e33df52c02feffb8cdb2973cd7d
-  data.tar.gz: 8d767b2ff8558de226cddfb43c662ce52952a75b7b5fabae89dd14638b555fb3
+  metadata.gz: 9e6ddf47c1d608d00d7daad9af18efe458565157e671d85b097985f1a2120c05
+  data.tar.gz: 0fa8d9cad469f73eb385e95771b3717bd7f513c62d8c9e143c0dab84d3719afd
 SHA512:
-  metadata.gz: 67903de0d8b95bd63d4dd0fe4d47a6a882574f10614e95824d30640f208619081a6ff2f21932c70720b9aeb9340527bf786e336d778f6c6fc057e055c62b71dc
-  data.tar.gz: ecce73635cdd3465a21070c16205f7e6df4f87ffd37e08c1c3bf3d9e126cbb85397ad58941f416eb912cf2a4475ef0ec011b88fc6e86e697ac5fea9da3ee3e2c
+  metadata.gz: 0e09c4d9fdec40a48da7ff63cc43cd4a50933d2cf324d6b22dfa449a4f886ae3eb131169351c25412936e42a1e5de159e767e636d893d12c1c7f86c69c91c957
+  data.tar.gz: eb3fbbf02edf2cc3686f0cc16c05ccc1bd6879179fb980e200e5eae4487f4c90eb18b0122587c8c9a9c3411bd2ac5dd1c6087d9b3e5481018861feec1c8cbaa2

data/README.md

@@ -10,22 +10,7 @@ It defines the state of Route53 using DSL, and updates Route53 according to DSL.
 
 **Notice**
 
-* Roadworker cannot update TTL of two or more same weighted A records (with different SetIdentifier) after creation.
-* `>= 0.4.3` compare resource records ignoring the order.
-* `>= 0.5.5`
-  * **Disable Divided HostedZone**
-  * **Use aws-sdk v2** [PR#20](https://github.com/winebarrel/roadworker/pull/20)
-  * Support Cross Account ELB Alias [PR#21](https://github.com/winebarrel/roadworker/pull/21)
-* `>= 0.5.6`
-  * Disable HealthCheck GC (pass `--health-check-gc` option if enable)
-  * Support Calculated Health Checks
-  * Support New Health Check attributes
-  * Add template feature
-* `>= 0.5.7`
-  * Fix for `dualstack` prefix
-  * Use constant for CanonicalHostedZoneNameID
-* `>= 0.5.9`
-  * Support CloudWatch Metrics Health Check
+Roadworker cannot update TTL of two or more same weighted A records (with different SetIdentifier) after creation.
 
 ## Installation
 

data/lib/roadworker.rb

@@ -17,6 +17,7 @@ require 'roadworker/log'
 require 'roadworker/utils'
 require 'roadworker/template-helper'
 
+require 'roadworker/batch'
 require 'roadworker/client'
 require 'roadworker/collection'
 require 'roadworker/dsl'

data/lib/roadworker/batch.rb

@@ -0,0 +1,362 @@
+module Roadworker
+  class Batch
+    include Log
+
+    # @param [Roadworker::Route53Wrapper::HostedzoneWrapper] hosted_zone
+    # @param [Roadworker::HealthCheck] health_checks
+    def initialize(hosted_zone, dry_run:, logger:, health_checks:)
+      @hosted_zone = hosted_zone
+      @dry_run = dry_run
+      @logger = logger
+      @health_checks = health_checks
+
+      @operations = []
+    end
+
+    attr_reader :hosted_zone, :health_checks
+    attr_reader :dry_run, :logger
+    attr_reader :operations
+
+    # @param [OpenStruct] rrset Roadworker::DSL::ResourceRecordSet#result
+    def create(rrset)
+      add_operation Create, rrset
+    end
+
+    # @param [OpenStruct] rrset Roadworker::DSL::ResourceRecordSet#result
+    def update(rrset)
+      add_operation Update, rrset
+    end
+
+    # @param [Roadworker::Route53Wrapper::ResourceRecordSetWrapper] rrset
+    def delete(rrset)
+      add_operation Delete, rrset
+    end
+
+    # @param [Aws::Route53::Client] route53
+    # @return [Boolean] updated
+    def request!(route53)
+      sorted_operations = operations.sort_by(&:sort_key)
+
+      batches = slice_operations(sorted_operations)
+      batches.each_with_index do |batch, i|
+        dispatch_batch!(route53, batch, i, batches.size)
+      end
+
+      sorted_operations.any? { |op| !op.changes.empty? }
+    end
+
+    def inspect
+      "#<#{self.class.name}: #{operations.size} operations>"
+    end
+
+    def to_s
+      inspect
+    end
+
+    private
+
+    def dispatch_batch!(route53, batch, i, total)
+      changes = batch.flat_map(&:changes)
+      return if changes.empty?
+
+      page = total > 1 ? " | #{i+1}/#{total}" : nil
+      log(:info, "=== Change batch: #{hosted_zone.name} | #{hosted_zone.id}#{hosted_zone.vpcs.empty? ? '' : ' - private'}#{page}", :bold)
+      batch.each do |operation|
+        operation.diff!()
+      end
+
+      if dry_run
+        log(:info, "---", :bold, dry_run: false)
+      else
+        change = route53.change_resource_record_sets(
+          hosted_zone_id: hosted_zone.id,
+          change_batch: {
+            changes: changes,
+          },
+        )
+        log(:info, "--> Change submitted: #{change.change_info.id}", :bold)
+      end
+      log(:info, "", :bold, dry_run: false)
+    end
+
+    # Slice operations to batches, per 32,000 characters in "Value" or per 1,000 operations.
+    def slice_operations(ops)
+      total_value_size = 0
+      total_ops = 0
+      ops.slice_before do |op|
+        total_value_size += op.value_size
+        total_ops += 1
+        if total_value_size > 32000 || total_ops > 1000
+          total_value_size = op.value_size
+          total_ops = 1
+          true
+        else
+          false
+        end
+      end.to_a
+    end
+
+    def add_operation(klass, rrset)
+      assert_record_name rrset
+      operations << klass.new(hosted_zone, rrset, health_checks: health_checks, dry_run: dry_run, logger: logger)
+      self
+    end
+
+    def assert_record_name(record)
+      unless record.name.downcase.sub(/\.$/,'').end_with?(hosted_zone.name.sub(/\.$/,''))
+        raise ArgumentError, "#{record.name.inspect} isn't under hosted zone name #{hosted_zone.name.inspect}" 
+      end
+    end
+
+    class Operation
+      include Log
+
+      # @param [Roadworker::Route53Wrapper::HostedzoneWrapper] hosted_zone
+      # @param [Roadworker::DSL::ResourceRecordSet] rrset
+      # @param [Roadworker::HealthCheck] health_checks
+      # @param [Logger] logger
+      def initialize(hosted_zone, rrset, health_checks:, dry_run:, logger:)
+        @hosted_zone = hosted_zone
+        @rrset = rrset
+        @health_checks = health_checks
+        @dry_run = dry_run
+        @logger = logger
+      end
+
+      attr_reader :hosted_zone, :rrset
+      attr_reader :health_checks
+      attr_reader :dry_run, :logger
+
+      def sort_key
+        # See Operation#cname_first?
+        cname_precedence = if rrset.type == 'CNAME'
+                             cname_first? ? 0 : 2
+                           else
+                             1
+                           end
+        # Alias target may be created in the same change batch. Let's do operations for non-alias records first.
+        alias_precedence = if rrset.dns_name
+                             1
+                           else
+                             0
+                           end
+        [rrset.name, cname_precedence, alias_precedence, rrset.type, rrset.set_identifier]
+      end
+
+      # CNAME should always be created/updated later, as CNAME doesn't permit other records
+      # See also Roadworker::Batch::Delete#cname_first?
+      def cname_first?
+        false
+      end
+
+      # Count total length of RR "Value" included in changes
+      # See also: Batch#slice_operations
+      # @return [Integer]
+      def value_size
+        changes.map do |change|
+          upsert_multiplier = change[:action] == 'UPSERT' ? 2 : 1
+          rrset = change[:resource_record_set]
+          next 0 unless rrset
+          rrs = rrset[:resource_records]
+          next 0 unless rrs
+          (rrs.map { |_| _[:value]&.size || 0 }.sum) * upsert_multiplier
+        end.sum || 0
+      end
+
+      # @return [Array<Hash>]
+      def changes
+        raise NotImplementedError
+      end
+
+      # @return [Hash]
+      def desired_rrset
+        raise NotImplementedError
+      end
+
+      # @return [Roadworker::Route53Wrapper::ResourceRecordSetWrapper]
+      def present_rrset
+        hosted_zone.find_resource_record_set(rrset.name, rrset.type, rrset.set_identifier) or raise "record not present"
+      end
+
+      def diff!(dry_run: false)
+        raise NotImplementedError
+      end
+
+      def inspect
+        "#<#{self.class.name} @changes=#{changes.inspect}>"
+      end
+
+      def to_s
+        inspect
+      end
+
+      private
+
+      # @param [String] dns_name
+      # @param [Hash] options
+      # @return [?]
+      def get_alias_target(dns_name, options)
+        Aws::Route53.dns_name_to_alias_target(dns_name, options, hosted_zone.id, hosted_zone.name)
+      end
+
+      # @param [?] health_check
+      # @return [?]
+      def get_health_check(check)
+        check ? health_checks.find_or_create(check) : nil
+      end
+
+    end
+
+    class Create < Operation
+      # @return [Hash]
+      def desired_rrset
+        return @new_rrset if defined? @new_rrset 
+        @new_rrset = {
+          name: rrset.name,
+          type: rrset.type,
+        }
+
+        Route53Wrapper::RRSET_ATTRS.each do |attribute|
+          value = rrset.send(attribute)
+          next unless value
+
+          case attribute
+          when :dns_name
+            attribute = :alias_target
+            dns_name, dns_name_opts = value
+            value = get_alias_target(dns_name, dns_name_opts)
+          when :health_check
+            attribute = :health_check_id
+            value = get_health_check(value)
+          end
+
+          @new_rrset[attribute] = value
+        end
+
+        @new_rrset
+      end
+
+      def changes
+        [
+          {
+            action: 'CREATE',
+            resource_record_set: desired_rrset.to_h,
+          },
+        ]
+      end
+
+      def diff!
+        log(:info, 'Create ResourceRecordSet', :cyan) do
+          "#{desired_rrset[:name]} #{desired_rrset[:type]}#{ desired_rrset[:set_identifier] && " (#{desired_rrset[:set_identifier]})" }"
+        end
+      end
+    end
+
+    class Delete < Operation
+      # CNAME should always be deleted first, as CNAME doesn't permit other records
+      def cname_first?
+        true
+      end
+
+      def hosted_zone_soa_or_ns?
+        (present_rrset.type == 'SOA' || present_rrset.type == 'NS') && hosted_zone.name == present_rrset.name
+      end
+
+      def changes
+        # Avoid deleting hosted zone SOA/NS
+        if hosted_zone_soa_or_ns?
+          return []
+        end
+
+        [
+          {
+            action: 'DELETE',
+            resource_record_set: present_rrset.to_h,
+          }
+        ]
+      end
+
+      def diff!
+        return if changes.empty?
+        log(:info, 'Delete ResourceRecordSet', :red) do
+          "#{present_rrset.name} #{present_rrset.type}#{ present_rrset.set_identifier && " (#{present_rrset.set_identifier})" }"
+        end
+      end
+    end
+
+
+    class Update < Operation
+      def desired_rrset
+        return @desired_rrset if defined? @desired_rrset
+        @desired_rrset = {name: rrset[:name]}
+
+        Route53Wrapper::RRSET_ATTRS_WITH_TYPE.each do |attribute|
+          value = rrset[attribute]
+          next unless value
+
+          case attribute
+          when :dns_name
+            dns_name, dns_name_opts = value
+            @desired_rrset[:alias_target] = get_alias_target(dns_name, dns_name_opts)
+          when :health_check
+            @desired_rrset[:health_check_id] = get_health_check(value)
+          else
+            @desired_rrset[attribute] = value
+          end
+        end
+
+        @desired_rrset
+      end
+
+      def changes
+        [
+          {
+            action: 'DELETE',
+            resource_record_set: present_rrset.to_h,
+          },
+          {
+            action: 'CREATE',
+            resource_record_set: desired_rrset.to_h,
+          },
+        ]
+      end
+
+      def diff!
+        log(:info, 'Update ResourceRecordSet', :green) do
+          "#{present_rrset.name} #{present_rrset.type}#{ present_rrset.set_identifier && " (#{present_rrset.set_identifier})" }"
+        end
+
+        # Note that desired_rrset is directly for Route 53, and present_record is also from Route 53
+        # Only given +rrset+ is brought from DSL, and dns_name & health_check is only valid in our DSL
+        Route53Wrapper::RRSET_ATTRS_WITH_TYPE.each do |attribute|
+          case attribute
+          when :dns_name
+            present = normalize_attribute_for_diff(attribute, present_rrset[:alias_target] && present_rrset[:alias_target][:dns_name])
+            desired = normalize_attribute_for_diff(attribute, desired_rrset[:alias_target] && desired_rrset[:alias_target][:dns_name])
+          when :health_check
+            present = normalize_attribute_for_diff(attribute, present_rrset[:health_check_id])
+            desired = normalize_attribute_for_diff(attribute, desired_rrset[:health_check_id])
+          else
+            present = normalize_attribute_for_diff(attribute, present_rrset[attribute])
+            desired = normalize_attribute_for_diff(attribute, desired_rrset[attribute])
+          end
+
+          if desired != present
+            color = String.colorize # XXX:
+            log(:info, "  #{attribute}:\n".green + Roadworker::Utils.diff(present, desired, color: color, indent: '    '), false)
+          end
+        end
+      end
+
+      private
+
+      def normalize_attribute_for_diff(attribute, value)
+        if value.is_a?(Array)
+          value = Aws::Route53.sort_rrset_values(attribute, value)
+          value = nil if value.empty?
+        end
+        value
+      end
+    end
+  end
+end

data/lib/roadworker/client.rb

@@ -20,8 +20,7 @@ module Roadworker
       if dsl.hosted_zones.empty? and not @options.force
         log(:warn, "Nothing is defined (pass `--force` if you want to remove)", :yellow)
       else
-        walk_hosted_zones(dsl)
-        updated = @options.updated
+        updated = walk_hosted_zones(dsl)
       end
 
       if updated and @options.health_check_gc
@@ -63,8 +62,10 @@ module Roadworker
     end
 
     def walk_hosted_zones(dsl)
-      expected = collection_to_hash(dsl.hosted_zones) {|i| [normalize_name(i.name), i.vpcs.empty?, normalize_id(i.id)] }
-      actual   = collection_to_hash(@route53.hosted_zones) {|i| [normalize_name(i.name), i.vpcs.empty?, normalize_id(i.id)] }
+      updated = false
+
+      expected = collection_to_hash(dsl.hosted_zones) {|i| [i.name, i.vpcs.empty?, normalize_id(i.id)] }
+      actual   = collection_to_hash(@route53.hosted_zones) {|i| [i.name, i.vpcs.empty?, normalize_id(i.id)] }
 
       expected.each do |keys, expected_zone|
         name, private_zone, id = keys
@@ -80,20 +81,28 @@ module Roadworker
           actual.delete(actual_keys) if actual_keys
         end
 
-        actual_zone ||= @route53.hosted_zones.create(name, :vpc => expected_zone.vpcs.first)
+        unless actual_zone
+          updated = true
+          actual_zone = @route53.hosted_zones.create(name, :vpc => expected_zone.vpcs.first)
+        end
 
-        walk_vpcs(expected_zone, actual_zone)
-        walk_rrsets(expected_zone, actual_zone)
+        updated = true if walk_vpcs(expected_zone, actual_zone)
+        updated = true if walk_rrsets(expected_zone, actual_zone)
       end
 
       actual.each do |keys, zone|
         name = keys[0]
         next unless matched_zone?(name)
         zone.delete
+        updated = true
       end
+
+      updated
     end
 
     def walk_vpcs(expected_zone, actual_zone)
+      updated = false
+
       expected_vpcs = expected_zone.vpcs || []
       actual_vpcs = actual_zone.vpcs || []
 
@@ -102,6 +111,7 @@ module Roadworker
       else
         (expected_vpcs - actual_vpcs).each do |vpc|
           actual_zone.associate_vpc(vpc)
+          updated = true
         end
 
         unexpected_vpcs = actual_vpcs - expected_vpcs
@@ -111,28 +121,30 @@ module Roadworker
         else
           unexpected_vpcs.each do |vpc|
             actual_zone.disassociate_vpc(vpc)
+            updated = true
           end
         end
       end
+
+      updated
     end
 
+    # @param [OpenStruct] expected_zone Roadworker::DSL::Hostedzone#result
+    # @param [Roadworker::Route53Wrapper::HostedzoneWrapper] actual_zone
     def walk_rrsets(expected_zone, actual_zone)
+      change_batch = Batch.new(actual_zone, health_checks: @options.health_checks, logger: @options.logger, dry_run: @options.dry_run)
+
       expected = collection_to_hash(expected_zone.rrsets, :name, :type, :set_identifier)
-      actual   = collection_to_hash(actual_zone.rrsets, :name, :type, :set_identifier)
+      actual   = actual_zone.rrsets.to_h.dup
 
       expected.each do |keys, expected_record|
-        name = keys[0]
-        type = keys[1]
-        set_identifier = keys[2]
-
+        name, type, set_identifier = keys
         actual_record = actual.delete(keys)
 
-        if not actual_record and %w(A CNAME).include?(type)
-          actual_type = (type == 'A' ? 'CNAME' : 'A')
-          actual_record = actual.delete([name, actual_type, set_identifier])
-        end
-
-        if expected_zone.ignore_patterns.any? { |pattern| pattern === name }
+        # XXX: normalization should be happen on DSL as much as possible, but ignore_patterns expect no trailing dot
+        # and to keep backward compatibility, removing then dot when checking ignored_patterns.
+        name_for_ignore_patterns = name.sub(/\.\z/, '')
+        if expected_zone.ignore_patterns.any? { |pattern| pattern === name_for_ignore_patterns }
           log(:warn, "Ignoring defined record in DSL, because it is ignored record", :yellow) do
             "#{name} #{type}" + (set_identifier ? " (#{set_identifier})" : '')
           end
@@ -141,21 +153,25 @@ module Roadworker
 
         if actual_record
           unless actual_record.eql?(expected_record)
-            actual_record.update(expected_record)
+            change_batch.update(expected_record)
           end
         else
-          actual_record = actual_zone.rrsets.create(name, type, expected_record)
+          change_batch.create(expected_record)
         end
       end
 
-      actual.each do |keys, record|
-        name = keys[0]
+      actual.each do |(name, _type, _set_identifier), record|
+        # XXX: normalization should be happen on DSL as much as possible, but ignore_patterns expect no trailing dot
+        # and to keep backward compatibility, removing then dot when checking ignored_patterns.
+        name = name.sub(/\.\z/, '')
         if expected_zone.ignore_patterns.any? { |pattern| pattern === name }
           next
         end
 
-        record.delete
+        change_batch.delete(record)
       end
+
+      change_batch.request!(@options.route53)
     end
 
     def collection_to_hash(collection, *keys)
@@ -166,8 +182,7 @@ module Roadworker
           key_list = yield(item)
         else
           key_list = keys.map do |k|
-            value = item.send(k)
-            (k == :name && value) ? normalize_name(value) : value
+             item.send(k)
           end
         end
 
@@ -177,10 +192,6 @@ module Roadworker
       return hash
     end
 
-    def normalize_name(name)
-      name.downcase.sub(/\.\z/, '')
-    end
-
     def normalize_id(id)
       id.sub(%r!^/hostedzone/!, '') if id
     end

data/lib/roadworker/dsl.rb

@@ -16,6 +16,12 @@ module Roadworker
       def test(dsl, options)
         Tester.test(dsl, options)
       end
+
+      def normalize_dns_name(name)
+        # Normalize name. AWS always returns name with trailing dot, and stores name always lowercase.
+        # https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/DomainNameFormat.html
+        "#{name.downcase}.".sub(/\.+\z/, '.')
+      end
     end # of class method
 
     attr_reader :result
@@ -60,12 +66,12 @@ module Roadworker
       attr_reader :result
 
       def initialize(context, name, id, rrsets = [], &block)
-        @name = name
-        @context = context.merge(:hosted_zone_name => name)
+        @name = DSL.normalize_dns_name(name)
+        @context = context.merge(:hosted_zone_name => @name)
 
         @result = OpenStruct.new({
           :id => id,
-          :name => name,
+          :name => @name,
           :vpcs => [],
           :resource_record_sets => rrsets,
           :rrsets => rrsets,
@@ -105,7 +111,7 @@ module Roadworker
       end
 
       def ignore_under(rrset_name)
-        ignore /(\A|\.)#{Regexp.escape(rrset_name.to_s.sub(/\.\z/, ''))}\z/
+        ignore(/(\A|\.)#{Regexp.escape(rrset_name.to_s.sub(/\.\z/, ''))}\z/)
       end
 
       def resource_record_set(rrset_name, type, &block)
@@ -123,6 +129,9 @@ module Roadworker
         attr_reader :result
 
         def initialize(context, name, type, &block)
+          name = DSL.normalize_dns_name(name)
+          type = type.upcase
+
           @context = context.merge(
             :rrset_name => name,
             :rrset_type => type

data/lib/roadworker/log.rb

@@ -1,12 +1,12 @@
 module Roadworker
   module Log
 
-    def log(level, message, color, log_id = nil)
+    def log(level, message, color, log_id = nil, dry_run: @dry_run || (@options && @options.dry_run), logger: @logger || @options.logger)
       log_id = yield if block_given?
       message = "#{message}: #{log_id}" if log_id
-      message << ' (dry-run)' if @options.dry_run
+      message << ' (dry-run)' if dry_run
       message = message.send(color) if color
-      @options.logger.send(level, message)
+      logger.send(level, message)
     end
 
   end # Log

data/lib/roadworker/route53-ext.rb

@@ -155,11 +155,28 @@ module Aws
         elsif name =~ /\.([^.]+)\.vpce\.amazonaws\.com\z/i
           region = $1.downcase
           vpce_dns_name_to_alias_target(name, region, hosted_zone_id)
+        elsif name =~ /\.awsglobalaccelerator\.com\z/i
+          globalaccelerator_dns_name_to_alias_target(name)
         else
           raise "Invalid DNS Name: #{name}"
         end
       end
 
+      def sort_rrset_values(attribute, values)
+        sort_lambda =
+          case attribute
+          when :resource_records
+            # After aws-sdk-core v3.44.1, Aws::Route53::Types::ResourceRecord#to_s returns filtered string
+            # like "{:value=>\"[FILTERED]\"}" (cf. https://github.com/aws/aws-sdk-ruby/pull/1941).
+            # To keep backward compatibility, sort by the value of resource record explicitly.
+            lambda { |i| i[:value] }
+          else
+            lambda { |i| i.to_s }
+          end
+
+        values.sort_by(&sort_lambda)
+      end
+
       private
 
       def elb_dns_name_to_alias_target(name, region, options)
@@ -250,6 +267,15 @@ module Aws
           :evaluate_target_health => false, # XXX:
         }
       end
+
+      def globalaccelerator_dns_name_to_alias_target(name)
+        # https://docs.aws.amazon.com/Route53/latest/APIReference/API_AliasTarget.html
+        {
+          :hosted_zone_id         => 'Z2BJ6XQ5FK7U4H',
+          :dns_name               => name,
+          :evaluate_target_health => false, # XXX:
+        }
+      end
     end # of class method
 
   end # Route53

data/lib/roadworker/route53-wrapper.rb

@@ -86,18 +86,26 @@ module Roadworker
       attr_reader :vpcs
 
       def resource_record_sets
-        ResourceRecordSetCollectionWrapper.new(@hosted_zone, @options)
+        @resource_record_sets ||= ResourceRecordSetCollectionWrapper.new(@hosted_zone, @options)
       end
       alias rrsets resource_record_sets
 
+      # @return [Roadworker::Route53Wrapper::ResourceRecordSetWrapper]
+      def find_resource_record_set(name, type, set_identifier)
+        resource_record_sets.to_h[[name, type, set_identifier]]
+      end
+
       def delete
         if @options.force
           log(:info, 'Delete Hostedzone', :red, @hosted_zone.name)
 
+          change_batch = Batch.new(self, health_checks: @options.health_checks, logger: @options.logger, dry_run: @options.dry_run)
           self.rrsets.each do |record|
-            record.delete
+            change_batch.delete(record)
           end
 
+          change_batch.request!(@options.route53)
+
           unless @options.dry_run
             @options.route53.delete_hosted_zone(id: @hosted_zone.id)
             @options.updated = true
@@ -142,61 +150,24 @@ module Roadworker
         @options = options
       end
 
-      def each
-        if @hosted_zone.id
-          Collection.batch(@options.route53.list_resource_record_sets(hosted_zone_id: @hosted_zone.id), :resource_record_sets) do |record|
-            yield(ResourceRecordSetWrapper.new(record, @hosted_zone, @options))
-          end
-        end
-      end
+      # @return [Hash<Array<(String,String,String)>, Roadworker::Route53Wrapper::ResourceRecordSetWrapper>]
+      def to_h
+        return @hash if defined? @hash
+        @hash = {}
 
-      def create(name, type, expected_record)
-        log(:info, 'Create ResourceRecordSet', :cyan) do
-          log_id = [name, type].join(' ')
-          rrset_setid = expected_record.set_identifier
-          rrset_setid ? (log_id + " (#{rrset_setid})") : log_id
+        self.each do |item|
+          @hash[[item.name, item.type, item.set_identifier]] = item
         end
 
-        if @options.dry_run
-          record = expected_record
-        else
-          resource_record_set_params = {
-            name: name,
-            type: type,
-          }
-
-          Route53Wrapper::RRSET_ATTRS.each do |attribute|
-            value = expected_record.send(attribute)
-            next unless value
-
-            case attribute
-            when :dns_name
-              attribute = :alias_target
-              dns_name, dns_name_opts = value
-              value = Aws::Route53.dns_name_to_alias_target(dns_name, dns_name_opts, @hosted_zone.id, @hosted_zone.name || @options.hosted_zone_name)
-            when :health_check
-              attribute = :health_check_id
-              value = @options.health_checks.find_or_create(value)
-            end
+        @hash
+      end
 
-            resource_record_set_params[attribute] = value
+      def each
+        if @hosted_zone.id
+          Collection.batch(@options.route53.list_resource_record_sets(hosted_zone_id: @hosted_zone.id), :resource_record_sets) do |record|
+            yield(ResourceRecordSetWrapper.new(record, @hosted_zone, @options))
           end
-
-          @options.route53.change_resource_record_sets(
-            hosted_zone_id: @hosted_zone.id,
-            change_batch: {
-              changes: [
-                {
-                  action: 'CREATE',
-                  resource_record_set: resource_record_set_params,
-                },
-              ],
-            },
-          )
-          @options.updated = true
         end
-
-        ResourceRecordSetWrapper.new(expected_record, @hosted_zone, @options)
       end
     end # ResourceRecordSetCollectionWrapper
 
@@ -212,10 +183,10 @@ module Roadworker
       def eql?(expected_record)
         Route53Wrapper::RRSET_ATTRS_WITH_TYPE.all? do |attribute|
           expected = expected_record.public_send(attribute)
-          expected = sort_rrset_values(attribute, expected) if expected.kind_of?(Array)
+          expected = Aws::Route53.sort_rrset_values(attribute, expected) if expected.kind_of?(Array)
           expected = nil if expected.kind_of?(Array) && expected.empty?
           actual = self.public_send(attribute)
-          actual = sort_rrset_values(attribute, actual) if actual.kind_of?(Array)
+          actual = Aws::Route53.sort_rrset_values(attribute, actual) if actual.kind_of?(Array)
           actual = nil if actual.kind_of?(Array) && actual.empty?
 
           if attribute == :geo_location and actual
@@ -252,99 +223,6 @@ module Roadworker
         end
       end
 
-      def update(expected_record)
-        log_id_proc = proc do
-          log_id = [self.name, self.type].join(' ')
-          rrset_setid = self.set_identifier
-          rrset_setid ? (log_id + " (#{rrset_setid})") : log_id
-        end
-
-        log(:info, 'Update ResourceRecordSet', :green, &log_id_proc)
-
-        resource_record_set_prev = @resource_record_set.dup
-        Route53Wrapper::RRSET_ATTRS_WITH_TYPE.each do |attribute|
-          expected = expected_record.send(attribute)
-          expected = expected.sort_by {|i| i.to_s } if expected.kind_of?(Array)
-          expected = nil if expected.kind_of?(Array) && expected.empty?
-          actual = self.send(attribute)
-          actual = actual.sort_by {|i| i.to_s } if actual.kind_of?(Array)
-          actual = nil if actual.kind_of?(Array) && actual.empty?
-
-          # XXX: Fix for diff
-          if attribute == :health_check and actual
-            if (actual[:child_health_checks] || []).empty?
-              actual[:child_health_checks] = []
-            end
-
-            if (actual[:regions] || []).empty?
-              actual[:regions] = []
-            end
-          end
-
-          if (expected and !actual) or (!expected and actual)
-            log(:info, "  #{attribute}:\n".green + Roadworker::Utils.diff(actual, expected, :color => @options.color, :indent => '    '), false)
-            unless @options.dry_run
-              self.send(:"#{attribute}=", expected)
-            end
-          elsif expected and actual
-            if expected != actual
-              log(:info, "  #{attribute}:\n".green + Roadworker::Utils.diff(actual, expected, :color => @options.color, :indent => '    '), false)
-              unless @options.dry_run
-                self.send(:"#{attribute}=", expected)
-              end
-            end
-          end
-        end
-
-        unless @options.dry_run
-          @options.route53.change_resource_record_sets(
-            hosted_zone_id: @hosted_zone.id,
-            change_batch: {
-              changes: [
-                {
-                  action: 'DELETE',
-                  resource_record_set: resource_record_set_prev,
-                },
-                {
-                  action: 'CREATE',
-                  resource_record_set: @resource_record_set,
-                },
-              ],
-            },
-          )
-          @options.updated = true
-        end
-      end
-
-      def delete
-        if self.type =~ /\A(SOA|NS)\z/i
-          hz_name = (@hosted_zone.name || @options.hosted_zone_name).downcase.sub(/\.\z/, '')
-          rrs_name = @resource_record_set.name.downcase.sub(/\.\z/, '')
-          return if hz_name == rrs_name
-        end
-
-        log(:info, 'Delete ResourceRecordSet', :red) do
-          log_id = [self.name, self.type].join(' ')
-          rrset_setid = self.set_identifier
-          rrset_setid ? (log_id + " (#{rrset_setid})") : log_id
-        end
-
-        unless @options.dry_run
-          @options.route53.change_resource_record_sets(
-            hosted_zone_id: @hosted_zone.id,
-            change_batch: {
-              changes: [
-                {
-                  action: 'DELETE',
-                  resource_record_set: @resource_record_set,
-                },
-              ],
-            },
-          )
-          @options.updated = true
-        end
-      end
-
       def name
         value = @resource_record_set.name
         value ? value.gsub("\\052", '*') : value
@@ -364,41 +242,12 @@ module Roadworker
         end
       end
 
-      def dns_name=(value)
-        if value
-          dns_name, dns_name_opts = value
-          @resource_record_set.alias_target = Aws::Route53.dns_name_to_alias_target(dns_name, dns_name_opts, @hosted_zone.id, @hosted_zone.name || @options.hosted_zone_name)
-        else
-          @resource_record_set.alias_target = nil
-        end
-      end
-
       def health_check
         @options.health_checks[@resource_record_set.health_check_id]
       end
 
-      def health_check=(check)
-        health_check_id = check ? @options.health_checks.find_or_create(check) : nil
-        @resource_record_set.health_check_id = health_check_id
-      end
-
       private
 
-      def sort_rrset_values(attribute, values)
-        sort_lambda =
-          case attribute
-          when :resource_records
-            # After aws-sdk-core v3.44.1, Aws::Route53::Types::ResourceRecord#to_s returns filtered string
-            # like "{:value=>\"[FILTERED]\"}" (cf. https://github.com/aws/aws-sdk-ruby/pull/1941).
-            # To keep backward compatibility, sort by the value of resource record explicitly.
-            lambda { |i| i[:value] }
-          else
-            lambda { |i| i.to_s }
-          end
-
-        values.sort_by(&sort_lambda)
-      end
-
       def method_missing(method_name, *args)
         @resource_record_set.send(method_name, *args)
       end

data/lib/roadworker/utils.rb

@@ -4,12 +4,16 @@ module Roadworker
       def matched_zone?(name)
         result = true
 
+        # XXX: normalization should be happen on DSL as much as possible, but patterns expect no trailing dot
+        # and to keep backward compatibility, removing then dot when checking patterns.
+        name_for_patterns = name.sub(/\.\z/, '')
+
         if @options.exclude_zone
-          result &&= name !~ @options.exclude_zone
+          result &&= name_for_patterns !~ @options.exclude_zone
         end
 
         if @options.target_zone
-          result &&= name =~ @options.target_zone
+          result &&= name_for_patterns =~ @options.target_zone
         end
 
         result

data/lib/roadworker/version.rb

@@ -1,3 +1,3 @@
 module Roadworker
-  VERSION = "0.5.12"
+  VERSION = "0.5.13"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roadworker
 version: !ruby/object:Gem::Version
-  version: 0.5.12
+  version: 0.5.13
 platform: ruby
 authors:
 - winebarrel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-26 00:00:00.000000000 Z
+date: 2020-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-route53
@@ -192,20 +192,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: transpec
-  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'
 description: Roadworker is a tool to manage Route53. It defines the state of Route53
   using DSL, and updates Route53 according to DSL.
 email: sgwr_dts@yahoo.co.jp
@@ -217,6 +203,7 @@ files:
 - README.md
 - bin/roadwork
 - lib/roadworker.rb
+- lib/roadworker/batch.rb
 - lib/roadworker/client.rb
 - lib/roadworker/collection.rb
 - lib/roadworker/dsl-converter.rb