chef 0.10.4 → 0.10.6.beta.1

data/lib/chef/provider/file.rb

@@ -151,7 +151,11 @@ class Chef
       end
 
       def action_create_if_missing
-        action_create
+        if ::File.exists?(@new_resource.path)
+          Chef::Log.debug("File #{@new_resource.path} exists, taking no action.")
+        else
+          action_create
+        end
       end
 
       def action_delete

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

@@ -38,6 +38,7 @@ class Chef
         def create_group
           command = "groupadd"
           command << set_options
+          command << groupadd_options
           run_command(:command => command)
           modify_group_members    
         end
@@ -74,7 +75,16 @@ class Chef
           end
           opts << " #{@new_resource.group_name}"
         end
-        
+
+        def groupadd_options
+          opts = ''
+          case node[:platform]
+          when "centos", "redhat", "scientific", "fedora"
+            opts << " -r" if @new_resource.system
+          end
+          opts
+        end
+
       end
     end
   end

data/lib/chef/provider/ifconfig.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Jason Jackson (jason.jackson@monster.com)
-# Copyright:: Copyright (c) 2009 Jason Jackson
+# Author:: Jason K. Jackson (jasonjackson@gmail.com)
+# Copyright:: Copyright (c) 2009 Jason K. Jackson
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -21,6 +21,18 @@ require 'chef/mixin/command'
 require 'chef/provider'
 require 'erb'
 
+#  Recipe example:
+#
+#    int = {Hash with your network settings...}
+#
+#    ifconfig  int['ip'] do 
+#      ignore_failure  true 
+#      device  int['dev'] 
+#      mask    int['mask']  
+#      gateway int['gateway'] 
+#      mtu     int['mtu']
+#    end
+
 class Chef
   class Provider
     class Ifconfig < Chef::Provider
@@ -88,14 +100,33 @@ class Chef
         generate_config
       end
 
+      def action_enable
+        # check to see if load_current_resource found ifconfig
+        # enables, but does not manage config files
+        unless @current_resource.inet_addr
+          unless @new_resource.device == "lo"
+            command = "ifconfig #{@new_resource.device} #{@new_resource.name}"
+            command << " netmask #{@new_resource.mask}" if @new_resource.mask
+            command << " metric #{@new_resource.metric}" if @new_resource.metric
+            command << " mtu #{@new_resource.mtu}" if @new_resource.mtu
+          end
+
+          run_command(
+            :command => command
+          )
+          Chef::Log.info("#{@new_resource} enabled")
+          @new_resource.updated_by_last_action(true)
+        end
+      end
+
       def action_delete
         # check to see if load_current_resource found the interface
         if @current_resource.device
           command = "ifconfig #{@new_resource.device} down"
-
           run_command(
             :command => command
           )
+          delete_config
           Chef::Log.info("#{@new_resource} deleted")
           @new_resource.updated_by_last_action(true)
         else
@@ -103,8 +134,21 @@ class Chef
         end
       end
 
-      # This is a little lame of me, as if any of these values aren't filled out it leaves blank lines
-      # in the file.  Can refactor later to have this nice and tight.
+      def action_disable
+        # check to see if load_current_resource found the interface
+        # disables, but leaves config files in place.
+        if @current_resource.device
+          command = "ifconfig #{@new_resource.device} down"
+          run_command(
+            :command => command
+          )
+          Chef::Log.info("#{@new_resource} disabled")
+          @new_resource.updated_by_last_action(true)
+        else
+          Chef::Log.debug("#{@new_resource} does not exist - nothing to do")
+        end
+      end
+
       def generate_config
         b = binding
         case node[:platform]
@@ -117,6 +161,7 @@ class Chef
 <% if @new_resource.mask %>NETMASK=<%= @new_resource.mask %><% end %>
 <% if @new_resource.network %>NETWORK=<%= @new_resource.network %><% end %>
 <% if @new_resource.bcast %>BROADCAST=<%= @new_resource.bcast %><% end %>
+<% if @new_resource.onparent %>ONPARENT=<%= @new_resource.onparent %><% end %>
           }
           template = ::ERB.new(content)
           network_file = ::File.new("/etc/sysconfig/network-scripts/ifcfg-#{@new_resource.device}", "w")
@@ -129,6 +174,22 @@ class Chef
           # template
         end
       end
