chef 11.4.4 → 11.6.0.hotfix.1

data/lib/chef/cookbook/chefignore.rb

@@ -43,7 +43,8 @@ class Chef
 
       def parse_ignore_file
         ignore_globs = []
-        if File.exist?(@ignore_file) && File.readable?(@ignore_file)
+        if File.exist?(@ignore_file) && File.readable?(@ignore_file) &&
+          (File.file?(@ignore_file) || File.symlink?(@ignore_file))
           File.foreach(@ignore_file) do |line|
             ignore_globs << line.strip unless line =~ COMMENTS_AND_WHITESPACE
           end

data/lib/chef/cookbook/synchronizer.rb

@@ -56,12 +56,14 @@ class Chef
   # Synchronizes the locally cached copies of cookbooks with the files on the
   # server.
   class CookbookSynchronizer
-    EAGER_SEGMENTS = Chef::CookbookVersion::COOKBOOK_SEGMENTS.dup
-    EAGER_SEGMENTS.delete(:files)
-    EAGER_SEGMENTS.delete(:templates)
-    EAGER_SEGMENTS.freeze
-
     def initialize(cookbooks_by_name, events)
+      @eager_segments = Chef::CookbookVersion::COOKBOOK_SEGMENTS.dup
+      unless Chef::Config[:no_lazy_load]
+        @eager_segments.delete(:files)
+        @eager_segments.delete(:templates)
+      end
+      @eager_segments.freeze
+
       @cookbooks_by_name, @events = cookbooks_by_name, events
     end
 
@@ -138,7 +140,7 @@ class Chef
 
       # files and templates are lazily loaded, and will be done later.
 
-      EAGER_SEGMENTS.each do |segment|
+      @eager_segments.each do |segment|
         segment_filenames = Array.new
         cookbook.manifest[segment].each do |manifest_record|
 

data/lib/chef/cookbook/syntax_check.rb

@@ -16,6 +16,7 @@
 # limitations under the License.
 #
 
+require 'pathname'
 require 'chef/mixin/shell_out'
 require 'chef/mixin/checksum'
 
@@ -102,8 +103,22 @@ class Chef
         @validated_files = PersistentSet.new
       end
 
+      def chefignore
+        @chefignore ||= Chefignore.new(File.dirname(cookbook_path))
+      end
+
+      def remove_ignored_files(file_list)
+        return file_list unless chefignore.ignores.length > 0
+        file_list.reject do |full_path|
+          cookbook_pn = Pathname.new cookbook_path
+          full_pn = Pathname.new full_path
+          relative_pn = full_pn.relative_path_from cookbook_pn
+          chefignore.ignored? relative_pn.to_s
+        end
+      end
+
       def ruby_files
-        Dir[File.join(cookbook_path, '**', '*.rb')]
+        remove_ignored_files Dir[File.join(cookbook_path, '**', '*.rb')]
       end
 
       def untested_ruby_files
@@ -118,7 +133,7 @@ class Chef
       end
 
       def template_files
-        Dir[File.join(cookbook_path, '**', '*.erb')]
+        remove_ignored_files Dir[File.join(cookbook_path, '**', '*.erb')]
       end
 
       def untested_template_files

data/lib/chef/cookbook_uploader.rb

@@ -110,7 +110,16 @@ class Chef
       # files are uploaded, so save the manifest
       cookbooks.each do |cb|
         save_url = opts[:force] ? cb.force_save_url : cb.save_url
-        rest.put_rest(save_url, cb)
+        begin
+          rest.put_rest(save_url, cb)
+        rescue Net::HTTPServerException => e
+          case e.response.code
+          when "409"
+            raise Chef::Exceptions::CookbookFrozen, "Version #{cb.version} of cookbook #{cb.name} is frozen. Use --force to override."
+          else
+            raise
+          end
+        end
       end
 
       Chef::Log.info("Upload complete!")

data/lib/chef/cookbook_version.rb

@@ -79,115 +79,6 @@ class Chef
       Chef::FileCache
     end
 
