chef 13.12.14-universal-mingw32 → 14.0.190-universal-mingw32

data/lib/chef/powershell.rb

@@ -0,0 +1,55 @@
+#
+# Author:: Stuart Preston (<stuart@chef.io>)
+# Copyright:: Copyright 2018, Chef Software, 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/json_compat"
+require "win32ole" if RUBY_PLATFORM =~ /mswin|mingw32|windows/
+
+class Chef
+  class PowerShell
+
+    attr_reader :result
+    attr_reader :errors
+
+    # Run a command under PowerShell via a managed (.NET) COM interop API.
+    # This implementation requires the managed dll to be registered on the
+    # target machine.
+    #
+    # Requires: .NET Framework 4.0 or higher on the target machine.
+    #
+    # @param script [String] script to run
+    # @return [Object] output
+    def initialize(script)
+      raise "Chef::PowerShell can only be used on the Windows platform." unless RUBY_PLATFORM =~ /mswin|mingw32|windows/
+      exec(script)
+    end
+
+    def error?
+      return true if errors.count > 0
+      false
+    end
+
+    private
+
+    def exec(script)
+      ps = WIN32OLE.new("Chef.PowerShell")
+      outcome = ps.ExecuteScript(script)
+      hashed_outcome = Chef::JSONCompat.parse(outcome)
+      @result = Chef::JSONCompat.parse(hashed_outcome["result"])
+      @errors = hashed_outcome["errors"]
+    end
+  end
+end

data/lib/chef/property.rb

@@ -359,31 +359,6 @@ class Chef
       else
         # We are getting the default value.
 
-        # If the user does something like this:
-        #
-        # ```
-        # class MyResource < Chef::Resource
-        #   property :content
-        #   action :create do
-        #     file '/x.txt' do
-        #       content content
-        #     end
-        #   end
-        # end
-        # ```
-        #
-        # It won't do what they expect. This checks whether you try to *read*
-        # `content` while we are compiling the resource.
-        if !nil_set &&
-            resource.respond_to?(:resource_initializing) &&
-            resource.resource_initializing &&
-            resource.respond_to?(:enclosing_provider) &&
-            resource.enclosing_provider &&
-            resource.enclosing_provider.new_resource &&
-            resource.enclosing_provider.new_resource.respond_to?(name)
-          Chef::Log.warn("#{Chef::Log.caller_location}: property #{name} is declared in both #{resource} and #{resource.enclosing_provider}. Use new_resource.#{name} instead. At #{Chef::Log.caller_location}")
-        end
-
         if has_default?
           # If we were able to cache the stored_default, grab it.
           if defined?(@stored_default)
@@ -392,7 +367,7 @@ class Chef
             # Otherwise, we have to validate it now.
             value = input_to_stored_value(resource, default, is_default: true)
           end
-          value = stored_value_to_output(resource, value, is_default: true)
+          value = stored_value_to_output(resource, value)
 
           # If the value is mutable (non-frozen), we set it on the instance
           # so that people can mutate it.  (All constant default values are
@@ -625,7 +600,9 @@ class Chef
     # @api private
     def explicitly_accepts_nil?(resource)
       options.has_key?(:coerce) ||
-        (options.has_key?(:is) && resource.send(:_pv_is, { name => nil }, name, options[:is], raise_error: false))
+        (options.has_key?(:is) && Chef::Mixin::ParamsValidate.send(:_pv_is, { name => nil }, name, options[:is]))
+    rescue Chef::Exceptions::ValidationFailed, Chef::Exceptions::CannotValidateStaticallyError
+      false
     end
 
     # @api private
@@ -701,25 +678,26 @@ class Chef
     end
 
     def input_to_stored_value(resource, value, is_default: false)
+      if value.nil? && !is_default && !explicitly_accepts_nil?(resource)
+        value = default
+      end
       unless value.is_a?(DelayedEvaluator)
-        value = coerce_and_validate(resource, value, is_default: is_default)
+        value = coerce_and_validate(resource, value)
       end
       value
     end
 
-    def stored_value_to_output(resource, value, is_default: false)
+    def stored_value_to_output(resource, value)
       # Crack open lazy values before giving the result to the user
       if value.is_a?(DelayedEvaluator)
         value = exec_in_resource(resource, value)