+
+      def delete_config
+        require 'fileutils'
+        case node[:platform]
+        when "centos","redhat","fedora"
+          ifcfg_file = "/etc/sysconfig/network-scripts/ifcfg-#{@new_resource.device}"
+          if ::File.exist?(ifcfg_file)
+            FileUtils.rm_f(ifcfg_file, :verbose => false, :force => true)
+          end
+        when "debian","ubuntu"
+          # delete configs
+        when "slackware"
+          # delete configs
+        end
+      end
+
     end
   end
 end

data/lib/chef/provider/package.rb

@@ -107,6 +107,28 @@ class Chef
         end
       end
 
+      def action_reconfig
+        if @current_resource.version == nil then
+          Chef::Log.debug("#{@new_resource} is NOT installed - nothing to do")
+          return
+        end
+
+        unless @new_resource.response_file then
+          Chef::Log.debug("#{@new_resource} no response_file provided - nothing to do")
+          return
+        end
+
+        status = preseed_package(@new_resource.package_name, @current_resource.version)
+        unless status then
+          Chef::Log.debug("#{@new_resource} preseeding has not changed - nothing to do")
+          return
+        end
+
+        status = reconfig_package(@new_resource.package_name, @current_resource.version)
+        @new_resource.updated_by_last_action(true) if status
+        Chef::Log.info("#{@new_resource} reconfigured")
+      end
+
       def install_package(name, version)
         raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :install"
       end
@@ -127,6 +149,10 @@ class Chef
         raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support pre-seeding package install/upgrade instructions - don't ask it to!"
       end
 
