chef 12.5.0.alpha.1 → 12.5.1

data/lib/chef/mixin/windows_architecture_helper.rb

@@ -19,19 +19,13 @@
 
 require 'chef/exceptions'
 require 'chef/platform/query_helpers'
-require 'win32/api' if Chef::Platform.windows?
-require 'chef/win32/api/process' if Chef::Platform.windows?
-require 'chef/win32/api/error' if Chef::Platform.windows?
+require 'chef/win32/process' if Chef::Platform.windows?
+require 'chef/win32/system' if Chef::Platform.windows?
 
 class Chef
   module Mixin
     module WindowsArchitectureHelper
 
-      if Chef::Platform.windows?
-        include Chef::ReservedNames::Win32::API::Process
-        include Chef::ReservedNames::Win32::API::Error
-      end
-
       def node_windows_architecture(node)
         node[:kernel][:machine].to_sym
       end
@@ -42,6 +36,16 @@ class Chef
           is_i386_process_on_x86_64_windows?
       end
 
+      def forced_32bit_override_required?(node, desired_architecture)
+        desired_architecture == :i386 &&
+          node_windows_architecture(node) == :x86_64 &&
+          !is_i386_process_on_x86_64_windows?
+      end
+
+      def wow64_directory
+        Chef::ReservedNames::Win32::System.get_system_wow64_directory
+      end
+
       def with_os_architecture(node, architecture: nil)
         node ||= begin
           os_arch = ENV['PROCESSOR_ARCHITEW6432'] ||
@@ -88,49 +92,21 @@ class Chef
 
       def is_i386_process_on_x86_64_windows?
         if Chef::Platform.windows?
-          is_64_bit_process_result = FFI::MemoryPointer.new(:int)
-
-          # The return value of IsWow64Process is nonzero value if the API call succeeds.
-          # The result data are returned in the last parameter, not the return value.
-          call_succeeded = IsWow64Process(GetCurrentProcess(), is_64_bit_process_result)
-
-          # The result is nonzero if IsWow64Process's calling process, in the case here
-          # this process, is running under WOW64, i.e. the result is nonzero if this
-          # process is 32-bit (aka :i386).
-          result = (call_succeeded != 0) && (is_64_bit_process_result.get_int(0) != 0)
+          Chef::ReservedNames::Win32::Process.is_wow64_process
         else
           false
         end
       end
 
       def disable_wow64_file_redirection( node )
-        original_redirection_state = ['0'].pack('P')
-
         if ( ( node_windows_architecture(node) == :x86_64) && ::Chef::Platform.windows?)
-          win32_wow_64_disable_wow_64_fs_redirection =
-            ::Win32::API.new('Wow64DisableWow64FsRedirection', 'P', 'L', 'kernel32')
-
-          succeeded = win32_wow_64_disable_wow_64_fs_redirection.call(original_redirection_state)
-
-          if succeeded == 0
-            raise Win32APIError "Failed to disable Wow64 file redirection"
-          end
-
+          Chef::ReservedNames::Win32::System.wow64_disable_wow64_fs_redirection
         end
-
-        original_redirection_state
       end
 
       def restore_wow64_file_redirection( node, original_redirection_state )
         if ( (node_windows_architecture(node) == :x86_64) && ::Chef::Platform.windows?)
-          win32_wow_64_revert_wow_64_fs_redirection =
-            ::Win32::API.new('Wow64RevertWow64FsRedirection', 'P', 'L', 'kernel32')
-
-          succeeded = win32_wow_64_revert_wow_64_fs_redirection.call(original_redirection_state)
-
-          if succeeded == 0
-            raise Win32APIError "Failed to revert Wow64 file redirection"
-          end
+          Chef::ReservedNames::Win32::System.wow64_revert_wow64_fs_redirection(original_redirection_state)
         end
       end
 

data/lib/chef/mixin/windows_env_helper.rb

@@ -18,6 +18,7 @@
 
 
 require 'chef/exceptions'
