chef 12.0.0.alpha.0 → 12.0.0.alpha.1

data/lib/chef/provider/git.rb

@@ -150,7 +150,7 @@ class Chef
 
         converge_by("checkout ref #{sha_ref} branch #{@new_resource.revision}") do
           # checkout into a local branch rather than a detached HEAD
-          shell_out!("git checkout -b #{@new_resource.checkout_branch} #{sha_ref}", run_options(:cwd => @new_resource.destination))
+          shell_out!("git checkout -B #{@new_resource.checkout_branch} #{sha_ref}", run_options(:cwd => @new_resource.destination))
           Chef::Log.info "#{@new_resource} checked out branch: #{@new_resource.revision} onto: #{@new_resource.checkout_branch} reference: #{sha_ref}"
         end
       end
@@ -283,6 +283,7 @@ class Chef
         env['GIT_SSH'] = @new_resource.ssh_wrapper if @new_resource.ssh_wrapper
         run_opts[:log_tag] = @new_resource.to_s
         run_opts[:timeout] = @new_resource.timeout if @new_resource.timeout
+        env.merge!(@new_resource.environment) if @new_resource.environment
         run_opts[:environment] = env unless env.empty?
         run_opts
 

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

@@ -16,16 +16,18 @@
 # limitations under the License.
 #
 
-require 'chef/provider/group/usermod'
+require 'chef/provider/group/groupadd'
+require 'chef/mixin/shell_out'
 
 class Chef
   class Provider
     class Group
-      class Aix < Chef::Provider::Group::Usermod
+      class Aix < Chef::Provider::Group::Groupadd
 
         def required_binaries
           [ "/usr/bin/mkgroup",
             "/usr/bin/chgroup",
+            "/usr/bin/chgrpmem",
             "/usr/sbin/rmgroup" ]
         end
 
@@ -51,6 +53,19 @@ class Chef
           run_command(:command => "rmgroup #{@new_resource.group_name}")
         end
 
+        def add_member(member)
+          shell_out!("chgrpmem -m + #{member} #{@new_resource.group_name}")
+        end
+
+        def set_members(members)
+          return if members.empty?
+          shell_out!("chgrpmem -m = #{members.join(',')} #{@new_resource.group_name}")
+        end
+
+        def remove_member(member)
+          shell_out!("chgrpmem -m - #{member} #{@new_resource.group_name}")
+        end
+
         def set_options
           opts = ""
           { :gid => "id" }.sort { |a,b| a[0] <=> b[0] }.each do |field, option|

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

@@ -39,11 +39,33 @@ class Chef
           return result[2]
         end
 
-        # This is handled in providers/group.rb by Etc.getgrnam()
-        # def group_exists?(group)
-        #   groups = safe_dscl("list /Groups")
-        #   !! ( groups =~ Regexp.new("\n#{group}\n") )
-        # end
+        def load_current_resource
+          @current_resource = Chef::Resource::Group.new(@new_resource.name)
+          @current_resource.group_name(@new_resource.name)
+          group_info = nil
+          begin
+            group_info = safe_dscl("read /Groups/#{@new_resource.name}")
+          rescue Chef::Exceptions::Group
+            @group_exists = false
+            Chef::Log.debug("#{@new_resource} group does not exist")
+          end
+
+          if group_info
+            group_info.each_line do |line|
+              key, val = line.split(': ')
+              val.strip! if val
+              case key.downcase
+              when 'primarygroupid'
+                @new_resource.gid(val) unless @new_resource.gid
+                @current_resource.gid(val)
+              when 'groupmembership'
+                @current_resource.members(val.split(' '))
+              end
+            end
+          end
+
+          @current_resource
+        end
 
         # get a free GID greater than 200
         def get_free_gid(search_limit=1000)
@@ -115,10 +137,6 @@ class Chef
           end
         end
 
-        def load_current_resource
-          super
-        end
-
         def create_group
           dscl_create_group
           set_gid

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

@@ -39,7 +39,14 @@ class Chef
         def create_group
           command = "pw groupadd"
           command << set_options
