chef 11.14.0.alpha.2-x86-mingw32 → 11.14.0.alpha.3-x86-mingw32

data/lib/chef/knife/bootstrap/chef-full.erb

@@ -19,20 +19,23 @@ exists() {
   fi
 }
 
-install_sh="https://www.opscode.com/chef/install.sh"
-version_string="-v <%= chef_version %>"
-
-if ! exists /usr/bin/chef-client; then
-  echo "Installing Chef Client..."
-  if exists wget; then
-    bash <(wget <%= "--proxy=on " if knife_config[:bootstrap_proxy] %> ${install_sh} -O -) ${version_string}
-  elif exists curl; then
-    bash <(curl -L <%= "--proxy \"#{knife_config[:bootstrap_proxy]}\" " if knife_config[:bootstrap_proxy] %> ${install_sh}) ${version_string}
-  else
-    echo "Neither wget nor curl found. Please install one and try again." >&2
-    exit 1
+<% if knife_config[:bootstrap_install_command] %>
+  <%= knife_config[:bootstrap_install_command] %>
+<% else %>
+  install_sh="<%= knife_config[:bootstrap_url] ? knife_config[:bootstrap_url] : "https://www.opscode.com/chef/install.sh" %>"
+  version_string="-v <%= chef_version %>"
+  if ! exists /usr/bin/chef-client; then
+    echo "Installing Chef Client..."
+    if exists wget; then
+      bash <(wget <%= "--proxy=on " if knife_config[:bootstrap_proxy] %> <%= knife_config[:bootstrap_wget_options] %> ${install_sh} -O -) <%= latest_current_chef_version_string %>
+    elif exists curl; then
+      bash <(curl -L <%= "--proxy \"#{knife_config[:bootstrap_proxy]}\" " if knife_config[:bootstrap_proxy] %> <%= knife_config[:bootstrap_curl_options] %> ${install_sh}) <%= latest_current_chef_version_string %>
+    else
+      echo "Neither wget nor curl found. Please install one and try again." >&2
+      exit 1
+    fi
   fi
-fi
+<% end %>
 
 mkdir -p /etc/chef
 

data/lib/chef/knife/core/bootstrap_context.rb

@@ -101,10 +101,35 @@ CONFIG
           @chef_config.key?(:knife) ? @chef_config[:knife] : {}
         end
 
+        #
+        # This function is used by older bootstrap templates other than chef-full
+        # and potentially by custom templates as well hence it's logic needs to be
+        # preserved for backwards compatibility reasons until we hit Chef 12.
         def chef_version
           knife_config[:bootstrap_version] || Chef::VERSION
         end
 
+        #
+        # chef version string to fetch the latest current version from omnitruck
+        # If user is on X.Y.Z bootstrap will use the latest X release
+        # X here can be 10 or 11
+        def latest_current_chef_version_string
+          chef_version_string = if knife_config[:bootstrap_version]
+            knife_config[:bootstrap_version]
+          else
+            Chef::VERSION.split(".").first
+          end
+
+          installer_version_string = ["-v", chef_version_string]
+
+          # If bootstrapping a pre-release version add -p to the installer string
+          if chef_version_string.split(".").length > 3
+            installer_version_string << "-p"
+          end
+
+          installer_version_string.join(" ")
+        end
+
         def first_boot
           (@config[:first_boot_attributes] || {}).merge(:run_list => @run_list)
         end
@@ -113,4 +138,3 @@ CONFIG
     end
   end
 end
-

data/lib/chef/knife/list.rb

@@ -43,21 +43,23 @@ class Chef
       def run
         patterns = name_args.length == 0 ? [""] : name_args
 
