awsutils 2.2.1 → 2.2.2

data/lib/awsutils/ec2latestimage.rb

@@ -1,7 +1,7 @@
 require 'json'
 require 'net/http'
 require 'optimist'
-# require 'aws-sdk' # see the comment on `image_details` below
+# require 'aws-sdk-ec2' # see the comment on `image_details` below
 
 module AwsUtils
   class Ec2LatestImage
@@ -9,9 +9,9 @@ module AwsUtils
       @releases ||= begin
         parsed_releases =
           if opts[:ownedbyme]
-            fail 'AWS_OWNER_ID not defined' unless ENV['AWS_OWNER_ID']
+            raise 'AWS_OWNER_ID not defined' unless ENV['AWS_OWNER_ID']
 
-            require 'aws-sdk'
+            require 'aws-sdk-ec2'
 
             ubuntu_images =
               connection.describe_images(owners: [ENV['AWS_OWNER_ID']]).images.select do |image|
@@ -31,7 +31,7 @@ module AwsUtils
           else
             resp = JSON.parse(
               Net::HTTP.get(
-                URI("http://cloud-images.ubuntu.com/locator/ec2/releasesTable?_=#{(Time.now.to_f*1000).to_i}")
+                URI("http://cloud-images.ubuntu.com/locator/ec2/releasesTable?_=#{(Time.now.to_f * 1000).to_i}")
               ).sub(/\],\n\]/, "]\n]")
             )
             parse_releases_array(resp['aaData'])
@@ -39,8 +39,8 @@ module AwsUtils
 
         parsed_releases.select do |rel|
           rel[:region] == opts[:region] &&
-          rel[:distro_version] == "#{opts[:release]}" &&
-          %w(amd64 x86_64).include?(rel[:arch])
+            rel[:distro_version] == opts[:release].to_s &&
+            %w[amd64 x86_64].include?(rel[:arch])
         end
       end
     end
@@ -81,23 +81,20 @@ module AwsUtils
     #     images_details.each_with_object({}) { |ami, m| m[ami.image_id] = ami }
     #   end
     # end
-
-    # rubocop:disable Metrics/MethodLength
     def parse_releases_array(releases)
       releases.map do |rel|
         {
-          region:         rel[0],
-          distro_name:    rel[1],
+          region: rel[0],
+          distro_name: rel[1],
           distro_version: rel[2],
-          arch:           rel[3],
-          type:           rel[4],
-          release:        rel[5],
-          ami:            parse_ami_link(rel[6]),
-          aki:            rel[7]
+          arch: rel[3],
+          type: rel[4],
+          release: rel[5],
+          ami: parse_ami_link(rel[6]),
+          aki: rel[7]
         }
       end
     end
-    # rubocop:enable Metrics/MethodLength
 
     def parse_ami_link(link)
       link.match(/launchAmi=(ami-\w{8})/)[1]

data/lib/awsutils/ec2listmachines.rb

@@ -1,404 +1,202 @@
-require 'rubygems'
 require 'optimist'
-require 'fog'
-
-gem 'fog', '>= 1.6.0'
-
-class Array
-  def longest
-    length = 0
-    val = ''
-    each do |a|
-      len_new = a.length
-      if len_new > length
-        length = len_new
-        val = a
-      end
-    end
-    val
-  end
-end
+require 'aws-sdk-ec2'
+require 'highline'
+require 'colorize'
+
+GROUPS_MAX_LENGTH = 96
 
 module AwsUtils
   class Ec2ListMachines
-    def connect
-      @connect = Fog::Compute.new(provider: 'AWS')
-      if $DEBUG
-        puts 'Inspect connection result:'
-        puts connect.inspect
+    def run
+      servers_sorted = formatted_servers.sort_by { |server| server.fetch(opts[:sort].to_sym, '') }
+
+      # Clear all formatting
+      printf "\033[0m"
+
+      items = bold_header + servers_sorted.map do |server|
+        columns.keys.map do |col|
+          # Set an empty string here so that CSV ends up with the right number of cols even when
+          # a field is unset
+          server[col] || ''
+        end
+      end.flatten
+
+      if opts[:csv]
+        hl = HighLine::List.new items, cols: columns.count
+        hl.row_join_string = ','
+        puts hl.to_s
+      else
+        puts HighLine.new.list items, :uneven_columns_across, columns.count
       end
