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

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

@@ -37,9 +37,11 @@ class Chef
           # do not call super here, inherit only shared_requirements
           shared_resource_requirements
           requirements.assert(:start, :stop, :restart, :reload) do |a|
-            a.assertion { ::File.exist?(@init_command) }
-            a.failure_message(Chef::Exceptions::Service, "#{@init_command} does not exist!")
-            a.whyrun("Init script '#{@init_command}' doesn't exist, assuming a prior action would have created it.") do
+            a.assertion do
+              custom_command_for_action?(action) || ::File.exist?(default_init_command)
+            end
+            a.failure_message(Chef::Exceptions::Service, "#{default_init_command} does not exist!")
+            a.whyrun("Init script '#{default_init_command}' doesn't exist, assuming a prior action would have created it.") do
               # blindly assume that the service exists but is stopped in why run mode:
               @status_load_success = false
             end
@@ -50,7 +52,7 @@ class Chef
           if @new_resource.start_command
             super
           else
-            shell_out!("#{@init_command} start")
+            shell_out!("#{default_init_command} start")
           end
         end
 
@@ -58,7 +60,7 @@ class Chef
           if @new_resource.stop_command
             super
           else
-            shell_out!("#{@init_command} stop")
+            shell_out!("#{default_init_command} stop")
           end
         end
 
@@ -66,7 +68,7 @@ class Chef
           if @new_resource.restart_command
             super
           elsif @new_resource.supports[:restart]
-            shell_out!("#{@init_command} restart")
+            shell_out!("#{default_init_command} restart")
           else
             stop_service
             sleep 1
@@ -78,7 +80,7 @@ class Chef
           if @new_resource.reload_command
             super
           elsif @new_resource.supports[:reload]
-            shell_out!("#{@init_command} reload")
+            shell_out!("#{default_init_command} reload")
           end
         end
       end

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

@@ -17,7 +17,6 @@
 #
 
 require 'chef/provider/service'
-require 'rexml/document'
 
 class Chef
   class Provider
@@ -25,18 +24,23 @@ 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)
           @plist_size = 0
           @plist = find_service_plist
-          @service_label = find_service_label
           set_service_status
 
           @current_resource
@@ -44,30 +48,33 @@ class Chef
 
         def define_resource_requirements
           #super
-          requirements.assert(:reload) do |a| 
-            a.failure_message Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :reload"
+          requirements.assert(:enable) do |a|
+            a.failure_message Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :enable"
           end
 
-          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."
+          requirements.assert(:disable) do |a|
+            a.failure_message Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :disable"
           end
 
-          requirements.assert(:enable, :disable) do |a|
-            a.assertion { !@service_label.to_s.empty? }
-            a.failure_message Chef::Exceptions::Service,
-              "Could not find service's label in plist file '#{@plist}'!"
+          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 > 0 } 
-            # No failure here in original code - so we also will not
+          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 }
+            # 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
           end
+
         end
 
         def start_service
@@ -104,56 +111,19 @@ class Chef
           end
         end
 
-        # On OS/X, enabling a service has the side-effect of starting it,
-        # and disabling a service has the side-effect of stopping it.
-        #
-        # This makes some sense on OS/X since launchctl is an "init"-style
-        # supervisor that will restart daemons that are crashing, etc.
-        def enable_service
-          if @current_resource.enabled
-            Chef::Log.debug("#{@new_resource} already enabled, not enabling")
-          else
-            shell_out!(
-              "launchctl load -w '#{@plist}'",
-              :user => @owner_uid, :group => @owner_gid
-            )
-          end
-        end
-
-        def disable_service
-          unless @current_resource.enabled
-            Chef::Log.debug("#{@new_resource} not enabled, not disabling")
-          else
-            shell_out!(
-              "launchctl unload -w '#{@plist}'",
-              :user => @owner_uid, :group => @owner_gid
-            )
-          end
-        end
 
         def set_service_status
-          return if @plist == nil or @service_label.to_s.empty?
+          return if @plist == nil
 