+require 'chef/mixin/wide_string'
 require 'chef/platform/query_helpers'
 require 'chef/win32/error' if Chef::Platform.windows?
 require 'chef/win32/api/system' if Chef::Platform.windows?
@@ -26,6 +27,8 @@ require 'chef/win32/api/unicode' if Chef::Platform.windows?
 class Chef
   module Mixin
     module WindowsEnvHelper
+      include Chef::Mixin::WideString
+
       if Chef::Platform.windows?
         include Chef::ReservedNames::Win32::API::System
       end
@@ -45,7 +48,7 @@ class Chef
           Chef::ReservedNames::Win32::Error.raise!
         end
         if ( SendMessageTimeoutW(HWND_BROADCAST, WM_SETTINGCHANGE, 0, FFI::MemoryPointer.from_string(
-            Chef::ReservedNames::Win32::Unicode.utf8_to_wide('Environment')
+            utf8_to_wide('Environment')
         ).address, flags, 5000, nil) == 0 )
           Chef::ReservedNames::Win32::Error.raise!
         end

data/lib/chef/monkey_patches/webrick-utils.rb

@@ -0,0 +1,51 @@
+require 'webrick/utils'
+
+module WEBrick
+  module Utils
+    ##
+    # Creates TCP server sockets bound to +address+:+port+ and returns them.
+    #
+    # It will create IPV4 and IPV6 sockets on all interfaces.
+    #
+    # NOTE: We need to monkey patch this method because
+    # create_listeners on Windows with Ruby > 2.0.0 does not
+    # raise an error if we're already listening on a port.
+    #
+    def create_listeners(address, port, logger=nil)
+      #
+      # utils.rb -- Miscellaneous utilities
+      #
+      # Author: IPR -- Internet Programming with Ruby -- writers
+      # Copyright (c) 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
+      # Copyright (c) 2002 Internet Programming with Ruby writers. All rights
+      # reserved.
+      #
+      # $IPR: utils.rb,v 1.10 2003/02/16 22:22:54 gotoyuzo Exp $
+      unless port
+        raise ArgumentError, "must specify port"
+      end
+      res = Socket::getaddrinfo(address, port,
+                                Socket::AF_UNSPEC,   # address family
+                                Socket::SOCK_STREAM, # socket type
+                                0,                   # protocol
+                                Socket::AI_PASSIVE)  # flag
+      last_error = nil
+      sockets = []
+      res.each{|ai|
+        begin
+          logger.debug("TCPServer.new(#{ai[3]}, #{port})") if logger
+          sock = TCPServer.new(ai[3], port)
+          port = sock.addr[1] if port == 0
+          Utils::set_close_on_exec(sock)
+          sockets << sock
+        rescue => ex
+          logger.warn("TCPServer Error: #{ex}") if logger
+          last_error  = ex
+        end
+      }
+      raise last_error if sockets.empty?
+      return sockets
+    end
+    module_function :create_listeners
+  end
+end

data/lib/chef/monkey_patches/win32/registry.rb