+      def reconfig_package(name, version)
+        raise( Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :reconfig" )
+      end
+
       def get_preseed_file(name, version)
         resource = preseed_resource(name, version)
         resource.run_action('create')
@@ -147,14 +173,24 @@ class Chef
 
         Chef::Log.debug("#{@new_resource} fetching preseed file to #{cache_seed_to}")
 
-        remote_file = Chef::Resource::CookbookFile.new(cache_seed_to, run_context)
-        remote_file.cookbook_name = @new_resource.cookbook_name
-        remote_file.source(@new_resource.response_file)
-        remote_file.backup(false)
+        begin
+          remote_file = Chef::Resource::Template.new(cache_seed_to, run_context)
+          remote_file.cookbook_name = @new_resource.cookbook_name
+          remote_file.source(@new_resource.response_file)
+          remote_file.backup(false)
+          provider = Chef::Platform.provider_for_resource(remote_file)
+          provider.template_location
+        rescue
+          Chef::Log.debug("#{@new_resource} fetching preseed file via Template resource failed, fallback to CookbookFile resource")
+          remote_file = Chef::Resource::CookbookFile.new(cache_seed_to, run_context)
+          remote_file.cookbook_name = @new_resource.cookbook_name
+          remote_file.source(@new_resource.response_file)
+          remote_file.backup(false)
+        end      
 
         remote_file
       end
-
+      
       def expand_options(options)
         options ? " #{options}" : ""
       end

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

@@ -129,6 +129,16 @@ class Chef
           end
         end
 
+        def reconfig_package(name, version)
+          Chef::Log.info("#{@new_resource} reconfiguring")
+          run_command_with_systems_locale(
+            :command => "dpkg-reconfigure #{name}",
+            :environment => {
+              "DEBIAN_FRONTEND" => "noninteractive"
+            }
+          )
+        end
+
       end
     end
   end

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

@@ -783,13 +783,26 @@ class Chef
           # Querying the cache
           #
 
+          # Check for package by name or name+arch
           def package_available?(package_name)
             refresh
+
             if @rpmdb.lookup(package_name)
-              true
+              return true
             else
-              false
+              if package_name =~ %r{^(.*)\.(.*)$}
+                pkg_name = $1
+                pkg_arch = $2
+
+                if matches = @rpmdb.lookup(pkg_name)
+                  matches.each do |m|
+                    return true if m.arch == pkg_arch
+                  end
+                end
+              end
             end
+
+            return false
           end
 
           # Returns a array of packages satisfying an RPMDependency
@@ -821,6 +834,7 @@ class Chef
           end
 
           private
+
           def version(package_name, arch=nil, is_available=false, is_installed=false)
             refresh
             packages = @rpmdb[package_name]
@@ -910,6 +924,37 @@ class Chef
           arch ? ".#{arch}" : nil
         end
 
+        def yum_command(command)
+          status, stdout, stderr = output_of_command(command, {})
+
+          # This is fun: rpm can encounter errors in the %post/%postun scripts which aren't
+          # considered fatal - meaning the rpm is still successfully installed. These issue
+          # cause yum to emit a non fatal warning but still exit(1). As there's currently no
+          # way to suppress this behavior and an exit(1) will break a Chef run we make an
+          # effort to trap these and re-run the same install command - it will either fail a
+          # second time or succeed.
+          #
+          # A cleaner solution would have to be done in python and better hook into
+          # yum/rpm to handle exceptions as we see fit.
+          if status.exitstatus == 1
+            stdout.each_line do |l|
+              # rpm-4.4.2.3 lib/psm.c line 2182
+              if l =~ %r{^error: %(post|postun)\(.*\) scriptlet failed, exit status \d+$}
+                Chef::Log.warn("#{@new_resource} caught non-fatal scriptlet issue: \"#{l}\". Can't trust yum exit status " +
+                               "so running install again to verify.")
+                status, stdout, stderr = output_of_command(command, {})
+                break
+              end
+            end
+          end
+
+          if status.exitstatus > 0
+            command_output = "STDOUT: #{stdout}"
+            command_output << "STDERR: #{stderr}"
+            handle_command_failures(status, command_output, {})
+          end
+        end
+
         # Standard Provider methods for Parent
         #
 
@@ -918,7 +963,15 @@ class Chef
             @yum.reload
           end
 
+          # At this point package_name could be:
+          # 
+          # 1) a package name, eg: "foo"
+          # 2) a package name.arch, eg: "foo.i386"
+          # 3) or a dependency, eg: "foo >= 1.1"
+
+          # Check if we have name or name+arch which has a priority over a dependency
           unless @yum.package_available?(@new_resource.package_name)
+            # If they aren't in the installed packages they could be a dependency
             parse_dependency
           end
 
@@ -968,9 +1021,7 @@ class Chef
 
         def install_package(name, version)
           if @new_resource.source
-            run_command_with_systems_locale(
-              :command => "yum -d0 -e0 -y#{expand_options(@new_resource.options)} localinstall #{@new_resource.source}"
-            )
+            yum_command("yum -d0 -e0 -y#{expand_options(@new_resource.options)} localinstall #{@new_resource.source}")
           else
             # Work around yum not exiting with an error if a package doesn't exist for CHEF-2062
             if @yum.version_available?(name, version, arch)
@@ -995,9 +1046,7 @@ class Chef
                 end
               end
 
-              run_command_with_systems_locale(
-                :command => "yum -d0 -e0 -y#{expand_options(@new_resource.options)} #{method} #{name}-#{version}#{yum_arch}"
-              )
+              yum_command("yum -d0 -e0 -y#{expand_options(@new_resource.options)} #{method} #{name}-#{version}#{yum_arch}")
             else
               raise Chef::Exceptions::Package, "Version #{version} of #{name} not found. Did you specify both version " +
                                                "and release? (version-release, e.g. 1.84-10.fc6)"
@@ -1033,13 +1082,9 @@ class Chef
 
         def remove_package(name, version)
           if version
-            run_command_with_systems_locale(
-             :command => "yum -d0 -e0 -y#{expand_options(@new_resource.options)} remove #{name}-#{version}#{yum_arch}"
-            )
+            yum_command("yum -d0 -e0 -y#{expand_options(@new_resource.options)} remove #{name}-#{version}#{yum_arch}")
           else
-            run_command_with_systems_locale(
-             :command => "yum -d0 -e0 -y#{expand_options(@new_resource.options)} remove #{name}#{yum_arch}"
-            )
+            yum_command("yum -d0 -e0 -y#{expand_options(@new_resource.options)} remove #{name}#{yum_arch}")
           end
           if flush_cache[:after]
             @yum.reload

data/lib/chef/provider/remote_directory.rb

@@ -44,7 +44,6 @@ class Chef
           files_to_purge.delete(::File.join(@new_resource.path, cookbook_file_relative_path))
         end
         purge_unmanaged_files(files_to_purge)
-        Chef::Log.info("#{@new_resource} created")
       end
 
       def action_create_if_missing

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

@@ -17,13 +17,13 @@
 #
 
 require 'chef/provider/service'
-require 'chef/provider/service/init'
+require 'chef/provider/service/invokercd'
 require 'chef/mixin/command'
 
 class Chef
   class Provider
     class Service
-      class Debian < Chef::Provider::Service::Init
+      class Debian < Chef::Provider::Service::Invokercd
         UPDATE_RC_D_ENABLED_MATCHES = /\/rc[\dS].d\/S|not installed/i
         UPDATE_RC_D_PRIORITIES = /\/rc([\dS]).d\/([SK])(\d\d)/i
 

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

@@ -0,0 +1,35 @@
+#
+# Author:: AJ Christensen (<aj@hjksolutions.com>)
+# Copyright:: Copyright (c) 2008 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/provider/service/init'
+require 'chef/mixin/command'
+
+class Chef
+  class Provider
+    class Service
+      class Invokercd < Chef::Provider::Service::Init
+        
+        def initialize(new_resource, run_context)
+          super
+          @init_command = "/usr/sbin/invoke-rc.d #{@new_resource.service_name}"
+        end
+      end
+    end
+  end
+end

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

@@ -1,7 +1,8 @@
 #
 # Author:: Nuo Yan <nuo@opscode.com>
 # Author:: Bryan McLellan <btm@loftninjas.org>
-# Copyright:: Copyright (c) 2010 Opscode, Inc
+# Author:: Seth Chisamore <schisamo@opscode.com>
+# Copyright:: Copyright (c) 2010-2011 Opscode, Inc
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,130 +18,138 @@
 # limitations under the License.
 #
 
-# pick up popen4 from chef/mixin/command/windows
-require 'chef/mixin/command'
 require 'chef/provider/service/simple'
+if RUBY_PLATFORM =~ /mswin|mingw32|windows/
+  require 'win32/service'
+end
 
-class Chef::Provider::Service::Windows < Chef::Provider::Service::Simple
-
-  def initialize(new_resource, run_context)
-    super
-    @init_command = "sc"
-  end
-
-  def io_popen(command)
-    io = IO.popen(command)
-    entries = io.readlines
-    io.close
-    entries
-  end
+class Chef::Provider::Service::Windows < Chef::Provider::Service
+  RUNNING = 'running'
+  STOPPED = 'stopped'
+  AUTO_START = 'auto start'
+  DISABLED = 'disabled'
 
   def load_current_resource
     @current_resource = Chef::Resource::Service.new(@new_resource.name)
-    @current_resource.service_name(@new_resource.service_name)
-    begin
-      # Check if service is running
-      status = popen4("#{@init_command} query #{@new_resource.service_name}") do |pid, stdin, stdout, stderr|
-        stdout.each_line do |line|
-          raise Chef::Exceptions::Service, "Service #{@new_resource.service_name} does not exist.\n#{stdout}\n" if line =~ /FAILED 1060/
-          @current_resource.running true if line =~/RUNNING/
-        end
-      end
-
-      # Check if service is enabled
-      status = popen4("#{@init_command} qc #{@new_resource.service_name}") do |pid, stdin, stdout, stderr|
-        stdout.each_line do |line|
-          raise Chef::Exceptions::Service, "Service #{@new_resource.service_name} does not exist.\n#{stdout}\n" if line =~ /FAILED 1060/
-          @current_resource.enabled true if line =~/AUTO_START/
-        end
-      end
-
-      Chef::Log.debug "#{@new_resource} running: #{@current_resource.running}"
-    rescue Exception => e
-      raise Chef::Exceptions::Service, "Exception determining state of service #{@new_resource.service_name}: #{e.message}"
-    end
+    @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)
+    Chef::Log.debug "#{@new_resource} enabled: #{@current_resource.enabled}"
     @current_resource
   end
 
   def start_service
