knife-ec2 0.19.16 → 1.0.1

data/lib/chef/knife/ec2_server_delete.rb

@@ -35,6 +35,13 @@ class Chef
 
       attr_reader :server
 
+      option :dry_run,
+        long: "--dry-run",
+        short: "-n",
+        boolean: true,
+        default: false,
+        description: "Don't take action, only print what would happen."
+
       option :purge,
         short: "-P",
         long: "--purge",
@@ -54,61 +61,48 @@ class Chef
       # necessary to make them confirm two more times.
       def destroy_item(klass, name, type_name)
         object = klass.load(name)
-        object.destroy
+        object.destroy unless config[:dry_run]
         ui.warn("Deleted #{type_name} #{name}")
       rescue Net::HTTPServerException
         ui.warn("Could not find a #{type_name} named #{name} to delete!")
       end
 
       def run
-        validate!
-        if @name_args.empty? && config[:chef_node_name]
-          ui.info("no instance id is specific, trying to retrieve it from node name")
-          instance_id = fetch_instance_id(config[:chef_node_name])
-          @name_args << instance_id unless instance_id.nil?
-        end
-
-        @name_args.each do |instance_id|
-
-          begin
-            @server = connection.servers.get(instance_id)
-
-            msg_pair("Instance ID", @server.id)
-            msg_pair("Instance Name", @server.tags["Name"])
-            msg_pair("Flavor", @server.flavor_id)
-            msg_pair("Image", @server.image_id)
-            msg_pair("Region", connection.instance_variable_get(:@region))
-            msg_pair("Availability Zone", @server.availability_zone)
-            msg_pair("Security Groups", @server.groups.join(", "))
-            msg_pair("IAM Profile", iam_name_from_profile(@server.iam_instance_profile)) if @server.iam_instance_profile
-            msg_pair("SSH Key", @server.key_name)
-            msg_pair("Root Device Type", @server.root_device_type)
-            msg_pair("Public DNS Name", @server.dns_name)
-            msg_pair("Public IP Address", @server.public_ip_address)
-            msg_pair("Private DNS Name", @server.private_dns_name)
-            msg_pair("Private IP Address", @server.private_ip_address)
-
-            puts "\n"
-            confirm("Do you really want to delete this server")
-
-            @server.destroy
-
-            ui.warn("Deleted server #{@server.id}")
-
-            if config[:purge]
-              if config[:chef_node_name]
-                thing_to_delete = config[:chef_node_name]
-              else
-                thing_to_delete = fetch_node_name(instance_id)
-              end
-              destroy_item(Chef::Node, thing_to_delete, "node")
-              destroy_item(Chef::ApiClient, thing_to_delete, "client")
-            else
-              ui.warn("Corresponding node and client for the #{instance_id} server were not deleted and remain registered with the Chef Server")
-            end
-          rescue NoMethodError
-            ui.error("Could not locate server '#{instance_id}'.  Please verify it was provisioned in the '#{locate_config_value(:region)}' region.")
+        validate_aws_config!
+        validate_instances!
+
+        server_hashes.each do |h|
+          instance_id = h["instance_id"]
+          msg_pair("Instance ID", instance_id)
+          msg_pair("Instance Name", h["name"])
+          msg_pair("Flavor", h["instance_type"])
+          msg_pair("Image", h["image_id"])
+          msg_pair("Region", fetch_region)
+          msg_pair("Availability Zone", h["az"])
+          msg_pair("Security Groups", h["security_groups"])
+          msg_pair("IAM Profile", h["iam_instance_profile"])
+          msg_pair("SSH Key", h["key_name"])
+          msg_pair("Root Device Type", h["root_device_type"])
+          msg_pair("Public DNS Name", h["public_dns_name"])
+          msg_pair("Public IP Address", h["public_ip_address"])
+          msg_pair("Private DNS Name", h["private_dns_name"])
+          msg_pair("Private IP Address", h["private_ip_address"])
+
+          puts "\n"
+          confirm("Do you really want to delete this server")
+
+          delete_instance(instance_id) unless config[:dry_run]
+
+          ui.warn("Deleted server #{instance_id}")
+
+          if config[:purge]
+            node_name = config[:chef_node_name] || fetch_node_name(instance_id)
+            destroy_item(Chef::Node, node_name, "node")
+            destroy_item(Chef::ApiClient, node_name, "client")
+          else
+            ui.warn("Corresponding node and client for the #{instance_id} server were not deleted and remain registered with the Chef Server")
           end
+          puts "\n"
         end
       end
 
@@ -137,6 +131,63 @@ class Chef
       def query
         @query ||= Chef::Search::Query.new
       end
