dnsmadeeasy 0.3.5 → 1.0.1

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/yaml_file.rb

@@ -21,28 +21,7 @@ module DnsMadeEasy
         return nil if mash.nil?
 
         creds = if mash.accounts.is_a?(Array)
-                  account = if account
-                              mash.accounts.find { |a| a.name == account.to_s }
-                            elsif
-                              # rubocop:todo Layout/ConditionPosition
-                              mash.accounts.size == 1
-                              # rubocop:enable Layout/ConditionPosition
-                              mash.accounts.first
-                            else
-                              mash.accounts.find(&:default_account)
-                            end
-
-                  unless account
-                    raise DnsMadeEasy::APIKeyAndSecretMissingError,
-                          (account ? "account #{account} was not found" : 'default account does not exist')
-                  end
-
-                  unless account.credentials
-                    raise DnsMadeEasy::InvalidCredentialsFormatError,
-                          'Expected account entry to have "credentials" key'
-                  end
-
-                  account.credentials
+                  credentials_from_array(mash.accounts, account&.to_s)
 
                 elsif mash.credentials
                   mash.credentials
@@ -52,11 +31,11 @@ module DnsMadeEasy
                         'expected either "accounts" or "credentials" as the top-level key'
                 end
 
-        # rubocop:todo Style/MultilineTernaryOperator
-        creds ? ApiKeys.new(creds.api_key,
-                            creds.api_secret,
-                            encryption_key || creds.encryption_key) : nil
-        # rubocop:enable Style/MultilineTernaryOperator
+        return nil unless creds
+
+        ApiKeys.new creds.api_key,
+                    creds.api_secret,
+                    encryption_key || creds.encryption_key
       end
 
       def to_s
@@ -65,6 +44,28 @@ module DnsMadeEasy
 
       private
 
+      def credentials_from_array(accounts, account_name = nil)
+        account = if account_name
+                    accounts.find { |a| a.name == account_name }
+                  elsif accounts.size == 1
+                    accounts.first
+                  else
+                    accounts.find(&:default_account)
+                  end
+
+        unless account
+          raise DnsMadeEasy::APIKeyAndSecretMissingError,
+                (account ? "account #{account} was not found" : 'Default account does not exist')
+        end
+
+        unless account.credentials
+          raise DnsMadeEasy::InvalidCredentialsFormatError,
+                'Expected an account entry to have the "credentials" key'
+        end
+
+        account.credentials
+      end
+
       def parse!
         self.mash = Hashie::Extensions::SymbolizeKeys.symbolize_keys(load_hash)
       end

data/lib/dnsmadeeasy/credentials.rb

@@ -82,16 +82,15 @@ 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
 
       # @return String path to the default credentials file.
       def default_credentials_path(user: nil)
-        user ? # rubocop:todo Style/MultilineTernaryOperator
-          File.expand_path(Dir.home(user) + '/.dnsmadeeasy/credentials.yml').freeze :
-          File.expand_path('~/.dnsmadeeasy/credentials.yml').freeze
+        File.expand_path(
+          user ? Dir.home(user) + '/.dnsmadeeasy/credentials.yml' : '~/.dnsmadeeasy/credentials.yml'
+        )
       end
     end
   end

data/lib/dnsmadeeasy/runner.rb

@@ -1,6 +1,8 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+# vim: ft=ruby
+
 require 'colored2'
 require 'awesome_print'
 require 'dnsmadeeasy'
@@ -9,12 +11,13 @@ 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
 
     def initialize(argv = nil)
-      self.argv   = argv || ARGV.dup
+      self.argv = argv || ARGV.dup
       self.format = process_flags_format
     end
 
@@ -44,76 +47,73 @@ module DnsMadeEasy
       end
       0
     rescue ArgumentError => e
+      warn(e.backtrace.join("\n").yellow)
       sig = method_signature(e, method)
-      # rubocop:todo Style/MultilineTernaryOperator
-      sig.shift == method.to_s ?
-        print_signature(method, sig) :
-        print_error('Action', method.to_s.bold.yellow.to_s, 'has generated an error'.red, exception: e)
-      # rubocop:enable Style/MultilineTernaryOperator
+      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
 
     def print_error(*args, exception: nil)
       unless args.empty?
