chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

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/mixins.rb

@@ -1,5 +1,4 @@
 require 'chef/mixin/shell_out'
-require 'chef/mixin/check_helper'
 require 'chef/mixin/checksum'
 require 'chef/mixin/command'
 require 'chef/mixin/convert_to_class_name'
@@ -7,12 +6,9 @@ require 'chef/mixin/create_path'
 require 'chef/mixin/deep_merge'
 require 'chef/mixin/enforce_ownership_and_permissions'
 require 'chef/mixin/from_file'
-require 'chef/mixin/language'
-require 'chef/mixin/language_include_attribute'
-require 'chef/mixin/language_include_recipe'
 require 'chef/mixin/params_validate'
 require 'chef/mixin/path_sanity'
-require 'chef/mixin/recipe_definition_dsl_core'
 require 'chef/mixin/template'
 require 'chef/mixin/securable'
 require 'chef/mixin/xml_escape'
+

data/{spec/unit/monkey_patches/uri_spec.rb → lib/chef/monkey_patches/file.rb}

@@ -1,4 +1,4 @@
-#--
+#
 # Author:: Daniel DeLeo (<dan@opscode.com>)
 # Copyright:: Copyright (c) 2013 Opscode, Inc.
 # License:: Apache License, Version 2.0
@@ -16,19 +16,11 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
-describe URI do
-
-  describe "when a URI contains an IPv6 literal" do
-
-    let(:ipv6_uri) do
-      URI.parse("https://[2a00:1450:4009:809::1008]:8443")
+if !File.respond_to?(:realpath)
+  require 'pathname'
+  class File
+    def self.realpath(path)
+      Pathname.new(path).realpath.to_s
     end
-
-    it "returns the hostname without brackets" do
-      ipv6_uri.hostname.should == "2a00:1450:4009:809::1008"
-    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

data/lib/chef/monkey_patches/net_http.rb

@@ -20,37 +20,3 @@ module Net
     include ChefNetHTTPExceptionExtensions
   end
 end
-
-if Net::HTTP.instance_methods.map {|m| m.to_s}.include?("proxy_uri")
-  begin
-    # Ruby 2.0 changes the way proxy support is implemented in Net::HTTP.
-    # The implementation does not work correctly with IPv6 literals because it
-    # concatenates the address into a URI without adding square brackets for
-    # IPv6 addresses.
-    #
-    # If the bug is present, a call to Net::HTTP#proxy_uri when the host is an
-    # IPv6 address will fail by creating an invalid URI, like so:
-    #
-    #    ruby -r'net/http' -e 'Net::HTTP.new("::1", 80).proxy_uri'
-    #    /Users/ddeleo/.rbenv/versions/2.0.0-p247/lib/ruby/2.0.0/uri/generic.rb:214:in `initialize': the scheme http does not accept registry part: ::1:80 (or bad hostname?) (URI::InvalidURIError)
-    #    	from /Users/ddeleo/.rbenv/versions/2.0.0-p247/lib/ruby/2.0.0/uri/http.rb:84:in `initialize'
-    #    	from /Users/ddeleo/.rbenv/versions/2.0.0-p247/lib/ruby/2.0.0/uri/common.rb:214:in `new'
-    #    	from /Users/ddeleo/.rbenv/versions/2.0.0-p247/lib/ruby/2.0.0/uri/common.rb:214:in `parse'
-    #    	from /Users/ddeleo/.rbenv/versions/2.0.0-p247/lib/ruby/2.0.0/uri/common.rb:747:in `parse'
-    #    	from /Users/ddeleo/.rbenv/versions/2.0.0-p247/lib/ruby/2.0.0/uri/common.rb:994:in `URI'
-    #    	from /Users/ddeleo/.rbenv/versions/2.0.0-p247/lib/ruby/2.0.0/net/http.rb:1027:in `proxy_uri'
-    #    	from -e:1:in `<main>'
-    #
-    # https://bugs.ruby-lang.org/issues/9129
-    Net::HTTP.new("::1", 80).proxy_uri
-  rescue URI::InvalidURIError
-    class Net::HTTP
-
-      def proxy_uri # :nodoc:
-        ipv6_safe_addr = address.to_s.include?(":") ? "[#{address}]" : address
-        @proxy_uri ||= URI("http://#{ipv6_safe_addr}:#{port}").find_proxy
-      end
-
-    end
-  end
-end

