chef 0.9.8 → 0.9.10.rc.0

data/distro/common/markdown/knife.mkd

@@ -115,6 +115,13 @@ __ssh QUERY COMMAND__ _(options)_
 
 The _ssh_ sub-command opens an ssh session to each of the nodes in the search results of the _QUERY_. This sub-command requires that the net-ssh-multi and highline Ruby libraries are installed. On Debian systems, these are the libnet-ssh-multi-ruby and libhighline-ruby packages. They can also be installed as RubyGems (net-ssh-multi and highline, respectively).
 
+__status__ _(options)_
+
+  * `-r`, `--run-list RUN_LIST`:
+    Show the run list
+
+The _status_ sub-command searches the Chef Server for all nodes and displays information about the last time the node checked into the server and executed a `node.save`. The fields displayed are the relative checkin time, the node name, it's operating system platform and version, the fully-qualified domain name and the default IP address. If the `-r` option is given, the node's run list will also be displayed. Note that depending on the configuration of the nodes, the FQDN and IP displayed may not be publicly reachable.
+
 ## BOOTSTRAP SUB-COMMANDS
 
 __bootstrap FQDN__ _(options)_

data/distro/debian/etc/default/chef-server

@@ -4,3 +4,6 @@ ADAPTER=thin
 PORT=4000
 USER=chef
 GROUP=chef
+# Sleep to give daemon enough time to fully start or stop.
+STARTTIME=10
+DIETIME=5

data/distro/debian/etc/default/chef-server-webui

@@ -4,3 +4,6 @@ ADAPTER=thin
 PORT=4040
 USER=chef
 GROUP=chef
+# Sleep to give daemon enough time to fully start or stop.
+STARTTIME=10
+DIETIME=5

data/distro/debian/etc/default/chef-solr

@@ -2,3 +2,6 @@ LOGFILE=/var/log/chef/solr.log
 CONFIG=/etc/chef/solr.rb
 USER=chef
 GROUP=chef
+# Sleep to give daemon enough time to fully start or stop.
+DIETIME=5
+STARTTIME=5

data/distro/debian/etc/default/chef-solr-indexer

@@ -2,3 +2,6 @@ LOGFILE=/var/log/chef/solr-indexer.log
 CONFIG=/etc/chef/solr.rb
 USER=chef
 GROUP=chef
+# Sleep to give daemon enough time to fully start or stop.
+DIETIME=5
+STARTTIME=5

data/distro/debian/etc/init.d/chef-server

