chef 0.9.6 → 0.9.8.beta.1

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

@@ -74,14 +74,15 @@ class Chef
 
            # do a dry run to get the latest version
            command = "#{easy_install_binary_path} -n #{@new_resource.package_name}"
-           pid, stdin, stdout, stderr = popen4(command)
-           dry_run_output = ""
-           stdout.each do |line|
-             dry_run_output << line
+           status  = popen4(command) do |pid, stdin, stdout, stderr|
+             dry_run_output = ""
+             stdout.each do |line|
+               dry_run_output << line
+             end
+             dry_run_output[/(.*)Best match: (.*) (.*)\n/]
+             @candidate_version = $3
+             @candidate_version
            end
-           dry_run_output[/(.*)Best match: (.*) (.*)\n/]
-           @candidate_version = $3
-           @candidate_version
         end
 
         def install_package(name, version)

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

@@ -55,7 +55,7 @@ class Chef
           status = popen4("pacman -Ss #{@new_resource.package_name}") do |pid, stdin, stdout, stderr|
             stdout.each do |line|
               case line
-                when /^(extra|core|community)\/#{@new_resource.package_name} (.+)$/
+                when /^(extra|core|community)\/#{Regexp.escape(@new_resource.package_name)} (.+)$/
                   # $2 contains a string like "4.4.0-1 (kde kdenetwork)" or "3.10-4 (base)"
                   # simply split by space and use first token
                   @candidate_version = $2.split(" ").first

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

@@ -71,11 +71,11 @@ class Chef
         def install_package(name, version)
           unless @current_resource.version
             run_command_with_systems_locale(
-              :command => "rpm -i #{@new_resource.source}"
+              :command => "rpm #{@new_resource.options} -i #{@new_resource.source}"
             )
           else
             run_command_with_systems_locale(
-              :command => "rpm -U #{@new_resource.source}"
+              :command => "rpm #{@new_resource.options} -U #{@new_resource.source}"
             )
           end
         end
@@ -85,11 +85,11 @@ class Chef
         def remove_package(name, version)
           if version
             run_command_with_systems_locale(
-              :command => "rpm -e #{name}-#{version}"
+              :command => "rpm #{@new_resource.options} -e #{name}-#{version}"
             )
           else
             run_command_with_systems_locale(
-              :command => "rpm -e #{name}"
+              :command => "rpm #{@new_resource.options} -e #{name}"
             )
           end
         end

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

