firespring_dev_commands 2.2.2 → 2.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b60fb9f23da32fe3006bd63627788753dc822b14d16782e253ecdfe3e516ae12
-  data.tar.gz: 94e3b4fc79749292e56e9db5de9f170def61c64e154daa11ef66e8bdbc4049cf
+  metadata.gz: 599f3f484514462356186c8d52adfac32e8aa925f7aeaa488bb5fa109db678f3
+  data.tar.gz: 3dffab80edf84b75d073adfc21c1a2c3e0d9dcc666a526f2bda2d5471ff24d6e
 SHA512:
-  metadata.gz: 5a53e1b2ffd61b54eabf8ad81559054dec6fd40f9023ebf22ec27aea56cc9c3cd884cc329d0055b133da54792e77bce23ea44119fceb67e87493e8e80d5e25af
-  data.tar.gz: 10237fa32a8c41d9a9b9c7196d7ded272d5ec4c36ad2cb2d789956acb33ed66a70388d4368b4ac2ed2fc5024aca91381d682cb1ef9f73b226ee5a1c88a44e0bd
+  metadata.gz: 0ea2c7d6d09e1e5ad6a85ee3d7d3e90826018bee1afc7c1ce1a206ca8514b658c8ef29534dc5b4082bf185d1540a9292218eb3836f6c3405b44d3ff10d98b484
+  data.tar.gz: c06fa865de8acedba8ec7b2934094f7a03fb46e2e1d5a116fc2b12fa4febcf6874940771a843bb022f5f571d5b77e9d4f00d5b3f4930f4cd2f16aa44293a66dd

data/lib/firespring_dev_commands/aws/route53.rb

@@ -1,44 +1,59 @@
+require 'aws-sdk-route53'
+
 module Dev
   class Aws
     # Class for performing Route53 functions
     class Route53
       attr_reader :client
 
-      def initialize(domains)
+      def initialize(domains = nil)
         @client = ::Aws::Route53::Client.new
-        @domains = domains
+        @domains = Array(domains || [])
       end
 
-      private def zones
+      def zones(&)
         if @domains.empty?
-          all_zones
+          each_zone(&)
         else
-          zones_by_domain_names(@domains)
+          each_zone_by_domains(&)
         end
       end
 
-      private def all_zones
-        [].tap do |ary|
-          Dev::Aws.each_page(client, :list_hosted_zones) do |response|
-            response.hosted_zones&.each do |hosted_zone|
-              ary << hosted_zone unless hosted_zone.config.private_zone
-            end
+      private def each_zone
+        Dev::Aws.each_page(client, :list_hosted_zones) do |response|
+          response.hosted_zones&.each do |hosted_zone|
+            next if hosted_zone.config.private_zone
+
+            yield hosted_zone
           end
+        rescue ::Aws::Route53::Errors::Throttling
+          sleep(1)
+          retry
         end
       end
 
-      private def zones_by_domain_names(domains)
-        [].tap do |ary|
-          domains.each do |domain_name|
-            response = client.list_hosted_zones_by_name({dns_name: domain_name})
-            target = response.hosted_zones.find { |it| it.name.chomp('.') == domain_name }
-            raise "The #{domain_name} hosted zone not found." unless target
+      private def each_zone_by_domains(&)
+        @domains.each do |domain|
+          response = client.list_hosted_zones_by_name({dns_name: domain})
 
-            ary << target
-          end
+          # The 'list_hosted_zones_by_name' returns fuzzy matches (so "foo.com" would return both "bar.foo.com" and "foo.com"
+          # So we are only selecting domains that match exactly since that's what we really want here
+          targets = response.hosted_zones.select { |it| it.name.chomp('.') == domain }
+          raise "The #{domain} hosted zone not found." if targets.empty?
+
+          targets.each(&)
+        rescue ::Aws::Route53::Errors::Throttling
+          sleep(1)
+          retry
         end
       end
 
+      private def ip_address(domain)
+        Addrinfo.ip(domain.to_s.strip)&.ip_address
+      rescue SocketError
+        "Unable to resolve domain: #{domain}"
+      end
+
       private def target_config_id(zone_id)
         client.list_query_logging_configs(
           hosted_zone_id: zone_id,
@@ -46,61 +61,78 @@ module Dev
         ).query_logging_configs&.first&.id
       end
 
-      private def pretty_puts(output)
-        # Find the maximum length of the keys
-        max_key_length = output.keys.map(&:to_s).max_by(&:length).length
+      # Get the hosted zone details for the zone id
+      private def details(zone_id)
+        response = client.get_hosted_zone(id: zone_id)
+        [response.hosted_zone, response.delegation_set]
+      end
+
+      def list_zone_details
+        zones do |zone|
+          puts
+          zone_details, delegation_set = details(zone.id)
+          dns_resource = Dev::Dns::Resource.new(zone_details.name)
 
