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

data/lib/chef/{mixin/check_helper.rb → platform/query_helpers.rb}

@@ -6,26 +6,37 @@
 # 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 Mixin
-    module CheckHelper      
-      def set_if_args(thing, arguments)
-        raise ArgumentError, "Must call set_if_args with a block!" unless Kernel.block_given?
-        if arguments != nil
-          yield(arguments)
+  class Platform
+
+    class << self
+      def windows?
+        if RUBY_PLATFORM =~ /mswin|mingw|windows/
+          true
         else
-          thing
+          false
         end
       end
+
+      def windows_server_2003?
+        return false unless windows?
+
+        require 'ruby-wmi'
+
+        host = WMI::Win32_OperatingSystem.find(:first)
+        (host.version && host.version.start_with?("5.2"))
+      end
     end
+
   end
 end

data/lib/chef/provider.rb

@@ -19,14 +19,13 @@
 
 require 'chef/mixin/from_file'
 require 'chef/mixin/convert_to_class_name'
-require 'chef/mixin/recipe_definition_dsl_core'
+require 'chef/dsl/recipe'
 require 'chef/mixin/enforce_ownership_and_permissions'
 require 'chef/mixin/why_run'
 class Chef
   class Provider
-    include Chef::Mixin::RecipeDefinitionDSLCore
+    include Chef::DSL::Recipe
     include Chef::Mixin::WhyRun
-    include Chef::Mixin::EnforceOwnershipAndPermissions
 
     attr_accessor :new_resource
     attr_accessor :current_resource
@@ -104,7 +103,7 @@ class Chef
       define_resource_requirements
       process_resource_requirements
 
-      # user-defined providers including LWRPs may 
+      # user-defined providers including LWRPs may
       # not include whyrun support - if they don't support it
       # we can't execute any actions while we're running in
       # whyrun mode. Instead we 'fake' whyrun by documenting that
@@ -129,12 +128,16 @@ class Chef
       requirements.run(@action)
     end
 
+    def resource_updated?
+      !converge_actions.empty? || @new_resource.updated_by_last_action?
+    end
+
     def set_updated_status
-      if converge_actions.empty? && !@new_resource.updated_by_last_action?
+      if !resource_updated?
         events.resource_up_to_date(@new_resource, @action)
       else
         events.resource_updated(@new_resource, @action)
-        new_resource.updated_by_last_action(true) 
+        new_resource.updated_by_last_action(true)
       end
     end
 
@@ -142,17 +145,16 @@ class Chef
       @requirements ||= ResourceRequirements.new(@new_resource, run_context)
     end
 
+    def converge_by(descriptions, &block)
+      converge_actions.add_action(descriptions, &block)
+    end
+
     protected
 
     def converge_actions
       @converge_actions ||= ConvergeActions.new(@new_resource, run_context, @action)
     end
 
-    def converge_by(descriptions, &block)
-      converge_actions.add_action(descriptions, &block)
-    end
-
-
     def recipe_eval(&block)
       # This block has new resource definitions within it, which
       # essentially makes it an in-line Chef run. Save our current
@@ -163,7 +165,7 @@ class Chef
       # this block cannot interact with resources outside, e.g.,
       # manipulating notifies.
 
-      converge_by ("would evaluate block and run any associated actions") do
+      converge_by ("evaluate block and run any associated actions") do
         saved_run_context = @run_context
         @run_context = @run_context.dup
         @run_context.resource_collection = Chef::ResourceCollection.new
@@ -173,51 +175,5 @@ class Chef
       end
     end
 
