TrueCar-chef 0.10.0.beta.3

data/lib/chef/handler.rb

@@ -0,0 +1,206 @@
+#--
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2010 Opscode, 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/client'
+require 'forwardable'
+
+class Chef
+  # == Chef::Handler
+  # The base class for an Exception or Notification Handler. Create your own
+  # handler by subclassing Chef::Handler. When a Chef run fails with an
+  # uncaught Exception, Chef will set the +run_status+ on your handler and call
+  # +report+
+  #
+  # ===Example:
+  #
+  #   require 'net/smtp'
+  #
+  #   module MyOrg
+  #     class OhNoes < Chef::Handler
+  #
+  #       def report
+  #         # Create the email message
+  #         message  = "From: Your Name <your@mail.address>\n"
+  #         message << "To: Destination Address <someone@example.com>\n"
+  #         message << "Subject: Chef Run Failure\n"
+  #         message << "Date: #{Time.now.rfc2822}\n\n"
+  #
+  #         # The Node is available as +node+
+  #         message << "Chef run failed on #{node.name}\n"
+  #         # +run_status+ is a value object with all of the run status data
+  #         message << "#{run_status.formatted_exception}\n"
+  #         # Join the backtrace lines. Coerce to an array just in case.
+  #         message << Array(backtrace).join("\n")
+  #
+  #         # Send the email
+  #         Net::SMTP.start('your.smtp.server', 25) do |smtp|
+  #           smtp.send_message message, 'from@address', 'to@address'
+  #         end
+  #       end
+  #
+  #     end
+  #   end
+  #
+  class Handler
+
+    # The list of currently configured report handlers
+    def self.report_handlers
+      Array(Chef::Config[:report_handlers])
+    end
+
+    # Run the report handlers. This will usually be called by a notification
+    # from Chef::Client
+    def self.run_report_handlers(run_status)
+      Chef::Log.info("Running report handlers")
+      report_handlers.each do |handler|
+        handler.run_report_safely(run_status)
+      end
+      Chef::Log.info("Report handlers complete")
+    end
+
+    # Wire up a notification to run the report handlers if the chef run
+    # succeeds.
+    Chef::Client.when_run_completes_successfully do |run_status|
+      run_report_handlers(run_status)
+    end
+
+    # The list of currently configured exception handlers
+    def self.exception_handlers
+      Array(Chef::Config[:exception_handlers])
+    end
+
+    # Run the exception handlers. Usually will be called by a notification
+    # from Chef::Client when the run fails.
+    def self.run_exception_handlers(run_status)
+      Chef::Log.error("Running exception handlers")
+      exception_handlers.each do |handler|
+        handler.run_report_safely(run_status)
+      end
+      Chef::Log.error("Exception handlers complete")
+    end
+
+    # Wire up a notification to run the exception handlers if the chef run fails.
+    Chef::Client.when_run_fails do |run_status|
+      run_exception_handlers(run_status)
+    end
+
+    extend Forwardable
+
+    # The Chef::RunStatus object containing data about the Chef run.
+    attr_reader :run_status
+
+    ##
+    # :method: start_time
+    #
+    # The time the chef run started
+    def_delegator :@run_status, :start_time
+
+    ##
+    # :method: end_time
+    #
+    # The time the chef run ended
+    def_delegator :@run_status, :end_time
+
+    ##
+    # :method: elapsed_time
+    #
+    # The time elapsed between the start and finish of the chef run
+    def_delegator :@run_status, :elapsed_time
+
+    ##
+    # :method: run_context
+    #
+    # The Chef::RunContext object used by the chef run
+    def_delegator :@run_status, :run_context
+
+    ##
+    # :method: exception
+    #
+    # The uncaught Exception that terminated the chef run, or nil if the run
+    # completed successfully
+    def_delegator :@run_status, :exception
+
+    ##
+    # :method: backtrace
+    #
+    # The backtrace captured by the uncaught exception that terminated the chef
+    # run, or nil if the run completed successfully
+    def_delegator :@run_status, :backtrace
+
+    ##
+    # :method: node
+    #
+    # The Chef::Node for this client run
+    def_delegator :@run_status, :node
+
+    ##
+    # :method: all_resources
+    #
+    # An Array containing all resources in the chef run's resource_collection
+    def_delegator :@run_status, :all_resources
+
+    ##
+    # :method: updated_resources
+    #
+    # An Array containing all resources that were updated during the chef run
+    def_delegator :@run_status, :updated_resources
+
+    ##
+    # :method: success?
+    #
+    # Was the chef run successful? True if the chef run did not raise an
+    # uncaught exception
+    def_delegator :@run_status, :success?
+
+    ##
+    # :method: failed?
+    #
+    # Did the chef run fail? True if the chef run raised an uncaught exception
+    def_delegator :@run_status, :failed?
+
+    # The main entry point for report handling. Subclasses should override this
+    # method with their own report handling logic.
+    def report
+    end
+
+    # Runs the report handler, rescuing and logging any errors it may cause.
+    # This ensures that all handlers get a chance to run even if one fails.
+    # This method should not be overridden by subclasses unless you know what
+    # you're doing.
+    def run_report_safely(run_status)
+      run_report_unsafe(run_status)
+    rescue Exception => e
+      Chef::Log.error("Report handler #{self.class.name} raised #{e.inspect}")
+      Array(e.backtrace).each { |line| Chef::Log.error(line) }
+    ensure
+      @run_status = nil
+    end
+
+    # Runs the report handler without any error handling. This method should
+    # not be used directly except in testing.
+    def run_report_unsafe(run_status)
+      @run_status = run_status
+      report
+    end
+
+    # Return the Hash representation of the run_status
+    def data
+      @run_status.to_hash
+    end
+
+  end
+end

