chef 11.4.4 → 11.6.0.hotfix.1

data/lib/chef/log.rb

@@ -18,6 +18,7 @@
 # limitations under the License.
 
 require 'logger'
+require 'chef/monologger'
 require 'mixlib/log'
 
 class Chef
@@ -25,8 +26,7 @@ class Chef
     extend Mixlib::Log
 
     # Force initialization of the primary log device (@logger)
-    init
-
+    init(MonoLogger.new(STDOUT))
 
     class Formatter
       def self.show_time=(*args)

data/lib/chef/mixin/file_class.rb

@@ -25,15 +25,6 @@ class Chef
       def file_class
         @host_os_file ||= if Chef::Platform.windows?
           require 'chef/win32/file'
-          begin
-            Chef::ReservedNames::Win32::File.verify_links_supported!
-          rescue Chef::Exceptions::Win32APIFunctionNotImplemented => e
-            message = "Link resource is not supported on this version of Windows"
-            message << ": #{node[:kernel][:name]}" if node
-            message << " (#{node[:platform_version]})" if node
-            Chef::Log.fatal(message)
-            raise e
-          end
           Chef::ReservedNames::Win32::File
         else
           ::File

data/lib/chef/mixin/language_include_recipe.rb

@@ -23,7 +23,7 @@ class Chef
   module Mixin
 
     deprecate_constant(:LanguageIncludeRecipe, Chef::DSL::IncludeRecipe, <<-EOM)
-Chef::Mixin::LanguageIncludeRecipe is deprecated, use Chef::DSL::Recipe
+Chef::Mixin::LanguageIncludeRecipe is deprecated, use Chef::DSL::IncludeRecipe
 instead.
 EOM
 

data/lib/chef/mixin/params_validate.rb

@@ -16,7 +16,8 @@
 # limitations under the License.
 
 class Chef
-  
+  class DelayedEvaluator < Proc
+  end
   module Mixin
     module ParamsValidate
       
@@ -75,18 +76,27 @@ class Chef
         end
         opts
       end
-          
+      
+      def lazy(&block)
+        DelayedEvaluator.new(&block)
+      end
+
       def set_or_return(symbol, arg, validation)
         iv_symbol = "@#{symbol.to_s}".to_sym
-        map = {
-          symbol => validation
-        }
-
         if arg == nil && self.instance_variable_defined?(iv_symbol) == true
-          self.instance_variable_get(iv_symbol)
+          ivar = self.instance_variable_get(iv_symbol)
+          if(ivar.is_a?(DelayedEvaluator))
+            validate({ symbol => ivar.call }, { symbol => validation })[symbol]
+          else
+            ivar
+          end
         else
-          opts = validate({ symbol => arg }, { symbol => validation })
-          self.instance_variable_set(iv_symbol, opts[symbol])
+          if(arg.is_a?(DelayedEvaluator))
+            val = arg
+          else
+            val = validate({ symbol => arg }, { symbol => validation })[symbol]
+          end
+          self.instance_variable_set(iv_symbol, val)
         end
       end
             

data/lib/chef/mixin/template.rb

@@ -6,9 +6,9 @@
 # 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.
@@ -22,8 +22,52 @@ require 'erubis'
 class Chef
   module Mixin
     module Template
-      
+
+      # A compatibility wrapper around IO.binread so it works on Ruby 1.8.7.
+      # --
+      # Used in the TemplateContext class, but that method namespace is shared
+      # with user code, so we want to avoid adding methods there when possible.
+      def self.binread(file)
+        if IO.respond_to?(:binread)
+          IO.binread(file)
+        else
+          File.open(file, "rb") {|f| f.read }
+        end
+      end
+
+      # == ChefContext
+      # ChefContext was previously used to mix behavior into Erubis::Context so
+      # that it would be available to templates. This behavior has now moved to
+      # TemplateContext, but this module is still mixed in to the
+      # TemplateContext class so that any user code that modified ChefContext
+      # will continue to work correctly.
       module ChefContext
+      end
+
+      # == TemplateContext
+      # TemplateContext is the base context class for all templates in Chef. It
+      # defines user-facing extensions to the base Erubis::Context to provide
+      # enhanced features. Individual instances of TemplateContext can be
+      # extended to add logic to a specific template.
+      #
+      class TemplateContext < Erubis::Context
+
+        include ChefContext
+
+        attr_reader :_extension_modules
+
+        def initialize(variables)
+          super
+          @_extension_modules = []
+        end
+
+        ###
+        # USER FACING API
+        ###
+
+        # Returns the current node object, or raises an error if it's not set.
+        # Provides API consistency, allowing users to reference the node object
+        # by the bare `node` everywhere.
         def node
           return @node if @node
           raise "Could not find a value for node. If you are explicitly setting variables in a template, " +
@@ -56,59 +100,105 @@ class Chef
         def render(partial_name, options = {})
           raise "You cannot render partials in this context" unless @template_finder
 