@@ -0,0 +1,127 @@
+#
+# 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/package'
+require 'chef/mixin/command'
+require 'chef/resource/package'
+
+class Chef
+  class Provider
+    class Package
+      class Solaris < Chef::Provider::Package
+
+        # def initialize(*args)
+        #   super
+        #   @current_resource = Chef::Resource::Package.new(@new_resource.name)
+        # end
+
+        def load_current_resource
+          @current_resource = Chef::Resource::Package.new(@new_resource.name)
+          @current_resource.package_name(@new_resource.package_name)
+          @new_resource.version(nil)
+
+          if @new_resource.source
+            unless ::File.exists?(@new_resource.source)
+              raise Chef::Exceptions::Package, "Package #{@new_resource.name} not found: #{@new_resource.source}"
+            end
+
+            Chef::Log.debug("Checking pkg status for #{@new_resource.package_name}")
+            status = popen4("pkginfo -l -d #{@new_resource.source} #{@new_resource.package_name}") do |pid, stdin, stdout, stderr|
+              stdout.each do |line|
+                case line
+                when /VERSION:\s+(.+)/
+                  @new_resource.version($1)
+                end
+              end
+            end
+          elsif Array(@new_resource.action).include?(:install)
+            raise Chef::Exceptions::Package, "Source for package #{@new_resource.name} required for action install"
+          end
+
+          Chef::Log.debug("Checking install state for #{@current_resource.package_name}")
+          status = popen4("pkginfo -l #{@current_resource.package_name}") do |pid, stdin, stdout, stderr|
+            stdout.each do |line|
+              case line
+              when /VERSION:\s+(.+)/
+                Chef::Log.debug("Package #{@current_resource.package_name} #{$1} is already installed")
+                @current_resource.version($1)
+              end
+            end
+          end
+
+          unless status.exitstatus == 0 || status.exitstatus == 1
+            raise Chef::Exceptions::Package, "pkginfo failed - #{status.inspect}!"
+          end
+
+          unless @current_resource.version.nil?
+            @current_resource.version(nil)
+          end
+
+          @current_resource
+        end
+
+        def candidate_version
+          return @candidate_version if @candidate_version
+          status = popen4("pkginfo -l -d #{@new_resource.source} #{new_resource.package_name}") do |pid, stdin, stdout, stderr|
+            stdout.each_line do |line|
+              case line
+              when /VERSION:\s+(.+)/
+                @candidate_version = $1
+                @new_resource.version($1)
+                Chef::Log.debug("candidate_version: setting install candidate version to #{@candidate_version}")
+              end
+            end
+          end
+          unless status.exitstatus == 0
+            raise Chef::Exceptions::Package, "pkginfo -l -d #{@new_resource.source} - #{status.inspect}!"
+          end
+          @candidate_version
+        end
+
+        def install_package(name, version)
+          Chef::Log.debug("Options: #{@new_resource.options}")
+          if @new_resource.options.nil?
+            run_command_with_systems_locale(
+                    :command => "pkgadd -n -d #{@new_resource.source} all"
+                  )
+            Chef::Log.debug("Installed package: #{@new_resource.package_name} #{@new_resource.version} from: #{@new_resource.source}")
+          else
+            run_command_with_systems_locale(
+              :command => "pkgadd -n#{expand_options(@new_resource.options)} -d #{@new_resource.source} all"
+            )
+            Chef::Log.debug("Installed package: #{@new_resource.package_name} #{@new_resource.version} from: #{@new_resource.source}")
+          end
+        end
+
+        def remove_package(name, version)
+          if @new_resource.options.nil?
+            run_command_with_systems_locale(
+                    :command => "pkgrm -n #{name}"
+                  )
+            Chef::Log.debug("Removed package #{@new_resource.package_name} #{@new_resource.version}")
+          else
+            run_command_with_systems_locale(
+              :command => "pkgrm -n#{expand_options(@new_resource.options)} #{name}"
+            )
+            Chef::Log.debug("Removed package #{@new_resource.package_name} #{@new_resource.version}")
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -24,8 +24,8 @@ require 'singleton'
 class Chef
   class Provider
     class Package
-      class Yum < Chef::Provider::Package  
-      
+      class Yum < Chef::Provider::Package
+
         class YumCache
           include Chef::Mixin::Command
           include Singleton
@@ -68,8 +68,11 @@ class Chef
                 if !@data.has_key?(name)
                   @data[name] = Hash.new
                 end
-                @data[name][type_sym] = { :epoch => epoch, :version => version,
-                                          :release => release, :arch => arch }
+                if !@data[name].has_key?(type_sym)
+                  @data[name][type_sym] = Hash.new
+                end
+                @data[name][type_sym][arch] = { :epoch => epoch, :version => version,
+                                                :release => release }
               end
               
               error = stderr.readlines
@@ -83,38 +86,58 @@ class Chef
           end
           alias :reload :load_data
 
-          def version(package_name, type)
+          def version(package_name, type, arch)
             if (x = @data[package_name])
               if (y = x[type])
-                return "#{y[:version]}-#{y[:release]}"
+                if arch
+                  if (z = y[arch])
+                    return "#{z[:version]}-#{z[:release]}"
+                  end
+                else
+                  # no arch specified - take the first match
+                  z = y.to_a[0][1]
+                  return "#{z[:version]}-#{z[:release]}"
+                end
               end
             end
 
             nil
           end
 
-          def installed_version(package_name)
-            version(package_name, :installed)
+          def installed_version(package_name, arch)
+            version(package_name, :installed, arch)
           end
 
