chef 0.10.0.beta.5 → 0.10.0.beta.6

data/lib/chef/application.rb

@@ -19,6 +19,7 @@ require 'chef/config'
 require 'chef/exceptions'
 require 'chef/log'
 require 'mixlib/cli'
+require 'tmpdir'
 
 class Chef::Application
   include Mixlib::CLI
@@ -121,9 +122,20 @@ class Chef::Application
 
 
   class << self
+    def debug_stacktrace(e)
+      message = "#{e.class}: #{e}\n#{e.backtrace.join("\n")}"
+      filename = File.join(Dir.tmpdir, "chef-stacktrace.out") 
+      Chef::Log.fatal("Stacktrace dumped to #{filename}")
+      Chef::Log.debug(message)
+      chef_stacktrace_out = File.open(filename, "w")
+      chef_stacktrace_out.puts "Generated at #{Time.now.to_s}"
+      chef_stacktrace_out.puts message
+      chef_stacktrace_out.close
+      true
+    end
+
     # Log a fatal error message to both STDERR and the Logger, exit the application
     def fatal!(msg, err = -1)
-      STDERR.puts("FATAL: #{msg}")
       Chef::Log.fatal(msg)
       Process.exit err
     end

data/lib/chef/application/client.rb

@@ -227,12 +227,14 @@ class Chef::Application::Client < Chef::Application
         raise
       rescue Exception => e
         if Chef::Config[:interval]
-          Chef::Log.error("#{e.class}:#{e}\n#{e.backtrace.join("\n")}")
+          Chef::Log.error("#{e.class}: #{e}")
+          Chef::Application.debug_stacktrace(e)
           Chef::Log.error("Sleeping for #{Chef::Config[:interval]} seconds before trying again")
           sleep Chef::Config[:interval]
           retry
         else
-          raise
+          Chef::Application.debug_stacktrace(e)
+          Chef::Application.fatal!("#{e.class}: #{e.message}", 1)
         end
       ensure
         GC.start

data/lib/chef/application/knife.rb

@@ -18,7 +18,7 @@
 require 'chef/knife'
 require 'chef/application'
 require 'mixlib/log'
-require 'ohai'
+require 'ohai/config'
 
 class Chef::Application::Knife < Chef::Application
 
@@ -40,6 +40,18 @@ class Chef::Application::Knife < Chef::Application
     :proc  => Proc.new { verbosity_level += 1},
     :default => 0
 
+  option :color,
+    :long         => '--color',
+    :boolean      => true,
+    :default      => true,
+    :description  => "Use colored output"
+
+  option :no_color,
+    :long         => '--no-color',
+    :boolean      => true,
+    :default      => false,
+    :description  => "Don't use colors in the output"
+
   option :environment,
     :short        => "-E ENVIRONMENT",
     :long         => "--environment ENVIRONMENT",
@@ -97,7 +109,7 @@ class Chef::Application::Knife < Chef::Application
     :short => "-F FORMAT",
     :long => "--format FORMAT",
     :description => "Which format to use for output",
-    :default => "json"
+    :default => "summary"
 
   option :version,
     :short        => "-v",
@@ -107,16 +119,28 @@ class Chef::Application::Knife < Chef::Application
     :proc         => lambda {|v| puts "Chef: #{::Chef::VERSION}"},
     :exit         => 0
 
+
   # Run knife
   def run
     Mixlib::Log::Formatter.show_time = false
     validate_and_parse_options
+    quiet_traps
     Chef::Knife.run(ARGV, options)
     exit 0
   end
 
   private
 
+  def quiet_traps
+    trap("TERM") do
+      exit 1
+    end
+
+    trap("INT") do
+      exit 2
+    end
+  end
+
   def validate_and_parse_options
     # Checking ARGV validity *before* parse_options because parse_options
     # mangles ARGV in some situations

data/lib/chef/application/solo.rb

@@ -201,13 +201,14 @@ class Chef::Application::Solo < Chef::Application
         raise
       rescue Exception => e
         if Chef::Config[:interval]
