diff --git a/lib/puppet/configurer.rb b/lib/puppet/configurer.rb
index a6058b82f..550e31b00 100644
--- a/lib/puppet/configurer.rb
+++ b/lib/puppet/configurer.rb
@@ -1,257 +1,245 @@
 # The client for interacting with the puppetmaster config server.
 require 'sync'
 require 'timeout'
 require 'puppet/network/http_pool'
 require 'puppet/util'
 
 class Puppet::Configurer
   require 'puppet/configurer/fact_handler'
   require 'puppet/configurer/plugin_handler'
+  require 'puppet/util/config_timeout'
 
   include Puppet::Configurer::FactHandler
   include Puppet::Configurer::PluginHandler
 
+  class <<self
+    include Puppet::Util::ConfigTimeout
+  end
+
   # For benchmarking
   include Puppet::Util
 
   attr_reader :compile_time
 
   # Provide more helpful strings to the logging that the Agent does
   def self.to_s
     "Puppet configuration client"
   end
 
   class << self
     # Puppetd should only have one instance running, and we need a way
     # to retrieve it.
     attr_accessor :instance
     include Puppet::Util
   end
 
   # How to lock instances of this class.
   def self.lockfile_path
     Puppet[:puppetdlockfile]
   end
 
   def execute_postrun_command
     execute_from_setting(:postrun_command)
   end
 
   def execute_prerun_command
     execute_from_setting(:prerun_command)
   end
 
   # Initialize and load storage
   def dostorage
       Puppet::Util::Storage.load
       @compile_time ||= Puppet::Util::Storage.cache(:configuration)[:compile_time]
   rescue => detail
     Puppet.log_exception(detail, "Removing corrupt state file #{Puppet[:statefile]}: #{detail}")
     begin
       ::File.unlink(Puppet[:statefile])
       retry
     rescue => detail
       raise Puppet::Error.new("Cannot remove #{Puppet[:statefile]}: #{detail}")
     end
   end
 
   # Just so we can specify that we are "the" instance.
   def initialize
     Puppet.settings.use(:main, :ssl, :agent)
 
     self.class.instance = self
     @running = false
     @splayed = false
   end
 
   # Prepare for catalog retrieval.  Downloads everything necessary, etc.
   def prepare(options)
     dostorage
     download_plugins unless options[:skip_plugin_download]
   end
 
   # Get the remote catalog, yo.  Returns nil if no catalog can be found.
   def retrieve_catalog(fact_options)
     fact_options ||= {}
     # First try it with no cache, then with the cache.
     unless (Puppet[:use_cached_catalog] and result = retrieve_catalog_from_cache(fact_options)) or result = retrieve_new_catalog(fact_options)
       if ! Puppet[:usecacheonfailure]
         Puppet.warning "Not using cache on failed catalog"
         return nil
       end
       result = retrieve_catalog_from_cache(fact_options)
     end
 
     return nil unless result
 
     convert_catalog(result, @duration)
   end
 
   # Convert a plain resource catalog into our full host catalog.
   def convert_catalog(result, duration)
     catalog = result.to_ral
     catalog.finalize
     catalog.retrieval_duration = duration
     catalog.write_class_file
     catalog.write_resource_file
     catalog
   end
 
   def prepare_and_retrieve_catalog(options)
     prepare(options)
 
     if Puppet::Resource::Catalog.indirection.terminus_class == :rest
       # This is a bit complicated.  We need the serialized and escaped facts,
       # and we need to know which format they're encoded in.  Thus, we
       # get a hash with both of these pieces of information.
       fact_options = facts_for_uploading
     end
 
     # set report host name now that we have the fact
     options[:report].host = Puppet[:node_name_value]
 
     unless catalog = (options.delete(:catalog) || retrieve_catalog(fact_options))
       Puppet.err "Could not retrieve catalog; skipping run"
       return
     end
     catalog
   end
 
   # Retrieve (optionally) and apply a catalog. If a catalog is passed in
   # the options, then apply that one, otherwise retrieve it.
   def apply_catalog(catalog, options)
     report = options[:report]
     report.configuration_version = catalog.version
     report.environment = Puppet[:environment]
 
     benchmark(:notice, "Finished catalog run") do
       catalog.apply(options)
     end
 
     report.finalize_report
     report
   end
 
   # The code that actually runs the catalog.
   # This just passes any options on to the catalog,
   # which accepts :tags and :ignoreschedules.
   def run(options = {})
     options[:report] ||= Puppet::Transaction::Report.new("apply")
     report = options[:report]
 
     Puppet::Util::Log.newdestination(report)
     begin
       begin
         unless catalog = prepare_and_retrieve_catalog(options)
           return nil
         end
 
         # Here we set the local environment based on what we get from the
         # catalog. Since a change in environment means a change in facts, and
         # facts may be used to determine which catalog we get, we need to
         # rerun the process if the environment is changed.
         tries = 0
         while catalog.environment and not catalog.environment.empty? and catalog.environment != Puppet[:environment]
           if tries > 3
             raise Puppet::Error, "Catalog environment didn't stabilize after #{tries} fetches, aborting run"
           end
           Puppet.warning "Local environment: \"#{Puppet[:environment]}\" doesn't match server specified environment \"#{catalog.environment}\", restarting agent run with new environment"
           Puppet[:environment] = catalog.environment
           return nil unless catalog = prepare_and_retrieve_catalog(options)
           tries += 1
         end
 
         execute_prerun_command or return nil
         apply_catalog(catalog, options)
         report.exit_status
       rescue SystemExit,NoMemoryError
         raise
       rescue => detail
         Puppet.log_exception(detail, "Failed to apply catalog: #{detail}")
         return nil
       ensure
         execute_postrun_command or return nil
       end
     ensure
       # Make sure we forget the retained module_directories of any autoload
       # we might have used.
       Thread.current[:env_module_directories] = nil
     end
   ensure
     Puppet::Util::Log.close(report)
     send_report(report)
   end
 
   def send_report(report)
     puts report.summary if Puppet[:summarize]
     save_last_run_summary(report)
     Puppet::Transaction::Report.indirection.save(report) if Puppet[:report]
   rescue => detail
     Puppet.log_exception(detail, "Could not send report: #{detail}")
   end
 
   def save_last_run_summary(report)
     mode = Puppet.settings.setting(:lastrunfile).mode
     Puppet::Util.replace_file(Puppet[:lastrunfile], mode) do |fh|
       fh.print YAML.dump(report.raw_summary)
     end
   rescue => detail
     Puppet.log_exception(detail, "Could not save last run local report: #{detail}")
   end
 
   private
 