-          cmd = shell_out(
-            "launchctl list #{@service_label}",
-            :user => @owner_uid, :group => @owner_gid
-          )
-
-          if cmd.exitstatus == 0
-            @current_resource.enabled(true)
-          else
-            @current_resource.enabled(false)
-          end
+          @current_resource.enabled(!@plist.nil?)
 
           if @current_resource.enabled
             @owner_uid = ::File.stat(@plist).uid
             @owner_gid = ::File.stat(@plist).gid
 
-            shell_out!(
-              "launchctl list", :user => @owner_uid, :group => @owner_gid
-            ).stdout.each_line do |line|
+            shell_out!("launchctl list", :user => @owner_uid, :group => @owner_gid).stdout.each_line do |line|
               case line
-              when /(\d+|-)\s+(?:\d+|-)\s+(.*\.?)#{@service_label}/
+              when /(\d+|-)\s+(?:\d+|-)\s+(.*\.?)#{@current_resource.service_name}/
                 pid = $1
                 @current_resource.running(!pid.to_i.zero?)
               end
@@ -165,31 +135,9 @@ class Chef
 
       private
 
-        def find_service_label
-          # CHEF-5223 "you can't glob for a file that hasn't been converged
-          # onto the node yet."
-          return nil if @plist.nil?
-
-          # Most services have the same internal label as the name of the
-          # plist file. However, there is no rule saying that *has* to be
-          # the case, and some core services (notably, ssh) do not follow
-          # this rule.
-
-          # plist files can come in XML or Binary formats. this command
-          # will make sure we get XML every time.
-          plist_xml = shell_out!("plutil -convert xml1 -o - #{@plist}").stdout
-
-          plist_doc = REXML::Document.new(plist_xml)
-          plist_doc.elements[
-            "/plist/dict/key[text()='Label']/following::string[1]/text()"]
-        end
-
         def find_service_plist
           plists = PLIST_DIRS.inject([]) do |results, dir|
-            edir = ::File.expand_path(dir)
-            entries = Dir.glob(
-              "#{edir}/*#{@current_resource.service_name}*.plist"
-            )
+            entries = Dir.glob("#{::File.expand_path(dir)}/*#{@current_resource.service_name}*.plist")
             entries.any? ? results << entries : results
           end
           plists.flatten!

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

@@ -128,7 +128,7 @@ class Chef
           elsif @new_resource.supports[:status]
             Chef::Log.debug("#{@new_resource} supports status, running")
             begin
-              if shell_out("#{@init_command} status").exitstatus == 0
+              if shell_out("#{default_init_command} status").exitstatus == 0
                 @current_resource.running true
                 Chef::Log.debug("#{@new_resource} is running")
               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 => "#{@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 => "#{@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 => "#{@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

@@ -17,18 +17,24 @@
 # limitations under the License.
 #
 
+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::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)
@@ -39,85 +45,14 @@ class Chef
         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."
+          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)
-          update = ::File.exist?(@new_resource.path)
-          if update && content_matches?
-            Chef::Log.debug("#{@new_resource} content has not changed.")
-            set_all_access_controls
-          else
-            description = []
-            action_message = update ? "update #{@current_resource} from #{short_cksum(@current_resource.checksum)} to #{short_cksum(@new_resource.checksum)}" :
-              "create #{@new_resource}"
-            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!
-              stat = ::File.stat(@new_resource.path)
-
-              # template depends on the checksum not changing, and updates it
-              # itself later in the code, so we cannot set it here, as we do with
-              # all other < File child provider classes
-              @new_resource.owner(stat.uid)
-              @new_resource.mode(stat.mode & 07777)
-              @new_resource.group(stat.gid)
-            end
-          end
-        end
-      end
-
-
-      def template_location
-        @template_file_cache_location ||= begin
-          if @new_resource.local
-            @new_resource.source
-          else
-            cookbook = run_context.cookbook_collection[resource_cookbook]
-            cookbook.preferred_filename_on_disk_location(node, :templates, @new_resource.source)
-          end
-        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 render_with_context(template_location, &block)
-        context = {}
-        context.merge!(@new_resource.variables)
-        context[:node] = node
-        render_template(IO.read(template_location), context, &block)
-      end
-
-      def managing_content?
-        return true if @new_resource.checksum
-        return true if !@new_resource.source.nil? && @action != :create_if_missing
-        false
-      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
+