chef 11.4.4 → 11.6.0.hotfix.1

data/lib/chef/provider/powershell_script.rb

@@ -0,0 +1,77 @@
+#
+# 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 PowershellScript < Chef::Provider::WindowsScript
+
+      protected
+      
+      EXIT_STATUS_NORMALIZATION_SCRIPT = "\nif ($? -eq $true) {exit 0} elseif ( $LASTEXITCODE -ne 0) {exit $LASTEXITCODE} else { exit 1 }"
+      EXIT_STATUS_RESET_SCRIPT = "$LASTEXITCODE=0\n"
+
+      # Process exit codes are strange with PowerShell. Unless you
+      # explicitly call exit in Powershell, the powershell.exe
+      # interpreter returns only 0 for success or 1 for failure. Since
+      # we'd like to get specific exit codes from executable tools run
+      # with Powershell, we do some work using the automatic variables
+      # $? and $LASTEXITCODE to return the process exit code of the
+      # last process run in the script if it is the last command
+      # executed, otherwise 0 or 1 based on whether $? is set to true
+      # (success, where we return 0) or false (where we return 1).
+      def NormalizeScriptExitStatus( code )
+        @code = (! code.nil?) ? ( EXIT_STATUS_RESET_SCRIPT + code + EXIT_STATUS_NORMALIZATION_SCRIPT ) : nil
+      end
+
+      public
+      
+      def initialize (new_resource, run_context)
+        super(new_resource, run_context, '.ps1')
+        NormalizeScriptExitStatus(new_resource.code)
+      end
+      
+      def flags
+        default_flags = [
+          "-NoLogo",
+          "-NonInteractive",
+          "-NoProfile",
+          "-ExecutionPolicy RemoteSigned",
+          # Powershell will hang if STDIN is redirected
+          # http://connect.microsoft.com/PowerShell/feedback/details/572313/powershell-exe-can-hang-if-stdin-is-redirected
+          "-InputFormat None",
+          # Must use -File rather than -Command to launch the script
+          # file created by the base class that contains the script
+          # code -- otherwise, powershell.exe does not propagate the
+          # error status of a failed Windows process that ran at the
+          # end of the script, it gets changed to '1'.                         
+          "-File"                         
+        ]
+
+        interpreter_flags = default_flags.join(' ')
+
+        if ! (@new_resource.flags.nil?)
+          interpreter_flags = [@new_resource.flags, interpreter_flags].join(' ')
+        end
+
+        interpreter_flags
+      end
+    end
+  end
+end

data/lib/chef/provider/remote_directory.rb

@@ -31,7 +31,6 @@ class Chef
   class Provider
     class RemoteDirectory < Chef::Provider::Directory
 
-      include Chef::Mixin::EnforceOwnershipAndPermissions
       include Chef::Mixin::FileClass
 
       def action_create
@@ -67,7 +66,7 @@ class Chef
         if @new_resource.purge
           unmanaged_files.sort.reverse.each do |f|
             # file_class comes from Chef::Mixin::FileClass
-            if ::File.directory?(f) && !Chef::Platform.windows? && !file_class.symlink?(f.dup) 
+            if ::File.directory?(f) && !Chef::Platform.windows? && !file_class.symlink?(f.dup)
               # Linux treats directory symlinks as files
               # Remove a directory as a directory when not on windows if it is not a symlink
               purge_directory(f)
@@ -134,10 +133,10 @@ class Chef
             cookbook_file.rights(permission, *args)
           end
         end
-        cookbook_file.mode(@new_resource.files_mode)    if @new_resource.files_mode
-        cookbook_file.group(@new_resource.files_group)  if @new_resource.files_group
-        cookbook_file.owner(@new_resource.files_owner)  if @new_resource.files_owner
-        cookbook_file.backup(@new_resource.files_backup) if @new_resource.files_backup
+        cookbook_file.mode(@new_resource.files_mode)       if @new_resource.files_mode
+        cookbook_file.group(@new_resource.files_group)     if @new_resource.files_group
+        cookbook_file.owner(@new_resource.files_owner)     if @new_resource.files_owner
+        cookbook_file.backup(@new_resource.files_backup)   if @new_resource.files_backup
 
         cookbook_file
       end

