chef 18.0.169-x64-mingw-ucrt

data/lib/chef/dsl/platform_introspection.rb

@@ -0,0 +1,265 @@
+#
+# Author:: Adam Jacob (<adam@chef.io>)
+# Copyright:: Copyright (c) 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.
+#
+
+autoload :ChefUtils, "chef-utils"
+require_relative "../mixin/chef_utils_wiring" unless defined?(Chef::Mixin::ChefUtilsWiring)
+
+class Chef
+  module DSL
+    # == Chef::DSL::PlatformIntrospection
+    # Provides the DSL for platform-dependent switch logic, such as
+    # #value_for_platform.
+    module PlatformIntrospection
+      include ChefUtils
+      include Chef::Mixin::ChefUtilsWiring
+
+      # Implementation class for determining platform dependent values
+      class PlatformDependentValue
+
+        # Create a platform dependent value object.
+        # === Arguments
+        # platform_hash (Hash) a hash of the same structure as Chef::Platform,
+        # like this:
+        #   {
+        #     :debian => {:default => 'the value for all debian'}
+        #     [:centos, :redhat, :fedora] => {:default => "value for all EL variants"}
+        #     :ubuntu => { :default => "default for ubuntu", '10.04' => "value for 10.04 only"},
+        #     :default => "the default when nothing else matches"
+        #   }
+        # * platforms can be specified as Symbols or Strings
+        # * multiple platforms can be grouped by using an Array as the key
+        # * values for platforms need to be Hashes of the form:
+        #   {platform_version => value_for_that_version}
+        # * the exception to the above is the default value, which is given as
+        #   :default => default_value
+        def initialize(platform_hash)
+          @values = {}
+          platform_hash.each { |platforms, value| set(platforms, value) }
+        end
+
+        def value_for_node(node)
+          platform, version = node[:platform].to_s, node[:platform_version].to_s
+          # Check if we match a version constraint via Chef::VersionConstraint::Platform and Chef::Version::Platform
+          matched_value = match_versions(node)
+          if @values.key?(platform) && @values[platform].key?(version)
+            @values[platform][version]
+          elsif matched_value
+            matched_value
+          elsif @values.key?(platform) && @values[platform].key?("default")
+            @values[platform]["default"]
+          elsif @values.key?("default")
+            @values["default"]
+          else
+            nil
+          end
+        end
+
+        private
+
+        def match_versions(node)
+          platform, version = node[:platform].to_s, node[:platform_version].to_s
+          return nil unless @values.key?(platform)
+
+          node_version = Chef::Version::Platform.new(version)
+          key_matches = []
+          keys = @values[platform].keys
+          keys.each do |k|
+
+            if Chef::VersionConstraint::Platform.new(k).include?(node_version)
+              key_matches << k
+            end
+          rescue Chef::Exceptions::InvalidVersionConstraint => e
+            Chef::Log.trace "Caught InvalidVersionConstraint. This means that a key in value_for_platform cannot be interpreted as a Chef::VersionConstraint::Platform."
+            Chef::Log.trace(e)
+
+          end
+          return @values[platform][version] if key_matches.include?(version)
+
+          case key_matches.length
+          when 0
+            nil
+          when 1
+            @values[platform][key_matches.first]
+          else
+            raise "Multiple matches detected for #{platform} with values #{@values}. The matches are: #{key_matches}"
+          end
+        rescue Chef::Exceptions::InvalidCookbookVersion => e
+          # Lets not break because someone passes a weird string like 'default' :)
+          Chef::Log.trace(e)
+          Chef::Log.trace "InvalidCookbookVersion exceptions are common and expected here: the generic constraint matcher attempted to match something which is not a constraint. Moving on to next version or constraint"
+          nil
+        rescue Chef::Exceptions::InvalidPlatformVersion => e
+          Chef::Log.trace "Caught InvalidPlatformVersion, this means that Chef::Version::Platform does not know how to turn #{node_version} into an x.y.z format"
+          Chef::Log.trace(e)
+          nil
+        end
+
+        def set(platforms, value)
+          if platforms.to_s == "default"
+            @values["default"] = value
+          else
+            assert_valid_platform_values!(platforms, value)
+            Array(platforms).each { |platform| @values[platform.to_s] = normalize_keys(value) }
+            value
+          end
+        end
+
+        def normalize_keys(hash)
+          hash.inject({}) do |h, key_value|
+            keys, value = *key_value
+            Array(keys).each do |key|
+              h[key.to_s] = value
+            end
+            h
+          end
+        end
+
+        def assert_valid_platform_values!(platforms, value)
+          unless value.is_a?(Hash)
+            msg = "platform dependent values must be specified in the format :platform => {:version => value} "
+            msg << "you gave a value #{value.inspect} for platform(s) #{platforms}"
+            raise ArgumentError, msg
+          end
+        end
+      end
+
+      # Given a hash similar to the one we use for Platforms, select a value from the hash.  Supports
+      # per platform defaults, along with a single base default. Arrays may be passed as hash keys and
+      # will be expanded.
+      #
+      # === Parameters
+      # platform_hash:: A platform-style hash.
+      #
+      # === Returns
+      # value:: Whatever the most specific value of the hash is.
+      def value_for_platform(platform_hash)
+        PlatformDependentValue.new(platform_hash).value_for_node(node)
+      end
+
+      # Given a list of platforms, returns true if the current recipe is being run on a node with
+      # that platform, false otherwise.
+      #
+      # === Parameters
+      # args:: A list of platforms. Each platform can be in string or symbol format.
+      #
+      # === Returns
+      # true:: If the current platform is in the list
+      # false:: If the current platform is not in the list
+      def platform?(*args)
+        has_platform = false
+
+        args.flatten.each do |platform|
+          has_platform = true if platform.to_s == node[:platform]
+        end
+
+        has_platform
+      end
+
+      # Implementation class for determining platform family dependent values
+      class PlatformFamilyDependentValue
+
+        # Create a platform family dependent value object.
+        # === Arguments
+        # platform_family_hash (Hash) a map of platform families to values.
+        # like this:
+        #   {
+        #     :rhel => "value for all EL variants"
+        #     :fedora =>  "value for fedora variants fedora and amazon" ,
+        #     [:fedora, :rhel] => "value for all known redhat variants"
+        #     :debian =>  "value for debian variants including debian, ubuntu, mint" ,
+        #     :default => "the default when nothing else matches"
+        #   }
+        # * platform families can be specified as Symbols or Strings
+        # * multiple platform families can be grouped by using an Array as the key
+        # * values for platform families can be any object, with no restrictions. Some examples:
+        #   - [:stop, :start]
+        #   - "mysql-devel"
+        #   - { :key => "value" }
+        def initialize(platform_family_hash)
+          @values = {}
+          @values["default"] = nil
+          platform_family_hash.each { |platform_families, value| set(platform_families, value) }
+        end
+
+        def value_for_node(node)
+          if node.key?(:platform_family)
+            platform_family = node[:platform_family].to_s
+            if @values.key?(platform_family)
+              @values[platform_family]
+            else
+              @values["default"]
+            end
+          else
+            @values["default"]
+          end
+        end
+
+        private
+
+        def set(platform_family, value)
+          if platform_family.to_s == "default"
+            @values["default"] = value
+          else
+            Array(platform_family).each { |family| @values[family.to_s] = value }
+            value
+          end
+        end
+      end
+
+      # Given a hash mapping platform families to values, select a value from the hash. Supports a single
+      # base default if platform family is not in the map. Arrays may be passed as hash keys and will be
+      # expanded
+      #
+      # === Parameters
+      # platform_family_hash:: A hash in the form { platform_family_name => value }
+      #
+      # === Returns
+      # value:: Whatever the most specific value of the hash is.
+      def value_for_platform_family(platform_family_hash)
+        PlatformFamilyDependentValue.new(platform_family_hash).value_for_node(node)
+      end
+
+      # Given a list of platform families, returns true if the current recipe is being run on a
+      # node within that platform family, false otherwise.
+      #
+      # === Parameters
+      # args:: A list of platform families. Each platform family can be in string or symbol format.
+      #
+      # === Returns
+      # true:: if the current node platform family is in the list.
+      # false:: if the current node platform family is not in the list.
+      def platform_family?(*args)
+        args.flatten.any? do |platform_family|
+          platform_family.to_s == node[:platform_family]
+        end
+      end
+
+      # a simple helper to determine if we're on a windows release pre-2012 / 8
+      #
+      # @deprecated Windows releases before Windows 2012 and 8 are no longer supported
+      # @return [Boolean] Is the system older than Windows 8 / 2012
+      def older_than_win_2012_or_8?(node = run_context.nil? ? nil : run_context.node)
+        false # we don't support platforms that would be true
+      end
+
+      # ^^^^^^ NOTE: PLEASE DO NOT CONTINUE TO ADD THESE KINDS OF PLATFORM_VERSION APIS WITHOUT ^^^^^^^
+      # ^^^^^^ GOING THROUGH THE DESIGN REVIEW PROCESS AND ADDRESS THE EXISTING CHEF-SUGAR ONES ^^^^^^^
+      # ^^^^^^ DO "THE HARD RIGHT THING" AND ADDRESS THE BROADER PROBLEM AND FIX IT ALL.        ^^^^^^^
+    end
+  end
+end

