chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

data/lib/chef/run_list.rb

@@ -155,8 +155,6 @@ class Chef
         RunListExpansionFromDisk.new(environment, @run_list_items)
       when 'server'
         RunListExpansionFromAPI.new(environment, @run_list_items, opts[:rest])
-      when 'couchdb'
-        RunListExpansionFromCouchDB.new(environment, @run_list_items, opts[:couchdb])
       end
     end
 

data/lib/chef/run_list/run_list_expansion.rb

@@ -21,7 +21,6 @@ require 'chef/mash'
 require 'chef/mixin/deep_merge'
 
 require 'chef/role'
-require 'chef/couchdb'
 require 'chef/rest'
 
 class Chef
@@ -174,7 +173,7 @@ class Chef
     class RunListExpansionFromAPI < RunListExpansion
 
       def rest
-        @rest ||= (source || Chef::REST.new(Chef::Config[:role_url]))
+        @rest ||= (source || Chef::REST.new(Chef::Config[:chef_server_url]))
       end
 
       def fetch_role(name, included_by)
@@ -188,19 +187,5 @@ class Chef
       end
     end
 
-    # Expand a run list from couchdb. Used in chef-server-api
-    class RunListExpansionFromCouchDB < RunListExpansion
-
-      def couchdb
-        source
-      end
-
-      def fetch_role(name, included_by)
-        Chef::Role.cdb_load(name, couchdb)
-      rescue Chef::Exceptions::CouchDBNotFound
-        role_not_found(name, included_by)
-      end
-
-    end
   end
 end

data/lib/chef/run_lock.rb

@@ -0,0 +1,96 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2012 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/mixin/create_path'
+require 'fcntl'
+
+class Chef
+
+  # == Chef::RunLock
+  # Provides an interface for acquiring and releasing a system-wide exclusive
+  # lock.
+  #
+  # Used by Chef::Client to ensure only one instance of chef-client (or solo)
+  # is modifying the system at a time.
+  class RunLock
+    include Chef::Mixin::CreatePath
+
+    attr_reader :runlock
+    attr_reader :runlock_file
+
+    # Create a new instance of RunLock
+    # === Arguments
+    # * config::: This will generally be the `Chef::Config`, but any Hash-like
+    #   object with Symbol keys will work. See 'Parameters' section.
+    # === Parameters/Config
+    # * :lockfile::: if set, this will be used as the full path to the lockfile.
+    # * :file_cache_path::: if `:lockfile` is not set, the lock file will be
+    #   named "chef-client-running.pid" and be placed in the directory given by
+    #   `:file_cache_path`
+    def initialize(config)
+      @runlock_file = config[:lockfile] || "#{config[:file_cache_path]}/chef-client-running.pid"
+      @runlock = nil
+    end
+
+    # Acquire the system-wide lock. Will block indefinitely if another process
+    # already has the lock.
+    #
+    # Each call to acquire should have a corresponding call to #release.
+    #
+    # The implementation is based on File#flock (see also: flock(2)).
+    def acquire
+      # ensure the runlock_file path exists
+      create_path(File.dirname(runlock_file))
+      @runlock = File.open(runlock_file,'w+')
+      # if we support FD_CLOEXEC (linux, !windows), then use it.
+      # NB: ruby-2.0.0-p195 sets FD_CLOEXEC by default, but not ruby-1.8.7/1.9.3
+      if Fcntl.const_defined?('F_SETFD') && Fcntl.const_defined?('FD_CLOEXEC')
+        runlock.fcntl(Fcntl::F_SETFD, runlock.fcntl(Fcntl::F_GETFD, 0) | Fcntl::FD_CLOEXEC)
+      end
+      unless runlock.flock(File::LOCK_EX|File::LOCK_NB)
+        # Another chef client running...
+        runpid = runlock.read.strip.chomp
+        Chef::Log.warn("Chef client #{runpid} is running, will wait for it to finish and then run.")
+        runlock.flock(File::LOCK_EX)
+      end
+      # We grabbed the run lock.  Save the pid.
+      runlock.truncate(0)
+      runlock.rewind # truncate doesn't reset position to 0.
+      runlock.write(Process.pid.to_s)
+    end
+
+    # Release the system-wide lock.
+    def release
+      if runlock
+        runlock.flock(File::LOCK_UN)
+        runlock.close
+        # Don't unlink the pid file, if another chef-client was waiting, it
+        # won't be recreated. Better to leave a "dead" pid file than not have
+        # it available if you need to break the lock.
+        reset
+      end
+    end
+
+    private
+
+    def reset
+      @runlock = nil
+    end
+
+  end
+end
+