+    end
+
+    private
 
-      @connect
+    def connect
+      @connect ||= Aws::EC2::Client.new
     end
 
-    def get_servers(opts)
-      static_ips = []
-      connect.addresses.all.each do |eip|
-        static_ips << eip.public_ip
+    def servers
+      return connect.describe_instances.reservations.map(&:instances).flatten unless opts[:search]
+
+      connect.describe_instances.reservations.map(&:instances).flatten.select do |i|
+        (name_tag = i.tags.find { |t| t.key == 'Name' }) &&
+          name_tag.value =~ /.*#{opts[:search]}.*/
       end
+    end
 
-      group_map = {}
-      connect.security_groups.map { |g| group_map[g.name] = g.group_id }
+    def include_terminated?
+      opts[:terminated] || opts[:state] == 'terminated'
+    end
 
-      if opts[:search]
-        servers = connect.servers.select do |s|
-          s.tags['Name'] =~ /.*#{opts[:search]}.*/
-        end
-      else
-        servers = connect.servers
-      end
+    # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+    def include_server?(server)
+      return false if (opts[:state] && server.state.name != opts[:state]) ||
+                      (opts[:type] && server.instance_type != opts[:type]) ||
+                      (opts[:zone] && server.placement.availability_zone != opts[:zone]) ||
+                      (server.state.name == 'terminated' && !include_terminated?)
 
-      servers_a = []
-
-      servers.each do |s|
-        if (opts[:state].nil? || (s.state == opts[:state])) &&
-          (
-            (opts[:terminated] == true) ||
-            (s.state != 'terminated') ||
-            (opts[:state] == 'terminated')
-          ) &&
-          (opts[:flavor].nil? || (s.flavor_id == opts[:flavor])) &&
-          (opts[:role].nil? || (s.tags['Role'] == opts[:role])) &&
-          (opts[:zone].nil? || (s.availability_zone.to_s == opts[:zone]))
-
-          if s.public_ip_address.nil?
-            pub_ip = ''
-          else
-            pub_ip = s.public_ip_address
-
-            static_ip = static_ips.include?(pub_ip) ? '(S)' : '(D)'
-          end
+      true
+    end
+    # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+
+    # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+    def formatted_servers
+      static_ips = connect.describe_addresses.addresses.map(&:public_ip)
+
+      servers.select { |server| include_server? server }.map do |server|
+        o = {
+          date: server.launch_time.to_s,
+          az: server.placement.availability_zone,
+          id: server.instance_id,
+          subnet: [server.subnet_id, "(#{subnet_name[server.subnet_id]})"].join(' '),
+          priv_ip: server.private_ip_address,
+          type: server.instance_type,
+          vpc: server.vpc_id,
+          state: opts[:csv] ? server.state.name : colorize_state(server.state.name).bold
+        }
 
-          role = s.tags['Role'] ? '-' : s.tags['Role']
+        if opts[:groups]
+          groups_string =
+            server.security_groupserver.map { |g| "#{g.group_id} (#{g.group_name})" }.join(', ')
 
-          if s.groups.first =~ /-/
-            group_to_insert = "#{group_map[s.groups.first]}/#{s.groups.first}"
-          else
-            group_to_insert = s.groups.first
+          # Shorten the groups string to a manageable length
+          unless (opts[:csv] || opts[:all_groups]) && groups_string.length > GROUPS_MAX_LENGTH
+            groups_string = groups_string[0..GROUPS_MAX_LENGTH] + '...'
           end
 
-          created = s.tags['created_on'] ||= s.created_at
-
-          servers_a << {
-            name: s.tags['Name'].to_s,
-            date: created.to_s,
-            role: role.to_s,
-            az: s.availability_zone.to_s,
-            id: s.id,
-            group: group_to_insert,
-            pub_ip: pub_ip,
-            static_ip: static_ip,
-            flavor: s.flavor_id,
-            state: s.state
-          }
+          o[:groups] = groups_string
+        end
 