+
+      private
+
+      # @return [Array<Hash>]
+      def server_hashes
+        all_data = []
+
+        servers_list = ec2_connection.describe_instances({
+          instance_ids: @name_args,
+        })
+
+        servers_list.reservations.each do |i|
+          server_data = {}
+          %w{image_id instance_id instance_type key_name root_device_type public_ip_address private_ip_address private_dns_name public_dns_name}.each do |id|
+            server_data[id] = i.instances[0].send(id)
+          end
+
+          server_data["name"] = i.instances[0].tags[0].value
+          server_data["az"] = i.instances[0].placement.availability_zone
+          server_data["iam_instance_profile"] = ( i.instances[0].iam_instance_profile.nil? ? nil : i.instances[0].iam_instance_profile.arn[/instance-profile\/(.*)/] )
+          server_data["security_groups"] = i.instances[0].security_groups.map { |x| x.group_name }.join(", ")
+
+          all_data << server_data
+        end
+        all_data
+      end
+
+      # Delete the server instance
+      def delete_instance(instance_id)
+        return nil unless instance_id || instance_id.is_a?(String)
+        ec2_connection.terminate_instances({
+          instance_ids: [
+            instance_id,
+          ],
+        })
+      end
+
+      # If SERVER instance id not provided then check chef_name_tag and fetch the node
+      # And if the node contains instance id then add it to the name args
+      def validate_instances!
+        if @name_args.empty?
+          if config[:chef_node_name]
+            ui.info("No instance id is specified, trying to retrieve it from node name")
+            instance_id = fetch_instance_id(config[:chef_node_name])
+
+            if instance_id.nil?
+              ui.info("No instance id found.")
+              exit 1
+            else
+              @name_args << instance_id
+            end
+          else
+            ui.info("No instance id is specified.")
+            exit 1
+          end
+        end
+      end
     end
   end
 end

data/lib/chef/knife/ec2_server_list.rb

@@ -34,8 +34,15 @@ class Chef
         default: true,
         description: "Do not display name tag in output"
 
+      option :iamprofile,
+        short: "-i",
+        long: "--iam-profile",
+        boolean: true,
+        default: false,
+        description: "Show the iam profile"
+
       option :az,
-        short: "-z",
+        short: "-a",
         long: "--availability-zone",
         boolean: true,
         default: false,
@@ -64,12 +71,24 @@ class Chef
         end
       end
 
+      # @return [Symbol]
+      def state_color(state)
+        case state
+        when "shutting-down", "terminated", "stopping", "stopped"
+          :red
+        when "pending"
+          :yellow
+        else
+          :green
+        end
+      end
+
       def run
         $stdout.sync = true
 
-        validate!
+        validate_aws_config!
 
