dnsmadeeasy 0.3.5 → 1.0.1

data/lib/dnsmadeeasy/zone/apply_executor.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require 'dry/monads'
+require 'dnsmadeeasy/zone/apply_result'
+require 'tty-spinner'
+
+module DnsMadeEasy
+  module Zone
+    # Executes safe plan actions against DNS Made Easy.
+    class ApplyExecutor
+      include Dry::Monads[:result]
+
+      MODES = %i[merge add_only delete_only].freeze
+      DEFAULT_MAX_THREADS = 4
+
+      def initialize(client:, domain:, plan:, remote_records:, mode: :merge, spinner_factory: nil, spinner_output: $stderr,
+                     max_threads: DEFAULT_MAX_THREADS)
+        @client = client
+        @domain = domain
+        @plan = plan
+        @remote_records = remote_records
+        @mode = mode
+        @spinner_factory = spinner_factory || default_spinner_factory(spinner_output)
+        @max_threads = [max_threads.to_i, 1].max
+      end
+
+      def executable_action_count
+        executable_actions.length
+      end
+
+      def call
+        return Failure(["Unsupported apply mode: #{mode}"]) unless MODES.include?(mode)
+
+        applied_actions, failed_actions = execute_actions(executable_actions)
+
+        Success(ApplyResult.new(
+                  applied_actions: applied_actions,
+                  failed_actions: failed_actions,
+                  skipped_actions: skipped_actions
+                ))
+      end
+
+      private
+
+      attr_reader :client,
+                  :domain,
+                  :plan,
+                  :remote_records,
+                  :mode,
+                  :spinner_factory,
+                  :max_threads
+
+      def executable_actions
+        sort_actions(
+          case mode
+          when :add_only
+            plan.creates
+          when :delete_only
+            deletable_actions
+          else
+            plan.creates + plan.updates
+          end
+        )
+      end
+
+      def skipped_actions
+        plan.actions - executable_actions
+      end
+
+      def execute_actions(actions)
+        return [[], []] if actions.empty?
+
+        applied_actions = []
+        failed_actions = []
+        outcome_mutex = Mutex.new
+        spinner_group = spinner_factory.call("Applying #{actions.length} DNS action(s)")
+
+        action_chunks(actions).each_with_index do |chunk, index|
+          register_chunk(spinner_group, chunk, index, outcome_mutex, applied_actions, failed_actions)
+        end
+
+        spinner_group.auto_spin
+
+        [ordered_actions(applied_actions), ordered_actions(failed_actions)]
+      end
+
+      def register_chunk(spinner_group, chunk, index, outcome_mutex, applied_actions, failed_actions)
+        spinner_group.register("[:spinner] worker #{index + 1}: #{chunk.length} action(s)") do |spinner|
+          failed = execute_chunk(chunk, outcome_mutex, applied_actions, failed_actions)
+          failed ? spinner.error : spinner.success
+        end
+      end
+
+      def execute_chunk(chunk, outcome_mutex, applied_actions, failed_actions)
+        failed = false
+        chunk.each do |indexed_action|
+          failed = true if execute_indexed_action(indexed_action, outcome_mutex, applied_actions, failed_actions)
+        end
+        failed
+      end
+
+      def execute_indexed_action(indexed_action, outcome_mutex, applied_actions, failed_actions)
+        execute_action(indexed_action.fetch(:action))
+        outcome_mutex.synchronize { applied_actions << indexed_action }
+        false
+      rescue StandardError
+        outcome_mutex.synchronize { failed_actions << indexed_action }
+        true
+      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
+        chunk_size = (indexed_actions.length.to_f / worker_count).ceil
+        indexed_actions.each_slice(chunk_size).to_a
+      end
+
+      def ordered_actions(indexed_actions)
+        indexed_actions.sort_by { |indexed_action| indexed_action.fetch(:index) }.map { |indexed_action| indexed_action.fetch(:action) }
+      end
+
+      def execute_action(action)
+        case action.action
+        when 'create'
+          create_record(action.record)
+        when 'update'
+          update_record(action)
+        when 'skipped_delete'
+          delete_record(action.record)
+        end
+      end
+
+      def create_record(record)
+        client.create_record(domain, api_owner(record), record.type, record.value, record_options(record))
+      end
+
+      def update_record(action)
+        provider_id = provider_id_for(action.remote_record)
+        client.update_record(domain, provider_id, api_owner(action.desired_record), action.desired_record.type,
+                             action.desired_record.value, record_options(action.desired_record))
+      end
+
+      def delete_record(record)
+        client.delete_record(domain, provider_id_for(record))
+      end
+
+      def provider_id_for(record)
+        provider_record = remote_records.provider_records.find { |candidate| candidate.record == record }
+        raise KeyError, "No provider id for #{record.owner} #{record.type}" unless provider_record&.provider_id
+
+        provider_record.provider_id
+      end
+
+      def deletable_actions
+        plan.skipped_deletes.reject { |action| protected_delete?(action.record) }
+      end
+
+      def sort_actions(actions)
+        actions.sort_by(&:sort_key)
+      end
+
+      def protected_delete?(record)
+        record.type == 'SOA' || (record.owner == '@' && record.type == 'NS')
+      end
+
+      def api_owner(record)
+        record.owner == '@' ? '' : record.owner
+      end
+
+      def record_options(record)
+        options = { 'ttl' => record.ttl }
+        options['mxLevel'] = record.priority if record.type == 'MX'
+        options.merge!('priority' => record.priority, 'weight' => record.weight, 'port' => record.port) if record.type == 'SRV'
+        options.compact
+      end
+
+      def default_spinner_factory(spinner_output)
+        lambda do |message|
+          TTY::Spinner::Multi.new(
+            "[:spinner] #{message}",
+            output: spinner_output,
+            clear: true,
+            hide_cursor: true
+          )
+        end
+      end
+    end
+  end
+end