-    public
-
-    class << self
-      include Chef::Mixin::ConvertToClassName
-
-      def build_from_file(cookbook_name, filename, run_context)
-        pname = filename_to_qualified_string(cookbook_name, filename)
-
-        # Add log entry if we override an existing light-weight provider.
-        class_name = convert_to_class_name(pname)
-        overriding = Chef::Provider.const_defined?(class_name)
-        Chef::Log.info("#{class_name} light-weight provider already initialized -- overriding!") if overriding
-
-        new_provider_class = Class.new self do |cls|
-
-          include Chef::Mixin::RecipeDefinitionDSLCore
-
-          def load_current_resource
-            # silence Chef::Exceptions::Override exception
-          end
-
-          class << cls
-            include Chef::Mixin::FromFile
-
-            # setup DSL's shortcut methods
-            def action(name, &block)
-              define_method("action_#{name.to_s}") do
-                instance_eval(&block)
-              end
-            end
-          end
-
-          # load provider definition from file
-          cls.class_from_file(filename)
-        end
-
-        # register new class as a Chef::Provider
-        pname = filename_to_qualified_string(cookbook_name, filename)
-        class_name = convert_to_class_name(pname)
-        Chef::Provider.const_set(class_name, new_provider_class)
-        Chef::Log.debug("Loaded contents of #{filename} into a provider named #{pname} defined in Chef::Provider::#{class_name}")
-
-        new_provider_class
-      end
-    end
-
   end
 end

data/lib/chef/provider/batch.rb

@@ -0,0 +1,35 @@
+#
+# Author:: Adam Edwards (<adamed@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/provider/windows_script'
+
+class Chef
+  class Provider
+    class Batch < Chef::Provider::WindowsScript
+
+      def initialize (new_resource, run_context)
+        super(new_resource, run_context, '.bat')
+      end
+
+      def flags
+        @new_resource.flags.nil? ? '/c' : new_resource.flags + ' /c'
+      end
+        
+    end
+  end
+end

data/lib/chef/provider/breakpoint.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.
@@ -19,18 +19,18 @@
 class Chef
   class Provider
     class Breakpoint < Chef::Provider
-      
+
       def load_current_resource
       end
-      
+
       def action_break
-        if defined?(Shef) && Shef.running?
+        if defined?(Shell) && Shell.running?
           run_context.resource_collection.iterator.pause
           @new_resource.updated_by_last_action(true)
           run_context.resource_collection.iterator
         end
       end
-      
+
     end
   end
 end

data/lib/chef/provider/cookbook_file.rb

@@ -16,15 +16,21 @@
 # limitations under the License.
 #
 
-require 'chef/file_access_control'
 require 'chef/provider/file'
-require 'tempfile'
+require 'chef/deprecation/provider/cookbook_file'
+require 'chef/deprecation/warnings'
 
 class Chef
   class Provider
     class CookbookFile < Chef::Provider::File
-      def whyrun_supported?
-        true
+
+      extend Chef::Deprecation::Warnings
+      include Chef::Deprecation::Provider::CookbookFile
+      add_deprecation_warnings_for(Chef::Deprecation::Provider::CookbookFile.instance_methods)
+
+      def initialize(new_resource, run_context)
+        @content_class = Chef::Provider::CookbookFile::Content
+        super
       end
 
       def load_current_resource
@@ -32,82 +38,7 @@ class Chef
         super
       end
 
-      def action_create
-        if file_cache_location && content_stale?
-          description = []
-          description << "create a new cookbook_file #{@new_resource.path}"
-          description << diff_current(file_cache_location)
-          converge_by(description) do
-            Chef::Log.debug("#{@new_resource} has new contents")
-            backup_new_resource
-            deploy_tempfile do |tempfile|
-              Chef::Log.debug("#{@new_resource} staging #{file_cache_location} to #{tempfile.path}")
-              tempfile.close
-              FileUtils.cp(file_cache_location, tempfile.path)
-              enforce_tempfile_inheritance(tempfile.path)
-            end
-            Chef::Log.info("#{@new_resource} created file #{@new_resource.path}")
-          end
-        else
-          set_all_access_controls
-        end
-      end
-
-      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
-
-      # Determine the cookbook to get the file from. If new resource sets an
-      # explicit cookbook, use it, otherwise fall back to the implicit cookbook
-      # i.e., the cookbook the resource was declared in.
-      def resource_cookbook
-        @new_resource.cookbook || @new_resource.cookbook_name
-      end
-
-      def backup_new_resource
-        if ::File.exists?(@new_resource.path)
-          backup @new_resource.path
-        end
-      end
-
-      def content_stale?
-        ( ! ::File.exist?(@new_resource.path)) || ( ! compare_content)
-      end
-
-      protected
-
-      def enforce_tempfile_inheritance(tempfile_path)
-        # On the Windows platform, files in the temp directory
-        # default to not inherit unless the new resource specifies rights of
-        # some sort. Here we ensure that even when no rights are
-        # specified, the dacl's inheritance flag is set.
-        if Chef::Platform.windows? &&
-            @new_resource.rights.nil? &&
-            @new_resource.group.nil? &&
-            @new_resource.owner.nil? &&
-            @new_resource.deny_rights.nil?
-
-          securable_tempfile = Chef::ReservedNames::Win32::Security::SecurableObject.new(tempfile_path)
-
-          # No rights were specified, so the dacl will have no explicit aces
-          default_dacl = Chef::ReservedNames::Win32::Security::ACL.create([])
-
-          # In setting this default dacl, set inheritance to true
-          securable_tempfile.set_dacl(default_dacl, true)
-        end
-      end
-
-      private
-
-      def managing_content?
-        return true if @new_resource.checksum
-        return true if !@new_resource.source.nil? && @action != :create_if_missing
-        false
-      end
-
     end
   end
 end