@@ -57,7 +57,9 @@ stop_server() {
 
 reload_server() {
   stop_server
+  [ -n "$DIETIME" ] && sleep $DIETIME
   start_server
+  [ -n "$STARTTIME" ] && sleep $STARTTIME
 }
 
 case "$1" in
@@ -69,7 +71,7 @@ case "$1" in
         exit 0
     fi
     if start_server ; then
-        sleep 1
+        [ -n "$STARTTIME" ] && sleep $STARTTIME # Wait some time
         if  running ;  then
             log_end_msg 0
         else

data/distro/debian/etc/init.d/chef-server-webui

@@ -58,7 +58,9 @@ stop_server() {
 
 reload_server() {
   stop_server
+  [ -n "$DIETIME" ] && sleep $DIETIME
   start_server
+  [ -n "$STARTTIME" ] && sleep $STARTTIME
 }
 
 case "$1" in
@@ -70,7 +72,7 @@ case "$1" in
         exit 0
     fi
     if start_server ; then
-        sleep 1
+        [ -n "$STARTTIME" ] && sleep $STARTTIME # Wait some time
         if  running ;  then
             log_end_msg 0
         else

data/distro/redhat/etc/init.d/chef-client

@@ -35,7 +35,7 @@ start() {
     [ -x $exec ] || exit 5
     [ -f $config ] || exit 6
     echo -n $"Starting $prog: "
-    daemon chef-client -d -c "$config" -L "$logfile" -i "$interval" -s "$splay" "$options"
+    daemon chef-client -d -c "$config" -L "$logfile" -p "$pidfile" -i "$interval" -s "$splay" "$options"
     retval=$?
     echo
     [ $retval -eq 0 ] && touch $lockfile

data/lib/chef/application.rb

@@ -80,6 +80,8 @@ class Chef::Application
       Chef::Log.warn("Can not find config file: #{config[:config_file]}, using defaults.")
       Chef::Log.warn("#{error.message}")
       Chef::Log.warn("*****************************************")
+
+      Chef::Config.merge!(config)
     end
 
   end

data/lib/chef/application/client.rb

@@ -149,6 +149,9 @@ class Chef::Application::Client < Chef::Application
    
     if Chef::Config[:daemonize]
       Chef::Config[:interval] ||= 1800
+    else
+      Chef::Config[:interval] = nil
+      Chef::Config[:splay] = nil
     end
 
     if Chef::Config[:json_attribs]
@@ -221,9 +224,8 @@ class Chef::Application::Client < 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.fatal("Sleeping for #{Chef::Config[:interval]} seconds before trying again")
+          Chef::Log.error("#{e.class}:#{e}\n#{e.backtrace.join("\n")}")
+          Chef::Log.error("Sleeping for #{Chef::Config[:interval]} seconds before trying again")
           sleep Chef::Config[:interval]
           retry
         else

data/lib/chef/application/knife.rb

@@ -31,6 +31,8 @@ require 'uri'
 
 class Chef::Application::Knife < Chef::Application
 
+  NO_COMMAND_GIVEN = "You need to pass a sub-command (e.g., knife SUB-COMMAND)\n"
+
   banner "Usage: #{$0} sub-command (options)"
 
   option :config_file, 
@@ -114,6 +116,7 @@ class Chef::Application::Knife < Chef::Application
 
   # Run knife 
   def run
+    Mixlib::Log::Formatter.show_time = false
     validate_and_parse_options
     Chef::Knife.run(ARGV, options)
     exit 0
@@ -124,11 +127,15 @@ class Chef::Application::Knife < Chef::Application
   def validate_and_parse_options
     # Checking ARGV validity *before* parse_options because parse_options
     # mangles ARGV in some situations
-    if no_subcommand_given?
-      print_help_and_exit if want_help?
-      print_help_and_exit(2, "Sorry, you need to pass a sub-command first!")
+    if no_command_given?
+      print_help_and_exit(1, NO_COMMAND_GIVEN)
+    elsif no_subcommand_given?
+      if (want_help? || want_version?)
+        print_help_and_exit
+      else 
+        print_help_and_exit(2, NO_COMMAND_GIVEN)
+      end
     end
-    print_help_and_exit if no_command_given?
   end
   
   def no_subcommand_given?
@@ -142,9 +149,13 @@ class Chef::Application::Knife < Chef::Application
   def want_help?
     ARGV[0] =~ /^(--help|-h)$/
   end
+
+  def want_version?
+    ARGV[0] =~ /^(--version|-v)$/
+  end
   
   def print_help_and_exit(exitcode=1, fatal_message=nil)
-    Chef::Log.fatal(fatal_message) if fatal_message
+    Chef::Log.error(fatal_message) if fatal_message
   
     begin
       self.parse_options

data/lib/chef/application/solo.rb

@@ -187,7 +187,6 @@ class Chef::Application::Solo < Chef::Application
         end
 
         @chef_solo = Chef::Client.new(@chef_solo_json)
-        @chef_solo_json = nil
         @chef_solo.run
         @chef_solo = nil
         if Chef::Config[:interval]

data/lib/chef/checksum.rb

@@ -25,7 +25,13 @@ class Chef
   class Checksum
     attr_accessor :checksum, :create_time
     attr_accessor :couchdb_id, :couchdb_rev
-    
+
+    # When a Checksum commits a sandboxed file to its final home in the checksum
+    # repo, this attribute will have the original on-disk path where the file
+    # was stored; it will be used if the commit is reverted to restore the sandbox
+    # to the pre-commit state.
+    attr_reader :original_committed_file_location
+
     DESIGN_DOCUMENT = {
       "version" => 1,
       "language" => "javascript",
@@ -52,6 +58,7 @@ class Chef
     def initialize(checksum=nil, couchdb=nil)
       @create_time = Time.now.iso8601
       @checksum = checksum
+      @original_committed_file_location = nil
     end
     
     def to_json(*a)
@@ -82,6 +89,51 @@ class Chef
       checksum
     end
 
+
+    ##
+    # On-Disk Checksum File Repo (Chef Server API)
+    ##
+
+    def file_location
+      File.join(checksum_repo_directory, checksum)
+    end
+
+    def checksum_repo_directory
+      File.join(Chef::Config.checksum_path, checksum[0..1])
+    end
+
+    # Moves the given +sandbox_file+ into the checksum repo using the path
+    # given by +file_location+ and saves the Checksum to the database
+    def commit_sandbox_file(sandbox_file)
+      @original_committed_file_location = sandbox_file
+      Chef::Log.info("commiting sandbox file: move #{sandbox_file} to #{file_location}")
+      FileUtils.mkdir_p(checksum_repo_directory)
+      File.rename(sandbox_file, file_location)
+      cdb_save
+    end
+
+    # Moves the checksum file back to its pre-commit location and deletes
+    # the checksum object from the database, effectively undoing +commit_sandbox_file+.
+    # Raises Chef::Exceptions::IllegalChecksumRevert if the original file location
+    # is unknown, which is will be the case if commit_sandbox_file was not
+    # previously called
+    def revert_sandbox_file_commit
+      unless original_committed_file_location
+        raise Chef::Exceptions::IllegalChecksumRevert, "Checksum #{self.inspect} cannot be reverted because the original sandbox file location is not known"
+      end
+
+      Chef::Log.warn("reverting sandbox file commit: moving #{file_location} back to #{original_committed_file_location}")
+      File.rename(file_location, original_committed_file_location)
+      cdb_destroy
+    end
+
+    # Removes the on-disk file backing this checksum object, then removes it
+    # from the database
+    def purge
+      purge_file
+      cdb_destroy
+    end
+
     ##
     # Couchdb
     ##
@@ -114,5 +166,17 @@ class Chef
       @couchdb_rev = (couchdb || Chef::CouchDB.new).store("checksum", checksum, self)["rev"]
     end
 
+
+    private
+
+    # Deletes the file backing this checksum from the on-disk repo.
+    # Purging the checksums is how users can get back to a valid state if
+    # they've deleted files, so we silently swallow Errno::ENOENT here.
+    def purge_file
+      FileUtils.rm(file_location)
+    rescue Errno::ENOENT
+      true
+    end
+
   end
 end

data/lib/chef/checksum_cache.rb

@@ -0,0 +1,173 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Daniel DeLeo (<dan@kallistec.com>)
+# Copyright:: Copyright (c) 2009 Opscode, Inc.
+# 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 'set'
+require 'fileutils'
+require 'chef/log'
+require 'chef/config'
+require 'chef/client'
+require 'chef/mixin/convert_to_class_name'
+require 'singleton'
+require 'moneta'
+
+class Chef 
+  class ChecksumCache
+    include Chef::Mixin::ConvertToClassName
+    include ::Singleton
+    
+    attr_reader :moneta
+    
+    def initialize(*args)
+      self.reset!(*args)
+    end
+    
+    def reset!(backend=nil, options=nil)
+      backend ||= Chef::Config[:cache_type]
+      options ||= Chef::Config[:cache_options]
+      
+      begin
+        require "moneta/#{convert_to_snake_case(backend, 'Moneta')}"
+      rescue LoadError => e
+        Chef::Log.fatal("Could not load Moneta back end #{backend.inspect}")
+        raise e
+      end
+     
+      @moneta = Moneta.const_get(backend).new(options)
+    end
+
+    def self.reset_cache_validity
+      @valid_cached_checksums = nil
+    end
+
+    Chef::Client.when_run_starts do |run_status|
+      reset_cache_validity
+    end
+
+    def self.valid_cached_checksums
+      @valid_cached_checksums ||= Set.new
+    end
+
+    def self.validate_checksum(checksum_key)
+      valid_cached_checksums << checksum_key
+    end
+
+    def self.all_cached_checksums
+      all_checksums_with_filenames = {}
+
+      Dir[File.join(Chef::Config[:cache_options][:path], '*')].each do |cksum_file|
+        all_checksums_with_filenames[File.basename(cksum_file)] = cksum_file
+      end
+      all_checksums_with_filenames
+    end
+
+    def self.cleanup_checksum_cache
+      Chef::Log.info("cleaning the checksum cache")
+      if (Chef::Config[:cache_type].to_s == "BasicFile")
+        all_cached_checksums.each do |cache_key, cksum_cache_file|
+          unless valid_cached_checksums.include?(cache_key)
+            remove_unused_checksum(cksum_cache_file)
+          end
+        end
+      end
+    end
+
+    Chef::Client.when_run_completes_successfully do |run_status|
+      cleanup_checksum_cache
+    end
+
+    def self.remove_unused_checksum(checksum_file)
+      Chef::Log.debug("removing unused checksum cache file #{checksum_file}")
+      FileUtils.rm(checksum_file)
+    end
+
+    def self.checksum_for_file(*args)
+      instance.checksum_for_file(*args)
+    end
+
+    def validate_checksum(*args)
+      self.class.validate_checksum(*args)
+    end
+
+    def checksum_for_file(file, key=nil)
+      key ||= generate_key(file)
+      fstat = File.stat(file)
+      lookup_checksum(key, fstat) || generate_checksum(key, file, fstat)
+    end
+
+    def lookup_checksum(key, fstat)
+      cached = @moneta.fetch(key)
+      if cached && file_unchanged?(cached, fstat)
+        validate_checksum(key)
+        cached["checksum"]
+      else
+        nil
+      end
+    end
+
+    def generate_checksum(key, file, fstat)
+      checksum = checksum_file(file, Digest::SHA256.new)
+      moneta.store(key, {"mtime" => fstat.mtime.to_f, "checksum" => checksum})
+      validate_checksum(key)
+      checksum
+    end
+
+    def generate_key(file, group="chef")
+      "#{group}-file-#{file.gsub(/(#{File::SEPARATOR}|\.)/, '-')}"
+    end
+
+    def self.generate_md5_checksum_for_file(*args)
+      instance.generate_md5_checksum_for_file(*args)
+    end
+
+    def generate_md5_checksum_for_file(file)
+      checksum_file(file, Digest::MD5.new)
+    end
+
+    def generate_md5_checksum(io)
+      checksum_io(io, Digest::MD5.new)
+    end
+
+    private
+
+    def file_unchanged?(cached, fstat)
+      cached["mtime"].to_f == fstat.mtime.to_f
+    end
+
+    def checksum_file(file, digest)
+      File.open(file) { |f| checksum_io(f, digest) }
+    end
+
+    def checksum_io(io, digest)
+      while chunk = io.read(1024 * 8)
+        digest.update(chunk)
+      end
+      digest.hexdigest
+    end
+
+  end
+end
+
+module Moneta
+  module Defaults
+    def default
+      nil
+    end
+  end
+end