-    begin
-      if @new_resource.start_command
-        popen4(@new_resource.start_command) do |pid, stdin, stdout, stderr|
-          Chef::Log.debug stdout.readlines
-        end
+    if Win32::Service.exists?(@new_resource.service_name)
+      if current_state == RUNNING
+        Chef::Log.debug "#{@new_resource} already started - nothing to do"
       else
-        popen4("#{@init_command} start #{@new_resource.service_name}") do |pid, stdin, stdout, stderr|
-          output = stdout.readlines
-          Chef::Log.debug output.join
-          output.join =~ /RUNNING/ || output.join =~ /START_PENDING/ ? true : false
+        if @new_resource.start_command
+          Chef::Log.debug "#{@new_resource} starting service using the given start_command"
+          shell_out!(@new_resource.start_command)
+        else
+          spawn_command_thread do
+            Win32::Service.start(@new_resource.service_name)
+            wait_for_state(RUNNING)
+          end
         end
+        @new_resource.updated_by_last_action(true)
       end
-    rescue Exception => e
-      raise Chef::Exceptions::Service, "Failed to start service #{@new_resource.service_name}: #{e.message}"
+    else
+        Chef::Log.debug "#{@new_resource} does not exist - nothing to do"
     end
   end
 
   def stop_service
-    begin
-      if @new_resource.stop_command
-        Chef::Log.debug "#{@new_resource} stopping service using the given stop_command"
-        popen4(@new_resource.stop_command) do |pid, stdin, stdout, stderr|
-          Chef::Log.debug stdout.readlines
+    if Win32::Service.exists?(@new_resource.service_name)
+      if current_state == RUNNING
+        if @new_resource.stop_command
+          Chef::Log.debug "#{@new_resource} stopping service using the given stop_command"
+          shell_out!(@new_resource.stop_command)
+        else
+          spawn_command_thread do
+            Win32::Service.stop(@new_resource.service_name)
+            wait_for_state(STOPPED)
+          end
         end
