chef 0.10.8 → 0.10.10.beta.1

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

@@ -25,7 +25,7 @@ class Chef
   class Provider
     class Package
       class Dpkg < Chef::Provider::Package::Apt
-        DPKG_INFO = /([a-z\d\-\+]+)\t([\w\d.~-]+)/
+        DPKG_INFO = /([a-z\d\-\+\.]+)\t([\w\d.~-]+)/
         DPKG_INSTALLED = /^Status: install ok installed/
         DPKG_VERSION = /^Version: (.+)$/
 

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

@@ -24,7 +24,7 @@ class Chef
   class Provider
     class Package
       class Portage < Chef::Provider::Package
-        PACKAGE_NAME_PATTERN = %r{(([^/]+)/)?([^/]+)}
+        PACKAGE_NAME_PATTERN = %r{(?:([^/]+)/)?([^/]+)}
 
         def load_current_resource
           @current_resource = Chef::Resource::Package.new(@new_resource.name)
@@ -32,7 +32,7 @@ class Chef
 
           @current_resource.version(nil)
 
-          _, category_with_slash, category, pkg = %r{^#{PACKAGE_NAME_PATTERN}$}.match(@new_resource.package_name).to_a
+          category, pkg = %r{^#{PACKAGE_NAME_PATTERN}$}.match(@new_resource.package_name)[1,2]
 
           possibilities = Dir["/var/db/pkg/#{category || "*"}/#{pkg}-*"].map {|d| d.sub(%r{/var/db/pkg/}, "") }
           versions = possibilities.map do |entry|
@@ -43,7 +43,10 @@ class Chef
 
           if versions.size > 1
             atoms = versions.map {|v| v.first }.sort
-            raise Chef::Exceptions::Package, "Multiple packages found for #{@new_resource.package_name}: #{atoms.join(" ")}. Specify a category."
+            categories = atoms.map {|v| v.split('/')[0] }.uniq
+            if !category && categories.size > 1
+              raise Chef::Exceptions::Package, "Multiple packages found for #{@new_resource.package_name}: #{atoms.join(" ")}. Specify a category."
+            end
           elsif versions.size == 1
             @current_resource.version(versions.first.last)
             Chef::Log.debug("#{@new_resource} current version #{$1}")

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

@@ -65,6 +65,17 @@ class Chef
             raise NotImplementedError
           end
 
+          ## 
+          # A rubygems specification object containing the list of gemspecs for all
+          # available gems in the gem installation.
+          # Implemented by subclasses
+          # For rubygems >= 1.8.0
+          # === Returns
+          # Gem::Specification
+          def gem_specification
+            raise NotImplementedError
+          end
+
           ##
           # Lists the installed versions of +gem_name+, constrained by the
           # version spec in +gem_dep+
@@ -74,7 +85,11 @@ class Chef
           # === Returns
           # [Gem::Specification]  an array of Gem::Specification objects
           def installed_versions(gem_dep)
-            gem_source_index.search(gem_dep)
+            if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.8.0')
+              gem_specification.find_all_by_name(gem_dep.name, gem_dep)
+            else
+              gem_source_index.search(gem_dep)
+            end
           end
 
           ##
@@ -203,6 +218,10 @@ class Chef
             Gem.source_index
           end
 
+          def gem_specification
+            Gem::Specification
+          end
+
           def candidate_version_from_remote(gem_dependency, *sources)
             with_gem_sources(*sources) do
               find_newest_remote_version(gem_dependency, *sources)
@@ -213,7 +232,7 @@ class Chef
 
         class AlternateGemEnvironment < GemEnvironment
           JRUBY_PLATFORM = /(:?universal|x86_64|x86)\-java\-[0-9\.]+/
-          
+
           def self.gempath_cache
             @gempath_cache ||= {}
           end
@@ -246,6 +265,15 @@ class Chef
             @source_index ||= Gem::SourceIndex.from_gems_in(*gem_paths.map { |p| p + '/specifications' })
           end
 
+          def gem_specification
+            # Only once, dirs calls a reset
+            unless @specification
+              Gem::Specification.dirs = gem_paths
+              @specification = Gem::Specification
+            end
+            @specification
+          end
+
           ##
           # Attempt to detect the correct platform settings for the target gem
           # environment.
@@ -311,18 +339,51 @@ class Chef
               raise ArgumentError, msg
             end
             @gem_env = AlternateGemEnvironment.new(new_resource.gem_binary)
+            Chef::Log.debug("#{@new_resource} using gem '#{new_resource.gem_binary}'")
+          elsif is_omnibus? && (!@new_resource.instance_of? Chef::Resource::ChefGem)
+            # Opscode Omnibus - The ruby that ships inside omnibus is only used for Chef
+            # Default to installing somewhere more functional
+            gem_location = find_gem_by_path
+            @gem_env = AlternateGemEnvironment.new(gem_location)
+            Chef::Log.debug("#{@new_resource} using gem '#{gem_location}'")
           else
             @gem_env = CurrentGemEnvironment.new
+            Chef::Log.debug("#{@new_resource} using gem from running ruby environment")
+          end
+        end
+
+        def is_omnibus?
+          if RbConfig::CONFIG['bindir'] == "/opt/opscode/embedded/bin"
+            Chef::Log.debug("#{@new_resource} detected omnibus installation in #{RbConfig::CONFIG['bindir']}")
+            # Omnibus installs to a static path because of linking on unix, find it.
+            true
+          elsif RbConfig::CONFIG['bindir'].sub(/^[\w]:/, '')  == "/opscode/chef/embedded/bin"
+            Chef::Log.debug("#{@new_resource} detected omnibus installation in #{RbConfig::CONFIG['bindir']}")
+            # windows, with the drive letter removed
+            true
+          else
+            false
           end
         end
 
+        def find_gem_by_path
+          Chef::Log.debug("#{@new_resource} searching for 'gem' binary in path: #{ENV['PATH']}")
+          separator = ::File::ALT_SEPARATOR ? ::File::ALT_SEPARATOR : ::File::SEPARATOR
+          path_to_first_gem = ENV['PATH'].split(::File::PATH_SEPARATOR).select { |path| ::File.exists?(path + separator + "gem") }.first
+          raise Chef::Exceptions::FileNotFound, "Unable to find 'gem' binary in path: #{ENV['PATH']}" if path_to_first_gem.nil?
+          path_to_first_gem + separator + "gem"
+        end
+
         def gem_dependency
           Gem::Dependency.new(@new_resource.package_name, @new_resource.version)
         end
 
         def source_is_remote?
           return true if @new_resource.source.nil?
-          URI.parse(@new_resource.source).absolute?
+          scheme = URI.parse(@new_resource.source).scheme
+          # URI.parse gets confused by MS Windows paths with forward slashes.
+          scheme = nil if scheme =~ /^[a-z]$/
+          %w{http https}.include?(scheme)
         end
 
         def current_version
@@ -384,7 +445,7 @@ class Chef
           return false unless @current_resource && @current_resource.version
           return false if @current_resource.version.nil?
           # in the future we could support squiggly requirements like "~> 1.2.0"
-          # for now, the behavior when using anything other than exact 
+          # for now, the behavior when using anything other than exact
           # requirements is undefined.
           Gem::Requirement.new(@new_resource.version).satisfied_by?(Gem::Version.new(@current_resource.version))
         end
@@ -419,8 +480,16 @@ class Chef
         end
 
         def install_via_gem_command(name, version)
-          src = @new_resource.source && "  --source=#{@new_resource.source} --source=http://rubygems.org"
-          shell_out!("#{gem_binary_path} install #{name} -q --no-rdoc --no-ri -v \"#{version}\"#{src}#{opts}", :env=>nil)
+          if @new_resource.source =~ /\.gem$/i
+            name = @new_resource.source
+          else
+            src = @new_resource.source && "  --source=#{@new_resource.source} --source=http://rubygems.org"
+          end
+          if version
+            shell_out!("#{gem_binary_path} install #{name} -q --no-rdoc --no-ri -v \"#{version}\"#{src}#{opts}", :env=>nil)
+          else
+            shell_out!("#{gem_binary_path} install #{name} -q --no-rdoc --no-ri #{src}#{opts}", :env=>nil)
+          end
         end
 
         def upgrade_package(name, version)

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

@@ -0,0 +1,84 @@
+#
+# Authors:: Trevor O (trevoro@joyent.com)
+#           Bryan McLellan (btm@loftninjas.org)
+#           Matthew Landauer (matthew@openaustralia.org)
+# Copyright:: Copyright (c) 2009 Bryan McLellan, Matthew Landauer
+# 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.
+#
+# Notes
+#
+#  * Supports installing using a local package name
+#  * Otherwise reverts to installing from the pkgsrc repositories URL
+
+require 'chef/provider/package'
+require 'chef/mixin/shell_out'
+require 'chef/resource/package'
+require 'chef/mixin/get_source_from_package'
+
+class Chef
+  class Provider
+    class Package
+      class SmartOS < Chef::Provider::Package
+        include Chef::Mixin::ShellOut
+        attr_accessor :is_virtual_package
+
+
+        def load_current_resource
+					Chef::Log.debug("#{@new_resource} loading current resource")
+					@current_resource = Chef::Resource::Package.new(@new_resource.name)
+					@current_resource.package_name(@new_resource.package_name)
+					@current_resource.version(nil)
+          check_package_state(@new_resource.package_name)
+					@current_resource # modified by check_package_state
+				end
+				
+				def check_package_state(name)
+					Chef::Log.debug("#{@new_resource} checking package #{name}")
+					# XXX
+					version = nil
+					info = shell_out!("pkg_info -E \"#{name}*\"", :env => nil, :returns => [0,1])
+					
+					if info.stdout
+						version = info.stdout[/^#{@new_resource.package_name}-(.+)/, 1]
+          end
+
+					if !version
+						@current_resource.version(nil)
+					else
+						@current_resource.version(version)
+					end
+        end
+
+        def install_package(name, version)
+					Chef::Log.debug("#{@new_resource} installing package #{name}-#{version}")
+					package = "#{name}-#{version}"
+          out = shell_out!("pkgin -y install #{package}", :env => nil)
+        end
+
+				def upgrade_package(name, version)
+					Chef::Log.debug("#{@new_resource} upgrading package #{name}-#{version}")
+					install_package(name, version)
+				end
+
+				def remove_package(name, version)
+					Chef::Log.debug("#{@new_resource} removing package #{name}-#{version}")
+					package = "#{name}-#{version}"
+          out = shell_out!("pkgin -y remove #{package}", :env => nil)
+				end
+
+      end
+    end
+  end
+end

data/lib/chef/provider/package/yum-dump.py

@@ -180,14 +180,15 @@ def dump_packages(yb, list, output_provides):
     else:
       provides = "[]"
 
-    print '%s %s %s %s %s %s %s' % (
+    print '%s %s %s %s %s %s %s %s' % (
       pkg.name,
       pkg.epoch,
       pkg.version,
       pkg.release,
       pkg.arch,
       provides,
-      pkg.type )
+      pkg.type,
+      pkg.repoid )
 
   return 0
 

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

@@ -497,12 +497,13 @@ class Chef
         class RPMDbPackage < RPMPackage
           # <rpm parts>, installed, available
           def initialize(*args)
+            @repoid = args.pop
             # state
             @available = args.pop
             @installed = args.pop
             super(*args)
           end
-          attr_reader :available, :installed
+          attr_reader :repoid, :available, :installed
         end
 
         # Simple storage for RPMPackage objects - keeps them unique and sorted
@@ -712,7 +713,7 @@ class Chef
                   next
                 end
 
-                if line =~ %r{^(\S+) ([0-9]+) (\S+) (\S+) (\S+) \[(.*)\] ([i,a,r])$}
+                if line =~ %r{^(\S+) ([0-9]+) (\S+) (\S+) (\S+) \[(.*)\] ([i,a,r]) (\S+)$}
                   name     = $1
                   epoch    = $2
                   version  = $3
@@ -720,6 +721,7 @@ class Chef
                   arch     = $5
                   provides = parse_provides($6)
                   type     = $7
+                  repoid   = $8
                 else
                   Chef::Log.warn("Problem parsing line '#{line}' from yum-dump.py! " +
                                  "Please check your yum configuration.")
@@ -740,7 +742,7 @@ class Chef
                   installed = true
                 end
 
-                pkg = RPMDbPackage.new(name, epoch, version, release, arch, provides, installed, available)
+                pkg = RPMDbPackage.new(name, epoch, version, release, arch, provides, installed, available, repoid)
                 @rpmdb << pkg
               end
 
@@ -811,23 +813,36 @@ class Chef
             @rpmdb.whatprovides(rpmdep)
           end
 
+          # Check if a package-version.arch is available to install
           def version_available?(package_name, desired_version, arch=nil)
-             version(package_name, arch, true, false) do |v|
-               return true if desired_version == v
-             end
+            version(package_name, arch, true, false) do |v|
+              return true if desired_version == v
+            end
 
             return false
           end
 
+          # Return the source repository for a package-version.arch
+          def package_repository(package_name, desired_version, arch=nil)
+            package(package_name, arch, true, false) do |pkg|
+              return pkg.repoid if desired_version == pkg.version.to_s
+            end
+
+            return nil
+          end
+
+          # Return the latest available version for a package.arch
           def available_version(package_name, arch=nil)
             version(package_name, arch, true, false)
           end
           alias :candidate_version :available_version
 
+          # Return the currently installed version for a package.arch
           def installed_version(package_name, arch=nil)
             version(package_name, arch, false, true)
           end
 
+          # Return an array of packages allowed to be installed multiple times, such as the kernel
           def allow_multi_install
             refresh
             @allow_multi_install
@@ -836,6 +851,23 @@ class Chef
           private
 
           def version(package_name, arch=nil, is_available=false, is_installed=false)
+            package(package_name, arch, is_available, is_installed) do |pkg|
+              if block_given?
+                yield pkg.version.to_s
+              else
+                # first match is latest version
+                return pkg.version.to_s
+              end
+            end
+
+            if block_given?
+              return self
+            else
+              return nil
+            end
+          end
+
+          def package(package_name, arch=nil, is_available=false, is_installed=false)
             refresh
             packages = @rpmdb[package_name]
             if packages
@@ -851,10 +883,10 @@ class Chef
                 end
 
                 if block_given?
-                  yield pkg.version.to_s
+                  yield pkg
                 else
                   # first match is latest version
-                  return pkg.version.to_s
+                  return pkg
                 end
               end
             end
@@ -1026,6 +1058,7 @@ class Chef
             # Work around yum not exiting with an error if a package doesn't exist for CHEF-2062
             if @yum.version_available?(name, version, arch)
               method = "install"
+              log_method = "installing"
 
               # More Yum fun:
               #
@@ -1038,6 +1071,7 @@ class Chef
                   # Unless they want this...
                   if allow_downgrade
                     method = "downgrade"
+                    log_method = "downgrading"
                   else
                     # we bail like yum when the package is older
                     raise Chef::Exceptions::Package, "Installed package #{name}-#{@current_resource.version} is newer " +
@@ -1046,12 +1080,16 @@ class Chef
                 end
               end
 
+              repo = @yum.package_repository(name, version, arch)
+              Chef::Log.info("#{@new_resource} #{log_method} #{name}-#{version}#{yum_arch} from #{repo} repository")
+
               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)"
             end
           end
+
           if flush_cache[:after]
             @yum.reload
           else
@@ -1067,10 +1105,12 @@ class Chef
         #
         # Hacky - better overall solution? Custom compare in Package provider?
         def action_upgrade
+          # Could be uninstalled or have no candidate
+          if @current_resource.version.nil? || candidate_version.nil? 
+            super
           # Ensure the candidate is newer
-          if RPMVersion.parse(candidate_version) > RPMVersion.parse(@current_resource.version)
+          elsif RPMVersion.parse(candidate_version) > RPMVersion.parse(@current_resource.version)
             super
-          # Candidate is older
           else
             Chef::Log.debug("#{@new_resource} is at the latest version - nothing to do")
           end
@@ -1086,6 +1126,7 @@ class Chef
           else
             yum_command("yum -d0 -e0 -y#{expand_options(@new_resource.options)} remove #{name}#{yum_arch}")
           end
+
           if flush_cache[:after]
             @yum.reload
           else