-        # Get the matches (recursively)
-        all_results = parallelize(pattern_args_from(patterns), :flatten => true) do |pattern|
-          pattern_results = Chef::ChefFS::FileSystem.list(config[:local] ? local_fs : chef_fs, pattern)
+        # Get the top-level matches
+        args = pattern_args_from(patterns)
+        all_results = parallelize(pattern_args_from(patterns)) do |pattern|
+          pattern_results = Chef::ChefFS::FileSystem.list(config[:local] ? local_fs : chef_fs, pattern).to_a
           if pattern_results.first && !pattern_results.first.exists? && pattern.exact_path
             ui.error "#{format_path(pattern_results.first)}: No such file or directory"
             self.exit_code = 1
           end
           pattern_results
-        end
+        end.flatten(1).to_a
 
         # Process directories
         if !config[:bare_directories]
-          dir_results = parallelize(all_results.select { |result| result.dir? }, :flatten => true) do |result|
+          dir_results = parallelize(all_results.select { |result| result.dir? }) do |result|
             add_dir_result(result)
-          end.to_a
+          end.flatten(1)
+
         else
           dir_results = []
         end
@@ -109,7 +111,7 @@ class Chef
         result = [ [ result, children ] ]
         if config[:recursive]
           child_dirs = children.select { |child| child.dir? }
-          result += parallelize(child_dirs, :flatten => true) { |child| add_dir_result(child) }.to_a
+          result += parallelize(child_dirs) { |child| add_dir_result(child) }.flatten(1).to_a
         end
         result
       end
@@ -152,4 +154,3 @@ class Chef
     end
   end
 end
-

data/lib/chef/knife/serve.rb

@@ -0,0 +1,44 @@
+require 'chef/knife'
+
+class Chef
+  class Knife
+    class Serve < Knife
+      option :repo_mode,
+        :long => '--repo-mode MODE',
+        :description => "Specifies the local repository layout.  Values: static (only environments/roles/data_bags/cookbooks), everything (includes nodes/clients/users), hosted_everything (includes acls/groups/etc. for Enterprise/Hosted Chef).  Default: everything/hosted_everything"
+
+      option :chef_repo_path,
+        :long => '--chef-repo-path PATH',
+        :description => 'Overrides the location of chef repo. Default is specified by chef_repo_path in the config'
+
+      option :chef_zero_host,
+        :long => '--chef-zero-host IP',
+        :description => 'Overrides the host upon which chef-zero listens. Default is 127.0.0.1.'
+
+      def configure_chef
+        super
+        Chef::Config.local_mode = true
+        Chef::Config[:repo_mode] = config[:repo_mode] if config[:repo_mode]
+
+        # --chef-repo-path forcibly overrides all other paths
+        if config[:chef_repo_path]
+          Chef::Config.chef_repo_path = config[:chef_repo_path]
+          %w(acl client cookbook container data_bag environment group node role user).each do |variable_name|
+            Chef::Config.delete("#{variable_name}_path".to_sym)
+          end
+        end
+      end
+
+      def run
+        begin
+          server = Chef::Application.chef_zero_server
+          output "Serving files from:\n#{server.options[:data_store].chef_fs.fs_description}"
+          server.stop
+          server.start(stdout) # to print header
+        ensure
+          server.stop
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/show.rb

@@ -20,7 +20,7 @@ class Chef
       def run
         # Get the matches (recursively)
         error = false
-        entry_values = parallelize(pattern_args, :flatten => true) do |pattern|
+        entry_values = parallelize(pattern_args) do |pattern|
           parallelize(Chef::ChefFS::FileSystem.list(config[:local] ? local_fs : chef_fs, pattern)) do |entry|
             if entry.dir?
               ui.error "#{format_path(entry)}: is a directory" if pattern.exact_path
@@ -40,7 +40,7 @@ class Chef
               end
             end
           end
-        end
+        end.flatten(1)
         entry_values.each do |entry, value|
           if entry
             output "#{format_path(entry)}:"
@@ -54,4 +54,3 @@ class Chef
     end
   end
 end
-

data/lib/chef/knife/ssh.rb