@@ -0,0 +1,72 @@
+#
+# Copyright:: Copyright 2015 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/win32/api/registry'
+require 'chef/win32/unicode'
+require 'win32/registry'
+
+module Win32
+  class Registry
+
+    module API
+
+      extend Chef::ReservedNames::Win32::API::Registry
+
+      module_function
+
+      if RUBY_VERSION =~ /^2\.1/
+        # ::Win32::Registry#delete_value is broken in Ruby 2.1 (up to Ruby 2.1.6).
+        # This should be resolved in a later release (see note #9 in link below).
+        # https://bugs.ruby-lang.org/issues/10820
+        def DeleteValue(hkey, name)
+          check RegDeleteValueW(hkey, name.to_wstring)
+        end
+      end
+
+      # ::Win32::Registry#delete_key uses RegDeleteKeyW. We need to use
+      # RegDeleteKeyExW to properly support WOW64 systems.
+      def DeleteKey(hkey, name)
+        check RegDeleteKeyExW(hkey, name.to_wstring, 0, 0)
+      end
+
+    end
+
+    if RUBY_VERSION =~ /^2.1/
+      # ::Win32::Registry#write does not correctly handle data in Ruby 2.1 (up to Ruby 2.1.6).
+      # https://bugs.ruby-lang.org/issues/11439
+      def write(name, type, data)
+        case type
+        when REG_SZ, REG_EXPAND_SZ
+          data = data.to_s.encode(WCHAR) + WCHAR_NUL
+        when REG_MULTI_SZ
+          data = data.to_a.map {|s| s.encode(WCHAR)}.join(WCHAR_NUL) << WCHAR_NUL << WCHAR_NUL
+        when REG_BINARY
+          data = data.to_s
+        when REG_DWORD
+          data = API.packdw(data.to_i)
+        when REG_DWORD_BIG_ENDIAN
+          data = [data.to_i].pack('N')
+        when REG_QWORD
+          data = API.packqw(data.to_i)
+        else
+          raise TypeError, "Unsupported type #{type}"
+        end
+        API.SetValue(@hkey, name, type, data, data.bytesize)
+      end
+    end
+  end
+end

data/lib/chef/node.rb

@@ -63,6 +63,8 @@ class Chef
 
     include Chef::Mixin::ParamsValidate
 
+    NULL_ARG = Object.new
+
     # Create a new Chef::Node object.
     def initialize(chef_server_rest: nil)
       @chef_server_rest = chef_server_rest
@@ -72,6 +74,9 @@ class Chef
       @primary_runlist = Chef::RunList.new
       @override_runlist = Chef::RunList.new
 
+      @policy_name = nil
+      @policy_group = nil
+
       @attributes = Chef::Node::Attribute.new({}, {}, {}, {})
 
       @run_state = {}
@@ -132,6 +137,50 @@ class Chef
 
     alias :environment :chef_environment
 
+    # The `policy_name` for this node. Setting this to a non-nil value will
+    # enable policyfile mode when `chef-client` is run. If set in the config
+    # file or in node json, running `chef-client` will update this value.
+    #
+    # @see Chef::PolicyBuilder::Dynamic
+    # @see Chef::PolicyBuilder::Policyfile
+    #
+    # @param arg [String] the new policy_name value
+    # @return [String] the current policy_name, or the one you just set
+    def policy_name(arg=NULL_ARG)
+      return @policy_name if arg.equal?(NULL_ARG)
+      validate({policy_name: arg}, { policy_name: { kind_of: [ String, NilClass ], regex: /^[\-:.[:alnum:]_]+$/ } })
+      @policy_name = arg
+    end
+
+    # A "non-DSL-style" setter for `policy_name`
+    #
+    # @see #policy_name
+    def policy_name=(policy_name)
+      policy_name(policy_name)
+    end
+
+    # The `policy_group` for this node. Setting this to a non-nil value will
+    # enable policyfile mode when `chef-client` is run. If set in the config
+    # file or in node json, running `chef-client` will update this value.
+    #
+    # @see Chef::PolicyBuilder::Dynamic
+    # @see Chef::PolicyBuilder::Policyfile
+    #
+    # @param arg [String] the new policy_group value
+    # @return [String] the current policy_group, or the one you just set
+    def policy_group(arg=NULL_ARG)
+      return @policy_group if arg.equal?(NULL_ARG)
+      validate({policy_group: arg}, { policy_group: { kind_of: [ String, NilClass ], regex: /^[\-:.[:alnum:]_]+$/ } })
+      @policy_group = arg
+    end
+
+    # A "non-DSL-style" setter for `policy_group`
+    #
+    # @see #policy_group
+    def policy_group=(policy_group)
+      policy_group(policy_group)
+    end
+
     def attributes
       @attributes
     end
@@ -391,7 +440,7 @@ class Chef
 
       self.tags # make sure they're defined
 
