chef 11.14.0.alpha.4-x86-mingw32 → 11.14.0.rc.2-x86-mingw32

data/lib/chef/knife/ssh.rb

@@ -170,12 +170,16 @@ class Chef
           # if a command line attribute was not passed, and we have a
           # cloud public_hostname, use that.  see #configure_attribute
           # for the source of config[:attribute] and
-          # config[:override_attribute]
-          if config[:override_attribute]
-            host = extract_nested_value(item, config[:override_attribute])
+          # config[:attribute_from_cli]
+          if config[:attribute_from_cli]
+            Chef::Log.debug("Using node attribute '#{config[:attribute_from_cli]}' from the command line as the ssh target")
+            host = extract_nested_value(item, config[:attribute_from_cli])
           elsif item[:cloud] && item[:cloud][:public_hostname]
+            Chef::Log.debug("Using node attribute 'cloud[:public_hostname]' automatically as the ssh target")
             host = item[:cloud][:public_hostname]
           else
+            # ssh attribute from a configuration file or the default will land here
+            Chef::Log.debug("Using node attribute '#{config[:attribute]}' as the ssh target")
             host = extract_nested_value(item, config[:attribute])
           end
           # next if we couldn't find the specified attribute in the
@@ -413,10 +417,8 @@ class Chef
         # Thus we can differentiate between a config file value and a command line override at this point by checking config[:attribute]
         # We can tell here if fqdn was passed from the command line, rather than being the default, by checking config[:attribute]
         # However, after here, we cannot tell these things, so we must preserve config[:attribute]
-        config[:override_attribute] = config[:attribute] || Chef::Config[:knife][:ssh_attribute]
-        config[:attribute] = (Chef::Config[:knife][:ssh_attribute] ||
-                              config[:attribute] ||
-                              "fqdn").strip
+        config[:attribute_from_cli] = config[:attribute]
+        config[:attribute] = (config[:attribute_from_cli] || Chef::Config[:knife][:ssh_attribute] || "fqdn").strip
       end
 
       def cssh
@@ -431,6 +433,11 @@ class Chef
         end
         raise Chef::Exceptions::Exec, "no command found for cssh" unless cssh_cmd
 
+        # pass in the consolidated itentity file option to cssh(X)
+        if config[:identity_file]
+          cssh_cmd << " --ssh_args '-i #{File.expand_path(config[:identity_file])}'"
+        end
+
         session.servers_for.each do |server|
           cssh_cmd << " #{server.user ? "#{server.user}@#{server.host}" : server.host}"
         end

data/lib/chef/mixin/convert_to_class_name.rb

@@ -25,6 +25,7 @@ class Chef
       def convert_to_class_name(str)
         str = str.dup
         str.gsub!(/[^A-Za-z0-9_]/,'_')
+        str.gsub!(/^(_+)?/,'')
         rname = nil
         regexp = %r{^(.+?)(_(.+))?$}
 

data/lib/chef/mixin/windows_architecture_helper.rb

@@ -19,19 +19,26 @@
 
 require 'chef/exceptions'
 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?
 
 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
 
       def wow64_architecture_override_required?(node, desired_architecture)
-        is_i386_windows_process? &&
+        desired_architecture == :x86_64 &&
           node_windows_architecture(node) == :x86_64 &&
-          desired_architecture == :x86_64
+          is_i386_process_on_x86_64_windows?
       end
 
       def node_supports_windows_architecture?(node, desired_architecture)
@@ -51,8 +58,21 @@ class Chef
         end
       end
 
-      def is_i386_windows_process?
-        Chef::Platform.windows? && 'X86'.casecmp(ENV['PROCESSOR_ARCHITECTURE']) == 0
+      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)
+        else
+          false
+        end
       end
 
       def disable_wow64_file_redirection( node )

data/lib/chef/platform/provider_mapping.rb

@@ -72,6 +72,11 @@ class Chef
               ">= 11.10" => {
                 :ifconfig => Chef::Provider::Ifconfig::Debian
               }
+              # Chef::Provider::Service::Upstart is a candidate to be used in
+              # ubuntu versions >= 13.10 but it currently requires all the
+              # services to have an entry under /etc/init. We need to update it
+              # to use the service ctl apis in order to migrate to using it on
+              # ubuntu >= 13.10.
             },
             :gcel   => {
               :default => {
@@ -363,6 +368,14 @@ class Chef
                 :package => Chef::Provider::Package::Aix
               }
             },
