qurd 0.0.1

data/lib/hash.rb

@@ -0,0 +1,6 @@
+# rubocop:disable Documentation
+class Hash
+  def inspect
+    to_json
+  end
+end

data/lib/qurd.rb

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'bundler/setup'
+# monkey patch inspect
+require 'hash'
+# add method underscore
+require 'string'
+require 'fileutils'
+require 'singleton'
+require 'json'
+require 'yaml'
+require 'hashie'
+require 'cabin'
+require 'aws-sdk'
+require 'qurd/version'
+
+# Ain't that some bullshit
+module Qurd
+  autoload :Action, 'qurd/action'
+  autoload :Configuration, 'qurd/configuration'
+  autoload :Listener, 'qurd/listener'
+  autoload :Message, 'qurd/message'
+  autoload :Mixins, 'qurd/mixins'
+  autoload :Processor, 'qurd/processor'
+
+  extend Mixins::Configuration
+
+  class << self
+    def start(config = nil)
+      qurd_config.configure(config)
+      daemonize
+      listen_to_queues
+    end
+
+    private
+
+    def daemonize
+      IO.write(qurd_configuration.pid_file, $$)
+    end
+
+    # Iterate over listeners and their queues, listen for messages, and
+    # processing them
+    def listen_to_queues
+      threads = qurd_configuration.listeners.map(&:listen).flatten
+      $0 = "qurd [#{threads.count} threads]"
+      qurd_logger.debug("Threads #{threads}")
+      threads.each(&:join)
+    end
+  end
+end

data/lib/qurd/action.rb

@@ -0,0 +1,92 @@
+module Qurd
+  # Subclass and override {#launch}, {#launch_error}, {#terminate},
+  # {#terminate_error}, and {#test}, optionally override class method
+  # {#Qurd::Action.configure} and instance methods {#run_before} and
+  # {#run_after}
+  # @abstract
+  class Action
+    # Raised if the +message+ is invalid
+    class InvalidMessage < StandardError; end
+
+    autoload :Dummy, 'qurd/action/dummy'
+    autoload :Chef, 'qurd/action/chef'
+    autoload :Route53, 'qurd/action/route53'
+
+    extend Qurd::Mixins::Configuration
+    include Qurd::Mixins::Configuration
+
+    extend Qurd::Mixins::AwsClients
+    include Qurd::Mixins::AwsClients
+
+    # @!attribute context [r]
+    #   The logging context
+    #   @return [Cabin::Context]
+    # @!attribute message [r]
+    #   @return [Qurd::Message]
+    attr_reader :context, :message
+
+    # Optionally configure the plugin
+    # @param [String] _action optionally configure, based on the actions
+    # +launch+, +launch_error+, +terminate+, +terminate_error+, or +test+
+    def self.configure(_action)
+      qurd_logger.debug('Nothing to do')
+    end
+
+    # Run the plugin for a given {#Qurd::Message}
+    # @param [Qurd::Message] message message The message
+    # @raise [Qurd::Action::InvalidMessage] If the +message+ is not a
+    #   {#Qurd::Message}
+    # @see Qurd::Message
+    def initialize(message)
+      unless message.is_a?(Qurd::Message)
+        qurd_logger!("Message is not a Qurd::Message (#{message.class})",
+                     Qurd::Action::InvalidMessage)
+      end
+      @message = message
+      @context = message.context
+    end
+
+    # Aws region for the message
+    # @return [String]
+    def region
+      message.region
+    end
+
+    # Aws credentials for the message
+    # @return [Aws::Credentials]
+    def aws_credentials
+      message.aws_credentials
+    end
+
+    # Executed before the processor runs the plugins for an action
+    # @see Qurd::Processor
+    def run_before
+      qurd_logger.debug('Nothing to do')
+    end
+
+    # Run the plugin
+    def launch
+      qurd_logger!("Override the abstract method #{__method__}")
+    end
+    alias_method :launch_error, :launch
+    alias_method :terminate, :launch
+    alias_method :terminate_error, :launch
+    alias_method :test, :launch
+
+    # Executed after the processor runs the plugins for an action
+    # @see Qurd::Processor
+    def run_after
+      qurd_logger.debug('Nothing to do')
+    end
+
+    def inspect
+      format('<%s:%x instance_id:%s message_id:%s context:%s>',
+             self.class,
+             object_id,
+             message.instance_id,
+             message.message_id,
+             context.inspect
+      )
+    end
+  end
+end

data/lib/qurd/action/chef.rb