data/lib/chef/monkey_patches/securerandom.rb

@@ -0,0 +1,44 @@
+#
+# Author:: James Casey <james@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.
+#
+
+# == SecureRandom (Patch)
+# On ruby 1.9, SecureRandom has a uuid method which generates a v4 UUID.  The
+# backport of SecureRandom to 1.8.7 is missing this method
+
+require 'securerandom'
+
+module SecureRandom
+  unless respond_to?(:uuid)
+    # SecureRandom.uuid generates a v4 random UUID (Universally Unique IDentifier).
+    #
+    #   p SecureRandom.uuid #=> "2d931510-d99f-494a-8c67-87feb05e1594"
+    #   p SecureRandom.uuid #=> "bad85eb9-0713-4da7-8d36-07a8e4b00eab"
+    #   p SecureRandom.uuid #=> "62936e70-1815-439b-bf89-8492855a7e6b"
+    #
+    # The version 4 UUID is purely random (except the version).
+    # It doesn't contain meaningful information such as MAC address, time, etc.
+    #
+    # See RFC 4122 for details of UUID.
+    def self.uuid
+      ary = self.random_bytes(16).unpack("NnnnnN")
+      ary[2] = (ary[2] & 0x0fff) | 0x4000
+      ary[3] = (ary[3] & 0x3fff) | 0x8000
+      "%08x-%04x-%04x-%04x-%04x%08x" % ary
+    end
+  end
+end

data/lib/chef/monologger.rb

@@ -0,0 +1,93 @@
+require 'logger'
+
+require 'pp'
+
+#== MonoLogger
+# A subclass of Ruby's stdlib Logger with all the mutex and logrotation stuff
+# ripped out.
+class MonoLogger < Logger
+
+  #
+  # === Synopsis
+  #
+  #   Logger.new(name, shift_age = 7, shift_size = 1048576)
+  #   Logger.new(name, shift_age = 'weekly')
+  #
+  # === Args
+  #
+  # +logdev+::
+  #   The log device.  This is a filename (String) or IO object (typically
+  #   +STDOUT+, +STDERR+, or an open file).
+  # +shift_age+::
+  #   Number of old log files to keep, *or* frequency of rotation (+daily+,
+  #   +weekly+ or +monthly+).
+  # +shift_size+::
+  #   Maximum logfile size (only applies when +shift_age+ is a number).
+  #
+  # === Description
+  #
+  # Create an instance.
+  #
+  def initialize(logdev)
+    @progname = nil
+    @level = DEBUG
+    @default_formatter = Formatter.new
+    @formatter = nil
+    @logdev = nil
+    if logdev
+      @logdev = LocklessLogDevice.new(logdev)
+    end
+  end
+
+
+  class LocklessLogDevice < LogDevice
+
+    def initialize(log = nil)
+      @dev = @filename = @shift_age = @shift_size = nil
+      if log.respond_to?(:write) and log.respond_to?(:close)
+        @dev = log
+      else
+        @dev = open_logfile(log)
+        @dev.sync = true
+        @filename = log
+      end
+    end
+
+    def write(message)
+      @dev.write(message)
+    rescue Exception => ignored
+      warn("log writing failed. #{ignored}")
+    end
+
+    def close
+      @dev.close rescue nil
+    end
+
+  private
+
+    def open_logfile(filename)
+      if (FileTest.exist?(filename))
+        open(filename, (File::WRONLY | File::APPEND))
+      else
+        create_logfile(filename)
+      end
+    end
+
+    def create_logfile(filename)
+      logdev = open(filename, (File::WRONLY | File::APPEND | File::CREAT))
+      logdev.sync = true
+      add_log_header(logdev)
+      logdev
+    end
+
+    def add_log_header(file)
+      file.write(
+        "# Logfile created on %s by %s\n" % [Time.now.to_s, Logger::ProgName]
+      )
+    end
+
+  end
+
+
+end
+