-    # Synchronizes all the cookbooks from the chef-server.
-    #
-    # === Returns
-    # true:: Always returns true
-    def self.sync_cookbooks(cookbook_hash)
-      Chef::Log.info("Loading cookbooks [#{cookbook_hash.keys.sort.join(', ')}]")
-      Chef::Log.debug("Cookbooks detail: #{cookbook_hash.inspect}")
-
-      clear_obsoleted_cookbooks(cookbook_hash)
-
-      # Synchronize each of the node's cookbooks, and add to the
-      # valid_cache_entries hash.
-      cookbook_hash.values.each do |cookbook|
-        sync_cookbook_file_cache(cookbook)
-      end
-
-      true
-    end
-
-    # Iterates over cached cookbooks' files, removing files belonging to
-    # cookbooks that don't appear in +cookbook_hash+
-    def self.clear_obsoleted_cookbooks(cookbook_hash)
-      # Remove all cookbooks no longer relevant to this node
-      cache.find(File.join(%w{cookbooks ** *})).each do |cache_file|
-        cache_file =~ /^cookbooks\/([^\/]+)\//
-        unless cookbook_hash.has_key?($1)
-          Chef::Log.info("Removing #{cache_file} from the cache; its cookbook is no longer needed on this client.")
-          cache.delete(cache_file)
-        end
-      end
-    end
-
-    # Update the file caches for a given cache segment.  Takes a segment name
-    # and a hash that matches one of the cookbooks/_attribute_files style
-    # remote file listings.
-    #
-    # === Parameters
-    # cookbook<Chef::Cookbook>:: The cookbook to update
-    # valid_cache_entries<Hash>:: Out-param; Added to this hash are the files that
-    # were referred to by this cookbook
-    def self.sync_cookbook_file_cache(cookbook)
-      Chef::Log.debug("Synchronizing cookbook #{cookbook.name}")
-
-      # files and templates are lazily loaded, and will be done later.
-      eager_segments = COOKBOOK_SEGMENTS.dup
-
-      unless Chef::Config[:no_lazy_load] then
-        eager_segments.delete(:files)
-        eager_segments.delete(:templates)
-      end
-
-      eager_segments.each do |segment|
-        segment_filenames = Array.new
-        cookbook.manifest[segment].each do |manifest_record|
-          # segment = cookbook segment
-          # remote_list = list of file hashes
-          #
-          # We need the list of known good attribute files, so we can delete any that are
-          # just laying about.
-
-          cache_filename = File.join("cookbooks", cookbook.name, manifest_record['path'])
-          valid_cache_entries[cache_filename] = true
-
-          current_checksum = nil
-          if cache.has_key?(cache_filename)
-            current_checksum = checksum_cookbook_file(cache.load(cache_filename, false))
-          end
-
-          # If the checksums are different between on-disk (current) and on-server
-          # (remote, per manifest), do the update. This will also execute if there
-          # is no current checksum.
-          if current_checksum != manifest_record['checksum']
-            raw_file = chef_server_rest.get_rest(manifest_record[:url], true)
-
-            Chef::Log.info("Storing updated #{cache_filename} in the cache.")
-            cache.move_to(raw_file.path, cache_filename)
-          else
-            Chef::Log.debug("Not storing #{cache_filename}, as the cache is up to date.")
-          end
-
-          # make the segment filenames a full path.
-          full_path_cache_filename = cache.load(cache_filename, false)
-          segment_filenames << full_path_cache_filename
-        end
-
-        # replace segment filenames with a full-path one.
-        if segment.to_sym == :recipes
-          cookbook.recipe_filenames = segment_filenames
-        elsif segment.to_sym == :attributes
-          cookbook.attribute_filenames = segment_filenames
-        else
-          cookbook.segment_filenames(segment).replace(segment_filenames)
-        end
-      end
-    end
-
-    def self.cleanup_file_cache
-      unless Chef::Config[:solo]
-        # Delete each file in the cache that we didn't encounter in the
-        # manifest.
-        cache.find(File.join(%w{cookbooks ** *})).each do |cache_filename|
-          unless valid_cache_entries[cache_filename]
-            Chef::Log.info("Removing #{cache_filename} from the cache; it is no longer needed by chef-client.")
-            cache.delete(cache_filename)
-          end
-        end
-      end
-    end
-
     # Creates a new Chef::CookbookVersion object.
     #
     # === Returns

data/lib/chef/data_bag.rb

@@ -82,14 +82,23 @@ class Chef
     end
 
     def self.list(inflate=false)
-      if inflate
-        # Can't search for all data bags like other objects, fall back to N+1 :(
-        list(false).inject({}) do |response, bag_and_uri|
-          response[bag_and_uri.first] = load(bag_and_uri.first)
-          response
+      if Chef::Config[:solo]
+        unless File.directory?(Chef::Config[:data_bag_path])
+          raise Chef::Exceptions::InvalidDataBagPath, "Data bag path '#{Chef::Config[:data_bag_path]}' is invalid"
         end
+
+        names = Dir.glob(File.join(Chef::Config[:data_bag_path], "*")).map{|f|File.basename(f)}.sort
+        names.inject({}) {|h, n| h[n] = n; h}
       else
