aws-cleaner 2.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7dbf7b40e9d34f325743db1b1a16b359fb7ff316
-  data.tar.gz: 1f4479e2e60ebb733785c73940e086694c0de5f2
+  metadata.gz: 634ceede119aecae922a17090cb5d18a18855e54
+  data.tar.gz: e1f7409e0ba5e6096bbc9d2667aba98333e47054
 SHA512:
-  metadata.gz: 6a8db0835e460feb45834b4c382af525ed56d786605ad21a58420234e2329776b87a42b11ae2025a141eb9d16bfc36e6c57d4c227fd02f499a5794f91075717e
-  data.tar.gz: ffb52f2e284ef0542dd04364713f2f47fe5e56d0646e5f580f74749508305d71ddaff34384a723ca5ca117bc2c3b8da3d5ce54b8305709caa8935eac100c5b23
+  metadata.gz: 0d03730f5c4a09e5ba56eb1dc4cebce0c3a27fe320a776a543faa30d70f11d85a06de04010a69537d7cd1712fbf26e4a61b96474271bd4627e7e32974c081ad4
+  data.tar.gz: 51409d6d97e5abb81c4bdc722f1ac7b7e0ff1d6a9915fe3ac1ff9ea356d8b4cb9ce9f5e76ebb5c95c5427747270ece2540fd6e2c73e107defd2599884e2df007

data/bin/aws_cleaner.rb

@@ -4,10 +4,11 @@
 # and remove the node from Chef and Sensu and send a notification
 # to Hipchat or Slack
 #
-# Copyright (c) 2015, 2016 Eric Heydrick
+# Copyright (c) 2015-2017 Eric Heydrick
 # Licensed under The MIT License
 #
 
+# ensure gems are present
 begin
   require 'json'
   require 'yaml'
@@ -21,6 +22,9 @@ rescue LoadError => e
   raise "Missing gems: #{e}"
 end
 
+# require our class
+require_relative '../lib/aws_cleaner/aws_cleaner.rb'
+
 def config(file)
   YAML.load(File.read(file))
 rescue StandardError => e
@@ -28,185 +32,21 @@ rescue StandardError => e
 end
 
 # get options
-opts = Trollop::options do
+opts = Trollop.options do
   opt :config, 'Path to config file', type: :string, default: 'config.yml'
 end
 
 @config = config(opts[:config])
 