-      automatic_attrs[:recipes] = expansion.recipes.with_fully_qualified_names_and_version_constraints
+      automatic_attrs[:recipes] = expansion.recipes.with_duplicate_names
       automatic_attrs[:expanded_run_list] = expansion.recipes.with_fully_qualified_names_and_version_constraints
       automatic_attrs[:roles] = expansion.roles
 
@@ -461,6 +510,14 @@ class Chef
         #Render correctly for run_list items so malformed json does not result
         "run_list" => @primary_runlist.run_list.map { |item| item.to_s }
       }
+      # Chef Server rejects node JSON with extra keys; prior to 12.3,
+      # "policy_name" and "policy_group" are unknown; after 12.3 they are
+      # optional, therefore only including them in the JSON if present
+      # maximizes compatibility for most people.
+      unless policy_group.nil? && policy_name.nil?
+        result["policy_name"] = policy_name
+        result["policy_group"] = policy_group
+      end
       result
     end
 
@@ -492,6 +549,10 @@ class Chef
       else
         o["recipes"].each { |r| node.recipes << r }
       end
+
+      node.policy_name = o["policy_name"] if o.has_key?("policy_name")
+      node.policy_group = o["policy_group"] if o.has_key?("policy_group")
+
       node
     end
 
@@ -553,8 +614,16 @@ class Chef
           chef_server_rest.put_rest("nodes/#{name}", data_for_save)
         end
       rescue Net::HTTPServerException => e
-        raise e unless e.response.code == "404"
-        chef_server_rest.post_rest("nodes", data_for_save)
+        if e.response.code == "404"
+          chef_server_rest.post_rest("nodes", data_for_save)
+        # Chef Server before 12.3 rejects node JSON with 'policy_name' or
+        # 'policy_group' keys, but 'policy_name' will be detected first.
+        # Backcompat can be removed in 13.0
+        elsif e.response.code == "400" && e.response.body.include?("Invalid key policy_name")
+          save_without_policyfile_attrs
+        else
+          raise
+        end
       end
       self
     end
@@ -563,6 +632,15 @@ class Chef
     def create
       chef_server_rest.post_rest("nodes", data_for_save)
       self
+    rescue Net::HTTPServerException => e
+      # Chef Server before 12.3 rejects node JSON with 'policy_name' or
+      # 'policy_group' keys, but 'policy_name' will be detected first.
+      # Backcompat can be removed in 13.0
+      if e.response.code == "400" && e.response.body.include?("Invalid key policy_name")
+        chef_server_rest.post_rest("nodes", data_for_save_without_policyfile_attrs)
+      else
+        raise
+      end
     end
 
     def to_s
@@ -575,6 +653,22 @@ class Chef
 
     private
 
+    def save_without_policyfile_attrs
+      trimmed_data = data_for_save_without_policyfile_attrs
+
+      chef_server_rest.put_rest("nodes/#{name}", trimmed_data)
+    rescue Net::HTTPServerException => e
+      raise e unless e.response.code == "404"
+      chef_server_rest.post_rest("nodes", trimmed_data)
+    end
+
+    def data_for_save_without_policyfile_attrs
+      data_for_save.tap do |trimmed_data|
+        trimmed_data.delete("policy_name")
+        trimmed_data.delete("policy_group")
+      end
+    end
+
     def data_for_save
       data = for_json
       ["automatic", "default", "normal", "override"].each do |level|

data/lib/chef/node_map.rb

@@ -32,8 +32,8 @@ class Chef
     # @return [NodeMap] Returns self for possible chaining
     #
     def set(key, value, platform: nil, platform_version: nil, platform_family: nil, os: nil, on_platform: nil, on_platforms: nil, canonical: nil, override: nil, &block)
-      Chef::Log.deprecation "The on_platform option to node_map has been deprecated" if on_platform
-      Chef::Log.deprecation "The on_platforms option to node_map has been deprecated" if on_platforms
+      Chef.log_deprecation("The on_platform option to node_map has been deprecated") if on_platform
+      Chef.log_deprecation("The on_platforms option to node_map has been deprecated") if on_platforms
       platform ||= on_platform || on_platforms
       filters = {}
       filters[:platform] = platform if platform

