Added enable flag for chef and set it to true by default

README.md

@@ -17,7 +17,7 @@ You will need to create a CloudWatch Events rule that's configured to send termi
 1. Goto CloudWatch Events in the AWS Console
 1. Click *Create rule*
 1. Select event source of *EC2 instance state change notification*
-1. Select specific state of *Terminated*
+1. Select specific state of *Terminated* (optional will ignore events that are not *Terminated*)
 1. Add a target of *SQS Queue* and set queue to the cloudwatch-events queue created in step one
 1. Give the rule a name/description and click *Create rule*
 
@@ -87,9 +87,36 @@ To enable webhooks, add a `:webhooks:` section to the config:
 Chat notifications can be sent when the webhook successfully executes. See
 config.yml.sample for an example of the config.
 
+### Client Lookup
+
+By default aws-cleaner assumes that the lookup will be done against chef as this was one of its core intentions. This can be configured for sensu via config:
+```
+:general:
+  :lookup_type: 'sensu'
+```
+
+### States
+
+By default aws-cleaner assumes that the only state you will be looking for is `terminated` you can change this via config:
+```
+:general:
+  :states:
+   - 'terminated'
+```
+
+### Chef
+
+If switching the client lookup to sensu you will probably want to disable chef via the following config:
+```
+:chef:
+  :enable: false
+```
+
 ### Sensu
 