-        server_list = [
+        servers_list = [
           ui.color("Instance ID", :bold),
 
           if config[:name]
@@ -94,65 +113,85 @@ class Chef
             end
           end,
 
-          ui.color("IAM Profile", :bold),
+          if config[:iamprofile]
+            ui.color("IAM Profile", :bold)
+          end,
+
           ui.color("State", :bold)
         ].flatten.compact
 
-        output_column_count = server_list.length
+        output_column_count = servers_list.length
 
         if !config[:region] && Chef::Config[:knife][:region].nil?
           ui.warn "No region was specified in knife.rb/config.rb or as an argument. The default region, us-east-1, will be used:"
         end
 
-        servers = connection.servers
         if config[:format] == "summary"
-          servers.each do |server|
-            server_list << server.id.to_s
-
-            if config[:name]
-              server_list << server.tags["Name"].to_s
+          server_hashes.each do |v|
+            servers_list << v["instance_id"]
+            servers_list << v["name"] if config[:name]
+            servers_list << v["public_ip_address"]
+            servers_list << v["private_ip_address"]
+            servers_list << v["instance_type"]
+            servers_list << v["az"] if config[:az]
+            servers_list << v["image_id"]
+            servers_list << v["key_name"]
+            servers_list << v["security_groups"].join(",")
+            if config[:tags]
+              config[:tags].split(",").collect do |tag_name|
+                servers_list << v["tags"].find { |tag| tag == tag_name }
+              end
             end
+            servers_list << v["iam_instance_profile"].to_s if config[:iamprofile] # may be nil
+            servers_list << v["state"]
+          end
+          puts ui.list(servers_list, :uneven_columns_across, output_column_count)
+        else
+          output(format_for_display(server_hashes))
+        end
+      end
 
-            server_list << server.public_ip_address.to_s
-            server_list << server.private_ip_address.to_s
-            server_list << server.flavor_id.to_s
+      private
 
-            if config[:az]
-              server_list << ui.color(
-                                  server.availability_zone.to_s,
-                                  azcolor(server.availability_zone.to_s)
-                                )
-            end
+      # @return [Array<Hash>]
+      def server_hashes
+        all_data = []
+        ec2_connection.describe_instances.reservations.each do |i|
+          server_data = {}
+          %w{image_id instance_id instance_type key_name public_ip_address private_ip_address}.each do |id|
+            server_data[id] = i.instances[0].send(id)
+          end
 
-            server_list << server.image_id.to_s
-            server_list << server.key_name.to_s
-            server_list << server.groups.join(", ")
+          # dig into tags struct
+          tags = extract_tags(i.instances[0].tags)
 
-            if config[:tags]
-              config[:tags].split(",").each do |tag_name|
-                server_list << server.tags[tag_name].to_s
-              end
-            end
+          if config[:name]
+            server_data["name"] = tags[0]
+          end
 
-            server_list << iam_name_from_profile(server.iam_instance_profile)
-
-            server_list << begin
-              state = server.state.to_s.downcase
-              case state
-              when "shutting-down", "terminated", "stopping", "stopped"
-                ui.color(state, :red)
-              when "pending"
-                ui.color(state, :yellow)
-              else
-                ui.color(state, :green)
-              end
-            end
+          if config[:az]
+            server_data["az"] = ui.color(i.instances[0].placement.availability_zone, azcolor(i.instances[0].placement.availability_zone))
           end
 
-          puts ui.list(server_list, :uneven_columns_across, output_column_count)
-        else
-          output(format_for_display(servers))
+          server_data["iam_instance_profile"] = ( i.instances[0].iam_instance_profile.nil? ? nil : i.instances[0].iam_instance_profile.arn[/instance-profile\/(.*)/] )
+
+          server_data["state"] = ui.color(i.instances[0].state.name, state_color(i.instances[0].state.name))
+
+          if config[:tags]
+            server_data["tags"] = tags
+          end
+
+          # dig into security_groups struct
+          server_data["security_groups"] = i.instances[0].security_groups.map { |x| x.group_name }
+
+          all_data << server_data
         end
+        all_data
+      end
+
+      # @return [Array<String>]
+      def extract_tags(tags_struct)
+        tags_struct.map { |x| x.value }
       end
     end
   end

data/lib/chef/knife/ec2_subnet_list.rb

@@ -0,0 +1,79 @@
+#
+# 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 Ec2SubnetList < Knife
+
+      include Knife::Ec2Base
+
+      banner "knife ec2 subnet list (options)"
+
+      def run
+        validate_aws_config!
+        custom_warnings!
+
+        subnet_list = [
+          ui.color("ID", :bold),
+          ui.color("State", :bold),
+          ui.color("CIDR Block", :bold),
+          ui.color("AZ", :bold),
+          ui.color("Available IPs", :bold),
+          ui.color("AZ Default?", :bold),
+          ui.color("Maps Public IP?", :bold),
+          ui.color("VPC ID", :bold)
+        ].flatten.compact
+
+        output_column_count = subnet_list.length
+
+        if config[:format] == "summary"
+          subnet_hash.each_pair do |_k, v|
+            subnet_list << v["subnet_id"]
+            subnet_list << v["state"]
+            subnet_list << v["cidr_block"]
+            subnet_list << v["availability_zone"]
+            subnet_list << v["available_ip_address_count"].to_s
+            subnet_list << (v["default_for_az"] ? "Yes" : "No")
+            subnet_list << (v["map_public_ip_on_launch"] ? "Yes" : "No")
+            subnet_list << v["vpc_id"]
+          end
+          puts ui.list(subnet_list, :uneven_columns_across, output_column_count)
+        else
+          output(format_for_display(subnet_hash))
+        end
+      end
+
+      private
+
+      # @return [Hash<Hash>]
+      def subnet_hash
+        all_data = {}
+        ec2_connection.describe_subnets.first.subnets.each do |s|
+          s_data = {}
+          %w{subnet_id availability_zone available_ip_address_count cidr_block default_for_az map_public_ip_on_launch state vpc_id}.each do |id|
+            s_data[id] = s.send(id)
+          end
+          all_data[s_data["subnet_id"]] = s_data
+        end
+        all_data
+      end
+    end
+  end
+end

data/lib/chef/knife/ec2_vpc_list.rb

@@ -0,0 +1,75 @@
+#
+# 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 Ec2VpcList < Knife
+
+      include Knife::Ec2Base
+
+      banner "knife ec2 vpc list (options)"
+
+      def run
+        validate_aws_config!
+        custom_warnings!
+
+        vpcs_list = [
+          ui.color("ID", :bold),
+          ui.color("State", :bold),
+          ui.color("CIDR Block", :bold),
+          ui.color("Instance Tenancy", :bold),
+          ui.color("DHCP Options ID", :bold),
+          ui.color("Default VPC?", :bold)
+        ].flatten.compact
+
+        output_column_count = vpcs_list.length
+
+        if config[:format] == "summary"
+          vpc_hash.each_pair do |_k, v|
+            vpcs_list << v["vpc_id"]
+            vpcs_list << v["state"]
+            vpcs_list << v["cidr_block"]
+            vpcs_list << v["instance_tenancy"]
+            vpcs_list << v["dhcp_options_id"]
+            vpcs_list << (v["is_default"] ? "Yes" : "No")
+          end
+          puts ui.list(vpcs_list, :uneven_columns_across, output_column_count)
+        else
+          output(format_for_display(vpc_hash))
+        end
+      end
+
+      private
+
+      # @return [Hash<Hash>]
+      def vpc_hash
+        all_data = {}
+        ec2_connection.describe_vpcs.first.vpcs.each do |v|
+          v_data = {}
+          %w{vpc_id cidr_block dhcp_options_id instance_tenancy is_default state}.each do |id|
+            v_data[id] = v.send(id)
+          end
+          all_data[v_data["vpc_id"]] = v_data
+        end
+        all_data
+      end
+    end
+  end
+end