chef 12.0.0.alpha.2 → 12.0.0.rc.0

data/lib/chef/provider/deploy.rb

@@ -22,6 +22,7 @@ require "chef/monkey_patches/fileutils"
 require "chef/provider/git"
 require "chef/provider/subversion"
 require "chef/dsl/recipe"
+require "chef/util/path_helper"
 
 class Chef
   class Provider
@@ -243,7 +244,7 @@ class Chef
       end
 
       def all_releases
-        Dir.glob(@new_resource.deploy_to + "/releases/*").sort
+        Dir.glob(Chef::Util::PathHelper.escape_glob(@new_resource.deploy_to) + "/releases/*").sort
       end
 
       def update_cached_repo
@@ -374,7 +375,7 @@ class Chef
 
       def gem_resource_collection_runner
         gems_collection = Chef::ResourceCollection.new
-        gem_packages.each { |rbgem| gems_collection << rbgem }
+        gem_packages.each { |rbgem| gems_collection.insert(rbgem) }
         gems_run_context = run_context.dup
         gems_run_context.resource_collection = gems_collection
         Chef::Runner.new(gems_run_context)

data/lib/chef/provider/deploy/revision.rb

@@ -27,6 +27,8 @@ class Chef
   class Provider
     class Deploy
       class Revision < Chef::Provider::Deploy
+        provides :deploy_revision
+        provides :deploy_branch
 
         def all_releases
           sorted_releases
@@ -42,7 +44,7 @@ class Chef
 
           known_releases = sorted_releases
 
-          Dir["#{new_resource.deploy_to}/releases/*"].each do |release_dir|
+          Dir["#{Chef::Util::PathHelper.escape_glob(new_resource.deploy_to)}/releases/*"].each do |release_dir|
             unless known_releases.include?(release_dir)
               converge_by("Remove unknown release in #{release_dir}") do
                 FileUtils.rm_rf(release_dir)
@@ -85,7 +87,7 @@ class Chef
         end
 
         def sorted_releases_from_filesystem
-          Dir.glob(new_resource.deploy_to + "/releases/*").sort_by { |d| ::File.ctime(d) }
+          Dir.glob(Chef::Util::PathHelper.escape_glob(new_resource.deploy_to) + "/releases/*").sort_by { |d| ::File.ctime(d) }
         end
 
         def load_cache

data/lib/chef/provider/deploy/timestamped.rb

@@ -20,6 +20,8 @@ class Chef
   class Provider
     class Deploy
       class Timestamped < Chef::Provider::Deploy
+        provides :timestamped_deploy
+        provides :deploy
 
         protected
 

data/lib/chef/provider/directory.rb

@@ -27,6 +27,8 @@ class Chef
   class Provider
     class Directory < Chef::Provider::File
 
+      provides :directory
+
       def whyrun_supported?
         true
       end

data/lib/chef/provider/dsc_script.rb