data/lib/chef/runner.rb

@@ -18,10 +18,10 @@
 # limitations under the License.
 #
 
+require 'chef/exceptions'
 require 'chef/mixin/params_validate'
 require 'chef/node'
 require 'chef/resource_collection'
-require 'chef/platform'
 
 class Chef
   # == Chef::Runner
@@ -81,15 +81,37 @@ class Chef
         Array(resource.action).each {|action| run_action(resource, action)}
       end
 
-      # Run all our :delayed actions
+    rescue Exception => e
+      Chef::Log.info "Running queued delayed notifications before re-raising exception"
+      run_delayed_notifications(e)
+    else
+      run_delayed_notifications(nil)
+      true
+    end
+
+    private
+
+    # Run all our :delayed actions
+    def run_delayed_notifications(error=nil)
+      collected_failures = Exceptions::MultipleFailures.new
+      collected_failures.client_run_failure(error) unless error.nil?
       delayed_actions.each do |notification|
-        Chef::Log.info( "#{notification.notifying_resource} sending #{notification.action}"\
-                        " action to #{notification.resource} (delayed)")
-        # Struct of resource/action to call
-        run_action(notification.resource, notification.action, :delayed)
+        result = run_delayed_notification(notification)
+        if result.kind_of?(Exception)
+          collected_failures.notification_failure(result)
+        end
       end
+      collected_failures.raise!
+    end
 
+    def run_delayed_notification(notification)
+      Chef::Log.info( "#{notification.notifying_resource} sending #{notification.action}"\
+                      " action to #{notification.resource} (delayed)")
+      # Struct of resource/action to call
+      run_action(notification.resource, notification.action, :delayed)
       true
+    rescue Exception => e
+      e
     end
   end
 end

data/lib/chef/sandbox.rb

@@ -1,153 +1,20 @@
-#
-# 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.
-
-require 'chef/log'
-require 'uuidtools'
-
 class Chef
   class Sandbox
-    attr_accessor :is_completed, :create_time
-    alias_method :is_completed?, :is_completed
-    attr_reader :guid
-    
-    alias :name :guid
-    
-    attr_accessor :couchdb, :couchdb_id, :couchdb_rev
-
-    # list of checksum ids
-    attr_accessor :checksums
-
-    DESIGN_DOCUMENT = {
-      "version" => 1,
-      "language" => "javascript",
-      "views" => {
-        "all" => {
-          "map" => <<-EOJS
-          function(doc) { 
-            if (doc.chef_type == "sandbox") {
-              emit(doc.guid, doc);
-            }
-          }
-          EOJS
-        },
-        "all_id" => {
-          "map" => <<-EOJS
-          function(doc) {
-            if (doc.chef_type == "sandbox") {
-              emit(doc.guid, doc.guid);
-            }
-          }
-          EOJS
-        },
-        "all_incomplete" => {
-          "map" => <<-EOJS
-          function(doc) {
-            if (doc.chef_type == "sandbox" && !doc.is_completed) {
-              emit(doc.guid, doc.guid);
-            }
-          }
-          EOJS
-        },
-        "all_completed" => {
-          "map" => <<-EOJS
-          function(doc) {
-            if (doc.chef_type == "sandbox" && doc.is_completed) {
-              emit(doc.guid, doc.guid);
-            }
-          }
-          EOJS
-        },
-      }
-    }
-    
-    # Creates a new Chef::Sandbox object.  
+    # I DO NOTHING!!
+
+    # So, the reason we have a completely empty class here is so that
+    # Chef 11 clients do not choke when interacting with Chef 10
+    # servers.  The original Chef::Sandbox class (that actually did
+    # things) has been removed since its functionality is no longer
+    # needed for Chef 11.  However, since we still use the JSON gem
+    # and make use of its "auto-inflation" of classes (driven by the
+    # contents of the 'json_class' key in all of our JSON), any
+    # sandbox responses from a Chef 10 server to a Chef 11 client
+    # would cause knife to crash.  The JSON gem would attempt to
+    # auto-inflate based on a "json_class": "Chef::Sandbox" hash
+    # entry, but would not be able to find a Chef::Sandbox class!
     #