-          Chef::Log.error("#{e.class}")
-          Chef::Log.fatal("#{e}\n#{e.backtrace.join("\n")}")
+          Chef::Log.error("#{e.class}: #{e}")
+          Chef::Log.debug("#{e.class}: #{e}\n#{e.backtrace.join("\n")}")
           Chef::Log.fatal("Sleeping for #{Chef::Config[:interval]} seconds before trying again")
           sleep Chef::Config[:interval]
           retry
         else
-          raise
+          Chef::Application.debug_stacktrace(e)
+          Chef::Application.fatal!("#{e.class}: #{e.message}", 1)
         end
       ensure
         GC.start

data/lib/chef/client.rb

@@ -143,6 +143,7 @@ class Chef
     def run
       run_context = nil
 
+      Chef::Log.info("*** Chef #{Chef::VERSION} ***")
       enforce_path_sanity
       run_ohai
       register unless Chef::Config[:solo]
@@ -151,7 +152,7 @@ class Chef
       begin
 
         run_status.start_clock
-        Chef::Log.info("Starting Chef Run (Version #{Chef::VERSION})")
+        Chef::Log.info("Starting Run for #{node.name}")
         run_started
 
         run_context = setup_run_context

data/lib/chef/cookbook_version.rb

@@ -911,7 +911,8 @@ class Chef
           elsif segment == :templates || segment == :files
             matcher = segment_file.match("/#{Regexp.escape(name.to_s)}/(#{Regexp.escape(segment.to_s)}/(.+?)/(.+))")
             unless matcher
-              Chef::Log.debug("Skipping file #{segment_file}, as it doesn't have a proper segment.")
+              Chef::Log.debug("Skipping file #{segment_file}, as it isn't in any of the proper directories (platform-version, platform or default)")
+              Chef::Log.debug("You probably need to move #{segment_file} into the 'default' sub-directory")
               next
             end
             path = matcher[1]

data/lib/chef/knife.rb

@@ -21,13 +21,16 @@ require 'forwardable'
 require 'chef/version'
 require 'mixlib/cli'
 require 'chef/mixin/convert_to_class_name'
-require 'chef/knife/subcommand_loader'
-require 'chef/knife/ui'
-
+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
     extend Chef::Mixin::ConvertToClassName
     extend Forwardable
@@ -50,7 +53,7 @@ class Chef
     def_delegator :@ui, :confirm
 
     attr_accessor :name_args
-    attr_reader :ui
+    attr_accessor :ui
 
     def self.ui
       @ui ||= Chef::Knife::UI.new(STDOUT, STDERR, STDIN, {})
@@ -92,6 +95,10 @@ class Chef
       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?
@@ -102,7 +109,7 @@ class Chef
     end
 
     def self.load_commands
-      subcommand_loader.load_commands
+      @commands_loaded ||= subcommand_loader.load_commands
     end
 
     def self.subcommands
@@ -123,6 +130,7 @@ class Chef
     # 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"
 
@@ -133,6 +141,7 @@ class Chef
       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]
@@ -154,7 +163,7 @@ class Chef
       subcommand_class.load_deps unless want_help?(args)
       instance = subcommand_class.new(args)
       instance.configure_chef
-      instance.run
+      instance.run_with_pretty_exceptions
     end
 
     def self.guess_category(args)
@@ -276,12 +285,14 @@ class Chef
 
       # Don't try to load a knife.rb if it doesn't exist.
       if config[:config_file]
-        Chef::Config.from_file(config[:config_file])
+        read_config_file(config[:config_file])
       else
         # ...but do log a message if no config was found.
         self.msg("No knife configuration file found")
       end
 
+      config[:color] = config[:color] && !config[:no_color]
+
       case config[:verbosity]
       when 0
         Chef::Config[:log_level] = :error
@@ -313,50 +324,127 @@ class Chef
       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 load_from_file(klass, from_file, bag=nil)