-  def self.timeout
-    timeout = Puppet[:configtimeout]
-    case timeout
-    when String
-      if timeout =~ /^\d+$/
-        timeout = Integer(timeout)
-      else
-        raise ArgumentError, "Configuration timeout must be an integer"
-      end
-    when Integer # nothing
-    else
-      raise ArgumentError, "Configuration timeout must be an integer"
-    end
-
-    timeout
-  end
-
   def execute_from_setting(setting)
     return true if (command = Puppet[setting]) == ""
 
     begin
       Puppet::Util::Execution.execute([command])
       true
     rescue => detail
       Puppet.log_exception(detail, "Could not run command from #{setting}: #{detail}")
       false
     end
   end
 
   def retrieve_catalog_from_cache(fact_options)
     result = nil
     @duration = thinmark do
       result = Puppet::Resource::Catalog.indirection.find(Puppet[:node_name_value], fact_options.merge(:ignore_terminus => true))
     end
     Puppet.notice "Using cached catalog"
     result
   rescue => detail
     Puppet.log_exception(detail, "Could not retrieve catalog from cache: #{detail}")
     return nil
   end
 
   def retrieve_new_catalog(fact_options)
     result = nil
     @duration = thinmark do
       result = Puppet::Resource::Catalog.indirection.find(Puppet[:node_name_value], fact_options.merge(:ignore_cache => true))
     end
     result
   rescue SystemExit,NoMemoryError
     raise
   rescue Exception => detail
     Puppet.log_exception(detail, "Could not retrieve catalog from remote server: #{detail}")
     return nil
   end
 end
diff --git a/lib/puppet/configurer/downloader.rb b/lib/puppet/configurer/downloader.rb
index 4a70c0669..9a0af4e29 100644
--- a/lib/puppet/configurer/downloader.rb
+++ b/lib/puppet/configurer/downloader.rb
@@ -1,85 +1,72 @@
 require 'puppet/configurer'
 require 'puppet/resource/catalog'
 
 class Puppet::Configurer::Downloader
-  attr_reader :name, :path, :source, :ignore
-
-  # Determine the timeout value to use.
-  def self.timeout
-    timeout = Puppet[:configtimeout]
-    case timeout
-    when String
-      if timeout =~ /^\d+$/
-        timeout = Integer(timeout)
-      else
-        raise ArgumentError, "Configuration timeout must be an integer"
-      end
-    when Integer # nothing
-    else
-      raise ArgumentError, "Configuration timeout must be an integer"
-    end
-
-    timeout
+  require 'puppet/util/config_timeout'
+  class <<self
+    include Puppet::Util::ConfigTimeout
   end
+  
+  attr_reader :name, :path, :source, :ignore
 
   # Evaluate our download, returning the list of changed values.
   def evaluate
     Puppet.info "Retrieving #{name}"
 
     files = []
     begin