-    # === Returns
-    # object<Chef::Sandbox>:: Duh. :)
-    def initialize(guid=nil, couchdb=nil)
-      @guid = guid || UUIDTools::UUID.random_create.to_s.gsub(/\-/,'').downcase
-      @is_completed = false
-      @create_time = Time.now.iso8601
-      @checksums = Array.new
-    end
-
-    def include?(checksum)
-      @checksums.include?(checksum)
-    end
-
-    alias :member? :include?
-
-    def to_json(*a)
-      result = {
-        :guid => guid,
-        :name => name,   # same as guid, used for id_map
-        :checksums => checksums,
-        :create_time => create_time,
-        :is_completed => is_completed,
-        :json_class => self.class.name,
-        :chef_type => 'sandbox'
-      }
-      result["_rev"] = @couchdb_rev if @couchdb_rev
-      result.to_json(*a)
-    end
-
-    def self.json_create(o)
-      sandbox = new(o['guid'])
-      sandbox.checksums = o['checksums']
-      sandbox.create_time = o['create_time']
-      sandbox.is_completed = o['is_completed']
-      if o.has_key?('_rev')
-        sandbox.couchdb_rev = o["_rev"]
-        o.delete("_rev")
-      end
-      if o.has_key?("_id")
-        sandbox.couchdb_id = o["_id"]
-        #sandbox.index_id = sandbox.couchdb_id
-        o.delete("_id")
-      end
-      sandbox
-    end
-
-    ##
-    # Couchdb
-    ##
-    
-    def self.create_design_document(couchdb=nil)
-      (couchdb || Chef::CouchDB.new).create_design_document("sandboxes", DESIGN_DOCUMENT)
-    end
-    
-    def self.cdb_list(inflate=false, couchdb=nil)
-      rs = (couchdb || Chef::CouchDB.new).list("sandboxes", inflate)
-      lookup = (inflate ? "value" : "key")
-      rs["rows"].collect { |r| r[lookup] }            
-    end
-
-    def self.cdb_load(guid, couchdb=nil)
-      # Probably want to look for a view here at some point
-      (couchdb || Chef::CouchDB.new).load("sandbox", guid)
-    end
-
-    def cdb_destroy
-      (couchdb || Chef::CouchDB.new).delete("sandbox", guid, @couchdb_rev)
-    end
-
-    def cdb_save(couchdb=nil)
-      @couchdb_rev = (couchdb || Chef::CouchDB.new).store("sandbox", guid, self)["rev"]
-    end
-
+    # This is a workaround until such time as we can completely remove
+    # the reliance on the "json_class" field.
   end
 end

data/lib/chef/scan_access_control.rb

@@ -118,10 +118,8 @@ class Chef
 
     def current_mode
       case new_resource.mode
-      when String, nil
-        (stat.mode & 007777).to_s(8)
-      when Integer
-        stat.mode & 007777
+      when String, Integer, nil
+        "0#{(stat.mode & 07777).to_s(8)}"
       else
         Chef::Log.error("The `mode` parameter of the #@new_resource resource is set to an invalid value (#{new_resource.mode.inspect})")
         raise ArgumentError, "Invalid value #{new_resource.mode.inspect} for `mode` on resource #@new_resource"
@@ -129,7 +127,12 @@ class Chef
     end
 
     def stat
-      @stat ||= @new_resource.instance_of?(Chef::Resource::Link) ? ::File.lstat(@new_resource.path) : ::File.stat(@new_resource.path)
+      @stat ||= if @new_resource.instance_of?(Chef::Resource::Link)
+        ::File.lstat(@new_resource.path)
+      else
+        realpath = ::File.realpath(@new_resource.path)
+        ::File.stat(realpath)
+      end
     end
   end
 end

data/lib/chef/search/query.rb

@@ -31,7 +31,7 @@ class Chef
       attr_accessor :rest
 
       def initialize(url=nil)
-        @rest = Chef::REST.new(url ||Chef::Config[:search_url])
+        @rest = Chef::REST.new(url ||Chef::Config[:chef_server_url])
       end
 
       # Search Solr for objects of a given type, for a given query. If you give
@@ -53,7 +53,7 @@ class Chef
       end
 
       def list_indexes
-        response = @rest.get_rest("search")
+        @rest.get_rest("search")
       end
 
       private

data/lib/chef/shef/ext.rb

@@ -1,6 +1,6 @@
 #--
