knife-ec2 0.19.16 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eca2c2f560a3a801db6f64bad73bbf766e5884164a1bc56d23afebf29911417e
-  data.tar.gz: 34897bd6689958ff49c4627ec08ae819364ba0a578b8deef0c92cb7219606a05
+  metadata.gz: e04afd6e4a0620bf4674a380606b26cb788fc4148ba1c5b3d6bd0f5b961a95f7
+  data.tar.gz: 5d9a506ba3e9c639e9ba356af39377c498146e3904f870a07018b7eacc1d5f0e
 SHA512:
-  metadata.gz: 71989dcdb4ac810b423ce75684563a685dd04fed81cca49630fe01cd36bc2cc697df3b81ac262f97263fbdfb909c97a95bcdc66be25b6729373476e2e6e3df4f
-  data.tar.gz: 10c20723124e241d81ed631cda7f7e9eb324acc428cb8c4bb3252c317a993ce6195d29ade245e1ff25145a817eb4d84ac3927dfffe2573305d76eb170c4e7955
+  metadata.gz: 9dab9ba5f3d204aab6d65534b3eb4e3a018007fa8917c44de439cc04a4bf8f745b6f9a14a96e2fcd4e811a6cc1f34df5eb50bfae825674886348cbbfaa738212
+  data.tar.gz: 9486a1aa93798a9aae585fc18e9888c93875a653a2d99bc2110ccd483446266daf16526960be44ad5acd53296ef9a931abc87b37c5af459097a6fdee70af85ec

data/lib/chef/knife/ec2_ami_list.rb

@@ -58,10 +58,10 @@ class Chef
       def run
         $stdout.sync = true
 
-        validate!
+        validate_aws_config!
         custom_warnings!
 
