chef 10.12.0 → 10.14.0.beta.1

data/lib/chef/provider/git.rb

@@ -28,23 +28,57 @@ class Chef
     class Git < Chef::Provider
 
       include Chef::Mixin::ShellOut
+      
+      def whyrun_supported?
+        true
+      end
 
       def load_current_resource
+        @resolved_reference = nil
         @current_resource = Chef::Resource::Git.new(@new_resource.name)
         if current_revision = find_current_revision
           @current_resource.revision current_revision
         end
       end
 
-      def action_checkout
-        assert_target_directory_valid!
+      def define_resource_requirements
+        # Parent directory of the target must exist. 
+        requirements.assert(:checkout, :sync) do |a|
+          dirname = ::File.dirname(@new_resource.destination)
+          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 #{@new_resource.destination}, the enclosing directory #{dirname} does not exist")
+        end
+
+
+        requirements.assert(:all_actions) do |a|
+          a.assertion { !(@new_resource.revision =~ /^origin\//) }
+          a.failure_message Chef::Exceptions::InvalidRemoteGitReference,
+             "Deploying remote branches is not supported. " +
+             "Specify the remote branch as a local branch for " +
+             "the git repository you're deploying from " +
+             "(ie: '#{@new_resource.revision.gsub('origin/', '')}' rather than '#{@new_resource.revision}')."
+        end
+
+        requirements.assert(:all_actions) do |a|
+          # this can't be recovered from in why-run mode, because nothing that 
+          # we do in the course of a run is likely to create a valid target_revision 
+          # if we can't resolve it up front.
+          a.assertion { target_revision != nil }
+          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}"
+        end
+      end 
 
+      def action_checkout
         if target_dir_non_existent_or_empty?
           clone
           checkout
           enable_submodules
           add_remotes
-          @new_resource.updated_by_last_action(true)
         else
           Chef::Log.debug "#{@new_resource} checkout destination #{@new_resource.destination} already exists or is a non-empty directory"
         end
@@ -52,13 +86,12 @@ class Chef
 
       def action_export
         action_checkout
-        FileUtils.rm_rf(::File.join(@new_resource.destination,".git"))
-        @new_resource.updated_by_last_action(true)
+        converge_by("complete the export by removing #{@new_resource.destination}.git after checkout") do 
+          FileUtils.rm_rf(::File.join(@new_resource.destination,".git"))
+        end
       end
 
       def action_sync
-        assert_target_directory_valid!
-
         if existing_git_clone?
           current_rev = find_current_revision
           Chef::Log.debug "#{@new_resource} current revision: #{current_rev} target revision: #{target_revision}"
@@ -66,22 +99,13 @@ class Chef
             fetch_updates
             enable_submodules
             Chef::Log.info "#{@new_resource} updated to revision #{target_revision}"
-            @new_resource.updated_by_last_action(true)
           end
           add_remotes
         else
           action_checkout
-          @new_resource.updated_by_last_action(true)
         end
       end
 
-      def assert_target_directory_valid!
-        target_parent_directory = ::File.dirname(@new_resource.destination)
-        unless ::File.directory?(target_parent_directory)
-          msg = "Cannot clone #{@new_resource} to #{@new_resource.destination}, the enclosing directory #{target_parent_directory} does not exist"
-          raise Chef::Exceptions::MissingParentDirectory, msg
-        end
-      end
 
       def existing_git_clone?
         ::File.exist?(::File.join(@new_resource.destination, ".git"))
@@ -103,51 +127,60 @@ class Chef
       def add_remotes
         if (@new_resource.additional_remotes.length > 0)
           @new_resource.additional_remotes.each_pair do |remote_name, remote_url|
-            Chef::Log.info "#{@new_resource} adding git remote #{remote_name} = #{remote_url}"
-            command = "git remote add #{remote_name} #{remote_url}"
-            if shell_out(command, run_options(:cwd => @new_resource.destination, :log_level => :info)).exitstatus != 0
-              @new_resource.updated_by_last_action(true)
+            converge_by("add remote #{remote_name} from #{remote_url}") do
+              Chef::Log.info "#{@new_resource} adding git remote #{remote_name} = #{remote_url}"
+              command = "git remote add #{remote_name} #{remote_url}"
+              if shell_out(command, run_options(:cwd => @new_resource.destination, :log_level => :info)).exitstatus != 0
+                @new_resource.updated_by_last_action(true)
+              end
             end
           end
         end
       end
 
-      def clone
-        remote = @new_resource.remote
+      def clone 
+        converge_by("clone from #{@new_resource.repository} into #{@new_resource.destination}") do
+          remote = @new_resource.remote
 
-        args = []
-        args << "-o #{remote}" unless remote == 'origin'
-        args << "--depth #{@new_resource.depth}" if @new_resource.depth
+          args = []
+          args << "-o #{remote}" unless remote == 'origin'
+          args << "--depth #{@new_resource.depth}" if @new_resource.depth
 
-        Chef::Log.info "#{@new_resource} cloning repo #{@new_resource.repository} to #{@new_resource.destination}"
+          Chef::Log.info "#{@new_resource} cloning repo #{@new_resource.repository} to #{@new_resource.destination}"
 
-        clone_cmd = "git clone #{args.join(' ')} #{@new_resource.repository} #{Shellwords.escape @new_resource.destination}"
-        shell_out!(clone_cmd, run_options(:log_level => :info))
+          clone_cmd = "git clone #{args.join(' ')} #{@new_resource.repository} #{Shellwords.escape @new_resource.destination}"
+          shell_out!(clone_cmd, run_options(:log_level => :info))
+        end
       end
 
       def checkout
         sha_ref = target_revision
-        # checkout into a local branch rather than a detached HEAD
-        shell_out!("git checkout -b deploy #{sha_ref}", run_options(:cwd => @new_resource.destination))
-        Chef::Log.info "#{@new_resource} checked out branch: #{@new_resource.revision} reference: #{sha_ref}"
+        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 deploy #{sha_ref}", run_options(:cwd => @new_resource.destination))
+          Chef::Log.info "#{@new_resource} checked out branch: #{@new_resource.revision} reference: #{sha_ref}"
+        end
       end
 
       def enable_submodules
         if @new_resource.enable_submodules
-          Chef::Log.info "#{@new_resource} enabling git submodules"
-          # the --recursive flag means we require git 1.6.5+ now, see CHEF-1827
-          command = "git submodule update --init --recursive"
-          shell_out!(command, run_options(:cwd => @new_resource.destination, :log_level => :info))
+          converge_by("enable git submodules for #{@new_resource}") do 
+            Chef::Log.info "#{@new_resource} enabling git submodules"
+            # the --recursive flag means we require git 1.6.5+ now, see CHEF-1827
+            command = "git submodule update --init --recursive"
+            shell_out!(command, run_options(:cwd => @new_resource.destination, :log_level => :info))
+          end
         end
       end
 
       def fetch_updates
         setup_remote_tracking_branches if @new_resource.remote != 'origin'
-
-        # since we're in a local branch already, just reset to specified revision rather than merge
-        fetch_command = "git fetch #{@new_resource.remote} && git fetch #{@new_resource.remote} --tags && git reset --hard #{target_revision}"
-        Chef::Log.debug "Fetching updates from #{new_resource.remote} and resetting to revision #{target_revision}"
-        shell_out!(fetch_command, run_options(:cwd => @new_resource.destination))
+        converge_by("fetch updates for #{@new_resource.remote}") do
+          # since we're in a local branch already, just reset to specified revision rather than merge
+          fetch_command = "git fetch #{@new_resource.remote} && git fetch #{@new_resource.remote} --tags && git reset --hard #{target_revision}"
+          Chef::Log.debug "Fetching updates from #{new_resource.remote} and resetting to revision #{target_revision}"
+          shell_out!(fetch_command, run_options(:cwd => @new_resource.destination))
+        end
       end
 
       # Use git-config to setup a remote tracking branches. Could use
@@ -158,12 +191,13 @@ class Chef
       # based from each other it should still work fine.
       def setup_remote_tracking_branches
         command = []
-
-        Chef::Log.debug "#{@new_resource} configuring remote tracking branches for repository #{@new_resource.repository} "+
-                        "at remote #{@new_resource.remote}"
-        command << "git config remote.#{@new_resource.remote}.url #{@new_resource.repository}"
-        command << "git config remote.#{@new_resource.remote}.fetch +refs/heads/*:refs/remotes/#{@new_resource.remote}/*"
-        shell_out!(command.join(" && "), run_options(:cwd => @new_resource.destination))
+        converge_by("set up remote tracking branches for #{@new_resource.repository} at #{@new_resource.remote}") do
+          Chef::Log.debug "#{@new_resource} configuring remote tracking branches for repository #{@new_resource.repository} "+
+                          "at remote #{@new_resource.remote}"
+          command << "git config remote.#{@new_resource.remote}.url #{@new_resource.repository}"
+          command << "git config remote.#{@new_resource.remote}.fetch +refs/heads/*:refs/remotes/#{@new_resource.remote}/*"
+          shell_out!(command.join(" && "), run_options(:cwd => @new_resource.destination))
+        end
       end
 
       def current_revision_matches_target_revision?
@@ -172,13 +206,10 @@ class Chef
 
       def target_revision
         @target_revision ||= begin
-          assert_revision_not_remote
-
           if sha_hash?(@new_resource.revision)
             @target_revision = @new_resource.revision
           else
-            resolved_reference = remote_resolve_reference
-            @target_revision = extract_revision(resolved_reference)
+            @target_revision = remote_resolve_reference
           end
         end
       end
@@ -188,7 +219,12 @@ class Chef
       def remote_resolve_reference
         Chef::Log.debug("#{@new_resource} resolving remote reference")
         command = git('ls-remote', @new_resource.repository, @new_resource.revision)
-        shell_out!(command, run_options).stdout
+        @resolved_reference = shell_out!(command, run_options).stdout
+        if  @resolved_reference =~ /^([0-9a-f]{40})\s+(\S+)/
+          $1
+        else
+          nil
+        end
       end
 
       private
@@ -219,27 +255,6 @@ class Chef
         string =~ /^[0-9a-f]{40}$/
       end
 
-      def assert_revision_not_remote
-        if @new_resource.revision =~ /^origin\//
-          reference = @new_resource.revision
-          error_text =  "Deploying remote branches is not supported. " +
-                        "Specify the remote branch as a local branch for " +
-                        "the git repository you're deploying from " +
-                        "(ie: '#{reference.gsub('origin/', '')}' rather than '#{reference}')."
-          raise RuntimeError, error_text
-        end
-      end
-
-      def extract_revision(resolved_reference)
-        unless resolved_reference =~ /^([0-9a-f]{40})\s+(\S+)/
-          msg = "Unable to parse SHA reference for '#{@new_resource.revision}' in repository '#{@new_resource.repository}'. "
-          msg << "Verify your (case-sensitive) repository URL and revision.\n"
-          msg << "`git ls-remote` output: #{resolved_reference}"
-          raise Chef::Exceptions::UnresolvableGitReference, msg
-        end
-        $1
-      end
-
     end
   end
 end

data/lib/chef/provider/group.rb

@@ -26,7 +26,12 @@ class Chef
     class Group < Chef::Provider
       include Chef::Mixin::Command
       attr_accessor :group_exists
-      
+      attr_accessor :change_desc
+
+      def whyrun_supported?
+        true
+      end
+
       def initialize(new_resource, run_context)
         super
         @group_exists = true
@@ -52,67 +57,88 @@ class Chef
         
         @current_resource
       end
+
+      def define_resource_requirements
+        requirements.assert(:modify) do |a| 
+          a.assertion { @group_exists } 
+          a.failure_message(Chef::Exceptions::Group, "Cannot modify #{@new_resource} - group does not exist!")
+          a.whyrun("Group #{@new_resource} does not exist. Unless it would have been created earlier in this run, this attempt to modify it would fail.")
+        end
+      end
       
-      # Check to see if a group needs any changes
+      # Check to see if a group needs any changes. Populate 
+      # @change_desc with a description of why a change must occur 
       #
       # ==== Returns
       # <true>:: If a change is required
       # <false>:: If a change is not required
       def compare_group
-        return true if @new_resource.gid != @current_resource.gid
-
+        @change_desc = nil
+        if @new_resource.gid != @current_resource.gid
+          @change_desc = "change gid #{@current_resource.gid} to #{@new_resource.gid}"
+          return true
+        end
+        
         if(@new_resource.append)
+          missing_members = []
           @new_resource.members.each do |member|
             next if @current_resource.members.include?(member)
+            missing_members << member
+          end
+          if missing_members.length > 0
+            @change_desc = "add missing member(s): #{missing_members.join(", ")}"
             return true
           end
         else
-          return true if @new_resource.members != @current_resource.members
+          if @new_resource.members != @current_resource.members
+            @change_desc = "replace group members with new list of members"
+            return true
+          end
         end
-
         return false
       end
       
       def action_create
         case @group_exists
         when false
-          create_group
-          Chef::Log.info("#{@new_resource} created")
-          @new_resource.updated_by_last_action(true)
+          converge_by("create #{@new_resource}") do 
+            create_group
+            Chef::Log.info("#{@new_resource} created")
+          end
         else 
           if compare_group
-            manage_group
-            Chef::Log.info("#{@new_resource} altered")
-            @new_resource.updated_by_last_action(true)
+            converge_by(["alter group #{@new_resource}", @change_desc ]) do 
+              manage_group
+              Chef::Log.info("#{@new_resource} altered")
+            end
           end
         end
       end
       
       def action_remove
         if @group_exists
-          remove_group
-          @new_resource.updated_by_last_action(true)
-          Chef::Log.info("#{@new_resource} removed")
+          converge_by("remove group #{@new_resource}") do
+            remove_group
+            Chef::Log.info("#{@new_resource} removed")
+          end
         end
       end
       
       def action_manage
         if @group_exists && compare_group
-          manage_group 
-          @new_resource.updated_by_last_action(true)
-          Chef::Log.info("#{@new_resource} managed")
+          converge_by(["manage group #{@new_resource}", @change_desc]) do
+            manage_group 
+            Chef::Log.info("#{@new_resource} managed")
+          end
         end
       end
       
       def action_modify
-        if @group_exists 
-          if compare_group
+        if compare_group
+          converge_by(["modify group #{@new_resource}", @change_desc]) do
             manage_group
-            @new_resource.updated_by_last_action(true)
             Chef::Log.info("#{@new_resource} modified")
           end
-        else
-          raise Chef::Exceptions::Group, "Cannot modify #{@new_resource} - group does not exist!"
         end
       end
       

data/lib/chef/provider/group/dscl.rb

@@ -84,9 +84,17 @@ class Chef
           end
         end
 
+        def define_resource_requirements
+          super
+          requirements.assert(:all_actions) do |a| 
+            a.assertion { ::File.exists?("/usr/bin/dscl") } 
+            a.failure_message Chef::Exceptions::Group, "Could not find binary /usr/bin/dscl for #{@new_resource.name}"
+            # No whyrun alternative: this component should be available in the base install of any given system that uses it
+          end
+        end
+
         def load_current_resource
           super
-          raise Chef::Exceptions::Group, "Could not find binary /usr/bin/dscl for #{@new_resource}" unless ::File.exists?("/usr/bin/dscl")
         end
         
         def create_group

data/lib/chef/provider/group/gpasswd.rb

@@ -28,8 +28,15 @@ class Chef
 
         def load_current_resource
           super
+        end
 
-          raise Chef::Exceptions::Group, "Could not find binary /usr/bin/gpasswd for #{@new_resource}" unless ::File.exists?("/usr/bin/gpasswd")
+        def define_resource_requirements
+          super
+          requirements.assert(:all_actions) do |a| 
+            a.assertion { ::File.exists?("/usr/bin/gpasswd") } 
+            a.failure_message Chef::Exceptions::Group, "Could not find binary /usr/bin/gpasswd for #{@new_resource}" 
+            # No whyrun alternative: this component should be available in the base install of any given system that uses it
+          end
         end
 
         def modify_group_members

data/lib/chef/provider/group/groupadd.rb

@@ -29,8 +29,16 @@ class Chef
 
         def load_current_resource
           super
+        end
+
+        def define_resource_requirements
+          super
           required_binaries.each do |required_binary|
-            raise Chef::Exceptions::Group, "Could not find binary #{required_binary} for #{@new_resource}" unless ::File.exists?(required_binary)
+            requirements.assert(:all_actions) do |a| 
+              a.assertion { ::File.exists?(required_binary) } 
+              a.failure_message Chef::Exceptions::Group, "Could not find binary #{required_binary} for #{@new_resource}" 
+              # No whyrun alternative: this component should be available in the base install of any given system that uses it
+            end
           end
         end
 

data/lib/chef/provider/group/groupmod.rb

@@ -0,0 +1,120 @@
+#
+# Author:: Dan Crosta (<dcrosta@late.am>)
+# Copyright:: Copyright (c) 2012 Opscode, 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/mixin/shell_out'
+
+class Chef
+  class Provider
+    class Group
+      class Groupmod < Chef::Provider::Group
+
+        include Chef::Mixin::ShellOut
+
+        def load_current_resource
+          super
+          [ "group", "user" ].each do |binary|
+            raise Chef::Exceptions::Group, "Could not find binary /usr/sbin/#{binary} for #{@new_resource}" unless ::File.exists?("/usr/sbin/#{binary}")
+          end
+        end
+
+        # Create the group
+        def create_group
+          command = "group add"
+          command << set_options
+          shell_out!(command)
+
+          add_group_members(@new_resource.members)
+        end
+
+        # Manage the group when it already exists
+        def manage_group
+          if @new_resource.append
+            to_add = @new_resource.members.dup
+            to_add.reject! { |user| @current_resource.members.include?(user) }
+
+            to_delete = Array.new
+
+            Chef::Log.debug("#{@new_resource} not changing group members, the group has no members to add") if to_add.empty?
+          else
+            to_add = @new_resource.members.dup
+            to_add.reject! { |user| @current_resource.members.include?(user) }
+
+            to_delete = @current_resource.members.dup
+            to_delete.reject! { |user| @new_resource.members.include?(user) }
+
+            Chef::Log.debug("#{@new_resource} setting group members to: none") if @new_resource.members.empty?
+          end
+
+          if to_delete.empty?
+            # If we are only adding new members to this group, then
+            # call add_group_members with only those users
+            add_group_members(to_add)
+          else
+            Chef::Log.debug("#{@new_resource} removing members #{to_delete.join(', ')}")
+
+            # This is tricky, but works: rename the existing group to
+            # "<name>_bak", create a new group with the same GID and
+            # "<name>", then set correct members on that group
+            rename = "group mod -n #{@new_resource.group_name}_bak #{@new_resource.group_name}"
+            shell_out!(rename)
+
+            create = "group add"
+            create << set_options(:overwrite_gid => true)
+            shell_out!(create)
+
+            # Ignore to_add here, since we're replacing the group we
+            # have to add all members who should be in the group.
+            add_group_members(@new_resource.members)
+
+            remove = "group del #{@new_resource.group_name}_bak"
+            shell_out!(remove)
+          end
+        end
+
+        # Remove the group
+        def remove_group
+          shell_out!("group del #{@new_resource.group_name}")
+        end
+
+        # Adds a list of usernames to the group using `user mod`
+        def add_group_members(members)
+          Chef::Log.debug("#{@new_resource} adding members #{members.join(', ')}") if !members.empty?
+          members.each do |user|
+            shell_out!("user mod -G #{@new_resource.group_name} #{user}")
+          end
+        end
+
+        # Little bit of magic as per Adam's useradd provider to pull and assign the command line flags
+        #
+        # ==== Returns
+        # <string>:: A string containing the option and then the quoted value
+        def set_options(overwrite_gid=false)
+          opts = ""
+          if overwrite_gid || @new_resource.gid && (@current_resource.gid != @new_resource.gid)
+            opts << " -g '#{@new_resource.gid}'"
+          end
+          if overwrite_gid
+            opts << " -o"
+          end
+          opts << " #{@new_resource.group_name}"
+          opts
+        end
+      end
+    end
+  end
+end