diff --git a/lib/puppet/provider/package/yum.rb b/lib/puppet/provider/package/yum.rb
index c32052d3d..0b382d372 100644
--- a/lib/puppet/provider/package/yum.rb
+++ b/lib/puppet/provider/package/yum.rb
@@ -1,110 +1,112 @@
 require 'puppet/util/package'
 
 Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
   desc "Support via `yum`.
 
   Using this provider's `uninstallable` feature will not remove dependent packages. To
   remove dependent packages with this provider use the `purgeable` feature, but note this
   feature is destructive and should be used with the utmost care."
 
+  has_feature :install_options
   has_feature :versionable
 
   commands :yum => "yum", :rpm => "rpm", :python => "python"
 
   self::YUMHELPER = File::join(File::dirname(__FILE__), "yumhelper.py")
 
   attr_accessor :latest_info
 
   if command('rpm')
     confine :true => begin
       rpm('--version')
       rescue Puppet::ExecutionFailure
         false
       else
         true
       end
   end
 
   defaultfor :operatingsystem => [:fedora, :centos, :redhat]
 
   def self.prefetch(packages)
     raise Puppet::Error, "The yum provider can only be used as root" if Process.euid != 0
     super
     return unless packages.detect { |name, package| package.should(:ensure) == :latest }
 
     # collect our 'latest' info
     updates = {}
     python(self::YUMHELPER).each_line do |l|
       l.chomp!
       next if l.empty?
       if l[0,4] == "_pkg"
         hash = nevra_to_hash(l[5..-1])
         [hash[:name], "#{hash[:name]}.#{hash[:arch]}"].each  do |n|
           updates[n] ||= []
           updates[n] << hash
         end
       end
     end
 
     # Add our 'latest' info to the providers.
     packages.each do |name, package|
       if info = updates[package[:name]]
         package.provider.latest_info = info[0]
       end
     end
   end
 
   def install
     should = @resource.should(:ensure)
     self.debug "Ensuring => #{should}"
     wanted = @resource[:name]
     operation = :install
+    install_options = @resource[:install_options].flatten.compact.join(' ')
 
     case should
     when true, false, Symbol
       # pass
       should = nil
     else
       # Add the package version
       wanted += "-#{should}"
       is = self.query
       if is && Puppet::Util::Package.versioncmp(should, is[:ensure]) < 0
         self.debug "Downgrading package #{@resource[:name]} from version #{is[:ensure]} to #{should}"
         operation = :downgrade
       end
     end
 
-    yum "-d", "0", "-e", "0", "-y", operation, wanted
+    yum "-d", "0", "-e", "0", "-y", install_options, operation, wanted
 
     is = self.query
     raise Puppet::Error, "Could not find package #{self.name}" unless is
 
     # FIXME: Should we raise an exception even if should == :latest
     # and yum updated us to a version other than @param_hash[:ensure] ?
     raise Puppet::Error, "Failed to update to version #{should}, got version #{is[:ensure]} instead" if should && should != is[:ensure]
   end
 
   # What's the latest package version available?
   def latest
     upd = latest_info
     unless upd.nil?
       # FIXME: there could be more than one update for a package
       # because of multiarch
       return "#{upd[:epoch]}:#{upd[:version]}-#{upd[:release]}"
     else
       # Yum didn't find updates, pretend the current
       # version is the latest
       raise Puppet::DevError, "Tried to get latest on a missing package" if properties[:ensure] == :absent
       return properties[:ensure]
     end
   end
 
   def update
     # Install in yum can be used for update, too
     self.install
   end
 
   def purge
     yum "-y", :erase, @resource[:name]
   end
 end
diff --git a/spec/unit/provider/package/yum_spec.rb b/spec/unit/provider/package/yum_spec.rb
index 23d49cab4..73e0bb347 100755
--- a/spec/unit/provider/package/yum_spec.rb
+++ b/spec/unit/provider/package/yum_spec.rb
@@ -1,195 +1,196 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 provider = Puppet::Type.type(:package).provider(:yum)
 
 describe provider do
   before do
     # Create a mock resource
      @resource = stub 'resource'
      @resource.stubs(:[]).with(:name).returns 'mypackage'
      @provider = provider.new(@resource)
      @provider.stubs(:resource).returns @resource
      @provider.stubs(:yum).returns 'yum'
      @provider.stubs(:rpm).returns 'rpm'
      @provider.stubs(:get).with(:name).returns 'mypackage'
      @provider.stubs(:get).with(:version).returns '1'
      @provider.stubs(:get).with(:release).returns '1'
      @provider.stubs(:get).with(:arch).returns 'i386'
+     @provider.stubs(:get).with(:install_options).returns '-x expackage'
   end
   # provider should repond to the following methods
    [:install, :latest, :update, :purge].each do |method|
      it "should have a(n) #{method}" do
        @provider.should respond_to(method)
     end
   end
 
   describe 'when installing' do
     before(:each) do
       Puppet::Util.stubs(:which).with("rpm").returns("/bin/rpm")
       provider.stubs(:which).with("rpm").returns("/bin/rpm")
       Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "--version"], {:combine => true, :custom_environment => {}, :failonfail => true}).returns("4.10.1\n").at_most_once
     end
 
     it 'should call yum install for :installed' do
       @resource.stubs(:should).with(:ensure).returns :installed
-      @provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :install, 'mypackage')
+      @provider.expects(:yum).with('-d', '0', '-e', '0', '-y', '-x expackage', :install, 'mypackage')
       @provider.install
     end
 
     it 'should use :install to update' do
       @provider.expects(:install)
       @provider.update
     end
 
     it 'should be able to set version' do
       @resource.stubs(:should).with(:ensure).returns '1.2'
