chef 15.17.4-universal-mingw32 → 16.0.257-universal-mingw32

data/lib/chef/property.rb

@@ -1,6 +1,7 @@
 #
 # Author:: John Keiser <jkeiser@chef.io>
-# Copyright:: Copyright 2015-2016, John Keiser.
+# Copyright:: Copyright 2015-2016, John Keiser
+# Copyright:: Copyright (c) Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -140,6 +141,10 @@ class Chef
         raise ArgumentError, "A property cannot be both a name_property/name_attribute and have a default value. Use one or the other on property #{self}"
       end
 
+      if options[:name_property]
+        options[:desired_state] = false unless options.key?(:desired_state)
+      end
+
       # Recursively freeze the default if it isn't a lazy value.
       unless default.is_a?(DelayedEvaluator)
         visitor = lambda do |obj|
@@ -244,6 +249,15 @@ class Chef
       options[:default_description]
     end
 
+    #
+    # The equal_to field of this property.
+    #
+    # @return [Array, NilClass]
+    #
+    def equal_to
+      options[:equal_to]
+    end
+
     #
     # Whether this is part of the resource's natural identity or not.
     #
@@ -289,8 +303,12 @@ class Chef
     #
     # @return [Boolean]
     #
-    def required?
-      options[:required]
+    def required?(action = nil)
+      if !action.nil? && options[:required].is_a?(Array)
+        options[:required].include?(action)
+      else
+        !!options[:required]
+      end
     end
 
     #
@@ -543,7 +561,7 @@ class Chef
           modified_options.key?(:default)
         options = options.reject { |k, v| k == :name_attribute || k == :name_property || k == :default }
       end
-      self.class.new(options.merge(modified_options))
+      self.class.new(**options.merge(modified_options))
     end
 
     #

data/lib/chef/provider.rb

@@ -23,7 +23,7 @@ require_relative "mixin/enforce_ownership_and_permissions"
 require_relative "mixin/why_run"
 require_relative "mixin/shell_out"
 require_relative "mixin/provides"
-require_relative "dsl/core"
+require_relative "dsl/recipe"
 require_relative "platform/service_helpers"
 require_relative "node_map"
 require "forwardable" unless defined?(Forwardable)
@@ -35,6 +35,7 @@ class Chef
 
     attr_accessor :new_resource
     attr_accessor :current_resource
+    attr_accessor :after_resource
     attr_accessor :run_context
 
     attr_reader :recipe_name
@@ -44,8 +45,7 @@ class Chef
     extend Chef::Mixin::Provides
     extend Forwardable
 
-    # includes the "core" DSL and not the "recipe" DSL by design
-    include Chef::DSL::Core
+    include Chef::DSL::Recipe
     # the class only gets the Universal DSL (no resource_collection at class parsing time)
     extend Chef::DSL::Universal
 
@@ -64,7 +64,7 @@ class Chef
     #
     # @return [void]
     def self.action(name, &block)
-      # We need the block directly in a method so that `super` works.
+      # We need the block directly in a method so that `return` works.
       define_method("compile_action_#{name}", &block)
       class_eval <<-EOM
         def action_#{name}
@@ -81,6 +81,20 @@ class Chef
       # Chef.deprecated(:use_inline_resources, "The use_inline_resources mode is no longer optional and the line enabling it can be removed")
     end
 
+    # Use a partial code fragment.  This can be used for code sharing between multiple resources.
+    #
+    # Do not wrap the code fragment in a class or module.  It also does not support the use of super
+    # to subclass any methods defined in the fragment, the methods will just be overwritten.
+    #
+    # @param partial [String] the code fragment to eval against the class
+    #
+    def self.use(partial)
+      dirname = ::File.dirname(partial)
+      basename = ::File.basename(partial, ".rb")
+      basename = basename[1..-1] if basename.start_with?("_")
+      class_eval IO.read(::File.expand_path("#{dirname}/_#{basename}.rb", ::File.dirname(caller_locations.first.absolute_path)))
+    end
+
     # delegate to the resource
     #
     def_delegators :@new_resource, :property_is_set?
@@ -95,6 +109,7 @@ class Chef
       @new_resource = new_resource
       @action = action
       @current_resource = nil
+      @after_resource = nil
       @run_context = run_context
       @converge_actions = nil
 
@@ -137,6 +152,7 @@ class Chef
       new_resource.cookbook_name
     end
 