+

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

@@ -0,0 +1,49 @@
+#
+# 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 CookbookFile
+      class Content < Chef::FileContentManagement::ContentBase
+
+        private
+
+        def file_for_provider
+          cookbook = run_context.cookbook_collection[resource_cookbook]
+          file_cache_location = cookbook.preferred_filename_on_disk_location(run_context.node, :files, @new_resource.source, @new_resource.path)
+          if file_cache_location.nil?
+            nil
+          else
+            tempfile = Chef::FileContentManagement::Tempfile.new(@new_resource).tempfile
+            tempfile.close
+            Chef::Log.debug("#{@new_resource} staging #{file_cache_location} to #{tempfile.path}")
+            FileUtils.cp(file_cache_location, tempfile.path)
+            tempfile
+          end
+        end
+
+        def resource_cookbook
+          @new_resource.cookbook || @new_resource.cookbook_name
+        end
+      end
+    end
+  end
+end

data/lib/chef/provider/deploy.rb

@@ -21,12 +21,13 @@ require "chef/mixin/from_file"
 require "chef/monkey_patches/fileutils"
 require "chef/provider/git"
 require "chef/provider/subversion"
+require 'chef/dsl/recipe'
 
 class Chef
   class Provider
     class Deploy < Chef::Provider
 
-      include Chef::Mixin::RecipeDefinitionDSLCore
+      include Chef::DSL::Recipe
       include Chef::Mixin::FromFile
       include Chef::Mixin::Command
 
@@ -35,8 +36,8 @@ class Chef
       def initialize(new_resource, run_context)
         super(new_resource, run_context)
 
-        # will resolve to ither git or svn based on resource attributes , 
-        # and will create a resource corresponding to that provider 
+        # will resolve to either git or svn based on resource attributes,
+        # and will create a resource corresponding to that provider
         @scm_provider = new_resource.scm_provider.new(new_resource, run_context)
 
         # @configuration is not used by Deploy, it is only for backwards compat with
@@ -76,11 +77,11 @@ class Chef
           #There is no reason to assume 2 deployments in a single chef run, hence fails in whyrun.
         end
 
