chef 12.0.0.alpha.1-x86-mingw32 → 12.0.0.alpha.2-x86-mingw32

data/lib/chef/knife/serve.rb

@@ -33,7 +33,7 @@ class Chef
       def run
         server = Chef::LocalMode.chef_zero_server
         begin
-          output "Serving files from:\n#{server.options[:data_store].chef_fs.fs_description}"
+          output "Serving files from:\n#{Chef::LocalMode.chef_fs.fs_description}"
           server.stop
           server.start(stdout) # to print header
         ensure

data/lib/chef/local_mode.rb

@@ -52,9 +52,10 @@ class Chef
         require 'chef/chef_fs/chef_fs_data_store'
         require 'chef/chef_fs/config'
 
-        chef_fs = Chef::ChefFS::Config.new.local_fs
-        chef_fs.write_pretty_json = true
-        data_store = Chef::ChefFS::ChefFSDataStore.new(chef_fs)
+        @chef_fs = Chef::ChefFS::Config.new.local_fs
+        @chef_fs.write_pretty_json = true
+        data_store = Chef::ChefFS::ChefFSDataStore.new(@chef_fs)
+        data_store = ChefZero::DataStore::V1ToV2Adapter.new(data_store, 'chef')
         server_options = {}
         server_options[:data_store] = data_store
         server_options[:log_level] = Chef::Log.level
@@ -62,7 +63,7 @@ class Chef
         server_options[:port] = parse_port(Chef::Config.chef_zero.port)
         @chef_zero_server = ChefZero::Server.new(server_options)
         @chef_zero_server.start_background
-        Chef::Log.info("Started chef-zero at #{@chef_zero_server.url} with #{chef_fs.fs_description}")
+        Chef::Log.info("Started chef-zero at #{@chef_zero_server.url} with #{@chef_fs.fs_description}")
         Chef::Config.chef_server_url = @chef_zero_server.url
       end
     end
@@ -72,6 +73,11 @@ class Chef
       @chef_zero_server
     end
 
+    # Return the chef_fs object for the current chef-zero server.
+    def self.chef_fs
+      @chef_fs
+    end
+
     # If chef_zero_server is non-nil, stop it and remove references to it.
     def self.destroy_server_connectivity
       if @chef_zero_server

data/lib/chef/mixin/deep_merge.rb

@@ -29,7 +29,6 @@ class Chef
 
       class InvalidSubtractiveMerge < ArgumentError; end
 
-
       OLD_KNOCKOUT_PREFIX = "!merge:".freeze
 
       # Regex to match the "knockout prefix" that was used to indicate
@@ -86,8 +85,12 @@ class Chef
         when Hash
           if dest.kind_of?(Hash)
             source.each do |src_key, src_value|
-              if dest[src_key]
-                dest[src_key] = deep_merge!(src_value, dest[src_key])
+              if dest.has_key? src_key
+                if dest[src_key].nil?
+                  dest[src_key] = nil
+                else
+                  dest[src_key] = deep_merge!(src_value, dest[src_key])
+                end
               else # dest[src_key] doesn't exist so we take whatever source has
                 raise_if_knockout_used!(src_value)
                 dest[src_key] = src_value

data/lib/chef/mixin/shell_out.rb

@@ -20,7 +20,6 @@
 require 'chef/shell_out'
 
 require 'mixlib/shellout'
-require 'chef/config'
 
 class Chef
   module Mixin
@@ -31,32 +30,39 @@ class Chef
       # Generally speaking, 'extend Chef::Mixin::ShellOut' in your recipes and include 'Chef::Mixin::ShellOut' in your LWRPs
       # You can also call Mixlib::Shellout.new directly, but you lose all of the above functionality
 
+      # we use 'en_US.UTF-8' by default because we parse localized strings in English as an API and
+      # generally must support UTF-8 unicode.
       def shell_out(*command_args)