@@ -0,0 +1,179 @@
+#
+# Author:: Adam Edwards (<adamed@getchef.com>)
+#
+# Copyright:: 2014, Chef Software, Inc.
+#
+# 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/util/powershell/cmdlet'
+require 'chef/util/dsc/configuration_generator'
+require 'chef/util/dsc/local_configuration_manager'
+require 'chef/util/path_helper'
+
+class Chef
+  class Provider
+    class DscScript < Chef::Provider
+
+      provides :dsc_script, os: "windows"
+
+      def initialize(dsc_resource, run_context)
+        super(dsc_resource, run_context)
+        @dsc_resource = dsc_resource
+        @resource_converged = false
+        @operations = {
+          :set => Proc.new { |config_manager, document|
+            config_manager.set_configuration(document)
+          },
+          :test => Proc.new { |config_manager, document|
+            config_manager.test_configuration(document)
+          }}
+      end
+
+      def action_run
+        if ! @resource_converged
+          converge_by(generate_description) do
+            run_configuration(:set)
+            Chef::Log.info("DSC resource configuration completed successfully")
+          end
+        end
+      end
+
+      def load_current_resource
+        if supports_dsc?
+          @dsc_resources_info = run_configuration(:test)
+          @resource_converged = @dsc_resources_info.all? do |resource|
+            !resource.changes_state?
+          end
+        end
+      end
+
+      def whyrun_supported?
+        true
+      end
+
+      def define_resource_requirements
+        requirements.assert(:run) do |a|
+          err = [
+            'Could not find PowerShell DSC support on the system',
+            powershell_info_str,
+            "Powershell 4.0 or higher was not detected on your system and is required to use the dsc_script resource.",
+          ]
+          a.assertion { supports_dsc? }
+          a.failure_message Chef::Exceptions::NoProviderAvailable, err.join(' ')
+          a.whyrun err + ["Assuming a previous resource installs Powershell 4.0 or higher."]
+          a.block_action!
+        end
+      end
+
+      protected
+
+      def supports_dsc?
+        run_context && Chef::Platform.supports_dsc?(node)
+      end
+
+      def run_configuration(operation)
+        config_directory = ::Dir.mktmpdir("chef-dsc-script")
+        configuration_data_path = get_configuration_data_path(config_directory)
+        configuration_flags = get_augmented_configuration_flags(configuration_data_path)
+
+        config_manager = Chef::Util::DSC::LocalConfigurationManager.new(@run_context.node, config_directory)
+
+        begin
+          configuration_document = generate_configuration_document(config_directory, configuration_flags)
+          @operations[operation].call(config_manager, configuration_document)
+        rescue Exception => e
+          Chef::Log.error("DSC operation failed: #{e.message.to_s}")
+          raise e
+        ensure
+          ::FileUtils.rm_rf(config_directory)
+        end
+      end
+
+      def get_augmented_configuration_flags(configuration_data_path)
+        updated_flags = @dsc_resource.flags.nil? ? {} : @dsc_resource.flags.dup
+        if configuration_data_path
+          Chef::Util::PathHelper.validate_path(configuration_data_path)
+          updated_flags[:configurationdata] = configuration_data_path
+        end
+        updated_flags
+      end
+
+      def generate_configuration_document(config_directory, configuration_flags)
+        shellout_flags = {
+          :cwd => @dsc_resource.cwd,
+          :environment => @dsc_resource.environment,
+          :timeout => @dsc_resource.timeout
+        }
+
+        generator = Chef::Util::DSC::ConfigurationGenerator.new(@run_context.node, config_directory)
+
+        if @dsc_resource.command
+          generator.configuration_document_from_script_path(@dsc_resource.command, configuration_name, configuration_flags, shellout_flags)
+        else
+          # If code is also not provided, we mimic what the other script resources do (execute nothing)
+          Chef::Log.warn("Neither code or command were provided for dsc_resource[#{@dsc_resource.name}].") unless @dsc_resource.code
+          generator.configuration_document_from_script_code(@dsc_resource.code || '', configuration_flags, shellout_flags)
+        end
+      end
+
+      def get_configuration_data_path(config_directory)
+        if @dsc_resource.configuration_data_script
+          @dsc_resource.configuration_data_script
+        elsif @dsc_resource.configuration_data
+          configuration_data_path = "#{config_directory}/chef_dsc_config_data.psd1"
+          ::File.open(configuration_data_path, 'wt') do | script |
+            script.write(@dsc_resource.configuration_data)
+          end
+          configuration_data_path
+        end
+      end
+
+      def configuration_name
+        @dsc_resource.configuration_name || @dsc_resource.name
+      end
+
+      def configuration_friendly_name
+        if @dsc_resource.code
+          @dsc_resource.name
+        else
+          configuration_name
+        end
+      end
+
+      private
+
+      def generate_description
+        ["converge DSC configuration '#{configuration_friendly_name}'"] +
+          @dsc_resources_info.map do |resource|
+            if resource.changes_state?
+              # We ignore the last log message because it only contains the time it took, which looks weird
+              cleaned_messages = resource.change_log[0..-2].map { |c| c.sub(/^#{Regexp.escape(resource.name)}/, '').strip }
+              "converge DSC resource #{resource.name} by #{cleaned_messages.find_all{ |c| c != ''}.join("\n")}"
+            else
+              # This is needed because a dsc script can have resouces that are both converged and not
+              "converge DSC resource #{resource.name} by doing nothing because it is already converged"
+            end
+          end
+      end
+
+      def powershell_info_str
+        if run_context && run_context.node[:languages] && run_context.node[:languages][:powershell]
+          install_info = "Powershell #{run_context.node[:languages][:powershell][:version]} was found on the system."
+        else
+          install_info = 'Powershell was not found.'
+        end
+      end
+    end
+  end
+end

data/lib/chef/provider/env.rb

@@ -58,20 +58,22 @@ class Chef
       # ==== Returns
       # <true>:: If a change is required
       # <false>:: If a change is not required
-      def compare_value
+      def requires_modify_or_create?
         if @new_resource.delim
           #e.g. check for existing value within PATH
-          not @current_resource.value.split(@new_resource.delim).any? do |val|
-            val == @new_resource.value
+          not new_values.all? do |val|
+            current_values.include? val
           end
         else
           @new_resource.value != @current_resource.value
         end
       end
 
+      alias_method :compare_value, :requires_modify_or_create?
+
       def action_create
         if @key_exists
-          if compare_value
+          if requires_modify_or_create?
             modify_env
             Chef::Log.info("#{@new_resource} altered")
             @new_resource.updated_by_last_action(true)
@@ -91,13 +93,14 @@ class Chef
       #           after we removed the element.
       def delete_element
         return false unless @new_resource.delim #no delim: delete the key
-        if compare_value
+        needs_delete = new_values.any? { |v| current_values.include?(v) }
+        if !needs_delete
           Chef::Log.debug("#{@new_resource} element '#{@new_resource.value}' does not exist")
           return true #do not delete the key
         else
           new_value =
-            @current_resource.value.split(@new_resource.delim).select { |item|
-            item != @new_resource.value
+            current_values.select { |item|
+              not new_values.include?(item)
           }.join(@new_resource.delim)
 
           if new_value.empty?
@@ -122,7 +125,7 @@ class Chef
 
       def action_modify
         if @key_exists
-          if compare_value
+          if requires_modify_or_create?
             modify_env
             Chef::Log.info("#{@new_resource} modified")
             @new_resource.updated_by_last_action(true)
@@ -142,11 +145,23 @@ class Chef
 
       def modify_env
         if @new_resource.delim
-          #e.g. add to PATH
-          @new_resource.value(@new_resource.value + @new_resource.delim + @current_resource.value)
+          values = new_values.reject do |v|
+            current_values.include?(v)
+          end
+          @new_resource.value((values + [@current_resource.value]).join(@new_resource.delim))
         end
         create_env
       end
+
+      # Returns the current values to split by delimiter
+      def current_values
+        @current_values ||= @current_resource.value.split(@new_resource.delim)
+      end
+
+      # Returns the new values to split by delimiter
+      def new_values
+        @new_values ||= @new_resource.value.split(@new_resource.delim)
+      end
      end
   end
 end

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

@@ -16,13 +16,13 @@
 # limitations under the License.
 #
 
-require 'chef/win32/api/system' if RUBY_PLATFORM =~ /mswin|mingw32|windows/
+require 'chef/mixin/windows_env_helper'
 
 class Chef
   class Provider
     class Env
       class Windows < Chef::Provider::Env
-        include Chef::ReservedNames::Win32::API::System if RUBY_PLATFORM =~ /mswin|mingw32|windows/
+        include Chef::Mixin::WindowsEnvHelper
 
         def create_env
           obj = env_obj(@new_resource.key_name)
@@ -33,7 +33,9 @@ class Chef
           end
           obj.variablevalue = @new_resource.value
           obj.put_
-          ENV[@new_resource.key_name] = @new_resource.value
+          value = @new_resource.value
+          value = expand_path(value) if @new_resource.key_name.upcase == 'PATH'
+          ENV[@new_resource.key_name] = value
           broadcast_env_change
         end
 
@@ -41,14 +43,16 @@ class Chef
           obj = env_obj(@new_resource.key_name)
           if obj
             obj.delete_
-            ENV.delete(@new_resource.key_name)
             broadcast_env_change
           end
+          if ENV[@new_resource.key_name]
+            ENV.delete(@new_resource.key_name)
+          end
         end
 
         def env_value(key_name)
           obj = env_obj(key_name)
-          return obj ? obj.variablevalue : nil
+          return obj ? obj.variablevalue : ENV[key_name]
         end
 
         def env_obj(key_name)
@@ -60,17 +64,6 @@ class Chef
           end
         end
 
-        #see: http://msdn.microsoft.com/en-us/library/ms682653%28VS.85%29.aspx
-        HWND_BROADCAST = 0xffff
-        WM_SETTINGCHANGE = 0x001A
-        SMTO_BLOCK = 0x0001
-        SMTO_ABORTIFHUNG = 0x0002
-        SMTO_NOTIMEOUTIFNOTHUNG = 0x0008
-
-        def broadcast_env_change
-          flags = SMTO_BLOCK | SMTO_ABORTIFHUNG | SMTO_NOTIMEOUTIFNOTHUNG
-          SendMessageTimeoutA(HWND_BROADCAST, WM_SETTINGCHANGE, 0, FFI::MemoryPointer.from_string('Environment').address, flags, 5000, nil)
-        end
       end
     end
   end

data/lib/chef/provider/erl_call.rb

@@ -25,6 +25,8 @@ class Chef
     class ErlCall < Chef::Provider
       include Chef::Mixin::Command
 
+      provides :erl_call
+
       def initialize(node, new_resource)
         super(node, new_resource)
       end

data/lib/chef/provider/execute.rb

@@ -23,6 +23,8 @@ class Chef
   class Provider
     class Execute < Chef::Provider
 
+      provides :execute
+
       def load_current_resource
         true
       end
@@ -50,10 +52,11 @@ class Chef
         opts[:umask] = @new_resource.umask if @new_resource.umask
         opts[:log_level] = :info
         opts[:log_tag] = @new_resource.to_s
-        if STDOUT.tty? && !Chef::Config[:daemon] && Chef::Log.info?
+        if STDOUT.tty? && !Chef::Config[:daemon] && Chef::Log.info? && !@new_resource.sensitive
           opts[:live_stream] = STDOUT
         end
-        converge_by("execute #{@new_resource.command}") do
+        description = @new_resource.sensitive ? "sensitive resource" : @new_resource.command
+        converge_by("execute #{description}") do
           result = shell_out!(@new_resource.command, opts)
           Chef::Log.info("#{@new_resource} ran successfully")
         end

data/lib/chef/provider/file.rb

@@ -54,6 +54,8 @@ class Chef
       include Chef::Deprecation::Provider::File
       add_deprecation_warnings_for(Chef::Deprecation::Provider::File.instance_methods)
 
+      provides :file
+
       attr_reader :deployment_strategy
 
       attr_accessor :needs_creating

data/lib/chef/provider/git.rb

@@ -25,6 +25,8 @@ class Chef
   class Provider
     class Git < Chef::Provider
 
+      provides :git
+
       def whyrun_supported?
         true
       end
@@ -64,7 +66,7 @@ class Chef
           a.failure_message Chef::Exceptions::UnresolvableGitReference,
             "Unable to parse SHA reference for '#{@new_resource.revision}' in repository '#{@new_resource.repository}'. " +
             "Verify your (case-sensitive) repository URL and revision.\n" +
-            "`git ls-remote` output: #{@resolved_reference}"
+            "`git ls-remote '#{@new_resource.repository}' '#{rev_search_pattern}'` output: #{@resolved_reference}"
         end
       end
 
@@ -102,6 +104,10 @@ class Chef
         end
       end
 
+      def git_minor_version
+        @git_minor_version ||= Gem::Version.new(shell_out!('git --version', run_options).stdout.split.last)
+      end
+
       def existing_git_clone?
         ::File.exist?(::File.join(@new_resource.destination, ".git"))
       end
@@ -137,6 +143,7 @@ class Chef
           args = []
           args << "-o #{remote}" unless remote == 'origin'
           args << "--depth #{@new_resource.depth}" if @new_resource.depth
+          args << "--no-single-branch" if @new_resource.depth and git_minor_version >= Gem::Version.new('1.7.10')
 
           Chef::Log.info "#{@new_resource} cloning repo #{@new_resource.repository} to #{@new_resource.destination}"
 
@@ -150,7 +157,8 @@ class Chef
 
         converge_by("checkout ref #{sha_ref} branch #{@new_resource.revision}") do
           # checkout into a local branch rather than a detached HEAD
-          shell_out!("git checkout -B #{@new_resource.checkout_branch} #{sha_ref}", run_options(:cwd => @new_resource.destination))
+          shell_out!("git branch -f #{@new_resource.checkout_branch} #{sha_ref}", run_options(:cwd => @new_resource.destination))
+          shell_out!("git checkout #{@new_resource.checkout_branch}", run_options(:cwd => @new_resource.destination))
           Chef::Log.info "#{@new_resource} checked out branch: #{@new_resource.revision} onto: #{@new_resource.checkout_branch} reference: #{sha_ref}"
         end
       end
@@ -234,33 +242,53 @@ class Chef
         # annotated tags, we have to search for "revision*" and
         # post-process. Special handling for 'HEAD' to ignore a tag
         # named 'HEAD'.
-        rev_pattern = case @new_resource.revision
-                      when '', 'HEAD'
-                        'HEAD'
-                      else
-                        @new_resource.revision + '*'
-                      end
-        command = git("ls-remote \"#{@new_resource.repository}\" \"#{rev_pattern}\"")
-        @resolved_reference = shell_out!(command, run_options).stdout
-        ref_lines = @resolved_reference.split("\n")
-        refs = ref_lines.map { |line| line.split("\t") }
-        # first try for ^{} indicating the commit pointed to by an
-        # annotated tag
-        tagged_commit = refs.find { |m| m[1].end_with?("#{@new_resource.revision}^{}") }
+        @resolved_reference = git_ls_remote(rev_search_pattern)
+        refs = @resolved_reference.split("\n").map { |line| line.split("\t") }
+        # First try for ^{} indicating the commit pointed to by an
+        # annotated tag.
         # It is possible for a user to create a tag named 'HEAD'.
         # Using such a degenerate annotated tag would be very
         # confusing. We avoid the issue by disallowing the use of
         # annotated tags named 'HEAD'.
-        if tagged_commit && rev_pattern != 'HEAD'
-          tagged_commit[0]
+        if rev_search_pattern != 'HEAD'
+          found = find_revision(refs, @new_resource.revision, '^{}')
         else
-          found = refs.find { |m| m[1].end_with?(@new_resource.revision) }
-          if found
-            found[0]
-          else
-            nil
-          end
+          found = refs_search(refs, 'HEAD')
         end
+        found = find_revision(refs, @new_resource.revision) if found.empty?
+        found.size == 1 ? found.first[0] : nil
+      end
+
+      def find_revision(refs, revision, suffix="")
+        found = refs_search(refs, rev_match_pattern('refs/tags/', revision) + suffix)
+        found = refs_search(refs, rev_match_pattern('refs/heads/', revision) + suffix) if found.empty?
+        found = refs_search(refs, revision + suffix) if found.empty?
+        found
+      end
+
+      def rev_match_pattern(prefix, revision)
+        if revision.start_with?(prefix)
+          revision
+        else
+          prefix + revision
+        end
+      end
+
+      def rev_search_pattern
+        if ['', 'HEAD'].include? @new_resource.revision
+          'HEAD'
+        else
+          @new_resource.revision + '*'
+        end
+      end
+
+      def git_ls_remote(rev_pattern)
+        command = git(%Q(ls-remote "#{@new_resource.repository}" "#{rev_pattern}"))
+        shell_out!(command, run_options).stdout
+      end
+
+      def refs_search(refs, pattern)
+        refs.find_all { |m| m[1] == pattern }
       end
 
       private