chef 11.10.4-x86-mingw32 → 11.12.0.alpha.1-x86-mingw32

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dddfe18a6d04b87280ee0777f536f0ce6252697b
+  data.tar.gz: 94116c273d11917139c8ac129f8a450d5c0afcdb
+SHA512:
+  metadata.gz: 7a4d41432cf787f14d92c58b4e2e1ed8f18b1f92cc50754da6124b2c692454953949859e0eb525f069e6ebbb5faa1ed564b292315e29723df440d218c3ef9a91
+  data.tar.gz: ecab7c1677eed8ed83a6d24b5116a8dc629cc8b869aa70b4eee8e22d5573e1d121c4dd19f93c298dd97181787d0220a3f717e82f7ca69f42211766a810512301

data/CONTRIBUTING.md

@@ -24,7 +24,7 @@ Chef uses the Apache 2.0 license to strike a balance between open contribution a
 The license tells you what rights you have that are provided by the copyright holder. It is important that the contributor fully understands what rights
 they are licensing and agrees to them. Sometimes the copyright holder isn't the contributor, most often when the contributor is doing work for a company.
 
-To make a good faith effort to ensure these criteria are met, Opscode requires a Contributor License Agreement (CLA) or a Corporate Contributor License
+To make a good faith effort to ensure these criteria are met, Chef requires a Contributor License Agreement (CLA) or a Corporate Contributor License
 Agreement (CCLA) for all contributions. This is without exception due to some matters not being related to copyright and to avoid having to continually
 check with our lawyers about small patches.
 
@@ -74,7 +74,7 @@ helpful to be clear about your use case and change so they can understand it eve
 
 ### Github and Pull Requests
 
-All of Opscode's open source projects are available on [Github](http://www.github.com/opscode).
+All of Chef's open source projects are available on [Github](http://www.github.com/opscode).
 
 We don't require you to use Github, and we will even take patch diffs attached to tickets on the tracker.
 However Github has a lot of convenient features, such as being able to see a diff of changes between a
@@ -115,7 +115,7 @@ and accounting for it.
 
 ## Code Review
 
-Opscode regularly reviews code contributions and provides suggestions for improvement in the code itself or the implementation.
+Chef regularly reviews code contributions and provides suggestions for improvement in the code itself or the implementation.
 
 We find contributions by searching the ticket tracker for _resolved_ tickets with a status of _fixed_. If we have feedback we will
 reopen the ticket and you should resolve it again when you've made the changes or have a response to our feedback. When we believe
@@ -134,14 +134,14 @@ The versioning for the Chef project is X.Y.Z.
 * Y is a minor release, which adds both new features and bug fixes
 * Z is a patch release, which adds just bug fixes
 
