chef 11.4.4 → 11.6.0.hotfix.1

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

@@ -24,12 +24,18 @@ class Chef
       class Macosx < Chef::Provider::Service::Simple
         include Chef::Mixin::ShellOut
 
-        PLIST_DIRS = %w{~/Library/LaunchAgents
-                         /Library/LaunchAgents
+        def self.gather_plist_dirs
+          locations = %w{/Library/LaunchAgents
                          /Library/LaunchDaemons
                          /System/Library/LaunchAgents
                          /System/Library/LaunchDaemons }
 
+          locations << "#{ENV['HOME']}/Library/LaunchAgents" if ENV['HOME']
+          locations
+        end
+
+        PLIST_DIRS = gather_plist_dirs
+
         def load_current_resource
           @current_resource = Chef::Resource::Service.new(@new_resource.name)
           @current_resource.service_name(@new_resource.service_name)
@@ -42,28 +48,28 @@ class Chef
 
         def define_resource_requirements
           #super
-          requirements.assert(:enable) do |a| 
+          requirements.assert(:enable) do |a|
             a.failure_message Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :enable"
           end
 
-          requirements.assert(:disable) do |a| 
+          requirements.assert(:disable) do |a|
             a.failure_message Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :disable"
           end
 
-          requirements.assert(:reload) do |a| 
+          requirements.assert(:reload) do |a|
             a.failure_message Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :reload"
           end
 
-          requirements.assert(:all_actions) do |a| 
-            a.assertion { @plist_size < 2 } 
+          requirements.assert(:all_actions) do |a|
+            a.assertion { @plist_size < 2 }
             a.failure_message Chef::Exceptions::Service, "Several plist files match service name. Please use full service name."
           end
 
-          requirements.assert(:all_actions) do |a| 
-            a.assertion { @plist_size > 0 } 
+          requirements.assert(:all_actions) do |a|
+            a.assertion { @plist_size > 0 }
             # No failrue here in original code - so we also will not
             # fail. Instead warn that the service is potentially missing
-            a.whyrun "Assuming that the service would have been previously installed and is currently disabled." do 
+            a.whyrun "Assuming that the service would have been previously installed and is currently disabled." do
               @current_resource.enabled(false)
               @current_resource.running(false)
             end

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

@@ -16,6 +16,7 @@
 # limitations under the License.
 #
 
+require 'chef/mixin/shell_out'
 require 'chef/provider/service'
 require 'chef/mixin/command'
 
@@ -23,6 +24,7 @@ class Chef
   class Provider
     class Service
       class Solaris < Chef::Provider::Service
+        include Chef::Mixin::ShellOut
 
         def initialize(new_resource, run_context=nil)
           super
@@ -42,23 +44,22 @@ class Chef
         end
 
         def enable_service
-          run_command(:command => "#{default_init_command} enable #{@new_resource.service_name}")
-          return service_status.enabled
+          shell_out!("#{default_init_command} enable -s #{@new_resource.service_name}")
         end
 
         def disable_service
-          run_command(:command => "#{default_init_command} disable #{@new_resource.service_name}")
-          return service_status.enabled
+          shell_out!("#{default_init_command} disable -s #{@new_resource.service_name}")
         end
 
         alias_method :stop_service, :disable_service
         alias_method :start_service, :enable_service
 
         def reload_service
-          run_command(:command => "#{default_init_command} refresh #{@new_resource.service_name}")
+          shell_out!("#{default_init_command} refresh #{@new_resource.service_name}")
         end
 
         def restart_service
+          ## svcadm restart doesn't supports sync(-s) option
           disable_service
           return enable_service
         end

data/lib/chef/provider/template.rb

@@ -19,18 +19,22 @@
 
 require 'chef/provider/template_finder'
 require 'chef/provider/file'
-require 'chef/mixin/template'
-require 'chef/mixin/checksum'
-require 'chef/file_access_control'
+require 'chef/deprecation/provider/template'
+require 'chef/deprecation/warnings'
+
 
 class Chef
   class Provider
-
     class Template < Chef::Provider::File
 
-      include Chef::Mixin::EnforceOwnershipAndPermissions
-      include Chef::Mixin::Checksum
-      include Chef::Mixin::Template
+      extend Chef::Deprecation::Warnings
+      include Chef::Deprecation::Provider::Template
+      add_deprecation_warnings_for(Chef::Deprecation::Provider::Template.instance_methods)
+
+      def initialize(new_resource, run_context)
+        @content_class = Chef::Provider::Template::Content
+        super
+      end
 
       def load_current_resource
         @current_resource = Chef::Resource::Template.new(@new_resource.name)
@@ -40,81 +44,15 @@ class Chef
       def define_resource_requirements
         super
 
-        requirements.assert(:create, :create_if_missing) do |a| 
-          a.assertion { ::File::exist?(template_location) } 
-          a.failure_message "Template source #{template_location} could not be found."
-          a.whyrun "Template source #{template_location} does not exist. Assuming it would have been created."
+        requirements.assert(:create, :create_if_missing) do |a|
+          a.assertion { ::File::exists?(content.template_location) }
+          a.failure_message "Template source #{content.template_location} could not be found."
+          a.whyrun "Template source #{content.template_location} does not exist. Assuming it would have been created."
           a.block_action!
         end
       end
 
-      def action_create
-        render_with_context(template_location) do |rendered_template|
-          rendered(rendered_template)
-          if file_already_exists? && content_matches?
-            Chef::Log.debug("#{@new_resource} content has not changed.")
-            set_all_access_controls
-            update_new_file_state(@new_resource.path)
-          else
-            description = []
-            action_message = if file_already_exists?
-              "update #{@current_resource} from #{short_cksum(@current_resource.checksum)} to #{short_cksum(@new_resource.checksum)}"
-            else
-              "create #{@new_resource}"
-            end
-            description << action_message
-            description << diff_current(rendered_template.path)
-            converge_by(description) do
-              backup
-              FileUtils.cp(rendered_template.path, @new_resource.path)
-              Chef::Log.info("#{@new_resource} updated content")
-              access_controls.set_all!
-              update_new_file_state(@new_resource.path)
-            end
-          end
-        end
-      end
-
-      def template_finder
-        @template_finder ||= begin
-          TemplateFinder.new(run_context, cookbook_name, node)
-        end
-      end
-
-      def template_location
-        @template_file_cache_location ||= begin
-          template_finder.find(@new_resource.source, :local => @new_resource.local, :cookbook => @new_resource.cookbook)
-        end
-      end
-
-      def resource_cookbook
-        @new_resource.cookbook || @new_resource.cookbook_name
-      end
-
-      def rendered(rendered_template)
-        @new_resource.checksum(checksum(rendered_template.path))
-        Chef::Log.debug("Current content's checksum:  #{@current_resource.checksum}")
-        Chef::Log.debug("Rendered content's checksum: #{@new_resource.checksum}")
-      end
-
-      def content_matches?
-        @current_resource.checksum == @new_resource.checksum
-      end
-
-      private
-
-      def file_already_exists?
-        ::File.exist?(@new_resource.path)
-      end
-
-      def render_with_context(template_location, &block)
-        context = {}
-        context.merge!(@new_resource.variables)
-        context[:node] = node
-        context[:template_finder] = template_finder
-        render_template(IO.read(template_location), context, &block)
-      end
-
     end
   end
 end
+

data/lib/chef/provider/template/content.rb

@@ -0,0 +1,61 @@
+#
+# Author:: Lamont Granquist (<lamont@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/mixin/template'
+require 'chef/file_content_management/content_base'
+
+class Chef
+  class Provider
+    class Template
+
+      class Content < Chef::FileContentManagement::ContentBase
+
+        include Chef::Mixin::Template
+
+        def template_location
+          @template_file_cache_location ||= begin
+            template_finder.find(@new_resource.source, :local => @new_resource.local, :cookbook => @new_resource.cookbook)
+          end
+        end
+
+        private
+
+        def file_for_provider
+          context = TemplateContext.new(@new_resource.variables)
+          context[:node] = @run_context.node
+          context[:template_finder] = template_finder
+          context._extend_modules(@new_resource.helper_modules)
+          output = context.render_template(template_location)
+
+          tempfile = Tempfile.open("chef-rendered-template")
+          tempfile.binmode
+          tempfile.write(output)
+          tempfile.close
+          tempfile
+        end
+
+        def template_finder
+          @template_finder ||= begin
+            TemplateFinder.new(run_context, @new_resource.cookbook_name, @run_context.node)
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,90 @@
+#
+# Author:: Stephen Nelson-Smith (<sns@opscode.com>)
+# Author:: Jon Ramsey (<jonathon.ramsey@gmail.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.
+
+class Chef
+  class Provider
+    class User
+      class Solaris < Chef::Provider::User::Useradd
+        UNIVERSAL_OPTIONS = [[:comment, "-c"], [:gid, "-g"], [:shell, "-s"], [:uid, "-u"]]
+
+        attr_writer :password_file
+
+        def initialize(new_resource, run_context)
+          @password_file = "/etc/shadow"
+          super
+        end
+
+        def create_user
+          super
+          manage_password
+        end
+
+        def manage_user
+          manage_password
+          super
+        end
+
+      private
+
+        def manage_password
+          if @current_resource.password != @new_resource.password && @new_resource.password
+            Chef::Log.debug("#{@new_resource} setting password to #{@new_resource.password}")
+            write_shadow_file
+          end
+        end
+
+        def write_shadow_file
+          buffer = Tempfile.new("shadow", "/etc")
+          ::File.open(@password_file) do |shadow_file|
+            shadow_file.each do |entry|
+              user = entry.split(":").first
+              if user == @new_resource.username
+                buffer.write(updated_password(entry))
+              else
+                buffer.write(entry)
+              end
+            end
+          end
+          buffer.close
+
+          # FIXME: mostly duplicates code with file provider deploying a file
+          mode = ::File.stat(@password_file).mode & 07777
+          uid  = ::File.stat(@password_file).uid
+          gid  = ::File.stat(@password_file).gid
+
+          FileUtils.chown uid, gid, buffer.path
+          FileUtils.chmod mode, buffer.path
+
+          FileUtils.mv buffer.path, @password_file
+        end
+
+        def updated_password(entry)
+          fields = entry.split(":")
+          fields[1] = @new_resource.password
+          fields[2] = days_since_epoch
+          fields.join(":")
+        end
+
+        def days_since_epoch
+          (Time.now.to_i / 86400).floor
+        end
+      end
+    end
+  end
+end
+

data/lib/chef/provider/user/useradd.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.
@@ -17,111 +17,124 @@
 #
 
 require 'pathname'
+require 'chef/mixin/shell_out'
 require 'chef/provider/user'
 
 class Chef
   class Provider
-    class User 
+    class User
       class Useradd < Chef::Provider::User
+
+        include Chef::Mixin::ShellOut
+
         UNIVERSAL_OPTIONS = [[:comment, "-c"], [:gid, "-g"], [:password, "-p"], [:shell, "-s"], [:uid, "-u"]]
 
         def create_user
           command = compile_command("useradd") do |useradd|
-            useradd << universal_options
-            useradd << useradd_options
+            useradd.concat(universal_options)
+            useradd.concat(useradd_options)
           end
-          run_command(:command => command)
+          shell_out!(*command)
         end
-        
+
         def manage_user
-          command = compile_command("usermod") do |u|
-            u << universal_options
+          if universal_options != ""
+            command = compile_command("usermod") do |u|
+              u.concat(universal_options)
+            end
+            shell_out!(*command)
           end
-          run_command(:command => command)
         end
-        
+
         def remove_user
-          command = "userdel"
-          command << " -r" if managing_home_dir?
-          command << " #{@new_resource.username}"
-          run_command(:command => command)
+          command = [ "userdel" ]
+          command << "-r" if managing_home_dir?
+          command << new_resource.username
+          shell_out!(*command)
         end
-        
+
         def check_lock
-          status = popen4("passwd -S #{@new_resource.username}") do |pid, stdin, stdout, stderr|
-            status_line = stdout.gets.split(' ')
-            case status_line[1]
-            when /^P/
-              @locked = false
-            when /^N/
-              @locked = false
-            when /^L/
-              @locked = true
-            end
+          # we can get an exit code of 1 even when it's successful on
+          # rhel/centos (redhat bug 578534). See additional error checks below.
+          passwd_s = shell_out!("passwd", "-S", new_resource.username, :returns => [0,1])
+          status_line = passwd_s.stdout.split(' ')
+          case status_line[1]
+          when /^P/
+            @locked = false
+          when /^N/
+            @locked = false
+          when /^L/
+            @locked = true
           end
 
-          unless status.exitstatus == 0
+          unless passwd_s.exitstatus == 0
             raise_lock_error = false
-            # we can get an exit code of 1 even when it's successful on rhel/centos (redhat bug 578534)
-            if status.exitstatus == 1 && ['redhat', 'centos'].include?(node[:platform])
-              passwd_version_status = popen4('rpm -q passwd') do |pid, stdin, stdout, stderr|
-                passwd_version = stdout.gets.chomp
+            if ['redhat', 'centos'].include?(node[:platform])
+              passwd_version_check = shell_out!('rpm -q passwd')
+              passwd_version = passwd_version_check.stdout.chomp
 
-                unless passwd_version == 'passwd-0.73-1'
-                  raise_lock_error = true
-                end
+              unless passwd_version == 'passwd-0.73-1'
+                raise_lock_error = true
               end
             else
               raise_lock_error = true
             end
 
-            raise Chef::Exceptions::User, "Cannot determine if #{@new_resource} is locked!" if raise_lock_error
+            raise Chef::Exceptions::User, "Cannot determine if #{new_resource} is locked!" if raise_lock_error
           end
 
           @locked
         end
-        
+
         def lock_user
-          run_command(:command => "usermod -L #{@new_resource.username}")
+          shell_out!("usermod", "-L", new_resource.username)
         end
-        
+
         def unlock_user
-          run_command(:command => "usermod -U #{@new_resource.username}")
+          shell_out!("usermod", "-U", new_resource.username)
         end
 
         def compile_command(base_command)
+          base_command = Array(base_command)
           yield base_command
-          base_command << " #{@new_resource.username}"
+          base_command << new_resource.username
           base_command
         end
-        
+
         def universal_options
-          opts = ''
-          
-          UNIVERSAL_OPTIONS.each do |field, option|
-            if @current_resource.send(field) != @new_resource.send(field)
-              if @new_resource.send(field)
-                Chef::Log.debug("#{@new_resource} setting #{field} to #{@new_resource.send(field)}")
-                opts << " #{option} '#{@new_resource.send(field)}'"
+          @universal_options ||=
+            begin
+              opts = []
+              # magic allows UNIVERSAL_OPTIONS to be overridden in a subclass
+              self.class::UNIVERSAL_OPTIONS.each do |field, option|
+                update_options(field, option, opts)
+              end
+              if updating_home?
+                if managing_home_dir?
+                  Chef::Log.debug("#{new_resource} managing the users home directory")
+                  opts << "-d" << new_resource.home << "-m"
+                else
+                  Chef::Log.debug("#{new_resource} setting home to #{new_resource.home}")
+                  opts << "-d" << new_resource.home
+                end
               end
+              opts << "-o" if new_resource.non_unique || new_resource.supports[:non_unique]
+              opts
             end
-          end
-          if updating_home?
-            if managing_home_dir?
-              Chef::Log.debug("#{@new_resource} managing the users home directory")
-              opts << " -m -d '#{@new_resource.home}'"
-            else
-              Chef::Log.debug("#{@new_resource} setting home to #{@new_resource.home}")
-              opts << " -d '#{@new_resource.home}'"
+        end
+
+        def update_options(field, option, opts)
+          if @current_resource.send(field) != new_resource.send(field)
+            if new_resource.send(field)
+              Chef::Log.debug("#{new_resource} setting #{field} to #{new_resource.send(field)}")
+              opts << option << new_resource.send(field).to_s
             end
           end
-          opts << " -o" if @new_resource.non_unique || @new_resource.supports[:non_unique]
-          opts
         end
 
         def useradd_options
-          opts = ''
-          opts << " -r" if @new_resource.system
+          opts = []
+          opts << "-r" if new_resource.system
           opts
         end
 
@@ -130,12 +143,12 @@ class Chef
           # Pathname#cleanpath does a better job than ::File::expand_path (on both unix and windows)
           # ::File.expand_path("///tmp") == ::File.expand_path("/tmp") => false
           # ::File.expand_path("\\tmp") => "C:/tmp"
-          return true if @current_resource.home.nil? && @new_resource.home
-          @new_resource.home and Pathname.new(@current_resource.home).cleanpath != Pathname.new(@new_resource.home).cleanpath
+          return true if @current_resource.home.nil? && new_resource.home
+          new_resource.home and Pathname.new(@current_resource.home).cleanpath != Pathname.new(new_resource.home).cleanpath
         end
 
         def managing_home_dir?
-          @new_resource.manage_home || @new_resource.supports[:manage_home]
+          new_resource.manage_home || new_resource.supports[:manage_home]
         end
 
       end