-          def candidate_version(package_name)
-            version(package_name, :available)
+          def candidate_version(package_name, arch)
+            version(package_name, :available, arch)
           end
-         
+
           def flush
             @data.clear
           end
         end
 
         def initialize(new_resource, run_context)
-          @yum = YumCache.instance
           super
+          @yum = YumCache.instance
+        end
+
+        def arch
+          if @new_resource.respond_to?("arch")
+            @new_resource.arch 
+          else
+            nil
+          end
         end
-      
+
+        def yum_arch
+          arch ? ".#{arch}" : nil
+        end
+
         def load_current_resource
           @current_resource = Chef::Resource::Package.new(@new_resource.name)
           @current_resource.package_name(@new_resource.package_name)
-        
+
           if @new_resource.source
             unless ::File.exists?(@new_resource.source)
               raise Chef::Exceptions::Package, "Package #{@new_resource.name} not found: #{@new_resource.source}"
@@ -132,42 +155,42 @@ class Chef
             end
           end
 
-          Chef::Log.debug("Checking yum info for #{@new_resource.package_name}")
-    
+          Chef::Log.debug("Checking yum info for #{@new_resource.package_name}#{yum_arch}")
+
           @yum.refresh
 
-          installed_version = @yum.installed_version(@new_resource.package_name)
-          @candidate_version = @yum.candidate_version(@new_resource.package_name)
-          
+          installed_version = @yum.installed_version(@new_resource.package_name, arch)
+          @candidate_version = @yum.candidate_version(@new_resource.package_name, arch)
+
           @current_resource.version(installed_version)
           if candidate_version
             @candidate_version = candidate_version
           else
             @candidate_version = installed_version
           end
-        
+
           @current_resource
         end
 
         def install_package(name, version)
           if @new_resource.source 
             run_command_with_systems_locale(
-              :command => "yum -d0 -e0 -y localinstall #{@new_resource.source}"
+              :command => "yum -d0 -e0 -y #{@new_resource.options} localinstall #{@new_resource.source}"
             )
           else
             run_command_with_systems_locale(
-              :command => "yum -d0 -e0 -y install #{name}-#{version}"
+              :command => "yum -d0 -e0 -y #{@new_resource.options} install #{name}-#{version}#{yum_arch}"
             )
           end
           @yum.flush
         end
-      
+
         def upgrade_package(name, version)
           # If we're not given a version, running update is the correct
           # option. If we are, then running install_package is right.
           unless version
             run_command_with_systems_locale(
-              :command => "yum -d0 -e0 -y update #{name}"
+              :command => "yum -d0 -e0 -y #{@new_resource.options} update #{name}#{yum_arch}"
             )   
             @yum.flush
           else
@@ -178,21 +201,21 @@ class Chef
         def remove_package(name, version)
           if version
             run_command_with_systems_locale(
-             :command => "yum -d0 -e0 -y remove #{name}-#{version}"
+             :command => "yum -d0 -e0 -y #{@new_resource.options} remove #{name}-#{version}#{yum_arch}"
             )
           else
             run_command_with_systems_locale(
-             :command => "yum -d0 -e0 -y remove #{name}"
+             :command => "yum -d0 -e0 -y #{@new_resource.options} remove #{name}#{yum_arch}"
             )
           end
             
           @yum.flush
         end
-      
+
         def purge_package(name, version)
           remove_package(name, version)
         end
-      
+
       end
     end
   end

data/lib/chef/provider/remote_directory.rb

@@ -36,8 +36,11 @@ class Chef
         super
         Chef::Log.debug("Doing a remote recursive directory transfer for #{@new_resource}")
           