-        output.each do |key, value|
-          puts "#{key.to_s.ljust(max_key_length)}\t=>\t#{value}"
+          puts "#{zone_details.name.chomp('.').light_white} (#{zone_details.id}):"
+          puts format('  %-50s %s', 'Delegation Set:', delegation_set.id)
+          puts format('  %-50s %s', 'Delegation Defined Nameservers:', delegation_set.name_servers.sort.join(', '))
+          puts format('  %-50s %s', 'DNS Reported Nameservers:', dns_resource.recursive_nameserver_lookup.sort.join(', '))
+          puts format('  %-50s %s', 'DNS Reported Nameserver IPs:', dns_resource.recursive_nameserver_lookup.sort.map { |it| dns_resource.recursive_a_lookup(it) }.join(', '))
+          puts format('  %-50s %s', 'Domain Apex IP Resolution:', dns_resource.recursive_a_lookup.sort.join(', '))
+        rescue ::Aws::Route53::Errors::Throttling
+          sleep(1)
+          retry
         end
+        puts
       end
 
       def list_query_configs
-        output = {}
-        zones.each do |zone|
+        zones do |zone|
           target_config_id = target_config_id(zone.id)
-
-          output[zone.name] = if target_config_id
-                                "Config\t=>\t#{target_config_id}".colorize(:green)
-                              else
-                                'No query logging config assigned.'.colorize(:red)
-                              end
+          message = if target_config_id
+                      "Config\t=>\t#{target_config_id}".colorize(:green)
+                    else
+                      'No query logging config assigned.'.colorize(:red)
+                    end
+          puts format('%-50s => %s', zone.name, message)
+        rescue ::Aws::Route53::Errors::Throttling
+          sleep(1)
+          retry
         end
-
-        pretty_puts(output)
       end
 
       def activate_query_logging(log_group)
-        output = {}
-
-        zones.each do |zone|
+        zones do |zone|
           response = client.create_query_logging_config(
             hosted_zone_id: zone.id,
             cloud_watch_logs_log_group_arn: log_group
           )
-          output[zone.id] = response.location
+          puts format('%-50s => %s', zone.id, response.location)
+        rescue ::Aws::Route53::Errors::Throttling
+          sleep(1)
+          retry
         rescue ::Aws::Route53::Errors::ServiceError => e
           raise "Error: #{e.message}" unless e.instance_of?(::Aws::Route53::Errors::QueryLoggingConfigAlreadyExists)
 
-          output[zone.id] = e.message
+          puts format('%-50s => %s', zone.id, e.message)
         end
-        pretty_puts(output)
       end
 
       def deactivate_query_logging
-        output = {}
-        zones.each do |zone|
+        zones do |zone|
           target_config_id = target_config_id(zone.id)
           if target_config_id
             client.delete_query_logging_config(
               id: target_config_id
             )
-            output[zone.id] = 'Query logging config removed.'.colorize(:green)
+            puts format('%-50s => %s', zone.id, 'Query logging config removed.'.colorize(:green))
           else
-            output[zone.id] = 'No query logging config assigned.'.colorize(:red)
+            puts format('%-50s => %s', zone.id, 'No query logging config assigned.'.colorize(:red))
           end
+        rescue ::Aws::Route53::Errors::Throttling
+          sleep(1)
+          retry
         end
-        pretty_puts(output)
       end
     end
   end

data/lib/firespring_dev_commands/dns/resource.rb

@@ -0,0 +1,83 @@
+module Dev
+  class Dns
+    class Resource
+      attr_reader :domain
+
+      def initialize(domain)
+        @domain = domain
+      end
+
+      # Returns whether or not the given value is a valid IPv4 or IPv6 address
+      def self.ip?(value)
+        ipv4?(value) || ipv6?(value)
+      end
+
+      # Returns whether or not the given value is a valid IPv4 address
+      def self.ipv4?(value)
+        value.match?(Resolv::IPv4::Regex)
+      end
+
+      # Returns whether or not the given value is a valid IPv6 address
+      def self.ipv6?(value)
+        value.match?(Resolv::IPv6::Regex)
+      end
+
+      # Recursively determine the correct nameservers for the given domain.
+      # If nameservers are not found, strip subdomains off until we've reached the TLD
+      def recursive_nameserver_lookup(name = domain)
+        records = lookup(name, type: Resolv::DNS::Resource::IN::NS)
+
+        # Strip the subdomain and try again if we didn't find any nameservers (this can happen with wildcards)
+        return recursive_nameserver_lookup(name.split('.', 2).last) if records.empty?
+
+        # Look up the IPs for the nameservers
+        records
+      end
+
+      # Recursively attempt to find an A record for the given domain.
+      # If one isn't found, also check for CNAMEs continually until we have either found an IP or run out of things to check
+      def recursive_a_lookup(name = domain)
+        # Try looking up an A record first. If we find one, we are done.
+        records = lookup(name, type: Resolv::DNS::Resource::IN::A)
+        return records unless records.empty?
+
+        # Try looking up a CNAME record
+        records = lookup(name, type: Resolv::DNS::Resource::IN::CNAME)
+
+        # If we didn't find an A record _or_ a CNAME, just return empty
+        return records if records.empty?
+
+        # If we found more than one CNAME that is a DNS error
+        raise "Found more than one CNAME entry for #{name}. This is not allowed by DNS" if records.length > 1
+
+        recursive_a_lookup(records.first)
+      end
+
+      # Lookup the given name using the record type provided.
+      def lookup(name = domain, type: Resolv::DNS::Resource::IN::A)
+        # Validate the type
+        raise 'lookup type must be a Resolv::DNS::Resource' unless type.ancestors.include?(Resolv::DNS::Resource)
+
+        # If we were given a tld, return empty
+        return [] unless name.include?('.')
+
+        # Look up NS records for the given host
+        records = Resolv::DNS.new.getresources(name, type)
+
+        # Return the record names
+        records.map do |record|
+          if record.respond_to?(:address)
+            record.address.to_s
+          elsif record.respond_to?(:name)
+            record.name.to_s
+          else
+            ''
+          end
+        end
+      rescue
+        sleep(1)
+        retry
+      end
+    end
+  end
+end

