chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

data/lib/chef/provider/file/content.rb

@@ -0,0 +1,39 @@
+#
+# Author:: Lamont Granquist (<lamont@opscode.com>)
+# Copyright:: Copyright (c) 2013 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/file_content_management/content_base'
+require 'chef/file_content_management/tempfile'
+
+class Chef
+  class Provider
+    class File
+      class Content < Chef::FileContentManagement::ContentBase
+        def file_for_provider
+          if @new_resource.content
+            tempfile = Chef::FileContentManagement::Tempfile.new(@new_resource).tempfile
+            tempfile.write(@new_resource.content)
+            tempfile.close
+            tempfile
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef/provider/git.rb

@@ -21,14 +21,13 @@ require 'chef/log'
 require 'chef/provider'
 require 'chef/mixin/shell_out'
 require 'fileutils'
-require 'shellwords'
 
 class Chef
   class Provider
     class Git < Chef::Provider
 
       include Chef::Mixin::ShellOut
-      
+
       def whyrun_supported?
         true
       end
@@ -42,7 +41,7 @@ class Chef
       end
 
       def define_resource_requirements
-        # Parent directory of the target must exist. 
+        # Parent directory of the target must exist.
         requirements.assert(:checkout, :sync) do |a|
           dirname = ::File.dirname(@new_resource.destination)
           a.assertion { ::File.directory?(dirname) }
@@ -62,16 +61,16 @@ class Chef
         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 
+          # 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, 
+          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" + 
+            "Verify your (case-sensitive) repository URL and revision.\n" +
             "`git ls-remote` output: #{@resolved_reference}"
         end
-      end 
+      end
 
       def action_checkout
         if target_dir_non_existent_or_empty?
@@ -86,7 +85,7 @@ class Chef
 
       def action_export
         action_checkout
-        converge_by("complete the export by removing #{@new_resource.destination}.git after checkout") do 
+        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
@@ -129,16 +128,13 @@ class Chef
           @new_resource.additional_remotes.each_pair do |remote_name, remote_url|
             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
+              setup_remote_tracking_branches(remote_name, remote_url)
             end
           end
         end
       end
 
-      def clone 
+      def clone
         converge_by("clone from #{@new_resource.repository} into #{@new_resource.destination}") do
           remote = @new_resource.remote
 
@@ -148,8 +144,8 @@ class Chef
 
           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}\" \"#{@new_resource.destination}\""
+          shell_out!(clone_cmd, run_options)
         end
       end
 
@@ -164,17 +160,20 @@ class Chef
 
       def enable_submodules
         if @new_resource.enable_submodules
-          converge_by("enable git submodules for #{@new_resource}") do 
+          converge_by("enable git submodules for #{@new_resource}") do
+            Chef::Log.info "#{@new_resource} synchronizing git submodules"
+            command = "git submodule sync"
+            shell_out!(command, run_options(:cwd => @new_resource.destination))
             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))
+            shell_out!(command, run_options(:cwd => @new_resource.destination))
           end
         end
       end
 
       def fetch_updates
-        setup_remote_tracking_branches if @new_resource.remote != 'origin'
+        setup_remote_tracking_branches(@new_resource.remote, @new_resource.repository)
         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}"
@@ -183,23 +182,38 @@ class Chef
         end
       end
 
-      # Use git-config to setup a remote tracking branches. Could use
-      # git-remote but it complains when a remote of the same name already
-      # exists, git-config will just silenty overwrite the setting every
-      # time. This could cause wierd-ness in the remote cache if the url
-      # changes between calls, but as long as the repositories are all
-      # based from each other it should still work fine.
-      def setup_remote_tracking_branches
-        command = []
-        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))
+      def setup_remote_tracking_branches(remote_name, remote_url)
+        converge_by("set up remote tracking branches for #{remote_url} at #{remote_name}") do
+          Chef::Log.debug "#{@new_resource} configuring remote tracking branches for repository #{remote_url} "+
+            "at remote #{remote_name}"
+          check_remote_command = "git config --get remote.#{remote_name}.url"
+          remote_status = shell_out!(check_remote_command, run_options(:cwd => @new_resource.destination, :returns => [0,1,2]))
+          case remote_status.exitstatus
+          when 0, 2
+            # * Status 0 means that we already have a remote with this name, so we should update the url
+            #   if it doesn't match the url we want.
+            # * Status 2 means that we have multiple urls assigned to the same remote (not a good idea)
+            #   which we can fix by replacing them all with our target url (hence the --replace-all option)
+
+            if multiple_remotes?(remote_status) || !remote_matches?(remote_url,remote_status)
+              update_remote_url_command = "git config --replace-all remote.#{remote_name}.url #{remote_url}"
+              shell_out!(update_remote_url_command, run_options(:cwd => @new_resource.destination))
+            end
+          when 1
+            add_remote_command = "git remote add #{remote_name} #{remote_url}"
+            shell_out!(add_remote_command, run_options(:cwd => @new_resource.destination))
+          end
         end
       end
 