data/lib/chef/handler/json_file.rb

@@ -0,0 +1,58 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2010 Opscode, 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/handler'
+require 'chef/resource/directory'
+
+class Chef
+  class Handler
+    class JsonFile < ::Chef::Handler
+
+      attr_reader :config
+
+      def initialize(config={})
+        @config = config
+        @config[:path] ||= "/var/chef/reports"
+        @config
+      end
+
+      def report
+        if exception
+          Chef::Log.error("Creating JSON exception report")
+        else
+          Chef::Log.info("Creating JSON run report")
+        end
+
+        build_report_dir
+        savetime = Time.now.strftime("%Y%m%d%H%M%S")
+        File.open(File.join(config[:path], "chef-run-report-#{savetime}.json"), "w") do |file|
+          file.puts Chef::JSONCompat.to_json_pretty(data)
+        end
+      end
+
+      def build_report_dir
+        unless File.exists?(config[:path])
+          FileUtils.mkdir_p(config[:path])
+          File.chmod(00700, config[:path])
+        end
+      end
+
+
+    end
+  end
+end

data/lib/chef/index_queue.rb

@@ -0,0 +1,29 @@
+#
+# Author:: Daniel DeLeo (<dan@kallistec.com>)
+# Copyright:: Copyright (c) 2009 Daniel DeLeo
+# 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 "singleton"
+require "bunny"
+
+require "chef/index_queue/amqp_client"
+require "chef/index_queue/indexable"
+require "chef/index_queue/consumer"
+
+class Chef
+  module IndexQueue
+  end
+end

data/lib/chef/index_queue/amqp_client.rb