-        server_list = [
+        servers_list = [
           ui.color("AMI ID", :bold),
           ui.color("Platform", :bold),
           ui.color("Architecture", :bold),
@@ -70,48 +70,59 @@ class Chef
           ui.color("Description", :bold)
         ].flatten.compact
 
-        output_column_count = server_list.length
-        begin
-          owner = locate_config_value(:owner) || "aws-marketplace"
-          servers = connection.describe_images({ "Owner" => "#{owner}" }) # aws-marketplace, microsoft
-        rescue Exception => api_error
-          raise api_error
-        end
+        output_column_count = servers_list.length
 
-        servers.body["imagesSet"].each do |server|
-          server["platform"] = find_server_platform(server["name"]) unless server["platform"]
-
-          if locate_config_value(:platform) && locate_config_value(:search)
-            locate_config_value(:search).downcase!
-            if server["description"] && server["platform"] == locate_config_value(:platform) && server["description"].downcase.include?(locate_config_value(:search))
-              server_list += get_server_list(server)
-            end
-          elsif locate_config_value(:platform)
-            if server["platform"] == locate_config_value(:platform)
-              server_list += get_server_list(server)
-            end
-          elsif locate_config_value(:search)
-            locate_config_value(:search).downcase!
-            if server["description"] && server["description"].downcase.include?(locate_config_value(:search))
-              server_list += get_server_list(server)
-            end
-          else
-            server_list += get_server_list(server)
+        if config[:format] == "summary"
+          ami_hashes.each_pair do |_k, v|
+            servers_list << v["image_id"]
+            servers_list << v["platform"]
+            servers_list << v["architecture"]
+            servers_list << v["size"]
+            servers_list << v["name"]
+            servers_list << v["description"]
           end
+          puts ui.list(servers_list, :uneven_columns_across, output_column_count)
+        else
+          output(format_for_display(ami_hashes))
         end
-        puts ui.list(server_list, :uneven_columns_across, output_column_count)
       end
 
       private
 
-      def get_server_list(server)
-        server_list = []
-        server_list << server["imageId"]
-        server_list << server["platform"]
-        server_list << server["architecture"]
-        server_list << server["blockDeviceMapping"].first["volumeSize"].to_s
-        server_list << server["name"].split(/\W+/).first
-        server_list << server["description"]
+      def ami_hashes
+        all_data = {}
+        ec2_connection.describe_images(image_params).images.each do |v|
+          v_data = {}
+          if locate_config_value(:search)
+            next unless v.description.downcase.include?(locate_config_value(:search).downcase)
+          end
+
+          %w{image_id platform description architecture}.each do |id|
+            v_data[id] = v.send(id)
+          end
+
+          v_data["name"] = v.name.split(/\W+/).first
+          v_data["size"] = v.block_device_mappings[0].ebs.volume_size.to_s
+          all_data[v_data["image_id"]] = v_data
+        end
+        all_data
+      end
+
+      def image_params
+        params = {}
+        owner = locate_config_value(:owner) || "aws-marketplace" # aws-marketplace, microsoft
+        params["owners"] = [owner.to_s]
+
+        filters = []
+        filters << { platform: locate_config_value(:platform) } if locate_config_value(:platform)
+
+        # TODO: Need to find substring to match in the description
+        # filters << { description: locate_config_value(:search) } if locate_config_value(:search)
+
+        if filters.length > 0
+          params["filters"] = filters
+        end
+        params
       end
     end
   end

data/lib/chef/knife/ec2_base.rb

@@ -27,26 +27,23 @@ class Chef
         includer.class_eval do
 
           deps do
-            require "fog/aws"
+            require "aws-sdk-ec2"
             require "chef/json_compat"
             require "chef/util/path_helper"
           end
 
           option :aws_credential_file,
             long: "--aws-credential-file FILE",
-            description: "File containing AWS credentials as used by the AWS Command Line Interface.",
-            proc: Proc.new { |key| Chef::Config[:knife][:aws_credential_file] = key }
+            description: "File containing AWS credentials as used by the AWS Command Line Interface."
 
           option :aws_config_file,
             long: "--aws-config-file FILE",
-            description: "File containing AWS configurations as used by the AWS Command Line Interface.",
-            proc: Proc.new { |key| Chef::Config[:knife][:aws_config_file] = key }
+            description: "File containing AWS configurations as used by the AWS Command Line Interface."
 
           option :aws_profile,
             long: "--aws-profile PROFILE",
             description: "AWS profile, from AWS credential file and AWS config file, to use",
-            default: "default",
-            proc: Proc.new { |key| Chef::Config[:knife][:aws_profile] = key }
+            default: "default"
 
           option :aws_access_key_id,
             short: "-A ID",
@@ -68,7 +65,8 @@ class Chef
           option :region,
             long: "--region REGION",
             description: "Your AWS region",
-            proc: Proc.new { |key| Chef::Config[:knife][:region] = key }
+            proc: Proc.new { |key| Chef::Config[:knife][:region] = key },
+            default: "us-east-1"
 
           option :use_iam_profile,
             long: "--use-iam-profile",
@@ -79,29 +77,102 @@ class Chef
         end
       end
 
-      # @return [Fog::Compute]
-      def connection
-        connection_settings = {
-          provider: "AWS",
-          region: locate_config_value(:region),
-        }
+      def connection_string
+        conn = {}
+        conn[:region] = locate_config_value(:region)
+        conn[:credentials] =
+          if locate_config_value(:use_iam_profile)
+            Aws::InstanceProfileCredentials.new
+          else
+            Aws::Credentials.new(locate_config_value(:aws_access_key_id), locate_config_value(:aws_secret_access_key), locate_config_value(:aws_session_token))
+          end
+        conn
+      end
 
-        if locate_config_value(:use_iam_profile)
-          connection_settings[:use_iam_profile] = true
-        else
-          connection_settings[:aws_access_key_id] = locate_config_value(:aws_access_key_id)
-          connection_settings[:aws_secret_access_key] = locate_config_value(:aws_secret_access_key)
-          connection_settings[:aws_session_token] = locate_config_value(:aws_session_token)
-        end
-        @connection ||= begin
-          connection = Fog::Compute.new(connection_settings)
+      # @return [Aws::EC2::Client]
+      def ec2_connection
+        @ec2_connection ||= Aws::EC2::Client.new(connection_string)
+      end
+
+      def fetch_ami(image_id)
+        return {} unless image_id
+        ec2_connection.describe_images({
+          image_ids: [image_id],
+        }).images.first
+      end
+
+      def fetch_ec2_instance(instance_id)
+        instance = ec2_connection.describe_instances({
+          instance_ids: [
+            instance_id,
+          ],
+        }).reservations[0]
+        normalize_server_data(server_hashes(instance))
+      end
+
+      def fetch_network_interfaces(nic_id)
+        ec2_connection.describe_network_interfaces({
+          network_interface_ids: [nic_id],
+        }).network_interfaces[0]
+      end
+
+      def fetch_password_data(server_id)
+        ec2_connection.get_password_data({
+          instance_id: server_id,
+        })
+      end
+
+      # @return [String]
+      def fetch_region
+        ec2_connection.instance_variable_get(:@config).region
+      end
+
+      def fetch_subnet(subnet_id)
+        ec2_connection.describe_subnets({
+          subnet_ids: [subnet_id],
+        }).subnets[0]
+      end
+
+      # @return [Hash]
+      def server_hashes(server_obj)
+        server_data = {}
+        %w{ebs_optimized image_id instance_id instance_type key_name platform public_dns_name public_ip_address private_dns_name private_ip_address root_device_type}.each do |id|
+          server_data[id] = server_obj.instances[0].send(id)
         end
+
+        server_data["availability_zone"] = server_obj.instances[0].placement.availability_zone
+        server_data["groups"] = server_obj.groups.map { |grp| grp.name }
+        server_data["iam_instance_profile"] = ( server_obj.instances[0].iam_instance_profile.nil? ? nil : server_obj.instances[0].iam_instance_profile.arn[/instance-profile\/(.*)/] )
+        server_data["id"] = server_data["instance_id"]
+
+        tags = server_obj.instances[0].tags.map { |x| x.value }
+        server_data["name"] = tags[0]
+        server_data["placement_group"] = server_obj.instances[0].placement.group_name
+        server_data["security_groups"] = server_obj.instances[0].security_groups.map { |x| x.group_name }
+        server_data["security_group_ids"] = server_obj.instances[0].security_groups.map { |x| x.group_id }
+        server_data["state"] = server_obj.instances[0].state.name
+        server_data["subnet_id"] = server_obj.instances[0].network_interfaces[0].subnet_id
+        server_data["tags"] = tags
+        server_data["tenancy"] = server_obj.instances[0].placement.tenancy
+        server_data["volume_id"] = server_obj.instances[0].block_device_mappings[0]&.ebs&.volume_id
+        server_data["block_device_mappings"] = server_obj.instances[0].block_device_mappings
+        server_data
+      end
+
+      # @return [Struct]
+      def normalize_server_data(server_hashes)
+        require "ostruct"
+        OpenStruct.new(server_hashes)
       end
 
       # @return [String]
       def locate_config_value(key)
         key = key.to_sym
-        config[key] || Chef::Config[:knife][key]
+        if defined?(config_value) # Inherited by bootstrap
+          config_value(key) || default_config[key]
+        else
+          config[key] || Chef::Config[:knife][key] || default_config[key]
+        end
       end
 
       def msg_pair(label, value, color = :cyan)
@@ -110,15 +181,19 @@ class Chef
         end
       end
 
+      def ami
+        @ami ||= fetch_ami(locate_config_value(:image))
+      end
+
+      # Platform value return for Windows AMIs; otherwise, it is blank.
       # @return [Boolean]
       def is_image_windows?
-        image_info = connection.images.get(@server.image_id)
-        image_info.platform == "windows"
+        ami.platform == "windows"
       end
 
       # validate the config options that were passed since some of them cannot be used together
       # also validate the aws configuration file contents if present
-      def validate!(keys = [:aws_access_key_id, :aws_secret_access_key])
+      def validate_aws_config!(keys = [:aws_access_key_id, :aws_secret_access_key])
         errors = [] # track all errors so we report on all of them
 
         validate_aws_config_file! if locate_config_value(:aws_config_file)
@@ -157,7 +232,7 @@ class Chef
         end
 
         if locate_config_value(:owner)
-          unless ["self", "aws-marketplace", "microsoft"].include? (locate_config_value(:owner))
+          unless ["self", "aws-marketplace", "microsoft"].include? (locate_config_value(:owner)) # rubocop:disable Style/WordArray
             raise ArgumentError, "Invalid owner: #{locate_config_value(:owner)}. Allowed owners are self, aws-marketplace or microsoft."
           end
         end
@@ -236,17 +311,14 @@ class Chef
       raise ArgumentError, "The provided --aws_config_file (#{config_file}) cannot be found on disk." unless File.exist?(config_file)
 
       aws_config = ini_parse(File.read(config_file))
-      profile = if locate_config_value(:aws_profile) == "default"
-                  "default"
-                else
-                  "profile #{locate_config_value(:aws_profile)}"
-                end
+      profile_key = locate_config_value(:aws_profile)
+      profile_key = "profile #{profile_key}" if profile_key != "default"
 
       unless aws_config.values.empty?
-        if aws_config[profile]
-          Chef::Config[:knife][:region] = aws_config[profile]["region"]
+        if aws_config[profile_key]
+          Chef::Config[:knife][:region] = aws_config[profile_key]["region"]
         else
-          raise ArgumentError, "The provided --aws-profile '#{profile}' is invalid."
+          raise ArgumentError, "The provided --aws-profile '#{profile_key}' is invalid."
         end
       end
     end

data/lib/chef/knife/ec2_eip_list.rb

@@ -0,0 +1,88 @@
+#
+# Author:: Tim Smith (<tsmith@chef.io>)
+# Copyright:: Copyright (c) 2018 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "chef/knife/ec2_base"
+
+class Chef
+  class Knife
+    class Ec2EniList < Knife
+
+      include Knife::Ec2Base
+
+      banner "knife ec2 eni list (options)"
+
+      def run
+        validate_aws_config!
+        custom_warnings!
+
+        eni_list = [
+          ui.color("ID", :bold),
+          ui.color("Status", :bold),
+          ui.color("AZ", :bold),
+          ui.color("Public IP", :bold),
+          ui.color("Private IPs", :bold),
+          ui.color("IPv6 IPs", :bold),
+          ui.color("Subnet ID", :bold),
+          ui.color("VPC ID", :bold)
+        ].flatten.compact
+
+        output_column_count = eni_list.length
+
+        if config[:format] == "summary"
+          eni_hash.each_pair do |_k, v|
+            eni_list << v["network_interface_id"]
+            eni_list << v["status"]
+            eni_list << v["availability_zone"]
+            eni_list << v["public_ip"].to_s # to_s since it might be nil
+            eni_list << v["private_ips"].join(",")
+            eni_list << v["ipv_6_addresses"].join(",")
+            eni_list << v["subnet_id"]
+            eni_list << v["vpc_id"]
+          end
+          puts ui.list(eni_list, :uneven_columns_across, output_column_count)
+        else
+          output(format_for_display(eni_hash))
+        end
+      end
+
+      private
+
+      # build a hash of ENI we care about
+      # @return [Hash]
+      def eni_hash
+        all_data = {}
+        ec2_connection.describe_network_interfaces.first.network_interfaces.each do |eni|
+          eni_data = {}
+          %w{network_interface_id status mac_address availability_zone subnet_id vpc_id ipv_6_addresses}.each do |id|
+            eni_data[id] = eni.send(id)
+          end
+
+          # parse out the 1+ private IPs from the associations in the
+          # Aws::EC2::Types::NetworkInterfacePrivateIpAddress struct
+          eni_data["private_ips"] = eni.private_ip_addresses.map { |a| a["private_ip_address"] }
+
+          # grab the 1 public ip from the Aws::EC2::Types::NetworkInterfaceAssociation struct if it exists
+          eni_data["public_ip"] = ( eni.association.nil? ? nil : eni.association["public_ip"] )
+
+          all_data[eni_data["network_interface_id"]] = eni_data
+        end
+        all_data
+      end
+    end
+  end
+end

data/lib/chef/knife/ec2_flavor_list.rb

@@ -24,42 +24,11 @@ class Chef
 
       include Knife::Ec2Base
 
-      banner "knife ec2 flavor list (options)"
+      banner "knife ec2 flavor list (options) [DEPRECATED]"
 
       def run
-        validate!
-        custom_warnings!
-
-        flavor_list = [
-          ui.color("ID", :bold),
-          ui.color("Name", :bold),
-          ui.color("Architecture", :bold),
-          ui.color("RAM", :bold),
-          ui.color("Disk", :bold),
-          ui.color("Cores", :bold)
-        ].flatten.compact
-
-        output_column_count = flavor_list.length
-
-        begin
-          flavors = connection.flavors.sort_by(&:id)
-        rescue Exception => api_error
-          raise api_error
-        end
-
-        if config[:format] == "summary"
-          flavors.each do |flavor|
-            flavor_list << flavor.id.to_s
-            flavor_list << flavor.name
-            flavor_list << "#{flavor.bits}-bit"
-            flavor_list << "#{flavor.ram}"
-            flavor_list << "#{flavor.disk} GB"
-            flavor_list << flavor.cores.to_s
-          end
-          puts ui.list(flavor_list, :uneven_columns_across, output_column_count)
-        else
-          output(format_for_display(flavors))
-        end
+        ui.error("knife ec2 flavor list has been deprecated as this functionality is not provided by the AWS API the previous implementatin relied upon hardcoded values that were often incorrect. For an up to date list of instance types see https://www.ec2instances.info/")
+        exit 1
       end
     end
   end