-      Timeout.timeout(self.class.timeout) do
+      ::Timeout.timeout(self.class.timeout) do
         catalog.apply do |trans|
           trans.changed?.find_all do |resource|
             yield resource if block_given?
             files << resource[:path]
           end
         end
       end
     rescue Puppet::Error, Timeout::Error => detail
       Puppet.log_exception(detail, "Could not retrieve #{name}: #{detail}")
     end
 
     files
   end
 
   def initialize(name, path, source, ignore = nil)
     @name, @path, @source, @ignore = name, path, source, ignore
   end
 
   def catalog
     catalog = Puppet::Resource::Catalog.new
     catalog.host_config = false
     catalog.add_resource(file)
     catalog
   end
 
   def file
     args = default_arguments.merge(:path => path, :source => source)
     args[:ignore] = ignore.split if ignore
     Puppet::Type.type(:file).new(args)
   end
 
   private
 
   require 'sys/admin' if Puppet.features.microsoft_windows?
 
   def default_arguments
     {
       :path => path,
       :recurse => true,
       :source => source,
       :tag => name,
       :purge => true,
       :force => true,
       :backup => false,
       :noop => false
     }.merge(
       Puppet.features.microsoft_windows? ? {} :
       {
         :owner => Process.uid,
         :group => Process.gid
       }
     )
   end
 end
diff --git a/lib/puppet/indirector/facts/facter.rb b/lib/puppet/indirector/facts/facter.rb
index e41ef02e7..407d2a06e 100644
--- a/lib/puppet/indirector/facts/facter.rb
+++ b/lib/puppet/indirector/facts/facter.rb
@@ -1,96 +1,83 @@
 require 'puppet/node/facts'
 require 'puppet/indirector/code'
 
 class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
+  require 'puppet/util/config_timeout'
+  class <<self
+    include Puppet::Util::ConfigTimeout
+  end
   desc "Retrieve facts from Facter.  This provides a somewhat abstract interface
     between Puppet and Facter.  It's only `somewhat` abstract because it always
     returns the local host's facts, regardless of what you attempt to find."
 
 
   # Clear out all of the loaded facts. Reload facter but not puppet facts.
   # NOTE: This is clumsy and shouldn't be required for later (1.5.x) versions
   # of Facter.
   def self.reload_facter
     Facter.clear
 
     # Reload everything.
     if Facter.respond_to? :loadfacts
       Facter.loadfacts
     elsif Facter.respond_to? :load
       Facter.load
     else
       Puppet.warning "You should upgrade your version of Facter to at least 1.3.8"
     end
   end
 
   def self.load_fact_plugins
     # Add any per-module fact directories to the factpath
     module_fact_dirs = Puppet[:modulepath].split(File::PATH_SEPARATOR).collect do |d|
       ["lib", "plugins"].map do |subdirectory|
         Dir.glob("#{d}/*/#{subdirectory}/facter")
       end
     end.flatten
     dirs = module_fact_dirs + Puppet[:factpath].split(File::PATH_SEPARATOR)
     x = dirs.uniq.each do |dir|
       load_facts_in_dir(dir)
     end
   end
 
   def self.load_facts_in_dir(dir)
     return unless FileTest.directory?(dir)
 
     Dir.chdir(dir) do
       Dir.glob("*.rb").each do |file|
         fqfile = ::File.join(dir, file)
         begin
           Puppet.info "Loading facts in #{fqfile}"
-          Timeout::timeout(self.timeout) do
+          ::Timeout::timeout(self.timeout) do
             load file
           end
         rescue SystemExit,NoMemoryError
           raise
         rescue Exception => detail
           Puppet.warning "Could not load fact file #{fqfile}: #{detail}"
         end
       end
     end
   end
 
-  def self.timeout
-    timeout = Puppet[:configtimeout]
-    case timeout
-    when String
-      if timeout =~ /^\d+$/
-        timeout = Integer(timeout)
-      else
-        raise ArgumentError, "Configuration timeout must be an integer"
-      end
-    when Integer # nothing
-    else
-      raise ArgumentError, "Configuration timeout must be an integer"
-    end
-
-    timeout
-  end
-
   def destroy(facts)
     raise Puppet::DevError, "You cannot destroy facts in the code store; it is only used for getting facts from Facter"
   end
 
   # Look a host's facts up in Facter.
   def find(request)
     self.class.reload_facter
     self.class.load_fact_plugins
     result = Puppet::Node::Facts.new(request.key, Facter.to_hash)
 
     result.add_local_facts
     result.stringify
     result.downcase_if_necessary
 
     result
   end
 
   def save(facts)
     raise Puppet::DevError, "You cannot save facts to the code store; it is only used for getting facts from Facter"
   end
 end
diff --git a/lib/puppet/util/config_timeout.rb b/lib/puppet/util/config_timeout.rb
new file mode 100644
index 000000000..6e05ea231
--- /dev/null
+++ b/lib/puppet/util/config_timeout.rb
@@ -0,0 +1,18 @@
+module Puppet::Util::ConfigTimeout
+  def timeout
+    timeout = Puppet[:configtimeout]
+    case timeout
+    when String
+      if timeout =~ /^\d+$/
+        timeout = Integer(timeout)
+      else
+        raise ArgumentError, "Configuration timeout must be an integer"
+      end
+    when Integer # nothing
+    else
+      raise ArgumentError, "Configuration timeout must be an integer"
+    end
+
+    timeout
+  end
+end
\ No newline at end of file