@@ -0,0 +1,128 @@
+require 'qurd/action'
+require 'chef'
+require 'chef/search/query'
+module Qurd
+  class Action
+    # Clean up chef client and node data
+    # @example Chef configuration
+    #   chef_configuration: "/etc/chef/some_knife_config.rb"
+    class Chef < Action
+      @configure_done = false
+
+      # Add a setter and getter for {#Qurd::Message} +chef_node+ +chef_client+
+      # and configure Chef using {#Qurd::Configuration} +chef_configuration+ or
+      # the default +/etc/chef/knife.rb+. If {#Qurd::Configuration} +log_file+
+      # is defined, Chef will log to it.
+      # @param [String] _action the name of the action being configured
+      def self.configure(_action)
+        return if @configure_done
+        configure_chef
+        Qurd::Message.add_accessor(:chef_node)
+        Qurd::Message.add_accessor(:chef_client)
+        @configure_done = true
+      end
+
+      # Parse Chef's configuration file, as defined in +qurd.yml+, set Chef's
+      # +log_level+, and Chef's +log_location+
+      def self.configure_chef
+        config = File.expand_path(qurd_configuration.chef_configuration ||
+                                  '/etc/chef/knife.rb')
+        qurd_logger.debug("Configuring Chef for using #{config}")
+        ::Chef::Config.from_file(config)
+        ::Chef::Config[:log_level] = qurd_configuration.log_level
+        if qurd_configuration.log_file_io
+          qurd_logger.debug('Setting chef log file to ' \
+                            "'#{qurd_configuration.log_file_io.path}'")
+          ::Chef::Config[:log_location] = qurd_configuration.log_file_io
+        end
+      end
+
+      # Find the node, using the +instance_id+ of the +message+
+      def run_before
+        find_chef_node
+        find_chef_client
+      end
+
+      # Delete the node, if the message did not fail other processing steps and
+      # dry_run is not true
+      # @see {#Qurd::Message}
+      def terminate
+        if message.failed?
+          qurd_logger.warn('Not deleting, message failed to process')
+        elsif qurd_configuration.dry_run
+          check_dry_run
+        else
+          qurd_logger.debug('Deleting')
+          message.chef_node.destroy unless message.chef_node.nil?
+          message.chef_client.destroy unless message.chef_client.nil?
+        end
+      end
+
+      # Respond to test actions
+      def test
+        qurd_logger.info('Test')
+      end
+
+      private
+
+      # Set the +message+ +chef_node+ and +context+ +chef_name+
+      # @see chef_search_node
+      def find_chef_node
+        node = chef_search_node
+        message.chef_node = node
+        message.context[:chef_name] = node.name
+        qurd_logger.debug('Chef node found')
+      rescue NoMethodError
+        qurd_logger.warn('Chef node not found')
+        message.chef_node = nil
+        message.context[:chef_name] = nil
+      end
+
+      # Set the +message+ +chef_client+ and +context+ +chef_client_name+
+      # @see chef_search_client
+      def find_chef_client
+        client = chef_search_client(message.chef_node.name)
+        message.chef_client = client
+        message.context[:chef_client_name] = client.name
+        qurd_logger.debug('Chef client found')
+      rescue NoMethodError
+        qurd_logger.warn('Chef client not found')
+        message.chef_client = nil
+        message.context[:chef_client_name] = nil
+      end
+
+      # Memoize a +Chef::Search::Query+
+      # @return [Chef::Search::Query]
+      def chef_search
+        @chef_search ||= ::Chef::Search::Query.new
+      end
+
+      # Search for a Chef node, based on the +instance_id+
+      # @return [Chef::Node|nil]
+      # @see instance_id
+      def chef_search_node
+        res = chef_search.search(:node, "instance_id:#{message.instance_id}")
+        res.last == 1 ? res[0][0] : nil
+      end
+
+      # Search for a Chef client, based on the +name+ passed, likely FQDN
+      # @param [String] name the client's name
+      # @return [Chef::ApiClient|nil]
+      def chef_search_client(name)
+        res = chef_search.search(:client, "name:#{name}")
+        res.last == 1 ? res[0][0] : nil
+      end
+
+      # Print log messages, based on object state
+      def check_dry_run
+        if !find_chef_node
+          qurd_logger.debug('Dry run; missing node')
+        elsif !find_chef_client
+          qurd_logger.debug('Dry run; missing client')
+        else
+          qurd_logger.debug('Dry run; would delete')
+        end
+      end
+    end
+  end
+end

data/lib/qurd/action/dummy.rb

@@ -0,0 +1,27 @@
+require 'qurd/action'
+module Qurd
+  class Action
+    # Example of a sub-classed {#Qurd::Action}
+    class Dummy < Action
+      def self.configure(action)
+        case action
+        when 'launch' then qurd_logger.debug('launch')
+        when 'launch_error' then qurd_logger.debug('launch_error')
+        when 'terminate' then qurd_logger.debug('terminate')
+        when 'terminate_error' then qurd_logger.debug('terminate_error')
+        when 'test' then qurd_logger.debug('test')
+        end
+      end
+
+      def launch
+        message.context[:dummy] = true
+        qurd_logger.debug('Qurd is debugging') if qurd_config.debug?
+        qurd_logger.info("Received message #{message.inspect}")
+      end
+      alias_method :launch_error, :launch
+      alias_method :terminate, :launch
+      alias_method :terminate_error, :launch
+      alias_method :test, :launch
+    end
+  end
+end

data/lib/qurd/action/route53.rb