-        cmd = Mixlib::ShellOut.new(*run_command_compatible_options(command_args))
-        cmd.live_stream ||= io_for_live_stream
-        cmd.run_command
-        cmd
+        args = command_args.dup
+        if args.last.is_a?(Hash)
+          options = args.pop.dup
+          env_key = options.has_key?(:env) ? :env : :environment
+          options[env_key] ||= {}
+          options[env_key] = options[env_key].dup
+          options[env_key]['LC_ALL'] ||= Chef::Config[:internal_locale] unless options[env_key].has_key?('LC_ALL')
+          args << options
+        else
+          args << { :environment => { 'LC_ALL' => Chef::Config[:internal_locale] } }
+        end
+
+        shell_out_command(*args)
       end
 
+      # call shell_out (using en_US.UTF-8) and raise errors
       def shell_out!(*command_args)
-        cmd= shell_out(*command_args)
+        cmd = shell_out(*command_args)
         cmd.error!
         cmd
       end
 
-      # environment['LC_ALL'] should be nil or what the user specified
       def shell_out_with_systems_locale(*command_args)
-        args = command_args.dup
-        if args.last.is_a?(Hash)
-          options = args.last
-          env_key = options.has_key?(:env) ? :env : :environment
-          options[env_key] ||= {}
-          options[env_key]['LC_ALL'] ||= nil
-        else
-          args << { :environment => { 'LC_ALL' => nil } }
-        end
+        shell_out_command(*command_args)
+      end
 
-        shell_out(*args)
+      def shell_out_with_systems_locale!(*command_args)
+        cmd = shell_out_with_systems_locale(*command_args)
+        cmd.error!
+        cmd
       end
 
       DEPRECATED_OPTIONS =
@@ -83,6 +89,13 @@ class Chef
 
       private
 
+      def shell_out_command(*command_args)
+        cmd = Mixlib::ShellOut.new(*run_command_compatible_options(command_args))
+        cmd.live_stream ||= io_for_live_stream
+        cmd.run_command
+        cmd
+      end
+
       def deprecate_option(old_option, new_option)
         Chef::Log.logger.warn "DEPRECATION: Chef::Mixin::ShellOut option :#{old_option} is deprecated. Use :#{new_option}"
       end
@@ -97,3 +110,6 @@ class Chef
     end
   end
 end
+
+# Break circular dep
+require 'chef/config'

data/lib/chef/null_logger.rb

@@ -0,0 +1,72 @@
+#
+# Author:: Daniel DeLeo (<dan@getchef.com>)
+# Copyright:: Copyright (c) 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.
+
+class Chef
+
+  # Null logger implementation that just ignores everything. This is used by
+  # classes that are intended to be reused outside of Chef, but need to offer
+  # logging functionality when used by other Chef code.
+  #
+  # It does not define the full interface provided by Logger, just enough to be
+  # a reasonable duck type. In particular, methods setting the log level, log
+  # device, etc., are not implemented because any code calling those methods
+  # probably expected a real logger and not this "fake" one.
+  class NullLogger
+
+    def fatal(message, &block)
+    end
+
+    def error(message, &block)
+    end
+
+    def warn(message, &block)
+    end
+
+    def info(message, &block)
+    end
+
+    def debug(message, &block)
+    end
+
+    def add(severity, message=nil, progname=nil)
+    end
+
+    def <<(message)
+    end
+
+    def fatal?
+      false
+    end
+
+    def error?
+      false
+    end
+
+    def warn?
+      false
+    end
+
+    def info?
+      false
+    end
+
+    def debug?
+      false
+    end
+
+  end
+end

data/lib/chef/platform.rb

@@ -16,8 +16,9 @@
 # limitations under the License.
 #
 
-require 'chef/platform/provider_mapping'
+# Order of these headers is important: query helpers is needed by many things
 require 'chef/platform/query_helpers'
+require 'chef/platform/provider_mapping'
 
 class Chef
   class Platform

data/lib/chef/platform/provider_mapping.rb

@@ -16,8 +16,8 @@
 # limitations under the License.
 #
 