data/lib/dnsmadeeasy/zone/apply_result.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'dry/struct'
+require 'dnsmadeeasy/types'
+require 'dnsmadeeasy/zone/plan_action'
+
+module DnsMadeEasy
+  module Zone
+    # Result of executing a zone plan.
+    class ApplyResult < Dry::Struct
+      transform_keys(&:to_sym)
+
+      attribute :applied_actions, Types::Array.of(PlanAction).default([].freeze)
+      attribute :failed_actions, Types::Array.of(PlanAction).default([].freeze)
+      attribute :skipped_actions, Types::Array.of(PlanAction).default([].freeze)
+
+      def success?
+        failed_actions.empty?
+      end
+    end
+  end
+end

data/lib/dnsmadeeasy/zone/diff.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'dnsmadeeasy/zone/plan'
+
+module DnsMadeEasy
+  module Zone
+    # Builds a conservative execution plan from desired and remote record sets.
+    # TTL-only differences are ignored unless compare_ttl is true.
+    class Diff
+      def initialize(desired_records:, remote_records:, compare_ttl: false)
+        @provider_managed_records, @desired_records = desired_records.partition { |record| provider_managed?(record) }
+        @remote_records = remote_records
+        @compare_ttl = compare_ttl
+      end
+
+      def call
+        Plan.new(
+          creates: create_actions,
+          updates: update_actions,
+          skipped_creates: skipped_create_actions,
+          skipped_deletes: skipped_delete_actions,
+          ambiguous: ambiguous_actions
+        )
+      end
+
+      private
+
+      attr_reader :desired_records,
+                  :provider_managed_records,
+                  :remote_records,
+                  :compare_ttl
+
+      # Apex NS records are owned by DNS Made Easy: the API neither returns
+      # nor accepts them, so they are excluded from the diff and reported.
+      def provider_managed?(record)
+        record.owner == '@' && record.type == 'NS'
+      end
+
+      def skipped_create_actions
+        provider_managed_records.map do |record|
+          PlanAction.new(action: 'skipped_create', record: record,
+                         message: 'Apex NS records are managed by the DNS provider')
+        end
+      end
+
+      def create_actions
+        missing_desired_records.map { |record| PlanAction.new(action: 'create', record: record) }
+      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
+          )
+        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
+        return desired if compare_ttl
+
+        desired.new(ttl: pair.fetch(:remote).first.ttl)
+      end
+
+      def skipped_delete_actions
+        remote_only_records.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?
+
+          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})"
+          )
+        end
+      end
+
+      def missing_desired_records
+        desired_records.reject { |record| remote_keys.include?(comparison_key(record)) } - changed_desired_records
+      end
+
+      def remote_only_records
+        remote_records.reject { |record| desired_keys.include?(comparison_key(record)) } - changed_remote_records
+      end
+
+      def changed_desired_records
+        changed_identity_pairs.values.flat_map { |pair| pair.fetch(:desired) }
+      end
+
+      def changed_remote_records
+        changed_identity_pairs.values.flat_map { |pair| pair.fetch(:remote) }
+      end
+
+      def changed_identity_pairs
+        @changed_identity_pairs ||= desired_by_identity.each_with_object({}) do |(identity, desired_group), pairs|
+          remote_group = remote_by_identity.fetch(identity, [])
+          next if remote_group.empty? || same_record_multiset?(desired_group, remote_group)
+
+          pairs[identity] = { desired: desired_group, remote: remote_group }
+        end
+      end
+
+      # Groups match regardless of order: the API returns records in
+      # arbitrary order while zone files are sorted.
+      def same_record_multiset?(desired_group, remote_group)
+        comparison_keys(desired_group).tally == comparison_keys(remote_group).tally
+      end
+
+      def desired_by_identity
+        @desired_by_identity ||= desired_records.group_by { |record| identity(record) }
+      end
+
+      def remote_by_identity
+        @remote_by_identity ||= remote_records.group_by { |record| identity(record) }
+      end
+
+      def identity(record)
+        [record.owner, record.type]
+      end
+
+      def desired_keys
+        @desired_keys ||= comparison_keys(desired_records)
+      end
+
+      def remote_keys
+        @remote_keys ||= comparison_keys(remote_records)
+      end
+
+      def comparison_keys(records)
+        records.map { |record| comparison_key(record) }
+      end
+
+      def comparison_key(record)
+        key = [record.owner, record.type, record.value, record.priority, record.weight, record.port]
+        compare_ttl ? key << record.ttl : key
+      end
+    end
+  end
+end

