aws_public_ips 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: c360fd8fc1dec710ad8ee00b18babdd8bb4781494dad119291a6fa03fcb65b1f
-  data.tar.gz: bbf9fa5b7a48c45d5b9056117d5c56e9d1aac2a97acf27eebeda0198cc76cd72
+SHA1:
+  metadata.gz: 4a083bab67810085c9610fee6ca593420f077afd
+  data.tar.gz: eec41af99070ed34d83759f3f042bb3461618e3d
 SHA512:
-  metadata.gz: 7717d68059ba9b004df5f16755bfd8ce69af4fc73ade7e7cd559311d2c11d5ed2f6f704483eb667654d35e8fef4fa076ce1840f82e387dce028cb7b7dc7251a1
-  data.tar.gz: c0b4e447f652d427077a0c9dbadc8c7b81ee620286d33508e04ef970978f8570110be11e69506f9eefac9021687e10f9ac3d424485ddbb7edff25a41e09b49d1
+  metadata.gz: 78688710a288065d81d6ce4ab60170cbbd3e1f83bed09d3c07efb89a4ad11e92155451ff03836b747554e485081db14b0f262c25636b38ae1c001c7556da80fc
+  data.tar.gz: 96ab667b2321e1c5f8b656551db71d92c1690715cba785900895493b8f402b48a3e8ea7ae56d9d8b575a2f5ccaa3412ac58f52f895bf2d5e005b616e09307560

data/bin/aws_public_ips

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-$LOAD_PATH.unshift(File.expand_path(File.join('..', '..', 'lib'), __FILE__))
+$LOAD_PATH.unshift(::File.expand_path(::File.join('..', '..', 'lib'), __FILE__))
 require 'aws_public_ips/cli'
 
-AwsPublicIps::CLI.new.run(ARGV)
+::AwsPublicIps::CLI.new.run(::ARGV)

data/lib/aws_public_ips/checks/apigateway.rb

@@ -7,7 +7,7 @@ module AwsPublicIps
   module Checks
     module Apigateway
       def self.run
-        client = Aws::APIGateway::Client.new
+        client = ::Aws::APIGateway::Client.new
 
         # TODO(arkadiy) https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-private-integration.html
 
@@ -19,7 +19,7 @@ module AwsPublicIps
             {
               id: api.id,
               hostname: hostname,
-              ip_addresses: Utils.resolve_hostname(hostname)
+              ip_addresses: ::AwsPublicIps::Utils.resolve_hostname(hostname)
             }
           end
         end

data/lib/aws_public_ips/checks/cloudfront.rb

@@ -7,14 +7,17 @@ module AwsPublicIps
   module Checks
     module Cloudfront
       def self.run
-        client = Aws::CloudFront::Client.new
+        client = ::Aws::CloudFront::Client.new
+
+        # Cloudfront distrubtions are always public, they don't have a concept of VPC
+        # No "coming up" problem here like with RDS/Redshift
 
         client.list_distributions.flat_map do |response|
           response.distribution_list.items.flat_map do |distribution|
             {
               id: distribution.id,
               hostname: distribution.domain_name,
-              ip_addresses: Utils.resolve_hostname(distribution.domain_name)
+              ip_addresses: ::AwsPublicIps::Utils.resolve_hostname(distribution.domain_name)
             }
           end
         end

data/lib/aws_public_ips/checks/ec2.rb

@@ -6,16 +6,15 @@ module AwsPublicIps
   module Checks
     module Ec2
       def self.run
-        client = Aws::EC2::Client.new
+        client = ::Aws::EC2::Client.new
 
-        # TODO(arkadiy) confirm this covers Batch, Fargate
         # Iterate over all EC2 instances. This will include those from EC2, ECS, EKS, Fargate, Batch,
         # Beanstalk, and NAT Instances
         # It will not include NAT Gateways (IPv4) or Egress Only Internet Gateways (IPv6), but they do not allow
         # ingress traffic so we skip them anyway
         client.describe_instances.flat_map do |response|
           response.reservations.flat_map do |reservation|
-            reservation.instances.map do |instance|
+            reservation.instances.flat_map do |instance|
               # EC2-Classic instances have a `public_ip_address` and no `network_interfaces`
               # EC2-VPC instances both set, so we uniq the ip addresses
               ip_addresses = [instance.public_ip_address].compact + instance.network_interfaces.flat_map do |interface|
@@ -23,6 +22,9 @@ module AwsPublicIps
                 public_ip + interface.ipv_6_addresses.map(&:ipv_6_address)
               end
 