+            :exherbo => {
+              :default => {
+                :package => Chef::Provider::Package::Paludis,
+                :service => Chef::Provider::Service::Systemd,
+                :cron => Chef::Provider::Cron,
+                :mdadm => Chef::Provider::Mdadm
+              }
+            },
             :default => {
               :file => Chef::Provider::File,
               :directory => Chef::Provider::Directory,

data/lib/chef/provider/env/windows.rb

@@ -16,14 +16,13 @@
 # limitations under the License.
 #
 
-if RUBY_PLATFORM =~ /mswin|mingw32|windows/
-  require 'Win32API'
-end
+require 'chef/win32/api/system' if RUBY_PLATFORM =~ /mswin|mingw32|windows/
 
 class Chef
   class Provider
     class Env
       class Windows < Chef::Provider::Env
+        include Chef::ReservedNames::Win32::API::System if RUBY_PLATFORM =~ /mswin|mingw32|windows/
 
         def create_env
           obj = env_obj(@new_resource.key_name)
@@ -73,10 +72,8 @@ class Chef
         SMTO_NOTIMEOUTIFNOTHUNG = 0x0008
 
         def broadcast_env_change
-          result = 0
           flags = SMTO_BLOCK | SMTO_ABORTIFHUNG | SMTO_NOTIMEOUTIFNOTHUNG
-          @send_message ||= Win32API.new('user32', 'SendMessageTimeout', 'LLLPLLP', 'L')
-          @send_message.call(HWND_BROADCAST, WM_SETTINGCHANGE, 0, 'Environment', flags, 5000, result)
+          SendMessageTimeoutA(HWND_BROADCAST, WM_SETTINGCHANGE, 0, FFI::MemoryPointer.from_string('Environment').address, flags, 5000, nil)
         end
       end
     end

data/lib/chef/provider/git.rb

@@ -95,8 +95,7 @@ class Chef
 
       def action_sync
         if existing_git_clone?
-          current_rev = find_current_revision
-          Chef::Log.debug "#{@new_resource} current revision: #{current_rev} target revision: #{target_revision}"
+          Chef::Log.debug "#{@new_resource} current revision: #{@current_resource.revision} target revision: #{target_revision}"
           unless current_revision_matches_target_revision?
             fetch_updates
             enable_submodules

data/lib/chef/provider/log.rb

@@ -25,6 +25,9 @@ class Chef
       # Chef log provider, allows logging to chef's logs from recipes
       class ChefLog < Chef::Provider
 
+        # ordered array of the log levels
+        @@levels = [ :debug, :info, :warn, :error, :fatal ]
+
         # No concept of a 'current' resource for logs, this is a no-op
         #
         # === Return
@@ -39,7 +42,18 @@ class Chef
         # true:: Always return true
         def action_write
           Chef::Log.send(@new_resource.level, @new_resource.message)
-          @new_resource.updated_by_last_action(true)
+
+          # resolve the integers for the current log levels
+          global_level = Mixlib::Log::LEVELS.fetch(Chef::Log.level)
+          resource_level = Mixlib::Log::LEVELS.fetch(@new_resource.level)
+
+          # If the resource level is greater than or the same os the global
+          # level, then it should have been written to the log.  Mark the
+          # resource as updated.
+          if resource_level >= global_level
+            @new_resource.updated_by_last_action(true)
+          end
+
         end
 
       end

data/lib/chef/provider/package/apt.rb

@@ -55,7 +55,7 @@ class Chef
           Chef::Log.debug("#{@new_resource} checking package status for #{package}")
           installed = false
 
-          shell_out!("apt-cache#{expand_options(default_release_options)} policy #{package}").stdout.each_line do |line|
+          shell_out!("apt-cache#{expand_options(default_release_options)} policy #{package}", :timeout => @new_resource.timeout).stdout.each_line do |line|
             case line
             when /^\s{2}Installed: (.+)$/
               installed_version = $1
@@ -72,7 +72,7 @@ class Chef
               if candidate_version == '(none)'
                 # This may not be an appropriate assumption, but it shouldn't break anything that already worked -- btm
                 @is_virtual_package = true
-                showpkg = shell_out!("apt-cache showpkg #{package}").stdout
+                showpkg = shell_out!("apt-cache showpkg #{package}", :timeout => @new_resource.timeout).stdout
                 providers = Hash.new
                 # Returns all lines after 'Reverse Provides:'
                 showpkg.rpartition(/Reverse Provides:\s*#{$/}/)[2].each_line do |line|
@@ -132,7 +132,7 @@ class Chef
         # interactive prompts. Command is run with default localization rather
         # than forcing locale to "C", so command output may not be stable.
         def run_noninteractive(command)
-          shell_out!(command, :env => { "DEBIAN_FRONTEND" => "noninteractive", "LC_ALL" => nil })
+          shell_out!(command, :env => { "DEBIAN_FRONTEND" => "noninteractive", "LC_ALL" => nil }, :timeout => @new_resource.timeout)
         end
 
       end

data/lib/chef/provider/package/dpkg.rb

@@ -24,13 +24,14 @@ require 'chef/mixin/get_source_from_package'
 class Chef
   class Provider
     class Package
-      class Dpkg < Chef::Provider::Package::Apt
+      class Dpkg < Chef::Provider::Package
         # http://www.debian.org/doc/debian-policy/ch-controlfields.html#s-f-Version
         DPKG_INFO = /([a-z\d\-\+\.]+)\t([\w\d.~:-]+)/
         DPKG_INSTALLED = /^Status: install ok installed/
         DPKG_VERSION = /^Version: (.+)$/
 
         include Chef::Mixin::GetSourceFromPackage
+
         def define_resource_requirements
           super
           requirements.assert(:install) do |a|
@@ -98,31 +99,49 @@ class Chef
         end
 
         def install_package(name, version)
-          run_command_with_systems_locale(
-            :command => "dpkg -i#{expand_options(@new_resource.options)} #{@new_resource.source}",
-            :environment => {
-              "DEBIAN_FRONTEND" => "noninteractive"
-            }
+          Chef::Log.info("#{@new_resource} installing #{@new_resource.source}")
+          run_noninteractive(
+            "dpkg -i#{expand_options(@new_resource.options)} #{@new_resource.source}"
           )
         end
 
         def remove_package(name, version)
-          run_command_with_systems_locale(
-            :command => "dpkg -r#{expand_options(@new_resource.options)} #{@new_resource.package_name}",
-            :environment => {
-              "DEBIAN_FRONTEND" => "noninteractive"
-            }
+          Chef::Log.info("#{@new_resource} removing #{@new_resource.package_name}")
+          run_noninteractive(
+            "dpkg -r#{expand_options(@new_resource.options)} #{@new_resource.package_name}"
           )
         end
 
         def purge_package(name, version)
-          run_command_with_systems_locale(
-            :command => "dpkg -P#{expand_options(@new_resource.options)} #{@new_resource.package_name}",
-            :environment => {
-              "DEBIAN_FRONTEND" => "noninteractive"
-            }
+          Chef::Log.info("#{@new_resource} purging #{@new_resource.package_name}")
+          run_noninteractive(
+            "dpkg -P#{expand_options(@new_resource.options)} #{@new_resource.package_name}"
           )
         end
+
+        def upgrade_package(name, version)
+          install_package(name, version)
+        end
+
+        def preseed_package(preseed_file)
+          Chef::Log.info("#{@new_resource} pre-seeding package installation instructions")
+          run_noninteractive("debconf-set-selections #{preseed_file}")
+        end
+
+        def reconfig_package(name, version)
+          Chef::Log.info("#{@new_resource} reconfiguring")
+          run_noninteractive("dpkg-reconfigure #{name}")
+        end
+
+        # Runs command via shell_out with magic environment to disable
+        # interactive prompts. Command is run with default localization rather
+        # than forcing locale to "C", so command output may not be stable.
+        #
+        # FIXME: This should be "LC_ALL" => "en_US.UTF-8" in order to stabilize the output and get UTF-8
+        def run_noninteractive(command)
+          shell_out!(command, :env => { "DEBIAN_FRONTEND" => "noninteractive", "LC_ALL" => nil })
+        end
+
       end
     end
   end

data/lib/chef/provider/package/paludis.rb

@@ -0,0 +1,91 @@
+#
+# Author:: Vasiliy Tolstov (<v.tolstov@selfip.ru>)
+# Copyright:: Copyright (c) 2014 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/provider/package'
+require 'chef/resource/package'
+require 'chef/mixin/shell_out'
+
+class Chef
+  class Provider
+    class Package
+      class Paludis < Chef::Provider::Package
+
+        include Chef::Mixin::ShellOut
+
+        def load_current_resource
+          @current_resource = Chef::Resource::Package.new(@new_resource.package_name)
+          @current_resource.package_name(@new_resource.package_name)
+
+          @current_resource.version(nil)
+
+          Chef::Log.debug("Checking package status for #{@new_resource.package_name}")
+          installed = false
+          re = Regexp.new('(.*)[[:blank:]](.*)[[:blank:]](.*)$')
+
+          shell_out!("cave -L warning print-ids -m \"*/#{@new_resource.package_name.split('/').last}\" -f \"%c/%p %v %r\n\"").stdout.each_line do |line|
+            res = re.match(line)
+            unless res.nil?
+              case res[3]
+              when 'accounts', 'installed-accounts'
+                next
+              when 'installed'
+                installed = true
+                @current_resource.version(res[2])
+              else
+                @candidate_version = res[2]
+                @current_resource.version(nil)              
+              end
+            end
+          end
+
+          @current_resource
+        end
+
+        def install_package(name, version)
+          if(version)
+            pkg = "=#{name}-#{version}"
+          else
+            pkg = "#{@new_resource.package_name}"
+          end
+          shell_out!("cave -L warning resolve -x#{expand_options(@new_resource.options)} \"#{pkg}\"")
+        end
+
+        def upgrade_package(name, version)
+          install_package(name, version)
+        end
+
+        def remove_package(name, version)
+          if(version)
+            pkg = "=#{@new_resource.package_name}-#{version}"
+          else
+            pkg = "#{@new_resource.package_name}"
+          end
+
+          shell_out!("cave -L warning uninstall -x#{expand_options(@new_resource.options)} \"#{pkg}\"")
+        end
+
+        def purge_package(name, version)
+          remove_package(name, version)
+        end
+
+      end
+    end
+  end
+end
+
+

data/lib/chef/provider/package/rpm.rb

@@ -60,9 +60,10 @@ class Chef
             status = popen4("rpm -qp --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' #{@new_resource.source}") do |pid, stdin, stdout, stderr|
               stdout.each do |line|
                 case line
-                when /([\w\d_.-]+)\s([\w\d_.-]+)/
+                when /([\w\d+_.-]+)\s([\w\d_.-]+)/
                   @current_resource.package_name($1)
                   @new_resource.version($2)
+                  @candidate_version = $2
                 end
               end
             end
@@ -77,7 +78,7 @@ class Chef
           @rpm_status = popen4("rpm -q --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' #{@current_resource.package_name}") do |pid, stdin, stdout, stderr|
             stdout.each do |line|
               case line
-              when /([\w\d_.-]+)\s([\w\d_.-]+)/
+              when /([\w\d+_.-]+)\s([\w\d_.-]+)/
                 Chef::Log.debug("#{@new_resource} current version is #{$2}")
                 @current_resource.version($2)
               end

data/lib/chef/provider/package/yum-dump.py

@@ -43,9 +43,6 @@ from distutils import version
 
 YUM_PID_FILE='/var/run/yum.pid'
 
-# Seconds to wait for exclusive access to yum
-LOCK_TIMEOUT = 10
-
 YUM_VER = version.StrictVersion(yum.__version__)
 YUM_MAJOR = YUM_VER.version[0]
 
@@ -219,8 +216,8 @@ def yum_dump(options):
   # Wrap the collection and output of packages in yum's global lock to prevent
   # any inconsistencies.
   try:
-    # Spin up to LOCK_TIMEOUT
-    countdown = LOCK_TIMEOUT
+    # Spin up to --yum-lock-timeout option
+    countdown = options.yum_lock_timeout
     while True:
       try:
         yb.doLock(YUM_PID_FILE)
@@ -230,7 +227,7 @@ def yum_dump(options):
         countdown -= 1
         if countdown == 0:
            print >> sys.stderr, "yum-dump Locking Error! Couldn't obtain an " \
-             "exclusive yum lock in %d seconds. Giving up." % LOCK_TIMEOUT
+             "exclusive yum lock in %d seconds. Giving up." % options.yum_lock_timeout
            return 200
       else:
         break
@@ -281,6 +278,9 @@ def main():
   parser.add_option("--disablerepo",
                     action="callback",  callback=gather_repo_opts, type="string", dest="repo_control", default=[],
                     help="disable repositories by id or glob")
+  parser.add_option("--yum-lock-timeout",
+                    action="store",  type="int", dest="yum_lock_timeout", default=30,
+                    help="Time in seconds to wait for yum process lock")
 
   (options, args) = parser.parse_args()