+      def multiple_remotes?(check_remote_command_result)
+        check_remote_command_result.exitstatus == 2
+      end
+
+      def remote_matches?(remote_url, check_remote_command_result)
+        check_remote_command_result.stdout.strip.eql?(remote_url)
+      end
+
       def current_revision_matches_target_revision?
         (!@current_resource.revision.nil?) && (target_revision.strip.to_i(16) == @current_resource.revision.strip.to_i(16))
       end
@@ -218,12 +232,37 @@ class Chef
 
       def remote_resolve_reference
         Chef::Log.debug("#{@new_resource} resolving remote reference")
-        command = git('ls-remote', @new_resource.repository, @new_resource.revision)
+        # The sha pointed to by an annotated tag is identified by the
+        # '^{}' suffix appended to the tag. In order to resolve
+        # 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
-        if  @resolved_reference =~ /^([0-9a-f]{40})\s+(\S+)/
-          $1
+        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}^{}") }
+        # 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]
         else
-          nil
+          found = refs.find { |m| m[1].end_with?(@new_resource.revision) }
+          if found
+            found[0]
+          else
+            nil
+          end
         end
       end
 
@@ -234,12 +273,6 @@ class Chef
         run_opts[:group] = @new_resource.group if @new_resource.group
         run_opts[:environment] = {"GIT_SSH" => @new_resource.ssh_wrapper} if @new_resource.ssh_wrapper
         run_opts[:log_tag] = @new_resource.to_s
-        run_opts[:log_level] ||= :debug
-        if run_opts[:log_level] == :info
-          if STDOUT.tty? && !Chef::Config[:daemon] && Chef::Log.info?
-            run_opts[:live_stream] = STDOUT
-          end
-        end
         run_opts
       end
 

data/lib/chef/provider/group.rb

@@ -6,9 +6,9 @@
 # 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.
@@ -18,7 +18,6 @@
 
 require 'chef/provider'
 require 'chef/mixin/command'
-require 'chef/resource/group'
 require 'etc'
 
 class Chef
@@ -36,11 +35,11 @@ class Chef
         super
         @group_exists = true
       end
-
+      
       def load_current_resource
         @current_resource = Chef::Resource::Group.new(@new_resource.name)
         @current_resource.group_name(@new_resource.group_name)
-
+        
         group_info = nil
         begin
           group_info = Etc.getgrnam(@new_resource.group_name)
@@ -48,47 +47,37 @@ class Chef
           @group_exists = false
           Chef::Log.debug("#{@new_resource} group does not exist")
         end
-
+        
         if group_info
           @new_resource.gid(group_info.gid) unless @new_resource.gid
           @current_resource.gid(group_info.gid)
           @current_resource.members(group_info.mem)
         end
-
+        
         @current_resource
       end
 
       def define_resource_requirements
-        requirements.assert(:modify) do |a|
-          a.assertion { @group_exists }
+        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
-
-        requirements.assert(:all_actions) do |a|
-          # Make sure that the resource doesn't contain any common
-          # user names in the members and exclude_members properties.
-          if !@new_resource.members.nil? && !@new_resource.excluded_members.nil?
-            common_members = @new_resource.members & @new_resource.excluded_members
-            a.assertion { common_members.empty? }
-            a.failure_message(Chef::Exceptions::ConflictingMembersInGroup, "Attempting to both add and remove users from a group: '#{common_members.join(', ')}'")
-            # No why-run alternative
-          end
-        end
       end
-
-      # Check to see if a group needs any changes. Populate
-      # @change_desc with a description of why a change must occur
+      
+      # 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
-        @change_desc = [ ]
+        @change_desc = nil
         if @new_resource.gid != @current_resource.gid
-          @change_desc << "change gid #{@current_resource.gid} to #{@new_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|
@@ -96,44 +85,35 @@ class Chef
             missing_members << member
           end
           if missing_members.length > 0
-            @change_desc << "add missing member(s): #{missing_members.join(", ")}"
-          end
-
-          members_to_be_removed = []
-          @new_resource.excluded_members.each do |member|
-            if @current_resource.members.include?(member)
-              members_to_be_removed << member
-            end
-          end
-          if members_to_be_removed.length > 0
-            @change_desc << "remove existing member(s): #{members_to_be_removed.join(", ")}"
+            @change_desc = "add missing member(s): #{missing_members.join(", ")}"
+            return true
           end
         else
           if @new_resource.members != @current_resource.members
-            @change_desc << "replace group members with new list of members"
+            @change_desc = "replace group members with new list of members"
+            return true
           end
         end
-
-        !@change_desc.empty?
+        return false
       end
-
+      
       def action_create
         case @group_exists
         when false