+    # hook that subclasses can use to do lazy validation for where properties aren't flexibile enough
     def check_resource_semantics!; end
 
     # a simple placeholder method that will be called / raise if a resource tries to
@@ -149,6 +165,13 @@ class Chef
 
     def cleanup_after_converge; end
 
+    def load_after_resource
+      # This is a backwards compatible hack, custom resources properly wire up a new after_resource
+      # via load_current_value.  It is acceptible for old style resources that cannot be easily made
+      # into custom resources to override this method and provide a proper after_resource.
+      @after_resource = @new_resource
+    end
+
     # the :nothing action which is available on all resources by default
     def action_nothing
       logger.trace("Doing nothing for #{@new_resource}")
@@ -159,12 +182,20 @@ class Chef
       run_context.events
     end
 
+    def validate_required_properties!
+      # all we do is run through all the required properties for this action and vivify them
+      new_resource.class.properties.each { |name, property| property.required?(action) && property.get(new_resource) }
+    end
+
     def run_action(action = nil)
       @action = action unless action.nil?
 
-      # @todo it would be preferable to get the action to be executed in the constructor...
+      # hook that subclasses can use to do lazy validation for where properties aren't flexibile enough
       check_resource_semantics!
 
+      # force the validation of required properties
+      validate_required_properties!
+
       # user-defined LWRPs may include unsafe load_current_resource methods that cannot be run in whyrun mode
       if whyrun_mode? && !whyrun_supported?
         events.resource_current_state_load_bypassed(@new_resource, @action, @current_resource)
@@ -192,6 +223,9 @@ class Chef
       set_updated_status
 
       cleanup_after_converge
+
+      load_after_resource
+      events.resource_after_state_loaded(@new_resource, @action, @after_resource)
     end
 
     def process_resource_requirements
@@ -334,7 +368,7 @@ class Chef
     end
 
     def self.provides(short_name, opts = {}, &block)
-      Chef.provider_handler_map.set(short_name, self, opts, &block)
+      Chef.provider_handler_map.set(short_name, self, **opts, &block)
     end
 
     def self.provides?(node, resource)

data/lib/chef/provider/cron.rb

@@ -95,7 +95,7 @@ class Chef
         end
       end
 
-      def action_create
+      action :create do
         crontab = ""
         newcron = ""
         cron_found = false
@@ -155,7 +155,7 @@ class Chef
         end
       end
 
-      def action_delete
+      action :delete do
         if @cron_exists
           crontab = ""
           cron_found = false

data/lib/chef/provider/directory.rb

@@ -121,7 +121,7 @@ class Chef
         end
       end
 
-      def action_create
+      action :create do
         unless ::File.exists?(new_resource.path)
           converge_by("create new directory #{new_resource.path}") do
             if new_resource.recursive == true
@@ -137,7 +137,7 @@ class Chef
         load_resource_attributes_from_file(new_resource) unless Chef::Config[:why_run]
       end
 
-      def action_delete
+      action :delete do
         if ::File.exists?(new_resource.path)
           converge_by("delete existing directory #{new_resource.path}") do
             if new_resource.recursive == true

data/lib/chef/provider/dsc_resource.rb

@@ -33,7 +33,7 @@ class Chef
         @reboot_resource = nil
       end
 
-      def action_run
+      action :run do
         unless test_resource
           converge_by(generate_description) do
             result = set_resource

data/lib/chef/provider/dsc_script.rb

@@ -40,7 +40,7 @@ class Chef
           end }
       end
 
-      def action_run
+      action :run do
         unless @resource_converged
           converge_by(generate_description) do
             run_configuration(:set)

data/lib/chef/provider/execute.rb

@@ -27,7 +27,7 @@ class Chef
 
       provides :execute, target_mode: true
 
-      def_delegators :new_resource, :command, :returns, :environment, :user, :domain, :password, :group, :cwd, :umask, :creates, :elevated, :default_env
+      def_delegators :new_resource, :command, :returns, :environment, :user, :domain, :password, :group, :cwd, :umask, :creates, :elevated, :default_env, :timeout
 
       def load_current_resource
         current_resource = Chef::Resource::Execute.new(new_resource.name)
@@ -41,13 +41,7 @@ class Chef
         end
       end
 
-      def timeout
-        # original implementation did not specify a timeout, but ShellOut
-        # *always* times out. So, set a very long default timeout
-        new_resource.timeout || 3600
-      end
-
-      def action_run
+      action :run do
         if creates && sentinel_file.exist?
           logger.debug("#{new_resource} sentinel file #{sentinel_file} exists - nothing to do")
           return false