-Major releases and have historically been once a year. Minor releases for Chef average every two months and patch releases come as needed.
+Major releases have historically been once a year. Minor releases for Chef average every three months and patch releases come as needed.
 
 There are usually beta releases and release candidates (RC) of major and minor releases announced on
 the [chef-dev mailing list](http://lists.opscode.com/sympa/info/chef-dev). Once an RC is released, we wait at least three
 days to allow for testing for regressions before the final release. If a blocking regression is found then another RC is made containing
 the fix and the timer is reset.
 
-Once the official release is made, the release notes are available on the [Opscode blog](http://www.opscode.com/blog).
+Once the official release is made, the release notes are available on the [Chef blog](http://www.getchef.com/blog).
 
 ## Working with the community
 
@@ -151,5 +151,5 @@ These resources will help you learn more about Chef and connect to other members
 * #chef and #chef-hacking IRC channels on irc.freenode.net
 * [Community Cookbook site](http://community.opscode.com)
 * [Chef wiki](http://wiki.opscode.com/display/chef)
-* Opscode Chef [product page](http://www.opscode.com/chef)
+* Chef [product page](http://www.getchef.com/chef)
 

data/README.md

@@ -61,7 +61,7 @@ Then get the source and install it:
 
 Before working on the code, if you plan to contribute your changes, you need to
 read the
-[Opscode Contributing document](http://docs.opscode.com/community_contributions.html).
+[Chef Contributions document](http://docs.opscode.com/community_contributions.html).
 
 You will also need to set up the repository with the appropriate branches. We
 document the process on the

data/lib/chef/api_client.rb

@@ -162,9 +162,7 @@ class Chef
       if response.kind_of?(Chef::ApiClient)
         response
       else
-        client = Chef::ApiClient.new
-        client.name(response['clientname'])
-        client
+        json_create(response)
       end
     end
 

data/lib/chef/application.rb

@@ -208,7 +208,8 @@ class Chef::Application
     @chef_client = Chef::Client.new(
       @chef_client_json,
       :override_runlist => config[:override_runlist],
-      :specific_recipes => specific_recipes
+      :specific_recipes => specific_recipes,
+      :runlist => config[:runlist]
     )
     @chef_client_json = nil
 

data/lib/chef/application/client.rb

@@ -170,7 +170,7 @@ class Chef::Application::Client < Chef::Application
   option :override_runlist,
     :short        => "-o RunlistItem,RunlistItem...",
     :long         => "--override-runlist RunlistItem,RunlistItem...",
-    :description  => "Replace current run list with specified items",
+    :description  => "Replace current run list with specified items for a single run",
     :proc         => lambda{|items|
       items = items.split(',')
       items.compact.map{|item|
@@ -178,6 +178,16 @@ class Chef::Application::Client < Chef::Application
       }
     }
 
+  option :runlist,
+    :short        => "-r RunlistItem,RunlistItem...",
+    :long         => "--runlist RunlistItem,RunlistItem...",
+    :description  => "Permanently replace current run list with specified items",
+    :proc         => lambda{|items|
+      items = items.split(',')
+      items.compact.map{|item|
+        Chef::RunList::RunListItem.new(item)
+      }
+    }
   option :why_run,
     :short        => '-W',
     :long         => '--why-run',

data/lib/chef/client.rb

@@ -44,6 +44,7 @@ require 'chef/version'
 require 'chef/resource_reporter'
 require 'chef/run_lock'
 require 'chef/policy_builder'
+require 'chef/request_id'
 require 'ohai'
 require 'rbconfig'
 
@@ -54,6 +55,16 @@ class Chef
   class Client
     include Chef::Mixin::PathSanity
 
+    # IO stream that will be used as 'STDOUT' for formatters. Formatters are
+    # configured during `initialize`, so this provides a convenience for
+    # setting alternative IO stream during tests.
+    STDOUT_FD = STDOUT
+
+    # IO stream that will be used as 'STDERR' for formatters. Formatters are
+    # configured during `initialize`, so this provides a convenience for
+    # setting alternative IO stream during tests.
+    STDERR_FD = STDERR
+
     # Clears all notifications for client run status events.
     # Primarily for testing purposes.
     def self.clear_notifications
@@ -128,15 +139,13 @@ class Chef
     attr_accessor :rest
     attr_accessor :runner
 
-    #--
-    # TODO: timh/cw: 5-19-2010: json_attribs should be moved to RunContext?
     attr_reader :json_attribs
     attr_reader :run_status
     attr_reader :events
 
     # Creates a new Chef::Client.
     def initialize(json_attribs=nil, args={})
-      @json_attribs = json_attribs
+      @json_attribs = json_attribs || {}
       @node = nil
       @run_status = nil
       @runner = nil
@@ -148,12 +157,16 @@ class Chef
       @events = EventDispatch::Dispatcher.new(*event_handlers)
       @override_runlist = args.delete(:override_runlist)
       @specific_recipes = args.delete(:specific_recipes)
+
+      if new_runlist = args.delete(:runlist)
+        @json_attribs["run_list"] = new_runlist
+      end
     end
 
     def configure_formatters
       formatters_for_run.map do |formatter_name, output_path|
         if output_path.nil?
-          Chef::Formatters.new(formatter_name, STDOUT, STDERR)
+          Chef::Formatters.new(formatter_name, STDOUT_FD, STDERR_FD)
         else
           io = File.open(output_path, "a+")
           io.sync = true
@@ -280,13 +293,10 @@ class Chef
     end
 
     def node_name
-      name = Chef::Config[:node_name] || ohai[:fqdn] || ohai[:hostname]
+      name = Chef::Config[:node_name] || ohai[:fqdn] || ohai[:machinename] || ohai[:hostname]
       Chef::Config[:node_name] = name
 
-      unless name
-        msg = "Unable to determine node name: configure node_name or configure the system's hostname and fqdn"
-        raise Chef::Exceptions::CannotDetermineNodeName, msg
-      end
+      raise Chef::Exceptions::CannotDetermineNodeName unless name
 
       # node names > 90 bytes only work with authentication protocol >= 1.1
       # see discussion in config.rb.
@@ -391,10 +401,12 @@ class Chef
       # don't add code that may fail before entering this section to be sure to release lock
       begin
         runlock.save_pid
+        request_id = Chef::RequestID.instance.request_id
         run_context = nil
         @events.run_start(Chef::VERSION)
         Chef::Log.info("*** Chef #{Chef::VERSION} ***")
         Chef::Log.info "Chef-client pid: #{Process.pid}"
+        Chef::Log.debug("Chef-client request_id: #{request_id}")
         enforce_path_sanity
         run_ohai
         @events.ohai_completed(node)
@@ -404,6 +416,7 @@ class Chef
 
         build_node
 
+        run_status.run_id = request_id
         run_status.start_clock
         Chef::Log.info("Starting Chef Run for #{node.name}")
         run_started
@@ -434,6 +447,8 @@ class Chef
         @events.run_failed(e)
         raise
       ensure
+        Chef::RequestID.instance.reset_request_id
+        request_id = nil
         @run_status = nil
         run_context = nil
         runlock.release

data/lib/chef/cookbook/syntax_check.rb

@@ -17,6 +17,8 @@
 #
 
 require 'pathname'
+require 'stringio'
+require 'erubis'
 require 'chef/mixin/shell_out'
 require 'chef/mixin/checksum'
 
@@ -161,28 +163,127 @@ class Chef
 
       def validate_template(erb_file)
         Chef::Log.debug("Testing template #{erb_file} for syntax errors...")
-        result = shell_out("erubis -x #{erb_file} | ruby -c")
+        if validate_inline?
+          validate_erb_file_inline(erb_file)
+        else
+          validate_erb_via_subcommand(erb_file)
+        end
+      end
+
+      def validate_ruby_file(ruby_file)
+        Chef::Log.debug("Testing #{ruby_file} for syntax errors...")
+        if validate_inline?
+          validate_ruby_file_inline(ruby_file)
+        else
+          validate_ruby_by_subcommand(ruby_file)
+        end
+      end
+
+      # Whether or not we're running on a version of ruby that can support
+      # inline validation. Inline validation relies on the `RubyVM` features
+      # introduced with ruby 1.9, so 1.8 cannot be supported.
+      def validate_inline?
+        defined?(RubyVM::InstructionSequence)
+      end
+
+      # Validate the ruby code in an erb template. Uses RubyVM to do syntax
+      # checking, so callers should check #validate_inline? before calling.
+      def validate_erb_file_inline(erb_file)
+        old_stderr = $stderr
+
+        engine = Erubis::Eruby.new
+        engine.convert!(IO.read(erb_file))
+
+        ruby_code = engine.src
+
+        # Even when we're compiling the code w/ RubyVM, syntax errors just
+        # print to $stderr. We want to capture this and handle the printing
+        # ourselves, so we must temporarily swap $stderr to capture the output.
+        tmp_stderr = $stderr = StringIO.new
+
+        abs_path = File.expand_path(erb_file)
+        RubyVM::InstructionSequence.new(ruby_code, erb_file, abs_path, 0)
+
+        true
+      rescue SyntaxError
+        $stderr = old_stderr
+        invalid_erb_file(erb_file, tmp_stderr.string)
+        false
+      ensure
+        # be paranoid about setting stderr back to the old value.
+        $stderr = old_stderr if defined?(old_stderr) && old_stderr
+      end
+
+      # Validate the ruby code in an erb template. Pipes the output of `erubis
+      # -x` to `ruby -c`, so it works with any ruby version, but is much slower
+      # than the inline version.
+      # --
+      # TODO: This can be removed when ruby 1.8 support is dropped.
+      def validate_erb_via_subcommand(erb_file)
+        result = shell_out("erubis -x #{erb_file} | #{ruby} -c")
         result.error!
         true
       rescue Mixlib::ShellOut::ShellCommandFailed
+        invalid_erb_file(erb_file, result.stderr)
+        false
+      end
+
+      # Debug a syntax error in a template.
+      def invalid_erb_file(erb_file, error_message)
         file_relative_path = erb_file[/^#{Regexp.escape(cookbook_path+File::Separator)}(.*)/, 1]
         Chef::Log.fatal("Erb template #{file_relative_path} has a syntax error:")
-        result.stderr.each_line { |l| Chef::Log.fatal(l.chomp) }
+        error_message.each_line { |l| Chef::Log.fatal(l.chomp) }
+        nil
+      end
+
+      # Validate the syntax of a ruby file. Uses (Ruby 1.9+ only) RubyVM to
+      # compile the code without evaluating it or spawning a new process.
+      # Callers should check #validate_inline? before calling.
+      def validate_ruby_file_inline(ruby_file)
+        # Even when we're compiling the code w/ RubyVM, syntax errors just
+        # print to $stderr. We want to capture this and handle the printing
+        # ourselves, so we must temporarily swap $stderr to capture the output.
+        old_stderr = $stderr
+        tmp_stderr = $stderr = StringIO.new
+        abs_path = File.expand_path(ruby_file)
+        file_content = IO.read(abs_path)
+        RubyVM::InstructionSequence.new(file_content, ruby_file, abs_path, 0)
+        true
+      rescue SyntaxError
+        $stderr = old_stderr
+        invalid_ruby_file(ruby_file, tmp_stderr.string)
         false
+      ensure
+        # be paranoid about setting stderr back to the old value.
+        $stderr = old_stderr if defined?(old_stderr) && old_stderr
       end
 
-      def validate_ruby_file(ruby_file)
-        Chef::Log.debug("Testing #{ruby_file} for syntax errors...")
-        result = shell_out("ruby -c #{ruby_file}")
+      # Validate the syntax of a ruby file by shelling out to `ruby -c`. Should
+      # work for all ruby versions, but is slower and uses more resources than
+      # the inline strategy.
+      def validate_ruby_by_subcommand(ruby_file)
+        result = shell_out("#{ruby} -c #{ruby_file}")
         result.error!
         true
       rescue Mixlib::ShellOut::ShellCommandFailed
+        invalid_ruby_file(ruby_file, result.stderr)
+        false
+      end
+
+      # Debugs ruby syntax errors by printing the path to the file and any
+      # diagnostic info given in +error_message+
+      def invalid_ruby_file(ruby_file, error_message)
         file_relative_path = ruby_file[/^#{Regexp.escape(cookbook_path+File::Separator)}(.*)/, 1]
         Chef::Log.fatal("Cookbook file #{file_relative_path} has a ruby syntax error:")
-        result.stderr.each_line { |l| Chef::Log.fatal(l.chomp) }
+        error_message.each_line { |l| Chef::Log.fatal(l.chomp) }
         false
       end
 
+      # Returns the full path to the running ruby.
+      def ruby
+        Gem.ruby
+      end
+
     end
   end
 end

data/lib/chef/dsl/reboot_pending.rb

@@ -0,0 +1,61 @@
+# Author:: Bryan McLellan <btm@loftninjas.org>
+# Author:: Seth Chisamore <schisamo@opscode.com>
+# Copyright:: Copyright (c) 2011,2014, Chef Software, 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/dsl/platform_introspection'
+require 'chef/dsl/registry_helper'
+
+class Chef
+  module DSL
+    module RebootPending
+
+      include Chef::DSL::RegistryHelper
+      include Chef::DSL::PlatformIntrospection
+
+      # Returns true if the system needs a reboot or is expected to reboot
+      # Raises UnsupportedPlatform if this functionality isn't provided yet
+      def reboot_pending?
+
+        if platform?("windows")
+          # PendingFileRenameOperations contains pairs (REG_MULTI_SZ) of filenames that cannot be updated
+          # due to a file being in use (usually a temporary file and a system file)
+          # \??\c:\temp\test.sys!\??\c:\winnt\system32\test.sys
+          # http://technet.microsoft.com/en-us/library/cc960241.aspx
+          registry_value_exists?('HKLM\SYSTEM\CurrentControlSet\Control\Session Manager', { :name => 'PendingFileRenameOperations' }) ||
+
+          # RebootRequired key contains Update IDs with a value of 1 if they require a reboot.
+          # The existence of RebootRequired alone is sufficient on my Windows 8.1 workstation in Windows Update
+          registry_key_exists?('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired') ||
+
+          # Vista + Server 2008 and newer may have reboots pending from CBS
+          registry_key_exists?('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootRequired') ||
+
+          # The mere existance of the UpdateExeVolatile key should indicate a pending restart for certain updates
+          # http://support.microsoft.com/kb/832475
+          (registry_key_exists?('HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile') &&
+                !registry_get_values('HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile').select { |v| v[:name] == "Flags" }[0].nil? &&
+                [1,2,3].include?(registry_get_values('HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile').select { |v| v[:name] == "Flags" }[0][:data]))
+        elsif platform?("ubuntu")
+          # This should work for Debian as well if update-notifier-common happens to be installed. We need an API for that.
+          File.exists?('/var/run/reboot-required')
+        else
+          raise Chef::Exceptions::UnsupportedPlatform.new(node[:platform])
+        end
+      end
+    end
+  end
+end

data/lib/chef/exceptions.rb

@@ -50,7 +50,13 @@ class Chef
     class Override < RuntimeError; end
     class UnsupportedAction < RuntimeError; end
     class MissingLibrary < RuntimeError; end
-    class CannotDetermineNodeName < RuntimeError; end
+
+    class CannotDetermineNodeName < RuntimeError
+      def initialize
+        super "Unable to determine node name: configure node_name or configure the system's hostname and fqdn"
+      end
+    end
+
     class User < RuntimeError; end
     class Group < RuntimeError; end
     class Link < RuntimeError; end
@@ -309,5 +315,10 @@ class Chef
       end
     end
 
+    class UnsupportedPlatform < RuntimeError
+      def initialize(platform)
+        super "This functionality is not supported on platform #{platform}."
+      end
+    end
   end
 end