+        if server.vpc_id && opts[:vpc]
+          o[:vpc] = [server.vpc_id, "(#{vpc_name[server.vpc_id]})"].join(' ')
         end
-      end
 
-      servers_a
-    end
+        if server.public_ip_address
+          static_ip = static_ips.include?(server.public_ip_address) ? '(S)' : '(D)'
+          o[:pub_ip] = [server.public_ip_address, static_ip].join(' ')
+        end
 
-    def sort_servers(servers_a, sort_col)
-      case sort_col
-      when 'role'
-        servers_a.sort_by { |a| a[:role] }
-      when 'az'
-        servers_a.sort_by { |a| a[:az] }
-      when 'name'
-        servers_a.sort_by { |a| a[:name] }
-      when 'id'
-        servers_a.sort_by { |a| a[:id] }
-      when 'group'
-        servers_a.sort_by { |a| a[:group] }
-      when 'flavor'
-        servers_a.sort_by { |a| a[:flavor] }
-      when 'state'
-        servers_a.sort_by { |a| a[:state] }
-      when 'ip'
-        servers_a.sort_by { |a| a[:pub_ip] }
-      when 'static'
-        servers_a.sort_by { |a| a[:static_ip] }
-      when 'date'
-        servers_a.sort_by { |a| a[:date] }
-      else
-        servers_a.sort_by { |a| a[:name] }
+        # Always include the name tag regardless of cli args (for searching)
+        (opts[:tags] | %w[tag_Name]).each do |tag|
+          next unless (k = server.tags.find { |t| t.key == tag })
+
+          o["tag_#{tag}".to_sym] = k.value
+        end
+
+        o
       end
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
 
-    def get_longest_server_name(servers_sorted)
-      server_names = []
-      servers_sorted.each do |server|
-        server_names << server[:name]
-      end
+    def vpc_name
+      @vpc_name ||= connect.describe_vpcs.vpcs.each_with_object({}) do |v, m|
+        next unless (tag = v.tags.find { |t| t.key == 'Name' })
 
-      server_names.longest.length + 1
+        m[v.vpc_id] = tag.value
+      end
     end
 
-    def print_headers(csv_opt, servers_sorted, longest_server_name, show_dates)
-      if csv_opt == true
-        if show_dates
-          printf(
-            "%s,%s,%s,%s,%s,%s,%s,%s,%s\n",
-            'Name',
-            'Created',
-            'Role',
-            'AZ',
-            'ID',
-            'Sec Group',
-            'Public IP,(S/D)',
-            'Flavor',
-            'State'
-          )
-        else
-          printf(
-            "%s,%s,%s,%s,%s,%s,%s,%s\n",
-            'Name',
-            'Role',
-            'AZ',
-            'ID',
-            'Sec Group',
-            'Public IP,(S/D)',
-            'Flavor',
-            'State'
-          )
-        end
-      else
-        if show_dates
-          printf(
-            "\033[0;4m%-#{longest_server_name}s %-30s %-16s %-10s %-10s " \
-              "%-24s %-19s %-10s %-7s\033[0m\n",
-            'Name',
-            'Created',
-            'Role',
-            'AZ',
-            'ID',
-            'Sec Group',
-            'Public IP (S/D)',
-            'Flavor',
-            'State'
-          )
-        else
-          printf(
-            "\033[0;4m%-#{longest_server_name}s %-16s %-10s %-10s %-24s " \
-              "%-19s %-10s %-7s\033[0m\n",
-            'Name',
-            'Role',
-            'AZ',
-            'ID',
-            'Sec Group',
-            'Public IP (S/D)',
-            'Flavor',
-            'State'
-          )
-        end
+    def subnet_name
+      @subnet_name ||= connect.describe_subnets.subnets.each_with_object({}) do |s, m|
+        next unless (tag = s.tags.find { |t| t.key == 'Name' })
+
+        m[s.subnet_id] = tag.value
       end
     end
 