+        @new_resource.updated_by_last_action(true)
       else
-        popen4("#{@init_command} stop #{@new_resource.service_name}") do |pid, stdin, stdout, stderr|
-          output = stdout.readlines
-          Chef::Log.debug output.join
-          raise Chef::Exceptions::Service, "Service #{@new_resource.service_name} has dependencies and cannot be stopped.\n" if output.join =~ /FAILED 1051/
-          output.join =~ /1/
-        end
+        Chef::Log.debug "#{@new_resource} already stopped - nothing to do"
       end
-    rescue Exception => e
-      raise Chef::Exceptions::Service, "Failed to start service #{@new_resource.service_name}: #{e.message}"
+    else
+      Chef::Log.debug "#{@new_resource} does not exist - nothing to do"
     end
   end
 
   def restart_service
-    begin
+    if Win32::Service.exists?(@new_resource.service_name)
       if @new_resource.restart_command
         Chef::Log.debug "#{@new_resource} restarting service using the given restart_command"
-        popen4(@new_resource.restart_command) do |pid, stdin, stdout, stderr|
-          Chef::Log.debug stdout.readlines
-        end
+        shell_out!(@new_resource.restart_command)
       else
         stop_service
-        sleep 1
         start_service
       end
-    rescue Exception => e
-      raise Chef::Exceptions::Service, "Failed to start service #{@new_resource.service_name}: #{e.message}"
+      @new_resource.updated_by_last_action(true)
+    else
+      Chef::Log.debug "#{@new_resource} does not exist - nothing to do"
     end
   end
 
-  def enable_service()
-    begin
-      popen4("#{@init_command} config #{@new_resource.service_name} start= #{determine_startup_type}") do |pid, stdin, stdout, stderr|
-        stdout.readlines.join =~ /SUCCESS/
+  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
-    rescue Exception => e
-      raise Chef::Exceptions::Service, "Failed to start service #{@new_resource.service_name}: #{e.message}"
+    else
+      Chef::Log.debug "#{@new_resource} does not exist - nothing to do"
     end
   end
 
-  def disable_service()
-    begin
-      popen4("#{@init_command} config #{@new_resource.service_name} start= disabled") do |pid, stdin, stdout, stderr|
-        stdout.readlines.join =~ /SUCCESS/
+  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
-    rescue Exception => e
-      raise Chef::Exceptions::Service, "Failed to start service #{@new_resource.service_name}: #{e.message}"
+    else
+      Chef::Log.debug "#{@new_resource} does not exist - nothing to do"
     end
   end
 
   private
+  def current_state
+    Win32::Service.status(@new_resource.service_name).current_state
+  end
 
-  def determine_startup_type
-    {:automatic => 'auto', :mannual => 'demand'}[@new_resource.startup_type]
+  def start_type
+    Win32::Service.config_info(@new_resource.service_name).start_type
   end
 
+  # Helper method that waits for a status to change its state since state
+  # changes aren't usually instantaneous.
+  def wait_for_state(desired_state)
+    sleep 1 until current_state == desired_state
+  end
+
+  # There ain't no party like a thread party...
+  def spawn_command_thread
+    worker = Thread.new do
+      yield
+    end
+    Timeout.timeout(60) do
+      worker.join
+    end
+  end
 end