data/lib/chef/provider/remote_file.rb

@@ -1,4 +1,5 @@
 #
+# Author:: Jesse Campbell (<hikeit@gmail.com>)
 # Author:: Adam Jacob (<adam@opscode.com>)
 # Copyright:: Copyright (c) 2008 Opscode, Inc.
 # License:: Apache License, Version 2.0
@@ -17,125 +18,28 @@
 #
 
 require 'chef/provider/file'
-require 'chef/rest'
-require 'uri'
-require 'tempfile'
-require 'net/https'
+require 'chef/deprecation/provider/remote_file'
+require 'chef/deprecation/warnings'
 
 class Chef
   class Provider
     class RemoteFile < Chef::Provider::File
 
-      include Chef::Mixin::EnforceOwnershipAndPermissions
+      extend Chef::Deprecation::Warnings
+      include Chef::Deprecation::Provider::RemoteFile
+      add_deprecation_warnings_for(Chef::Deprecation::Provider::RemoteFile.instance_methods)
 
-      def load_current_resource
-        @current_resource = Chef::Resource::RemoteFile.new(@new_resource.name)
+      def initialize(new_resource, run_context)
+        @content_class = Chef::Provider::RemoteFile::Content
         super
       end
 
-      def action_create
-        Chef::Log.debug("#{@new_resource} checking for changes")
-
-        if current_resource_matches_target_checksum?
-          Chef::Log.debug("#{@new_resource} checksum matches target checksum (#{@new_resource.checksum}) - not updating")
-        else
-          sources = @new_resource.source
-          source = sources.shift
-          begin
-            rest = Chef::REST.new(source, nil, nil, http_client_opts(source))
-            raw_file = rest.streaming_request(rest.create_url(source), {})
-          rescue SocketError, Errno::ECONNREFUSED, Timeout::Error, Net::HTTPFatalError => e
-            Chef::Log.debug("#{@new_resource} cannot be downloaded from #{source}")
-            if source = sources.shift
-              Chef::Log.debug("#{@new_resource} trying to download from another mirror")
-              retry
-            else
-              raise e
-            end
-          end
-          if matches_current_checksum?(raw_file)
-            Chef::Log.debug "#{@new_resource} target and source checksums are the same - not updating"
-          else
-            description = [] 
-            description << "copy file downloaded from #{@new_resource.source} into #{@new_resource.path}"
-            description << diff_current(raw_file.path)
-            converge_by(description) do
-              backup_new_resource
-              FileUtils.cp raw_file.path, @new_resource.path
-              Chef::Log.info "#{@new_resource} updated"
-              raw_file.close!
-            end
-            # whyrun mode cleanup - the temp file will never be used,
-            # so close/unlink it here. 
-            if whyrun_mode?
-              raw_file.close!
-            end
-          end
-        end
-        set_all_access_controls
-        update_new_file_state
-      end
-
-      def current_resource_matches_target_checksum?
-        @new_resource.checksum && @current_resource.checksum && @current_resource.checksum =~ /^#{Regexp.escape(@new_resource.checksum)}/
-      end
-
-      def matches_current_checksum?(candidate_file)
-        Chef::Log.debug "#{@new_resource} checking for file existence of #{@new_resource.path}"
-        if ::File.exists?(@new_resource.path)
-          Chef::Log.debug "#{@new_resource} file exists at #{@new_resource.path}"
-          @new_resource.checksum(checksum(candidate_file.path))
-          Chef::Log.debug "#{@new_resource} target checksum: #{@current_resource.checksum}"
-          Chef::Log.debug "#{@new_resource} source checksum: #{@new_resource.checksum}"
-
-          @new_resource.checksum == @current_resource.checksum
-        else
-          Chef::Log.debug "#{@new_resource} creating #{@new_resource.path}"
-          false
-        end
-      end
-
-      def backup_new_resource
-        if ::File.exists?(@new_resource.path)
-          Chef::Log.debug "#{@new_resource} checksum changed from #{@current_resource.checksum} to #{@new_resource.checksum}"
-          backup @new_resource.path
-        end
-      end
-
-      def source_file(source, current_checksum, &block)
-        if absolute_uri?(source)
-          fetch_from_uri(source, &block)
-        elsif !Chef::Config[:solo]
-          fetch_from_chef_server(source, current_checksum, &block)
-        else
-          fetch_from_local_cookbook(source, &block)
-        end
-      end
-
-      def http_client_opts(source)
-        opts={}
-        # CHEF-3140
-        # 1. If it's already compressed, trying to compress it more will
-        # probably be counter-productive.
-        # 2. Some servers are misconfigured so that you GET $URL/file.tgz but
-        # they respond with content type of tar and content encoding of gzip,
-        # which tricks Chef::REST into decompressing the response body. In this
-        # case you'd end up with a tar archive (no gzip) named, e.g., foo.tgz,
-        # which is not what you wanted.
-        if @new_resource.path =~ /gz$/ or source =~ /gz$/
-          opts[:disable_gzip] = true
-        end
-        opts
-      end
-
-      private
-
-      def absolute_uri?(source)
-        URI.parse(source).absolute?
-      rescue URI::InvalidURIError
-        false
+      def load_current_resource
+        @current_resource = Chef::Resource::RemoteFile.new(@new_resource.name)
+        super
       end
 
     end
   end
 end