-          converge_by("create #{@new_resource}") do
+          converge_by("create #{@new_resource}") do 
             create_group
             Chef::Log.info("#{@new_resource} created")
           end
-        else
+        else 
           if compare_group
-            converge_by(["alter group #{@new_resource}"] + change_desc) do
+            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
           converge_by("remove group #{@new_resource}") do
@@ -142,25 +122,25 @@ class Chef
           end
         end
       end
-
+      
       def action_manage
         if @group_exists && compare_group
-          converge_by(["manage group #{@new_resource}"] + change_desc) do
-            manage_group
+          converge_by(["manage group #{@new_resource}", @change_desc]) do
+            manage_group 
             Chef::Log.info("#{@new_resource} managed")
           end
         end
       end
-
+      
       def action_modify
         if compare_group
-          converge_by(["modify group #{@new_resource}"] + change_desc) do
+          converge_by(["modify group #{@new_resource}", @change_desc]) do
             manage_group
             Chef::Log.info("#{@new_resource} modified")
           end
         end
       end
-
+      
       def create_group
         raise NotImplementedError, "subclasses of Chef::Provider::Group should define #create_group"
       end

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

@@ -39,33 +39,11 @@ class Chef
           return result[2]
         end
         
-        def load_current_resource
-          @current_resource = Chef::Resource::Group.new(@new_resource.name)
-          @current_resource.group_name(@new_resource.name)
-          group_info = nil
-          begin
-            group_info = safe_dscl("read /Groups/#{@new_resource.name}")
-          rescue Chef::Exceptions::Group
-            @group_exists = false
-            Chef::Log.debug("#{@new_resource} group does not exist")
-          end
-
-          if group_info
-            group_info.each_line do |line|
-              key, val = line.split(': ')
-              val.strip! if val
-              case key.downcase
-              when 'primarygroupid'
-                @new_resource.gid(val) unless @new_resource.gid
-                @current_resource.gid(val)
-              when 'groupmembership'
-                @current_resource.members(val.split(' '))
-              end
-            end
-          end
-
-          @current_resource
-        end
+        # This is handled in providers/group.rb by Etc.getgrnam()
+        # def group_exists?(group)
+        #   groups = safe_dscl("list /Groups")
+        #   !! ( groups =~ Regexp.new("\n#{group}\n") )
+        # end
 
         # get a free GID greater than 200
         def get_free_gid(search_limit=1000)
@@ -95,36 +73,14 @@ class Chef
         end
 
         def set_members
-          # First reset the memberships if the append is not set
           unless @new_resource.append
             Chef::Log.debug("#{@new_resource} removing group members #{@current_resource.members.join(' ')}") unless @current_resource.members.empty?
             safe_dscl("create /Groups/#{@new_resource.group_name} GroupMembers ''") # clear guid list
             safe_dscl("create /Groups/#{@new_resource.group_name} GroupMembership ''") # clear user list
-            @current_resource.members([ ])
-          end
-
-          # Add any members that need to be added
-          if @new_resource.members && !@new_resource.members.empty?
-            members_to_be_added = [ ]
-            @new_resource.members.each do |member|
-              members_to_be_added << member if !@current_resource.members.include?(member)
-            end
-            unless members_to_be_added.empty?
-              Chef::Log.debug("#{@new_resource} setting group members #{members_to_be_added.join(', ')}")
-              safe_dscl("append /Groups/#{@new_resource.group_name} GroupMembership #{members_to_be_added.join(' ')}")
-            end
           end
-
-          # Remove any members that need to be removed
-          if @new_resource.excluded_members && !@new_resource.excluded_members.empty?
-            members_to_be_removed = [ ]
-            @new_resource.excluded_members.each do |member|
-              members_to_be_removed << member if @current_resource.members.include?(member)
-            end
-            unless members_to_be_removed.empty?
-              Chef::Log.debug("#{@new_resource} removing group members #{members_to_be_removed.join(', ')}")
-              safe_dscl("delete /Groups/#{@new_resource.group_name} GroupMembership #{members_to_be_removed.join(' ')}")
-            end
+          unless @new_resource.members.empty?
+            Chef::Log.debug("#{@new_resource} setting group members #{@new_resource.members.join(', ')}")
+            safe_dscl("append /Groups/#{@new_resource.group_name} GroupMembership #{@new_resource.members.join(' ')}")
           end
         end
 
@@ -137,6 +93,10 @@ class Chef
           end
         end
 
+        def load_current_resource
+          super
+        end
+        
         def create_group
           dscl_create_group
           set_gid
@@ -150,7 +110,7 @@ class Chef
           if @new_resource.gid && (@current_resource.gid != @new_resource.gid)
             set_gid
           end
-          if @new_resource.members || @new_resource.excluded_members
+          if @new_resource.members && (@current_resource.members != @new_resource.members)
             set_members
           end
         end