dnsmadeeasy 0.4.0 → 1.0.5

data/lib/dnsmadeeasy/cli/message_helpers.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'tty-box'
+
+module DnsMadeEasy
+  module CLI
+    # Colorful boxed CLI status messages. All boxes print to stderr so that
+    # stdout carries only command payload (zone files, plan output) and
+    # stays safe to pipe or redirect.
+    #
+    # Include the module to call info/success/warning/error directly from a
+    # command; boxes then print to the includer's @err stream when present.
+    # The module-level methods (MessageHelpers.error etc.) remain available
+    # for callers outside the command classes.
+    module MessageHelpers
+      BOX_OPTIONS = {
+        border: { type: :thick },
+        width: 85
+      }.freeze
+
+      # Right-aligned key column for "key: value" lines inside boxes.
+      KEY_WIDTH = 30
+
+      class << self
+        attr_accessor :stdout, :stderr
+
+        def included(base)
+          base.include(InstanceMethods)
+        end
+
+        def info(message)
+          print_box(:info, message, stderr)
+        end
+
+        def warn(message)
+          print_box(:warn, message, stderr)
+        end
+
+        def error(message)
+          print_box(:error, message, stderr)
+        end
+
+        def success(message)
+          print_box(:success, message, stderr)
+        end
+
+        def print_box(box_type, message, output)
+          box = TTY::Box.public_send(box_type, message, **BOX_OPTIONS)
+          output.puts
+          output.puts(box)
+          box
+        end
+
+        def kv(key, value)
+          format("%#{KEY_WIDTH}s: %s", key, value)
+        end
+      end
+
+      # Boxed helpers for command classes. The warn box is exposed as
+      # #warning because commands already use Kernel-style plain #warn.
+      module InstanceMethods
+        def info(message)
+          MessageHelpers.print_box(:info, message, message_output)
+        end
+
+        def warning(message)
+          MessageHelpers.print_box(:warn, message, message_output)
+        end
+
+        def error(message)
+          MessageHelpers.print_box(:error, message, message_output)
+        end
+
+        def success(message)
+          MessageHelpers.print_box(:success, message, message_output)
+        end
+
+        def kv(key, value)
+          MessageHelpers.kv(key, value)
+        end
+
+        private
+
+        def message_output
+          (defined?(@err) && @err) || MessageHelpers.stderr
+        end
+      end
+
+      self.stdout = $stdout
+      self.stderr = $stderr
+    end
+  end
+end

data/lib/dnsmadeeasy/cli/reported_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module DnsMadeEasy
+  module CLI
+    # Raised after an error has already been rendered to the user;
+    # the Launcher exits non-zero without printing it again.
+    class ReportedError < StandardError
+    end
+  end
+end

data/lib/dnsmadeeasy/credentials/api_keys.rb

@@ -13,7 +13,7 @@ module DnsMadeEasy
     # Immutable instance with key and secret.
     #
     class ApiKeys