-        value = coerce_and_validate(resource, value, is_default: is_default)
+        value = coerce_and_validate(resource, value)
       end
       value
     end
 
-    # Coerces and validates the value. If the value is a default, it will warn
-    # the user that invalid defaults are bad mmkay, and return it as if it were
-    # valid.
-    def coerce_and_validate(resource, value, is_default: false)
+    # Coerces and validates the value.
+    def coerce_and_validate(resource, value)
       result = coerce(resource, value)
       validate(resource, result)
 

data/lib/chef/provider.rb

@@ -1,7 +1,7 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
 # Author:: Christopher Walters (<cw@chef.io>)
-# Copyright:: Copyright 2008-2016, 2009-2017, Chef Software Inc.
+# Copyright:: Copyright 2008-2016, 2009-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -38,7 +38,7 @@ class Chef
     attr_accessor :run_context
 
     attr_reader :recipe_name
-    attr_reader :cookbook_name
+    attr_reader :logger
 
     include Chef::Mixin::WhyRun
     extend Chef::Mixin::Provides
@@ -91,6 +91,12 @@ class Chef
       @run_context = run_context
       @converge_actions = nil
 
+      @logger = if run_context
+                  run_context.logger.with_child({ resource: new_resource.name, cookbook: cookbook_name, recipe: recipe_name })
+                else
+                  Chef::Log.with_child({ resource: new_resource.name, cookbook: cookbook_name, recipe: recipe_name })
+                end
+
       @recipe_name = nil
       @cookbook_name = nil
       self.class.include_resource_dsl_module(new_resource)
@@ -131,7 +137,7 @@ class Chef
     end
 
     def action_nothing
-      Chef::Log.debug("Doing nothing for #{@new_resource}")
+      logger.trace("Doing nothing for #{@new_resource}")
       true
     end
 
@@ -272,7 +278,7 @@ class Chef
                                                  end
                              end.join(", ")
                            end
-          Chef::Log.debug("Skipping update of #{new_resource}: has not changed any of the specified properties #{properties_str}.")
+          logger.debug("Skipping update of #{new_resource}: has not changed any of the specified properties #{properties_str}.")
           return false
         end
 
@@ -343,45 +349,16 @@ class Chef
           extend Forwardable
           define_singleton_method(:to_s) { "forwarder module for #{provider_class}" }
           define_singleton_method(:inspect) { to_s }
-          # Add a delegator for each explicit property that will get the *current* value
-          # of the property by default instead of the *actual* value.
-          resource.class.properties.each do |name, property|
-            class_eval(<<-EOM, __FILE__, __LINE__)
-              def #{name}(*args, &block)
-                # If no arguments were passed, we process "get" by defaulting
-                # the value to current_resource, not new_resource. This helps
-                # avoid issues where resources accidentally overwrite perfectly
-                # valid stuff with default values.
-                #
-                # This magic is to make this kind of thing easy:
-                #
-                # FileUtils.chown new_resource.mode.nil? ? current_resource.mode : new_resource.mode, new_resource.path
-                #
-                # We do this in the file provider where we need to construct a new filesystem object and
-                # when the new_resource is nil/default that means "preserve the current stuff" and does not
-                # mean to ignore it which will wind up defaulting to changing the file to have a "root"
-                # ownership if anything else changes.  Its kind of overly clever and magical, and most likely
-                # gets the use case wrong where someone has a property that they really mean to default to
-                # some value which /should/ get set if its left as the default and where the default is
-                # meant to be declarative.  Instead of property_is_set? we should most likely be using
-                # nil? but we're going to deprecate all of it anyway.  Just type out what you really mean longhand.
-                #
-                if args.empty? && !block
-                  if !new_resource.property_is_set?(__method__) && current_resource
-                    Chef.deprecated(:namespace_collisions, "rename #{name} to current_resource.#{name}")
-                    return current_resource.public_send(__method__)
-                  end
-                end
-                Chef.deprecated(:namespace_collisions, "rename #{name} to new_resource.#{name}")
-                new_resource.public_send(__method__, *args, &block)
-              end
-            EOM
-          end
+          # this magic, stated simply, is that any instance method declared directly on
+          # the resource we are building, will be accessible from the action_class(provider)
+          # instance.  methods declared on Chef::Resource and properties are not inherited.
           dsl_methods =
             resource.class.public_instance_methods +
             resource.class.protected_instance_methods -
             provider_class.instance_methods -