@@ -0,0 +1,168 @@
+require 'qurd/action'
+module Qurd
+  class Action
+    # Clean up route53 records
+    # @example Route53 configuration
+    #   auto_scaling_queues:
+    #     staging:
+    #       credentials: foo
+    #       region: us-east-1
+    #       queues:
+    #         - "/QueueName/i"
+    #   route53:
+    #     staging:
+    #       hosted_zone: "staging.example.com."
+    class Route53 < Action
+      # Parent class for errors
+      class Errors < StandardError
+        # Hosted Zone not found
+        class ZoneNotFound < Errors; end
+        # Resource record set not found
+        class ResourceNotFound < Errors; end
+        # Hostname not available from EC2 and Chef
+        class HostNotFound < Errors; end
+      end
+
+      @configure_done = false
+      # Verify each +auto_scaling_queue+ has a corresponding +route53+ key and
+      # that each of those keys defines a +hosted_zone+
+      # @param [String] _action the action being configured
+      # @raise [RuntimeError] if any +auto_scaling_queues+ do not have correctly
+      #   configured +route53+ keys
+      def self.configure(_action)
+        return if @configure_done
+        check_configuration
+        @configure_done = true
+      end
+
+      # Delete the record, if the message did not fail other processing steps and
+      # dry_run is not true
+      # @see {#Qurd::Message}
+      def terminate
+        if message.failed?
+          qurd_logger.warn('Not deleting, message failed to process')
+        elsif qurd_configuration.dry_run
+          if !hosted_zone
+            qurd_logger.debug('Dry run; missing hosted_zone')
+          elsif !hostname
+            qurd_logger.debug('Dry run; missing hostname')
+          elsif !resource_record
+            qurd_logger.debug('Dry run; missing resource_record')
+          else
+            qurd_logger.debug('Dry run; would delete')
+          end
+        else
+          route53_delete
+        end
+      end
+
+      # Respond to test actions
+      def test
+        qurd_logger.info('Test')
+      end
+
+      private
+
+      def instance_name
+        message.instance_name
+      end
+
+      def route53
+        @route53 ||= aws_client(:Route53)
+      end
+
+      def qurd_route53
+        @config ||= qurd_configuration.route53[message.name]
+      end
+
+      def chef_node_name
+        return @chef_node_name if @chef_node_name
+        @chef_node_name = message.chef_node.name
+        qurd_logger.debug("Found chef name '#{@chef_node_name}'")
+        @chef_node_name
+      rescue NoMethodError
+        qurd_logger.debug('No node found')
+        nil
+      end
+
+      def hostname
+        @hostname = instance_name || chef_node_name
+        @hostname.sub!(/([^.])$/, '\1.')
+        qurd_logger.debug("Using host '#{@hostname}'")
+        @hostname
+      rescue NoMethodError
+        qurd_logger!('No instance or chef information',
+                     Errors::HostNotFound)
+      end
+
+      def resource_record(tries = nil)
+        @rr = aws_retryable(tries) do
+          route53.list_resource_record_sets(
+            hosted_zone_id: hosted_zone.id,
+            start_record_name: hostname,
+            max_items: 1
+          ).resource_record_sets.first
+        end
+        @rr || qurd_logger!('Resource record not found',
+                            Errors::ResourceNotFound)
+      end
+
+      def route53_delete(tries = nil)
+        qurd_logger.debug('Deleting')
+        aws_retryable(tries) do
+          route53.change_resource_record_sets(
+            hosted_zone_id: hosted_zone.id,
+            change_batch: {
+              changes: [
+                action: 'DELETE',
+                resource_record_set: {
+                  name: resource_record.name,
+                  type: resource_record.type,
+                  ttl: resource_record.ttl,
+                  resource_records: resource_record.resource_records
+                }
+              ]
+            }
+          )
+        end
+      rescue Qurd::Action::Route53::Errors => e
+        qurd_logger.error("Failed to delete: #{e}")
+        message.failed!(e)
+      end
+
+      def hosted_zone(tries = nil)
+        return @hosted_zone if @hosted_zone
+        name = qurd_route53.hosted_zone
+        qurd_logger.debug("Looking for zone '#{name}'")
+        aws_retryable(tries) do
+          @hosted_zone = route53.list_hosted_zones_by_name(
+            dns_name: name,
+            max_items: 1
+          ).hosted_zones.first
+          qurd_logger.debug "Found zone '#{@hosted_zone}'"
+        end
+        @hosted_zone || qurd_logger!("Zone not found: '#{name}'",
+                                     Errors::ZoneNotFound)
+      end
+
+      def self.config_valid?(name)
+        if qurd_configuration.route53.nil? || \
+           qurd_configuration.route53[name].nil? || \
+           qurd_configuration.route53[name].hosted_zone.nil?
+          false
+        else
+          true
+        end
+      end
+
+      def self.check_configuration
+        missing = []
+        qurd_configuration.auto_scaling_queues.each do |name, _monitor|
+          missing << name unless config_valid?(name)
+        end
+        m = missing.join(', ')
+        qurd_logger! "Missing configuration for route53: #{m}" unless m.empty?
+      end
+    end
+  end
+end