-    def get_flavor_color(flavor)
-      case flavor
-      when 't1.micro'
-        '1;33'
-      when 'm1.large'
-        '0;33'
-      when 'm1.xlarge'
-        '0;34'
-      when 'm2.2xlarge'
-        '0;35'
-      when 'm2.4xlarge'
-        '0;31'
-      when 'm2.xlarge'
-        '0;36'
-      else
-        '0'
-      end
+    def columns
+      # This method also determines this display order
+
+      o = { id: 'ID' }
+
+      o.merge!(
+        az: 'AZ',
+        subnet: 'Subnet',
+        priv_ip: 'Private IP'
+      )
+
+      o[:groups] = 'Security Groups' if opts[:groups]
+      o[:vpc] = 'VPC' if opts[:vpc]
+      o[:created] = 'Created' if opts[:dates]
+
+      o.merge!(
+        type: 'Type',
+        state: 'State',
+        pub_ip: 'Public IP'
+      )
+
+      opts[:tags].each { |t| o["tag_#{t}".to_sym] = "Tag:#{t}" }
+
+      o
     end
 
-    def get_state_color(state)
+    def colorize_state(state)
       case state
       when 'running'
-        '1;32'
+        state.colorize :green
       when 'stopped'
-        '1;31'
-      when 'starting'
-        '5;32'
-      when 'stopping'
-        '5;31'
+        state.colorize :red
+      when 'starting', 'stopping'
+        state.colorize :orange
       else
-        '0'
+        state.disable_colorization = true
       end
     end
 
-    def print_machine_list(servers_sorted, nocolor_opt, csv_opt, longest_server_name, show_dates)
-      servers_sorted.each do |server|
-        name =      server[:name]
-        date =      server[:date]
-        role =      server[:role]
-        az =        server[:az]
-        id =        server[:id]
-        group =     server[:group]
-        ip =        server[:pub_ip]
-        static_ip = server[:static_ip]
-        flavor =    server[:flavor]
-        state =     server[:state]
-        fcolor =    get_flavor_color(flavor)
-        scolor =    get_state_color(state)
-
-        if (nocolor_opt == false) && (csv_opt == false)
-          if show_dates
-            printf(
-              "\033[1m%-#{longest_server_name}s\033[0m %-30s %-16s %-10s %-10s " \
-                "%-24s %-19s \033[#{fcolor}m%-11s\033[#{scolor}m%-7s\033[0m\n",
-              name,
-              date,
-              role,
-              az,
-              id,
-              group,
-              "#{ip} #{static_ip}",
-              flavor,
-              state
-            )
-          else
-            printf(
-              "\033[1m%-#{longest_server_name}s\033[0m %-16s %-10s %-10s " \
-                "%-24s %-19s \033[#{fcolor}m%-11s\033[#{scolor}m%-7s\033[0m\n",
-              name,
-              role,
-              az,
-              id,
-              group,
-              "#{ip} #{static_ip}",
-              flavor,
-              state
-            )
-          end
-        elsif csv_opt == true
-          if show_dates
-            printf(
-              "%s,%s,%s,%s,%s,%s,%s,%s,%s\n",
-              name,
-              date,
-              role,
-              az,
-              id,
-              group,
-              "#{ip},#{static_ip}",
-              flavor,
-              state
-            )
-          else
-            printf(
-              "%s,%s,%s,%s,%s,%s,%s,%s\n",
-              name,
-              role,
-              az,
-              id,
-              group,
-              "#{ip},#{static_ip}",
-              flavor,
-              state
-            )
-          end
+    def bold_header
+      columns.values.each_with_index.map do |v, i|
+        if i.zero?
+          "\033[1m#{v}"
+        elsif i == columns.count - 1
+          "#{v}\033[0m"
         else