+              # Don't return an entry if all ips were private
+              next [] if ip_addresses.empty?
+
               # If hostname is empty string, canonicalize to nil
               hostname = instance.public_dns_name.empty? ? nil : instance.public_dns_name
               {

data/lib/aws_public_ips/checks/elasticsearch.rb

@@ -7,10 +7,10 @@ module AwsPublicIps
   module Checks
     module Elasticsearch
       def self.run
-        client = Aws::ElasticsearchService::Client.new
+        client = ::Aws::ElasticsearchService::Client.new
 
-        # ElasticSearch instances can be launched publicly or into VPCs. Public instances have a
-        # `domain_status.endpoint` hostname and VPC instances have a `domain_status.endpoints['vpc']` hostname.
+        # ElasticSearch instances can be launched into classic into VPCs. Classic instances are public and have a
+        # `domain_status.endpoint` hostname, and VPC instances have a `domain_status.endpoints['vpc']` hostname.
         # However VPC ElasticSearch instances create their own Network Interface and AWS will not allow you
         # to associate an Elastic IP to it. As a result VPC ElasticSearch instances are always private, even with an
         # internet gateway.
@@ -23,7 +23,7 @@ module AwsPublicIps
               {
                 id: domain.domain_status.domain_id,
                 hostname: hostname,
-                ip_addresses: Utils.resolve_hostname(hostname)
+                ip_addresses: ::AwsPublicIps::Utils.resolve_hostname(hostname)
               }
             end.compact
           end

data/lib/aws_public_ips/checks/elb.rb

@@ -7,18 +7,19 @@ module AwsPublicIps
   module Checks
     module Elb
       def self.run
-        client = Aws::ElasticLoadBalancing::Client.new
+        client = ::Aws::ElasticLoadBalancing::Client.new
 
         # EC2-Classic load balancers are only returned by the 'elasticloadbalancing' API, and
         # EC2-VPC ALBs/NLBs are only returned by the 'elasticloadbalancingv2' API
         client.describe_load_balancers.flat_map do |response|
           response.load_balancer_descriptions.flat_map do |load_balancer|
             next [] unless load_balancer.scheme == 'internet-facing'
+            # EC2-Classic load balancers get IPv6 DNS records created but they are not returned by the API
+            hostnames = [load_balancer.dns_name, "ipv6.#{load_balancer.dns_name}"]
             {
               id: load_balancer.canonical_hosted_zone_name_id,
               hostname: load_balancer.dns_name,
-              # EC2-Classic load balancers get IPv6 DNS records created but they are not returned by the API
-              ip_addresses: Utils.resolve_hostnames([load_balancer.dns_name, "ipv6.#{load_balancer.dns_name}"])
+              ip_addresses: ::AwsPublicIps::Utils.resolve_hostnames(hostnames)
             }
           end
         end

data/lib/aws_public_ips/checks/elbv2.rb

@@ -7,7 +7,7 @@ module AwsPublicIps
   module Checks
     module Elbv2
       def self.run
-        client = Aws::ElasticLoadBalancingV2::Client.new
+        client = ::Aws::ElasticLoadBalancingV2::Client.new
 
         # EC2-Classic load balancers are only returned by the 'elasticloadbalancing' API, and
         # EC2-VPC ALBs/NLBs are only returned by the 'elasticloadbalancingv2' API
@@ -21,7 +21,7 @@ module AwsPublicIps
             {
               id: load_balancer.canonical_hosted_zone_id,
               hostname: load_balancer.dns_name,
-              ip_addresses: Utils.resolve_hostname(load_balancer.dns_name)
+              ip_addresses: ::AwsPublicIps::Utils.resolve_hostname(load_balancer.dns_name)
             }
           end
         end

data/lib/aws_public_ips/checks/lightsail.rb

@@ -7,7 +7,7 @@ module AwsPublicIps
   module Checks
     module Lightsail
       def self.run
-        client = Aws::Lightsail::Client.new
+        client = ::Aws::Lightsail::Client.new
 
         # Lightsail instances are always exposed directly, and can also be put behind a load balancer
 
@@ -28,7 +28,7 @@ module AwsPublicIps
               # Names are unique
               id: load_balancer.name,
               hostname: load_balancer.dns_name,
-              ip_addresses: Utils.resolve_hostname(load_balancer.dns_name)
+              ip_addresses: ::AwsPublicIps::Utils.resolve_hostname(load_balancer.dns_name)
             }
           end
         end

data/lib/aws_public_ips/checks/rds.rb