-            resource.class.properties.keys
+            resource.class.properties.keys -
+            resource.class.properties.keys.map { |k| "#{k}=".to_sym } -
+            Chef::Resource.instance_methods
           def_delegators(:new_resource, *dsl_methods)
         end
         include @included_resource_dsl_module

data/lib/chef/provider/apt_preference.rb

@@ -47,7 +47,7 @@ class Chef
 
         # cleanup any existing pref files w/o the sanitized name (created by old apt cookbook)
         if (sanitized_prefname != new_resource.package_name) && ::File.exist?("#{APT_PREFERENCE_DIR}/#{new_resource.package_name}.pref")
-          Chef::Log.warn "Replacing legacy #{new_resource.package_name}.pref with #{sanitized_prefname}.pref in #{APT_PREFERENCE_DIR}"
+          logger.warn "Replacing legacy #{new_resource.package_name}.pref with #{sanitized_prefname}.pref in #{APT_PREFERENCE_DIR}"
           declare_resource(:file, "#{APT_PREFERENCE_DIR}/#{new_resource.package_name}.pref") do
             action :delete
           end
@@ -55,7 +55,7 @@ class Chef
 
         # cleanup any existing pref files without the .pref extension (created by old apt cookbook)
         if ::File.exist?("#{APT_PREFERENCE_DIR}/#{new_resource.package_name}")
-          Chef::Log.warn "Replacing legacy #{new_resource.package_name} with #{sanitized_prefname}.pref in #{APT_PREFERENCE_DIR}"
+          logger.warn "Replacing legacy #{new_resource.package_name} with #{sanitized_prefname}.pref in #{APT_PREFERENCE_DIR}"
           declare_resource(:file, "#{APT_PREFERENCE_DIR}/#{new_resource.package_name}") do
             action :delete
           end
@@ -72,7 +72,7 @@ class Chef
         sanitized_prefname = safe_name(new_resource.package_name)
 
         if ::File.exist?("#{APT_PREFERENCE_DIR}/#{sanitized_prefname}.pref")
-          Chef::Log.info "Un-pinning #{sanitized_prefname} from #{APT_PREFERENCE_DIR}"
+          logger.info "Un-pinning #{sanitized_prefname} from #{APT_PREFERENCE_DIR}"
           declare_resource(:file, "#{APT_PREFERENCE_DIR}/#{sanitized_prefname}.pref") do
             action :delete
           end

data/lib/chef/provider/apt_repository.rb

@@ -29,14 +29,15 @@ class Chef
 
       provides :apt_repository, platform_family: "debian"
 
-      LIST_APT_KEYS = "apt-key list".freeze
       LIST_APT_KEY_FINGERPRINTS = "apt-key adv --list-public-keys --with-fingerprint --with-colons".freeze
 
       def load_current_resource
       end
 
       action :add do
-        unless new_resource.key.nil?
+        if new_resource.key.nil?
+          logger.debug "No 'key' property specified skipping key import"
+        else
           new_resource.key.each do |k|
             if is_key_id?(k) && !has_cookbook_file?(k)
               install_key_from_keyserver(k)
@@ -56,16 +57,10 @@ class Chef
           action :nothing
         end
 
