chef 0.8.16 → 0.9.0.a3

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

@@ -48,14 +48,14 @@ class Chef
           @current_resource.version(nil)
 
           # get the currently installed version if installed
+          package_version = nil
           if install_check(@new_resource.package_name)
             command = "python -c \"import #{@new_resource.package_name}; print #{@new_resource.package_name}.__path__\""
-            pid, stdin, stdout, stderr = popen4(command)
-            install_location = stdout.readline
-            install_location[/\S\S(.*)\/(.*)-(.*)-py(.*).egg\S/]
-            package_version = $3
-          else
-            package_version = nil
+            status = popen4(command) do |pid, stdin, stdout, stderr|
+              install_location = stdout.readline
+              install_location[/\S\S(.*)\/(.*)-(.*)-py(.*).egg\S/]
+              package_version = $3
+            end
           end
 
           if package_version == @new_resource.version

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

@@ -18,13 +18,14 @@
 #
 
 require 'chef/provider/package'
-require 'chef/mixin/command'
+require 'chef/mixin/shell_out'
 require 'chef/resource/package'
 
 class Chef
   class Provider
     class Package
       class Freebsd < Chef::Provider::Package
+        include Chef::Mixin::ShellOut
 
         def initialize(*args)
           super
@@ -32,19 +33,8 @@ class Chef
         end
 
         def current_installed_version