data/lib/chef/platform/provider_mapping.rb

@@ -200,14 +200,13 @@ class Chef
             class_name = resource_type.class.name ? resource_type.class.name.split('::').last :
               convert_to_class_name(resource_type.resource_name.to_s)
 
-            begin
-              result = Chef::Provider.const_get(class_name)
-              Chef::Log.warn("Class Chef::Provider::#{class_name} does not declare 'resource_name #{convert_to_snake_case(class_name).to_sym.inspect}'.")
-              Chef::Log.warn("This will no longer work in Chef 13: you must use 'resource_name' to provide DSL.")
-            rescue NameError
+            if Chef::Provider.const_defined?(class_name)
+              Chef::Log.warn("Class Chef::Provider::#{class_name} does not declare 'provides #{convert_to_snake_case(class_name).to_sym.inspect}'.")
+              Chef::Log.warn("This will no longer work in Chef 13: you must use 'provides' to use the resource's DSL.")
+              return Chef::Provider.const_get(class_name)
             end
           end
-          result
+          nil
         end
 
     end

data/lib/chef/platform/query_helpers.rb

@@ -25,13 +25,10 @@ class Chef
       end
 
       def windows_server_2003?
+        # WMI startup shouldn't be performed unless we're on Windows.
         return false unless windows?
         require 'wmi-lite/wmi'
 
-        # CHEF-4888: Work around ruby #2618, expected to be fixed in Ruby 2.1.0
-        # https://github.com/ruby/ruby/commit/588504b20f5cc880ad51827b93e571e32446e5db
-        # https://github.com/ruby/ruby/commit/27ed294c7134c0de582007af3c915a635a6506cd
-
         wmi = WmiLite::Wmi.new
         host = wmi.first_of('Win32_OperatingSystem')
         is_server_2003 = (host['version'] && host['version'].start_with?("5.2"))
@@ -39,6 +36,44 @@ class Chef
         is_server_2003
       end
 
+      def windows_nano_server?
+        return false unless windows?
+        require 'win32/registry'
+
+        # This method may be called before ohai runs (e.g., it may be used to
+        # determine settings in config.rb). Chef::Win32::Registry.new uses
+        # node attributes to verify the machine architecture which aren't
+        # accessible before ohai runs.
+        nano = nil
+        key = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Server\\ServerLevels"
+        access = ::Win32::Registry::KEY_QUERY_VALUE | 0x0100 # nano is 64-bit only
+        begin
+          ::Win32::Registry::HKEY_LOCAL_MACHINE.open(key, access) do |reg|
+            nano = reg["NanoServer"]
+          end
+        rescue ::Win32::Registry::Error
+          # If accessing the registry key failed, then we're probably not on
+          # nano. Fail through.
+        end
+        return nano == 1
+      end
+
+      def supports_msi?
+        return false unless windows?
+        require 'win32/registry'
+
+        key = "System\\CurrentControlSet\\Services\\msiserver"
+        access = ::Win32::Registry::KEY_QUERY_VALUE
+
+        begin
+          ::Win32::Registry::HKEY_LOCAL_MACHINE.open(key, access) do |reg|
+            true
+          end
+        rescue ::Win32::Registry::Error
+          false
+        end
+      end
+
       def supports_powershell_execution_bypass?(node)
         node[:languages] && node[:languages][:powershell] &&
           node[:languages][:powershell][:version].to_i >= 3
@@ -55,6 +90,13 @@ class Chef
           Gem::Version.new(node[:languages][:powershell][:version]) >=
             Gem::Version.new("5.0.10018.0")
       end
+
+      def dsc_refresh_mode_disabled?(node)
+        require 'chef/util/powershell/cmdlet'
+        cmdlet = Chef::Util::Powershell::Cmdlet.new(node, "Get-DscLocalConfigurationManager", :object)
+        metadata = cmdlet.run!.return_value
+        metadata['RefreshMode'] == 'Disabled'
+      end
     end
   end
 end