chef 12.4.3-universal-mingw32 → 12.5.1-universal-mingw32

data/lib/chef/win32/security.rb

@@ -22,7 +22,7 @@ require 'chef/win32/memory'
 require 'chef/win32/process'
 require 'chef/win32/unicode'
 require 'chef/win32/security/token'
-require 'chef/mixin/wstring'
+require 'chef/mixin/wide_string'
 
 class Chef
   module ReservedNames::Win32

data/lib/chef/win32/security/token.rb

@@ -18,7 +18,7 @@
 
 require 'chef/win32/security'
 require 'chef/win32/api/security'
-
+require 'chef/win32/unicode'
 require 'ffi'
 
 class Chef

data/lib/chef/win32/system.rb

@@ -0,0 +1,62 @@
+#
+# Author:: Salim Alam (<salam@chef.io>)
+# Copyright:: Copyright 2015 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/win32/api/system'
+require 'chef/win32/error'
+require 'ffi'
+
+class Chef
+  module ReservedNames::Win32
+    class System
+      include Chef::ReservedNames::Win32::API::System
+      extend Chef::ReservedNames::Win32::API::System
+
+      def self.get_system_wow64_directory
+        ptr = FFI::MemoryPointer.new(:char, 255, true)
+        succeeded = GetSystemWow64DirectoryA(ptr, 255)
+
+        if succeeded == 0
+          raise Win32APIError, "Failed to get Wow64 system directory"
+        end
+
+        ptr.read_string.strip
+      end
+
+      def self.wow64_disable_wow64_fs_redirection
+        original_redirection_state = FFI::MemoryPointer.new(:pointer)
+
+        succeeded = Wow64DisableWow64FsRedirection(original_redirection_state)
+
+        if succeeded == 0
+          raise Win32APIError, "Failed to disable Wow64 file redirection"
+        end
+
+        original_redirection_state
+      end
+
+      def self.wow64_revert_wow64_fs_redirection(original_redirection_state)
+        succeeded = Wow64RevertWow64FsRedirection(original_redirection_state)
+
+        if succeeded == 0
+          raise Win32APIError, "Failed to revert Wow64 file redirection"
+        end
+      end
+
+    end
+  end
+end

data/lib/chef/win32/unicode.rb

@@ -17,6 +17,7 @@
 # limitations under the License.
 #
 
+require 'chef/mixin/wide_string'
 require 'chef/win32/api/unicode'
 
 class Chef
@@ -30,6 +31,8 @@ end
 
 module FFI
   class Pointer
+    include Chef::Mixin::WideString
+
     def read_wstring(num_wchars = nil)
       if num_wchars.nil?
         # Find the length of the string
@@ -43,13 +46,15 @@ module FFI
         num_wchars = length
       end
 
-      Chef::ReservedNames::Win32::Unicode.wide_to_utf8(self.get_bytes(0, num_wchars*2))
+      wide_to_utf8(self.get_bytes(0, num_wchars*2))
     end
   end
 end
 
 class String
+  include Chef::Mixin::WideString
+
   def to_wstring
-    Chef::ReservedNames::Win32::Unicode.utf8_to_wide(self)
+    utf8_to_wide(self)
   end
 end

data/lib/chef/win32/version.rb

@@ -122,10 +122,6 @@ class Chef
         # WMI always returns the truth. See article at
         # http://msdn.microsoft.com/en-us/library/windows/desktop/ms724439(v=vs.85).aspx
 
-        # 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
         os_info = wmi.first_of('Win32_OperatingSystem')
         os_version = os_info['version']

data/lib/chef/workstation_config_loader.rb

@@ -1,5 +1,5 @@
 #
-# Author:: Daniel DeLeo (<dan@getchef.com>)
+# Author:: Claire McQuin (<claire@chef.io>)
 # Copyright:: Copyright (c) 2014 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
@@ -16,163 +16,8 @@
 # limitations under the License.
 #
 