-        files_to_purge = Set.new Dir[::File.join(@new_resource.path, '**', '*')]
-
+        files_to_purge = Set.new(
+          Dir.glob(::File.join(@new_resource.path, '**', '*'), ::File::FNM_DOTMATCH).select do |name|
+            name !~ /(?:^|#{Regexp.escape(::File::SEPARATOR)})\.\.?$/
+          end
+        )
         files_to_transfer.each do |cookbook_file_relative_path|
           create_cookbook_file(cookbook_file_relative_path)
           files_to_purge.delete(::File.dirname(::File.join(@new_resource.path, cookbook_file_relative_path)))

data/lib/chef/provider/remote_file.rb

@@ -71,7 +71,7 @@ class Chef
       end
 
       def current_resource_matches_target_checksum?
-        @new_resource.checksum && @current_resource.checksum && @current_resource.checksum =~ /^#{@new_resource.checksum}/
+        @new_resource.checksum && @current_resource.checksum && @current_resource.checksum =~ /^#{Regexp.escape(@new_resource.checksum)}/
       end
 
       def matches_current_checksum?(candidate_file)

data/lib/chef/provider/ruby_block.rb

@@ -26,6 +26,7 @@ class Chef
 
       def action_create
         @new_resource.block.call
+        @new_resource.updated = true
       end
     end
   end

data/lib/chef/provider/script.rb

@@ -29,7 +29,7 @@ class Chef
 
         set_owner_and_group
 
-        @new_resource.command("#{@new_resource.interpreter} #{script_file.path}")
+        @new_resource.command("\"#{@new_resource.interpreter}\" \"#{script_file.path}\"")
         super
       ensure
         unlink_script_file
@@ -52,4 +52,4 @@ class Chef
 
     end
   end
-end
+end

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

@@ -25,7 +25,8 @@ class Chef
     class Service
       class Debian < Chef::Provider::Service::Init
         UPDATE_RC_D_ENABLED_MATCHES = /etc\/rc[\dS].d\/S|not installed/i
-        
+        UPDATE_RC_D_PRIORITIES = /etc\/rc([\dS]).d\/([SK])(\d\d)/i
+
         def load_current_resource
           super
           
@@ -51,16 +52,51 @@ class Chef
           assert_update_rcd_available
 
           status = popen4("/usr/sbin/update-rc.d -n -f #{@current_resource.service_name} remove") do |pid, stdin, stdout, stderr|
+            priority = {}
+            enabled = false
+
             stdout.each_line do |line|
-              return true if line =~ UPDATE_RC_D_ENABLED_MATCHES
+              if UPDATE_RC_D_PRIORITIES =~ line
+                priority[$1] = [($2 == "S" ? :start : :stop), $3]
+              end
+              if line =~ UPDATE_RC_D_ENABLED_MATCHES
+                enabled = true
+              end
             end
+            @current_resource.enabled enabled
+            @current_resource.priority priority
           end  
 
           unless status.exitstatus == 0
             raise Chef::Exceptions::Service, "/usr/sbin/update-rc.d -n -f #{@current_resource.service_name} failed - #{status.inspect}"
           end
-          
-          false
+          @current_resource.enabled
+        end
+
+        def enable_service()
+          # If we have a priority which is just a number, we have to
+          # construct the actual priority object
+
+          if @new_resource.priority.is_a? Integer
+            run_command(:command => "/usr/sbin/update-rc.d #{@new_resource.service_name} defaults #{@new_resource.priority} #{100 - @new_resource.priority}")
+          elsif @new_resource.priority.is_a? Hash
+            args = ""
+            @new_resource.priority.each do |level, o|
+              action = o[0]
+              priority = o[1]
+              args += "#{action} #{priority} #{level} . "
+            end
+            run_command(:command => "/usr/sbin/update-rc.d #{@new_resource.service_name} #{args}")
+          else # No priority, go with update-rc.d defaults
+            run_command(:command => "/usr/sbin/update-rc.d #{@new_resource.service_name} defaults")
+          end
+
+        end
+
+        def disable_service()
+          run_command(:command => "/usr/sbin/update-rc.d #{@new_resource.service_name} disable")
+#          @new_resource.priority({2 => [:stop, 80]})
+#          enable_service
         end
         
       end