chef 11.14.0.alpha.3-x86-mingw32 → 11.14.0.alpha.4-x86-mingw32

data/lib/chef/application/windows_service.rb

@@ -211,6 +211,7 @@ class Chef
       def reconfigure(startup_parameters=[])
         configure_chef startup_parameters
         configure_logging
+        configure_proxy_environment_variables
 
         Chef::Config[:chef_server_url] = config[:chef_server_url] if config.has_key? :chef_server_url
         unless Chef::Config[:exception_handlers].any? {|h| Chef::Handler::ErrorReport === h}

data/lib/chef/chef_fs/parallelizer/parallel_enumerable.rb

@@ -195,13 +195,15 @@ class Chef
                 process_one
               end
             end
-          ensure
-            # If someone called "first" or something that exits the enumerator
-            # early, we want to make sure and throw away any extra results
-            # (gracefully) so that the next enumerator can start over.
+          rescue
+            # If we exited early, perhaps due to any? finding a result, we want
+            # to make sure and throw away any extra results (gracefully) so that
+            # the next enumerator can start over.
             if !finished?
               stop
             end
+            raise
+          ensure
             @each_running = false
           end
         end

data/lib/chef/config.rb

@@ -324,8 +324,8 @@ class Chef
     config_context :chef_zero do
       config_strict_mode true
       default(:enabled) { Chef::Config.local_mode }
-      default :port, 8889
       default :host, 'localhost'
+      default :port, 8889
     end
     default :chef_server_url,   "https://localhost:443"
 
@@ -363,8 +363,10 @@ class Chef
 
     # Whether or not to verify the SSL cert for HTTPS requests to the Chef
     # server API. If set to `true`, the server's cert will be validated
-    # regardless of the :ssl_verify_mode setting.
-    default :verify_api_cert, false
+    # regardless of the :ssl_verify_mode setting. This is set to `true` when
+    # running in local-mode.
+    # NOTE: This is a workaround until verify_peer is enabled by default.
+    default(:verify_api_cert) { Chef::Config.local_mode }
 
     # Path to the default CA bundle files.
     default :ssl_ca_path, nil

data/lib/chef/exceptions.rb

@@ -329,5 +329,7 @@ class Chef
         super "Unable to acquire lock. Waited #{duration} seconds for #{blocking_pid} to release."
       end
     end
+
+    class BadProxyURI < RuntimeError; end
   end
 end

data/lib/chef/http/basic_client.rb

@@ -98,6 +98,7 @@ class Chef
         end
 
         http_client.read_timeout = config[:rest_timeout]
+        http_client.open_timeout = config[:rest_timeout]
         http_client
       end
 

data/lib/chef/knife.rb

@@ -394,6 +394,7 @@ class Chef
       if Chef::Config.local_mode && !Chef::Config.has_key?(:cookbook_path) && !Chef::Config.has_key?(:chef_repo_path)
         Chef::Config.chef_repo_path = Chef::Config.find_chef_repo_path(Dir.pwd)
       end
+      Chef::Config.chef_zero.host = config[:chef_zero_host] if config[:chef_zero_host]
       Chef::Config.chef_zero.port = config[:chef_zero_port] if config[:chef_zero_port]
 
       # Expand a relative path from the config directory. Config from command

data/lib/chef/platform/provider_mapping.rb