data/lib/dnsmadeeasy/zone/file.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'dry/struct'
+require 'dnsmadeeasy/types'
+require 'dnsmadeeasy/zone/record_set'
+
+module DnsMadeEasy
+  module Zone
+    # Parsed zone-file document with metadata needed for canonical output.
+    class File < Dry::Struct
+      transform_keys(&:to_sym)
+
+      attribute :origin, Types::NonEmptyString
+      attribute :ttl, Types::Ttl.default(300)
+      attribute :record_set, RecordSet
+
+      def records
+        record_set.records
+      end
+
+      def sorted
+        record_set.sorted
+      end
+    end
+  end
+end

data/lib/dnsmadeeasy/zone/parser.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require 'dns/zonefile'
+require 'dry/monads'
+require 'dnsmadeeasy/zone/file'
+require 'dnsmadeeasy/zone/record'
+require 'dnsmadeeasy/zone/record_set'
+
+module DnsMadeEasy
+  module Zone
+    # Parses standard zone-file text into provider-neutral records.
+    class Parser
+      include Dry::Monads[:result]
+
+      # ANAME is absent from the dns-zonefile grammar; ANAME lines are
+      # rewritten to CNAME before parsing and converted back afterwards.
+      SUPPORTED_RECORD_CLASSES = {
+        'DNS::Zonefile::A' => 'A',
+        'DNS::Zonefile::AAAA' => 'AAAA',
+        'DNS::Zonefile::CNAME' => 'CNAME',
+        'DNS::Zonefile::MX' => 'MX',
+        'DNS::Zonefile::NS' => 'NS',
+        'DNS::Zonefile::PTR' => 'PTR',
+        'DNS::Zonefile::SPF' => 'SPF',
+        'DNS::Zonefile::SRV' => 'SRV',
+        'DNS::Zonefile::TXT' => 'TXT'
+      }.freeze
+
+      ANAME_LINE = /^(?<owner>[^\s;]\S*)\s+(?:\d+\s+)?(?:IN\s+)?ANAME\s+(?<target>\S+)/i
+
+      def initialize(zone_text)
+        @zone_text = zone_text
+        @aname_keys = []
+      end
+
+      def call
+        zone = DNS::Zonefile.load(parseable_zone_text)
+        records, errors = build_records(zone)
+        return Failure(errors) if errors.any?
+
+        Success(File.new(origin: zone_origin(zone), ttl: zone_ttl(zone), record_set: RecordSet.new(records: records)))
+      rescue DNS::Zonefile::ParsingError, DNS::Zonefile::UnknownRecordType, Dry::Struct::Error => e
+        Failure([e.message])
+      end
+
+      private
+
+      attr_reader :zone_text,
+                  :aname_keys
+
+      def parseable_zone_text
+        zone_lines = rewrite_aname_lines(zone_text.lines)
+        insert_synthetic_soa(zone_lines) unless zone_text.match?(/\bSOA\b/)
+        zone_lines.join
+      end
+
+      def rewrite_aname_lines(zone_lines)
+        zone_lines.map do |line|
+          match = ANAME_LINE.match(line)
+          next line unless match
+
+          aname_keys << [match[:owner], match[:target]]
+          line.sub(/\bANAME\b/i, 'CNAME')
+        end
+      end
+
+      def insert_synthetic_soa(zone_lines)
+        insertion_index = zone_lines.index { |line| !line.strip.start_with?('$') && !line.strip.empty? } || zone_lines.length
+        zone_lines.insert(insertion_index, synthetic_soa_line)
+      end
+
+      def synthetic_soa_line
+        "@ IN SOA ns.#{origin_from_text} hostmaster.#{origin_from_text} ( 1 1d 1d 4W #{ttl_from_text} )\n"
+      end
+
+      def origin_from_text
+        zone_text[/^\$ORIGIN\s+(\S+)/, 1] || 'example.invalid.'
+      end
+
+      def ttl_from_text
+        zone_text[/^\$TTL\s+(\d+)/, 1] || 300
+      end
+
+      def build_records(zone)
+        origin = zone_origin(zone)
+        zone.records.each_with_object([[], []]) do |provider_record, (records, errors)|
+          next if provider_record.is_a?(DNS::Zonefile::SOA)
+
+          record_type = SUPPORTED_RECORD_CLASSES[provider_record.class.name]
+          if record_type
+            records << build_record(provider_record, record_type, origin)
+          else
+            errors << "Unsupported DNS record type: #{provider_record.class.name.split('::').last}"
+          end
+        end
+      end
+
+      def zone_origin(zone)
+        zone.soa&.origin || '.'
+      end
+
+      def zone_ttl(zone)
+        zone.soa&.ttl || 300
+      end
+
+      def build_record(provider_record, record_type, origin)
+        record_type = 'ANAME' if record_type == 'CNAME' && aname?(provider_record, origin)
+        attributes = {
+          owner: normalize_owner(provider_record.host, origin),
+          type: record_type,
+          value: record_value(provider_record, record_type, origin),
+          ttl: provider_record.ttl
+        }.merge(record_metadata(provider_record, record_type))
+
+        Record.new(attributes)
+      end
+
+      def normalize_owner(host, origin)
+        return '@' if host == origin
+
+        host.delete_suffix(".#{origin}").delete_suffix('.')
+      end
+
+      def record_value(provider_record, record_type, origin)
+        case record_type
+        when 'A', 'AAAA'
+          provider_record.address
+        when 'ANAME', 'CNAME', 'MX', 'NS', 'PTR', 'SRV'
+          normalize_target(provider_record.domainname, origin)
+        when 'SPF', 'TXT'
+          normalize_text_value(provider_record.data)
+        end
+      end
+
+      def normalize_target(target, origin)
+        return '@' if target == origin
+
+        target
+      end
+
+      def aname?(provider_record, origin)
+        owner = normalize_owner(provider_record.host, origin)
+        target = absolute_name(provider_record.domainname, origin)
+        aname_keys.any? do |key_owner, key_target|
+          normalize_owner(absolute_name(key_owner, origin), origin) == owner &&
+            absolute_name(key_target, origin) == target
+        end
+      end
+
+      def absolute_name(name, origin)
+        return origin if name == '@'
+
+        name.end_with?('.') ? name : "#{name}.#{origin}"
+      end
+
+      def normalize_text_value(value)
+        value.delete_prefix('"').delete_suffix('"')
+      end
+
+      def record_metadata(provider_record, record_type)
+        case record_type
+        when 'MX'
+          { priority: provider_record.priority }
+        when 'SRV'
+          { priority: provider_record.priority, weight: provider_record.weight, port: provider_record.port }
+        else
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/dnsmadeeasy/zone/plan.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'dry/struct'
+require 'dnsmadeeasy/types'
+require 'dnsmadeeasy/zone/plan_action'
+
+module DnsMadeEasy
+  module Zone
+    # Diff result describing intended changes without applying them.
+    class Plan < Dry::Struct
+      transform_keys(&:to_sym)
+
+      attribute :creates, Types::Array.of(PlanAction).default([].freeze)
+      attribute :updates, Types::Array.of(PlanAction).default([].freeze)
+      attribute :skipped_creates, Types::Array.of(PlanAction).default([].freeze)
+      attribute :skipped_deletes, Types::Array.of(PlanAction).default([].freeze)
+      attribute :ambiguous, Types::Array.of(PlanAction).default([].freeze)
+
+      def actions
+        [creates, updates, skipped_creates, skipped_deletes, ambiguous].flatten.sort_by(&:sort_key)
+      end
+
+      def empty?
+        actions.empty?
+      end
+    end
+  end
+end

data/lib/dnsmadeeasy/zone/plan_action.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'dry/struct'
+require 'dnsmadeeasy/types'
+require 'dnsmadeeasy/zone/record'
+
+module DnsMadeEasy
+  module Zone
+    # A single proposed zone-management action.
+    class PlanAction < Dry::Struct
+      transform_keys(&:to_sym)
+
+      ACTION_TYPES = %w[create update skipped_create skipped_delete ambiguous].freeze
+
+      attribute :action, Types::StrictString.enum(*ACTION_TYPES)
+      attribute :record, Record.optional.default(nil)
+      attribute :remote_record, Record.optional.default(nil)
+      attribute :desired_record, Record.optional.default(nil)
+      attribute :message, Types::OptionalString.default(nil)
+
+      def sort_key
+        [
+          ACTION_TYPES.index(action),
+          (record || desired_record || remote_record)&.sort_key || []
+        ]
+      end
+    end
+  end
+end