data/lib/chef/dsl/powershell.rb

@@ -0,0 +1,29 @@
+#
+# Author:: Jay Mundrawala (<jdm@chef.io>)
+# Copyright:: Copyright (c) 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_relative "../util/powershell/ps_credential"
+
+class Chef
+  module DSL
+    module Powershell
+      def ps_credential(username = "placeholder", password) # rubocop:disable Style/OptionalArguments
+        Chef::Util::Powershell::PSCredential.new(username, password)
+      end
+    end
+  end
+end

data/lib/chef/dsl/reader_helpers.rb

@@ -0,0 +1,51 @@
+#
+# Copyright:: Copyright (c) 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.
+
+autoload :TOML, "tomlrb"
+require_relative "../json_compat"
+autoload :YAML, "yaml"
+
+class Chef
+  module DSL
+    module ReaderHelpers
+
+      def parse_file(filename)
+        case File.extname(filename)
+        when ".toml"
+          parse_toml(filename)
+        when ".yaml", ".yml"
+          parse_yaml(filename)
+        when ".json"
+          parse_json(filename)
+        end
+      end
+
+      def parse_json(filename)
+        JSONCompat.parse(IO.read(filename))
+      end
+
+      def parse_toml(filename)
+        Tomlrb.load_file(filename)
+      end
+
+      def parse_yaml(filename)
+        YAML.safe_load_file(filename, permitted_classes: [Date])
+      end
+
+      extend self
+    end
+  end
+end