-      @provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :install, 'mypackage-1.2')
+      @provider.expects(:yum).with('-d', '0', '-e', '0', '-y', '-x expackage', :install, 'mypackage-1.2')
       @provider.stubs(:query).returns :ensure => '1.2'
       @provider.install
     end
 
     it 'should be able to downgrade' do
       @resource.stubs(:should).with(:ensure).returns '1.0'
       @provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :downgrade, 'mypackage-1.0')
       @provider.stubs(:query).returns(:ensure => '1.2').then.returns(:ensure => '1.0')
       @provider.install
     end
   end
 
   describe 'when uninstalling' do
     it 'should use erase to purge' do
       @provider.expects(:yum).with('-y', :erase, 'mypackage')
       @provider.purge
     end
   end
 
   it 'should be versionable' do
     provider.should be_versionable
   end
 
   describe '#latest' do
     describe 'when latest_info is nil' do
       before :each do
         @provider.stubs(:latest_info).returns(nil)
       end
 
       it 'raises if ensure is absent and latest_info is nil' do
         @provider.stubs(:properties).returns({:ensure => :absent})
 
         expect { @provider.latest }.to raise_error(
           Puppet::DevError,
           'Tried to get latest on a missing package'
         )
       end
 
       it 'returns the ensure value if the package is not already installed' do
         @provider.stubs(:properties).returns({:ensure => '3.4.5'})
 
         @provider.latest.should == '3.4.5'
       end
     end
 
     describe 'when latest_info is populated' do
       before :each do
         @provider.stubs(:latest_info).returns({
           :name     => 'mypackage',
           :epoch    => '1',
           :version  => '2.3.4',
           :release  => '5',
           :arch     => 'i686',
           :provider => :yum,
           :ensure   => '2.3.4-5'
         })
       end
 
       it 'includes the epoch in the version string' do
         @provider.latest.should == '1:2.3.4-5'
       end
     end
   end
 
   describe 'prefetching' do
     let(:nevra_format) { Puppet::Type::Package::ProviderRpm::NEVRA_FORMAT }
 
     let(:packages) do
       <<-RPM_OUTPUT
       cracklib-dicts 0 2.8.9 3.3 x86_64
       basesystem 0 8.0 5.1.1.el5.centos noarch
       chkconfig 0 1.3.30.2 2.el5 x86_64
       myresource 0 1.2.3.4 5.el4 noarch
       mysummaryless 0 1.2.3.4 5.el4 noarch
       RPM_OUTPUT
     end
 
     let(:yumhelper_output) do
       <<-YUMHELPER_OUTPUT
  * base: centos.tcpdiag.net
  * extras: centos.mirrors.hoobly.com
  * updates: mirrors.arsc.edu
 _pkg nss-tools 0 3.14.3 4.el6_4 x86_64
 _pkg pixman 0 0.26.2 5.el6_4 x86_64
 _pkg myresource 0 1.2.3.4 5.el4 noarch
 _pkg mysummaryless 0 1.2.3.4 5.el4 noarch
      YUMHELPER_OUTPUT
     end
 
     let(:execute_options) do
       {:failonfail => true, :combine => true, :custom_environment => {}}
     end
 
     let(:rpm_version) { "RPM version 4.8.0\n" }
 
     let(:package_type) { Puppet::Type.type(:package) }
     let(:yum_provider) { provider }
 
     def pretend_we_are_root_for_yum_provider
       Process.stubs(:euid).returns(0)
     end
 
     def expect_yum_provider_to_provide_rpm
       Puppet::Type::Package::ProviderYum.stubs(:rpm).with('--version').returns(rpm_version)
       Puppet::Type::Package::ProviderYum.expects(:command).with(:rpm).returns("/bin/rpm")
     end
 
     def expect_execpipe_to_provide_package_info_for_an_rpm_query
       Puppet::Util::Execution.expects(:execpipe).with("/bin/rpm -qa --nosignature --nodigest --qf '#{nevra_format}'").yields(packages)
     end
 
     def expect_python_yumhelper_call_to_return_latest_info
       Puppet::Type::Package::ProviderYum.expects(:python).with(regexp_matches(/yumhelper.py$/)).returns(yumhelper_output)
     end
 
     def a_package_type_instance_with_yum_provider_and_ensure_latest(name)
       type_instance = package_type.new(:name => name)
       type_instance.provider = yum_provider.new
       type_instance[:ensure] = :latest
       return type_instance
     end
 
     before do
       pretend_we_are_root_for_yum_provider
       expect_yum_provider_to_provide_rpm
       expect_execpipe_to_provide_package_info_for_an_rpm_query
       expect_python_yumhelper_call_to_return_latest_info
     end
 
     it "injects latest provider info into passed resources when prefetching" do
       myresource = a_package_type_instance_with_yum_provider_and_ensure_latest('myresource')
       mysummaryless = a_package_type_instance_with_yum_provider_and_ensure_latest('mysummaryless')
 
       yum_provider.prefetch({ "myresource" => myresource, "mysummaryless" => mysummaryless })
 
       expect(@logs.map(&:message).grep(/^Failed to match rpm line/)).to be_empty
       expect(myresource.provider.latest_info).to eq({
         :name=>"myresource",
         :epoch=>"0",
         :version=>"1.2.3.4",
         :release=>"5.el4",
         :arch=>"noarch",
         :provider=>:yum,
         :ensure=>"1.2.3.4-5.el4"
       })
     end
   end
 end