-        components = if is_ppa_url?(new_resource.uri) && new_resource.components.empty?
-                       "main"
-                     else
-                       new_resource.components
-                     end
-
         repo = build_repo(
           new_resource.uri,
           new_resource.distribution,
-          components,
+          repo_components,
           new_resource.trusted,
           new_resource.arch,
           new_resource.deb_src
@@ -96,19 +91,27 @@ class Chef
               ignore_failure true
               action :nothing
             end
-
           end
+        else
+          logger.trace("/etc/apt/sources.list.d/#{new_resource.name}.list does not exist. Nothing to do")
         end
       end
 
+      # is the provided ID a key ID from a keyserver. Looks at length and HEX only values
+      # @param [String] id the key value passed by the user that *may* be an ID
       def is_key_id?(id)
         id = id[2..-1] if id.start_with?("0x")
         id =~ /^\h+$/ && [8, 16, 40].include?(id.length)
       end
 
+      # run the specified command and extract the fingerprints from the output
+      # accepts a command so it can be used to extract both the current key's fingerprints
+      # and the fingerprint of the new key
+      # @param [String] cmd the command to run
+      #
+      # @return [Array] an array of fingerprints
       def extract_fingerprints_from_cmd(cmd)
         so = shell_out(cmd)
-        so.run_command
         so.stdout.split(/\n/).map do |t|
           if z = t.match(/^fpr:+([0-9A-F]+):/)
             z[1].split.join
@@ -116,31 +119,47 @@ class Chef
         end.compact
       end
 
-      def key_is_valid?(cmd, key)
+      # validate the key against the apt keystore to see if that version is expired
+      # @param [String] key
+      #
+      # @return [Boolean] is the key valid or not
+      def key_is_valid?(key)
         valid = true
 
-        so = shell_out(cmd)
-        so.run_command
+        so = shell_out("apt-key list")
         so.stdout.split(/\n/).map do |t|
           if t =~ %r{^\/#{key}.*\[expired: .*\]$}
-            Chef::Log.debug "Found expired key: #{t}"
+            logger.debug "Found expired key: #{t}"
             valid = false
             break
           end
         end
 
-        Chef::Log.debug "key #{key} #{valid ? "is valid" : "is not valid"}"
+        logger.debug "key #{key} #{valid ? "is valid" : "is not valid"}"
         valid
       end
 
+      # return the specified cookbook name or the cookbook containing the
+      # resource.
+      #
+      # @return [String] name of the cookbook
       def cookbook_name
         new_resource.cookbook || new_resource.cookbook_name
       end
 
+      # determine if a cookbook file is available in the run
+      # @param [String] fn the path to the cookbook file
+      #
+      # @return [Boolean] cookbook file exists or doesn't
       def has_cookbook_file?(fn)
         run_context.has_cookbook_file_in_cookbook?(cookbook_name, fn)
       end
 
+      # determine if there are any new keys by comparing the fingerprints of installed
+      # keys to those of the passed file
+      # @param [String] file the keyfile of the new repository
+      #
+      # @return [Boolean] true: no new keys in the file. false: there are new keys
       def no_new_keys?(file)
         # Now we are using the option --with-colons that works across old os versions
         # as well as the latest (16.10). This for both `apt-key` and `gpg` commands
@@ -149,37 +168,56 @@ class Chef
         (installed_keys & proposed_keys).sort == proposed_keys.sort
       end
 
+      # Given the provided key URI determine what kind of chef resource we need
+      # to fetch the key
+      # @param [String] uri the uri of the gpg key (local path or http URL)
+      #
+      # @raise [Chef::Exceptions::FileNotFound] Key isn't remote or found in the current run
+      #
+      # @return [Symbol] :remote_file or :cookbook_file
+      def key_type(uri)
+        if uri.start_with?("http")
+          :remote_file
+        elsif has_cookbook_file?(uri)
+          :cookbook_file
+        else
+          raise Chef::Exceptions::FileNotFound, "Cannot locate key file: #{uri}"
+        end
+      end
+
+      # Fetch the key using either cookbook_file or remote_file, validate it,
+      # and install it with apt-key add
+      # @param [String] key the key to install
+      #
+      # @raise [RuntimeError] Invalid key which can't verify the apt repository
+      #
+      # @return [void]
       def install_key_from_uri(key)
         key_name = key.gsub(/[^0-9A-Za-z\-]/, "_")
         cached_keyfile = ::File.join(Chef::Config[:file_cache_path], key_name)
-        type = if key.start_with?("http")
-                 :remote_file
-               elsif has_cookbook_file?(key)
-                 :cookbook_file
-               else
-                 raise Chef::Exceptions::FileNotFound, "Cannot locate key file"
-               end
 
-        declare_resource(type, cached_keyfile) do
+        declare_resource(key_type(key), cached_keyfile) do
           source key
           mode "0644"
           sensitive new_resource.sensitive
           action :create
+          verify "gpg %{path}"
         end
 
-        raise "The key #{cached_keyfile} is invalid and cannot be used to verify an apt repository." unless key_is_valid?("gpg #{cached_keyfile}", "")
-
         declare_resource(:execute, "apt-key add #{cached_keyfile}") do
           sensitive new_resource.sensitive
           action :run
-          not_if do
-            no_new_keys?(cached_keyfile)
-          end
+          not_if { no_new_keys?(cached_keyfile) }
           notifies :run, "execute[apt-cache gencaches]", :immediately
         end
       end
 
-      def install_key_from_keyserver(key, keyserver = new_resource.keyserver)
+      # build the apt-key command to install the keyserver
+      # @param [String] key the key to install
+      # @param [String] keyserver the key server to use
+      #
+      # @return [String] the full apt-key command to run
+      def keyserver_install_cmd(key, keyserver)
         cmd = "apt-key adv --recv"
         cmd << " --keyserver-options http-proxy=#{new_resource.key_proxy}" if new_resource.key_proxy
         cmd << " --keyserver "
@@ -190,22 +228,37 @@ class Chef
                end
 
         cmd << " #{key}"
+        cmd
+      end
 
+      # @param [String] key
+      # @param [String] keyserver
+      #
+      # @raise [RuntimeError] Invalid key which can't verify the apt repository
+      #
+      # @return [void]
+      def install_key_from_keyserver(key, keyserver = new_resource.keyserver)
         declare_resource(:execute, "install-key #{key}") do
-          command cmd
+          command keyserver_install_cmd(key, keyserver)
           sensitive new_resource.sensitive
           not_if do
             present = extract_fingerprints_from_cmd(LIST_APT_KEY_FINGERPRINTS).any? do |fp|
               fp.end_with? key.upcase
             end
-            present && key_is_valid?(LIST_APT_KEYS, key.upcase)
+            present && key_is_valid?(key.upcase)
           end
           notifies :run, "execute[apt-cache gencaches]", :immediately
         end
 
-        raise "The key #{key} is invalid and cannot be used to verify an apt repository." unless key_is_valid?(LIST_APT_KEYS, key.upcase)
+        raise "The key #{key} is invalid and cannot be used to verify an apt repository." unless key_is_valid?(key.upcase)
       end
 
+      # @param [String] owner
+      # @param [String] repo
+      #
+      # @raise [RuntimeError] Could not access the Launchpad PPA API
+      #
+      # @return [void]
       def install_ppa_key(owner, repo)
         url = "https://launchpad.net/api/1.0/~#{owner}/+archive/#{repo}"
         key_id = Chef::HTTP::Simple.new(url).get("signing_key_fingerprint").delete('"')
@@ -214,12 +267,33 @@ class Chef
         raise "Could not access Launchpad ppa API: #{e.message}"
       end
 
+      # determine if the repository URL is a PPA
+      # @param [String] url the url of the repository
+      #
+      # @return [Boolean] is the repo URL a PPA
       def is_ppa_url?(url)
         url.start_with?("ppa:")
       end
 
+      # determine the repository's components:
+      #  - "components" property if defined
+      #  - "main" if "components" not defined and the repo is a PPA URL
+      #  - otherwise nothing
+      #
+      # @return [String] the repository component
+      def repo_components
+        if is_ppa_url?(new_resource.uri) && new_resource.components.empty?
+          "main"
+        else
+          new_resource.components
+        end
+      end
+
+      # given a PPA return a PPA URL in http://ppa.launchpad.net format
+      # @param [String] ppa the ppa URL
+      #
+      # @return [String] full PPA URL
       def make_ppa_url(ppa)
-        return unless is_ppa_url?(ppa)
         owner, repo = ppa[4..-1].split("/")
         repo ||= "ppa"
 
@@ -227,6 +301,14 @@ class Chef
         "http://ppa.launchpad.net/#{owner}/#{repo}/ubuntu"
       end
 
+      # build complete repo text that will be written to the config
+      # @param [String] uri
+      # @param [Array] components
+      # @param [Boolean] trusted
+      # @param [String] arch
+      # @param [Boolean] add_src
+      #
+      # @return [String] complete repo config text
       def build_repo(uri, distribution, components, trusted, arch, add_src = false)
         uri = make_ppa_url(uri) if is_ppa_url?(uri)