-require 'chef/config'
 require 'chef/log'
+require 'chef/exceptions'
 require 'chef/mixin/params_validate'
 require 'chef/version_constraint/platform'
 

data/lib/chef/platform/rebooter.rb

@@ -0,0 +1,54 @@
+#
+# Author:: Chris Doherty <cdoherty@getchef.com>)
+# Copyright:: Copyright (c) 2014 Chef, 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/reboot_pending'
+require 'chef/log'
+require 'chef/platform'
+
+class Chef
+  class Platform
+    module Rebooter
+      extend Chef::Mixin::ShellOut
+
+      class << self
+
+        def reboot!(node)
+          reboot_info = node.run_context.reboot_info
+
+          cmd = if Chef::Platform.windows?
+            # should this do /f as well? do we then need a minimum delay to let apps quit?
+            "shutdown /r /t #{reboot_info[:delay_mins]} /c \"#{reboot_info[:reason]}\""
+          else
+            # probably Linux-only.
+            "shutdown -r +#{reboot_info[:delay_mins]} \"#{reboot_info[:reason]}\""
+          end
+
+          Chef::Log.warn "Rebooting server at a recipe's request. Details: #{reboot_info.inspect}"
+          shell_out!(cmd)
+        end
+
+        # this is a wrapper function so Chef::Client only needs a single line of code.
+        def reboot_if_needed!(node)
+          if node.run_context.reboot_requested?
+            reboot!(node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef/provider/ifconfig.rb

@@ -19,6 +19,7 @@
 require 'chef/log'
 require 'chef/mixin/command'
 require 'chef/provider'
+require 'chef/resource/file'
 require 'chef/exceptions'
 require 'erb'
 
@@ -109,11 +110,11 @@ class Chef
                 :command => command
               )
               Chef::Log.info("#{@new_resource} added")
-              # Write out the config files
-              generate_config
             end
           end
         end
+        # Write out the config files
+        generate_config
       end
 
       def action_enable
@@ -140,12 +141,12 @@ class Chef
             run_command(
               :command => command
             )
-            delete_config
             Chef::Log.info("#{@new_resource} deleted")
           end
         else
           Chef::Log.debug("#{@new_resource} does not exist - nothing to do")
         end
+        delete_config
       end
 
       def action_disable
@@ -168,27 +169,25 @@ class Chef
         ! @config_template.nil? and ! @config_path.nil?
       end
 
+      def resource_for_config(path)
+        Chef::Resource::File.new(path, run_context)
+      end
+
       def generate_config
         return unless can_generate_config?
         b = binding
         template = ::ERB.new(@config_template)
-        converge_by ("generate configuration file : #{@config_path}") do
-          network_file = ::File.new(@config_path, "w")
-          network_file.puts(template.result(b))
-          network_file.close
-        end
-        Chef::Log.info("#{@new_resource} created configuration file")
+        config = resource_for_config(@config_path)
+        config.content(template.result(b))
+        config.run_action(:create)
+        @new_resource.updated_by_last_action(true) if config.updated?
       end
 
       def delete_config
         return unless can_generate_config?
-        require 'fileutils'
-        if ::File.exist?(@config_path)
-          converge_by ("delete the #{@config_path}") do
-            FileUtils.rm_f(@config_path, :verbose => false)
-          end
-        end
-        Chef::Log.info("#{@new_resource} deleted configuration file")
+        config = resource_for_config(@config_path)
+        config.run_action(:delete)
+        @new_resource.updated_by_last_action(true) if config.updated?
       end
 
       private

data/lib/chef/provider/link.rb

@@ -83,7 +83,7 @@ class Chef
       end
 
       def canonicalize(path)
-        Chef::Platform.windows? ? path.gsub('/', '\\') : path
+        Chef::Util::PathHelper.canonical_path(path)
       end
 
       def action_create

data/lib/chef/provider/mount/mount.rb

@@ -127,7 +127,7 @@ class Chef
         end
 
         def remount_command
