chef 0.8.16 → 0.9.0.a3

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

@@ -21,8 +21,8 @@ require 'chef/mixin/command'
 
 class Chef::Provider::Service::Arch < Chef::Provider::Service::Init
   
-  def initialize(node, new_resource, collection=nil, definitions=nil, cookbook_loader=nil)
-    super(node, new_resource, collection, definitions, cookbook_loader)
+  def initialize(new_resource, run_context)
+    super
     @init_command = "/etc/rc.d/#{@new_resource.service_name}"
   end
   
@@ -106,4 +106,4 @@ class Chef::Provider::Service::Arch < Chef::Provider::Service::Init
     update_daemons(new_daemons)
   end
 
-end
+end

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

@@ -24,38 +24,43 @@ class Chef
   class Provider
     class Service
       class Debian < Chef::Provider::Service::Init
+        UPDATE_RC_D_ENABLED_MATCHES = /etc\/rc[\dS].d\/S|not installed/i
+        
         def load_current_resource
           super
           
+          @current_resource.enabled(service_currently_enabled?)
+          @current_resource        
+        end
+
+        def enable_service()
+          run_command(:command => "/usr/sbin/update-rc.d #{@new_resource.service_name} defaults")
+        end
+
+        def disable_service()
+          run_command(:command => "/usr/sbin/update-rc.d -f #{@new_resource.service_name} remove")
+        end
+        
+        def assert_update_rcd_available
           unless ::File.exists? "/usr/sbin/update-rc.d"
             raise Chef::Exceptions::Service, "/usr/sbin/update-rc.d does not exist!"
           end
+        end
+        
+        def service_currently_enabled?
+          assert_update_rcd_available
 
           status = popen4("/usr/sbin/update-rc.d -n -f #{@current_resource.service_name} remove") do |pid, stdin, stdout, stderr|
-            r = /etc\/rc[\dS].d\/S|not installed/i
             stdout.each_line do |line|
-              if r.match(line)
-                @current_resource.enabled true
-                break
-              else
-                @current_resource.enabled false
-              end
+              return true if line =~ UPDATE_RC_D_ENABLED_MATCHES
             end
           end  
 
           unless status.exitstatus == 0
             raise Chef::Exceptions::Service, "/usr/sbin/update-rc.d -n -f #{@current_resource.service_name} failed - #{status.inspect}"
           end
-
-          @current_resource        
-        end
-
-        def enable_service()
-          run_command(:command => "/usr/sbin/update-rc.d #{@new_resource.service_name} defaults")
-        end
-
-        def disable_service()
-          run_command(:command => "/usr/sbin/update-rc.d -f #{@new_resource.service_name} remove")
+          
+          false
         end
         
       end

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

@@ -65,11 +65,11 @@ class Chef
           else
             Chef::Log.debug("#{@new_resource} does not support status and you have not specified a status command, falling back to process table inspection")
 
-            if @node[:command][:ps].nil? or @node[:command][:ps].empty?
+            if node[:command][:ps].nil? or node[:command][:ps].empty?
               raise Chef::Exceptions::Service, "#{@new_resource}: could not determine how to inspect the process table, please set this nodes 'ps' attribute"
             end
 
-            status = popen4(@node[:command][:ps]) do |pid, stdin, stdout, stderr|
+            status = popen4(node[:command][:ps]) do |pid, stdin, stdout, stderr|
               r = Regexp.new(@new_resource.pattern)
               Chef::Log.debug("#{@new_resource}: attempting to match #{@new_resource.pattern} (#{r}) against process table")
               stdout.each_line do |line|
@@ -81,9 +81,9 @@ class Chef
               @current_resource.running false unless @current_resource.running
             end
             unless status.exitstatus == 0
-              raise Chef::Exceptions::Service, "Command #{@node[:command][:ps]} failed"
+              raise Chef::Exceptions::Service, "Command #{node[:command][:ps]} failed"
             else
-              Chef::Log.debug("#{@new_resource}: #{@node[:command][:ps]} exited and parsed successfully, process running: #{@current_resource.running}")
+              Chef::Log.debug("#{@new_resource}: #{node[:command][:ps]} exited and parsed successfully, process running: #{@current_resource.running}")
             end
           end
 

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

@@ -25,8 +25,8 @@ class Chef
     class Service
       class Init < Chef::Provider::Service::Simple
         