-          if variables = options.delete(:variables)
-            context = {}
-            context.merge!(variables)
-            context[:node] = @node
-            context[:template_finder] = @template_finder
-          else
-            context = self.dup
-          end
+          partial_variables = options.delete(:variables) || _public_instance_variables
+          partial_context = self.class.new(partial_variables)
+          partial_context._extend_modules(@_extension_modules)
 
           template_location = @template_finder.find(partial_name, options)
-          eruby = Erubis::Eruby.new(IO.read(template_location))
-          output = eruby.evaluate(context)
+          _render_template(Mixin::Template.binread(template_location), partial_context)
         end
-      end
-      
-      ::Erubis::Context.send(:include, ChefContext)
-      
-      # Render a template with Erubis.  Takes a template as a string, and a 
-      # context hash.  
-      def render_template(template, context)
-        begin
-          eruby = Erubis::Eruby.new(template)
-          output = eruby.evaluate(context)
-        rescue Object => e
-          raise TemplateError.new(e, template, context)
+
+        def render_template(template_location)
+          _render_template(Mixin::Template.binread(template_location), self)
+        end
+
+        def render_template_from_string(template)
+          _render_template(template, self)
+        end
+
+        ###
+        # INTERNAL PUBLIC API
+        ###
+
+        def _render_template(template, context)
+          # CHEF-2991
+          # Erubis always emits unix line endings during template
+          # rendering. This results in automatic conversion of windows
+          # line endings to linux line endings if the original template
+          # contains windows line endings. In order to fix this we
+          # determine the line ending style of the template before
+          # rendering and convert the line endings of the output if needed
+          # If template contains any windows line endings we emit
+          # the template result with windows line endings.
+          windows_line_endings = template.include? "\r\n"
+
+          begin
+            eruby = Erubis::Eruby.new(template)
+            output = eruby.evaluate(context)
+          rescue Object => e
+            raise TemplateError.new(e, template, context)
+          end
+
+          if windows_line_endings
+            # Convert line endings from "\n" -> "\r\n". Also converts
+            # "\r\n" -> "\r\n".
+            # This makes the regex match on all of "\r\n", so we don't
+            # accidentally convert "\r\n" -> "\r\r\n".
+            output = output.gsub(/\r?\n/,"\r\n")
+          end
+
+          output
+        end
+
+        def _extend_modules(module_names)
+          module_names.each do |mod|
+            context_methods = [:node, :render, :render_template, :render_template_from_string]
+            context_methods.each do |core_method|
+              if mod.method_defined?(core_method) or mod.private_method_defined?(core_method)
+                Chef::Log.warn("Core template method `#{core_method}' overridden by extension module #{mod}")
+              end
+            end
+            extend(mod)
+            @_extension_modules << mod
+          end
         end
-        Tempfile.open("chef-rendered-template") do |tempfile|
-          tempfile.print(output)
-          tempfile.close
-          yield tempfile
+
+        # Collects instance variables set on the current object as a Hash
+        # suitable for creating a new TemplateContext. Instance variables that
+        # are only valid for this specific instance are omitted from the
+        # collection.
+        def _public_instance_variables
+          all_ivars = instance_variables
+          all_ivars.delete(:@_extension_modules)
+          all_ivars.inject({}) do |ivar_map, ivar_symbol_name|
+            value = instance_variable_get(ivar_symbol_name)
+            name_without_at = ivar_symbol_name.to_s[1..-1].to_sym
+            ivar_map[name_without_at] = value
+            ivar_map
+          end
         end
       end
-      
+
       class TemplateError < RuntimeError
         attr_reader :original_exception, :context
         SOURCE_CONTEXT_WINDOW = 2
-        
+
         def initialize(original_exception, template, context)
           @original_exception, @template, @context = original_exception, template, context
         end
-        
+
         def message
           @original_exception.message
         end
-        
+
         def line_number
           @line_number ||= $1.to_i if original_exception.backtrace.find {|line| line =~ /\(erubis\):(\d+)/ }
         end
-        
+
         def source_location
           "on line ##{line_number}"
         end
-        
+
         def source_listing
           @source_listing ||= begin
             lines = @template.split(/\n/)
@@ -129,7 +219,7 @@ class Chef
             output.join("\n")
           end
         end
-        
+
         def to_s
           "\n\n#{self.class} (#{message}) #{source_location}:\n\n" +
             "#{source_listing}\n\n  #{original_exception.backtrace.join("\n  ")}\n\n"

data/lib/chef/mixin/windows_architecture_helper.rb