-      relative_path = ""
-      if klass == Chef::Role
-        relative_path = "roles"
-      elsif klass == Chef::Node
-        relative_path = "nodes"
-      elsif klass == Chef::DataBagItem
-        relative_path = "data_bags/#{bag}"
-      elsif klass == Chef::Environment
-        relative_path = "environments"
+    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
+      run
+    rescue Exception => e
+      raise if config[:verbosity] == 2
+      humanize_exception(e)
+      exit 100
+    end
 
-      relative_file = File.expand_path(File.join(Dir.pwd, relative_path, from_file))
-      filename = nil
-
-      if file_exists_and_is_readable?(from_file)
-        filename = from_file
-      elsif file_exists_and_is_readable?(relative_file)
-        filename = relative_file
+    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  "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.fatal("Cannot find file #{from_file}")
-        exit 30
+        ui.error "#{e.class.name}: #{e.message}"
       end
+    end
 
-      case from_file
-      when /\.(js|json)$/
-        Chef::JSONCompat.from_json(IO.read(filename))
-      when /\.rb$/
-        r = klass.new
-        r.from_file(filename)
-        r
+    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.fatal("File must end in .js, .json, or .rb")
-        exit 30
+        ui.error response.message
+        ui.info "Response: #{format_rest_error(response)}"
       end
     end
 
-    def file_exists_and_is_readable?(file)
-      File.exists?(file) && File.readable?(file)
+    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)
@@ -426,6 +514,10 @@ class Chef
       end
     end
 
+    def server_url
+      Chef::Config[:chef_server_url]
+    end
+
   end
 end
 

data/lib/chef/knife/cookbook_metadata.rb

@@ -24,6 +24,7 @@ class Chef
     class CookbookMetadata < Knife
 
       deps do
+        require 'chef/cookbook_loader'
         require 'chef/cookbook/metadata'
       end
 
@@ -49,12 +50,16 @@ class Chef
             generate_metadata(cname.to_s)
           end
         else
-          generate_metadata(@name_args[0])
+          cookbook_name = @name_args[0]
+          if cookbook_name.nil? || cookbook_name.empty?
+            ui.error "You must specify the cookbook to generate metadata for, or use the --all option."
+            exit 1
+          end
+          generate_metadata(cookbook_name)
         end
       end
 
       def generate_metadata(cookbook)
-        ui.info("Generating Metadata")
         Array(config[:cookbook_path]).reverse.each do |path|
           file = File.expand_path(File.join(path, cookbook, 'metadata.rb'))
           if File.exists?(file)
@@ -66,7 +71,7 @@ class Chef
       end
 
       def generate_metadata_from_file(cookbook, file)
-        Chef::Log.debug("Generating metadata for #{cookbook} from #{file}")
+        ui.info("Generating metadata for #{cookbook} from #{file}")
         md = Chef::Cookbook::Metadata.new
         md.name(cookbook)
         md.from_file(file)

data/lib/chef/knife/cookbook_site_install.rb

@@ -17,143 +17,19 @@
 #
 
 require 'chef/knife'
-require 'chef/mixin/shell_out'
 
 class Chef
   class Knife