-        def initialize(node, new_resource, collection=nil, definitions=nil, cookbook_loader=nil)
-          super(node, new_resource, collection, definitions, cookbook_loader)
+        def initialize(new_resource, run_context)
+          super
           @init_command = "/etc/init.d/#{@new_resource.service_name}"
         end
 

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

@@ -18,42 +18,40 @@
 
 require 'chef/provider/service'
 require 'chef/provider/service/init'
-require 'chef/mixin/command'
+require 'chef/mixin/shell_out'
 
 class Chef
   class Provider
     class Service
       class Redhat < Chef::Provider::Service::Init
+        include Chef::Mixin::ShellOut
         
-        def initialize(node, new_resource, collection=nil, definitions=nil, cookbook_loader=nil)
-          super(node, new_resource, collection, definitions, cookbook_loader)
+        CHKCONFIG_ON = /\d:on/
+        
+        def initialize(new_resource, run_context)
+          super
            @init_command = "/sbin/service #{@new_resource.service_name}"
+           @new_resource.supports[:status] = true
          end
         
         def load_current_resource
-          super
-          
           unless ::File.exists? "/sbin/chkconfig"
             raise Chef::Exceptions::Service, "/sbin/chkconfig does not exist!"
           end
-
-          status = popen4("/sbin/chkconfig --list #{@current_resource.service_name}") do |pid, stdin, stdout, stderr|
-            if stdout.gets =~ /\d:on/
-              @current_resource.enabled true
-            else
-              @current_resource.enabled false
-            end
-          end  
-
+          
+          super
+          
+          chkconfig = shell_out!("/sbin/chkconfig --list #{@current_resource.service_name}")
+          @current_resource.enabled(!!(chkconfig.stdout =~ CHKCONFIG_ON))
           @current_resource        
         end
 
         def enable_service()
-          run_command(:command => "/sbin/chkconfig #{@new_resource.service_name} on")
+          shell_out! "/sbin/chkconfig #{@new_resource.service_name} on"
         end
 
         def disable_service()
-          run_command(:command => "/sbin/chkconfig #{@new_resource.service_name} off")
+          shell_out! "/sbin/chkconfig #{@new_resource.service_name} off"
         end
         
       end

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

@@ -51,10 +51,10 @@ class Chef
             end
           elsif
             Chef::Log.debug "#{@new_resource}: falling back to process table inspection"
-            if @node[:command][:ps].nil? or @node[:command][:ps].empty?
+            if ps_cmd.nil? or ps_cmd.empty?
               raise Chef::Exceptions::Service, "#{@new_resource}: could not determine how to inspect the process table, please set this nodes 'command.ps' attribute"
             end
-            status = popen4(@node[:command][:ps]) do |pid, stdin, stdout, stderr|
+            status = popen4(ps_cmd) do |pid, stdin, stdout, stderr|
               r = Regexp.new(@new_resource.pattern)
               Chef::Log.debug "#{@new_resource}: attempting to match '#{@new_resource.pattern}' (#{r}) against process list"
               stdout.each_line do |line|
@@ -66,7 +66,7 @@ class Chef
               @current_resource.running false unless @current_resource.running
             end
             unless status.exitstatus == 0
-              raise Chef::Exceptions::Service, "Command #{@node[:command][:ps]} failed"
+              raise Chef::Exceptions::Service, "Command #{ps_cmd} failed"
             else
               Chef::Log.debug "#{@new_resource}: running: #{@current_resource.running}"
             end
@@ -108,6 +108,10 @@ class Chef
             raise Chef::Exceptions::Service, "#{self.to_s} requires that reload_command to be set"
           end
         end
+        
+        def ps_cmd
+          @run_context.node[:command] && @run_context.node[:command][:ps]
+        end
       end
     end
   end

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