-          member_options = set_members_options
+
+          # pw group[add|mod] -M is used to set the full membership list on a
+          # new or existing group. Because pw groupadd does not support the -m
+          # and -d options used by manage_group, we treat group creation as a
+          # special case and use -M.
+          Chef::Log.debug("#{@new_resource} setting group members: #{@new_resource.members.join(',')}")
+          member_options = [" -M #{@new_resource.members.join(',')}"]
+
           if member_options.empty?
             run_command(:command => command)
           else

data/lib/chef/provider/http_request.rb

@@ -33,13 +33,13 @@ class Chef
         @http = Chef::HTTP::Simple.new(@new_resource.url)
       end
 
-      # Send a HEAD request to @new_resource.url, with ?message=@new_resource.message
+      # Send a HEAD request to @new_resource.url
       def action_head
         message = check_message(@new_resource.message)
         # CHEF-4762: we expect a nil return value from Chef::HTTP for a "200 Success" response
         # and false for a "304 Not Modified" response
         modified = @http.head(
-          "#{@new_resource.url}?message=#{message}",
+          "#{@new_resource.url}",
           @new_resource.headers
         )
         Chef::Log.info("#{@new_resource} HEAD to #{@new_resource.url} successful")
@@ -50,13 +50,13 @@ class Chef
         end
       end
 
-      # Send a GET request to @new_resource.url, with ?message=@new_resource.message
+      # Send a GET request to @new_resource.url
       def action_get
         converge_by("#{@new_resource} GET to #{@new_resource.url}") do
 
           message = check_message(@new_resource.message)
           body = @http.get(
-            "#{@new_resource.url}?message=#{message}",
+            "#{@new_resource.url}",
             @new_resource.headers
           )
           Chef::Log.info("#{@new_resource} GET to #{@new_resource.url} successful")

data/lib/chef/provider/log.rb

@@ -25,8 +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 ]
+        def whyrun_supported?
+          true
+        end
 
         # No concept of a 'current' resource for logs, this is a no-op
         #
@@ -42,18 +43,7 @@ class Chef
         # true:: Always return true
         def action_write
           Chef::Log.send(@new_resource.level, @new_resource.message)
-
-          # 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
-
+          @new_resource.updated_by_last_action(true)
         end
 
       end

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

@@ -85,7 +85,7 @@ class Chef
 
           shell_out!("mount").stdout.each_line do |line|
             case line
-            when /^#{device_mount_regex}\s+on\s+#{Regexp.escape(real_mount_point)}/
+            when /^#{device_mount_regex}\s+on\s+#{Regexp.escape(real_mount_point)}\s/
               mounted = true
               Chef::Log.debug("Special device #{device_logstring} mounted as #{real_mount_point}")
             when /^([\/\w])+\son\s#{Regexp.escape(real_mount_point)}\s+/
@@ -167,7 +167,7 @@ class Chef
 
             found = false
             ::File.readlines("/etc/fstab").reverse_each do |line|
-              if !found && line =~ /^#{device_fstab_regex}\s+#{Regexp.escape(@new_resource.mount_point)}/
+              if !found && line =~ /^#{device_fstab_regex}\s+#{Regexp.escape(@new_resource.mount_point)}\s/
                 found = true
                 Chef::Log.debug("#{@new_resource} is removed from fstab")
                 next

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

@@ -39,33 +39,27 @@ class Chef
           end
         end
 
-        def load_current_resource
-          @current_resource = Chef::Resource::Package.new(@new_resource.name)
-          @current_resource.package_name(@new_resource.name)
-          check_package_state(@new_resource.package_name)
-          @current_resource
+        def get_current_version
+          shell_out("pkg info #{@new_resource.package_name}").stdout.each_line do |line|
+            return $1.split[0] if line =~ /^\s+Version: (.*)/
+          end
+          return nil
         end
 
-        def check_package_state(package)
-          Chef::Log.debug("Checking package status for #{package}")
-          installed = false
-          depends = false
-
-          shell_out!("pkg info -r #{package}").stdout.each_line do |line|
-            case line
-            when /^\s+State: Installed/
-              installed = true
-            when /^\s+Version: (.*)/
-              @candidate_version = $1.split[0]
-              if installed
-                @current_resource.version($1)
-              else
-                @current_resource.version(nil)
-              end
-            end
+        def get_candidate_version
+          shell_out!("pkg info -r #{new_resource.package_name}").stdout.each_line do |line|
+            return $1.split[0] if line =~ /Version: (.*)/
           end