-# Author:: Daniel DeLeo (<dan@kallistec.com>)
-# Copyright:: Copyright (c) 2009 Daniel DeLeo
+# Author:: Joshua Timberman (<joshua@opscode.com>)
+# Copyright:: Copyright (c) 2012 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,576 +16,4 @@
 # limitations under the License.
 #
 
-require 'tempfile'
-require 'chef/recipe'
-require 'fileutils'
-require 'chef/version'
-require 'chef/shef/shef_session'
-require 'chef/shef/model_wrapper'
-require 'chef/shef/shef_rest'
-require 'chef/json_compat'
-
-module Shef
-  module Extensions
-
-    Help = Struct.new(:cmd, :desc, :explanation)
-
-    # Extensions to be included in every 'main' object in shef. These objects
-    # are extended with this module.
-    module ObjectCoreExtensions
-
-      def ensure_session_select_defined
-        # irb breaks if you prematurely define IRB::JobMangager
-        # so these methods need to be defined at the latest possible time.
-        unless jobs.respond_to?(:select_session_by_context)
-          def jobs.select_session_by_context(&block)
-            @jobs.select { |job| block.call(job[1].context.main)}
-          end
-        end
-
-        unless jobs.respond_to?(:session_select)
-          def jobs.select_shef_session(target_context)
-            session = if target_context.kind_of?(Class)
-              select_session_by_context { |main| main.kind_of?(target_context) }
-            else
-              select_session_by_context { |main| main.equal?(target_context) }
-            end
-            Array(session.first)[1]
-          end
-        end
-      end
-
-      def find_or_create_session_for(context_obj)
-        ensure_session_select_defined
-        if subsession = jobs.select_shef_session(context_obj)
-          jobs.switch(subsession)
-        else
-          irb(context_obj)
-        end
-      end
-
-      def help_banner
-        banner = []
-        banner << ""
-        banner << "Shef Help"
-        banner << "".ljust(80, "=")
-        banner << "| " + "Command".ljust(25) + "| " + "Description"
-        banner << "".ljust(80, "=")
-
-        self.all_help_descriptions.each do |help_text|
-          banner << "| " + help_text.cmd.ljust(25) + "| " + help_text.desc
-        end
-        banner << "".ljust(80, "=")
-        banner << "\n"
-        banner << "Use help(:command) to get detailed help with individual commands"
-        banner << "\n"
-        banner.join("\n")
-      end
-
-      def explain_command(method_name)
-        help = self.all_help_descriptions.find { |h| h.cmd.to_s == method_name.to_s }
-        if help
-          puts ""
-          puts "Command: #{method_name}"
-          puts "".ljust(80, "=")
-          puts help.explanation || help.desc
-          puts "".ljust(80, "=")
-          puts ""
-        else
-          puts ""
-          puts "command #{method_name} not found or no help available"
-          puts ""
-        end
-      end
-
-      # helpfully returns +:on+ so we can have sugary syntax like `tracing on'
-      def on
-        :on
-      end
-
-      # returns +:off+ so you can just do `tracing off'
-      def off
-        :off
-      end
-
-      def help_descriptions
-        @help_descriptions ||= []
-      end
-
-      def all_help_descriptions
-        help_descriptions
-      end
-
-      def desc(help_text)
-        @desc = help_text
-      end
-
-      def explain(explain_text)
-        @explain = explain_text
-      end
-
-      def subcommands(subcommand_help={})
-        @subcommand_help = subcommand_help
-      end
-
-      def singleton_method_added(mname)
-        if @desc
-          help_descriptions << Help.new(mname.to_s, @desc.to_s, @explain)
-          @desc, @explain = nil, nil
-        end
-        if @subcommand_help
-          @subcommand_help.each do |subcommand, text|
-            help_descriptions << Help.new("#{mname}.#{subcommand}", text.to_s, nil)
-          end
-        end
-        @subcommand_help = {}
-      end
-
-    end
-
-    module String
-      def on_off_to_bool
-        case self
-        when "on"
-          true
-        when "off"
-          false
-        else
-          self
-        end
-      end
-    end
-
-    module Symbol
-      def on_off_to_bool
-        self.to_s.on_off_to_bool
-      end
-    end
-
-    module TrueClass
-      def to_on_off_str
-        "on"
-      end
-
-      def on_off_to_bool
-        self
-      end
-    end
-
-    module FalseClass
-      def to_on_off_str
-        "off"
-      end
-
-      def on_off_to_bool
-        self
-      end
-    end
-
-    # Methods that have associated help text need to be dynamically added
-    # to the main irb objects, so we define them in a proc and later
-    # instance_eval the proc in the object.
-    ObjectUIExtensions = Proc.new do
-      extend Shef::Extensions::ObjectCoreExtensions
-
-      desc "prints this help message"
-      explain(<<-E)
-## SUMMARY ##
-  When called with no argument, +help+ prints a table of all shef commands. When
-  called with an argument COMMAND, +help+ prints a detailed explanation of the
-  command if available, or the description if no explanation is available.
-E
-      def help(commmand=nil)
-        if commmand
-          explain_command(commmand)
-        else
-          puts help_banner
-        end
-        :ucanhaz_halp
-      end
-      alias :halp :help
-
-      desc "prints information about chef"
-      def version
-        puts  "This is shef, the Chef shell.\n" +
-              " Chef Version: #{::Chef::VERSION}\n" +
-              " http://www.opscode.com/chef\n" +
-              " http://wiki.opscode.com/display/chef/Home"
-        :ucanhaz_automation
-      end
-      alias :shef :version
-
-      desc "switch to recipe mode"
-      def recipe
-        find_or_create_session_for Shef.session.recipe
-        :recipe
-      end
-
-      desc "switch to attributes mode"
-      def attributes
-        find_or_create_session_for Shef.session.node
-        :attributes
-      end
-
-      desc "run chef using the current recipe"
-      def run_chef
-        Chef::Log.level = :debug
-        session = Shef.session
-        runrun = Chef::Runner.new(session.run_context).converge
-        Chef::Log.level = :info
-        runrun
-      end
-
-      desc "returns an object to control a paused chef run"
-      subcommands :resume       => "resume the chef run",
-                  :step         => "run only the next resource",
-                  :skip_back    => "move back in the run list",
-                  :skip_forward => "move forward in the run list"
-      def chef_run
-        Shef.session.resource_collection.iterator
-      end
-
-      desc "resets the current recipe"
-      def reset
-        Shef.session.reset!
-      end
-
-      desc "assume the identity of another node."
-      def become_node(node_name)
-        Shef::DoppelGangerSession.instance.assume_identity(node_name)
-        :doppelganger
-      end
-      alias :doppelganger :become_node
-
-      desc "turns printout of return values on or off"
-      def echo(on_or_off)
-        conf.echo = on_or_off.on_off_to_bool
-      end
-
-      desc "says if echo is on or off"
-      def echo?
-        puts "echo is #{conf.echo.to_on_off_str}"
-      end
-
-      desc "turns on or off tracing of execution. *verbose*"
-      def tracing(on_or_off)
-        conf.use_tracer = on_or_off.on_off_to_bool
-        tracing?
-      end
-      alias :trace :tracing
-
-      desc "says if tracing is on or off"
-      def tracing?
-        puts "tracing is #{conf.use_tracer.to_on_off_str}"
-      end
-      alias :trace? :tracing?
-
-      desc "simple ls style command"
-      def ls(directory)
-        Dir.entries(directory)
-      end
-    end
-
-    MainContextExtensions = Proc.new do
-      desc "returns the current node (i.e., this host)"
-      def node
-        Shef.session.node
-      end
-
-      desc "pretty print the node's attributes"
-      def ohai(key=nil)
-        pp(key ? node.attribute[key] : node.attribute)
-      end
-    end
-
-    RESTApiExtensions = Proc.new do
-      desc "edit an object in your EDITOR"
-      explain(<<-E)
-## SUMMARY ##
-  +edit(object)+ allows you to edit any object that can be converted to JSON.
-  When finished editing, this method will return the edited object:
-
-      new_node = edit(existing_node)
-
-## EDITOR SELECTION ##
-  Shef looks for an editor using the following logic
-  1. Looks for an EDITOR set by Shef.editor = "EDITOR"
-  2. Looks for an EDITOR configured in your shef config file
-  3. Uses the value of the EDITOR environment variable
-E
-      def edit(object)
-        unless Shef.editor
-          puts "Please set your editor with Shef.editor = \"vim|emacs|mate|ed\""
-          return :failburger
-        end
-
-        filename = "shef-edit-#{object.class.name}-"
-        if object.respond_to?(:name)
-          filename += object.name
-        elsif object.respond_to?(:id)
-          filename += object.id
-        end
-
-        edited_data = Tempfile.open([filename, ".js"]) do |tempfile|
-          tempfile.sync = true
-          tempfile.puts Chef::JSONCompat.to_json(object)
-          system("#{Shef.editor.to_s} #{tempfile.path}")
-          tempfile.rewind
-          tempfile.read
-        end
-
-        Chef::JSONCompat.from_json(edited_data)
-      end
-
-      desc "Find and edit API clients"
-      explain(<<-E)
-## SUMMARY ##
-  +clients+ allows you to query you chef server for information about your api
-  clients.
-
-## LIST ALL CLIENTS ##
-  To see all clients on the system, use
-
-      clients.all #=> [<Chef::ApiClient...>, ...]
-
-  If the output from all is too verbose, or you're only interested in a specific
-  value from each of the objects, you can give a code block to +all+:
-
-      clients.all { |client| client.name } #=> [CLIENT1_NAME, CLIENT2_NAME, ...]
-
-## SHOW ONE CLIENT ##
-  To see a specific client, use
-
-      clients.show(CLIENT_NAME)
-
-## SEARCH FOR CLIENTS ##
-  You can also search for clients using +find+ or +search+. You can use the
-  familiar string search syntax:
-
-      clients.search("KEY:VALUE")
-
-  Just as the +all+ subcommand, the +search+ subcommand can use a code block to
-  filter or transform the information returned from the search:
-
-      clients.search("KEY:VALUE") { |c| c.name }
-
-  You can also use a Hash based syntax, multiple search conditions will be 
-  joined with AND.
-
-      clients.find :KEY => :VALUE, :KEY2 => :VALUE2, ...
-
-## BULK-EDIT CLIENTS ##
-                    **BE CAREFUL, THIS IS DESTRUCTIVE**
-  You can bulk edit API Clients using the +transform+ subcommand, which requires
-  a code block. Each client will be saved after the code block is run. If the
-  code block returns +nil+ or +false+, that client will be skipped:
-
-      clients.transform("*:*") do |client|
-        if client.name =~ /borat/i
-          client.admin(false)
-          true
-        else
-          nil
-        end
-      end
-
-  This will strip the admin privileges from any client named after borat.
-E
-      subcommands :all        => "list all api clients",
-                  :show       => "load an api client by name",
-                  :search     => "search for API clients",
-                  :transform  => "edit all api clients via a code block and save them"
-      def clients
-        @clients ||= Shef::ModelWrapper.new(Chef::ApiClient, :client)
-      end
-
-      desc "Find and edit cookbooks"
-      subcommands :all        => "list all cookbooks",
-                  :show       => "load a cookbook by name",
-                  :transform  => "edit all cookbooks via a code block and save them"
-      def cookbooks
-        @cookbooks ||= Shef::ModelWrapper.new(Chef::CookbookVersion)
-      end
-
-      desc "Find and edit nodes via the API"
-      explain(<<-E)
-## SUMMARY ##
-  +nodes+ Allows you to query your chef server for information about your nodes.
-
-## LIST ALL NODES ##
-  You can list all nodes using +all+ or +list+
-
-      nodes.all #=> [<Chef::Node...>, <Chef::Node...>, ...]
-
-  To limit the information returned for each node, pass a code block to the +all+
-  subcommand:
-
-      nodes.all { |node| node.name } #=> [NODE1_NAME, NODE2_NAME, ...]
-
-## SHOW ONE NODE ##
-  You can show the data for a single node using the +show+ subcommand:
-
-      nodes.show("NODE_NAME") => <Chef::Node @name="NODE_NAME" ...>
-
-## SEARCH FOR NODES ##
-  You can search for nodes using the +search+ or +find+ subcommands:
-
-      nodes.find(:name => "app*") #=> [<Chef::Node @name="app1.example.com" ...>, ...]
-
-  Similarly to +all+, you can pass a code block to limit or transform the
-  information returned:
-
-      nodes.find(:name => "app#") { |node| node.ec2 } 
-
-## BULK EDIT NODES ##
-              **BE CAREFUL, THIS OPERATION IS DESTRUCTIVE**
-
-  Bulk edit nodes by passing a code block to the +transform+ or +bulk_edit+
-  subcommand. The block will be applied to each matching node, and then the node
-  will be saved. If the block returns +nil+ or +false+, that node will be 
-  skipped.
-
-      nodes.transform do |node|
-        if node.fqdn =~ /.*\\.preprod\\.example\\.com/
-          node.set[:environment] = "preprod"
-        end
-      end
-
-  This will assign the attribute to every node with a FQDN matching the regex.
-E
-      subcommands :all        => "list all nodes",
-                  :show       => "load a node by name",
-                  :search     => "search for nodes",
-                  :transform  => "edit all nodes via a code block and save them"
-      def nodes
-        @nodes ||= Shef::ModelWrapper.new(Chef::Node)
-      end
-
-      desc "Find and edit roles via the API"
-      explain(<<-E)
-## SUMMARY ##
-  +roles+ allows you to query and edit roles on your Chef server.
-
-## SUBCOMMANDS ##
-  * all       (list)
-  * show      (load)
-  * search    (find)
-  * transform (bulk_edit)
-
-## SEE ALSO ##
-  See the help for +nodes+ for more information about the subcommands.
-E
-      subcommands :all        => "list all roles",
-                  :show       => "load a role by name",
-                  :search     => "search for roles",
-                  :transform  => "edit all roles via a code block and save them"
-      def roles
-        @roles ||= Shef::ModelWrapper.new(Chef::Role)
-      end
-
-      desc "Find and edit +databag_name+ via the api"
-      explain(<<-E)
-## SUMMARY ##
-  +databags(DATABAG_NAME)+ allows you to query and edit data bag items on your
-  Chef server. Unlike other commands for working with data on the server, 
-  +databags+ requires the databag name as an argument, for example:
-    databags(:users).all
-
-## SUBCOMMANDS ##
-  * all       (list)
-  * show      (load)
-  * search    (find)
-  * transform (bulk_edit)
-
-## SEE ALSO ##
-  See the help for +nodes+ for more information about the subcommands.
-
-E
-      subcommands :all        => "list all items in the data bag",
-                  :show       => "load a data bag item by id",
-                  :search     => "search for items in the data bag",
-                  :transform  => "edit all items via a code block and save them"
-      def databags(databag_name)
-        @named_databags_wrappers ||= {}
-        @named_databags_wrappers[databag_name] ||= Shef::NamedDataBagWrapper.new(databag_name)
-      end
-
-      desc "Find and edit environments via the API"
-      explain(<<-E)
-## SUMMARY ##
-  +environments+ allows you to query and edit environments on your Chef server.
-
-## SUBCOMMANDS ##
-  * all       (list)
-  * show      (load)
-  * search    (find)
-  * transform (bulk_edit)
-
-## SEE ALSO ##
-  See the help for +nodes+ for more information about the subcommands.
-E
-      subcommands :all        => "list all environments",
-                  :show       => "load an environment by name",
-                  :search     => "search for environments",
-                  :transform  => "edit all environments via a code block and save them"
-      def environments
-        @environments ||= Shef::ModelWrapper.new(Chef::Environment)
-      end
-
-      desc "A REST Client configured to authenticate with the API"
-      def api
-        @rest = Shef::ShefREST.new(Chef::Config[:chef_server_url])
-      end
-
-    end
-
-    RecipeUIExtensions = Proc.new do
-      alias :original_resources :resources
-
-      desc "list all the resources on the current recipe"
-      def resources(*args)
-        if args.empty?
-          pp run_context.resource_collection.instance_variable_get(:@resources_by_name).keys
-        else
-          pp resources = original_resources(*args)
-          resources
-        end
-      end
-    end
-
-    def self.extend_context_object(obj)
-      obj.instance_eval(&ObjectUIExtensions)
-      obj.instance_eval(&MainContextExtensions)
-      obj.instance_eval(&RESTApiExtensions)
-      obj.extend(FileUtils)
-      obj.extend(Chef::Mixin::Language)
-    end
-
-    def self.extend_context_node(node_obj)
-      node_obj.instance_eval(&ObjectUIExtensions)
-    end
-
-    def self.extend_context_recipe(recipe_obj)
-      recipe_obj.instance_eval(&ObjectUIExtensions)
-      recipe_obj.instance_eval(&RecipeUIExtensions)
-    end
-
-  end
-end
-
-class String
-  include Shef::Extensions::String
-end
-
-class Symbol
-  include Shef::Extensions::Symbol
-end
-
-class TrueClass
-  include Shef::Extensions::TrueClass
-end
-
-class FalseClass
-  include Shef::Extensions::FalseClass
-end
-
+require 'chef/shell/ext'