chef 0.9.18 → 0.10.0.beta.0

data/lib/chef/exceptions.rb

@@ -1,6 +1,7 @@
 #
 # Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Author:: Seth Falcon (<seth@opscode.com>)
+# Copyright:: Copyright 2008-2010 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -49,6 +50,9 @@ class Chef
     class RedirectLimitExceeded < RuntimeError; end
     class AmbiguousRunlistSpecification < ArgumentError; end
     class CookbookNotFound < RuntimeError; end
+    # Cookbook loader used to raise an argument error when cookbook not found.
+    # for back compat, need to raise an error that inherits from ArgumentError
+    class CookbookNotFoundInRepo < ArgumentError; end
     class AttributeNotFound < RuntimeError; end
     class InvalidCommandOption < RuntimeError; end
     class CommandTimeout < RuntimeError; end
@@ -63,10 +67,87 @@ class Chef
     class InvalidResourceSpecification < ArgumentError; end
     class SolrConnectionError < RuntimeError; end
     class IllegalChecksumRevert < RuntimeError; end
+    class CookbookVersionNameMismatch < ArgumentError; end
     class MissingParentDirectory < RuntimeError; end
     class UnresolvableGitReference < RuntimeError; end
     class InvalidEnvironmentRunListSpecification < ArgumentError; end
     class InvalidDataBagItemID < ArgumentError; end
     class InvalidDataBagName < ArgumentError; end
+    class EnclosingDirectoryDoesNotExist < ArgumentError; end
+
+    class ObsoleteDependencySyntax < ArgumentError; end
+
+    # A different version of a cookbook was added to a
+    # VersionedRecipeList than the one already there.
+    class CookbookVersionConflict < ArgumentError ; end
+
+    # does not follow X.Y.Z format. ArgumentError?
+    class InvalidCookbookVersion < ArgumentError; end
+
+    # version constraint should be a string or array, or it doesn't
+    # match OP VERSION. ArgumentError?
+    class InvalidVersionConstraint < ArgumentError; end
+
+    class CookbookVersionSelection
+
+      # Compound exception: In run_list expansion and resolution,
+      # run_list items referred to cookbooks that don't exist and/or
+      # have no versions available.
+      class InvalidRunListItems < StandardError
+        attr_reader :non_existent_cookbooks
+        attr_reader :cookbooks_with_no_matching_versions
+
+        def initialize(message, non_existent_cookbooks, cookbooks_with_no_matching_versions)
+          super(message)
+
+          @non_existent_cookbooks = non_existent_cookbooks
+          @cookbooks_with_no_matching_versions = cookbooks_with_no_matching_versions
+        end
+
+        def to_json(*a)
+          result = {
+            "message" => message,
+            "non_existent_cookbooks" => non_existent_cookbooks,
+            "cookbooks_with_no_versions" => cookbooks_with_no_matching_versions
+          }
+          result.to_json(*a)
+        end
+      end
+
+      # In run_list expansion and resolution, a constraint was
+      # unsatisfiable.
+      #
+      # This exception may not be the complete error report. If you
+      # resolve the misconfiguration represented by this exception and
+      # re-solve, you may get another exception
+      class UnsatisfiableRunListItem < StandardError
+        attr_reader :run_list_item
+        attr_reader :non_existent_cookbooks, :most_constrained_cookbooks
+
+        # most_constrained_cookbooks: if I were to remove constraints
+        # regarding these cookbooks, I would get a solution or move on
+        # to the next error (deeper in the graph). An item in this list
+        # may be unsatisfiable, but when resolved may also reveal
+        # further unsatisfiable constraints; this condition would not be
+        # reported.
+        def initialize(message, run_list_item, non_existent_cookbooks, most_constrained_cookbooks)
+          super(message)
+
+          @run_list_item = run_list_item
+          @non_existent_cookbooks = non_existent_cookbooks
+          @most_constrained_cookbooks = most_constrained_cookbooks
+        end
+
+        def to_json(*a)
+          result = {
+            "message" => message,
+            "unsatisfiable_run_list_item" => run_list_item,
+            "non_existent_cookbooks" => non_existent_cookbooks,
+            "most_constrained_cookbooks" => most_constrained_cookbooks
+          }
+          result.to_json(*a)
+        end
+      end
+    end
   end
 end

data/lib/chef/index_queue/amqp_client.rb

@@ -19,6 +19,8 @@
 class Chef
   module IndexQueue
     class AmqpClient
+      VNODES = 1024
+
       include Singleton
 
       def initialize
@@ -29,11 +31,9 @@ class Chef
         @amqp_client && amqp_client.connected? && amqp_client.stop
         @amqp_client = nil
         @exchange = nil
-        @queue = nil
       end
       
       def stop
-        @queue && @queue.subscription && @queue.unsubscribe
         @amqp_client && @amqp_client.stop
       end
       