-           return "mount -o remount #{@new_resource.mount_point}"
+          return "mount -o remount,#{@new_resource.options.join(',')} #{@new_resource.mount_point}"
         end
 
         def remount_fs

data/lib/chef/provider/mount/solaris.rb

@@ -1,4 +1,4 @@
-#
+# Encoding: utf-8
 # Author:: Hugo Fichter
 # Author:: Lamont Granquist (<lamont@getchef.com>)
 # Author:: Joshua Timberman (<joshua@getchef.com>)
@@ -25,14 +25,16 @@ require 'forwardable'
 class Chef
   class Provider
     class Mount
+      # Mount Solaris File systems
       class Solaris < Chef::Provider::Mount
         extend Forwardable
 
-        VFSTAB = "/etc/vfstab".freeze
+        VFSTAB = '/etc/vfstab'.freeze
 
         def_delegator :@new_resource, :device, :device
         def_delegator :@new_resource, :device_type, :device_type
         def_delegator :@new_resource, :dump, :dump
+        def_delegator :@new_resource, :fsck_device, :fsck_device
         def_delegator :@new_resource, :fstype, :fstype
         def_delegator :@new_resource, :mount_point, :mount_point
         def_delegator :@new_resource, :options, :options
@@ -42,6 +44,7 @@ class Chef
           @current_resource = Chef::Resource::Mount.new(new_resource.name)
           current_resource.mount_point(mount_point)
           current_resource.device(device)
+          current_resource.fsck_device(fsck_device)
           current_resource.device_type(device_type)
           update_current_resource_state
         end
@@ -53,6 +56,14 @@ class Chef
             a.whyrun("Assuming device #{device} would have been created")
           end
 
+          unless fsck_device == '-'
+            requirements.assert(:mount, :remount) do |a|
+              a.assertion { ::File.exist?(fsck_device) }
+              a.failure_message(Chef::Exceptions::Mount, "Device #{fsck_device} does not exist")
+              a.whyrun("Assuming device #{fsck_device} would have been created")
+            end
+          end
+
           requirements.assert(:mount, :remount) do |a|
             a.assertion { ::File.exist?(mount_point) }
             a.failure_message(Chef::Exceptions::Mount, "Mount point #{mount_point} does not exist")
@@ -62,7 +73,7 @@ class Chef
 
         def mount_fs
           actual_options = options || []
-          actual_options.delete("noauto")
+          actual_options.delete('noauto')
           command = "mount -F #{fstype}"
           command << " -o #{actual_options.join(',')}" unless actual_options.empty?
           command << " #{device} #{mount_point}"
@@ -74,59 +85,28 @@ class Chef
         end
 
         def remount_fs
-          # FIXME: what about options like "-o remount,logging" to enable logging on a UFS device?
-          shell_out!("mount -o remount #{mount_point}")
+          # FIXME: Should remount always do the remount or only if the options change?
+          actual_options = options || []
+          actual_options.delete('noauto')
+          mount_options = actual_options.empty? ? '' : ",#{actual_options.join(',')}" 
+          shell_out!("mount -o remount#{mount_options} #{mount_point}")
         end
 
         def enable_fs
-          if !mount_options_unchanged?
+          unless mount_options_unchanged?
             # we are enabling because our options have changed, so disable first then re-enable.
             # XXX: this should be refactored to be the responsibility of the caller
             disable_fs if current_resource.enabled
           end
 
-          auto = options.nil? || ! options.include?("noauto")
-          actual_options = unless options.nil?
-                             options.delete("noauto")
-                             options
-                           end
-
-          autostr = auto ? 'yes' : 'no'
-          passstr = pass == 0 ? "-" : pass
-          optstr = (actual_options.nil? || actual_options.empty?) ? "-" : actual_options.join(',')
-
-          etc_tempfile do |f|
-            f.write(IO.read(VFSTAB).chomp)
-            f.puts("\n#{device}\t-\t#{mount_point}\t#{fstype}\t#{passstr}\t#{autostr}\t#{optstr}")
-            f.close
-            # move, preserving modes of destination file
-            mover = Chef::FileContentManagement::Deploy.strategy(true)
-            mover.deploy(f.path, VFSTAB)
-          end
-
+          vfstab_write(merge_vfstab_entry)
         end
 
         def disable_fs