+          return nil
+        end
 
-          return installed
+        def load_current_resource
+          @current_resource = Chef::Resource::Package.new(@new_resource.name)
+          @current_resource.package_name(@new_resource.package_name)
+          Chef::Log.debug("Checking package status for #{@new_resource.name}")
+          @current_resource.version(get_current_version)
+          @candidate_version = get_candidate_version
+          @current_resource
         end
 
         def install_package(name, version)

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

@@ -34,7 +34,7 @@ class Chef
           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|
+          shell_out!("cave -L warning print-ids -M none -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]
@@ -59,7 +59,7 @@ class Chef
           else
             pkg = "#{@new_resource.package_name}"
           end
-          shell_out!("cave -L warning resolve -x#{expand_options(@new_resource.options)} \"#{pkg}\"")
+          shell_out!("cave -L warning resolve -x#{expand_options(@new_resource.options)} \"#{pkg}\"",:timeout => @new_resource.timeout)
         end
 
         def upgrade_package(name, version)

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

@@ -60,7 +60,7 @@ 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
@@ -78,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/rubygems.rb

@@ -273,6 +273,8 @@ class Chef
             @platform_cache ||= {}
           end
 
+          include Chef::Mixin::ShellOut
+
           attr_reader :gem_binary_location
 
           def initialize(gem_binary_location)

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

@@ -19,6 +19,7 @@
 require 'chef/config'
 require 'chef/provider/package'
 require 'chef/mixin/command'
+require 'chef/mixin/shell_out'
 require 'chef/resource/package'
 require 'singleton'
 require 'chef/mixin/get_source_from_package'
@@ -645,6 +646,7 @@ class Chef
         # Cache for our installed and available packages, pulled in from yum-dump.py
         class YumCache
           include Chef::Mixin::Command
+          include Chef::Mixin::ShellOut
           include Singleton
 
           def initialize

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

@@ -103,7 +103,7 @@ class Chef
 
         private
         def zypper_package(command, pkgname, version)
-          version = "=#{version}" unless version.empty?
+          version = "=#{version}" unless version.nil? || version.empty?
           if zypper_version < 1.0
             shell_out!("zypper#{gpg_checks} #{command} -y #{pkgname}")
           else

data/lib/chef/provider/remote_file/cache_control_data.rb

@@ -139,8 +139,8 @@ class Chef
         end
 
         def load_data
-          Chef::JSONCompat.from_json(load_json_data)
-        rescue Chef::Exceptions::FileNotFound, FFI_Yajl::ParseError, JSON::ParserError
+          Chef::JSONCompat.parse(load_json_data)
+        rescue Chef::Exceptions::FileNotFound, Chef::Exceptions::JSON::ParseError
           false
         end
 

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

@@ -27,6 +27,7 @@ class Chef::Provider::Service::Windows < Chef::Provider::Service
 
   #Win32::Service.get_start_type
   AUTO_START = 'auto start'
+  MANUAL = 'demand start'
   DISABLED = 'disabled'
 
   #Win32::Service.get_current_state
@@ -45,11 +46,16 @@ class Chef::Provider::Service::Windows < Chef::Provider::Service
   end
 
   def load_current_resource
-    @current_resource = Chef::Resource::Service.new(@new_resource.name)
+    @current_resource = Chef::Resource::WindowsService.new(@new_resource.name)
     @current_resource.service_name(@new_resource.service_name)
     @current_resource.running(current_state == RUNNING)
     Chef::Log.debug "#{@new_resource} running: #{@current_resource.running}"
-    @current_resource.enabled(start_type == AUTO_START)
+    case current_start_type
+    when AUTO_START
+      @current_resource.enabled(true)
+    when DISABLED
+      @current_resource.enabled(false)
+    end
     Chef::Log.debug "#{@new_resource} enabled: #{@current_resource.enabled}"
     @current_resource
   end
@@ -125,15 +131,7 @@ class Chef::Provider::Service::Windows < Chef::Provider::Service
 
   def enable_service
     if Win32::Service.exists?(@new_resource.service_name)
-      if start_type == AUTO_START
-        Chef::Log.debug "#{@new_resource} already enabled - nothing to do"
-      else
-        Win32::Service.configure(
-          :service_name => @new_resource.service_name,
-          :start_type => Win32::Service::AUTO_START
-        )
-        @new_resource.updated_by_last_action(true)
-      end
+      set_startup_type(:automatic)
     else
       Chef::Log.debug "#{@new_resource} does not exist - nothing to do"
     end
@@ -141,26 +139,76 @@ class Chef::Provider::Service::Windows < Chef::Provider::Service
 
   def disable_service
     if Win32::Service.exists?(@new_resource.service_name)
-      if start_type == AUTO_START
-        Win32::Service.configure(
-          :service_name => @new_resource.service_name,
-          :start_type => Win32::Service::DISABLED
-        )
-        @new_resource.updated_by_last_action(true)
-      else
-        Chef::Log.debug "#{@new_resource} already disabled - nothing to do"
-      end
+      set_startup_type(:disabled)
     else
       Chef::Log.debug "#{@new_resource} does not exist - nothing to do"
     end
   end
 
+  def action_enable
+    if current_start_type != AUTO_START
+      converge_by("enable service #{@new_resource}") do
+        enable_service
+        Chef::Log.info("#{@new_resource} enabled")
+      end
+    else
+      Chef::Log.debug("#{@new_resource} already enabled - nothing to do")
+    end
+    load_new_resource_state
+    @new_resource.enabled(true)
+  end
+
+  def action_disable
+    if current_start_type != DISABLED
+      converge_by("disable service #{@new_resource}") do
+        disable_service
+        Chef::Log.info("#{@new_resource} disabled")
+      end
+    else
+      Chef::Log.debug("#{@new_resource} already disabled - nothing to do")
+    end
+    load_new_resource_state
+    @new_resource.enabled(false)
+  end
+
+  def action_configure_startup
+    case @new_resource.startup_type
+    when :automatic
+      if current_start_type != AUTO_START
+        converge_by("set service #{@new_resource} startup type to automatic") do
+          set_startup_type(:automatic)
+        end
+      else
+        Chef::Log.debug("#{@new_resource} startup_type already automatic - nothing to do")
+      end
+    when :manual
+      if current_start_type != MANUAL
+        converge_by("set service #{@new_resource} startup type to manual") do
+          set_startup_type(:manual)
+        end
+      else
+        Chef::Log.debug("#{@new_resource} startup_type already manual - nothing to do")
+      end
+    when :disabled
+      if current_start_type != DISABLED
+        converge_by("set service #{@new_resource} startup type to disabled") do
+          set_startup_type(:disabled)
+        end
+      else
+        Chef::Log.debug("#{@new_resource} startup_type already disabled - nothing to do")
+      end
+    end
+
+    # Avoid changing enabled from true/false for now
+    @new_resource.enabled(nil)
+  end
+
   private
   def current_state
     Win32::Service.status(@new_resource.service_name).current_state
   end
 
-  def start_type
+  def current_start_type
     Win32::Service.config_info(@new_resource.service_name).start_type
   end
 
@@ -188,4 +236,22 @@ class Chef::Provider::Service::Windows < Chef::Provider::Service
       worker.join
     end
   end
+
+  # Takes Win32::Service start_types
+  def set_startup_type(type)
+    # Set-Service Startup Type => Win32::Service Constant
+    allowed_types = { :automatic => Win32::Service::AUTO_START,
+                      :manual    => Win32::Service::DEMAND_START,
+                      :disabled  => Win32::Service::DISABLED }
+    unless allowed_types.keys.include?(type)
+      raise Chef::Exceptions::ConfigurationError, "#{@new_resource.name}: Startup type '#{type}' is not supported"
+    end
+
+    Chef::Log.debug "#{@new_resource.name} setting start_type to #{type}"
+    Win32::Service.configure(
+      :service_name => @new_resource.service_name,
+      :start_type => allowed_types[type]
+    )
+    @new_resource.updated_by_last_action(true)
+  end
 end