@@ -0,0 +1,116 @@
+#
+# Author:: Daniel DeLeo (<dan@kallistec.com>)
+# Copyright:: Copyright (c) 2009 Daniel DeLeo
+# 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.
+#
+
+class Chef
+  module IndexQueue
+    class AmqpClient
+      VNODES = 1024
+
+      include Singleton
+
+      def initialize
+        reset!
+      end
+
+      def reset!
+        @amqp_client && amqp_client.connected? && amqp_client.stop
+        @amqp_client = nil
+        @exchange = nil
+      end
+      
+      def stop
+        @amqp_client && @amqp_client.stop
+      end
+      
+      def amqp_client
+        unless @amqp_client
+          begin
+            @amqp_client = Bunny.new(amqp_opts)
+            Chef::Log.debug "Starting AMQP connection with client settings: #{@amqp_client.inspect}"
+            @amqp_client.start
+            @amqp_client.qos(:prefetch_count => 1)
+          rescue Bunny::ServerDownError => e
+            Chef::Log.fatal "Could not connect to rabbitmq. Is it running, reachable, and configured correctly?"
+            raise e
+          rescue Bunny::ProtocolError => e
+            Chef::Log.fatal "Connection to rabbitmq refused. Check your rabbitmq configuration and chef's amqp* settings"
+            raise e
+          end
+        end
+        @amqp_client
+      end
+
+      def exchange
+        @exchange ||= amqp_client.exchange("chef-indexer", :durable => true, :type => :fanout)
+      end
+      
+      def disconnected!
+        Chef::Log.error("Disconnected from the AMQP Broker (RabbitMQ)")
+        @amqp_client = nil
+        reset!
+      end
+
+      def queue_for_object(obj_id)
+        retries = 0
+        vnode_tag = obj_id_to_int(obj_id) % VNODES
+        begin
+          yield amqp_client.queue("vnode-#{vnode_tag}", :passive => false, :durable => true, :exclusive => false, :auto_delete => false)
+        rescue Bunny::ServerDownError, Bunny::ConnectionError, Errno::ECONNRESET
+          disconnected!
+          if (retries += 1) < 2
+            Chef::Log.info("Attempting to reconnect to the AMQP broker")
+            retry
+          else
+            Chef::Log.fatal("Could not re-connect to the AMQP broker, giving up")
+            raise
+          end
+        end
+      end
+
+      private
+
+      # Sometimes object ids are "proper" UUIDs, like "64bc00eb-120b-b6a2-ec0e-34fc90d151be"
+      # and sometimes they omit the dashes, like "64bc00eb120bb6a2ec0e34fc90d151be"
+      # UUIDTools uses different methods to parse the different styles.
+      def obj_id_to_int(obj_id)
+        UUIDTools::UUID.parse(obj_id).to_i
+      rescue ArgumentError
+        UUIDTools::UUID.parse_hexdigest(obj_id).to_i
+      end
+      
+      def durable_queue?
+        !!Chef::Config[:amqp_consumer_id]
+      end
+      
+      def consumer_id
+        Chef::Config[:amqp_consumer_id] || UUIDTools::UUID.random_create.to_s
+      end
+
+      def amqp_opts
+        { :spec   => '08',
+          :host   => Chef::Config[:amqp_host],
+          :port   => Chef::Config[:amqp_port],
+          :user   => Chef::Config[:amqp_user],
+          :pass   => Chef::Config[:amqp_pass],
+          :vhost  => Chef::Config[:amqp_vhost]}
+      end
+
+    end
+  end
+end
+

data/lib/chef/index_queue/consumer.rb

@@ -0,0 +1,76 @@
+#
+# Author:: Daniel DeLeo (<dan@kallistec.com>)
+# Copyright:: Copyright (c) 2009 Daniel DeLeo
+# 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.
+#
+
+class Chef
+  module IndexQueue
+    module Consumer
+      module ClassMethods
+        def expose(*methods)
+          @exposed_methods = Array(@exposed_methods)
+          @exposed_methods += methods
+        end
+        
+        def exposed_methods
+          @exposed_methods || []
+        end
+        
+        def whitelisted?(method_name)
+          exposed_methods.include?(method_name)
+        end
+      end
+      
+      def self.included(including_class)
+        including_class.send(:extend, ClassMethods)
+      end
+      
+      def run
+        Chef::Log.debug("Starting Index Queue Consumer")
+        AmqpClient.instance.queue # triggers connection setup
+        
+        begin
+          AmqpClient.instance.queue.subscribe(:ack => true, :timeout => false) do |message|
+            call_action_for_message(message)
+          end
+        rescue Bunny::ConnectionError, Errno::ECONNRESET, Bunny::ServerDownError
+          AmqpClient.instance.disconnected!
+          Chef::Log.warn "Connection to rabbitmq lost. attempting to reconnect"
+          sleep 1
+          retry
+        end
+      end
+      alias :start :run
+      
+      def call_action_for_message(message)
+        amqp_payload  = Chef::JSONCompat.from_json(message[:payload], :create_additions => false, :max_nesting => false)
+        action        = amqp_payload["action"].to_sym
+        app_payload   = amqp_payload["payload"]
+        assert_method_whitelisted(action)
+        send(action, app_payload)
+      end
+      
+      private
+      
+      def assert_method_whitelisted(method_name)
+        unless self.class.whitelisted?(method_name)
+          raise ArgumentError, "non-exposed method #{method_name} called via index queue"
+        end
+      end
+      
+    end
+  end
+end