-    class CookbookRepo
-
-      DIRTY_REPO = /^[\s]+M/
-
-      include Chef::Mixin::ShellOut
-
-      attr_reader :repo_path
-      attr_reader :default_branch
-      attr_reader :ui
-
-      def initialize(repo_path, ui, opts={})
-        @repo_path = repo_path
-        @ui = ui
-        @default_branch = 'master'
-      end
-
-      def sanity_check
-        unless ::File.directory?(repo_path)
-          ui.error("The cookbook repo path #{repo_path} does not exist or is not a directory")
-          exit 1
-        end
-        unless git_repo?(repo_path)
-          ui.error "The cookbook repo #{repo_path} is not a git repository."
-          ui.info("Use `git init` to initialize a git repo")
-          exit 1
-        end
-        unless branch_exists?(default_branch)
-          ui.error "The default branch '#{default_branch}' does not exist"
-          ui.info "If this is a new git repo, make sure you have at least one commit before installing cookbooks"
-          exit 1
-        end
-        cmd = git('status --porcelain')
-        if cmd.stdout =~ DIRTY_REPO
-          ui.error "You have uncommitted changes to your cookbook repo (#{repo_path}):"
-          ui.msg cmd.stdout
-          ui.info "Commit or stash your changes before importing cookbooks"
-          exit 1
-        end
-        # TODO: any untracked files in the cookbook directory will get nuked later
-        # make this an error condition also.
-        true
-      end
-
-      def reset_to_default_state
-        ui.info("Checking out the #{default_branch} branch.")
-        git("checkout #{default_branch}")
-      end
-
-      def prepare_to_import(cookbook_name)
-        branch = "chef-vendor-#{cookbook_name}"
-        if branch_exists?(branch)
-          ui.info("Pristine copy branch (#{branch}) exists, switching to it.")
-          git("checkout #{branch}")
-        else
-          ui.info("Creating pristine copy branch #{branch}")
-          git("checkout -b #{branch}")
-        end
-      end
-
-      def finalize_updates_to(cookbook_name, version)
-        if update_count = updated?(cookbook_name)
-          ui.info "#{update_count} files updated, committing changes"
-          git("add #{cookbook_name}")
-          git("commit -m 'Import #{cookbook_name} version #{version}' -- #{cookbook_name}")
-          ui.info("Creating tag cookbook-site-imported-#{cookbook_name}-#{version}")
-          git("tag -f cookbook-site-imported-#{cookbook_name}-#{version}")
-          true
-        else
-          ui.info("No changes made to #{cookbook_name}")
-          false
-        end
-      end
-
-      def merge_updates_from(cookbook_name, version)
-        branch = "chef-vendor-#{cookbook_name}"
-        Dir.chdir(repo_path) do
-          if system("git merge #{branch}")
-            ui.info("Cookbook #{cookbook_name} version #{version} successfully installed")
-          else
-            ui.error("You have merge conflicts - please resolve manually")
-            ui.info("Merge status (cd #{repo_path}; git status):")
-            system("git status")
-            exit 3
-          end
-        end
-      end
-
-      def updated?(cookbook_name)
-        update_count = git("status --porcelain -- #{cookbook_name}").stdout.strip.lines.count
-        update_count == 0 ? nil : update_count
-      end
-
-      def branch_exists?(branch_name)
-        git("branch --no-color").stdout.lines.any? {|l| l.include?(branch_name) }
-      end
-
-      private
-
-      def git_repo?(directory)
-        if File.directory?(File.join(directory, '.git'))
-          return true
-        elsif File.dirname(directory) == directory
-          return false
-        else
-          git_repo?(File.dirname(directory))
-        end
-      end
-
-      def apply_opts(opts)
-        opts.each do |option, value|
-          case option.to_s
-          when 'default_branch'
-            @default_branch = value
-          else
-            raise ArgumentError, "invalid option `#{option}' passed to CookbookRepo.new()"
-          end
-        end
-      end
-
-      def git(command)
-        shell_out!("git #{command}", :cwd => repo_path)
-      end
-
-    end
 
     class CookbookSiteInstall < Knife
 
       deps do
         require 'chef/mixin/shell_out'
+        require 'chef/knife/core/cookbook_scm_repo'
         require 'chef/cookbook/metadata'
       end
 
-      banner "knife cookbook site vendor COOKBOOK [VERSION] (options)"
+      banner "knife cookbook site install COOKBOOK [VERSION] (options)"
       category "cookbook site"
 
       option :deps,
@@ -192,7 +68,7 @@ class Chef
         @install_path = config[:cookbook_path].first
         ui.info "Installing #@cookbook_name to #{@install_path}"
 
-        @repo = CookbookRepo.new(@install_path, ui, config)
+        @repo = CookbookSCMRepo.new(@install_path, ui, config)
         #cookbook_path = File.join(vendor_path, name_args[0])
         upstream_file = File.join(@install_path, "#{@cookbook_name}.tar.gz")