@@ -0,0 +1,85 @@
+#
+# Author:: Toomas Pelberg (<toomasp@gmx.net>)
+# Copyright:: Copyright (c) 2010 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/service'
+require 'chef/mixin/command'
+
+class Chef
+  class Provider
+    class Service
+      class Solaris < Chef::Provider::Service
+
+        def initialize(new_resource, run_context=nil)
+          super
+          @init_command = "/usr/sbin/svcadm"
+          @status_command = "/bin/svcs -l"
+        end
+
+        def load_current_resource
+          @current_resource = Chef::Resource::Service.new(@new_resource.name)
+          @current_resource.service_name(@new_resource.service_name)
+          unless ::File.exists? "/bin/svcs"
+            raise Chef::Exceptions::Service, "/bin/svcs does not exist!"
+          end
+          @status = service_status.enabled
+          @current_resource
+        end
+
+        def enable_service
+          run_command(:command => "#{@init_command} enable #{@new_resource.service_name}")
+          return service_status.enabled
+        end
+
+        def disable_service
+          run_command(:command => "#{@init_command} disable #{@new_resource.service_name}")
+          return service_status.enabled
+        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}")
+        end
+
+        def restart_service
+          disable_service
+          return enable_service
+        end
+
+        def service_status
+          status = popen4("#{@status_command} #{@current_resource.service_name}") do |pid, stdin, stdout, stderr|
+            stdout.each do |line|
+              case line
+              when /state\s+online/
+                @current_resource.enabled(true)
+                @current_resource.running(true)
+              end
+            end
+          end
+          unless @current_resource.enabled
+            @current_resource.enabled(false)
+            @current_resource.running(false)
+          end
+          @current_resource
+        end
+
+      end
+    end
+  end
+end

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

@@ -25,6 +25,7 @@ class Chef
   class Provider
     class Service
       class Upstart < Chef::Provider::Service::Simple
+        UPSTART_STATE_FORMAT = /\w+ \(?(\w+)\)?[\/ ](\w+)/
        
         # Upstart does more than start or stop a service, creating multiple 'states' [1] that a service can be in.
         # In chef, when we ask a service to start, we expect it to have started before performing the next step
@@ -35,14 +36,18 @@ class Chef
         # [1] http://upstart.ubuntu.com/wiki/JobStates
         # [2] http://www.netsplit.com/2008/04/27/upstart-05-events/
 
-        def initialize(node, new_resource, collection=nil, definitions=nil, cookbook_loader=nil)
-          super(node, new_resource, collection, definitions, cookbook_loader)
-
-          platform, version = Chef::Platform.find_platform_and_version(node)
+        def initialize(new_resource, run_context)
+          # TODO: re-evaluate if this is needed after integrating cookbook fix
+          raise ArgumentError, "run_context cannot be nil" unless run_context
+          super
+          
+          run_context.node
+          
+          platform, version = Chef::Platform.find_platform_and_version(run_context.node)
           case platform
           when "ubuntu"
             case version
-            when /8.04/,/8.10/,/9.04/
+            when /8.04/,/8.10/,/9.04/,/10.04/
               @upstart_job_dir = "/etc/event.d"
               @upstart_conf_suffix = ""
             else
@@ -175,13 +180,13 @@ class Chef
         def upstart_state
           command = "/sbin/status #{@new_resource.service_name}"
           status = popen4(command) do |pid, stdin, stdout, stderr|
-            stdout.each do |line|
+            stdout.each_line do |line|
               # rsyslog stop/waiting
               # service goal/state
               # OR
               # rsyslog (stop) waiting
               # service (goal) state
-              line =~ /\w+ \(?(\w+)\)?[\/ ](\w+)/
+              line =~ UPSTART_STATE_FORMAT
               data = Regexp.last_match
               return data[2]
             end

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

@@ -20,8 +20,8 @@ require 'chef/provider/service/init'
 
 class Chef::Provider::Service::Windows < Chef::Provider::Service::Init
 
-  def initialize(node, new_resource, collection=nil, definitions=nil, cookbook_loader=nil)
-    super(node, new_resource, collection, definitions, cookbook_loader)
+  def initialize(new_resource, run_context)
+    super
     @init_command = "sc"
   end
 

data/lib/chef/provider/template.rb

@@ -1,6 +1,7 @@
 #
 # Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2008, 2010 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,70 +20,37 @@
 require 'chef/provider/file'
 require 'chef/mixin/template'
 require 'chef/mixin/checksum'
-require 'chef/mixin/find_preferred_file'
-require 'chef/rest'
-require 'chef/file_cache'
-require 'uri'
-require 'tempfile'
+require 'chef/file_access_control'
+
+#require 'chef/mixin/find_preferred_file'
+#require 'chef/rest'
+#require 'chef/file_cache'
+#require 'uri'
+#require 'tempfile'
 
 class Chef
   class Provider
 
     class Template < Chef::Provider::File
 
