microwave 11.400.3 → 11.400.4

data/lib/chef/search/query.rb

@@ -0,0 +1,65 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008 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/config'
+require 'uri'
+require 'chef/rest'
+require 'chef/node'
+require 'chef/role'
+require 'chef/data_bag'
+require 'chef/data_bag_item'
+
+class Chef
+  class Search
+    class Query
+
+      attr_accessor :rest
+
+      def initialize(url=nil)
+        @rest = Chef::REST.new(url ||Chef::Config[:search_url])
+      end
+
+      # Search Solr for objects of a given type, for a given query. If you give
+      # it a block, it will handle the paging for you dynamically.
+      def search(type, query="*:*", sort='X_CHEF_id_CHEF_X asc', start=0, rows=1000, &block)
+        raise ArgumentError, "Type must be a string or a symbol!" unless (type.kind_of?(String) || type.kind_of?(Symbol))
+
+        response = @rest.get_rest("search/#{type}?q=#{escape(query)}&sort=#{escape(sort)}&start=#{escape(start)}&rows=#{escape(rows)}")
+        if block
+          response["rows"].each { |o| block.call(o) unless o.nil?}
+          unless (response["start"] + response["rows"].length) >= response["total"]
+            nstart = response["start"] + rows
+            search(type, query, sort, nstart, rows, &block)
+          end
+          true
+        else
+          [ response["rows"], response["start"], response["total"] ]
+        end
+      end
+
+      def list_indexes
+        response = @rest.get_rest("search")
+      end
+
+      private
+        def escape(s)
+          s && URI.escape(s.to_s)
+        end
+    end
+  end
+end

data/lib/chef/shef/ext.rb

@@ -0,0 +1,19 @@
+#--
+# 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");
+# 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/shell/ext'

data/lib/chef/shell.rb