-        [ @new_resource.before_migrate, @new_resource.before_symlink, 
+        [ @new_resource.before_migrate, @new_resource.before_symlink,
           @new_resource.before_restart, @new_resource.after_restart ].each do |script|
           requirements.assert(:deploy, :force_deploy) do |a|
             callback_file = "#{release_path}/#{script}"
-            a.assertion do 
+            a.assertion do
               if script && script.class == String
                 ::File.exist?(callback_file)
               else
@@ -97,7 +98,7 @@ class Chef
       def action_deploy
         save_release_state
         if deployed?(release_path )
-          if current_release?(release_path ) 
+          if current_release?(release_path )
             Chef::Log.debug("#{@new_resource} is the latest version")
           else
             rollback_to release_path
@@ -112,7 +113,7 @@ class Chef
 
       def action_force_deploy
         if deployed?(release_path)
-          converge_by("delete deployed app at #{release_path} prior to force-deploy") do 
+          converge_by("delete deployed app at #{release_path} prior to force-deploy") do
             Chef::Log.info("Already deployed app at #{release_path}, forcing.")
             FileUtils.rm_rf(release_path)
             Chef::Log.info("#{@new_resource} forcing deploy of already deployed app at #{release_path}")
@@ -227,6 +228,10 @@ class Chef
       end
 
       def cleanup!
+        converge_by("update release history data") do
+          release_created(release_path)
+        end
+
         chop = -1 - @new_resource.keep_releases
         all_releases[0..chop].each do |old_release|
           converge_by("remove old release #{old_release}") do
@@ -262,10 +267,10 @@ class Chef
       def copy_cached_repo
         target_dir_path = @new_resource.deploy_to + "/releases"
         converge_by("deploy from repo to #{@target_dir_path} ") do
+          FileUtils.rm_rf(release_path) if ::File.exist?(release_path)
           FileUtils.mkdir_p(target_dir_path)
           FileUtils.cp_r(::File.join(@new_resource.destination, "."), release_path, :preserve => true)
           Chef::Log.info "#{@new_resource} copied the cached checkout to #{release_path}"
-          release_created(release_path)
         end
       end
 
@@ -283,14 +288,14 @@ class Chef
       end
 
       def link_current_release_to_production
-        converge_by(["remove existing link at #{@new_resource.current_path}", 
+        converge_by(["remove existing link at #{@new_resource.current_path}",
                     "link release #{release_path} into production at #{@new_resource.current_path}"]) do
           FileUtils.rm_f(@new_resource.current_path)
           begin
             FileUtils.ln_sf(release_path, @new_resource.current_path)
-            rescue => e
-              raise Chef::Exceptions::FileNotFound.new("Cannot symlink current release to production: #{e.message}")
-            end
+          rescue => e
+            raise Chef::Exceptions::FileNotFound.new("Cannot symlink current release to production: #{e.message}")
+          end
           Chef::Log.info "#{@new_resource} linked release #{release_path} into production at #{@new_resource.current_path}"
         end
         enforce_ownership
@@ -298,7 +303,7 @@ class Chef
 
       def run_symlinks_before_migrate
         links_info = @new_resource.symlink_before_migrate.map { |src, dst| "#{src} => #{dst}" }.join(", ")
-        converge_by("make pre-migration symliinks: #{links_info}") do
+        converge_by("make pre-migration symlinks: #{links_info}") do
           @new_resource.symlink_before_migrate.each do |src, dest|
             begin
               FileUtils.ln_sf(@new_resource.shared_path + "/#{src}", release_path + "/#{dest}")
@@ -312,7 +317,7 @@ class Chef
 
       def link_tempfiles_to_current_release
         dirs_info = @new_resource.create_dirs_before_symlink.join(",")
-        @new_resource.create_dirs_before_symlink.each do |dir| 
+        @new_resource.create_dirs_before_symlink.each do |dir|
           create_dir_unless_exists(release_path + "/#{dir}")
         end
         Chef::Log.info("#{@new_resource} created directories before symlinking: #{dirs_info}")
@@ -347,15 +352,15 @@ class Chef
 
       # Internal callback, called after copy_cached_repo.
       # Override if you need to keep state externally.
-      # Note that YOU are responsible for implementing whyrun-friendly behavior 
-      # in any actions you take in this callback. 
+      # Note that YOU are responsible for implementing whyrun-friendly behavior
+      # in any actions you take in this callback.
       def release_created(release_path)
       end
 
       # Note that YOU are responsible for using appropriate whyrun nomenclature
       # Override if you need to keep state externally.
-      # Note that YOU are responsible for implementing whyrun-friendly behavior 
-      # in any actions you take in this callback. 
+      # Note that YOU are responsible for implementing whyrun-friendly behavior
+      # in any actions you take in this callback.
       def release_deleted(release_path)
       end
 
@@ -438,9 +443,9 @@ class Chef
         yield
       rescue ::Exception => e
         if @new_resource.rollback_on_error
-          Chef::Log.warn "Error on deploying #{release_path}: #{e.message}" 
+          Chef::Log.warn "Error on deploying #{release_path}: #{e.message}"
           failed_release = release_path
-        
+
           if previous_release_path
             @release_path = previous_release_path
             rollback
@@ -451,7 +456,7 @@ class Chef
           end
           release_deleted(failed_release)
         end
-        
+
         raise
       end