@@ -30,6 +30,7 @@ class Chef
         require 'chef/exceptions'
         require 'chef/search/query'
         require 'chef/mixin/shell_out'
+        require 'chef/mixin/command'
         require 'mixlib/shellout'
       end
 

data/lib/chef/mixin/create_path.rb

@@ -44,14 +44,30 @@ class Chef
 
         file_path.each_index do |i|
           create_path = File.join(file_path[0, i + 1])
-          unless File.directory?(create_path)
-            Chef::Log.debug("Creating directory #{create_path}")
-            Dir.mkdir(create_path)
-          end
+          create_dir(create_path) unless File.directory?(create_path)
         end
+
         File.expand_path(File.join(file_path))
       end
 
+      private
+
+      def create_dir(path)
+        begin
+          # When doing multithreaded downloads into the file cache, the following
+          # interleaving raises an error here:
+          #
+          # thread1                                     thread2
+          # File.directory?(create_path) <- false
+          #                                             File.directory?(create_path) <- false
+          #                                             Dir.mkdir(create_path)
+          # Dir.mkdir(create_path) <- raises Errno::EEXIST
+          Chef::Log.debug("Creating directory #{path}")
+          Dir.mkdir(path)
+        rescue Errno::EEXIST
+        end
+      end
+
     end
   end
 end

data/lib/chef/node.rb

@@ -34,6 +34,7 @@ require 'chef/node/attribute'
 require 'chef/mash'
 require 'chef/json_compat'
 require 'chef/search/query'
+require 'chef/whitelist'
 
 class Chef
   class Node
@@ -520,18 +521,18 @@ class Chef
         if Chef::Config[:why_run]
           Chef::Log.warn("In whyrun mode, so NOT performing node save.")
         else
-          chef_server_rest.put_rest("nodes/#{name}", self)
+          chef_server_rest.put_rest("nodes/#{name}", data_for_save)
         end
       rescue Net::HTTPServerException => e
         raise e unless e.response.code == "404"
-        chef_server_rest.post_rest("nodes", self)
+        chef_server_rest.post_rest("nodes", data_for_save)
       end
       self
     end
 
     # Create the node via the REST API
     def create
-      chef_server_rest.post_rest("nodes", self)
+      chef_server_rest.post_rest("nodes", data_for_save)
       self
     end
 
@@ -543,5 +544,20 @@ class Chef
       self.name <=> other_node.name
     end
 
+    private
+
+    def data_for_save
+      data = for_json
+      ["automatic", "default", "normal", "override"].each do |level|
+        whitelist_config_option = "#{level}_attribute_whitelist".to_sym
+        whitelist = Chef::Config[whitelist_config_option]
+        unless whitelist.nil? # nil => save everything
+          Chef::Log.info("Whitelisting #{level} node attributes for save.")
+          data[level] = Chef::Whitelist.filter(data[level], whitelist)
+        end
+      end
+      data
+    end
+
   end
 end

data/lib/chef/platform/provider_mapping.rb