@@ -0,0 +1,329 @@
+# 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 'pp'
+require 'etc'
+require 'mixlib/cli'
+
+require 'chef'
+require 'chef/version'
+require 'chef/client'
+require 'chef/config'
+
+require 'chef/shell/shell_session'
+require 'chef/shell/ext'
+require 'chef/json_compat'
+
+# = Shell
+# Shell is Chef in an IRB session. Shell can interact with a Chef server via the
+# REST API, and run and debug recipes interactively.
+module Shell
+  LEADERS = Hash.new("")
+  LEADERS[Chef::Recipe] = ":recipe"
+  LEADERS[Chef::Node]   = ":attributes"
+
+  class << self
+    attr_accessor :client_type
+    attr_accessor :options
+    attr_accessor :env
+    attr_writer   :editor
+  end
+
+  # Start the irb REPL with chef-shell's customizations
+  def self.start
+    setup_logger
+    # FUGLY HACK: irb gives us no other choice.
+    irb_help = [:help, :irb_help, IRB::ExtendCommandBundle::NO_OVERRIDE]
+    IRB::ExtendCommandBundle.instance_variable_get(:@ALIASES).delete(irb_help)
+
+    parse_opts
+
+    # HACK: this duplicates the functions of IRB.start, but we have to do it
+    # to get access to the main object before irb starts.
+    ::IRB.setup(nil)
+
+    irb = IRB::Irb.new
+
+    init(irb.context.main)
+
+
+    irb_conf[:IRB_RC].call(irb.context) if irb_conf[:IRB_RC]
+    irb_conf[:MAIN_CONTEXT] = irb.context
+
+    trap("SIGINT") do
+      irb.signal_handle
+    end
+
+    catch(:IRB_EXIT) do
+      irb.eval_input
+    end
+  end
+
+  def self.setup_logger
+    Chef::Config[:log_level] ||= :warn
+    # If log_level is auto, change it to warn
+    Chef::Config[:log_level] = :warn if Chef::Config[:log_level] == :auto
+    Chef::Log.init(STDERR)
+    Mixlib::Authentication::Log.logger = Ohai::Log.logger = Chef::Log.logger
+    Chef::Log.level = Chef::Config[:log_level] || :warn
+  end
+
+  # Shell assumes it's running whenever it is defined
+  def self.running?
+    true
+  end
+
+  # Set the irb_conf object to something other than IRB.conf
+  # usful for testing.
+  def self.irb_conf=(conf_hash)
+    @irb_conf = conf_hash
+  end
+
+  def self.irb_conf
+    @irb_conf || IRB.conf
+  end
+
+  def self.configure_irb
+    irb_conf[:HISTORY_FILE] = "~/.chef/chef_shell_history"
+    irb_conf[:SAVE_HISTORY] = 1000
+
+    irb_conf[:IRB_RC] = lambda do |conf|
+      m = conf.main
+
+      conf.prompt_c       = "chef#{leader(m)} > "
+      conf.return_format  = " => %s \n"
+      conf.prompt_i       = "chef#{leader(m)} > "
+      conf.prompt_n       = "chef#{leader(m)} ?> "
+      conf.prompt_s       = "chef#{leader(m)}%l> "
+    end
+  end
+
+  def self.leader(main_object)
+    env_string = Shell.env ? " (#{Shell.env})" : ""
+    LEADERS[main_object.class] + env_string
+  end
+
+  def self.session
+    unless client_type.instance.node_built?
+      puts "Session type: #{client_type.session_type}"
+      client_type.instance.reset!
+    end
+    client_type.instance
+  end
+
+  def self.init(main)
+    parse_json
+    configure_irb
+
+    session # trigger ohai run + session load
+
+    session.node.consume_attributes(@json_attribs)
+
+    Extensions.extend_context_object(main)
+
+    main.version
+    puts
+
+    puts "run `help' for help, `exit' or ^D to quit."
+    puts
+    puts "Ohai2u#{greeting}!"
+  end
+
+  def self.greeting
+    " #{Etc.getlogin}@#{Shell.session.node.fqdn}"
+  rescue NameError, ArgumentError
+    ""
+  end
+
+  def self.parse_json
+    # HACK: copied verbatim from chef/application/client, because it's not
+    # reusable as written there :(
+    if Chef::Config[:json_attribs]
+      begin
+        json_io = open(Chef::Config[:json_attribs])
+      rescue SocketError => error
+        fatal!("I cannot connect to #{Chef::Config[:json_attribs]}", 2)
+      rescue Errno::ENOENT => error
+        fatal!("I cannot find #{Chef::Config[:json_attribs]}", 2)
+      rescue Errno::EACCES => error
+        fatal!("Permissions are incorrect on #{Chef::Config[:json_attribs]}. Please chmod a+r #{Chef::Config[:json_attribs]}", 2)
+      rescue Exception => error
+        fatal!("Got an unexpected error reading #{Chef::Config[:json_attribs]}: #{error.message}", 2)
+      end
+
+      begin
+        @json_attribs = Chef::JSONCompat.from_json(json_io.read)
+      rescue JSON::ParserError => error
+        fatal!("Could not parse the provided JSON file (#{Chef::Config[:json_attribs]})!: " + error.message, 2)
+      end
+    end
+  end
+
+  def self.fatal!(message, exit_status)
+    Chef::Log.fatal(message)
+    exit exit_status
+  end
+
+  def self.client_type
+    type = Shell::StandAloneSession
+    type = Shell::SoloSession   if Chef::Config[:shell_solo]
+    type = Shell::ClientSession if Chef::Config[:client]
+    type = Shell::DoppelGangerSession if Chef::Config[:doppelganger]
+    type
+  end
+
+  def self.parse_opts
+    @options = Options.new
+    @options.parse_opts
+  end
+
+  def self.editor
+    @editor || Chef::Config[:editor] || ENV['EDITOR']
+  end
+
+  class Options
+    include Mixlib::CLI
+
+    def self.footer(text=nil)
+      @footer = text if text
+      @footer
+    end
+
+    banner("chef-shell #{Chef::VERSION}\n\nUsage: chef-shell [NAMED_CONF] (OPTIONS)")
+
+    footer(<<-FOOTER)
+When no CONFIG is specified, chef-shell attempts to load a default configuration file:
+* If a NAMED_CONF is given, chef-shell will load ~/.chef/NAMED_CONF/chef_shell.rb
+* If no NAMED_CONF is given chef-shell will load ~/.chef/chef_shell.rb if it exists
+* chef-shell falls back to loading /etc/chef/client.rb or /etc/chef/solo.rb if -z or
+  -s options are given and no chef_shell.rb can be found.
+FOOTER
+
+    option :config_file,
+      :short => "-c CONFIG",
+      :long  => "--config CONFIG",
+      :description => "The configuration file to use"
+
+    option :help,
+      :short        => "-h",
+      :long         => "--help",
+      :description  => "Show this message",
+      :on           => :tail,
+      :boolean      => true,
+      :proc         => proc { print_help }
+
+    option :log_level,
+      :short  => "-l LOG_LEVEL",
+      :long   => '--log-level LOG_LEVEL',
+      :description => "Set the logging level",
+      :proc         => proc { |level| Chef::Config.log_level = level.to_sym; Shell.setup_logger }
+
+    option :standalone,
+      :short        => "-a",
+      :long         => "--standalone",
+      :description  => "standalone session",
+      :default      => true,
+      :boolean      => true
+
+    option :shell_solo,
+      :short        => "-s",
+      :long         => "--solo",
+      :description  => "chef-solo session",
+      :boolean      => true,
+      :proc         => proc {Chef::Config[:solo] = true}
+
+    option :client,
+      :short        => "-z",
+      :long         => "--client",
+      :description  => "chef-client session",
+      :boolean      => true
+
+    option :json_attribs,
+      :short => "-j JSON_ATTRIBS",
+      :long => "--json-attributes JSON_ATTRIBS",
+      :description => "Load attributes from a JSON file or URL",
+      :proc => nil
+
+    option :chef_server_url,
+      :short => "-S CHEFSERVERURL",
+      :long => "--server CHEFSERVERURL",
+      :description => "The chef server URL",
+      :proc => nil
+
+    option :version,
+      :short        => "-v",
+      :long         => "--version",
+      :description  => "Show chef version",
+      :boolean      => true,
+      :proc         => lambda {|v| puts "Chef: #{::Chef::VERSION}"},
+      :exit         => 0
+
+    def self.print_help
+      instance = new
+      instance.parse_options([])
+      puts instance.opt_parser
+      puts
+      puts footer
+      puts
+      exit 1
+    end
+
+    def self.setup!
+      self.new.parse_opts
+    end
+
+    def parse_opts
+      remainder = parse_options
+      environment = remainder.first
+      # We have to nuke ARGV to make sure irb's option parser never sees it.
+      # otherwise, IRB complains about command line switches it doesn't recognize.
+      ARGV.clear
+      config[:config_file] = config_file_for_shell_mode(environment)
+      config_msg = config[:config_file] || "none (standalone session)"
+      puts "loading configuration: #{config_msg}"
+      Chef::Config.from_file(config[:config_file]) if !config[:config_file].nil? && File.exists?(config[:config_file]) && File.readable?(config[:config_file])
+      Chef::Config.merge!(config)
+    end
+
+    private
+
+    def config_file_for_shell_mode(environment)
+      if config[:config_file]
+        config[:config_file]
+      elsif environment && ENV['HOME']
+        Shell.env = environment
+        config_file_to_try = ::File.join(ENV['HOME'], '.chef', environment, 'chef_shell.rb')
+        unless ::File.exist?(config_file_to_try)
+          puts "could not find chef-shell config for environment #{environment} at #{config_file_to_try}"
+          exit 1
+        end
+        config_file_to_try
+      elsif ENV['HOME'] && ::File.exist?(File.join(ENV['HOME'], '.chef', 'chef_shell.rb'))
+        File.join(ENV['HOME'], '.chef', 'chef_shell.rb')
+      elsif config[:solo]
+        "/etc/chef/solo.rb"
+      elsif config[:client]
+        "/etc/chef/client.rb"
+      else
+        nil
+      end
+    end
+
+  end
+
+end