-        # rubocop:todo Naming/HeredocDelimiterNaming
         puts <<~EOF
-          # rubocop:enable Naming/HeredocDelimiterNaming
-            #{'Error:'.bold.red} #{args.join(' ').red}
+          #{'Error:'.bold.red} #{args.join(' ').red}
         EOF
       end
 
-      if exception
-        # rubocop:todo Naming/HeredocDelimiterNaming
-        puts <<~EOF
-          # rubocop:enable Naming/HeredocDelimiterNaming
-            #{'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)
-      # rubocop:todo Naming/HeredocDelimiterNaming
-      puts <<~EOF # rubocop:todo Naming/HeredocDelimiterNaming
-        # rubocop:enable Naming/HeredocDelimiterNaming
-          #{'Error: '.bold.yellow}
-                #{'You are missing some arguments for this operation:'.red}
+      puts <<~EOF
+        #{'Error: '.bold.yellow}
+        #{'You are missing some arguments for this operation:'.red}
 
-                #{'Correct Usage: '.bold.yellow}
-                #{method.to_s.bold.green} #{sig.join(' ').blue}
+        #{'Correct Usage: '.bold.yellow}
+        #{method.to_s.bold.green} #{sig.join(' ').blue}
 
       EOF
     end
 
     def process_flags_format
-      if argv.first&.start_with?('--')
-        format = argv.shift.gsub(/^--/, '')
-        if format =~ /^h(elp)?$/i
-          print_help_message
-        end
+      if argv.first =~ /^op(erations)?$/i
+        print_supported_operations
+
+      elsif argv.include?('--help') || argv.include?('-h')
+        print_help_message
+
+      elsif !(argv & SUPPORTED_FORMAT_FLAGS).empty?
+        format_flag = (argv & SUPPORTED_FORMAT_FLAGS).first
+        format = format_flag.delete '--'
+        argv.delete(format_flag)
         unless SUPPORTED_FORMATS.include?(format)
-          puts "Error: format #{format.bold.red} is not supported."
-          puts "Supported values are: #{SUPPORTED_FORMATS.join(', ')}"
+          warn "Error: format #{format.bold.red} is not supported."
+          warn "Supported values are: #{SUPPORTED_FORMATS.join(', ')}"
           exit 1
         end
-      elsif argv.first =~ /^op(erations)?$/i
-        print_supported_operations
-        exit 0
+        format
       end
-      format
     end
 
     def configure_authentication
-      credentials_file = ENV['DNSMADEEASY_CREDENTIALS_FILE'] || DnsMadeEasy::Credentials.default_credentials_path(user: Etc.getlogin)
+      credentials_file = ENV['DNSMADEEASY_CREDENTIALS_FILE'] ||
+                         DnsMadeEasy::Credentials.default_credentials_path(user: Etc.getlogin)
+
       if ENV['DNSMADEEASY_API_KEY'] && ENV['DNSMADEEASY_API_SECRET']
         DnsMadeEasy.api_key = ENV['DNSMADEEASY_API_KEY']
         DnsMadeEasy.api_secret = ENV['DNSMADEEASY_API_SECRET']
+
       elsif credentials_file && ::File.exist?(credentials_file)
         keys = DnsMadeEasy::Credentials.keys_from_file(file: credentials_file)
         if keys
@@ -122,64 +122,73 @@ 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 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
-      # rubocop:todo Naming/HeredocDelimiterNaming
       puts <<~EOF
-        # rubocop:enable Naming/HeredocDelimiterNaming
-          #{'Usage:'.bold.yellow}
-                #{'# Execute an API call:'.dark}
-                #{"dme [ #{SUPPORTED_FORMATS.map { |f| "--#{f}" }.join(' | ')} ] operation [ arg1 arg2 ... ] ".bold.green}
-
-                #{'# Print suported operations:'.dark}
-                #{'dme op[erations]'.bold.green}
+        #{'Usage:'.bold.yellow}
+          #{'# Execute an API call:'.dark}
+          #{"dme [ #{SUPPORTED_FORMATS.map { |f| "--#{f}" }.join(' | ')} ] operation [ arg1 arg2 ... ] ".bold.green}
 