-      include Chef::Mixin::Checksum
+      #include Chef::Mixin::Checksum
       include Chef::Mixin::Template
-      include Chef::Mixin::FindPreferredFile
+      #include Chef::Mixin::FindPreferredFile
 
       def action_create
-        raw_template_file = nil
-
-        Chef::Log.debug("looking for template #{@new_resource.source} in cookbook #{cookbook_name.inspect}")
-
-        cache_file_name = "cookbooks/#{cookbook_name}/templates/default/#{@new_resource.source}"
-        template_cache_name = "#{cookbook_name}_#{@new_resource.source}"
-
-        if @new_resource.local
-          cache_file_name = @new_resource.source
-        elsif Chef::Config[:solo]
-          cache_file_name = solo_cache_file_name
-        else
-          raw_template_file = fetch_template_via_rest(cache_file_name, template_cache_name)
-        end
-
-        if template_updated?
-          Chef::Log.debug("Updating template for #{@new_resource} in the cache")
-          Chef::FileCache.move_to(raw_template_file.path, cache_file_name)
-        end
-
-        render_with_context(cache_file_name) do |template_file|
-
-          update = false
-
-          if ::File.exists?(@new_resource.path)
-            @new_resource.checksum(checksum(template_file.path))
-            if @new_resource.checksum != @current_resource.checksum
-              Chef::Log.debug("#{@new_resource} changed from #{@current_resource.checksum} to #{@new_resource.checksum}")
-              Chef::Log.info("Updating #{@new_resource} at #{@new_resource.path}")
-              update = true
-            end
+        render_with_context(template_location) do |rendered_template|
+          rendered(rendered_template)
+          if ::File.exist?(@new_resource.path) && content_matches?
+            Chef::Log.debug("#{@new_resource} content has not changed.")
+            set_all_access_controls(@new_resource.path)
           else
-            Chef::Log.info("Creating #{@new_resource} at #{@new_resource.path}")
-            update = true
-          end
-
-          if update
+            Chef::Log.info("Writing updated content for #{@new_resource} to #{@new_resource.path}")
             backup
-            FileUtils.cp(template_file.path, @new_resource.path)
+            set_all_access_controls(rendered_template.path)
+            FileUtils.cp(rendered_template.path, @new_resource.path)
             @new_resource.updated = true
-          else
-            Chef::Log.debug("#{@new_resource} is unchanged")
           end
         end
-
-        set_owner if @new_resource.owner != nil
-        set_group if @new_resource.group != nil
-        set_mode if @new_resource.mode != nil
       end
 
       def action_create_if_missing
@@ -93,86 +61,133 @@ class Chef
         end
       end
 
-      private
-
-      def template_updated
-        @template_updated = true
-      end
-
-      def template_not_updated
-        @template_updated = false
+      def template_location
+        Chef::Log.debug("looking for template #{@new_resource.source} in cookbook #{cookbook_name.inspect}")
+        @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 template_updated?
-        @template_updated
+      
+      def resource_cookbook
+        @new_resource.cookbook || @new_resource.cookbook_name
       end
 
-      def cookbook_name
-        @cookbook_name = (@new_resource.cookbook || @new_resource.cookbook_name)
+      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 render_with_context(cache_file_name, &block)
-        context = {}
-        context.merge!(@new_resource.variables)
-        context[:node] = @node
-        render_template(Chef::FileCache.load(cache_file_name), context, &block)
+      def content_matches?
+        @current_resource.checksum == @new_resource.checksum
       end
 
-      def solo_cache_file_name
-        filename = find_preferred_file(
-          cookbook_name,
-          :template,
-          @new_resource.source,
-          @node[:fqdn],
-          @node[:platform],
-          @node[:platform_version]
-        )
-        Chef::Log.debug("Using local file for template:#{filename}")
-        Pathname.new(filename).relative_path_from(Pathname.new(Chef::Config[:file_cache_path])).to_s
+      def set_all_access_controls(file)
+        access_controls = Chef::FileAccessControl.new(@new_resource, file)
+        access_controls.set_all
+        @new_resource.updated = access_controls.modified?
       end
 