+

data/lib/chef/provider/remote_file/cache_control_data.rb

@@ -0,0 +1,165 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Author:: Jesse Campbell (<hikeit@gmail.com>)
+# Author:: Lamont Granquist (<lamont@opscode.com>)
+# Copyright:: Copyright (c) 2013 Jesse Campbell
+# 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 'stringio'
+require 'chef/file_cache'
+require 'chef/json_compat'
+require 'chef/digester'
+require 'chef/exceptions'
+
+class Chef
+  class Provider
+    class RemoteFile
+
+      # == CacheControlData
+      # Implements per-uri storage of cache control data for a remote resource
+      # along with a sanity check checksum of the file in question.
+      # Provider::RemoteFile protocol implementation classes can use this
+      # information to avoid re-fetching files when the current copy is up to
+      # date. The way this information is used is protocol-dependent. For HTTP,
+      # this information is sent to the origin server via headers to make a
+      # conditional GET request.
+      #
+      # == API
+      # The general shape of the API is active-record-the-pattern-like. New
+      # instances should be instantiated via
+      # `CacheControlData.load_and_validate`, which will do a find-or-create
+      # operation and then sanity check the data against the checksum of the
+      # current copy of the file. If there is no data or the sanity check
+      # fails, the `etag` and `mtime` attributes will be set to nil; otherwise
+      # they are populated with the previously saved values.
+      #
+      # After fetching a file, the CacheControlData instance should be updated
+      # with new etag, mtime and checksum values in whatever format is
+      # preferred by the protocol used. Then call #save to save the data to disk.
+      class CacheControlData
+
+        def self.load_and_validate(uri, current_copy_checksum)
+          ccdata = new(uri)
+          ccdata.load
+          ccdata.validate!(current_copy_checksum)
+          ccdata
+        end
+
+        # Entity Tag of the resource. HTTP-specific. See also:
+        # http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.3.2
+        # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.19
+        attr_accessor :etag
+
+        # Last modified time of the remote resource. Different protocols will
+        # use different types for this field (e.g., string representation of a
+        # specific date format, integer, etc.) For HTTP-specific references,
+        # see:
+        # * http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3
+        # * http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.3.1
+        # * http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.25
+        attr_accessor :mtime
+
+        # SHA2-256 Hash of the file as last fetched.
+        attr_accessor :checksum
+
+        # URI of the resource as a String. This is the "primary key" used for
+        # storage and retrieval.
+        attr_reader :uri
+
+        def initialize(uri)
+          uri = uri.dup
+          uri.password = "XXXX" unless uri.userinfo.nil?
+          @uri = uri.to_s
+        end
+
+        def load
+          if previous_cc_data = load_data
+            apply(previous_cc_data)
+            self
+          else
+            false
+          end
+        end
+
+        def validate!(current_copy_checksum)
+          if current_copy_checksum.nil? or checksum != current_copy_checksum
+            reset!
+            false
+          else
+            true
+          end
+        end
+
+        # Saves the data to disk using Chef::FileCache. The filename is a
+        # sanitized version of the URI with a MD5 of the same URI appended (to
+        # avoid collisions between different URIs having the same sanitized
+        # form).
+        def save
+          Chef::FileCache.store("remote_file/#{sanitized_cache_file_basename}", json_data)
+        end
+
+        # :nodoc:
+        # JSON representation of this object for storage.
+        def json_data
+          Chef::JSONCompat.to_json(hash_data)
+        end
+
+        private
+
+        def hash_data
+          as_hash = {}
+          as_hash["etag"]     = etag
+          as_hash["mtime"]    = mtime
+          as_hash["checksum"] = checksum
+          as_hash
+        end
+
+        def reset!
+          @etag, @mtime = nil, nil
+        end
+
+        def apply(previous_cc_data)
+          @etag = previous_cc_data["etag"]
+          @mtime = previous_cc_data["mtime"]
+          @checksum = previous_cc_data["checksum"]
+        end
+
+        def load_data
+          Chef::JSONCompat.from_json(load_json_data)
+        rescue Chef::Exceptions::FileNotFound, Yajl::ParseError
+          false
+        end
+
+        def load_json_data
+          Chef::FileCache.load("remote_file/#{sanitized_cache_file_basename}")
+        end
+
+        def sanitized_cache_file_basename
+          # Scrub and truncate in accordance with the goals of keeping the name
+          # human-readable but within the bounds of local file system
+          # path length limits
+          scrubbed_uri = uri.gsub(/\W/, '_')[0..63]
+          uri_md5 = Chef::Digester.instance.generate_md5_checksum(StringIO.new(uri))
+          "#{scrubbed_uri}-#{uri_md5}.json"
+        end
+
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,75 @@
+#
+# Author:: Jesse Campbell (<hikeit@gmail.com>)
+# 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 'rest_client'
+require 'uri'
+require 'tempfile'
+require 'chef/file_content_management/content_base'
+
+class Chef
+  class Provider
+    class RemoteFile
+      class Content < Chef::FileContentManagement::ContentBase
+
+        private
+
+        def file_for_provider
+          Chef::Log.debug("#{@new_resource} checking for changes")
+
+          if current_resource_matches_target_checksum?
+            Chef::Log.debug("#{@new_resource} checksum matches target checksum (#{@new_resource.checksum}) - not updating")
+          else
+            sources = @new_resource.source
+            raw_file = try_multiple_sources(sources)
+          end
+          raw_file
+        end
+
+        # Given an array of source uris, iterate through them until one does not fail
+        def try_multiple_sources(sources)
+          sources = sources.dup
+          source = sources.shift
+          begin
+            uri = URI.parse(source)
+            raw_file = grab_file_from_uri(uri)
+          rescue SocketError, Errno::ECONNREFUSED, Errno::ENOENT, Errno::EACCES, Timeout::Error, Net::HTTPFatalError, Net::FTPError => e
+            Chef::Log.warn("#{@new_resource} cannot be downloaded from #{source}: #{e.to_s}")
+            if source = sources.shift
+              Chef::Log.info("#{@new_resource} trying to download from another mirror")
+              retry
+            else
+              raise e
+            end
+          end
+          raw_file
+        end
+
+        # Given a source uri, return a Tempfile, or a File that acts like a Tempfile (close! method)
+        def grab_file_from_uri(uri)
+          Chef::Provider::RemoteFile::Fetcher.for_resource(uri, @new_resource, @current_resource).fetch
+        end
+
+        def current_resource_matches_target_checksum?
+          @new_resource.checksum && @current_resource.checksum && @current_resource.checksum =~ /^#{Regexp.escape(@new_resource.checksum)}/
+        end
+
+      end
+    end
+  end
+end