@@ -57,7 +57,6 @@ class Chef
             :freebsd => {
               :default => {
                 :group   => Chef::Provider::Group::Pw,
-                :package => Chef::Provider::Package::Freebsd,
                 :service => Chef::Provider::Service::Freebsd,
                 :user    => Chef::Provider::User::Pw,
                 :cron    => Chef::Provider::Cron

data/lib/chef/platform/query_helpers.rb

@@ -30,15 +30,16 @@ class Chef
 
       def windows_server_2003?
         return false unless windows?
-        require 'ruby-wmi'
+        require 'wmi-lite/wmi'
 
         # CHEF-4888: Work around ruby #2618, expected to be fixed in Ruby 2.1.0
         # https://github.com/ruby/ruby/commit/588504b20f5cc880ad51827b93e571e32446e5db
         # https://github.com/ruby/ruby/commit/27ed294c7134c0de582007af3c915a635a6506cd
         WIN32OLE.ole_initialize
 
-        host = WMI::Win32_OperatingSystem.find(:first)
-        is_server_2003 = (host.version && host.version.start_with?("5.2"))
+        wmi = WmiLite::Wmi.new
+        host = wmi.first_of('Win32_OperatingSystem')
+        is_server_2003 = (host['version'] && host['version'].start_with?("5.2"))
 
         WIN32OLE.ole_uninitialize
 

data/lib/chef/provider/env/windows.rb

@@ -17,7 +17,6 @@
 #
 
 if RUBY_PLATFORM =~ /mswin|mingw32|windows/
-  require 'ruby-wmi'
   require 'Win32API'
 end
 
@@ -51,9 +50,17 @@ class Chef
           return obj ? obj.variablevalue : nil
         end
 
+        def find_env(environment_variables, key_name)
+          environment_variables.find do | environment_variable |
+            environment_variable['name'].downcase == key_name
+          end
+        end
+
         def env_obj(key_name)
-          WMI::Win32_Environment.find(:first,
-                                      :conditions => { :name => key_name })
+          wmi = WmiLite::Wmi.new
+          environment_variables = wmi.instances_of('Win32_Environment')
+          existing_variable = find_env(environment_variables, key_name)
+          existing_variable.nil? ? nil : existing_variable.wmi_ole_object
         end
 
         #see: http://msdn.microsoft.com/en-us/library/ms682653%28VS.85%29.aspx

data/lib/chef/provider/file.rb

@@ -296,7 +296,7 @@ class Chef
       def do_unlink
         @file_unlinked = false
         if @new_resource.force_unlink
-          if !real_file?(@new_resource.path)
+          if l_exist?(@new_resource.path) && !real_file?(@new_resource.path)
             # unlink things that aren't normal files
             description = "unlink #{file_type_string(@new_resource.path)} at #{@new_resource.path}"
             converge_by(description) do

data/lib/chef/provider/mount.rb

@@ -1,6 +1,7 @@
 #
-# Author:: Joshua Timberman (<joshua@opscode.com>)
-# Copyright:: Copyright (c) 2009 Opscode, Inc
+# Author:: Joshua Timberman (<joshua@getchef.com>)
+# Author:: Lamont Granquist (<lamont@getchef.com>)
+# Copyright:: Copyright (c) 2009-2014 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -26,6 +27,7 @@ class Chef
 
       include Chef::Mixin::Command
 
+      attr_accessor :unmount_retries
 
       def whyrun_supported?
         true
@@ -35,94 +37,134 @@ class Chef
         true
       end
 
+      def initialize(new_resource, run_context)
+        super
+        self.unmount_retries = 20
+      end
+
       def action_mount
-        unless @current_resource.mounted
-          converge_by("mount #{@current_resource.device} to #{@current_resource.mount_point}") do
-            status = mount_fs()
-            if status
-              Chef::Log.info("#{@new_resource} mounted")
-            end
+        unless current_resource.mounted
+          converge_by("mount #{current_resource.device} to #{current_resource.mount_point}") do
+            mount_fs
+            Chef::Log.info("#{new_resource} mounted")
           end
         else
-          Chef::Log.debug("#{@new_resource} is already mounted")
+          Chef::Log.debug("#{new_resource} is already mounted")
         end
       end
 
       def action_umount
-        if @current_resource.mounted
-          converge_by("unmount #{@current_resource.device}") do
-            status = umount_fs()
-            if status
-              Chef::Log.info("#{@new_resource} unmounted")
-            end
+        if current_resource.mounted
+          converge_by("unmount #{current_resource.device}") do
+            umount_fs
+            Chef::Log.info("#{new_resource} unmounted")
           end
         else
-          Chef::Log.debug("#{@new_resource} is already unmounted")
+          Chef::Log.debug("#{new_resource} is already unmounted")
         end
       end
 
       def action_remount
-        unless @new_resource.supports[:remount]
-          raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :remount"
-        else
-          if @current_resource.mounted
-            converge_by("remount #{@current_resource.device}") do
-              status = remount_fs()
-              if status
-                Chef::Log.info("#{@new_resource} remounted")
-              end
+        if current_resource.mounted
+          if new_resource.supports[:remount]
+            converge_by("remount #{current_resource.device}") do
+              remount_fs
+              Chef::Log.info("#{new_resource} remounted")
             end
           else
-            Chef::Log.debug("#{@new_resource} not mounted, nothing to remount")
+            converge_by("unmount #{current_resource.device}") do
+              umount_fs
+              Chef::Log.info("#{new_resource} unmounted")
+            end
+            wait_until_unmounted(unmount_retries)
+            converge_by("mount #{current_resource.device}") do
+              mount_fs
+              Chef::Log.info("#{new_resource} mounted")
+            end
           end
+        else
+          Chef::Log.debug("#{new_resource} not mounted, nothing to remount")
         end
       end
 
       def action_enable
-        unless @current_resource.enabled && mount_options_unchanged?
-          converge_by("remount #{@current_resource.device}") do
-            status = enable_fs
-            if status
-              Chef::Log.info("#{@new_resource} enabled")
-            else
-              Chef::Log.debug("#{@new_resource} already enabled")
-            end
+        unless current_resource.enabled && mount_options_unchanged?
+          converge_by("enable #{current_resource.device}") do
+            enable_fs
+            Chef::Log.info("#{new_resource} enabled")
           end
+        else
+          Chef::Log.debug("#{new_resource} already enabled")
         end
       end
 
       def action_disable
-        if @current_resource.enabled
-          converge_by("remount #{@current_resource.device}") do
-            status = disable_fs
-            if status
-              Chef::Log.info("#{@new_resource} disabled")
-            else
-              Chef::Log.debug("#{@new_resource} already disabled")
-            end
+        if current_resource.enabled
+          converge_by("disable #{current_resource.device}") do
+            disable_fs
+            Chef::Log.info("#{new_resource} disabled")
           end
+        else
+          Chef::Log.debug("#{new_resource} already disabled")
         end
       end
 
+      #
+      # Abstract Methods to be implemented by subclasses
+      #
+
+      # should actually check if the filesystem is mounted (not just return current_resource) and return true/false
+      def mounted?
+        raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not implement #mounted?"
+      end
+
+      # should check new_resource against current_resource to see if mount options need updating, returns true/false
+      def mount_options_unchanged?
+        raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not implement #mount_options_unchanged?"
+      end
+
+      #
+      # NOTE: for the following methods, this superclass will already have checked if the filesystem is
+      # enabled and/or mounted and they will be called in converge_by blocks, so most defensive checking
+      # does not need to be done in the subclass implementation -- just do the thing.
+      #
+
+      # should implement mounting of the filesystem, raises if action does not succeed
       def mount_fs
         raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :mount"
       end
 
+      # should implement unmounting of the filesystem, raises if action does not succeed
       def umount_fs
         raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :umount"
       end
 
+      # should implement remounting of the filesystem (via a -o remount or some other atomic-ish action that isn't
+      # simply a umount/mount style remount), raises if action does not succeed
       def remount_fs
         raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :remount"
       end
 
+      # should implement enabling of the filesystem (e.g. in /etc/fstab), raises if action does not succeed
       def enable_fs
         raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :enable"
       end
 
+      # should implement disabling of the filesystem (e.g. in /etc/fstab), raises if action does not succeed
       def disable_fs
         raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :disable"
       end
+
+      private
+
+      def wait_until_unmounted(tries)
+        while mounted?
+          if (tries -= 1) < 0
+            raise Chef::Exceptions::Mount, "Retries exceeded waiting for filesystem to unmount"
+          end
+          sleep 0.1
+        end
+      end
     end
   end
 end