data/lib/chef/dsl/reboot_pending.rb

@@ -0,0 +1,56 @@
+# Author:: Bryan McLellan <btm@loftninjas.org>
+# Author:: Seth Chisamore <schisamo@chef.io>
+# Copyright:: Copyright (c) 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_relative "platform_introspection"
+require_relative "registry_helper"
+
+class Chef
+  module DSL
+    module RebootPending
+
+      include Chef::DSL::RegistryHelper
+      include Chef::DSL::PlatformIntrospection
+
+      # Returns true if the system needs a reboot or is expected to reboot
+      # Note that we will silently miss any other platform-specific reboot notices besides Windows+Ubuntu.
+      def reboot_pending?
+        # don't break when used as a mixin in contexts without #node (e.g. specs).
+        if respond_to?(:node, true) && node.run_context.reboot_requested?
+          true
+        elsif platform?("windows")
+          # PendingFileRenameOperations contains pairs (REG_MULTI_SZ) of filenames that cannot be updated
+          # due to a file being in use (usually a temporary file and a system file)
+          # \??\c:\temp\test.sys!\??\c:\winnt\system32\test.sys
+          # http://technet.microsoft.com/en-us/library/cc960241.aspx
+          registry_value_exists?("HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager", { name: "PendingFileRenameOperations" }) ||
+
+            # RebootRequired key contains Update IDs with a value of 1 if they require a reboot.
+            # The existence of RebootRequired alone is sufficient on my Windows 8.1 workstation in Windows Update
+            registry_key_exists?('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired') ||
+
+            # Vista + Server 2008 and newer may have reboots pending from CBS
+            registry_key_exists?('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootPending')
+        elsif platform_family?("debian")
+          File.exist?("/var/run/reboot-required")
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/chef/dsl/recipe.rb

@@ -0,0 +1,71 @@
+#
+# Author:: Adam Jacob (<adam@chef.io>)
+# Author:: Christopher Walters (<cw@chef.io>)
+# Copyright:: Copyright (c) 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_relative "../exceptions"
+require_relative "compliance"
+require_relative "declare_resource"
+require_relative "definitions"
+require_relative "include_recipe"
+require_relative "reboot_pending"
+require_relative "resources"
+require_relative "universal"
+require_relative "../mixin/notifying_block"
+require_relative "../mixin/lazy_module_include"
+
+class Chef
+  module DSL
+    # Part of a family of DSL mixins.
+    #
+    # Chef::DSL::Recipe mixes into Recipes and Providers.
+    #   - this is restricted to recipe/resource/provider context where a resource collection exists.
+    #   - cookbook authors should typically include modules into here.
+    #
+    # Chef::DSL::Universal mixes into Recipes, LWRP Resources+Providers, Core Resources+Providers, and Attributes files.
+    #   - this adds resources and attributes files.
+    #   - do not add helpers which manipulate the resource collection.
+    #   - this is for general-purpose stuff that is useful nearly everywhere.
+    #   - it also pollutes the namespace of nearly every context, watch out.
+    #
+    module Recipe
+      include Chef::DSL::Compliance
+      include Chef::DSL::Universal
+      include Chef::DSL::DeclareResource
+      include Chef::Mixin::NotifyingBlock
+      include Chef::DSL::IncludeRecipe
+      include Chef::DSL::RebootPending
+      include Chef::DSL::Resources
+      include Chef::DSL::Definitions
+      extend Chef::Mixin::LazyModuleInclude
+
+      def resource_class_for(snake_case_name)
+        Chef::Resource.resource_for_node(snake_case_name, run_context.node)
+      end
+
+      def have_resource_class_for?(snake_case_name)
+        not resource_class_for(snake_case_name).nil?
+      rescue NameError
+        false
+      end
+
+      def exec(args)
+        raise Chef::Exceptions::ResourceNotFound, "exec was called, but you probably meant to use an execute resource.  If not, please call Kernel#exec explicitly.  The exec block called was \"#{args}\""
+      end
+    end
+  end
+end