data/lib/chef/shell/ext.rb

@@ -0,0 +1,593 @@
+#--
+# 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 'tempfile'
+require 'chef/recipe'
+require 'fileutils'
+require 'chef/dsl/platform_introspection'
+require 'chef/version'
+require 'chef/shell/shell_session'
+require 'chef/shell/model_wrapper'
+require 'chef/shell/shell_rest'
+require 'chef/json_compat'
+
+module Shell
+  module Extensions
+
+    Help = Struct.new(:cmd, :desc, :explanation)
+
+    # Extensions to be included in every 'main' object in chef-shell.
+    # 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_shell_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_shell_session(context_obj)
+          jobs.switch(subsession)
+        else
+          irb(context_obj)
+        end
+      end
+
+      def help_banner
+        banner = []
+        banner << ""
+        banner << "chef-shell 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 Shell::Extensions::ObjectCoreExtensions
+
+      desc "prints this help message"
+      explain(<<-E)
+## SUMMARY ##
+  When called with no argument, +help+ prints a table of all
+  chef-shell 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 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 :shell :version
+
+      desc "switch to recipe mode"
+      def recipe_mode
+        find_or_create_session_for Shell.session.recipe
+        :recipe
+      end
+
+      desc "switch to attributes mode"
+      def attributes_mode
+        find_or_create_session_for Shell.session.node
+        :attributes
+      end
+
+      desc "run chef using the current recipe"
+      def run_chef
+        Chef::Log.level = :debug
+        session = Shell.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
+        Shell.session.resource_collection.iterator
+      end
+
+      desc "resets the current recipe"
+      def reset
+        Shell.session.reset!
+      end
+
+      desc "assume the identity of another node."
+      def become_node(node_name)
+        Shell::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
+        Shell.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 ##
+  chef-shell looks for an editor using the following logic
+  1. Looks for an EDITOR set by Shell.editor = "EDITOR"
+  2. Looks for an EDITOR configured in your chef-shell config file
+  3. Uses the value of the EDITOR environment variable
+E
+      def edit(object)
+        unless Shell.editor
+          puts "Please set your editor with Shell.editor = \"vim|emacs|mate|ed\""
+          return :failburger
+        end
+
+        filename = "chef-shell-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("#{Shell.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 ||= Shell::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 ||= Shell::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 ||= Shell::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 ||= Shell::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] ||= Shell::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 ||= Shell::ModelWrapper.new(Chef::Environment)
+      end
+
+      desc "A REST Client configured to authenticate with the API"
+      def api
+        @rest = Shell::ShellREST.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::DSL::PlatformIntrospection)
+      obj.extend(Chef::DSL::DataQuery)
+    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 Shell::Extensions::String
+end
+
+class Symbol
+  include Shell::Extensions::Symbol
+end
+
+class TrueClass
+  include Shell::Extensions::TrueClass
+end
+
+class FalseClass
+  include Shell::Extensions::FalseClass
+end