dnsmadeeasy 1.0.3 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8fc4acfe2b0918ef18592054a35d07cbb708337b126ba512baaebdf4c77d83ad
-  data.tar.gz: 8f1afb57a6f8b18b5e502998f81bbbaa69acbbeb4a1f3f1cabcc3b3eecebf07a
+  metadata.gz: 759a25855a49669fe87a973eef041686c68237389bbf750eee5a3d98d49b3ebe
+  data.tar.gz: 66239b4a984c77bdb1b79390726c55283fec3557a008492acf8728360473049b
 SHA512:
-  metadata.gz: abfe6e3dd6a1a6e071b72d6938548d4ee84369c2897a891d343f557e2f0b31271967b51a58a9885beae29528db5d0b0fe0ddd44123fb3ed0f2036118913f220c
-  data.tar.gz: 04a3941fa03915750cd0e10c57f61aa079f951dc04c6ff41eb208c2bd4c3e9b0cc9038ea2be7055a91a26d881157a918a769ac94f859f5a5af550520e9cce048
+  metadata.gz: e6754018965be4d4335ce0d7b5c27736a7696ab489e8e0cb055987573d283ceae48ee004b9d7a1d64a935de6a45f65baacacb122754e0b221b8f8b40c4288668
+  data.tar.gz: 35a19aa2914f68b26579544633ce48b0ce3071aa255ee08ce7d5addd04cf47d607737bf60fac074aed6f4acc5db99dbe717323888adbd6fa88cf5c33aea3957c

data/lib/dnsmadeeasy/cli/commands/zone.rb

@@ -370,7 +370,22 @@ module DnsMadeEasy
               kv('Skipped', result.skipped_actions.length)
             ].join("\n")
 
-            result.failed_actions.empty? ? success(summary) : warning(summary)
+            return success(summary) if result.failed_actions.empty?
+
+            warning(summary)
+            puts failed_section(result.failed_actions)
+          end
+
+          # Each failed action carries the API error message attached by the
+          # executor; a bare failure count is undebuggable.
+          def failed_section(actions)
+            (['Failed'] + actions.map { |action| "  - #{failed_line(action)}" }).join("\n")
+          end
+
+          def failed_line(action)
+            record = action.record || action.desired_record
+            line = [record.owner, record.type, record.priority, record.value, "(ttl=#{record.ttl})"].compact.join(' ')
+            action.message ? "#{line} — #{action.message}" : line
           end
 
           def fail_with(message, errors)

data/lib/dnsmadeeasy/version.rb

@@ -2,5 +2,5 @@
 
 module DnsMadeEasy
   # Version 1.0+ is supporting zone file manipulation
-  VERSION = '1.0.3'
+  VERSION = '1.0.5'
 end

data/lib/dnsmadeeasy/zone/apply_executor.rb

@@ -13,8 +13,14 @@ module DnsMadeEasy
       MODES = %i[merge add_only delete_only].freeze
       DEFAULT_MAX_THREADS = 4
 
+      # The DNS Made Easy API intermittently rejects rapid record mutations
+      # (rate limiting); short exponential backoff absorbs transient failures.
+      RETRY_ATTEMPTS = 3
+      RETRY_BASE_SLEEP = 1.0
+
+      # rubocop:disable Metrics/ParameterLists -- dependency-injected executor
       def initialize(client:, domain:, plan:, remote_records:, mode: :merge, spinner_factory: nil, spinner_output: $stderr,
-                     max_threads: DEFAULT_MAX_THREADS)
+                     max_threads: DEFAULT_MAX_THREADS, sleeper: nil)
         @client = client
         @domain = domain
         @plan = plan
@@ -22,7 +28,9 @@ module DnsMadeEasy
         @mode = mode
         @spinner_factory = spinner_factory || default_spinner_factory(spinner_output)
         @max_threads = [max_threads.to_i, 1].max
+        @sleeper = sleeper || ->(seconds) { sleep(seconds) }
       end
+      # rubocop:enable Metrics/ParameterLists
 
       def executable_action_count
         executable_actions.length
@@ -48,7 +56,8 @@ module DnsMadeEasy
                   :remote_records,
                   :mode,
                   :spinner_factory,