data/lib/chef/dsl/registry_helper.rb

@@ -0,0 +1,63 @@
+#
+# Author:: Lamont Granquist (<lamont@chef.io>)
+# Copyright:: Copyright (c) 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.
+#
+
+#
+# Helper functions to access the windows registry from within recipes and
+# the not_if/only_if blocks in resources.  This only exposes the methods
+# in the chef/win32/registry class which are reasonably side-effect-free.
+# The actual modification of the registry should be done via the registry_key
+# resource in a more idempotent way.
+#
+#
+class Chef
+  module DSL
+    module RegistryHelper
+      # the registry instance is cheap to build and throwing it away ensures we
+      # don't carry any state (e.g. magic 32-bit/64-bit settings) between calls
+      def registry_key_exists?(key_path, architecture = :machine)
+        registry = Chef::Win32::Registry.new(run_context, architecture)
+        registry.key_exists?(key_path)
+      end
+
+      def registry_get_values(key_path, architecture = :machine)
+        registry = Chef::Win32::Registry.new(run_context, architecture)
+        registry.get_values(key_path)
+      end
+
+      def registry_has_subkeys?(key_path, architecture = :machine)
+        registry = Chef::Win32::Registry.new(run_context, architecture)
+        registry.has_subkeys?(key_path)
+      end
+
+      def registry_get_subkeys(key_path, architecture = :machine)
+        registry = Chef::Win32::Registry.new(run_context, architecture)
+        registry.get_subkeys(key_path)
+      end
+
+      def registry_value_exists?(key_path, value, architecture = :machine)
+        registry = Chef::Win32::Registry.new(run_context, architecture)
+        registry.value_exists?(key_path, value)
+      end
+
+      def registry_data_exists?(key_path, value, architecture = :machine)
+        registry = Chef::Win32::Registry.new(run_context, architecture)
+        registry.data_exists?(key_path, value)
+      end
+    end
+  end
+end

data/lib/chef/dsl/render_helpers.rb

@@ -0,0 +1,44 @@
+#
+# Copyright:: Copyright (c) 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_relative "toml"
+require_relative "../json_compat"
+autoload :YAML, "yaml"
+
+class Chef
+  module DSL
+    module RenderHelpers
+
+      # pretty-print a hash as a JSON string
+      def render_json(hash)
+        JSON.pretty_generate(hash) + "\n"
+      end
+
+      # pretty-print a hash as a TOML string
+      def render_toml(hash)
+        Chef::DSL::Toml::Dumper.new(hash).toml_str
+      end
+
+      # pretty-print a hash as a YAML string
+      def render_yaml(hash)
+        yaml_content = hash.transform_keys(&:to_s).to_yaml
+        # above replaces first-level keys with strings, below the rest
+        yaml_content.gsub!(" :", " ")
+      end
+
+      extend self
+    end
+  end
+end

data/lib/chef/dsl/resources.rb

@@ -0,0 +1,47 @@
+#
+# Author:: John Keiser <jkeiser@chef.io>
+# Copyright:: Copyright (c) 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_relative "cheffish"
+
+class Chef
+  module DSL
+    #
+    # Module containing a method for each globally declared Resource
+    #
+    # Depends on declare_resource(name, created_at, &block)
+    #
+    # @api private
+    module Resources
+      # Include the lazy loader for cheffish, so that the
+      # resource DSL is there but the gem isn't activated yet.
+      include Chef::DSL::Cheffish
+
+      def self.add_resource_dsl(dsl_name)
+        module_eval(<<-EOM, __FILE__, __LINE__ + 1)
+            def #{dsl_name}(args = nil, &block)
+              declare_resource(#{dsl_name.inspect}, args, created_at: caller[0], &block)
+            end
+        EOM
+      end
+
+      def self.remove_resource_dsl(dsl_name)
+        remove_method(dsl_name)
+      rescue NameError
+      end
+    end
+  end
+end