-          command = "pkg_info -E \"#{package_name}*\""
-          status = popen4(command) do |pid, stdin, stdout, stderr|
-            stdout.each do |line|
-              case line
-              when /^#{package_name}-(.+)/
-                return $1
-              end
-            end
-          end
-          unless status.exitstatus == 0 || status.exitstatus == 1
-            raise Chef::Exceptions::Package, "#{command} failed - #{status.inspect}!"
-          end
-          nil
+          pkg_info = shell_out!("pkg_info -E \"#{package_name}*\"", :env => nil, :returns => [0,1])
+          pkg_info.stdout[/^#{package_name}-(.+)/, 1]
         end
 
         def port_path
@@ -58,27 +48,17 @@ class Chef
             "/usr/ports/#{@new_resource.package_name}"
           # Otherwise look up the path to the ports directory using 'whereis'
           else
-            popen4("whereis -s #{@new_resource.package_name}") do |pid, stdin, stdout, stderr|
-              stdout.each do |line|
-                case line
-                when /^#{@new_resource.package_name}:\s+(.+)$/
-                  return $1
-                end
-              end
+            whereis = shell_out!("whereis -s #{@new_resource.package_name}", :env => nil)
+            unless path = whereis.stdout[/^#{@new_resource.package_name}:\s+(.+)$/, 1]
+              raise Chef::Exceptions::Package, "Could not find port with the name #{@new_resource.package_name}"
             end
-            raise Chef::Exceptions::Package, "Could not find port with the name #{@new_resource.package_name}"
+            path
           end
         end
 
         def ports_makefile_variable_value(variable)
-          command = "cd #{port_path}; make -V #{variable}"
-          status = popen4(command) do |pid, stdin, stdout, stderr|
-            return stdout.readline.strip
-          end
-          unless status.exitstatus == 0 || status.exitstatus == 1
-            raise Chef::Exceptions::Package, "#{command} failed - #{status.inspect}!"
-          end
-          nil
+          make_v = shell_out!("make -V #{variable}", :cwd => port_path, :env => nil, :returns => [0,1])
+          make_v.stdout.strip.split($\).first # $\ is the line separator, i.e., newline
         end
 
         def ports_candidate_version
@@ -114,26 +94,15 @@ class Chef
           unless @current_resource.version
             case @new_resource.source
             when /^ports$/
-              run_command_with_systems_locale(
-                :command => "make -DBATCH install",
-                :cwd => "#{port_path}"
-              )
+              shell_out!("make -DBATCH install", :cwd => port_path, :env => nil).status
             when /^http/, /^ftp/
-              run_command_with_systems_locale(
-                :command => "pkg_add -r #{package_name}",
-                :environment => { "PACKAGESITE" => @new_resource.source }
-              )
+              shell_out!("pkg_add -r #{package_name}", :env => { "PACKAGESITE" => @new_resource.source, 'LC_ALL' => nil }).status
               Chef::Log.info("Installed package #{package_name} from: #{@new_resource.source}")
             when /^\//
-              run_command_with_systems_locale(
-                :command => "pkg_add #{@new_resource.name}",
-                :environment => { "PKG_PATH" => @new_resource.source }
-              )
+              shell_out!("pkg_add #{@new_resource.name}", :env => { "PKG_PATH" => @new_resource.source , 'LC_ALL'=>nil}).status
               Chef::Log.info("Installed package #{@new_resource.name} from: #{@new_resource.source}")
             else
-              run_command_with_systems_locale(
-                :command => "pkg_add -r #{latest_link_name}"
-              )
+              shell_out!("pkg_add -r #{latest_link_name}", :env => nil).status
               Chef::Log.info("Installed package #{package_name}")
             end
           end
@@ -142,15 +111,12 @@ class Chef
         def remove_package(name, version)
           # a version is mandatory
           if version
-            run_command_with_systems_locale(
-              :command => "pkg_delete #{package_name}-#{version}"
-            )
+            shell_out!("pkg_delete #{package_name}-#{version}", :env => nil).status
           else
-            run_command_with_systems_locale(
-              :command => "pkg_delete #{package_name}-#{@current_resource.version}"
-            )
+            shell_out!("pkg_delete #{package_name}-#{@current_resource.version}", :env => nil).status
           end
         end
+
       end
     end
   end

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

@@ -45,7 +45,7 @@ class Chef
               end
             end
           else
-            if @new_resource.action.include?(:install)
+            if Array(@new_resource.action).include?(:install)
               raise Chef::Exceptions::Package, "Source for package #{@new_resource.name} required for action install"
             end
           end

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

@@ -1,14 +1,15 @@
 #
 # 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");
 # 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.
@@ -20,113 +21,429 @@ require 'chef/provider/package'
 require 'chef/mixin/command'
 require 'chef/resource/package'
 
+# Class methods on Gem are defined in rubygems
+require 'rubygems'
+# Ruby 1.9's gem_prelude can interact poorly with loading the full rubygems
+# explicitly like this. Make sure rubygems/specification is always last in this
+# list
+require 'rubygems/version'
+require 'rubygems/dependency'
+require 'rubygems/spec_fetcher'
+require 'rubygems/platform'
+require 'rubygems/format'
+require 'rubygems/dependency_installer'
+require 'rubygems/uninstaller'
+require 'rubygems/specification'
+
 class Chef
   class Provider
     class Package
-      class Rubygems < Chef::Provider::Package  
-      
-        def gem_list_parse(line)
-          installed_versions = Array.new
-          if md = line.match(/^#{@new_resource.package_name} \((.+?)(?: [^\)\.]+)?\)$/)
-            md.captures.first.split(/, /)
-          else
-            nil
+      class Rubygems < Chef::Provider::Package
+        class GemEnvironment
+          # HACK: trigger gem config load early. Otherwise it can get lazy
+          # loaded during operations where we've set Gem.sources to an
+          # alternate value and overwrite it with the defaults.
+          Gem.configuration
+
+          DEFAULT_UNINSTALLER_OPTS = {:ignore => true, :executables => true}
+
+          ##
+          # The paths where rubygems should search for installed gems.
+          # Implemented by subclasses.
+          def gem_paths
+            raise NotImplementedError
+          end
+
+          ##
+          # A rubygems source index containing the list of gemspecs for all
+          # available gems in the gem installation.
+          # Implemented by subclasses
+          # === Returns
+          # Gem::SourceIndex
+          def gem_source_index
+            raise NotImplementedError
+          end
+
+          ##
+          # Lists the installed versions of +gem_name+, constrained by the
+          # version spec in +gem_dep+
+          # === Arguments
+          # Gem::Dependency   +gem_dep+ is a Gem::Dependency object, its version
+          #                   specification constrains which gems are returned.
+          # === Returns
+          # [Gem::Specification]  an array of Gem::Specification objects
+          def installed_versions(gem_dep)
+            gem_source_index.search(gem_dep)
+          end
+
+          ##
+          # Yields to the provided block with rubygems' source list set to the
+          # list provided. Always resets the list when the block returns or
+          # raises an exception.
+          def with_gem_sources(*sources)
+            sources.compact!
+            original_sources = Gem.sources
+            Gem.sources = sources unless sources.empty?
+            yield
+          ensure
+            Gem.sources = original_sources
+          end
+
+          ##
+          # Determines the candidate version for a gem from a .gem file on disk
+          # and checks if it matches the version contraints in +gem_dependency+
+          # === Returns
+          # Gem::Version  a singular gem version object is returned if the gem
+          #               is available
+          # nil           returns nil if the gem on disk doesn't match the
+          #               version constraints for +gem_dependency+
+          def candidate_version_from_file(gem_dependency, source)
+            spec = Gem::Format.from_file_by_path(source).spec
+            if spec.satisfies_requirement?(gem_dependency)
+              logger.debug {"found candidate gem version #{spec.version} from local gem package #{source}"}
+              spec.version
+            else
+              # This is probably going to end badly...
+              logger.warn { "The gem package #{source} does not satisfy the requirements #{gem_dependency.to_s}" }
+              nil
+            end
+          end
+
+          ##
+          # Finds the newest version that satisfies the constraints of
+          # +gem_dependency+. The version is determined from the cache or a
+          # round-trip to the server as needed. The architecture and gem
+          # sources will be set before making the query.
+          # === Returns
+          # Gem::Version  a singular gem version object is returned if the gem
+          #               is available
+          # nil           returns nil if the gem could not be found
+          def candidate_version_from_remote(gem_dependency, *sources)
+            raise NotImplementedError
+          end
+
+          ##
+          # Find the newest gem version available from Gem.sources that satisfies
+          # the constraints of +gem_dependency+
+          def find_newest_remote_version(gem_dependency, *sources)
+            # DependencyInstaller sorts the results such that the last one is
+            # always the one it considers best.
+            spec_with_source = dependency_installer.find_gems_with_sources(gem_dependency).last
+
+            spec = spec_with_source && spec_with_source[0]
+            version = spec && spec_with_source[0].version
+            if version
+              logger.debug { "Found gem #{spec.name} version #{version} for platform #{spec.platform} from #{spec_with_source[1]}" }
+              version
+            else
+              source_list = sources.compact.empty? ? "[#{Gem.sources.join(', ')}]" : "[#{sources.join(', ')}]"
+              logger.warn { "Failed to find gem #{gem_dependency} from #{source_list}" }
+              nil
+            end
+          end
+
+          ##
+          # Installs a gem via the rubygems ruby API.
+          # === Options
+          # :sources    rubygems servers to use
+          # Other options are passed to Gem::DependencyInstaller.new
+          def install(gem_dependency, options={})
+            with_gem_sources(*options.delete(:sources)) do
+              dependency_installer(options).install(gem_dependency)
+            end
+          end
+
+          ##
+          # Uninstall the gem +gem_name+ via the rubygems ruby API. If
+          # +gem_version+ is provided, only that version will be uninstalled.
+          # Otherwise, all versions are uninstalled.
+          # === Options
+          # Options are passed to Gem::Uninstaller.new
+          def uninstall(gem_name, gem_version=nil, opts={})
+            gem_version ? opts[:version] = gem_version : opts[:all] = true
+            uninstaller(gem_name, opts).uninstall
+          end
+
+          def dependency_installer(opts={})
+            Gem::DependencyInstaller.new(opts)
+          end
+
+          def uninstaller(gem_name, opts={})
+            Gem::Uninstaller.new(gem_name, DEFAULT_UNINSTALLER_OPTS.merge(opts))
           end
+
+          private
+
+          def logger
+            Chef::Log.logger
+          end
+
         end
 
-        def gem_binary_path
-          path = @new_resource.gem_binary
-          path ? path : 'gem'
+        class CurrentGemEnvironment < GemEnvironment
+
+          def gem_paths
+            Gem.path
+          end
+
+          def gem_source_index
+            Gem.source_index
+          end
+
+          def candidate_version_from_remote(gem_dependency, *sources)
+            with_gem_sources(*sources) do
+              find_newest_remote_version(gem_dependency, *sources)
+            end
+          end
+
         end
-      
-        def load_current_resource
-          @current_resource = Chef::Resource::Package.new(@new_resource.name)
-          @current_resource.package_name(@new_resource.package_name)
-          @current_resource.version(nil)
-        
-          # First, we need to look up whether we have the local gem installed or not
-          status = popen4("#{gem_binary_path} list --local #{@new_resource.package_name}") do |pid, stdin, stdout, stderr|
-            stdout.each_line do |line|
-              next unless installed_versions = gem_list_parse(line)
-              # If the version we are asking for is installed, make that our current
-              # version.  Otherwise, go ahead and use the highest one, which
-              # happens to come first in the array.
-              if installed_versions.detect { |v| v == @new_resource.version }
-                Chef::Log.debug("#{@new_resource.package_name} at version #{@new_resource.version}")
-                @current_resource.version(@new_resource.version)
+
+        class AlternateGemEnvironment < GemEnvironment
+          JRUBY_PLATFORM = /(:?universal|x86_64|x86)\-java\-[0-9\.]+/
+          
+          def self.gempath_cache
+            @gempath_cache ||= {}
+          end
+
+          def self.platform_cache
+            @platform_cache ||= {}
+          end
+
+          include Chef::Mixin::ShellOut
+
+          attr_reader :gem_binary_location
+
+          def initialize(gem_binary_location)
+            @gem_binary_location = gem_binary_location
+          end
+
+          def gem_paths
+            if self.class.gempath_cache.key?(@gem_binary_location)
+              self.class.gempath_cache[@gem_binary_location]
+            else
+              # shellout! is a fork/exec which won't work on windows
+              shell_style_paths = shell_out!("#{@gem_binary_location} env gempath").stdout
+              # on windows, the path separator is (usually? always?) semicolon
+              paths = shell_style_paths.split(::File::PATH_SEPARATOR).map { |path| path.strip }
+              self.class.gempath_cache[@gem_binary_location] = paths
+            end
+          end
+
+          def gem_source_index
+            @source_index ||= Gem::SourceIndex.from_gems_in(*gem_paths.map { |p| p + '/specifications' })
+          end
+
+          ##
+          # Attempt to detect the correct platform settings for the target gem
+          # environment.
+          #
+          # In practice, this only makes a difference if different versions are
+          # available depending on platform, and only if the target gem
+          # environment has a radically different platform (i.e., jruby), so we
+          # just try to detect jruby and fall back to the current platforms
+          # (Gem.platforms) if we don't detect it.
+          #
+          # === Returns
+          # [String|Gem::Platform] returns an array of Gem::Platform-compatible
+          # objects, i.e., Strings that are valid for Gem::Platform or actual
+          # Gem::Platform objects.
+          def gem_platforms
+            if self.class.platform_cache.key?(@gem_binary_location)
+              self.class.platform_cache[@gem_binary_location]
+            else
+              gem_environment = shell_out!("#{@gem_binary_location} env").stdout
+              if jruby = gem_environment[JRUBY_PLATFORM]
+                self.class.platform_cache[@gem_binary_location] = ['ruby', Gem::Platform.new(jruby)]
               else
-                iv = installed_versions.first
-                Chef::Log.debug("#{@new_resource.package_name} at version #{iv}")
-                @current_resource.version(iv)
+                self.class.platform_cache[@gem_binary_location] = Gem.platforms
               end
             end
           end
-          
-          unless status.exitstatus == 0
-            raise Chef::Exceptions::Package, "#{gem_binary_path} list --local failed - #{status.inspect}!"
+
+          def with_gem_platforms(*alt_gem_platforms)
+            alt_gem_platforms.flatten!
+            original_gem_platforms = Gem.platforms
+            Gem.platforms = alt_gem_platforms
+            yield
+          ensure
+            Gem.platforms = original_gem_platforms
           end
-          
-          @current_resource
-        end
 
-        def candidate_version
-          return @candidate_version if @candidate_version
-
-          status = popen4("#{gem_binary_path} list --remote #{@new_resource.package_name}#{' --source=' + @new_resource.source if @new_resource.source}") do |pid, stdin, stdout, stderr|
-            stdout.each_line do |line|
-              next unless installed_versions = gem_list_parse(line)
-              Chef::Log.debug("candidate_version: remote rubygem(s) available: #{installed_versions.inspect}")
-              
-              unless installed_versions.empty?
-                Chef::Log.debug("candidate_version: setting install candidate version to #{installed_versions.first}")
-                @candidate_version = installed_versions.first
+          def candidate_version_from_remote(gem_dependency, *sources)
+            with_gem_sources(*sources) do
+              with_gem_platforms(*gem_platforms) do
+                find_newest_remote_version(gem_dependency, *sources)
               end
             end
+          end
+
+        end
+
+        include Chef::Mixin::ShellOut
+
+        attr_reader :gem_env
+
+        def logger
+          Chef::Log.logger
+        end
+
+        def initialize(new_resource, run_context=nil)
+          super
+          if new_resource.gem_binary
+            if new_resource.options && new_resource.options.kind_of?(Hash)
+              msg =  "options cannot be given as a hash when using an explicit gem_binary\n"
+              msg << "in #{new_resource} from #{new_resource.source_line}"
+              raise ArgumentError, msg
+            end
+            @gem_env = AlternateGemEnvironment.new(new_resource.gem_binary)
+          else
+            @gem_env = CurrentGemEnvironment.new
+          end
+        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?
+        end
+
+        def current_version
+          #raise 'todo'
+          # If one or more matching versions are installed, the newest of them
+          # is the current version
+          if !matching_installed_versions.empty?
+            gemspec = matching_installed_versions.last
+            logger.debug { "Found installed gem #{gemspec.name} version #{gemspec.version} matching #{gem_dependency}"}
+            gemspec
+          # If no version matching the requirements exists, the latest installed
+          # version is the current version.
+          elsif !all_installed_versions.empty?
+            gemspec = all_installed_versions.last
+            logger.debug { "Newest installed version of gem #{gemspec.name} is #{gemspec.version}" }
+            gemspec
+          else
+            logger.debug { "No installed version found for #{gem_dependency.to_s}"}
+            nil
+          end
+        end
+
+        def matching_installed_versions
+          @matching_installed_versions ||= @gem_env.installed_versions(gem_dependency)
+        end
+
+        def all_installed_versions
+          @all_installed_versions ||= begin
+            @gem_env.installed_versions(Gem::Dependency.new(gem_dependency.name))
+          end
+        end
 
+        def gem_sources
+          @new_resource.source ? [@new_resource.source, 'http://rubygems.org'] : nil
+        end
+
+        def load_current_resource
+          @current_resource = Chef::Resource::Package::GemPackage.new(@new_resource.name)
+          @current_resource.package_name(@new_resource.package_name)
+          if current_spec = current_version
+            @current_resource.version(current_spec.version.to_s)
           end
+          @current_resource
+        end
 
-          unless status.exitstatus == 0
-            raise Chef::Exceptions::Package, "#{gem_binary_path} list --remote failed - #{status.inspect}!"
+        def candidate_version
+          @candidate_version ||= begin
+            if target_version_already_installed?
+              nil
+            elsif source_is_remote?
+              @gem_env.candidate_version_from_remote(gem_dependency, *gem_sources).to_s
+            else
+              @gem_env.candidate_version_from_file(gem_dependency, @new_resource.source).to_s
+            end
           end
-          @candidate_version
         end
-      
+
+        def target_version_already_installed?
+          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 
+          # requirements is undefined.
+          Gem::Requirement.new(@new_resource.version).satisfied_by?(Gem::Version.new(@current_resource.version))
+        end
+
+        ##
+        # Installs the gem, using either the gems API or shelling out to `gem`
+        # according to the following criteria:
+        # 1. Use gems API (Gem::DependencyInstaller) by default
+        # 2. shell out to `gem install` when a String of options is given
+        # 3. use gems API with options if a hash of options is given
         def install_package(name, version)
-          src = nil
-          if @new_resource.source
-            src = "  --source=#{@new_resource.source} --source=http://rubygems.org"
-          end  
-          run_command_with_systems_locale(
-            :command => "#{gem_binary_path} install #{name} -q --no-rdoc --no-ri -v \"#{version}\"#{src}#{opts}"
-          )
-        end
-      
+          if source_is_remote? && @new_resource.gem_binary.nil?
+            if @new_resource.options.nil?
+              @gem_env.install(gem_dependency, :sources => gem_sources)
+            elsif @new_resource.options.kind_of?(Hash)
+              options = @new_resource.options
+              options[:sources] = gem_sources
+              @gem_env.install(gem_dependency, options)
+            else
+              install_via_gem_command(name, version)
+            end
+          elsif @new_resource.gem_binary.nil?
+            @gem_env.install(@new_resource.source)
+          else
+            install_via_gem_command(name,version)
+          end
+          true
+        end
+
+        def gem_binary_path
+          @new_resource.gem_binary || 'gem'
+        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)
+        end
+
         def upgrade_package(name, version)
           install_package(name, version)
         end
-      
+
         def remove_package(name, version)
+          if @new_resource.gem_binary.nil?
+            if @new_resource.options.nil?
+              @gem_env.uninstall(name, version)
+            elsif @new_resource.options.kind_of?(Hash)
+              @gem_env.uninstall(name, version, @new_resource.options)
+            else
+              uninstall_via_gem_command(name, version)
+            end
+          else
+            uninstall_via_gem_command(name, version)
+          end
+        end
+
+        def uninstall_via_gem_command(name, version)
           if version
-            run_command_with_systems_locale(
-              :command => "#{gem_binary_path} uninstall #{name} -q -v \"#{version}\""
-            )
+            shell_out!("#{gem_binary_path} uninstall #{name} -q -x -I -v \"#{version}\"#{opts}", :env=>nil)
           else
-            run_command_with_systems_locale(
-              :command => "#{gem_binary_path} uninstall #{name} -q -a"
-            )
+            shell_out!("#{gem_binary_path} uninstall #{name} -q -x -I -a#{opts}", :env=>nil)
           end
         end
-      
+
         def purge_package(name, version)
           remove_package(name, version)
         end
-        
+
         private
-        
+
         def opts
           expand_options(@new_resource.options)
         end
-      
+
       end
     end
   end