-      API_KEY_REGEX = /^([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$/.freeze
+      API_KEY_REGEX = /^([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$/
 
       attr_reader :api_key,
                   :api_secret,
@@ -24,7 +24,7 @@ module DnsMadeEasy
       include Sym
 
       def initialize(key, secret, encryption_key = nil, default: false, account: nil)
-        raise InvalidCredentialKeys, "Key and Secret can not be nil" if key.nil? || secret.nil?
+        raise InvalidCredentialKeys, 'Key and Secret can not be nil' if key.nil? || secret.nil?
 
         @default = default
         @account = account
@@ -38,17 +38,19 @@ module DnsMadeEasy
           @api_secret = secret
         end
 
-        raise InvalidCredentialKeys, "Key [#{api_key}] or Secret [#{api_secret}] has failed validation for its format" unless valid?
+        return if valid?
+
+        raise InvalidCredentialKeys,
+              "Key [#{api_key}] or Secret [#{api_secret}] has failed validation for its format"
       end
 
       def sym_resolve(encryption_key)
         null_output = ::File.open('/dev/null', 'w')
-        result = Sym::Application.new({ cache_passwords: true, key: encryption_key }, $stdin, null_output, null_output).execute
-        if result.is_a?(Hash)
-          raise InvalidCredentialKeys, "Unable to decrypt the data, error is: #{result[:exception]}"
-        else
-          result
-        end
+        result = Sym::Application.new({ cache_passwords: true, key: encryption_key }, $stdin, null_output,
+                                      null_output).execute
+        raise InvalidCredentialKeys, "Unable to decrypt the data, error is: #{result[:exception]}" if result.is_a?(Hash)
+
+        result
       end
 
       def to_s

data/lib/dnsmadeeasy/credentials.rb

@@ -82,7 +82,6 @@ module DnsMadeEasy
       def keys_from_file(file: default_credentials_path,
                          account: nil,
                          encryption_key: nil)
-
         YamlFile.new(file: file).keys(account: account,
                                       encryption_key: encryption_key)
       end

data/lib/dnsmadeeasy/runner.rb

@@ -11,7 +11,7 @@ require 'etc'
 
 module DnsMadeEasy
   class Runner
-    SUPPORTED_FORMATS = %w(json json_pretty yaml pp).freeze
+    SUPPORTED_FORMATS = %w[json json_pretty yaml pp].freeze
     SUPPORTED_FORMAT_FLAGS = SUPPORTED_FORMATS.map { |f| "--#{f}" }.freeze
 
     attr_accessor :format, :argv, :operation
@@ -47,16 +47,16 @@ module DnsMadeEasy
       end
       0
     rescue ArgumentError => e
-      STDERR.puts(e.backtrace.join("\n").yellow)
+      warn(e.backtrace.join("\n").yellow)
       sig = method_signature(e, method)
       print_signature(method, sig) if sig.shift == method.to_s
       print_error('Action', method.to_s.bold.yellow.to_s, 'has generated an error'.red, exception: e)
       1
-    rescue NoMethodError => e
+    rescue NoMethodError
       print_error('Action', method.to_s.bold.yellow.to_s, 'is not valid.'.red)
       puts 'HINT: try running ' + 'dme operations'.bold.green + ' to see the list of valid operations.'
       2
-    rescue Net::HTTPServerException => e
+    rescue Net::HTTPClientException => e
       print_error(exception: e)
       3
     end
@@ -68,11 +68,11 @@ module DnsMadeEasy
         EOF
       end
 
-      if exception
-        puts <<~EOF
-          #{'Exception: '.bold.red}#{exception.inspect.red}
-        EOF
-      end
+      return unless exception
+
+      puts <<~EOF
+        #{'Exception: '.bold.red}#{exception.inspect.red}
+      EOF
     end
 
     def print_signature(method, sig)
@@ -108,7 +108,7 @@ module DnsMadeEasy
 
     def configure_authentication
       credentials_file = ENV['DNSMADEEASY_CREDENTIALS_FILE'] ||
-        DnsMadeEasy::Credentials.default_credentials_path(user: Etc.getlogin)
+                         DnsMadeEasy::Credentials.default_credentials_path(user: Etc.getlogin)
 
       if ENV['DNSMADEEASY_API_KEY'] && ENV['DNSMADEEASY_API_SECRET']
         DnsMadeEasy.api_key = ENV['DNSMADEEASY_API_KEY']
@@ -122,13 +122,13 @@ module DnsMadeEasy
         end
       end
 
-      if DnsMadeEasy.api_key.nil?
-        print_error('API Key/Secret was not detected or read from file')
-        puts('You can also set two environment variables: ')
-        puts('    • DNSMADEEASY_API_KEY and ')
-        puts('    • DNSMADEEASY_API_SECRET')
-        exit 123
-      end
+      return unless DnsMadeEasy.api_key.nil?
+
+      print_error('API Key/Secret was not detected or read from file')
+      puts('You can also set two environment variables: ')
+      puts('    • DNSMADEEASY_API_KEY and ')
+      puts('    • DNSMADEEASY_API_SECRET')
+      exit 123
     end
 
     def print_usage_message
@@ -147,7 +147,7 @@ module DnsMadeEasy
       puts <<~EOF
 
         #{header 'Credentials'}
-          Store your credentials in a YAML file #{DnsMadeEasy::Credentials.default_credentials_path(user: ENV['USER']).blue}
+          Store your credentials in a YAML file #{DnsMadeEasy::Credentials.default_credentials_path(user: ENV.fetch('USER', nil)).blue}
           as follows:
 
             #{'# ~/.dnsmadeeasy/credentials.yml'.bold.black}
@@ -216,7 +216,7 @@ module DnsMadeEasy
           require 'pp'
           pp result
         else
-          m = "to_#{format}".to_sym
+          m = :"to_#{format}"
           puts result.send(m) if result.respond_to?(m)
         end
       else
@@ -228,13 +228,13 @@ module DnsMadeEasy
     # ..../dnsmadeeasy/lib/dnsmadeeasy/api/client.rb:143:in `create_a_record'
     def method_signature(e, method)
       file, line, call_method = e.backtrace.first.split(':')
-      call_method = call_method.gsub(/[']/, '').split('`').last
+      call_method = call_method.gsub('\'', '').split('`').last
       if call_method && call_method.to_sym == method.to_sym
         source_line = File.open(file).to_a[line.to_i - 1].chomp!
         if source_line =~ /def #{method}/
-          signature = source_line.strip.gsub(/,/, '').split(/[ ()]/)
+          signature = source_line.strip.gsub(',', '').split(/[ ()]/)
           signature.shift # remove def
-          return signature.reject { |a| a =~ /^([={}\)\(])*$/ }
+          return signature.reject { |a| a =~ /^([={})(])*$/ }
         end
       end
       []
@@ -242,8 +242,8 @@ module DnsMadeEasy
       []
     end
 
-    def puts(*args)
-      super(*args)
+    def puts(*)
+      super
     end
   end
 end

data/lib/dnsmadeeasy/types.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'dry/types'
+
+module DnsMadeEasy
+  # Shared dry-rb types used by value objects.
+  module Types
+    include Dry.Types()
+
+    DNS_RECORD_TYPES = %w[A AAAA CNAME ANAME MX NS PTR SPF SRV TXT].freeze
+
+    StrictString = Strict::String
+    NonEmptyString = StrictString.constrained(min_size: 1)
+    RecordType = StrictString.enum(*DNS_RECORD_TYPES)
+    Ttl = Coercible::Integer.constrained(gteq: 0)
+    OptionalInteger = Coercible::Integer.optional
+    OptionalString = StrictString.optional
+  end
+end

data/lib/dnsmadeeasy/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 module DnsMadeEasy
-  VERSION = '0.4.0'
+  # Version 1.0+ is supporting zone file manipulation
+  VERSION = '1.0.5'
 end

data/lib/dnsmadeeasy/zone/aname_flattener.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'dry/monads'
+require 'resolv'
+require 'dnsmadeeasy/zone/record'
+
+module DnsMadeEasy
+  module Zone
+    # Flattens ANAME records into resolved A records for RFC-portable
+    # exports. Resolution is a point-in-time snapshot, so every conversion
+    # is reported as a notice.
+    class AnameFlattener
+      include Dry::Monads[:result]
+
+      def initialize(records, resolver: nil)
+        @records = records
+        @resolver = resolver || default_resolver
+      end
+
+      def call
+        flattened = []
+        notices = []
+
+        records.each do |record|
+          if record.type == 'ANAME'
+            addresses = resolve(record)
+            return Failure(["Unable to resolve ANAME target #{record.value} for --strict-rfc export"]) if addresses.empty?
+
+            addresses.each { |address| flattened << record.new(type: 'A', value: address) }
+            notices << flatten_notice(record, addresses)
+          else
+            flattened << record
+          end
+        end
+
+        Success([flattened, notices])
+      end
+
+      private
+
+      attr_reader :records,
+                  :resolver
+
+      def resolve(record)
+        resolver.call(record.value)
+      rescue Resolv::ResolvError
+        []
+      end
+
+      def flatten_notice(record, addresses)
+        "Flattened ANAME #{record.owner} -> #{record.value} into A #{addresses.join(', ')} (point-in-time snapshot)"
+      end
+
+      def default_resolver
+        lambda do |target|
+          Resolv::DNS.open do |dns|
+            dns.getresources(target, Resolv::DNS::Resource::IN::A).map { |resource| resource.address.to_s }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dnsmadeeasy/zone/apply_executor.rb

@@ -0,0 +1,219 @@
+# 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
+
+      # 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, sleeper: nil)
+        @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
+        @sleeper = sleeper || ->(seconds) { sleep(seconds) }
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      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,
+                  :sleeper
+
+      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_with_retries(indexed_action.fetch(:action))
+        outcome_mutex.synchronize { applied_actions << indexed_action }
+        false
+      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
+        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