@@ -7,21 +7,25 @@ module AwsPublicIps
   module Checks
     module Rds
       def self.run
-        client = Aws::RDS::Client.new
+        client = ::Aws::RDS::Client.new
 
-        # TODO(arkadiy) not sure if this is true anymore after redshift, do more testing
-        # RDS instances can be:
-        # - launched into classic
-        # - launched into VPC
-        # - launched into a VPC but marked as `publicly_accessible`, in which case the VPC must have an Internet
-        # Gateway attached, and the DNS endpoint will resolve to a public ip address
+        # RDS instances can be launched into VPCs or into Classic mode.
+        # In classic mode they are always public.
+        # In VPC mode they can be marked as `publicly_accessible` or not - if they are then its VPC must have
+        # an Internet Gateway attached, and the DNS endpoint will resolve to a public ip address.
         client.describe_db_instances.flat_map do |response|
           response.db_instances.flat_map do |instance|
             next [] unless instance.publicly_accessible
+
+            if instance.endpoint.nil?
+              raise StandardError, "RDS DB '#{instance.dbi_resource_id}' has a nil endpoint. This likely" \
+                ' means the DB is being brought up right now.'
+            end
+
             {
               id: instance.dbi_resource_id,
               hostname: instance.endpoint.address,
-              ip_addresses: Utils.resolve_hostname(instance.endpoint.address)
+              ip_addresses: ::AwsPublicIps::Utils.resolve_hostname(instance.endpoint.address)
             }
           end
         end

data/lib/aws_public_ips/checks/redshift.rb

@@ -1,24 +1,32 @@
 # frozen_string_literal: true
 
 require 'aws-sdk-redshift'
+require 'aws_public_ips/utils'
 
 module AwsPublicIps
   module Checks
     module Redshift
       def self.run
-        client = Aws::Redshift::Client.new
+        client = ::Aws::Redshift::Client.new
 
-        # TODO(arkadiy) update copy from RDS
-        # Redshift clusters can only be launched into VPCs. They can be marked as `publicly_accessible`,
-        # in which case the VPC must have an Internet Gateway attached, and the DNS endpoint will
-        # resolve to a public ip address
+        # Redshift clusters can be launched into VPCs or into Classic mode.
+        # In classic mode they are always public.
+        # In VPC mode they can be marked as `publicly_accessible` or not - if they are then its VPC must have
+        # an Internet Gateway attached, and the DNS endpoint will resolve to a public ip address.
         client.describe_clusters.flat_map do |response|
           response.clusters.flat_map do |cluster|
             next [] unless cluster.publicly_accessible
+
+            if cluster.endpoint.nil?
+              raise StandardError, "Redshift cluster '#{cluster.cluster_identifier}' has a nil endpoint. This likely" \
+                ' means the cluster is being brought up right now.'
+            end
+
             {
               id: cluster.cluster_identifier,
               hostname: cluster.endpoint.address,
-              ip_addresses: cluster.cluster_nodes.map(&:public_ip_address)
+              ip_addresses: cluster.cluster_nodes.map(&:public_ip_address) +
+                ::AwsPublicIps::Utils.resolve_hostname(cluster.endpoint.address)
             }
           end
         end

data/lib/aws_public_ips/cli.rb

@@ -39,11 +39,11 @@ module AwsPublicIps
     # AWS Neptune (still in preview / not GA yet)
 
     def all_services
-      @all_services ||= Dir["#{__dir__}/checks/*.rb"].map { |path| File.basename(path, '.rb') }.sort
+      @all_services ||= ::Dir["#{__dir__}/checks/*.rb"].map { |path| ::File.basename(path, '.rb') }.sort
     end
 
     def all_formats
-      @all_formats ||= Dir["#{__dir__}/formatters/*.rb"].map { |path| File.basename(path, '.rb') }.sort
+      @all_formats ||= ::Dir["#{__dir__}/formatters/*.rb"].map { |path| ::File.basename(path, '.rb') }.sort
     end
 
     def parse(args)
@@ -53,28 +53,39 @@ module AwsPublicIps
         verbose: false
       }
 
-      OptionParser.new do |opts|
-        opts.banner = 'Usage: aws_public_ips [options]'
+      ::OptionParser.new do |parser|
+        parser.banner = 'Usage: aws_public_ips [options]'
 