@@ -276,6 +276,7 @@ class Chef
             :solaris  => {},
             :openindiana => {
               :default => {
+                :mount => Chef::Provider::Mount::Solaris,
                 :service => Chef::Provider::Service::Solaris,
                 :package => Chef::Provider::Package::Ips,
                 :cron => Chef::Provider::Cron::Solaris,
@@ -284,6 +285,7 @@ class Chef
             },
             :opensolaris => {
               :default => {
+                :mount => Chef::Provider::Mount::Solaris,
                 :service => Chef::Provider::Service::Solaris,
                 :package => Chef::Provider::Package::Ips,
                 :cron => Chef::Provider::Cron::Solaris,
@@ -292,6 +294,7 @@ class Chef
             },
             :nexentacore => {
               :default => {
+                :mount => Chef::Provider::Mount::Solaris,
                 :service => Chef::Provider::Service::Solaris,
                 :package => Chef::Provider::Package::Solaris,
                 :cron => Chef::Provider::Cron::Solaris,
@@ -300,6 +303,7 @@ class Chef
             },
             :omnios => {
               :default => {
+                :mount => Chef::Provider::Mount::Solaris,
                 :service => Chef::Provider::Service::Solaris,
                 :package => Chef::Provider::Package::Ips,
                 :cron => Chef::Provider::Cron::Solaris,
@@ -309,6 +313,7 @@ class Chef
             },
             :solaris2 => {
               :default => {
+                :mount => Chef::Provider::Mount::Solaris,
                 :service => Chef::Provider::Service::Solaris,
                 :package => Chef::Provider::Package::Ips,
                 :cron => Chef::Provider::Cron::Solaris,
@@ -316,6 +321,7 @@ class Chef
                 :user => Chef::Provider::User::Solaris,
               },
               "< 5.11" => {
+                :mount => Chef::Provider::Mount::Solaris,
                 :service => Chef::Provider::Service::Solaris,
                 :package => Chef::Provider::Package::Solaris,
                 :cron => Chef::Provider::Cron::Solaris,
@@ -325,6 +331,7 @@ class Chef
             },
             :smartos => {
               :default => {
+                :mount => Chef::Provider::Mount::Solaris,
                 :service => Chef::Provider::Service::Solaris,
                 :package => Chef::Provider::Package::SmartOS,
                 :cron => Chef::Provider::Cron::Solaris,

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

@@ -34,6 +34,7 @@ class Chef
           end
           obj.variablevalue = @new_resource.value
           obj.put_
+          ENV[@new_resource.key_name] = @new_resource.value
           broadcast_env_change
         end
 
@@ -41,6 +42,7 @@ class Chef
           obj = env_obj(@new_resource.key_name)
           if obj
             obj.delete_
+            ENV.delete(@new_resource.key_name)
             broadcast_env_change
           end
         end

data/lib/chef/provider/group/usermod.rb

@@ -78,7 +78,7 @@ class Chef
 
         def append_flags
           case node[:platform]
-          when "openbsd", "netbsd", "aix", "solaris2", "smartos"
+          when "openbsd", "netbsd", "aix", "solaris2", "smartos", "omnios"
             "-G"
           when "solaris", "suse", "opensuse"
             "-a -G"

data/lib/chef/provider/mount/solaris.rb

@@ -0,0 +1,233 @@
+#
+# Author:: Hugo Fichter
+# Author:: Lamont Granquist (<lamont@getchef.com>)
+# Author:: Joshua Timberman (<joshua@getchef.com>)
+# Copyright:: Copyright (c) 2009-2014 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/provider/mount'
+require 'chef/log'
+require 'chef/mixin/shell_out'
+require 'forwardable'
+
+class Chef
+  class Provider
+    class Mount
+      class Solaris < Chef::Provider::Mount
+        include Chef::Mixin::ShellOut
+        extend Forwardable
+
+        VFSTAB = "/etc/vfstab".freeze
+
+        def_delegator :@new_resource, :device, :device
+        def_delegator :@new_resource, :device_type, :device_type
+        def_delegator :@new_resource, :dump, :dump
+        def_delegator :@new_resource, :fstype, :fstype
+        def_delegator :@new_resource, :mount_point, :mount_point
+        def_delegator :@new_resource, :options, :options
+        def_delegator :@new_resource, :pass, :pass
+
+        def load_current_resource
+          @current_resource = Chef::Resource::Mount.new(new_resource.name)
+          current_resource.mount_point(mount_point)
+          current_resource.device(device)
+          current_resource.device_type(device_type)
+          update_current_resource_state
+        end
+
+        def define_resource_requirements
+          requirements.assert(:mount, :remount) do |a|
+            a.assertion { !device_should_exist? || ::File.exist?(device) }
+            a.failure_message(Chef::Exceptions::Mount, "Device #{device} does not exist")
+            a.whyrun("Assuming device #{device} would have been created")
+          end
+
+          requirements.assert(:mount, :remount) do |a|
+            a.assertion { ::File.exist?(mount_point) }
+            a.failure_message(Chef::Exceptions::Mount, "Mount point #{mount_point} does not exist")
+            a.whyrun("Assuming mount point #{mount_point} would have been created")
+          end
+        end
+
+        def mount_fs
+          actual_options = options || []
+          actual_options.delete("noauto")
+          command = "mount -F #{fstype}"
+          command << " -o #{actual_options.join(',')}" unless actual_options.empty?
+          command << " #{device} #{mount_point}"
+          shell_out!(command)
+        end
+
+        def umount_fs
+          shell_out!("umount #{mount_point}")
+        end
+
+        def remount_fs
+          # FIXME: what about options like "-o remount,logging" to enable logging on a UFS device?
+          shell_out!("mount -o remount #{mount_point}")
+        end
+
+        def enable_fs
+          if !mount_options_unchanged?
+            # we are enabling because our options have changed, so disable first then re-enable.
+            # XXX: this should be refactored to be the responsibility of the caller
+            disable_fs if current_resource.enabled
+          end
+
+          auto = options.nil? || ! options.include?("noauto")
+          actual_options = unless options.nil?
+                             options.delete("noauto")
+                             options
+                           end
+
+          autostr = auto ? 'yes' : 'no'
+          passstr = pass == 0 ? "-" : pass
+          optstr = (actual_options.nil? || actual_options.empty?) ? "-" : actual_options.join(',')
+
+          etc_tempfile do |f|
+            f.write(IO.read(VFSTAB).chomp)
+            f.puts("\n#{device}\t-\t#{mount_point}\t#{fstype}\t#{passstr}\t#{autostr}\t#{optstr}")
+            f.close
+            # move, preserving modes of destination file
+            mover = Chef::FileContentManagement::Deploy.strategy(true)
+            mover.deploy(f.path, VFSTAB)
+          end
+
+        end
+
+        def disable_fs
+          contents = []
+
+          found = false
+          ::File.readlines(VFSTAB).reverse_each do |line|
+            if !found && line =~ /^#{device_regex}\s+\S+\s+#{Regexp.escape(mount_point)}/
+              found = true
+              Chef::Log.debug("#{new_resource} is removed from vfstab")
+              next
+            end
+            contents << line
+          end
+
+          if found
+            etc_tempfile do |f|
+              f.write(contents.reverse.join(''))
+              f.close
+              # move, preserving modes of destination file
+              mover = Chef::FileContentManagement::Deploy.strategy(true)
+              mover.deploy(f.path, VFSTAB)
+            end
+          else
+            # this is likely some kind of internal error, since we should only call disable_fs when there
+            # the filesystem we want to disable is enabled.
+            Chef::Log.warn("#{new_resource} did not find the mountpoint to disable in the vfstab")
+          end
+        end
+
+        def etc_tempfile
+          yield Tempfile.open("vfstab", "/etc")
+        end
+
+        def mount_options_unchanged?
+          current_resource.fstype == fstype and
+            current_resource.options == options and
+            current_resource.dump == dump and
+            current_resource.pass == pass
+        end
+
+        def update_current_resource_state
+          current_resource.mounted(mounted?)
+          ( enabled, fstype, options, pass ) = read_vfstab_status
+          current_resource.enabled(enabled)
+          current_resource.fstype(fstype)
+          current_resource.options(options)
+          current_resource.pass(pass)
+        end
+
+        def enabled?
+          read_vfstab_status[0]
+        end
+
+        def mounted?
+          mounted = false
+          shell_out!("mount -v").stdout.each_line do |line|
+            # <device> on <mountpoint> type <fstype> <options> on <date>
+            # /dev/dsk/c1t0d0s0 on / type ufs read/write/setuid/devices/intr/largefiles/logging/xattr/onerror=panic/dev=700040 on Tue May  1 11:33:55 2012
+            case line
+            when /^#{device_regex}\s+on\s+#{Regexp.escape(mount_point)}\s+/
+              Chef::Log.debug("Special device #{device} is mounted as #{mount_point}")
+              mounted = true
+            when /^([\/\w]+)\son\s#{Regexp.escape(mount_point)}\s+/
+              Chef::Log.debug("Special device #{$1} is mounted as #{mount_point}")
+              mounted = false
+            end
+          end
+          mounted
+        end
+
+        private
+
+        def read_vfstab_status
+          # Check to see if there is a entry in /etc/vfstab. Last entry for a volume wins.
+          enabled = false
+          fstype = options = pass = nil
+          ::File.foreach(VFSTAB) do |line|
+            case line
+            when /^[#\s]/
+              next
+              # solaris /etc/vfstab format:
+              # device         device          mount           FS      fsck    mount   mount
+              # to mount       to fsck         point           type    pass    at boot options
+            when /^#{device_regex}\s+[-\/\w]+\s+#{Regexp.escape(mount_point)}\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)/
+              enabled = true
+              fstype = $1
+              options = $4
+              # Store the 'mount at boot' column from vfstab as the 'noauto' option
+              # in current_resource.options (linux style)
+              if $3 == "yes"
+                if options.nil? || options.empty?
+                  options = "noauto"
+                else
+                  options += ",noauto"
+                end
+              end
+              pass = ( $2 == "-" ) ? 0 : $2.to_i
+              Chef::Log.debug("Found mount #{device} to #{mount_point} in #{VFSTAB}")
+              next
+            when /^[-\/\w]+\s+[-\/\w]+\s+#{Regexp.escape(mount_point)}\s+/
+              # if we find a mountpoint on top of our mountpoint, then we are not enabled
+              enabled = false
+              Chef::Log.debug("Found conflicting mount point #{mount_point} in #{VFSTAB}")
+            end
+          end
+          [ enabled, fstype, options, pass ]
+        end
+
+        def device_should_exist?
+          !%w{tmpfs nfs ctfs proc mntfs objfs sharefs fd smbfs}.include?(fstype)
+        end
+
+        def device_regex
+          if ::File.symlink?(device)
+            "(?:#{Regexp.escape(device)}|#{Regexp.escape(::File.expand_path(::File.readlink(device),::File.dirname(device)))})"
+          else
+            Regexp.escape(device)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -37,6 +37,15 @@ class Chef
           @current_resource
         end
 
+        def define_resource_requirements
+          super
+
+          requirements.assert(:all_actions) do |a|
+            a.assertion { !@new_resource.source }
+            a.failure_message(Chef::Exceptions::Package, 'apt package provider cannot handle source attribute. Use dpkg provider instead')
+          end
+        end
+
         def default_release_options
           # Use apt::Default-Release option only if provider was explicitly defined
           "-o APT::Default-Release=#{@new_resource.default_release}" if @new_resource.provider && @new_resource.default_release

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

@@ -18,6 +18,7 @@
 
 require 'chef/resource/windows_package'
 require 'chef/provider/package'
+require 'chef/util/path_helper'
 
 class Chef
   class Provider
@@ -32,6 +33,8 @@ class Chef
 
         # load_current_resource is run in Chef::Provider#run_action when not in whyrun_mode?
         def load_current_resource
+          @new_resource.source(Chef::Util::PathHelper.validate_path(@new_resource.source))
+
           @current_resource = Chef::Resource::WindowsPackage.new(@new_resource.name)
           @current_resource.version(package_provider.installed_version)
           @new_resource.version(package_provider.package_version)

data/lib/chef/providers.rb

@@ -103,6 +103,7 @@ require 'chef/provider/group/windows'
 
 require 'chef/provider/mount/mount'
 require 'chef/provider/mount/aix'
+require 'chef/provider/mount/solaris'
 require 'chef/provider/mount/windows'
 
 require 'chef/provider/deploy/revision'

data/lib/chef/resource/mount.rb

@@ -65,10 +65,15 @@ class Chef
 
       def device_type(arg=nil)
         real_arg = arg.kind_of?(String) ? arg.to_sym : arg
+        valid_devices = if RUBY_PLATFORM =~ /solaris/i
+                          [ :device ]
+                        else
+                          [ :device, :label, :uuid ]
+                        end
         set_or_return(
           :device_type,
           real_arg,
-          :equal_to => [ :device, :label, :uuid ]
+          :equal_to => valid_devices
         )
       end