-                  :max_threads
+                  :max_threads,
+                  :sleeper
 
       def executable_actions
         sort_actions(
@@ -100,14 +109,35 @@ module DnsMadeEasy
       end
 
       def execute_indexed_action(indexed_action, outcome_mutex, applied_actions, failed_actions)
-        execute_action(indexed_action.fetch(:action))
+        execute_action_with_retries(indexed_action.fetch(:action))
         outcome_mutex.synchronize { applied_actions << indexed_action }
         false
-      rescue StandardError
-        outcome_mutex.synchronize { failed_actions << indexed_action }
+      rescue StandardError => e
+        failed = indexed_action.merge(action: annotate_failure(indexed_action.fetch(:action), e))
+        outcome_mutex.synchronize { failed_actions << failed }
         true
       end
 
+      def execute_action_with_retries(action)
+        attempt = 0
+        begin
+          execute_action(action)
+        rescue StandardError
+          attempt += 1
+          raise if attempt >= RETRY_ATTEMPTS
+
+          sleeper.call(RETRY_BASE_SLEEP * (2**(attempt - 1)))
+          retry
+        end
+      end
+
+      # Attach the error to the failed action so the CLI can explain what
+      # went wrong instead of reporting a bare count.
+      def annotate_failure(action, error)
+        message = error.message.to_s.strip
+        action.new(message: message.empty? ? error.class.name : message)
+      end
+
       def action_chunks(actions)
         indexed_actions = actions.each_with_index.map { |action, index| { action: action, index: index } }
         worker_count = [indexed_actions.length, max_threads].min

data/lib/dnsmadeeasy/zone/diff.rb

@@ -19,7 +19,7 @@ module DnsMadeEasy
           updates: update_actions,
           skipped_creates: skipped_create_actions,
           skipped_deletes: skipped_delete_actions,
-          ambiguous: ambiguous_actions
+          ambiguous: []
         )
       end
 
@@ -44,47 +44,69 @@ module DnsMadeEasy
       end
 
       def create_actions
-        missing_desired_records.map { |record| PlanAction.new(action: 'create', record: record) }
+        group_creates = group_deltas.flat_map { |delta| delta.fetch(:creates) }
+        (missing_desired_records + group_creates).map do |record|
+          PlanAction.new(action: 'create', record: record)
+        end
       end
 
       def update_actions
-        changed_identity_pairs.filter_map do |_identity, pair|
-          next unless pair.fetch(:desired).one? && pair.fetch(:remote).one?
-
-          PlanAction.new(
-            action: 'update',
-            desired_record: update_payload(pair),
-            remote_record: pair.fetch(:remote).first
-          )
+        group_deltas.flat_map do |delta|
+          delta.fetch(:updates).map do |desired, remote|
+            PlanAction.new(
+              action: 'update',
+              desired_record: update_payload(desired, remote),
+              remote_record: remote
+            )
+          end
         end
       end
 
       # When TTLs are not compared, an update must not modify the remote TTL
       # as a side effect, so the desired record inherits it.
-      def update_payload(pair)
-        desired = pair.fetch(:desired).first
+      def update_payload(desired, remote)
         return desired if compare_ttl
 
-        desired.new(ttl: pair.fetch(:remote).first.ttl)
+        desired.new(ttl: remote.ttl)
       end
 
       def skipped_delete_actions
-        remote_only_records.map do |record|
+        group_deletes = group_deltas.flat_map { |delta| delta.fetch(:deletes) }
+        (remote_only_records + group_deletes).map do |record|
           PlanAction.new(action: 'skipped_delete', record: record, message: 'Delete skipped by default')
         end
       end
 
-      def ambiguous_actions
-        changed_identity_pairs.filter_map do |_identity, pair|
-          next if pair.fetch(:desired).one? && pair.fetch(:remote).one?
+      # Individual records within an RRset carry no identity — only the set of
+      # values is meaningful in DNS. Within a changed (owner, type) group,
+      # records whose values match on both sides are unchanged; the rest are
+      # paired in sorted-value order as updates. Excess desired records become
+      # creates; excess remote records become (skipped) deletes. The end state
+      # is exact regardless of how records are paired.
+      def group_deltas
+        @group_deltas ||= changed_identity_pairs.values.map do |pair|
+          desired_changed = multiset_subtract(pair.fetch(:desired), pair.fetch(:remote)).sort_by(&:value)
+          remote_changed  = multiset_subtract(pair.fetch(:remote), pair.fetch(:desired)).sort_by(&:value)
+          paired          = [desired_changed.length, remote_changed.length].min
+
+          {
+            updates: desired_changed.first(paired).zip(remote_changed.first(paired)),
+            creates: desired_changed.drop(paired),
+            deletes: remote_changed.drop(paired)
+          }
+        end
+      end
+
+      # Records from +records+ that have no value-level counterpart in
+      # +others+, honoring duplicates (a multiset difference).
+      def multiset_subtract(records, others)
+        remaining = comparison_keys(others).tally
+        records.reject do |record|
+          key = comparison_key(record)
+          next false unless remaining[key].to_i.positive?
 
-          PlanAction.new(
-            action: 'ambiguous',
-            desired_record: pair.fetch(:desired).first,
-            remote_record: pair.fetch(:remote).first,
-            message: 'Multiple records share the same owner/type identity ' \
-                     "(desired: #{pair.fetch(:desired).length}, remote: #{pair.fetch(:remote).length})"
-          )
+          remaining[key] -= 1
+          true
         end
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dnsmadeeasy
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.5
 platform: ruby
 authors:
 - Konstantin Gredeskoul