-        opts.on('-s', '--services <s1>,<s2>,<s3>', Array, 'List of AWS services to check. Available services: ' \
+        parser.on('-s', '--services <s1>,<s2>,<s3>', Array, 'List of AWS services to check. Available services: ' \
           "#{all_services.join(',')}. Defaults to all.") do |services|
           services.map(&:downcase!).uniq!
           invalid_services = services - all_services
-          raise ArgumentError, "Invalid service(s): #{invalid_services.join(',')}" unless invalid_services.empty?
+          raise ::ArgumentError, "Invalid service(s): #{invalid_services.join(',')}" unless invalid_services.empty?
           options[:services] = services
         end
 
-        opts.on('-f', '--format <format>', String, 'Set output format. Available formats: ' \
+        parser.on('-f', '--format <format>', String, 'Set output format. Available formats: ' \
           "#{all_formats.join(',')}. Defaults to text.") do |fmt|
           unless all_formats.include?(fmt)
-            raise ArgumentError, "Invalid format '#{fmt}'. Valid formats are: #{all_formats.join(',')}"
+            raise ::ArgumentError, "Invalid format '#{fmt}'. Valid formats are: #{all_formats.join(',')}"
           end
           options[:format] = fmt
         end
 
-        opts.on('-v', '--[no-]verbose', 'Enable debug/trace output') do |verbose|
+        parser.on('-v', '--[no-]verbose', 'Enable debug/trace output') do |verbose|
           options[:verbose] = verbose
         end
+
+        parser.on_tail('--version', 'Print version') do
+          require 'aws_public_ips/version'
+          ::STDOUT.puts ::AwsPublicIps::VERSION
+          return nil  # nil to avoid rubocop warning
+        end
+
+        parser.on_tail('-h', '--help', 'Show this help message') do
+          ::STDOUT.puts parser
+          return nil  # nil to avoid rubocop warning
+        end
       end.parse(args)
 
       options
@@ -82,28 +93,29 @@ module AwsPublicIps
 
     def check_service(service)
       require "aws_public_ips/checks/#{service}.rb"
-      AwsPublicIps::Checks.const_get(service.capitalize).run
+      ::AwsPublicIps::Checks.const_get(service.capitalize).run
     end
 
     def output(formatter, results)
       require "aws_public_ips/formatters/#{formatter}.rb"
-      formatter_klass = AwsPublicIps::Formatters.const_get(formatter.capitalize)
+      formatter_klass = ::AwsPublicIps::Formatters.const_get(formatter.capitalize)
       output = formatter_klass.new(results).format
-      puts output unless output.empty?
+      ::STDOUT.puts output unless output.empty?
     end
 
     def run(args)
       options = parse(args)
+      return unless options
 
       results = options[:services].map do |service|
         [service.to_sym, check_service(service)]
       end.to_h
 
       output(options[:format], results)
-    rescue StandardError, Interrupt => ex
-      puts ex.inspect
-      puts ex.backtrace if options[:verbose]
-      Process.exit(1)
+    rescue ::StandardError, ::Interrupt => ex
+      ::STDERR.puts ex.inspect
+      ::STDERR.puts ex.backtrace if options && options[:verbose]
+      ::Process.exit(1)
     end
   end
 end

data/lib/aws_public_ips/formatters/prettyjson.rb

@@ -10,7 +10,7 @@ module AwsPublicIps
       end
 
       def format
-        JSON.pretty_generate(@results)
+        ::JSON.pretty_generate(@results)
       end
     end
   end

data/lib/aws_public_ips/utils.rb

@@ -10,9 +10,9 @@ module AwsPublicIps
 
     def self.resolve_hostname(hostname)
       # Default Resolv.getaddresses doesn't seem to return IPv6 results
-      resources = Resolv::DNS.open do |dns|
-        dns.getresources(hostname, Resolv::DNS::Resource::IN::A) +
-          dns.getresources(hostname, Resolv::DNS::Resource::IN::AAAA)
+      resources = ::Resolv::DNS.open do |dns|
+        dns.getresources(hostname, ::Resolv::DNS::Resource::IN::A) +
+          dns.getresources(hostname, ::Resolv::DNS::Resource::IN::AAAA)
       end
 
       resources.map do |resource|

data/lib/aws_public_ips/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AwsPublicIps
-  VERSION = '1.0.3'.freeze
+  VERSION = '1.0.4'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aws_public_ips
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Arkadiy Tetelman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-17 00:00:00.000000000 Z
+date: 2018-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-apigateway
@@ -184,14 +184,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.55.0
+        version: 0.56.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.55.0
+        version: 0.56.0
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
@@ -253,7 +253,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: A library/cli to fetch all public IP addresses associated with an AWS account