-      def fetch_template_via_rest(cache_file_name, template_cache_name)
-        if @node.run_state[:template_cache].has_key?(template_cache_name)
-          Chef::Log.debug("I have already fetched the template for #{@new_resource} once this run, not checking again.")
-          template_not_updated
-          return false
-        end
-
-        r = Chef::REST.new(Chef::Config[:template_url])
-
-        current_checksum = nil
-
-        if Chef::FileCache.has_key?(cache_file_name)
-          current_checksum = self.checksum(Chef::FileCache.load(cache_file_name, false))
-        else
-          Chef::Log.debug("Template #{@new_resource} is not in the template cache")
-        end
-
-        template_url = generate_url(
-          @new_resource.source,
-          "templates",
-          {
-            :checksum => current_checksum
-          }
-        )
-
-        begin
-          raw_template_file = r.get_rest(template_url, true)
-          template_updated
-        rescue Net::HTTPRetriableError => e
-          if e.response.kind_of?(Net::HTTPNotModified)
-            Chef::Log.debug("Cached template for #{@new_resource} is unchanged")
-          else
-            raise e
-          end
-        end
+      # def locate_or_fetch_template
+      #   Chef::Log.debug("looking for template #{@new_resource.source} in cookbook #{cookbook_name.inspect}")
+      # 
+      #   cache_file_name = "cookbooks/#{cookbook_name}/templates/default/#{@new_resource.source}"
+      #   template_cache_name = "#{cookbook_name}_#{@new_resource.source}"
+      # 
+      #   if @new_resource.local
+      #     cache_file_name = @new_resource.source
+      #   elsif Chef::Config[:solo]
+      #     cache_file_name = solo_cache_file_name
+      #   else
+      #     raw_template_file = fetch_template_via_rest(cache_file_name, template_cache_name)
+      #   end
+      # 
+      #   if template_updated?
+      #     Chef::Log.debug("Updating template for #{@new_resource} in the cache")
+      #     Chef::FileCache.move_to(raw_template_file.path, cache_file_name)
+      #   end
+      #   cache_file_name
+      # end
 
-        # We have checked the cache for this template this run
-        @node.run_state[:template_cache][template_cache_name] = true
+      private
 
-        raw_template_file
+      # def template_updated
+      #   @template_updated = true
+      # end
+      # 
+      # def template_not_updated
+      #   @template_updated = false
+      # end
+      # 
+      # def template_updated?
+      #   @template_updated
+      # end
+      # 
+      # def cookbook_name
+      #   @cookbook_name = (@new_resource.cookbook || @new_resource.cookbook_name)
+      # end
+
+      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 solo_cache_file_name
+      #   filename = find_preferred_file(
+      #     cookbook_name,
+      #     :template,
+      #     @new_resource.source,
+      #     node[:fqdn],
+      #     node[:platform],
+      #     node[:platform_version]
+      #   )
+      #   Chef::Log.debug("Using local file for template:#{filename}")
+      #   Pathname.new(filename).relative_path_from(Pathname.new(Chef::Config[:file_cache_path])).to_s
+      # end
+      # 
+      # def fetch_template_via_rest(cache_file_name, template_cache_name)
+      #   if node.run_state[:template_cache].has_key?(template_cache_name)
+      #     Chef::Log.debug("I have already fetched the template for #{@new_resource} once this run, not checking again.")
+      #     template_not_updated
+      #     return false
+      #   end
+      # 
+      #   r = Chef::REST.new(Chef::Config[:template_url])
+      # 
+      #   current_checksum = nil
+      # 
+      #   if Chef::FileCache.has_key?(cache_file_name)
+      #     current_checksum = self.checksum(Chef::FileCache.load(cache_file_name, false))
+      #   else
+      #     Chef::Log.debug("Template #{@new_resource} is not in the template cache")
+      #   end
+      # 
+      #   template_url = generate_url(@new_resource.source, "templates", :checksum => current_checksum)
+      # 
+      #   begin
+      #     raw_template_file = r.get_rest(template_url, true)
+      #     template_updated
+      #   rescue Net::HTTPRetriableError
+      #     if e.response.kind_of?(Net::HTTPNotModified)
+      #       Chef::Log.debug("Cached template for #{@new_resource} is unchanged")
+      #     else
+      #       raise
+      #     end
+      #   end
+      # 
+      #   # We have checked the cache for this template this run
+      #   node.run_state[:template_cache][template_cache_name] = true
+      # 
+      #   raw_template_file
+      # end
+
     end
   end
 end