chef 10.28.2-x86-mingw32

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

data/lib/chef/index_queue/indexable.rb

@@ -0,0 +1,109 @@
+#
+# Author:: Daniel DeLeo (<dan@kallistec.com>)
+# Author:: Seth Falcon (<seth@opscode.com>)
+# Copyright:: Copyright (c) 2009 Daniel DeLeo
+# 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/json_compat'
+
+class Chef
+  module IndexQueue
+    module Indexable
+      
+      module ClassMethods
+        
+        def index_object_type(explicit_type_name=nil)
+          @index_object_type = explicit_type_name.to_s if explicit_type_name
+          @index_object_type
+        end
+        
+        # Resets all metadata used for indexing to nil. Used for testing
+        def reset_index_metadata!
+          @index_object_type = nil
+        end
+        
+      end
+
+      def self.included(including_class)
+        including_class.send(:extend, ClassMethods)
+      end
+      
+      attr_accessor :index_id
+      
+      def index_object_type
+        self.class.index_object_type || Mixin::ConvertToClassName.snake_case_basename(self.class.name)
+      end
+      
+      def with_indexer_metadata(indexer_metadata={})
+        # changing input param symbol keys to strings, as the keys in hash that goes to solr are expected to be strings [cb]
+        # Ruby 1.9 hates you, cb [dan]
+        with_metadata = {}
+        indexer_metadata.each_key do |key|
+          with_metadata[key.to_s] = indexer_metadata[key]
+        end
+
+        with_metadata["type"]     ||= self.index_object_type
+        with_metadata["id"]       ||= self.index_id
+        with_metadata["database"] ||= Chef::Config[:couchdb_database]
+        with_metadata["item"]     ||= self.to_hash
+        with_metadata["enqueued_at"] ||= Time.now.utc.to_i
+
+        raise ArgumentError, "Type, Id, or Database missing in index operation: #{with_metadata.inspect}" if (with_metadata["id"].nil? or with_metadata["type"].nil?)
+        with_metadata        
+      end
+
+      def add_to_index(metadata={})
+       Chef::Log.debug("Pushing item to index queue for addition: #{self.with_indexer_metadata(metadata)}")
+       object_with_metadata = with_indexer_metadata(metadata)
+       obj_id = object_with_metadata["id"]
+       obj = {:action => :add, :payload => self.with_indexer_metadata(metadata)}
+
+       publish_object(obj_id, obj)
+      end
+
+      def delete_from_index(metadata={})
+        Chef::Log.debug("Pushing item to index queue for deletion: #{self.with_indexer_metadata(metadata)}")
+        object_with_metadata = with_indexer_metadata(metadata)
+        obj_id = object_with_metadata["id"]
+        obj = {:action => :delete, :payload => self.with_indexer_metadata(metadata)}
+
+        publish_object(obj_id, obj)
+      end
+
+      private
+
+      # Uses the publisher to update the object's queue. If
+      # Chef::Config[:persistent_queue] is true, the update is wrapped
+      # in a transaction.
+      def publish_object(object_id, object)
+        publisher = AmqpClient.instance
+        begin
+          publisher.amqp_client.tx_select if Chef::Config[:persistent_queue]
+          publisher.queue_for_object(object_id) do |queue|
+            queue.publish(Chef::JSONCompat.to_json(object), :persistent => Chef::Config[:persistent_queue])
+          end
+          publisher.amqp_client.tx_commit if Chef::Config[:persistent_queue]
+        rescue
+          publisher.amqp_client.tx_rollback if Chef::Config[:persistent_queue]
+          raise
+        end
+
+        true
+      end
+
+    end
+  end
+end

data/lib/chef/json_compat.rb