-By default aws-cleaner assumes that removing from sensu is desired as this was one of its core intentions. To allow people to leverage this without sensu you can disable it via config:
+By default aws-cleaner assumes that the lookup will be done against chef as this was one of its core intentions. This can be configured for sensu via config:
+
+You can disable sensu via config as well to skip removing the client from sensu:
 ```
 :sensu:
   :enable: false

bin/aws_cleaner.rb

@@ -63,7 +63,7 @@ def logger(config)
   logger
 end
 
-def webhook(id, instance_id)
+def webhook(instance_id)
   if @config[:webhooks]
     @config[:webhooks].each do |hook, hook_config|
       if AwsCleaner::Webhooks.fire_webhook(hook_config, @config, instance_id)
@@ -72,31 +72,26 @@ def webhook(id, instance_id)
         @logger.info("Failed to run webhook #{hook}")
       end
     end
-    AwsCleaner.new.delete_message(id, @config)
   end
 end
 
-def chef(id, instance_id, chef_node)
-  if chef_node
-    if AwsCleaner::Chef.remove_from_chef(chef_node, @chef_client, @config)
-      @logger.info("Removed #{chef_node} from Chef")
-      AwsCleaner.new.delete_message(id, @config)
-    end
+def chef(instance_id, chef_node)
+  return unless @config[:chef][:enable]
+
+  if AwsCleaner::Chef.remove_from_chef(chef_node, @chef_client, @config)
+    @logger.info("Removed #{chef_node} from Chef")
   else
-    @logger.info("Instance #{instance_id} does not exist in Chef, deleting message")
-    AwsCleaner.new.delete_message(id, @config)
+    @logger.info("Instance #{instance_id} does not exist in Chef")
   end
 end
 
-def sensu(id, instance_id, chef_node)
+def sensu(instance_id, sensu_node)
   return unless @config[:sensu][:enable]
-  if AwsCleaner::Sensu.in_sensu?(chef_node, @config)
-    if AwsCleaner::Sensu.remove_from_sensu(chef_node, @config)
-      @logger.info("Removed #{chef_node} from Sensu")
-    else
-      @logger.info("Instance #{instance_id} does not exist in Sensu, deleting message")
-    end
-    AwsCleaner.new.delete_message(id, @config)
+
+  if AwsCleaner::Sensu.remove_from_sensu(sensu_node, @config)
+    @logger.info("Removed #{sensu_node} from Sensu")
+  else
+    @logger.info("Instance #{instance_id} does not exist in Sensu")
   end
 end
 
@@ -115,12 +110,30 @@ def closelog(message)
 @sqs_client = AwsCleaner::SQS.client(@config)
 @chef_client = AwsCleaner::Chef.client(@config)
 
-# to provide backwards compatibility as this key did not exist previously
+# to provide backwards compatibility as these keys did not exist previously
+@config[:chef][:enable] = if @config[:chef][:enable].nil?
+                            true
+                          else
+                            @config[:chef][:enable]
+                          end
 @config[:sensu][:enable] = if @config[:sensu][:enable].nil?
                              true
                            else
                              @config[:sensu][:enable]
                            end
+@config[:general] = if @config[:general].nil?
+                      ''
+                    end
+@config[:general][:lookup_type] = if @config[:general][:lookup_type].nil?
+                                    'chef'
+                                  else
+                                    @config[:general][:lookup_type]
+                                  end
+@config[:general][:states] = if @config[:general][:states].nil?
+                               ['terminated']
+                             else
+                               @config[:general][:states]
+                             end
 
 # main loop
 loop do
@@ -144,16 +157,31 @@ def closelog(message)
         next
       end
 
-      instance_id = AwsCleaner.new.process_message(body)
+      instance_id = AwsCleaner.new.process_message(body, @config)
 
       if instance_id
-        chef_node = AwsCleaner::Chef.get_chef_node_name(instance_id, @config)
-        webhook(id, instance_id)
-        chef(id, instance_id, chef_node)
-        sensu(id, instance_id, chef_node)
-      else
-        @logger.info('Message not relevant, deleting')
+        node = case @config[:general][:lookup_type]
+               when 'sensu'
+                 AwsCleaner::Sensu.get_sensu_node_name(instance_id, @config)
+               else
+                 AwsCleaner::Chef.get_chef_node_name(instance_id, @config)
+               end
+
+        if node
+          @logger.info("Instance #{instance_id} found, node name is #{node}.")
+
+          webhook(instance_id)
+          chef(instance_id, node)
+          sensu(instance_id, node)
+
+          @logger.info("All done with #{node}, deleting message.")
+        else
+          @logger.info("Instance #{instance_id} not found, deleting message.")
+        end
+
         AwsCleaner.new.delete_message(id, @config)
+      else
+        @logger.info('Message not relevant, ignoring...')
       end
     end
 

config.yml.sample

@@ -1,3 +1,7 @@
+:general:
+  :lookup_type: 'chef'
+  :states:
+   - 'terminated'
 :aws:
   # only region is required when using iam which is recommended
   :access_key_id: 'AWS Access Key'
@@ -12,6 +16,7 @@
   :url: 'https://chef.example.com/organizations/example'
   :client: 'somebody'
   :key: '/path/to/client.pem'
+  :enable: true
 :hipchat:
   :api_token: 'Hipchat API token'
   :room: 'Notifications'

lib/aws-cleaner.rb

@@ -30,15 +30,15 @@ def self.client(config)
     # call the Chef API to get the node name of the instance
     def self.get_chef_node_name(instance_id, config)
       chef = client(config)
-      results = chef.search.query(:node, "ec2_instance_id:#{instance_id} OR chef_provisioning_reference_server_id:#{instance_id}")
+      results = chef.search.query(:node, "ec2_instance_id:#{instance_id[2..-1]} OR chef_provisioning_reference_server_id:#{instance_id[2..-1]}")
       return false if results.rows.empty?
       results.rows.first['name']
     end
 
     # call the Chef API to get the FQDN of the instance
     def self.get_chef_fqdn(instance_id, config)
       chef = client(config)
-      results = chef.search.query(:node, "ec2_instance_id:#{instance_id} OR chef_provisioning_reference_server_id:#{instance_id}")
+      results = chef.search.query(:node, "ec2_instance_id:#{instance_id[2..-1]} OR chef_provisioning_reference_server_id:#{instance_id[2..-1]}")
       return false if results.rows.empty?
       results.rows.first['automatic']['fqdn']
     end
@@ -58,6 +58,37 @@ def self.remove_from_chef(node_name, chef, config)
   end
 
   module Sensu
+    # call the Chef API to get the node name of the instance
+    def self.get_sensu_node_name(instance_id, config)
+      offset = 0
+      returned_clients = 100
+
+      while returned_clients == 100
+        response = RestClient::Request.execute(
+          url: "#{config[:sensu][:url]}/clients?limit=100&offset=#{offset}",
+          method: :get,
+          timeout: 5,
+          open_timeout: 5
+        )
+
+        clients = JSON.parse(response.body)
+        client = clients.find { |child| child['name'].include?(instance_id[2..-1]) }
+        client_name = if client.nil?
+                        false
+                      else
+                        client['name']
+                      end
+
+        break if client_name
+
+        returned_clients = clients.count
+        offset += 100
+      end
+
+      return false unless client_name
+      client_name
+    end
+
     # check if the node exists in Sensu
     def self.in_sensu?(node_name, config)
       RestClient::Request.execute(
@@ -102,9 +133,9 @@ def parse(body)
   end
 
   # return the instance_id of the terminated instance
-  def process_message(message_body)
-    return false if message_body['detail']['instance-id'].nil? &&
-                    message_body['detail']['state'] != 'terminated'
+  def process_message(message_body, config)
+    return false if message_body['detail']['instance-id'].nil? ||
+                    !config[:general][:states].include?(message_body['detail']['state'])
 
     instance_id = message_body['detail']['instance-id']
     instance_id