-@sqs = Aws::SQS::Client.new(@config[:aws])
-
-@chef = ChefAPI::Connection.new(
-  endpoint: @config[:chef][:url],
-  client: @config[:chef][:client],
-  key: @config[:chef][:key]
-)
-
-# delete the message from SQS
-def delete_message(id)
-  delete = @sqs.delete_message(
-    queue_url: @config[:sqs][:queue],
-    receipt_handle: id
-  )
-  delete ? true : false
-end
-
-# return the body of the SQS message in JSON
-def parse(body)
-  JSON.parse(body)
-rescue JSON::ParserError
-  return false
-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'
-
-  instance_id = message_body['detail']['instance-id']
-  instance_id
-end
-
-# call the Chef API to get the node name of the instance
-def get_chef_node_name(instance_id)
-  results = @chef.search.query(:node, "ec2_instance_id:#{instance_id} OR chef_provisioning_reference_server_id:#{instance_id}")
-  if results.rows.size > 0
-    return results.rows.first['name']
-  else
-    return false
-  end
-end
-
-# call the Chef API to get the FQDN of the instance
-def get_chef_fqdn(instance_id)
-  results = @chef.search.query(:node, "ec2_instance_id:#{instance_id} OR chef_provisioning_reference_server_id:#{instance_id}")
-  if results.rows.size > 0
-    return results.rows.first['automatic']['fqdn']
-  else
-    return false
-  end
-end
-
-# check if the node exists in Sensu
-def in_sensu?(node_name)
-  begin
-    RestClient::Request.execute(url: "#{@config[:sensu][:url]}/clients/#{node_name}", method: :get, timeout: 5, open_timeout: 5)
-  rescue RestClient::ResourceNotFound
-    return false
-  rescue => e
-    puts "Sensu request failed: #{e}"
-    return false
-  else
-    return true
-  end
-end
-
-# call the Sensu API to remove the node
-def remove_from_sensu(node_name)
-  response = RestClient::Request.execute(url: "#{@config[:sensu][:url]}/clients/#{node_name}", method: :delete, timeout: 5, open_timeout: 5)
-  case response.code
-  when 202
-    notify_chat('Removed ' + node_name + ' from Sensu')
-    return true
-  else
-    notify_chat('Failed to remove ' + node_name + ' from Sensu')
-    return false
-  end
-end
-
-# call the Chef API to remove the node
-def remove_from_chef(node_name)
-  begin
-    client = @chef.clients.fetch(node_name)
-    client.destroy
-    node = @chef.nodes.fetch(node_name)
-    node.destroy
-  rescue => e
-    puts "Failed to remove chef node: #{e}"
-  else
-    notify_chat('Removed ' + node_name + ' from Chef')
-  end
-end
-
-# notify hipchat
-def notify_hipchat(msg)
-  hipchat = HipChat::Client.new(
-    @config[:hipchat][:api_token],
-    api_version: 'v2'
-  )
-  room = @config[:hipchat][:room]
-  hipchat[room].send('AWS Cleaner', msg)
-end
-
-# notify slack
-def notify_slack(msg)
-  slack = Slack::Poster.new(@config[:slack][:webhook_url])
-  slack.channel = @config[:slack][:channel]
-  slack.username = @config[:slack][:username] ||= 'aws-cleaner'
-  slack.icon_emoji = @config[:slack][:icon_emoji] ||= nil
-  slack.send_message(msg)
-end
-
-# generic chat notification method
-def notify_chat(msg)
-  if @config[:hipchat][:enable]
-    notify_hipchat(msg)
-  elsif @config[:slack][:enable]
-    notify_slack(msg)
-  end
-end
-
-# generate the URL for the webhook
-def generate_template(item, template_variable_method, template_variable_argument, template_variable)
-  begin
-    replacement = send(template_variable_method, eval(template_variable_argument))
-    item.gsub!(/{#{template_variable}}/, replacement)
-  rescue Exception => e
-    puts "Error generating template: #{e.message}"
-    return false
-  else
-    item
-  end
-end
+# @sqs = Aws::SQS::Client.new(@config[:aws])
+@sqs_client = AwsCleaner::SQS.client(@config)
 
-# call an HTTP endpoint
-def fire_webhook(config)
-  # generate templated URL
-  if config[:template_variables] && config[:url] =~ /\{\S+\}/
-    url = generate_template(
-      config[:url],
-      config[:template_variables][:method],
-      config[:template_variables][:argument],
-      config[:template_variables][:variable]
-    )
-    return false unless url
-  else
-    url = config[:url]
-  end
-
-  hook = { method: config[:method].to_sym, url: url }
-  r = RestClient::Request.execute(hook)
-  if r.code != 200
-    return false
-  else
-    # notify chat when webhook is successful
-    if config[:chat][:enable]
-      msg = generate_template(
-        config[:chat][:message],
-        config[:chat][:method],
-        config[:chat][:argument],
-        config[:chat][:variable]
-      )
-      notify_chat(msg)
-    end
-    return true
-  end
-end
+@chef_client = AwsCleaner::Chef.client(@config)
 
 # main loop
 loop do
   # get messages from SQS
-  messages = @sqs.receive_message(
+  messages = @sqs_client.receive_message(
     queue_url: @config[:sqs][:queue],
     max_number_of_messages: 10,
     visibility_timeout: 3
@@ -216,53 +56,52 @@ loop do
 
   messages.each_with_index do |message, index|
     puts "Looking at message number #{index}"
-    body = parse(message.body)
+    body = AwsCleaner.new.parse(message.body)
     id = message.receipt_handle
 
     unless body
-      delete_message(id)
+      AwsCleaner.new.delete_message(id, @config)
       next
     end
 
-    @instance_id = process_message(body)
+    @instance_id = AwsCleaner.new.process_message(body)
 
     if @instance_id
       if @config[:webhooks]
-        @config[:webhooks].each do |hook, config|
-          if fire_webhook(config)
+        @config[:webhooks].each do |hook, hook_config|
+          if AwsCleaner::Webhooks.fire_webhook(hook_config, @config, @instance_id)
             puts "Successfully ran webhook #{hook}"
           else
             puts "Failed to run webhook #{hook}"
           end
         end
-        delete_message(id)
+        AwsCleaner.new.delete_message(id, @config)
       end
 
-      chef_node = get_chef_node_name(@instance_id)
+      chef_node = AwsCleaner::Chef.get_chef_node_name(@instance_id, @config)
 
       if chef_node
-        if remove_from_chef(chef_node)
+        if AwsCleaner::Chef.remove_from_chef(chef_node, @chef_client, @config)
           puts "Removed #{chef_node} from Chef"
-          delete_message(id)
+          AwsCleaner.new.delete_message(id, @config)
         end
       else
         puts "Instance #{@instance_id} does not exist in Chef, deleting message"
-        delete_message(id)
+        AwsCleaner.new.delete_message(id, @config)
       end
 
-      if in_sensu?(chef_node)
-        if remove_from_sensu(chef_node)
+      if AwsCleaner::Sensu.in_sensu?(chef_node, @config)
+        if AwsCleaner::Sensu.remove_from_sensu(chef_node, @config)
           puts "Removed #{chef_node} from Sensu"
-          delete_message(id)
         else
           puts "Instance #{@instance_id} does not exist in Sensu, deleting message"
-          delete_message(id)
         end
+        AwsCleaner.new.delete_message(id, @config)
       end
 
     else
       puts 'Message not relevant, deleting'
-      delete_message(id)
+      AwsCleaner.new.delete_message(id, @config)
     end
   end
 

data/lib/aws_cleaner/aws_cleaner.rb

@@ -0,0 +1,197 @@
+# main aws_cleaner lib
+class AwsCleaner
+  # SQS related stuff
+  module SQS
+    # sqs connection
+    def self.client(config)
+      Aws::SQS::Client.new(config[:aws])
+    end
+  end
+
+  # delete the message from SQS
+  def delete_message(id, config)
+    delete = AwsCleaner::SQS.client(config).delete_message(
+      queue_url: config[:sqs][:queue],
+      receipt_handle: id
+    )
+    delete ? true : false
+  end
+
+  module Chef
+    # chef connection
+    def self.client(config)
+      ChefAPI::Connection.new(
+        endpoint: config[:chef][:url],
+        client: config[:chef][:client],
+        key: config[:chef][:key]
+      )
+    end
+
+    # 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}")
+      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}")
+      return false if results.rows.empty?
+      results.rows.first['automatic']['fqdn']
+    end
+
+    # call the Chef API to remove the node
+    def self.remove_from_chef(node_name, chef, config)
+      client = chef.clients.fetch(node_name)
+      client.destroy
+      node = chef.nodes.fetch(node_name)
+      node.destroy
+    rescue => e
+      puts "Failed to remove chef node: #{e}"
+    else
+      # puts "Removed #{node_name} from chef"
+      AwsCleaner::Notify.notify_chat('Removed ' + node_name + ' from Chef', config)
+    end
+  end
+
+  module Sensu
+    # check if the node exists in Sensu
+    def self.in_sensu?(node_name, config)
+      RestClient::Request.execute(
+        url: "#{config[:sensu][:url]}/clients/#{node_name}",
+        method: :get,
+        timeout: 5,
+        open_timeout: 5
+      )
+    rescue RestClient::ResourceNotFound
+      return false
+    rescue => e
+      puts "Sensu request failed: #{e}"
+      return false
+    else
+      return true
+    end
+
+    # call the Sensu API to remove the node
+    def self.remove_from_sensu(node_name, config)
+      response = RestClient::Request.execute(
+        url: "#{config[:sensu][:url]}/clients/#{node_name}",
+        method: :delete,
+        timeout: 5,
+        open_timeout: 5
+      )
+      case response.code
+      when 202
+        AwsCleaner::Notify.notify_chat('Removed ' + node_name + ' from Sensu', config)
+        return true
+      else
+        AwsCleaner::Notify.notify_chat('Failed to remove ' + node_name + ' from Sensu', config)
+        return false
+      end
+    end
+  end
+
+  # return the body of the SQS message in JSON
+  def parse(body)
+    JSON.parse(body)
+  rescue JSON::ParserError
+    return false
+  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'
+
+    instance_id = message_body['detail']['instance-id']
+    instance_id
+  end
+
+  module Notify
+    # notify hipchat
+    def self.notify_hipchat(msg, config)
+      hipchat = HipChat::Client.new(
+        config[:hipchat][:api_token],
+        api_version: 'v2'
+      )
+      room = config[:hipchat][:room]
+      hipchat[room].send('AWS Cleaner', msg)
+    end
+
+    # notify slack
+    def self.notify_slack(msg, config)
+      slack = Slack::Poster.new(config[:slack][:webhook_url])
+      slack.channel = config[:slack][:channel]
+      slack.username = config[:slack][:username] ||= 'aws-cleaner'
+      slack.icon_emoji = config[:slack][:icon_emoji] ||= nil
+      slack.send_message(msg)
+    end
+
+    # generic chat notification method
+    def self.notify_chat(msg, config)
+      if config[:hipchat][:enable]
+        notify_hipchat(msg, config)
+      elsif config[:slack][:enable]
+        notify_slack(msg, config)
+      end
+    end
+  end
+
+  module Webhooks
+    # generate the URL for the webhook
+    def self.generate_template(item, template_variable_method, template_variable, config, instance_id)
+      if template_variable_method == 'get_chef_fqdn'
+        replacement = AwsCleaner::Chef.get_chef_fqdn(instance_id, config)
+      elsif template_variable_method == 'get_chef_node_name'
+        replacement = AwsCleaner::Chef.get_chef_node_name(instance_id, config)
+      else
+        raise 'Unknown templating method'
+      end
+      item.gsub!(/{#{template_variable}}/, replacement)
+    rescue StandardError => e
+      puts "Error generating template: #{e.message}"
+      return false
+    else
+      item
+    end
+
+    # call an HTTP endpoint
+    def self.fire_webhook(hook_config, config, instance_id)
+      # generate templated URL
+      if hook_config[:template_variables] && hook_config[:url] =~ /\{\S+\}/
+        url = AwsCleaner::Webhooks.generate_template(
+          hook_config[:url],
+          hook_config[:template_variables][:method],
+          hook_config[:template_variables][:variable],
+          config,
+          instance_id
+        )
+        return false unless url
+      else
+        url = hook_config[:url]
+      end
+
+      hook = { method: hook_config[:method].to_sym, url: url }
+      r = RestClient::Request.execute(hook)
+      if r.code != 200
+        return false
+      else
+        # notify chat when webhook is successful
+        if hook_config[:chat][:enable]
+          msg = AwsCleaner::Webhooks.generate_template(
+            hook_config[:chat][:message],
+            hook_config[:chat][:method],
+            hook_config[:chat][:variable],
+            config,
+            instance_id
+          )
+          AwsCleaner::Notify.notify_chat(msg, config)
+        end
+        return true
+      end
+    end
+  end
+end

metadata

@@ -1,15 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: aws-cleaner
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Eric Heydrick
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-30 00:00:00.000000000 Z
+date: 2017-03-28 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.46.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.46.0
 - !ruby/object:Gem::Dependency
   name: aws-sdk-core
   requirement: !ruby/object:Gem::Requirement
@@ -58,14 +114,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: slack-poster
   requirement: !ruby/object:Gem::Requirement
@@ -102,6 +158,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bin/aws_cleaner.rb
+- lib/aws_cleaner/aws_cleaner.rb
 homepage: https://github.com/eheydrick/aws-cleaner
 licenses:
 - MIT
@@ -122,7 +179,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.6
 signing_key: 
 specification_version: 4
 summary: AWS Cleaner cleans up after EC2 instances are terminated