-          if show_dates
-            printf(
-              "%-#{longest_server_name}s %-20s %-16s %-10s %-10s %-20s %-19s %-11s%-7s\n",
-              name,
-              date,
-              role,
-              az,
-              id,
-              group,
-              "#{ip} #{static_ip}",
-              flavor,
-              state
-            )
-          else
-            printf(
-              "%-#{longest_server_name}s %-16s %-10s %-10s %-20s %-19s %-11s%-7s\n",
-              name,
-              role,
-              az,
-              id,
-              group,
-              "#{ip} #{static_ip}",
-              flavor,
-              state
-            )
-          end
+          v
         end
       end
     end
 
-    def print_counts(servers_sorted, opts_csv)
-      flavor_data = {}
-      connect.flavors.each do |f|
-        flavor_data[f.id] = {
-          'cores' => f.cores,
-          'disk' => f.disk,
-          'ram' => f.ram
-        }
-      end
-      total_cores = 0
-      total_disk = 0.0
-      total_ram = 0.0
-
-      servers_sorted.each do |s|
-        total_cores += flavor_data[s[:flavor]]['cores']
-        total_disk += flavor_data[s[:flavor]]['disk'].to_f
-        total_ram += flavor_data[s[:flavor]]['ram'].to_f
-      end
-
-      if opts_csv
-        puts "total_instances,#{servers_sorted.count}"
-        puts "total_cores,#{total_cores}"
-        puts "total_disk,#{total_disk}"
-        puts "total_ram,#{total_ram}"
-      else
-        puts "\nTotals"
-        puts "\tInstances: #{servers_sorted.count}"
-        puts "\tCores: #{total_cores}"
-        printf("\tInstance storage: %.2f TB\n", total_disk / 1024)
-        printf("\tRAM: %.2f GB\n", total_ram / 1024)
-      end
-    end
-
-    def list_instances(opts)
-      servers = get_servers(opts)
-      servers_sorted = sort_servers(servers, opts[:sort])
-      longest_server_name = get_longest_server_name(servers_sorted)
-      print_headers(opts[:csv], servers_sorted, longest_server_name, opts[:dates])
-      print_machine_list(
-        servers_sorted,
-        opts[:nocolor],
-        opts[:csv],
-        longest_server_name,
-        opts[:dates]
-      )
+    def opts
+      @opts ||= begin
+        opts = Optimist.options do
+          opt :sort, 'Sort order', short: 's', default: 'tag_Name'
+          opt :tags, 'Tags to display', short: 'T', default: %w[Name]
+          opt :groups, 'Display Security Groups', default: false
+          opt :state, 'State', short: 'S', type: String
+          opt :type, 'Type', short: 'F', type: String
+          opt :zone, 'Availability Zone', short: 'Z', type: String
+          opt :csv, 'Output in CSV Format', short: 'C', default: false
+          opt :dates, 'Show creation timestamp', short: 'd', default: false
+          opt :terminated, 'Show terminated instances', short: 't', default: false
+          opt :nocolor, 'No color', short: 'c'
+          opt :vpc, 'Show VPC', default: true
+          opt :all_groups, 'Display full groups lists', default: false
+        end
 
-      print_counts(servers_sorted, opts[:csv])
-    end
+        opts[:search] = ARGV[0] unless ARGV.empty?
 
-    def parse_opts
-      opts = Optimist.options do
-        opt :sort, 'Sort order', short: 's', type: String
-        opt :state, 'State', short: 'S', type: String
-        opt :flavor, 'Flavor', short: 'F', type: String
-        opt :role, 'Role', short: 'r', type: String
-        opt :zone, 'Availability Zone', short: 'Z', type: String
-        opt :csv, 'Output in CSV Format', short: 'C', default: false
-        opt :dates, 'Show creation timestamp', short: 'd', default: false
-        opt :terminated, 'Show terminated instances', short: 't', default: false
-        opt :nocolor, 'No color', short: 'c'
+        opts
       end
-
-      opts[:search] = ARGV[0] unless ARGV[0].empty?
-
-      opts
-    end
-
-    def initialize
-      list_instances(parse_opts)
     rescue Interrupt
       puts 'Interrupted by user (SIGINT, Ctrl+C, etc.)'
     end