@@ -0,0 +1,91 @@
+#
+# 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/exceptions' 
+require 'win32/api' if Chef::Platform.windows?
+
+class Chef
+  module Mixin
+    module WindowsArchitectureHelper
+
+      def node_windows_architecture(node)
+        node[:kernel][:machine].to_sym
+      end
+
+      def wow64_architecture_override_required?(node, desired_architecture)
+        is_i386_windows_process? &&
+          node_windows_architecture(node) == :x86_64 &&
+          desired_architecture == :x86_64
+      end          
+
+      def node_supports_windows_architecture?(node, desired_architecture)
+        assert_valid_windows_architecture!(desired_architecture)
+        return (node_windows_architecture(node) == :x86_64 ||
+                desired_architecture == :i386) ? true : false
+      end
+
+      def valid_windows_architecture?(architecture)
+        return (architecture == :x86_64) || (architecture == :i386)
+      end
+
+      def assert_valid_windows_architecture!(architecture)
+        if ! valid_windows_architecture?(architecture)
+          raise Chef::Exceptions::Win32ArchitectureIncorrect,
+          "The specified architecture was not valid. It must be one of :i386 or :x86_64"
+        end
+      end
+
+      def is_i386_windows_process?
+        Chef::Platform.windows? && 'X86'.casecmp(ENV['PROCESSOR_ARCHITECTURE']) == 0
+      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
+
+        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
+        end
+      end
+      
+    end
+  end
+end

data/lib/chef/monkey_patches/file.rb

@@ -0,0 +1,26 @@
+#
+# Author:: Daniel DeLeo (<dan@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.
+#
+
+if !File.respond_to?(:realpath)
+  require 'pathname'
+  class File
+    def self.realpath(path)
+      Pathname.new(path).realpath.to_s
+    end
+  end
+end

data/lib/chef/monkey_patches/net-ssh-multi.rb

@@ -0,0 +1,140 @@
+#
+# Author:: Serdar Sutay (<serdar@opscode.com>)
+# Copyright:: Copyright (c) 2012 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.
+#
+
+# == net-ssh-multi gem patch for concurrency
+# net-ssh-multi gem has 2 bugs associated with the use of
+# :concurrent_connections option.
+# 1-) There is a race condition while fetching the next_session when
+# :concurrent_connections are set. @open_connections is being
+# incremented by the connection thread and sometimes
+# realize_pending_connections!() method can create more than required
+# connection threads before the @open_connections is set by the
+# previously created threads.
+# 2-) When :concurrent_connections is set, server classes are setup
+# with PendingConnection objects that always return true to busy?
+# calls. If a connection fails when :concurrent_connections is set,
+# server ends up returning true to all busy? calls since the session
+# object is not replaced. Due to this, main event loop (process()
+# function) never gets terminated.
+#
+# See: https://github.com/net-ssh/net-ssh-multi/pull/4
+
+require 'net/ssh/multi/version'
+
+if Net::SSH::Multi::Version::STRING == "1.1.0" || Net::SSH::Multi::Version::STRING == "1.2.0"
+
+  require 'net/ssh/multi'
+
+  module Net
+    module SSH
+      module Multi
+        class Server
+
+          # Make sure that server returns false if the ssh connection
+          # has failed.
+          def busy?(include_invisible=false)
+            !failed? && session && session.busy?(include_invisible)
+          end
+
+        end
+
+        class Session
+          def next_session(server, force=false) #:nodoc:
+            # don't retry a failed attempt
+            return nil if server.failed?
+
+            @session_mutex.synchronize do
+              if !force && concurrent_connections && concurrent_connections <= open_connections
+                connection = PendingConnection.new(server)
+                @pending_sessions << connection
+                return connection
+              end
+
+              # ===== PATCH START
+              # Only increment the open_connections count if the connection
+              # is not being forced. Incase of a force, it will already be
+              # incremented.
+              if !force
+                @open_connections += 1
+              end
+              # ===== PATCH END
+            end
+
+            begin
+              server.new_session
+
+              # I don't understand why this should be necessary--StandardError is a
+              # subclass of Exception, after all--but without explicitly rescuing
+              # StandardError, things like Errno::* and SocketError don't get caught
+              # here!
+            rescue Exception, StandardError => e
+              server.fail!
+              @session_mutex.synchronize { @open_connections -= 1 }
+
+              case on_error
+              when :ignore then
+                # do nothing
+              when :warn then
+                warn("error connecting to #{server}: #{e.class} (#{e.message})")
+              when Proc then
+                go = catch(:go) { on_error.call(server); nil }
+                case go
+                when nil, :ignore then # nothing
+                when :retry then retry
+                when :raise then raise
+                else warn "unknown 'go' command: #{go.inspect}"
+                end
+              else
+                raise
+              end
+
+              return nil
+            end
+          end
+
+          def realize_pending_connections! #:nodoc:
+            return unless concurrent_connections
+
+            server_list.each do |server|
+              server.close if !server.busy?(true)
+              server.update_session!
+            end
+
+            @connect_threads.delete_if { |t| !t.alive? }
+
+            count = concurrent_connections ? (concurrent_connections - open_connections) : @pending_sessions.length
+            count.times do
+              session = @pending_sessions.pop or break
+              # ===== PATCH START
+              # Increment the open_connections count here to prevent
+              # creation of connection thread again before that is
+              # incremented by the thread.
+              @session_mutex.synchronize { @open_connections += 1 }
+              # ===== PATCH END
+              @connect_threads << Thread.new do
+                session.replace_with(next_session(session.server, true))
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+
+end