@@ -59,24 +59,17 @@ class Chef
         @exchange ||= amqp_client.exchange("chef-indexer", :durable => true, :type => :fanout)
       end
       
-      def queue
-        unless @queue
-          @queue = amqp_client.queue("chef-index-consumer-" + consumer_id, :durable => durable_queue?)
-          @queue.bind(exchange)
-        end
-        @queue
-      end
-      
       def disconnected!
         Chef::Log.error("Disconnected from the AMQP Broker (RabbitMQ)")
         @amqp_client = nil
         reset!
       end
 
-      def send_action(action, data)
+      def queue_for_object(obj_id)
         retries = 0
+        vnode_tag = obj_id_to_int(obj_id) % VNODES
         begin
-          exchange.publish(Chef::JSONCompat.to_json({"action" => action.to_s, "payload" => data}))
+          yield amqp_client.queue("vnode-#{vnode_tag}", :passive => false, :durable => true, :exclusive => false, :auto_delete => false)
         rescue Bunny::ServerDownError, Bunny::ConnectionError, Errno::ECONNRESET
           disconnected!
           if (retries += 1) < 2
@@ -90,6 +83,15 @@ class Chef
       end
 
       private
+
+      # Sometimes object ids are "proper" UUIDs, like "64bc00eb-120b-b6a2-ec0e-34fc90d151be"
+      # and sometimes they omit the dashes, like "64bc00eb120bb6a2ec0e34fc90d151be"
+      # UUIDTools uses different methods to parse the different styles.
+      def obj_id_to_int(obj_id)
+        UUIDTools::UUID.parse(obj_id).to_i
+      rescue ArgumentError
+        UUIDTools::UUID.parse_hexdigest(obj_id).to_i
+      end
       
       def durable_queue?
         !!Chef::Config[:amqp_consumer_id]
@@ -111,3 +113,4 @@ class Chef
     end
   end
 end
+

data/lib/chef/index_queue/indexable.rb

@@ -1,6 +1,8 @@
 #
 # 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");
@@ -15,6 +17,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+require 'chef/json_compat'
 
 class Chef
   module IndexQueue
@@ -56,20 +59,51 @@ class Chef
         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)}")