-          contents = []
-
-          found = false
-          ::File.readlines(VFSTAB).reverse_each do |line|
-            if !found && line =~ /^#{device_regex}\s+\S+\s+#{Regexp.escape(mount_point)}/
-              found = true
-              Chef::Log.debug("#{new_resource} is removed from vfstab")
-              next
-            end
-            contents << line
-          end
+          contents, found = delete_vfstab_entry
 
           if found
-            etc_tempfile do |f|
-              f.write(contents.reverse.join(''))
-              f.close
-              # move, preserving modes of destination file
-              mover = Chef::FileContentManagement::Deploy.strategy(true)
-              mover.deploy(f.path, VFSTAB)
-            end
+            vfstab_write(contents.reverse)
           else
             # this is likely some kind of internal error, since we should only call disable_fs when there
             # the filesystem we want to disable is enabled.
@@ -135,19 +115,24 @@ class Chef
         end
 
         def etc_tempfile
-          yield Tempfile.open("vfstab", "/etc")
+          yield Tempfile.open('vfstab', '/etc')
         end
 
         def mount_options_unchanged?
-          current_resource.fstype == fstype and
-            current_resource.options == options and
-            current_resource.dump == dump and
-            current_resource.pass == pass
+          new_options = options_remove_noauto(options)
+          current_options = options_remove_noauto(current_resource.nil? ? nil : current_resource.options)
+
+          current_resource.fsck_device == fsck_device &&
+            current_resource.fstype == fstype &&
+            current_options == new_options &&
+            current_resource.dump == dump &&
+            current_resource.pass == pass &&
+            current_resource.options.include?('noauto') == !mount_at_boot?
         end
 
         def update_current_resource_state
           current_resource.mounted(mounted?)
-          ( enabled, fstype, options, pass ) = read_vfstab_status
+          (enabled, fstype, options, pass) = read_vfstab_status
           current_resource.enabled(enabled)
           current_resource.fstype(fstype)
           current_resource.options(options)
@@ -158,17 +143,18 @@ class Chef
           read_vfstab_status[0]
         end
 
+        # Check for the device in mounttab.
+        # <device> on <mountpoint> type <fstype> <options> on <date>
+        # /dev/dsk/c1t0d0s0 on / type ufs read/write/setuid/devices/intr/largefiles/logging/xattr/onerror=panic/dev=700040 on Tue May  1 11:33:55 2012
         def mounted?
           mounted = false
-          shell_out!("mount -v").stdout.each_line do |line|
-            # <device> on <mountpoint> type <fstype> <options> on <date>
-            # /dev/dsk/c1t0d0s0 on / type ufs read/write/setuid/devices/intr/largefiles/logging/xattr/onerror=panic/dev=700040 on Tue May  1 11:33:55 2012
+          shell_out!('mount -v').stdout.each_line do |line|
             case line
             when /^#{device_regex}\s+on\s+#{Regexp.escape(mount_point)}\s+/
               Chef::Log.debug("Special device #{device} is mounted as #{mount_point}")
               mounted = true
             when /^([\/\w]+)\son\s#{Regexp.escape(mount_point)}\s+/
-              Chef::Log.debug("Special device #{$1} is mounted as #{mount_point}")
+              Chef::Log.debug("Special device #{Regexp.last_match[1]} is mounted as #{mount_point}")
               mounted = false
             end
           end
@@ -178,7 +164,7 @@ class Chef
         private
 
         def read_vfstab_status
-          # Check to see if there is a entry in /etc/vfstab. Last entry for a volume wins.
+          # Check to see if there is an entry in /etc/vfstab. Last entry for a volume wins.
           enabled = false
           fstype = options = pass = nil
           ::File.foreach(VFSTAB) do |line|