-        Chef::REST.new(Chef::Config[:chef_server_url]).get_rest("data")
+        if inflate
+          # Can't search for all data bags like other objects, fall back to N+1 :(
+          list(false).inject({}) do |response, bag_and_uri|
+            response[bag_and_uri.first] = load(bag_and_uri.first)
+            response
+          end
+        else
+          Chef::REST.new(Chef::Config[:chef_server_url]).get_rest("data")
+        end
       end
     end
 

data/lib/chef/deprecation/mixin/template.rb

@@ -0,0 +1,49 @@
+#
+# Author:: Serdar Sutay (<serdar@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 'tempfile'
+require 'erubis'
+
+class Chef
+  module Deprecation
+    module Mixin
+      # == Deprecation::Provider::Mixin::Template
+      # This module contains the deprecated functions of
+      # Chef::Mixin::Template. These functions are refactored to different
+      # components. They are frozen and will be removed in Chef 12.
+      #
+
+      module Template
+        def render_template(template, context)
+          begin
+            eruby = Erubis::Eruby.new(template)
+            output = eruby.evaluate(context)
+          rescue Object => e
+            raise TemplateError.new(e, template, context)
+          end
+          Tempfile.open("chef-rendered-template") do |tempfile|
+            tempfile.print(output)
+            tempfile.close
+            yield tempfile
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/chef/deprecation/provider/cookbook_file.rb