data/lib/chef/provider/file.rb

@@ -137,7 +137,7 @@ class Chef
         end
       end
 
-      def action_create
+      action :create do
         do_generate_content
         do_validate_content
         do_unlink
@@ -148,7 +148,7 @@ class Chef
         load_resource_attributes_from_file(new_resource) unless Chef::Config[:why_run]
       end
 
-      def action_create_if_missing
+      action :create_if_missing do
         unless ::File.exist?(new_resource.path)
           action_create
         else
@@ -156,7 +156,7 @@ class Chef
         end
       end
 
-      def action_delete
+      action :delete do
         if ::File.exists?(new_resource.path)
           converge_by("delete file #{new_resource.path}") do
             do_backup unless file_class.symlink?(new_resource.path)
@@ -166,7 +166,7 @@ class Chef
         end
       end
 
-      def action_touch
+      action :touch do
         action_create
         converge_by("update utime on file #{new_resource.path}") do
           time = Time.now
@@ -381,7 +381,7 @@ class Chef
 
       def update_file_contents
         do_backup unless needs_creating?
-        deployment_strategy.deploy(tempfile.path, ::File.realpath(new_resource.path))
+        deployment_strategy.deploy(tempfile.path, ::File.realpath(new_resource.path).force_encoding(Chef::Config[:ruby_encoding]))
         logger.info("#{new_resource} updated file contents #{new_resource.path}")
         if managing_content?
           # save final checksum for reporting.

data/lib/chef/provider/git.rb

@@ -41,13 +41,27 @@ class Chef
       end
 
       def define_resource_requirements
+        unless new_resource.user.nil?
+          requirements.assert(:all_actions) do |a|
+            a.assertion do
+              begin
+                get_homedir(new_resource.user)
+              rescue ArgumentError
+                false
+              end
+            end
+            a.whyrun("User #{new_resource.user} does not exist, this run will fail unless it has been previously created. Assuming it would have been created.")
+            a.failure_message(Chef::Exceptions::User, "#{new_resource.user} required by resource #{new_resource.name} does not exist")
+          end
+        end
+
         # Parent directory of the target must exist.
         requirements.assert(:checkout, :sync) do |a|
           dirname = ::File.dirname(cwd)
           a.assertion { ::File.directory?(dirname) }
           a.whyrun("Directory #{dirname} does not exist, this run will fail unless it has been previously created. Assuming it would have been created.")
           a.failure_message(Chef::Exceptions::MissingParentDirectory,
-            "Cannot clone #{new_resource} to #{cwd}, the enclosing directory #{dirname} does not exist")
+                            "Cannot clone #{new_resource} to #{cwd}, the enclosing directory #{dirname} does not exist")
         end
 
         requirements.assert(:all_actions) do |a|
@@ -71,7 +85,7 @@ class Chef
         end
       end
 
-      def action_checkout
+      action :checkout do
         if target_dir_non_existent_or_empty?
           clone
           if new_resource.enable_checkout
@@ -84,14 +98,14 @@ class Chef
         end
       end
 
-      def action_export
+      action :export do
         action_checkout
         converge_by("complete the export by removing #{cwd}.git after checkout") do
           FileUtils.rm_rf(::File.join(cwd, ".git"))
         end
       end
 
-      def action_sync
+      action :sync do
         if existing_git_clone?
           logger.trace "#{new_resource} current revision: #{current_resource.revision} target revision: #{target_revision}"
           unless current_revision_matches_target_revision?
@@ -168,13 +182,24 @@ class Chef
       end
 
       def checkout
-        sha_ref = target_revision
-
-        converge_by("checkout ref #{sha_ref} branch #{new_resource.revision}") do
+        converge_by("checkout ref #{target_revision} branch #{new_resource.revision}") do
           # checkout into a local branch rather than a detached HEAD