@@ -0,0 +1,149 @@
+#
+# Author:: Tim Hinderliter (<tim@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.
+
+# Wrapper class for interacting with JSON.
+
+require 'json'
+require 'yajl'
+
+class Chef
+  class JSONCompat
+    JSON_MAX_NESTING = 1000
+
+    JSON_CLASS = "json_class".freeze
+
+    CHEF_APICLIENT          = "Chef::ApiClient".freeze
+    CHEF_CHECKSUM           = "Chef::Checksum".freeze
+    CHEF_COOKBOOKVERSION    = "Chef::CookbookVersion".freeze
+    CHEF_DATABAG            = "Chef::DataBag".freeze
+    CHEF_DATABAGITEM        = "Chef::DataBagItem".freeze
+    CHEF_ENVIRONMENT        = "Chef::Environment".freeze
+    CHEF_NODE               = "Chef::Node".freeze
+    CHEF_ROLE               = "Chef::Role".freeze
+    CHEF_SANDBOX            = "Chef::Sandbox".freeze
+    CHEF_RESOURCE           = "Chef::Resource".freeze
+    CHEF_RESOURCECOLLECTION = "Chef::ResourceCollection".freeze
+    CHEF_WEBUIUSER          = "Chef::WebUIUser".freeze
+    CHEF_OPENIDREGISTRAION  = "Chef::OpenIDRegistration".freeze
+
+    class <<self
+      # See CHEF-1292/PL-538. Increase the max nesting for JSON, which defaults
+      # to 19, and isn't enough for some (for example, a Node within a Node)
+      # structures.
+      def opts_add_max_nesting(opts)
+        if opts.nil? || !opts.has_key?(:max_nesting)
+          opts = opts.nil? ? Hash.new : opts.clone
+          opts[:max_nesting] = JSON_MAX_NESTING
+        end
+        opts
+      end
+
+      # Just call the JSON gem's parse method with a modified :max_nesting field
+      def from_json(source, opts = {})
+        obj = ::Yajl::Parser.parse(source)
+
+        unless obj.kind_of?(Hash) || obj.kind_of?(Array)
+          raise JSON::ParserError, "Top level JSON object must be a Hash or Array (actual: #{obj.class})"
+        end
+
+        # The old default in the json gem (which we are mimicing because we
+        # sadly rely on this misfeature) is to "create additions" i.e., convert
+        # JSON objects into ruby objects. Explicit :create_additions => false
+        # is required to turn it off.
+        if opts[:create_additions].nil? || opts[:create_additions]
+          map_to_rb_obj(obj)
+        else
+          obj
+        end
+      rescue Yajl::ParseError => e
+        raise JSON::ParserError, e.message
+      end
+
+      # Look at an object that's a basic type (from json parse) and convert it
+      # to an instance of Chef classes if desired.
+      def map_to_rb_obj(json_obj)
+        res = case json_obj
+        when Hash
+          mapped_hash = map_hash_to_rb_obj(json_obj)
+          if json_obj.has_key?(JSON_CLASS) && (class_to_inflate = class_for_json_class(json_obj[JSON_CLASS]))
+            class_to_inflate.json_create(mapped_hash)
+          else
+            mapped_hash
+          end
+        when Array
+          json_obj.map {|e| map_to_rb_obj(e) }
+        else
+          json_obj
+        end
+        res
+      end
+
+      def map_hash_to_rb_obj(json_hash)
+        json_hash.each do |key, value|
+          json_hash[key] = map_to_rb_obj(value)
+        end
+        json_hash
+      end
+
+      def to_json(obj, opts = nil)
+        obj.to_json(opts_add_max_nesting(opts))
+      end
+
+      def to_json_pretty(obj, opts = nil)
+        ::JSON.pretty_generate(obj, opts_add_max_nesting(opts))
+      end
+
+
+      def class_for_json_class(json_class)
+        case json_class
+        when CHEF_APICLIENT
+          Chef::ApiClient
+        when CHEF_CHECKSUM
+          Chef::Checksum
+        when CHEF_COOKBOOKVERSION
+          Chef::CookbookVersion
+        when CHEF_DATABAG
+          Chef::DataBag
+        when CHEF_DATABAGITEM
+          Chef::DataBagItem
+        when CHEF_ENVIRONMENT
+          Chef::Environment
+        when CHEF_NODE
+          Chef::Node
+        when CHEF_ROLE
+          Chef::Role
+        when CHEF_SANDBOX
+          Chef::Sandbox
+        when CHEF_RESOURCE
+          Chef::Resource
+        when CHEF_RESOURCECOLLECTION
+          Chef::ResourceCollection
+        when CHEF_WEBUIUSER
+          Chef::WebUIUser
+        when CHEF_OPENIDREGISTRAION
+          Chef::OpenIDRegistration
+        when /^Chef::Resource/
+          Chef::Resource.find_subclass_by_name(json_class)
+        else
+          raise JSON::ParserError, "Unsupported `json_class` type '#{json_class}'"
+        end
+      end
+
+    end
+  end
+end
+

data/lib/chef/knife.rb