@@ -0,0 +1,55 @@
+#
+# Author:: Serdar Sutay (<serdar@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.
+#
+
+
+class Chef
+  module Deprecation
+    module Provider
+
+      # == Deprecation::Provider::CookbookFile
+      # This module contains the deprecated functions of
+      # Chef::Provider::CookbookFile. These functions are refactored to
+      # different components. They are frozen and will be removed in Chef 12.
+      #
+      module CookbookFile
+
+        def file_cache_location
+          @file_cache_location ||= begin
+            cookbook = run_context.cookbook_collection[resource_cookbook]
+            cookbook.preferred_filename_on_disk_location(node, :files, @new_resource.source, @new_resource.path)
+          end
+        end
+
+        def resource_cookbook
+          @new_resource.cookbook || @new_resource.cookbook_name
+        end
+
+        def content_stale?
+          ( ! ::File.exist?(@new_resource.path)) || ( ! compare_content)
+        end
+
+        def backup_new_resource
+          if ::File.exists?(@new_resource.path)
+            backup @new_resource.path
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,197 @@
+#
+# Author:: Serdar Sutay (<serdar@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.
+#
+
+
+class Chef
+  module Deprecation
+    module Provider
+
+      # == Deprecation::Provider::File
+      # This module contains the deprecated functions of
+      # Chef::Provider::File. These functions are refactored to different
+      # components. They are frozen and will be removed in Chef 12.
+      #
+      module File
+
+        def diff_current_from_content(new_content)
+          result = nil
+          Tempfile.open("chef-diff") do |file|
+            file.write new_content
+            file.close
+            result = diff_current file.path
+          end
+          result
+        end
+
+        def is_binary?(path)
+          ::File.open(path) do |file|
+
+            buff = file.read(Chef::Config[:diff_filesize_threshold])
+            buff = "" if buff.nil?
+            return buff !~ /^[\r[:print:]]*$/
+          end
+        end
+
+        def diff_current(temp_path)
+          suppress_resource_reporting = false
+
+          return [ "(diff output suppressed by config)" ] if Chef::Config[:diff_disabled]
+          return [ "(no temp file with new content, diff output suppressed)" ] unless ::File.exists?(temp_path)  # should never happen?
+
+          # solaris does not support diff -N, so create tempfile to diff against if we are creating a new file
+          target_path = if ::File.exists?(@current_resource.path)
+                          @current_resource.path
+                        else
+                          suppress_resource_reporting = true  # suppress big diffs going to resource reporting service
+                          tempfile = Tempfile.new('chef-tempfile')
+                          tempfile.path
+                        end
+
+          diff_filesize_threshold = Chef::Config[:diff_filesize_threshold]
+          diff_output_threshold = Chef::Config[:diff_output_threshold]
+
+          if ::File.size(target_path) > diff_filesize_threshold || ::File.size(temp_path) > diff_filesize_threshold
+            return [ "(file sizes exceed #{diff_filesize_threshold} bytes, diff output suppressed)" ]
+          end
+
+          # MacOSX(BSD?) diff will *sometimes* happily spit out nasty binary diffs
+          return [ "(current file is binary, diff output suppressed)"] if is_binary?(target_path)
+          return [ "(new content is binary, diff output suppressed)"] if is_binary?(temp_path)
+
+          begin
+            # -u: Unified diff format
+            result = shell_out("diff -u #{target_path} #{temp_path}" )
+          rescue Exception => e
+            # Should *not* receive this, but in some circumstances it seems that
+            # an exception can be thrown even using shell_out instead of shell_out!
+            return [ "Could not determine diff. Error: #{e.message}" ]
+          end
+
+          # diff will set a non-zero return code even when there's
+          # valid stdout results, if it encounters something unexpected
+          # So as long as we have output, we'll show it.
+          if not result.stdout.empty?
+            if result.stdout.length > diff_output_threshold
+              [ "(long diff of over #{diff_output_threshold} characters, diff output suppressed)" ]
+            else
+              val = result.stdout.split("\n")
+              val.delete("\")
+              @new_resource.diff(val.join("\\n")) unless suppress_resource_reporting
+              val
+            end
+          elsif not result.stderr.empty?
+            [ "Could not determine diff. Error: #{result.stderr}" ]
+          else
+            [ "(no diff)" ]
+          end
+        end
+
+        def setup_acl
+          return if Chef::Platform.windows?
+          acl_scanner = ScanAccessControl.new(@new_resource, @current_resource)
+          acl_scanner.set_all!
+        end
+
+        def compare_content
+          checksum(@current_resource.path) == new_resource_content_checksum
+        end
+
+        def set_content
+          unless compare_content
+            description = []
+            description << "update content in file #{@new_resource.path} from #{short_cksum(@current_resource.checksum)} to #{short_cksum(new_resource_content_checksum)}"
+            description << diff_current_from_content(@new_resource.content)
+            converge_by(description) do
+              backup @new_resource.path if ::File.exists?(@new_resource.path)
+              ::File.open(@new_resource.path, "w") {|f| f.write @new_resource.content }
+              Chef::Log.info("#{@new_resource} contents updated")
+            end
+          end
+        end
+
+        def update_new_file_state(path=@new_resource.path)
+          if !::File.directory?(path)
+            @new_resource.checksum(checksum(path))
+          end
+
+          if Chef::Platform.windows?
+            # TODO: To work around CHEF-3554, add support for Windows
+            # equivalent, or implicit resource reporting won't work for
+            # Windows.
+            return
+          end
+
+          acl_scanner = ScanAccessControl.new(@new_resource, @new_resource)
+          acl_scanner.set_all!
+        end
+
+        def set_all_access_controls
+          if access_controls.requires_changes?
+            converge_by(access_controls.describe_changes) do
+              access_controls.set_all
+              #Update file state with new access values
+              update_new_file_state
+            end
+          end
+        end
+
+        def deploy_tempfile
+          Tempfile.open(::File.basename(@new_resource.name)) do |tempfile|
+            yield tempfile
+
+            temp_res = Chef::Resource::CookbookFile.new(@new_resource.name)
+            temp_res.path(tempfile.path)
+            ac = Chef::FileAccessControl.new(temp_res, @new_resource, self)
+            ac.set_all!
+            FileUtils.mv(tempfile.path, @new_resource.path)
+          end
+        end
+
+        def backup(file=nil)
+          file ||= @new_resource.path
+          if @new_resource.backup != false && @new_resource.backup > 0 && ::File.exist?(file)
+            time = Time.now
+            savetime = time.strftime("%Y%m%d%H%M%S")
+            backup_filename = "#{@new_resource.path}.chef-#{savetime}"
+            backup_filename = backup_filename.sub(/^([A-Za-z]:)/, "") #strip drive letter on Windows
+            # if :file_backup_path is nil, we fallback to the old behavior of
+            # keeping the backup in the same directory. We also need to to_s it
+            # so we don't get a type error around implicit to_str conversions.
+            prefix = Chef::Config[:file_backup_path].to_s
+            backup_path = ::File.join(prefix, backup_filename)
+            FileUtils.mkdir_p(::File.dirname(backup_path)) if Chef::Config[:file_backup_path]
+            FileUtils.cp(file, backup_path, :preserve => true)
+            Chef::Log.info("#{@new_resource} backed up to #{backup_path}")
+
+            # Clean up after the number of backups
+            slice_number = @new_resource.backup
+            backup_files = Dir[::File.join(prefix, ".#{@new_resource.path}.chef-*")].sort { |a,b| b <=> a }
+            if backup_files.length >= @new_resource.backup
+              remainder = backup_files.slice(slice_number..-1)
+              remainder.each do |backup_to_delete|
+                FileUtils.rm(backup_to_delete)
+                Chef::Log.info("#{@new_resource} removed backup at #{backup_to_delete}")
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end