@@ -190,18 +176,18 @@ class Chef
               # to mount       to fsck         point           type    pass    at boot options
             when /^#{device_regex}\s+[-\/\w]+\s+#{Regexp.escape(mount_point)}\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)/
               enabled = true
-              fstype = $1
-              options = $4
+              fstype = Regexp.last_match[1]
+              options = Regexp.last_match[4]
               # Store the 'mount at boot' column from vfstab as the 'noauto' option
               # in current_resource.options (linux style)
-              if $3 == "yes"
+              if Regexp.last_match[3] == 'no'
                 if options.nil? || options.empty?
-                  options = "noauto"
+                  options = 'noauto'
                 else
-                  options += ",noauto"
+                  options += ',noauto'
                 end
               end
-              pass = ( $2 == "-" ) ? 0 : $2.to_i
+              pass = (Regexp.last_match[2] == '-') ? 0 : Regexp.last_match[2].to_i
               Chef::Log.debug("Found mount #{device} to #{mount_point} in #{VFSTAB}")
               next
             when /^[-\/\w]+\s+[-\/\w]+\s+#{Regexp.escape(mount_point)}\s+/
@@ -210,21 +196,73 @@ class Chef
               Chef::Log.debug("Found conflicting mount point #{mount_point} in #{VFSTAB}")
             end
           end
-          [ enabled, fstype, options, pass ]
+          [enabled, fstype, options, pass]
         end
 
         def device_should_exist?
-          !%w{tmpfs nfs ctfs proc mntfs objfs sharefs fd smbfs}.include?(fstype)
+          !%w(tmpfs nfs ctfs proc mntfs objfs sharefs fd smbfs vxfs).include?(fstype)
+        end
+
+        def mount_at_boot?
+          options.nil? || !options.include?('noauto')
+        end
+
+        def vfstab_write(contents)
+          etc_tempfile do |f|
+            f.write(contents.join(''))
+            f.close
+            # move, preserving modes of destination file
+            mover = Chef::FileContentManagement::Deploy.strategy(true)
+            mover.deploy(f.path, VFSTAB)
+          end
+        end
+
+        def vfstab_entry
+          actual_options = unless options.nil?
+            tempops = options.dup
+            tempops.delete('noauto')
+            tempops
+          end
+          autostr = mount_at_boot? ? 'yes' : 'no'
+          passstr = pass == 0 ? '-' : pass
+          optstr = (actual_options.nil? || actual_options.empty?) ? '-' : actual_options.join(',')
+          "\n#{device}\t#{fsck_device}\t#{mount_point}\t#{fstype}\t#{passstr}\t#{autostr}\t#{optstr}\n"
+        end
+
+        def delete_vfstab_entry
+          contents = []
+          found = false
+          ::File.readlines(VFSTAB).reverse_each do |line|
+            if !found && line =~ /^#{device_regex}\s+\S+\s+#{Regexp.escape(mount_point)}/
+              found = true
+              Chef::Log.debug("#{new_resource} is removed from vfstab")
+              next
+            end
+            contents << line
+          end
+          [contents, found]
+        end
+
+        def merge_vfstab_entry
+          contents = ::File.readlines(VFSTAB)
+          contents[-1].chomp!
+          contents << vfstab_entry
+        end
+
+        def options_remove_noauto(temp_options)
+          new_options = []
+          new_options += temp_options.nil? ? [] : temp_options
+          new_options.delete('noauto')
+          new_options
         end
 
         def device_regex
           if ::File.symlink?(device)
-            "(?:#{Regexp.escape(device)}|#{Regexp.escape(::File.expand_path(::File.readlink(device),::File.dirname(device)))})"
+            "(?:#{Regexp.escape(device)}|#{Regexp.escape(::File.expand_path(::File.readlink(device), ::File.dirname(device)))})"
           else
             Regexp.escape(device)
           end
         end
-
       end
     end
   end