-require 'chef/config_fetcher'
-require 'chef/config'
-require 'chef/null_logger'
-require 'chef/util/path_helper'
+require 'chef-config/workstation_config_loader'
 
 class Chef
-
-  class WorkstationConfigLoader
-
-    # Path to a config file requested by user, (e.g., via command line option). Can be nil
-    attr_accessor :explicit_config_file
-
-    # TODO: initialize this with a logger for Chef and Knife
-    def initialize(explicit_config_file, logger=nil)
-      @explicit_config_file = explicit_config_file
-      @config_location = nil
-      @logger = logger || NullLogger.new
-    end
-
-    def no_config_found?
-      config_location.nil?
-    end
-
-    def config_location
-      @config_location ||= (explicit_config_file || locate_local_config)
-    end
-
-    def chef_config_dir
-      if @chef_config_dir.nil?
-        @chef_config_dir = false
-        full_path = working_directory.split(File::SEPARATOR)
-        (full_path.length - 1).downto(0) do |i|
-          candidate_directory = File.join(full_path[0..i] + [".chef" ])
-          if File.exist?(candidate_directory) && File.directory?(candidate_directory)
-            @chef_config_dir = candidate_directory
-            break
-          end
-        end
-      end
-      @chef_config_dir
-    end
-
-    def load
-      # Ignore it if there's no explicit_config_file and can't find one at a
-      # default path.
-      return false if config_location.nil?
-
-      if explicit_config_file && !path_exists?(config_location)
-        raise Exceptions::ConfigurationError, "Specified config file #{config_location} does not exist"
-      end
-
-      # Have to set Chef::Config.config_file b/c other config is derived from it.
-      Chef::Config.config_file = config_location
-      read_config(IO.read(config_location), config_location)
-    end
-
-    # (Private API, public for test purposes)
-    def env
-      ENV
-    end
-
-    # (Private API, public for test purposes)
-    def path_exists?(path)
-      Pathname.new(path).expand_path.exist?
-    end
-
-    private
-
-    def have_config?(path)
-      if path_exists?(path)
-        logger.info("Using config at #{path}")
-        true
-      else
-        logger.debug("Config not found at #{path}, trying next option")
-        false
-      end
-    end
-
-    def locate_local_config
-      candidate_configs = []
-
-      # Look for $KNIFE_HOME/knife.rb (allow multiple knives config on same machine)
-      if env['KNIFE_HOME']
-        candidate_configs << File.join(env['KNIFE_HOME'], 'config.rb')
-        candidate_configs << File.join(env['KNIFE_HOME'], 'knife.rb')
-      end
-      # Look for $PWD/knife.rb
-      if Dir.pwd
-        candidate_configs << File.join(Dir.pwd, 'config.rb')
-        candidate_configs << File.join(Dir.pwd, 'knife.rb')
-      end
-      # Look for $UPWARD/.chef/knife.rb
-      if chef_config_dir
-        candidate_configs << File.join(chef_config_dir, 'config.rb')
-        candidate_configs << File.join(chef_config_dir, 'knife.rb')
-      end
-      # Look for $HOME/.chef/knife.rb
-      Chef::Util::PathHelper.home('.chef') do |dot_chef_dir|
-        candidate_configs << File.join(dot_chef_dir, 'config.rb')
-        candidate_configs << File.join(dot_chef_dir, 'knife.rb')
-      end
-
-      candidate_configs.find do | candidate_config |
-        have_config?(candidate_config)
-      end
-    end
-
-    def working_directory
-      a = if Chef::Platform.windows?
-            env['CD']
-          else
-            env['PWD']
-          end || Dir.pwd
-
-      a
-    end
-
-    def read_config(config_content, config_file_path)
-      Chef::Config.from_string(config_content, config_file_path)
-    rescue SignalException
-      raise
-    rescue SyntaxError => e
-      message = ""
-      message << "You have invalid ruby syntax in your config file #{config_file_path}\n\n"
-      message << "#{e.class.name}: #{e.message}\n"
-      if file_line = e.message[/#{Regexp.escape(config_file_path)}:[\d]+/]
-        line = file_line[/:([\d]+)$/, 1].to_i
-        message << highlight_config_error(config_file_path, line)
-      end
-      raise Exceptions::ConfigurationError, message
-    rescue Exception => e
-      message = "You have an error in your config file #{config_file_path}\n\n"
-      message << "#{e.class.name}: #{e.message}\n"
-      filtered_trace = e.backtrace.grep(/#{Regexp.escape(config_file_path)}/)
-      filtered_trace.each {|bt_line| message << "  " << bt_line << "\n" }
-      if !filtered_trace.empty?
-        line_nr = filtered_trace.first[/#{Regexp.escape(config_file_path)}:([\d]+)/, 1]
-        message << highlight_config_error(config_file_path, line_nr.to_i)
-      end
-      raise Exceptions::ConfigurationError, message
-    end
-
-
-    def highlight_config_error(file, line)
-      config_file_lines = []
-      IO.readlines(file).each_with_index {|l, i| config_file_lines << "#{(i + 1).to_s.rjust(3)}: #{l.chomp}"}
-      if line == 1
-        lines = config_file_lines[0..3]
-      else
-        lines = config_file_lines[Range.new(line - 2, line)]
-      end
-      "Relevant file content:\n" + lines.join("\n") + "\n"
-    end
-
-    def logger
-      @logger
-    end
-
-  end
+  WorkstationConfigLoader = ChefConfig::WorkstationConfigLoader
 end

data/spec/data/cookbooks/openldap/templates/default/helpers.erb

@@ -0,0 +1,14 @@
+<%= @cookbook_name %>
+<%= @recipe_name %>
+<%= @recipe_line_string %>
+<%= @recipe_path %>
+<%= @recipe_line %>
+<%= @template_name %>
+<%= @template_path %>
+<%= cookbook_name %>
+<%= recipe_name %>
+<%= recipe_line_string %>
+<%= recipe_path %>
+<%= recipe_line %>
+<%= template_name %>
+<%= template_path %>

data/spec/data/cookbooks/openldap/templates/default/nested_openldap_partials.erb

@@ -0,0 +1 @@
+before <%= render 'nested_partial.erb', :variables => { :hello => @test } %> after

data/spec/data/cookbooks/openldap/templates/default/nested_partial.erb

@@ -0,0 +1 @@
+{<%= @hello %>}

data/spec/data/run_context/cookbooks/include/recipes/default.rb

@@ -0,0 +1,24 @@
+module ::RanResources
+  def self.resources
+    @resources ||= []
+  end
+end
+class RunContextCustomResource < Chef::Resource
+  action :create do
+    ruby_block '4' do
+      block { RanResources.resources << 4 }
+    end
+    recipe_eval do
+      ruby_block '1' do
+        block { RanResources.resources << 1 }
+      end
+      include_recipe 'include::includee'
+      ruby_block '3' do
+        block { RanResources.resources << 3 }
+      end
+    end
+    ruby_block '5' do
+      block { RanResources.resources << 5 }
+    end
+  end
+end

data/spec/data/run_context/cookbooks/include/recipes/includee.rb

@@ -0,0 +1,3 @@
+ruby_block '2' do
+  block { RanResources.resources << 2 }
+end

data/spec/functional/dsl/reboot_pending_spec.rb

@@ -30,13 +30,6 @@ describe Chef::DSL::RebootPending, :windows_only do
     ohai
   end
 
-  def registry_unsafe?
-    registry.value_exists?('HKLM\SYSTEM\CurrentControlSet\Control\Session Manager', { :name => 'PendingFileRenameOperations' }) ||
-    registry.key_exists?('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired')
-    registry.key_exists?('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootRequired') ||
-    registry.key_exists?('HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile')
-  end
-
   let(:node) { Chef::Node.new }
   let(:events) { Chef::EventDispatch::Dispatcher.new }
   let!(:ohai) { run_ohai } # Ensure we have necessary node data
@@ -45,76 +38,73 @@ describe Chef::DSL::RebootPending, :windows_only do
   let(:registry) { Chef::Win32::Registry.new(run_context) }
 
   describe "reboot_pending?" do
+    let(:reg_key) { nil }
+    let(:original_set) { false }
 
-    describe "when there is nothing to indicate a reboot is pending" do
-      it "should return false" do
-        skip "Found existing registry keys" if registry_unsafe?
-        expect(recipe.reboot_pending?).to be_falsey
-      end
-    end
+    before(:all) { @any_flag = Hash.new }
+
+    after { @any_flag[reg_key] = original_set }
 
     describe 'HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\PendingFileRenameOperations' do
+      let(:reg_key) { 'HKLM\SYSTEM\CurrentControlSet\Control\Session Manager' }
+      let(:original_set) { registry.value_exists?(reg_key, { :name => 'PendingFileRenameOperations' }) }
+
       it "returns true if the registry value exists" do
-        skip "Found existing registry keys" if registry_unsafe?
-        registry.set_value('HKLM\SYSTEM\CurrentControlSet\Control\Session Manager',
+        skip 'found existing registry key' if original_set
+        registry.set_value(reg_key,
             { :name => 'PendingFileRenameOperations', :type => :multi_string, :data => ['\??\C:\foo.txt|\??\C:\bar.txt'] })
 
         expect(recipe.reboot_pending?).to be_truthy
       end
 
       after do
-        unless registry_unsafe?
-          registry.delete_value('HKLM\SYSTEM\CurrentControlSet\Control\Session Manager', { :name => 'PendingFileRenameOperations' })
+        unless original_set
+          registry.delete_value(reg_key, { :name => 'PendingFileRenameOperations' })
         end
       end
     end
 
-    describe 'HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired' do
+    describe 'HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootRequired' do
+      let(:reg_key) { 'HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootRequired' }
+      let(:original_set) { registry.key_exists?(reg_key) }
+
       it "returns true if the registry key exists" do
-        skip "Found existing registry keys" if registry_unsafe?
-        registry.create_key('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired', false)
+        skip 'found existing registry key' if original_set
+        pending "Permissions are limited to 'TrustedInstaller' by default"
+        registry.create_key(reg_key, false)
 
         expect(recipe.reboot_pending?).to be_truthy
       end
 
       after do
-        unless registry_unsafe?
-          registry.delete_key('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired', false)
+        unless original_set
+          registry.delete_key(reg_key, false)
         end
       end
     end
 
-    describe 'HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootRequired' do
+    describe 'HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired' do
+      let(:reg_key) { 'HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired' }
+      let(:original_set) { registry.key_exists?(reg_key) }
+
       it "returns true if the registry key exists" do
-        pending "Permissions are limited to 'TrustedInstaller' by default"
-        skip "Found existing registry keys" if registry_unsafe?
-        registry.create_key('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootRequired', false)
+        skip 'found existing registry key' if original_set
+        registry.create_key(reg_key, false)
 
         expect(recipe.reboot_pending?).to be_truthy
       end
 
       after do
-        unless registry_unsafe?
-          registry.delete_key('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootRequired', false)
+        unless original_set
+          registry.delete_key(reg_key, false)
         end
       end
     end
 
-    describe 'HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile\Flags' do
-      it "returns true if the registry key exists" do
-        skip "Found existing registry keys" if registry_unsafe?
-        registry.create_key('HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile', true)
-        registry.set_value('HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile',
-                    { :name => 'Flags', :type => :dword, :data => 3 })
-
-        expect(recipe.reboot_pending?).to be_truthy
-      end
-
-      after do
-        unless registry_unsafe?
-          registry.delete_value('HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile', { :name => 'Flags' })
-          registry.delete_key('HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile', false)
-        end
+    describe "when there is nothing to indicate a reboot is pending" do
+      it "should return false" do
+        skip 'reboot pending' if @any_flag.any? { |_,v| v == true }
+        expect(recipe.reboot_pending?).to be_falsey
       end
     end
   end