-          git("branch", "-f", new_resource.checkout_branch, sha_ref, cwd: cwd)
-          git("checkout", new_resource.checkout_branch, cwd: cwd)
-          logger.info "#{new_resource} checked out branch: #{new_resource.revision} onto: #{new_resource.checkout_branch} reference: #{sha_ref}"
+          if new_resource.checkout_branch
+            # check out to a local branch
+            git("branch", "-f", new_resource.checkout_branch, target_revision, cwd: cwd)
+            git("checkout", new_resource.checkout_branch, cwd: cwd)
+            logger.info "#{new_resource} checked out branch: #{new_resource.revision} onto: #{new_resource.checkout_branch} reference: #{target_revision}"
+          elsif sha_hash?(new_resource.revision) || !is_branch?
+            # detached head
+            git("checkout", target_revision, cwd: cwd)
+            logger.info "#{new_resource} checked out reference: #{target_revision}"
+          else
+            # need a branch with a tracking branch
+            git("branch", "-f", new_resource.revision, target_revision, cwd: cwd)
+            git("checkout", new_resource.revision, cwd: cwd)
+            git("branch", "-u", "#{new_resource.remote}/#{new_resource.revision}", cwd: cwd)
+            logger.info "#{new_resource} checked out branch: #{new_resource.revision} reference: #{target_revision}"
+          end
         end
       end
 
@@ -197,7 +222,19 @@ class Chef
           logger.trace "Fetching updates from #{new_resource.remote} and resetting to revision #{target_revision}"
           git("fetch", "--prune", new_resource.remote, cwd: cwd)
           git("fetch", new_resource.remote, "--tags", cwd: cwd)
-          git("reset", "--hard", target_revision, cwd: cwd)
+          if new_resource.checkout_branch
+            # check out to a local branch
+            git("branch", "-f", new_resource.checkout_branch, target_revision, cwd: cwd)
+            git("checkout", new_resource.checkout_branch, cwd: cwd)
+          elsif sha_hash?(new_resource.revision) || is_tag?
+            # detached head
+            git("reset", "--hard", target_revision, cwd: cwd)
+          else
+            # need a branch with a tracking branch
+            git("branch", "-f", new_resource.revision, target_revision, cwd: cwd)
+            git("checkout", new_resource.revision, cwd: cwd)
+            git("branch", "-u", "#{new_resource.remote}/#{new_resource.revision}", cwd: cwd)
+          end
         end
       end
 
@@ -273,9 +310,18 @@ class Chef
 
       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
+        if !found.empty?
+          @is_tag = true
+          found
+        else
+          found = refs_search(refs, rev_match_pattern("refs/heads/", revision) + suffix)
+          if !found.empty?
+            @is_branch = true
+            found
+          else
+            refs_search(refs, revision + suffix)
+          end
+        end
       end
 
       def rev_match_pattern(prefix, revision)
@@ -306,6 +352,14 @@ class Chef
 
       private
 
+      def is_branch?
+        !!@is_branch
+      end
+
+      def is_tag?
+        !!@is_tag
+      end
+
       def run_options(run_opts = {})
         env = {}
         if new_resource.user
@@ -313,18 +367,7 @@ class Chef
           # Certain versions of `git` misbehave if git configuration is
           # inaccessible in $HOME. We need to ensure $HOME matches the
           # user who is executing `git` not the user running Chef.
-          env["HOME"] =
-            begin
-              require "etc" unless defined?(Etc)
-              case new_resource.user
-              when Integer
-                Etc.getpwuid(new_resource.user).dir
-              else
-                Etc.getpwnam(new_resource.user.to_s).dir
-              end
-            rescue ArgumentError # user not found
-              raise Chef::Exceptions::User, "Could not determine HOME for specified user '#{new_resource.user}' for resource '#{new_resource.name}'"
-            end
+          env["HOME"] = get_homedir(new_resource.user)
         end
         run_opts[:group] = new_resource.group if new_resource.group
         env["GIT_SSH"] = new_resource.ssh_wrapper if new_resource.ssh_wrapper
@@ -338,7 +381,7 @@ class Chef
       def git(*args, **run_opts)
         git_command = ["git", args].compact.join(" ")
         logger.trace "running #{git_command}"
-        shell_out!(git_command, run_options(run_opts))
+        shell_out!(git_command, **run_options(run_opts))
       end
 
       def sha_hash?(string)
@@ -355,6 +398,20 @@ class Chef
           new_resource.repository
         end
       end
+
+      # Returns the home directory of the user
+      # @param [String] user must be a string.
+      # @return [String] the home directory of the user.
+      #
+      def get_homedir(user)
+        require "etc" unless defined?(Etc)
+        case user
+        when Integer
+          Etc.getpwuid(user).dir
+        else
+          Etc.getpwnam(user.to_s).dir
+        end
+      end
     end
   end
 end