data/lib/firespring_dev_commands/templates/aws/services/route53.rb

@@ -6,16 +6,21 @@ module Dev
       module Services
         # Class contains rake templates for managing your AWS settings and logging in
         class Route53 < Dev::Template::BaseInterface
-          # Create the rake task which ensures active credentials are present
-          def create_ensure_credentials_task!
+          def create_list_zone_details_task!
             # Have to set a local variable to be accessible inside of the instance_eval block
             exclude = @exclude
 
             DEV_COMMANDS_TOP_LEVEL.instance_eval do
-              return if exclude.include?(:ensure_aws_credentials)
+              return if exclude.include?(:list_details)
 
-              task ensure_aws_credentials: %w(init) do
-                raise 'AWS Credentials not found / expired' unless Dev::Aws::Credentials.new.active?
+              namespace :aws do
+                namespace :hosted_zone do
+                  desc 'print details for all hosted zones'
+                  task list_details: %w(ensure_aws_credentials) do
+                    route53 = Dev::Aws::Route53.new(ENV['DOMAINS'].to_s.strip.split(','))
+                    route53.list_zone_details
+                  end
+                end
               end
             end
           end
@@ -26,9 +31,9 @@ module Dev
             exclude = @exclude
 
             DEV_COMMANDS_TOP_LEVEL.instance_eval do
-              namespace :aws do
-                return if exclude.include?(:dns_logging)
+              return if exclude.include?(:dns_logging_activate)
 
+              namespace :aws do
                 namespace :hosted_zone do
                   namespace :dns_logging do
                     desc 'Activates query logging for all hosted zones by default.' \
@@ -56,9 +61,9 @@ module Dev
             exclude = @exclude
 
             DEV_COMMANDS_TOP_LEVEL.instance_eval do
-              namespace :aws do
-                return if exclude.include?(:dns_logging)
+              return if exclude.include?(:dns_logging_deactivate)
 
+              namespace :aws do
                 namespace :hosted_zone do
                   namespace :dns_logging do
                     desc 'Deactivates query logging for all hosted zones by default. ' \
@@ -81,9 +86,9 @@ module Dev
             exclude = @exclude
 
             DEV_COMMANDS_TOP_LEVEL.instance_eval do
-              namespace :aws do
-                return if exclude.include?(:dns_logging)
+              return if exclude.include?(:dns_logging_config)
 
+              namespace :aws do
                 namespace :hosted_zone do
                   namespace :dns_logging do
                     desc 'Lists the current config for domain(s). ' \

data/lib/firespring_dev_commands/version.rb

@@ -6,6 +6,6 @@ module Dev
     # Use 'v.v.v.pre.alpha.v' for pre-release vesions
     # Use 'v.v.v.beta.v for beta versions
     # Use semantic versioning for any releases (https://semver.org/)
-    VERSION = '2.2.2'.freeze
+    VERSION = '2.2.3'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: firespring_dev_commands
 version: !ruby/object:Gem::Version
-  version: 2.2.2
+  version: 2.2.3
 platform: ruby
 authors:
 - Firespring
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-28 00:00:00.000000000 Z
+date: 2024-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -353,6 +353,7 @@ files:
 - lib/firespring_dev_commands/coverage/cobertura.rb
 - lib/firespring_dev_commands/coverage/none.rb
 - lib/firespring_dev_commands/daterange.rb
+- lib/firespring_dev_commands/dns/resource.rb
 - lib/firespring_dev_commands/docker.rb
 - lib/firespring_dev_commands/docker/compose.rb
 - lib/firespring_dev_commands/docker/desktop.rb