@@ -0,0 +1,537 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Brown (<cb@opscode.com>)
+# Copyright:: Copyright (c) 2009 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 'forwardable'
+require 'chef/version'
+require 'mixlib/cli'
+require 'chef/mixin/convert_to_class_name'
+require 'chef/mixin/path_sanity'
+require 'chef/knife/core/subcommand_loader'
+require 'chef/knife/core/ui'
+require 'chef/rest'
+require 'pp'
+
+class Chef
+  class Knife
+
+    Chef::REST::RESTRequest.user_agent = "Chef Knife#{Chef::REST::RESTRequest::UA_COMMON}"
+
+    include Mixlib::CLI
+    include Chef::Mixin::PathSanity
+    extend Chef::Mixin::ConvertToClassName
+    extend Forwardable
+
+    # Backwards Compat:
+    # Ideally, we should not vomit all of these methods into this base class;
+    # instead, they should be accessed by hitting the ui object directly.
+    def_delegator :@ui, :stdout
+    def_delegator :@ui, :stderr
+    def_delegator :@ui, :stdin
+    def_delegator :@ui, :msg
+    def_delegator :@ui, :ask_question
+    def_delegator :@ui, :pretty_print
+    def_delegator :@ui, :output
+    def_delegator :@ui, :format_list_for_display
+    def_delegator :@ui, :format_for_display
+    def_delegator :@ui, :format_cookbook_list_for_display
+    def_delegator :@ui, :edit_data
+    def_delegator :@ui, :edit_object
+    def_delegator :@ui, :confirm
+
+    attr_accessor :name_args
+    attr_accessor :ui
+
+    def self.ui
+      @ui ||= Chef::Knife::UI.new(STDOUT, STDERR, STDIN, {})
+    end
+
+    def self.msg(msg="")
+      ui.msg(msg)
+    end
+
+    def self.reset_subcommands!
+      @@subcommands = {}
+      @subcommands_by_category = nil
+    end
+
+    def self.inherited(subclass)
+      unless subclass.unnamed?
+        subcommands[subclass.snake_case_name] = subclass
+      end
+    end
+
+    # Explicitly set the category for the current command to +new_category+
+    # The category is normally determined from the first word of the command
+    # name, but some commands make more sense using two or more words
+    # ===Arguments
+    # new_category::: A String to set the category to (see examples)
+    # ===Examples:
+    # Data bag commands would be in the 'data' category by default. To put them
+    # in the 'data bag' category:
+    #   category('data bag')
+    def self.category(new_category)
+      @category = new_category
+    end
+
+    def self.subcommand_category
+      @category || snake_case_name.split('_').first unless unnamed?
+    end
+
+    def self.snake_case_name
+      convert_to_snake_case(name.split('::').last) unless unnamed?
+    end
+
+    def self.common_name
+      snake_case_name.split('_').join(' ')
+    end
+
+    # Does this class have a name? (Classes created via Class.new don't)
+    def self.unnamed?
+      name.nil? || name.empty?
+    end
+
+    def self.subcommand_loader
+      @subcommand_loader ||= Knife::SubcommandLoader.new(chef_config_dir)
+    end
+
+    def self.load_commands
+      @commands_loaded ||= subcommand_loader.load_commands
+    end
+
+    def self.subcommands
+      @@subcommands ||= {}
+    end
+
+    def self.subcommands_by_category
+      unless @subcommands_by_category
+        @subcommands_by_category = Hash.new { |hash, key| hash[key] = [] }
+        subcommands.each do |snake_cased, klass|
+          @subcommands_by_category[klass.subcommand_category] << snake_cased
+        end
+      end
+      @subcommands_by_category
+    end
+
+    # Print the list of subcommands knife knows about. If +preferred_category+
+    # is given, only subcommands in that category are shown
+    def self.list_commands(preferred_category=nil)
+      load_commands
+
+      category_desc = preferred_category ? preferred_category + " " : ''
+      msg "Available #{category_desc}subcommands: (for details, knife SUB-COMMAND --help)\n\n"
+
+      if preferred_category && subcommands_by_category.key?(preferred_category)
+        commands_to_show = {preferred_category => subcommands_by_category[preferred_category]}
+      else
+        commands_to_show = subcommands_by_category
+      end
+
+      commands_to_show.sort.each do |category, commands|
+        next if category =~ /deprecated/i
+        msg "** #{category.upcase} COMMANDS **"
+        commands.each do |command|
+          msg subcommands[command].banner if subcommands[command]
+        end
+        msg
+      end
+    end
+
+    # Run knife for the given +args+ (ARGV), adding +options+ to the list of
+    # CLI options that the subcommand knows how to handle.
+    # ===Arguments
+    # args::: usually ARGV
+    # options::: A Mixlib::CLI option parser hash. These +options+ are how
+    # subcommands know about global knife CLI options
+    def self.run(args, options={})
+      load_commands
+      subcommand_class = subcommand_class_from(args)
+      subcommand_class.options = options.merge!(subcommand_class.options)
+      subcommand_class.load_deps
+      instance = subcommand_class.new(args)
+      instance.configure_chef
+      instance.run_with_pretty_exceptions
+    end
+
+    def self.guess_category(args)
+      category_words = args.select {|arg| arg =~ /^(([[:alnum:]])[[:alnum:]\_\-]+)$/ }
+      category_words.map! {|w| w.split('-')}.flatten!
+      matching_category = nil
+      while (!matching_category) && (!category_words.empty?)
+        candidate_category = category_words.join(' ')
+        matching_category = candidate_category if subcommands_by_category.key?(candidate_category)
+        matching_category || category_words.pop
+      end
+      matching_category
+    end
+
+    def self.subcommand_class_from(args)
+      command_words = args.select {|arg| arg =~ /^(([[:alnum:]])[[:alnum:]\_\-]+)$/ }
+
+      subcommand_class = nil
+
+      while ( !subcommand_class ) && ( !command_words.empty? )
+        snake_case_class_name = command_words.join("_")
+        unless subcommand_class = subcommands[snake_case_class_name]
+          command_words.pop
+        end
+      end
+      # see if we got the command as e.g., knife node-list
+      subcommand_class ||= subcommands[args.first.gsub('-', '_')]
+      subcommand_class || subcommand_not_found!(args)
+    end
+
+    def self.deps(&block)
+      @dependency_loader = block
+    end
+
+    def self.load_deps
+      @dependency_loader && @dependency_loader.call
+    end
+
+    private
+
+    OFFICIAL_PLUGINS = %w[ec2 rackspace windows openstack terremark bluebox]
+
+    # :nodoc:
+    # Error out and print usage. probably becuase the arguments given by the
+    # user could not be resolved to a subcommand.
+    def self.subcommand_not_found!(args)
+      ui.fatal("Cannot find sub command for: '#{args.join(' ')}'")
+
+      if category_commands = guess_category(args)
+        list_commands(category_commands)
+      elsif missing_plugin = ( OFFICIAL_PLUGINS.find {|plugin| plugin == args[0]} )
+        ui.info("The #{missing_plugin} commands were moved to plugins in Chef 0.10")
+        ui.info("You can install the plugin with `(sudo) gem install knife-#{missing_plugin}")
+      else
+        list_commands
+      end
+
+      exit 10
+    end
+
+    @@chef_config_dir = nil
+
+    # search upward from current_dir until .chef directory is found
+    def self.chef_config_dir
+      if @@chef_config_dir.nil? # share this with subclasses
+        @@chef_config_dir = false
+        full_path = Dir.pwd.split(File::SEPARATOR)
+        (full_path.length - 1).downto(0) do |i|
+          candidate_directory = File.join(full_path[0..i] + [".chef" ])
+          if File.exist?(candidate_directory) && File.directory?(candidate_directory)
+            @@chef_config_dir = candidate_directory
+            break
+          end
+        end
+      end
+      @@chef_config_dir
+    end
+
+
+    public
+
+    # Create a new instance of the current class configured for the given
+    # arguments and options
+    def initialize(argv=[])
+      super() # having to call super in initialize is the most annoying anti-pattern :(
+      @ui = Chef::Knife::UI.new(STDOUT, STDERR, STDIN, config)
+
+      command_name_words = self.class.snake_case_name.split('_')
+
+      # Mixlib::CLI ignores the embedded name_args
+      @name_args = parse_options(argv)
+      @name_args.delete(command_name_words.join('-'))
+      @name_args.reject! { |name_arg| command_name_words.delete(name_arg) }
+
+      # knife node run_list add requires that we have extra logic to handle
+      # the case that command name words could be joined by an underscore :/
+      command_name_words = command_name_words.join('_')
+      @name_args.reject! { |name_arg| command_name_words == name_arg }
+
+      if config[:help]
+        msg opt_parser
+        exit 1
+      end
+
+      # copy Mixlib::CLI over so that it cab be configured in knife.rb
+      # config file
+      Chef::Config[:verbosity] = config[:verbosity]
+    end
+
+    def parse_options(args)
+      super
+    rescue OptionParser::InvalidOption => e
+      puts "Error: " + e.to_s
+      show_usage
+      exit(1)
+    end
+
+    def configure_chef
+      unless config[:config_file]
+        candidate_configs = []
+
+        # Look for $KNIFE_HOME/knife.rb (allow multiple knives config on same machine)
+        if ENV['KNIFE_HOME']
+          candidate_configs << File.join(ENV['KNIFE_HOME'], 'knife.rb')
+        end
+        # Look for $PWD/knife.rb
+        if Dir.pwd
+          candidate_configs << File.join(Dir.pwd, 'knife.rb')
+        end
+        # Look for $UPWARD/.chef/knife.rb
+        if self.class.chef_config_dir
+          candidate_configs << File.join(self.class.chef_config_dir, 'knife.rb')
+        end
+        # Look for $HOME/.chef/knife.rb
+        if ENV['HOME']
+          candidate_configs << File.join(ENV['HOME'], '.chef', 'knife.rb')
+        end
+
+        candidate_configs.each do | candidate_config |
+          candidate_config = File.expand_path(candidate_config)
+          if File.exist?(candidate_config)
+            config[:config_file] = candidate_config
+            break
+          end
+        end
+      end
+
+      # Don't try to load a knife.rb if it doesn't exist.
+      if config[:config_file]
+        read_config_file(config[:config_file])
+      else
+        # ...but do log a message if no config was found.
+        Chef::Config[:color] = config[:color]
+        ui.warn("No knife configuration file found")
+      end
+
+      Chef::Config[:color] = config[:color]
+
+      case Chef::Config[:verbosity]
+      when 0
+        Chef::Config[:log_level] = :error
+      when 1
+        Chef::Config[:log_level] = :info
+      else
+        Chef::Config[:log_level] = :debug
+      end
+
+      Chef::Config[:node_name]         = config[:node_name]       if config[:node_name]
+      Chef::Config[:client_key]        = config[:client_key]      if config[:client_key]
+      Chef::Config[:chef_server_url]   = config[:chef_server_url] if config[:chef_server_url]
+      Chef::Config[:environment]       = config[:environment]     if config[:environment]
+
+      # Expand a relative path from the config directory. Config from command
+      # line should already be expanded, and absolute paths will be unchanged.
+      if Chef::Config[:client_key] && config[:config_file]
+        Chef::Config[:client_key] = File.expand_path(Chef::Config[:client_key], File.dirname(config[:config_file]))
+      end
+
+      Mixlib::Log::Formatter.show_time = false
+      Chef::Log.init(Chef::Config[:log_location])
+      Chef::Log.level(Chef::Config[:log_level] || :error)
+
+      Chef::Log.debug("Using configuration from #{config[:config_file]}")
+      
+      if Chef::Config[:node_name] && Chef::Config[:node_name].bytesize > 90
+        # node names > 90 bytes only work with authentication protocol >= 1.1
+        # see discussion in config.rb.
+        Chef::Config[:authentication_protocol_version] = "1.1"
+      end
+    end
+
+    def read_config_file(file)
+      Chef::Config.from_file(file)
+    rescue SyntaxError => e
+      ui.error "You have invalid ruby syntax in your config file #{file}"
+      ui.info(ui.color(e.message, :red))
+      if file_line = e.message[/#{Regexp.escape(file)}:[\d]+/]
+        line = file_line[/:([\d]+)$/, 1].to_i
+        highlight_config_error(file, line)
+      end
+      exit 1
+    rescue Exception => e
+      ui.error "You have an error in your config file #{file}"
+      ui.info "#{e.class.name}: #{e.message}"
+      filtered_trace = e.backtrace.grep(/#{Regexp.escape(file)}/)
+      filtered_trace.each {|line| ui.msg("  " + ui.color(line, :red))}
+      if !filtered_trace.empty?
+        line_nr = filtered_trace.first[/#{Regexp.escape(file)}:([\d]+)/, 1]
+        highlight_config_error(file, line_nr.to_i)
+      end
+
+      exit 1
+    end
+
+    def highlight_config_error(file, line)
+      config_file_lines = []
+      IO.readlines(file).each_with_index {|l, i| config_file_lines << "#{(i + 1).to_s.rjust(3)}: #{l.chomp}"}
+      if line == 1
+        lines = config_file_lines[0..3]
+        lines[0] = ui.color(lines[0], :red)
+      else
+        lines = config_file_lines[Range.new(line - 2, line)]
+        lines[1] = ui.color(lines[1], :red)
+      end
+      ui.msg ""
+      ui.msg ui.color("     # #{file}", :white)
+      lines.each {|l| ui.msg(l)}
+      ui.msg ""
+    end
+
+    def show_usage
+      stdout.puts("USAGE: " + self.opt_parser.to_s)
+    end
+
+    def run_with_pretty_exceptions
+      unless self.respond_to?(:run)
+        ui.error "You need to add a #run method to your knife command before you can use it"
+      end
+      enforce_path_sanity
+      run
+    rescue Exception => e
+      raise if Chef::Config[:verbosity] == 2
+      humanize_exception(e)
+      exit 100
+    end
+
+    def humanize_exception(e)
+      case e
+      when SystemExit
+        raise # make sure exit passes through.
+      when Net::HTTPServerException, Net::HTTPFatalError
+        humanize_http_exception(e)
+      when Errno::ECONNREFUSED, Timeout::Error, Errno::ETIMEDOUT, SocketError
+        ui.error "Network Error: #{e.message}"
+        ui.info "Check your knife configuration and network settings"
+      when NameError, NoMethodError
+        ui.error "knife encountered an unexpected error"
+        ui.info  "This may be a bug in the '#{self.class.common_name}' knife command or plugin"
+        ui.info  "Please collect the output of this command with the `-VV` option before filing a bug report."
+        ui.info  "Exception: #{e.class.name}: #{e.message}"
+      when Chef::Exceptions::PrivateKeyMissing
+        ui.error "Your private key could not be loaded from #{api_key}"
+        ui.info  "Check your configuration file and ensure that your private key is readable"
+      else
+        ui.error "#{e.class.name}: #{e.message}"
+      end
+    end
+
+    def humanize_http_exception(e)
+      response = e.response
+      case response
+      when Net::HTTPUnauthorized
+        ui.error "Failed to authenticate to #{server_url} as #{username} with key #{api_key}"
+        ui.info "Response:  #{format_rest_error(response)}"
+      when Net::HTTPForbidden
+        ui.error "You authenticated successfully to #{server_url} as #{username} but you are not authorized for this action"
+        ui.info "Response:  #{format_rest_error(response)}"
+      when Net::HTTPBadRequest
+        ui.error "The data in your request was invalid"
+        ui.info "Response: #{format_rest_error(response)}"
+      when Net::HTTPNotFound
+        ui.error "The object you are looking for could not be found"
+        ui.info "Response: #{format_rest_error(response)}"
+      when Net::HTTPInternalServerError
+        ui.error "internal server error"
+        ui.info "Response: #{format_rest_error(response)}"
+      when Net::HTTPBadGateway
+        ui.error "bad gateway"
+        ui.info "Response: #{format_rest_error(response)}"
+      when Net::HTTPServiceUnavailable
+        ui.error "Service temporarily unavailable"
+        ui.info "Response: #{format_rest_error(response)}"
+      else
+        ui.error response.message
+        ui.info "Response: #{format_rest_error(response)}"
+      end
+    end
+
+    def username
+      Chef::Config[:node_name]
+    end
+
+    def api_key
+      Chef::Config[:client_key]
+    end
+
+    # Parses JSON from the error response sent by Chef Server and returns the
+    # error message
+    #--
+    # TODO: this code belongs in Chef::REST
+    def format_rest_error(response)
+      Array(Chef::JSONCompat.from_json(response.body)["error"]).join('; ')
+    rescue Exception
+      response.body
+    end
+
+    def create_object(object, pretty_name=nil, &block)
+      output = edit_data(object)
+
+      if Kernel.block_given?
+        output = block.call(output)
+      else
+        output.save
+      end
+
+      pretty_name ||= output
+
+      self.msg("Created #{pretty_name}")
+
+      output(output) if config[:print_after]
+    end
+
+    def delete_object(klass, name, delete_name=nil, &block)
+      confirm("Do you really want to delete #{name}")
+
+      if Kernel.block_given?
+        object = block.call
+      else
+        object = klass.load(name)
+        object.destroy
+      end
+
+      output(format_for_display(object)) if config[:print_after]
+
+      obj_name = delete_name ? "#{delete_name}[#{name}]" : object
+      self.msg("Deleted #{obj_name}")
+    end
+
+    def rest
+      @rest ||= begin
+        require 'chef/rest'
+        Chef::REST.new(Chef::Config[:chef_server_url])
+      end
+    end
+
+    def noauth_rest
+      @rest ||= begin
+        require 'chef/rest'
+        Chef::REST.new(Chef::Config[:chef_server_url], false, false)
+      end
+    end
+
+    def server_url
+      Chef::Config[:chef_server_url]
+    end
+
+  end
+end
+