+          #{'# Print suported operations:'.dark}
+          #{'dme op[erations]'.bold.green}
       EOF
     end
 
     def print_help_message
       print_usage_message
-
-      # rubocop:todo Naming/HeredocDelimiterNaming
       puts <<~EOF
-        # rubocop:enable Naming/HeredocDelimiterNaming
-          #{header 'Credentials'}
-            Store your credentials in a YAML file
-            #{DnsMadeEasy::Credentials.default_credentials_path(user: ENV['USER'])} as follows:
 
+        #{header 'Credentials'}
+          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}
             #{'credentials:
-              api_key: XXXX
-              api_secret: YYYY'.bold.magenta}
-
-            Or a multi-account version:
-
-            #{'accounts:
-              - name: production
-                credentials:
-                  api_key: XXXX
-                  api_secret: YYYY
-                  encryption_key: my_key
-              - name: development
-                default_account: true
-                credentials:
-                  api_key: ZZZZ
-                  api_secret: WWWW'.bold.magenta}
-
-          #{header 'Examples:'}
-             #{'dme domain moo.com
-             dme --json domain moo.com
-             dme find_all moo.com A www
-             dme find_first moo.com CNAME vpn-west
-             dme --yaml find_first moo.com CNAME vpn-west'.green}
+        api_key: XXXX
+        api_secret: YYYY'.cyan}
+
+          Or, you can use a multi-account version, but in that case it helps if you
+          specify which of the accounts is the default:
 
       EOF
+
+      puts <<-YAML
+    #{'# ~/.dnsmadeeasy/credentials.yml'.bold.black}
+    #{'accounts:
+    - name: production
+      credentials:
+        api_key: XXXX
+        api_secret: YYYY
+        encryption_key: my_key
+    - name: development
+      default_account: true
+      credentials:
+        api_key: ZZZZ
+        api_secret: WWWW'.cyan}
+      YAML
+
+      puts header 'Examples:'
+
+      puts '
+  $ dme domain moo.com
+  $ dme domain moo.com --yaml > moo.yml
+
+  $ dme all            moo.com
+  $ dme find_all       moo.com A          www
+  $ dme find_first     moo.com CNAME      vpn-west
+
+  $ dme update_record  moo.com www    A   11.3.43.56
+  $ dme create_record  moo.com ftp CNAME  www.moo.com.
+
+  $ dme --yaml find_first moo.com CNAME vpn-west'.green
       exit 1
     end
 
@@ -188,17 +197,14 @@ module DnsMadeEasy
     end
 
     def print_supported_operations
-      # rubocop:todo Naming/HeredocDelimiterNaming
       puts <<~EOF
-        # rubocop:enable Naming/HeredocDelimiterNaming
-          #{header 'Actions:'}
-            Checkout the README and RubyDoc for the arguments to each operation,
-            which is basically a method on a DnsMadeEasy::Api::Client instance.
-            #{'http://www.rubydoc.info/gems/dnsmadeeasy/DnsMadeEasy/Api/Client'.blue.bold.underlined}
-
-          #{header 'Valid Operations Are:'}
-            #{DnsMadeEasy::Api::Client.public_operations.join("\n  ").green.bold}
+        #{header 'Actions:'}
+          Checkout the README and RubyDoc for the arguments to each operation,
+          which is basically a method on a DnsMadeEasy::Api::Client instance.
+          #{'http://www.rubydoc.info/gems/dnsmadeeasy/DnsMadeEasy/Api/Client'.blue.bold.underlined}
 
+        #{header 'Valid Operations Are:'}
+          #{DnsMadeEasy::Api::Client.public_operations.join("\n  ").green.bold}
       EOF
     end
 
@@ -210,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
@@ -220,26 +226,24 @@ module DnsMadeEasy
 
     # e.backtrack.first looks like this:
     # ..../dnsmadeeasy/lib/dnsmadeeasy/api/client.rb:143:in `create_a_record'
-    # rubocop:todo Naming/MethodParameterName
     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
       []
     rescue StandardError
       []
     end
-    # rubocop:enable Naming/MethodParameterName
 
-    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.3.5'
+  # Version 1.0+ is supporting zone file manipulation
+  VERSION = '1.0.1'
 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