-        AmqpClient.instance.send_action(:add, self.with_indexer_metadata(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)}")
-        AmqpClient.instance.send_action(:delete, 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

@@ -24,8 +24,9 @@ class Chef
     JSON_MAX_NESTING = 1000
 
     class <<self
-      # See PL-538. Increase the max nesting for JSON, which defaults to 19,
-      # and isn't enough for some deep node (for example) structures.
+      # 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
@@ -40,7 +41,6 @@ class Chef
       end
 
       def to_json(obj, opts = nil)
-        #::JSON.generate(obj, opts_add_max_nesting(opts))
         obj.to_json(opts_add_max_nesting(opts))
       end
 

data/lib/chef/knife.rb

@@ -7,9 +7,9 @@
 # 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.
@@ -17,28 +17,52 @@
 # limitations under the License.
 #
 
+require 'forwardable'
 require 'chef/version'
 require 'mixlib/cli'
 require 'chef/mixin/convert_to_class_name'
-require 'chef/rest'
+require 'chef/knife/subcommand_loader'
+require 'chef/knife/ui'
+
 require 'pp'
 
 class Chef
   class Knife
-
-    Chef::REST::RESTRequest.user_agent = "Chef Knife#{Chef::REST::RESTRequest::UA_COMMON}"
-
     include Mixlib::CLI
     extend Chef::Mixin::ConvertToClassName
-
-    # The "require paths" of the core knife subcommands bundled with chef
-    DEFAULT_SUBCOMMAND_FILES = Dir[File.expand_path(File.join(File.dirname(__FILE__), 'knife', '*.rb'))]
-    DEFAULT_SUBCOMMAND_FILES.map! { |knife_file| knife_file[/#{CHEF_ROOT}#{Regexp.escape(File::SEPARATOR)}(.*)\.rb/,1] }
+    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_reader :ui
+
+    def self.ui
+      @ui ||= Chef::Knife::UI.new(STDOUT, STDERR, STDIN, {})
+    end
 
     def self.msg(msg="")
-      puts msg
+      ui.msg(msg)
+    end
+
+    def self.reset_subcommands!
+      @@subcommands = {}
+      @subcommands_by_category = nil
     end
 
     def self.inherited(subclass)
@@ -73,6 +97,14 @@ class Chef
       name.nil? || name.empty?
     end
 
+    def self.subcommand_loader
+      @subcommand_loader ||= Knife::SubcommandLoader.new(chef_config_dir)
+    end
+
+    def self.load_commands
+      subcommand_loader.load_commands
+    end
+
     def self.subcommands
       @@subcommands ||= {}
     end
@@ -87,17 +119,10 @@ class Chef
       @subcommands_by_category
     end
 
-    # Load all the sub-commands
-    def self.load_commands
-      DEFAULT_SUBCOMMAND_FILES.each { |subcommand| require subcommand }
-      subcommands
-    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"
 
@@ -125,7 +150,8 @@ class Chef
     def self.run(args, options={})
       load_commands
       subcommand_class = subcommand_class_from(args)
-      subcommand_class.options.merge!(options)
+      subcommand_class.options = options.merge!(subcommand_class.options)
+      subcommand_class.load_deps
       instance = subcommand_class.new(args)
       instance.configure_chef
       instance.run
@@ -155,16 +181,12 @@ class Chef
       subcommand_class || subcommand_not_found!(args)
     end
 
-    protected
+    def self.deps(&block)
+      @dependency_loader = block
+    end
 
-    def load_late_dependency(dep, gem_name = nil)
-      begin
-        require dep
-      rescue LoadError
-        gem_name ||= dep.gsub('/', '-')
-        Chef::Log.fatal "#{gem_name} is not installed. run \"gem install #{gem_name}\" to install it."
-        exit 1
-      end
+    def self.load_deps
+      @dependency_loader && @dependency_loader.call
     end
 
     private
@@ -174,9 +196,9 @@ class Chef
     # user could not be resolved to a subcommand.
     def self.subcommand_not_found!(args)
       unless want_help?(args)
-        Chef::Log.fatal("Cannot find sub command for: '#{args.join(' ')}'")
+        ui.fatal("Cannot find sub command for: '#{args.join(' ')}'")
       end
-      Chef::Knife.list_commands(guess_category(args))
+      list_commands(guess_category(args))
       exit 10
     end
 
@@ -187,12 +209,32 @@ class Chef
       (args.any? { |arg| arg =~ /^(:?(:?\-\-)?help|\-h)$/})
     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|
+          canidate_directory = File.join(full_path[0..i] + [".chef" ])
+          if File.exist?(canidate_directory) && File.directory?(canidate_directory)
+            @@chef_config_dir = canidate_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('_')
 
@@ -219,37 +261,11 @@ class Chef
       exit(1)
     end
 
-    def ask_question(question, opts={})
-      question = question + "[#{opts[:default]}] " if opts[:default]
-
-      if opts[:default] and config[:defaults]
-
-        opts[:default]
-
-      else
-
-        stdout.print question
-        a = stdin.readline.strip
-
-        if opts[:default]
-          a.empty? ? opts[:default] : a
-        else
-          a
-        end
-
-      end
-
-    end
-
     def configure_chef
       unless config[:config_file]
-        full_path = Dir.pwd.split(File::SEPARATOR)
-        (full_path.length - 1).downto(0) do |i|
-          config_file_to_check = File.join([ full_path[0..i], ".chef", "knife.rb" ].flatten)
-          if File.exists?(config_file_to_check)
-            config[:config_file] = config_file_to_check 
-            break
-          end
+        if self.class.chef_config_dir
+          candidate_config = File.expand_path('knife.rb',self.class.chef_config_dir)
+          config[:config_file] = candidate_config if File.exist?(candidate_config)
         end
         # If we haven't set a config yet and $HOME is set, and the home
         # knife.rb exists, use it:
@@ -266,13 +282,22 @@ class Chef
         self.msg("No knife configuration file found")
       end
 
-      Chef::Config[:log_level] = config[:log_level] if config[:log_level]
-      Chef::Config[:log_location] = config[:log_location] if config[:log_location]
-      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[:log_level]         = config[:log_level]       if config[:log_level]
+      Chef::Config[:log_location]      = config[:log_location]    if config[:log_location]
+      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])
+      Chef::Log.level(Chef::Config[:log_level] || :error)
 
       Chef::Log.debug("Using configuration from #{config[:config_file]}")
 
@@ -281,99 +306,6 @@ class Chef
       end
     end
 
-    def pretty_print(data)
-      puts data
-    end
-
-    def output(data)
-      case config[:format]
-      when "json", nil
-        stdout.puts Chef::JSONCompat.to_json_pretty(data)
-      when "yaml"
-        require 'yaml'
-        stdout.puts YAML::dump(data)
-      when "text"
-        # If you were looking for some attribute and there is only one match
-        # just dump the attribute value
-        if data.length == 1 and config[:attribute]
-          stdout.puts data.values[0]
-        else
-          PP.pp(data, stdout)
-        end
-      else
-        raise ArgumentError, "Unknown output format #{config[:format]}"
-      end
-    end
-
-    def format_list_for_display(list)
-      config[:with_uri] ? list : list.keys.sort { |a,b| a <=> b } 
-    end
-
-    def format_for_display(item)
-      data = item.kind_of?(Chef::DataBagItem) ? item.raw_data : item
-
-      if config[:attribute]
-        config[:attribute].split(".").each do |attr|
-          if data.respond_to?(:[])
-            data = data[attr]
-          elsif data.nil?
-            nil # don't get no method error on nil
-          else data.respond_to?(attr.to_sym)
-            data = data.send(attr.to_sym)
-          end
-        end
-        { config[:attribute] => data.kind_of?(Chef::Node::Attribute) ? data.to_hash : data }
-      elsif config[:run_list]
-        data = data.run_list.run_list
-        { "run_list" => data }
-      elsif config[:id_only]
-        data.respond_to?(:name) ? data.name : data["id"]
-      else
-        data
-      end
-    end
-
-    def edit_data(data, parse_output=true)
-      output = Chef::JSONCompat.to_json_pretty(data)
-      
-      if (!config[:no_editor])
-        filename = "knife-edit-"
-        0.upto(20) { filename += rand(9).to_s }
-        filename << ".js"
-        filename = File.join(Dir.tmpdir, filename)
-        tf = File.open(filename, "w")
-        tf.sync = true
-        tf.puts output
-        tf.close
-        raise "Please set EDITOR environment variable" unless system("#{config[:editor]} #{tf.path}") 
-        tf = File.open(filename, "r")
-        output = tf.gets(nil)
-        tf.close
-        File.unlink(filename)
-      end
-
-      parse_output ? Chef::JSONCompat.from_json(output) : output
-    end
-
-    def confirm(question, append_instructions=true)
-      return true if config[:yes]
-
-      stdout.print question
-      stdout.print "? (Y/N) " if append_instructions
-      answer = stdin.readline
-      answer.chomp!
-      case answer
-      when "Y", "y"
-        true
-      when "N", "n"
-        self.msg("You said no, so I'm done here.")
-        exit 3 
-      else
-        self.msg("I have no idea what to do with #{answer}")
-        self.msg("Just say Y or N, please.")
-        confirm(question)
-      end
-    end
 
     def show_usage
       stdout.puts("USAGE: " + self.opt_parser.to_s)
@@ -387,6 +319,8 @@ class Chef
         relative_path = "nodes"
       elsif klass == Chef::DataBagItem
         relative_path = "data_bags/#{bag}"
+      elsif klass == Chef::Environment
+        relative_path = "environments"
       end
 
       relative_file = File.expand_path(File.join(Dir.pwd, relative_path, from_file))
@@ -394,10 +328,10 @@ class Chef
 
       if file_exists_and_is_readable?(from_file)
         filename = from_file
-      elsif file_exists_and_is_readable?(relative_file) 
-        filename = relative_file 
+      elsif file_exists_and_is_readable?(relative_file)
+        filename = relative_file
       else
-        Chef::Log.fatal("Cannot find file #{from_file}")
+        ui.fatal("Cannot find file #{from_file}")
         exit 30
       end
 
@@ -409,7 +343,7 @@ class Chef
         r.from_file(filename)
         r
       else
-        Chef::Log.fatal("File must end in .js, .json, or .rb")
+        ui.fatal("File must end in .js, .json, or .rb")
         exit 30
       end
     end
@@ -418,33 +352,6 @@ class Chef
       File.exists?(file) && File.readable?(file)
     end
 
-    def edit_object(klass, name)
-      object = klass.load(name)
-
-      output = edit_data(object)
-
-      # Only make the save if the user changed the object.
-      #
-      # Output JSON for the original (object) and edited (output), then parse 
-      # them without reconstituting the objects into real classes
-      # (create_additions=false). Then, compare the resulting simple objects,
-      # which will be Array/Hash/String/etc. 
-      #
-      # We wouldn't have to do these shenanigans if all the editable objects 
-      # implemented to_hash, or if to_json against a hash returned a string 
-      # with stable key order.
-      object_parsed_again = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(object), :create_additions => false)
-      output_parsed_again = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(output), :create_additions => false)
-      if object_parsed_again != output_parsed_again
-        output.save
-        self.msg("Saved #{output}")
-      else
-        self.msg("Object unchanged, not saving")
-      end
-
-      output(format_for_display(object)) if config[:print_after]
-    end
-
     def create_object(object, pretty_name=nil, &block)
       output = edit_data(object)
 
@@ -457,7 +364,7 @@ class Chef
       pretty_name ||= output
 
       self.msg("Created (or updated) #{pretty_name}")
-      
+
       output(output) if config[:print_after]
     end
 
@@ -505,18 +412,6 @@ class Chef
       end
     end
 
-    def msg(message)
-      stdout.puts message
-    end
-
-    def stdout
-      STDOUT
-    end
-
-    def stdin
-      STDIN
-    end
-
     def rest
       @rest ||= Chef::REST.new(Chef::Config[:chef_server_url])
     end