diff --git a/lib/puppet/application/agent.rb b/lib/puppet/application/agent.rb
index 3749241f8..9f5921de1 100644
--- a/lib/puppet/application/agent.rb
+++ b/lib/puppet/application/agent.rb
@@ -1,270 +1,272 @@
 require 'puppet/application'
 
 class Puppet::Application::Agent < Puppet::Application
 
   should_parse_config
   run_mode :agent
 
   attr_accessor :args, :agent, :daemon, :host
 
   def preinit
     # Do an initial trap, so that cancels don't get a stack trace.
     Signal.trap(:INT) do
       $stderr.puts "Cancelling startup"
       exit(0)
     end
 
     {
       :waitforcert => nil,
       :detailed_exitcodes => false,
       :verbose => false,
       :debug => false,
       :centrallogs => false,
       :setdest => false,
       :enable => false,
       :disable => false,
       :client => true,
       :fqdn => nil,
       :serve => [],
       :digest => :MD5,
       :fingerprint => false,
     }.each do |opt,val|
       options[opt] = val
     end
 
     @args = {}
     require 'puppet/daemon'
     @daemon = Puppet::Daemon.new
     @daemon.argv = ARGV.dup
   end
 
   option("--centrallogging")
   option("--disable")
   option("--enable")
   option("--debug","-d")
   option("--fqdn FQDN","-f")
   option("--test","-t")
   option("--verbose","-v")
 
   option("--fingerprint")
   option("--digest DIGEST")
 
   option("--serve HANDLER", "-s") do |arg|
     if Puppet::Network::Handler.handler(arg)
       options[:serve] << arg.to_sym
     else
       raise "Could not find handler for #{arg}"
     end
   end
 
   option("--no-client") do |arg|
     options[:client] = false
   end
 
   option("--detailed-exitcodes") do |arg|
     options[:detailed_exitcodes] = true
   end
 
   option("--logdest DEST", "-l DEST") do |arg|
     begin
       Puppet::Util::Log.newdestination(arg)
       options[:setdest] = true
     rescue => detail
       puts detail.backtrace if Puppet[:debug]
       $stderr.puts detail.to_s
     end
   end
 
   option("--waitforcert WAITFORCERT", "-w") do |arg|
     options[:waitforcert] = arg.to_i
   end
 
   option("--port PORT","-p") do |arg|
     @args[:Port] = arg
   end
 
   def run_command
     return fingerprint if options[:fingerprint]
     return onetime if Puppet[:onetime]
     main
   end
 
   def fingerprint
     unless cert = host.certificate || host.certificate_request
       $stderr.puts "Fingerprint asked but no certificate nor certificate request have yet been issued"
       exit(1)
       return
     end
     unless fingerprint = cert.fingerprint(options[:digest])
       raise ArgumentError, "Could not get fingerprint for digest '#{options[:digest]}'"
     end
     Puppet.notice fingerprint
   end
 
   def onetime
     unless options[:client]
       $stderr.puts "onetime is specified but there is no client"
       exit(43)
       return
     end
 
     @daemon.set_signal_traps
 
     begin
       report = @agent.run
     rescue => detail
       puts detail.backtrace if Puppet[:trace]
       Puppet.err detail.to_s
     end
 
     if not report
       exit(1)
     elsif options[:detailed_exitcodes] then
       exit(report.exit_status)
     else
       exit(0)
     end
   end
 
   def main
     Puppet.notice "Starting Puppet client version #{Puppet.version}"
 
     @daemon.start
   end
 
   # Enable all of the most common test options.
   def setup_test
     Puppet.settings.handlearg("--ignorecache")
     Puppet.settings.handlearg("--no-usecacheonfailure")
     Puppet.settings.handlearg("--no-splay")
     Puppet.settings.handlearg("--show_diff")
     Puppet.settings.handlearg("--no-daemonize")
     options[:verbose] = true
     Puppet[:onetime] = true
     options[:detailed_exitcodes] = true
   end
 
   # Handle the logging settings.
   def setup_logs
     if options[:debug] or options[:verbose]
       Puppet::Util::Log.newdestination(:console)
       if options[:debug]
         Puppet::Util::Log.level = :debug
       else
         Puppet::Util::Log.level = :info
       end
     end
 
     Puppet::Util::Log.newdestination(:syslog) unless options[:setdest]
   end
 
   def enable_disable_client(agent)
     if options[:enable]
       agent.enable
     elsif options[:disable]
       agent.disable
     end
     exit(0)
   end
 
   def setup_listen
     unless FileTest.exists?(Puppet[:authconfig])
       Puppet.err "Will not start without authorization file #{Puppet[:authconfig]}"
       exit(14)
     end
 
     handlers = nil
 
     if options[:serve].empty?
       handlers = [:Runner]
     else
       handlers = options[:serve]
     end
 
     require 'puppet/network/server'
     # No REST handlers yet.
     server = Puppet::Network::Server.new(:xmlrpc_handlers => handlers, :port => Puppet[:puppetport])
 
     @daemon.server = server
   end
 
   def setup_host
     @host = Puppet::SSL::Host.new
     waitforcert = options[:waitforcert] || (Puppet[:onetime] ? 0 : 120)
     cert = @host.wait_for_cert(waitforcert) unless options[:fingerprint]
   end
 
   def setup
     setup_test if options[:test]
 
     setup_logs
 
     exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
 
     # If noop is set, then also enable diffs
     Puppet[:show_diff] = true if Puppet[:noop]
 
     args[:Server] = Puppet[:server]
     if options[:fqdn]
       args[:FQDN] = options[:fqdn]
       Puppet[:certname] = options[:fqdn]
     end
 
     if options[:centrallogs]
       logdest = args[:Server]
 
       logdest += ":" + args[:Port] if args.include?(:Port)
       Puppet::Util::Log.newdestination(logdest)
     end
 
     Puppet.settings.use :main, :agent, :ssl
 
     # Always ignoreimport for agent. It really shouldn't even try to import,
     # but this is just a temporary band-aid.
     Puppet[:ignoreimport] = true
 
     # We need to specify a ca location for all of the SSL-related i
     # indirected classes to work; in fingerprint mode we just need
     # access to the local files and we don't need a ca.
     Puppet::SSL::Host.ca_location = options[:fingerprint] ? :none : :remote
 
     Puppet::Transaction::Report.terminus_class = :rest
+    # we want the last report to be persisted locally
+    Puppet::Transaction::Report.cache_class = :yaml
 
     # Override the default; puppetd needs this, usually.
     # You can still override this on the command-line with, e.g., :compiler.
     Puppet[:catalog_terminus] = :rest
 
     # Override the default.
     Puppet[:facts_terminus] = :facter
 
     Puppet::Resource::Catalog.cache_class = :yaml
 
 
     # We need tomake the client either way, we just don't start it
     # if --no-client is set.
     require 'puppet/agent'
     require 'puppet/configurer'
     @agent = Puppet::Agent.new(Puppet::Configurer)
 
     enable_disable_client(@agent) if options[:enable] or options[:disable]
 
     @daemon.agent = agent if options[:client]
 
     # It'd be nice to daemonize later, but we have to daemonize before the
     # waitforcert happens.
     @daemon.daemonize if Puppet[:daemonize]
 
     setup_host
 
     @objects = []
 
     # This has to go after the certs are dealt with.
     if Puppet[:listen]
       unless Puppet[:onetime]
         setup_listen
       else
         Puppet.notice "Ignoring --listen on onetime run"
       end
     end
   end
 end
diff --git a/lib/puppet/application/apply.rb b/lib/puppet/application/apply.rb
index cc733e1f5..7f0b95a89 100644
--- a/lib/puppet/application/apply.rb
+++ b/lib/puppet/application/apply.rb
@@ -1,157 +1,160 @@
 require 'puppet/application'
 
 class Puppet::Application::Apply < Puppet::Application
 
   should_parse_config
 
   option("--debug","-d")
   option("--execute EXECUTE","-e") do |arg|
     options[:code] = arg
   end
   option("--loadclasses","-L")
   option("--verbose","-v")
   option("--use-nodes")
   option("--detailed-exitcodes")
 
   option("--apply catalog",  "-a catalog") do |arg|
     options[:catalog] = arg
   end
 
   option("--logdest LOGDEST", "-l") do |arg|
     begin
       Puppet::Util::Log.newdestination(arg)
       options[:logset] = true
     rescue => detail
       $stderr.puts detail.to_s
     end
   end
 
   def run_command
     if options[:catalog]
       apply
     elsif Puppet[:parseonly]
       parseonly
     else
       main
     end
   end
 
   def apply
     if options[:catalog] == "-"
       text = $stdin.read
     else
       text = File.read(options[:catalog])
     end
 
     begin
       catalog = Puppet::Resource::Catalog.convert_from(Puppet::Resource::Catalog.default_format,text)
       catalog = Puppet::Resource::Catalog.pson_create(catalog) unless catalog.is_a?(Puppet::Resource::Catalog)
     rescue => detail
       raise Puppet::Error, "Could not deserialize catalog from pson: #{detail}"
     end
 
     catalog = catalog.to_ral
 
     require 'puppet/configurer'
     configurer = Puppet::Configurer.new
     configurer.run :catalog => catalog
   end
 
   def parseonly
     # Set our code or file to use.
     if options[:code] or command_line.args.length == 0
       Puppet[:code] = options[:code] || STDIN.read
     else
       Puppet[:manifest] = command_line.args.shift
     end
     begin
       Puppet::Node::Environment.new(Puppet[:environment]).known_resource_types
     rescue => detail
       Puppet.err detail
       exit 1
     end
     exit 0
   end
 
   def main
     # Set our code or file to use.
     if options[:code] or command_line.args.length == 0
       Puppet[:code] = options[:code] || STDIN.read
     else
       manifest = command_line.args.shift
       raise "Could not find file #{manifest}" unless File.exist?(manifest)
       Puppet.warning("Only one file can be applied per run.  Skipping #{command_line.args.join(', ')}") if command_line.args.size > 0
       Puppet[:manifest] = manifest
     end
 
     # Collect our facts.
     unless facts = Puppet::Node::Facts.find(Puppet[:certname])
       raise "Could not find facts for #{Puppet[:certname]}"
     end
 
     # Find our Node
     unless node = Puppet::Node.find(Puppet[:certname])
       raise "Could not find node #{Puppet[:certname]}"
     end
 
     # Merge in the facts.
     node.merge(facts.values)
 
     # Allow users to load the classes that puppet agent creates.
     if options[:loadclasses]
       file = Puppet[:classfile]
       if FileTest.exists?(file)
         unless FileTest.readable?(file)
           $stderr.puts "#{file} is not readable"
           exit(63)
         end
         node.classes = File.read(file).split(/[\s\n]+/)
       end
     end
 
     begin
       # Compile our catalog
       starttime = Time.now
       catalog = Puppet::Resource::Catalog.find(node.name, :use_node => node)
 
       # Translate it to a RAL catalog
       catalog = catalog.to_ral
 
       catalog.finalize
 
       catalog.retrieval_duration = Time.now - starttime
 
       require 'puppet/configurer'
       configurer = Puppet::Configurer.new
       report = configurer.run(:skip_plugin_download => true, :catalog => catalog)
 
       exit( options[:detailed_exitcodes] ? report.exit_status : 0 )
     rescue => detail
       puts detail.backtrace if Puppet[:trace]
       $stderr.puts detail.message
       exit(1)
     end
   end
 
   def setup
     exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
 
     # If noop is set, then also enable diffs
     Puppet[:show_diff] = true if Puppet[:noop]
 
     Puppet::Util::Log.newdestination(:console) unless options[:logset]
     client = nil
     server = nil
 
     Signal.trap(:INT) do
       $stderr.puts "Exiting"
       exit(1)
     end
 
+    # we want the last report to be persisted locally
+    Puppet::Transaction::Report.cache_class = :yaml
+
     if options[:debug]
       Puppet::Util::Log.level = :debug
     elsif options[:verbose]
       Puppet::Util::Log.level = :info
     end
   end
 end
diff --git a/lib/puppet/configurer.rb b/lib/puppet/configurer.rb
index d3c902576..9f68ca499 100644
--- a/lib/puppet/configurer.rb
+++ b/lib/puppet/configurer.rb
@@ -1,237 +1,246 @@
 # The client for interacting with the puppetmaster config server.
 require 'sync'
 require 'timeout'
 require 'puppet/network/http_pool'
 require 'puppet/util'
 
 class Puppet::Configurer
   class CommandHookError < RuntimeError; end
 
   require 'puppet/configurer/fact_handler'
   require 'puppet/configurer/plugin_handler'
 
   include Puppet::Configurer::FactHandler
   include Puppet::Configurer::PluginHandler
 
   # 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 clear
     @catalog.clear(true) if @catalog
     @catalog = nil
   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
       puts detail.backtrace if Puppet[:trace]
       Puppet.err "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]
 
     download_fact_plugins unless options[:skip_plugin_download]
 
     execute_prerun_command
   end
 
   # Get the remote catalog, yo.  Returns nil if no catalog can be found.
   def retrieve_catalog
     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
     else
       fact_options = {}
     end
 
     # 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
   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 = {})
     begin
       prepare(options)
     rescue SystemExit,NoMemoryError
       raise
     rescue Exception => detail
       puts detail.backtrace if Puppet[:trace]
       Puppet.err "Failed to prepare catalog: #{detail}"
     end
 
     options[:report] ||= Puppet::Transaction::Report.new("apply")
     report = options[:report]
     Puppet::Util::Log.newdestination(report)
 
     if catalog = options[:catalog]
       options.delete(:catalog)
     elsif ! catalog = retrieve_catalog
       Puppet.err "Could not retrieve catalog; skipping run"
       return
     end
 
     report.configuration_version = catalog.version
 
     transaction = nil
 
     begin
       benchmark(:notice, "Finished catalog run") do
         transaction = catalog.apply(options)
       end
       report
     rescue => detail
       puts detail.backtrace if Puppet[:trace]
       Puppet.err "Failed to apply catalog: #{detail}"
       return
     end
   ensure
     # Make sure we forget the retained module_directories of any autoload
     # we might have used.
     Thread.current[:env_module_directories] = nil
 
     # Now close all of our existing http connections, since there's no
     # reason to leave them lying open.
     Puppet::Network::HttpPool.clear_http_instances
     execute_postrun_command
 
     Puppet::Util::Log.close(report)
-
     send_report(report, transaction)
   end
 
   def send_report(report, trans)
     report.finalize_report if trans
     puts report.summary if Puppet[:summarize]
+    save_last_run_summary(report)
     report.save if Puppet[:report]
   rescue => detail
     puts detail.backtrace if Puppet[:trace]
     Puppet.err "Could not send report: #{detail}"
   end
 
+  def save_last_run_summary(report)
+    Puppet::Util::FileLocking.writelock(Puppet[:lastrunfile], 0660) do |file|
+      file.print YAML.dump(report.raw_summary)
+    end
+  rescue => detail
+    puts detail.backtrace if Puppet[:trace]
+    Puppet.err "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 if (command = Puppet[setting]) == ""
 
     begin
       Puppet::Util.execute([command])
     rescue => detail
       raise CommandHookError, "Could not run command from #{setting}: #{detail}"
     end
   end
 
   def retrieve_catalog_from_cache(fact_options)
     result = nil
     @duration = thinmark do
       result = Puppet::Resource::Catalog.find(Puppet[:certname], fact_options.merge(:ignore_terminus => true))
     end
     Puppet.notice "Using cached catalog"
     result
   rescue => detail
     puts detail.backtrace if Puppet[:trace]
     Puppet.err "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.find(Puppet[:certname], fact_options.merge(:ignore_cache => true))
     end
     result
   rescue SystemExit,NoMemoryError
     raise
   rescue Exception => detail
     puts detail.backtrace if Puppet[:trace]
     Puppet.err "Could not retrieve catalog from remote server: #{detail}"
     return nil
   end
 end
diff --git a/lib/puppet/defaults.rb b/lib/puppet/defaults.rb
index 36159bcf7..2a1ded592 100644
--- a/lib/puppet/defaults.rb
+++ b/lib/puppet/defaults.rb
@@ -1,818 +1,826 @@
 # The majority of the system configuration parameters are set in this file.
 module Puppet
   setdefaults(:main,
     :confdir => [Puppet.run_mode.conf_dir, "The main Puppet configuration directory.  The default for this parameter is calculated based on the user.  If the process
     is running as root or the user that Puppet is supposed to run as, it defaults to a system directory, but if it's running as any other user,
     it defaults to being in the user's home directory."],
     :vardir => [Puppet.run_mode.var_dir, "Where Puppet stores dynamic and growing data.  The default for this parameter is calculated specially, like `confdir`_."],
     :name => [Puppet.application_name.to_s, "The name of the application, if we are running as one.  The
       default is essentially $0 without the path or `.rb`."],
     :run_mode => [Puppet.run_mode.name.to_s, "The effective 'run mode' of the application: master, agent, or user."]
   )
 
   setdefaults(:main, :logdir => Puppet.run_mode.logopts)
 
   setdefaults(:main,
     :trace => [false, "Whether to print stack traces on some errors"],
     :autoflush => {
       :default => false,
       :desc    => "Whether log files should always flush to disk.",
       :hook    => proc { |value| Log.autoflush = value }
     },
     :syslogfacility => ["daemon", "What syslog facility to use when logging to
       syslog.  Syslog has a fixed list of valid facilities, and you must
       choose one of those; you cannot just make one up."],
     :statedir => { :default => "$vardir/state",
       :mode => 01755,
       :desc => "The directory where Puppet state is stored.  Generally,
         this directory can be removed without causing harm (although it
         might result in spurious service restarts)."
     },
     :rundir => {
       :default => Puppet.run_mode.run_dir,
       :mode => 01777,
       :desc => "Where Puppet PID files are kept."
     },
     :genconfig => [false,
       "Whether to just print a configuration to stdout and exit.  Only makes
       sense when used interactively.  Takes into account arguments specified
       on the CLI."],
     :genmanifest => [false,
       "Whether to just print a manifest to stdout and exit.  Only makes
       sense when used interactively.  Takes into account arguments specified
       on the CLI."],
     :configprint => ["",
       "Print the value of a specific configuration parameter.  If a
       parameter is provided for this, then the value is printed and puppet
       exits.  Comma-separate multiple values.  For a list of all values,
       specify 'all'.  This feature is only available in Puppet versions
       higher than 0.18.4."],
     :color => ["ansi", "Whether to use colors when logging to the console.
       Valid values are `ansi` (equivalent to `true`), `html` (mostly
       used during testing with TextMate), and `false`, which produces
       no color."],
     :mkusers => [false,
       "Whether to create the necessary user and group that puppet agent will
       run as."],
     :manage_internal_file_permissions => [true,
       "Whether Puppet should manage the owner, group, and mode of files
       it uses internally"
       ],
     :onetime => {:default => false,
       :desc => "Run the configuration once, rather than as a long-running
       daemon. This is useful for interactively running puppetd.",
       :short => 'o'
       },
     :path => {:default => "none",
       :desc => "The shell search path.  Defaults to whatever is inherited
         from the parent process.",
       :call_on_define => true, # Call our hook with the default value, so we always get the libdir set.
       :hook => proc do |value|
         ENV["PATH"] = "" if ENV["PATH"].nil?
         ENV["PATH"] = value unless value == "none"
         paths = ENV["PATH"].split(File::PATH_SEPARATOR)
         %w{/usr/sbin /sbin}.each do |path|
           ENV["PATH"] += File::PATH_SEPARATOR + path unless paths.include?(path)
         end
         value
       end
     },
     :libdir => {:default => "$vardir/lib",
       :desc => "An extra search path for Puppet.  This is only useful
         for those files that Puppet will load on demand, and is only
         guaranteed to work for those cases.  In fact, the autoload
         mechanism is responsible for making sure this directory
         is in Ruby's search path",
       :call_on_define => true, # Call our hook with the default value, so we always get the libdir set.
       :hook => proc do |value|
         $LOAD_PATH.delete(@oldlibdir) if defined?(@oldlibdir) and $LOAD_PATH.include?(@oldlibdir)
         @oldlibdir = value
         $LOAD_PATH << value
       end
     },
     :ignoreimport => [false, "A parameter that can be used in commit
       hooks, since it enables you to parse-check a single file rather
       than requiring that all files exist."],
     :authconfig => [ "$confdir/namespaceauth.conf",
       "The configuration file that defines the rights to the different
       namespaces and methods.  This can be used as a coarse-grained
       authorization system for both `puppet agent` and `puppet master`."
     ],
     :environment => {:default => "production", :desc => "The environment Puppet is running in.  For clients
       (e.g., `puppet agent`) this determines the environment itself, which
       is used to find modules and much more.  For servers (i.e., `puppet master`) this provides the default environment for nodes
       we know nothing about."
     },
     :diff_args => ["-u", "Which arguments to pass to the diff command when printing differences between files."],
     :diff => ["diff", "Which diff command to use when printing differences between files."],
     :show_diff => [false, "Whether to print a contextual diff when files are being replaced.  The diff
       is printed on stdout, so this option is meaningless unless you are running Puppet interactively.
       This feature currently requires the `diff/lcs` Ruby library."],
     :daemonize => { :default => true,
       :desc => "Send the process into the background.  This is the default.",
       :short => "D"
     },
     :maximum_uid => [4294967290, "The maximum allowed UID.  Some platforms use negative UIDs
       but then ship with tools that do not know how to handle signed ints, so the UIDs show up as
       huge numbers that can then not be fed back into the system.  This is a hackish way to fail in a
       slightly more useful way when that happens."],
     :node_terminus => ["plain", "Where to find information about nodes."],
     :catalog_terminus => ["compiler", "Where to get node catalogs.  This is useful to change if, for instance,
       you'd like to pre-compile catalogs and store them in memcached or some other easily-accessed store."],
     :facts_terminus => {
       :default => Puppet.application_name.to_s == "master" ? 'yaml' : 'facter', 
       :desc => "The node facts terminus.",
       :hook => proc do |value|
         require 'puppet/node/facts'
         if value.to_s == "rest"
           Puppet::Node::Facts.cache_class = :yaml
         end
       end
     },
     :inventory_terminus => [ "$facts_terminus", "Should usually be the same as the facts terminus" ],
     :httplog => { :default => "$logdir/http.log",
       :owner => "root",
       :mode => 0640,
       :desc => "Where the puppet agent web server logs."
     },
     :http_proxy_host => ["none",
       "The HTTP proxy host to use for outgoing connections.  Note: You
       may need to use a FQDN for the server hostname when using a proxy."],
     :http_proxy_port => [3128, "The HTTP proxy port to use for outgoing connections"],
     :filetimeout => [ 15,
       "The minimum time to wait (in seconds) between checking for updates in
       configuration files.  This timeout determines how quickly Puppet checks whether
       a file (such as manifests or templates) has changed on disk."
     ],
     :queue_type => ["stomp", "Which type of queue to use for asynchronous processing."],
     :queue_type => ["stomp", "Which type of queue to use for asynchronous processing."],
     :queue_source => ["stomp://localhost:61613/", "Which type of queue to use for asynchronous processing.  If your stomp server requires
       authentication, you can include it in the URI as long as your stomp client library is at least 1.1.1"],
     :async_storeconfigs => {:default => false, :desc => "Whether to use a queueing system to provide asynchronous database integration.
       Requires that `puppetqd` be running and that 'PSON' support for ruby be installed.",
       :hook => proc do |value|
         if value
           # This reconfigures the terminii for Node, Facts, and Catalog
           Puppet.settings[:storeconfigs] = true
 
           # But then we modify the configuration
           Puppet::Resource::Catalog.cache_class = :queue
         else
           raise "Cannot disable asynchronous storeconfigs in a running process"
         end
       end
     },
     :thin_storeconfigs => {:default => false, :desc =>
       "Boolean; wether storeconfigs store in the database only the facts and exported resources.
       If true, then storeconfigs performance will be higher and still allow exported/collected
       resources, but other usage external to Puppet might not work",
       :hook => proc do |value|
         Puppet.settings[:storeconfigs] = true if value
         end
       },
     :config_version => ["", "How to determine the configuration version.  By default, it will be the
       time that the configuration is parsed, but you can provide a shell script to override how the
       version is determined.  The output of this script will be added to every log message in the
       reports, allowing you to correlate changes on your hosts to the source version on the server."],
     :zlib => [true,
       "Boolean; whether to use the zlib library",
     ],
     :prerun_command => ["", "A command to run before every agent run.  If this command returns a non-zero
       return code, the entire Puppet run will fail."],
     :postrun_command => ["", "A command to run after every agent run.  If this command returns a non-zero
       return code, the entire Puppet run will be considered to have failed, even though it might have
       performed work during the normal run."],
     :freeze_main => [false, "Freezes the 'main' class, disallowing any code to be added to it.  This
       essentially means that you can't have any code outside of a node, class, or definition other
       than in the site manifest."]
   )
 
   hostname = Facter["hostname"].value
   domain = Facter["domain"].value
   if domain and domain != ""
     fqdn = [hostname, domain].join(".")
   else
     fqdn = hostname
   end
 
 
     Puppet.setdefaults(
     :main,
 
     # We have to downcase the fqdn, because the current ssl stuff (as oppsed to in master) doesn't have good facilities for
     # manipulating naming.
     :certname => {:default => fqdn.downcase, :desc => "The name to use when handling certificates.  Defaults
       to the fully qualified domain name.",
       :call_on_define => true, # Call our hook with the default value, so we're always downcased
       :hook => proc { |value| raise(ArgumentError, "Certificate names must be lower case; see #1168") unless value == value.downcase }},
     :certdnsnames => ['', "The DNS names on the Server certificate as a colon-separated list.
       If it's anything other than an empty string, it will be used as an alias in the created
       certificate.  By default, only the server gets an alias set up, and only for 'puppet'."],
     :certdir => {
       :default => "$ssldir/certs",
       :owner => "service",
       :desc => "The certificate directory."
     },
     :ssldir => {
       :default => "$confdir/ssl",
       :mode => 0771,
       :owner => "service",
       :desc => "Where SSL certificates are kept."
     },
     :publickeydir => {
       :default => "$ssldir/public_keys",
       :owner => "service",
       :desc => "The public key directory."
     },
     :requestdir => {
       :default => "$ssldir/certificate_requests",
       :owner => "service",
       :desc => "Where host certificate requests are stored."
     },
     :privatekeydir => { :default => "$ssldir/private_keys",
       :mode => 0750,
       :owner => "service",
       :desc => "The private key directory."
     },
     :privatedir => { :default => "$ssldir/private",
       :mode => 0750,
       :owner => "service",
       :desc => "Where the client stores private certificate information."
     },
     :passfile => { :default => "$privatedir/password",
       :mode => 0640,
       :owner => "service",
       :desc => "Where puppet agent stores the password for its private key.
         Generally unused."
     },
     :hostcsr => { :default => "$ssldir/csr_$certname.pem",
       :mode => 0644,
       :owner => "service",
       :desc => "Where individual hosts store and look for their certificate requests."
     },
     :hostcert => { :default => "$certdir/$certname.pem",
       :mode => 0644,
       :owner => "service",
       :desc => "Where individual hosts store and look for their certificates."
     },
     :hostprivkey => { :default => "$privatekeydir/$certname.pem",
       :mode => 0600,
       :owner => "service",
       :desc => "Where individual hosts store and look for their private key."
     },
     :hostpubkey => { :default => "$publickeydir/$certname.pem",
       :mode => 0644,
       :owner => "service",
       :desc => "Where individual hosts store and look for their public key."
     },
     :localcacert => { :default => "$certdir/ca.pem",
       :mode => 0644,
       :owner => "service",
       :desc => "Where each client stores the CA certificate."
     },
     :hostcrl => { :default => "$ssldir/crl.pem",
       :mode => 0644,
       :owner => "service",
       :desc => "Where the host's certificate revocation list can be found.
         This is distinct from the certificate authority's CRL."
     },
     :certificate_revocation => [true, "Whether certificate revocation should be supported by downloading a Certificate Revocation List (CRL)
       to all clients.  If enabled, CA chaining will almost definitely not work."]
   )
 
     setdefaults(
     :ca,
     :ca_name => ["Puppet CA: $certname", "The name to use the Certificate Authority certificate."],
     :cadir => {  :default => "$ssldir/ca",
       :owner => "service",
       :group => "service",
       :mode => 0770,
       :desc => "The root directory for the certificate authority."
     },
     :cacert => { :default => "$cadir/ca_crt.pem",
       :owner => "service",
       :group => "service",
       :mode => 0660,
       :desc => "The CA certificate."
     },
     :cakey => { :default => "$cadir/ca_key.pem",
       :owner => "service",
       :group => "service",
       :mode => 0660,
       :desc => "The CA private key."
     },
     :capub => { :default => "$cadir/ca_pub.pem",
       :owner => "service",
       :group => "service",
       :desc => "The CA public key."
     },
     :cacrl => { :default => "$cadir/ca_crl.pem",
       :owner => "service",
       :group => "service",
       :mode => 0664,
 
       :desc => "The certificate revocation list (CRL) for the CA. Will be used if present but otherwise ignored.",
       :hook => proc do |value|
         if value == 'false'
           Puppet.warning "Setting the :cacrl to 'false' is deprecated; Puppet will just ignore the crl if yours is missing"
         end
       end
     },
     :caprivatedir => { :default => "$cadir/private",
       :owner => "service",
       :group => "service",
       :mode => 0770,
       :desc => "Where the CA stores private certificate information."
     },
     :csrdir => { :default => "$cadir/requests",
       :owner => "service",
       :group => "service",
       :desc => "Where the CA stores certificate requests"
     },
     :signeddir => { :default => "$cadir/signed",
       :owner => "service",
       :group => "service",
       :mode => 0770,
       :desc => "Where the CA stores signed certificates."
     },
     :capass => { :default => "$caprivatedir/ca.pass",
       :owner => "service",
       :group => "service",
       :mode => 0660,
       :desc => "Where the CA stores the password for the private key"
     },
     :serial => { :default => "$cadir/serial",
       :owner => "service",
       :group => "service",
       :mode => 0644,
       :desc => "Where the serial number for certificates is stored."
     },
     :autosign => { :default => "$confdir/autosign.conf",
       :mode => 0644,
       :desc => "Whether to enable autosign.  Valid values are true (which
         autosigns any key request, and is a very bad idea), false (which
         never autosigns any key request), and the path to a file, which
         uses that configuration file to determine which keys to sign."},
     :ca_days => ["", "How long a certificate should be valid.
       This parameter is deprecated, use ca_ttl instead"],
     :ca_ttl => ["5y", "The default TTL for new certificates; valid values
       must be an integer, optionally followed by one of the units
       'y' (years of 365 days), 'd' (days), 'h' (hours), or
       's' (seconds). The unit defaults to seconds. If this parameter
       is set, ca_days is ignored. Examples are '3600' (one hour)
       and '1825d', which is the same as '5y' (5 years) "],
     :ca_md => ["md5", "The type of hash used in certificates."],
     :req_bits => [2048, "The bit length of the certificates."],
     :keylength => [1024, "The bit length of keys."],
     :cert_inventory => {
       :default => "$cadir/inventory.txt",
       :mode => 0644,
       :owner => "service",
       :group => "service",
       :desc => "A Complete listing of all certificates"
     }
   )
 
   # Define the config default.
 
     setdefaults(
     Puppet.settings[:name],
     :config => ["$confdir/puppet.conf",
       "The configuration file for #{Puppet[:name]}."],
     :pidfile => ["$rundir/$name.pid", "The pid file"],
     :bindaddress => ["", "The address a listening server should bind to.  Mongrel servers
       default to 127.0.0.1 and WEBrick defaults to 0.0.0.0."],
     :servertype => {:default => "webrick", :desc => "The type of server to use.  Currently supported
       options are webrick and mongrel.  If you use mongrel, you will need
       a proxy in front of the process or processes, since Mongrel cannot
       speak SSL.",
 
       :call_on_define => true, # Call our hook with the default value, so we always get the correct bind address set.
       :hook => proc { |value|  value == "webrick" ? Puppet.settings[:bindaddress] = "0.0.0.0" : Puppet.settings[:bindaddress] = "127.0.0.1" if Puppet.settings[:bindaddress] == "" }
     }
   )
 
   setdefaults(:master,
     :user => ["puppet", "The user puppet master should run as."],
     :group => ["puppet", "The group puppet master should run as."],
     :manifestdir => ["$confdir/manifests", "Where puppet master looks for its manifests."],
     :manifest => ["$manifestdir/site.pp", "The entry-point manifest for puppet master."],
     :code => ["", "Code to parse directly.  This is essentially only used
       by `puppet`, and should only be set if you're writing your own Puppet
       executable"],
     :masterlog => { :default => "$logdir/puppetmaster.log",
       :owner => "service",
       :group => "service",
       :mode => 0660,
       :desc => "Where puppet master logs.  This is generally not used,
         since syslog is the default log destination."
     },
     :masterhttplog => { :default => "$logdir/masterhttp.log",
       :owner => "service",
       :group => "service",
       :mode => 0660,
       :create => true,
       :desc => "Where the puppet master web server logs."
     },
     :masterport => [8140, "Which port puppet master listens on."],
     :parseonly => [false, "Just check the syntax of the manifests."],
     :node_name => ["cert", "How the puppetmaster determines the client's identity
       and sets the 'hostname', 'fqdn' and 'domain' facts for use in the manifest,
       in particular for determining which 'node' statement applies to the client.
       Possible values are 'cert' (use the subject's CN in the client's
       certificate) and 'facter' (use the hostname that the client
       reported in its facts)"],
     :bucketdir => {
       :default => "$vardir/bucket",
       :mode => 0750,
       :owner => "service",
       :group => "service",
       :desc => "Where FileBucket files are stored."
     },
     :rest_authconfig => [ "$confdir/auth.conf",
       "The configuration file that defines the rights to the different
       rest indirections.  This can be used as a fine-grained
       authorization system for `puppet master`."
     ],
     :ca => [true, "Wether the master should function as a certificate authority."],
     :modulepath => {:default => "$confdir/modules:/usr/share/puppet/modules",
       :desc => "The search path for modules as a colon-separated list of
       directories.", :type => :setting }, # We don't want this to be considered a file, since it's multiple files.
     :ssl_client_header => ["HTTP_X_CLIENT_DN", "The header containing an authenticated
       client's SSL DN.  Only used with Mongrel.  This header must be set by the proxy
       to the authenticated client's SSL DN (e.g., `/CN=puppet.puppetlabs.com`).
       See http://projects.puppetlabs.com/projects/puppet/wiki/Using_Mongrel for more information."],
     :ssl_client_verify_header => ["HTTP_X_CLIENT_VERIFY", "The header containing the status
       message of the client verification. Only used with Mongrel.  This header must be set by the proxy
       to 'SUCCESS' if the client successfully authenticated, and anything else otherwise.
       See http://projects.puppetlabs.com/projects/puppet/wiki/Using_Mongrel for more information."],
     # To make sure this directory is created before we try to use it on the server, we need
     # it to be in the server section (#1138).
     :yamldir => {:default => "$vardir/yaml", :owner => "service", :group => "service", :mode => "750",
       :desc => "The directory in which YAML data is stored, usually in a subdirectory."},
     :server_datadir => {:default => "$vardir/server_data", :owner => "service", :group => "service", :mode => "750",
       :desc => "The directory in which serialized data is stored, usually in a subdirectory."},
     :reports => ["store",
       "The list of reports to generate.  All reports are looked for
       in `puppet/reports/name.rb`, and multiple report names should be
       comma-separated (whitespace is okay)."
     ],
     :reportdir => {:default => "$vardir/reports",
       :mode => 0750,
       :owner => "service",
       :group => "service",
       :desc => "The directory in which to store reports
         received from the client.  Each client gets a separate
         subdirectory."},
     :reporturl => ["http://localhost:3000/reports",
       "The URL used by the http reports processor to send reports"],
     :fileserverconfig => ["$confdir/fileserver.conf", "Where the fileserver configuration is stored."],
     :strict_hostname_checking => [false, "Whether to only search for the complete
       hostname as it is in the certificate when searching for node information
       in the catalogs."]
   )
 
   setdefaults(:metrics,
     :rrddir => {:default => "$vardir/rrd",
       :mode => 0750,
       :owner => "service",
       :group => "service",
       :desc => "The directory where RRD database files are stored.
         Directories for each reporting host will be created under
         this directory."
     },
     :rrdinterval => ["$runinterval", "How often RRD should expect data.
       This should match how often the hosts report back to the server."]
   )
 
   setdefaults(:agent,
     :localconfig => { :default => "$statedir/localconfig",
       :owner => "root",
       :mode => 0660,
       :desc => "Where puppet agent caches the local configuration.  An
         extension indicating the cache format is added automatically."},
     :statefile => { :default => "$statedir/state.yaml",
       :mode => 0660,
       :desc => "Where puppet agent and puppet master store state associated
         with the running configuration.  In the case of puppet master,
         this file reflects the state discovered through interacting
         with clients."
       },
     :clientyamldir => {:default => "$vardir/client_yaml", :mode => "750", :desc => "The directory in which client-side YAML data is stored."},
     :client_datadir => {:default => "$vardir/client_data", :mode => "750", :desc => "The directory in which serialized data is stored on the client."},
     :classfile => { :default => "$statedir/classes.txt",
       :owner => "root",
       :mode => 0644,
       :desc => "The file in which puppet agent stores a list of the classes
         associated with the retrieved configuration.  Can be loaded in
         the separate `puppet` executable using the `--loadclasses`
         option."},
     :puppetdlog => { :default => "$logdir/puppetd.log",
       :owner => "root",
       :mode => 0640,
       :desc => "The log file for puppet agent.  This is generally not used."
     },
     :server => ["puppet", "The server to which server puppet agent should connect"],
     :ignoreschedules => [false,
       "Boolean; whether puppet agent should ignore schedules.  This is useful
       for initial puppet agent runs."],
     :puppetport => [8139, "Which port puppet agent listens on."],
     :noop => [false, "Whether puppet agent should be run in noop mode."],
     :runinterval => [1800, # 30 minutes
       "How often puppet agent applies the client configuration; in seconds."],
     :listen => [false, "Whether puppet agent should listen for
       connections.  If this is true, then by default only the
       `runner` server is started, which allows remote authorized
       and authenticated nodes to connect and trigger `puppet agent`
       runs."],
     :ca_server => ["$server", "The server to use for certificate
       authority requests.  It's a separate server because it cannot
       and does not need to horizontally scale."],
     :ca_port => ["$masterport", "The port to use for the certificate authority."],
     :catalog_format => {
       :default => "",
       :desc => "(Deprecated for 'preferred_serialization_format') What format to
         use to dump the catalog.  Only supports 'marshal' and 'yaml'.  Only
         matters on the client, since it asks the server for a specific format.",
       :hook => proc { |value|
         if value
           Puppet.warning "Setting 'catalog_format' is deprecated; use 'preferred_serialization_format' instead."
           Puppet.settings[:preferred_serialization_format] = value
         end
       }
     },
     :preferred_serialization_format => ["pson", "The preferred means of serializing
       ruby instances for passing over the wire.  This won't guarantee that all
       instances will be serialized using this method, since not all classes
       can be guaranteed to support this format, but it will be used for all
       classes that support it."],
     :puppetdlockfile => [ "$statedir/puppetdlock", "A lock file to temporarily stop puppet agent from doing anything."],
     :usecacheonfailure => [true,
       "Whether to use the cached configuration when the remote
       configuration will not compile.  This option is useful for testing
       new configurations, where you want to fix the broken configuration
       rather than reverting to a known-good one."
     ],
     :use_cached_catalog => [false,
       "Whether to only use the cached catalog rather than compiling a new catalog
       on every run.  Puppet can be run with this enabled by default and then selectively
       disabled when a recompile is desired."],
     :ignorecache => [false,
       "Ignore cache and always recompile the configuration.  This is
       useful for testing new configurations, where the local cache may in
       fact be stale even if the timestamps are up to date - if the facts
       change or if the server changes."
     ],
     :downcasefacts => [false, "Whether facts should be made all lowercase when sent to the server."],
     :dynamicfacts => ["memorysize,memoryfree,swapsize,swapfree",
       "Facts that are dynamic; these facts will be ignored when deciding whether
       changed facts should result in a recompile.  Multiple facts should be
       comma-separated."],
     :splaylimit => ["$runinterval",
       "The maximum time to delay before runs.  Defaults to being the same as the
       run interval."],
     :splay => [false,
       "Whether to sleep for a pseudo-random (but consistent) amount of time before
       a run."],
     :clientbucketdir => {
       :default => "$vardir/clientbucket",
       :mode => 0750,
       :desc => "Where FileBucket files are stored locally."
     },
     :configtimeout => [120,
       "How long the client should wait for the configuration to be retrieved
       before considering it a failure.  This can help reduce flapping if too
       many clients contact the server at one time."
     ],
     :reportserver => {
       :default => "$server",
       :call_on_define => false,
       :desc => "(Deprecated for 'report_server') The server to which to send transaction reports.",
       :hook => proc do |value|
         Puppet.settings[:report_server] = value if value
       end
     },
     :report_server => ["$server",
       "The server to send transaction reports to."
     ],
     :report_port => ["$masterport",
       "The port to communicate with the report_server."
     ],
     :inventory_server => ["$server",
       "The server to send facts to."
     ],
     :inventory_port => ["$masterport",
       "The port to communicate with the inventory_server."
     ],
     :report => [false,
       "Whether to send reports after every transaction."
     ],
+    :lastrunfile =>  { :default => "$statedir/last_run_summary.yaml",
+      :mode => 0660,
+      :desc => "Where puppet agent stores the last run report summary in yaml format."
+    },
+    :lastrunreport =>  { :default => "$statedir/last_run_report.yaml",
+      :mode => 0660,
+      :desc => "Where puppet agent stores the last run report in yaml format."
+    },
     :graph => [false, "Whether to create dot graph files for the different
       configuration graphs.  These dot files can be interpreted by tools
       like OmniGraffle or dot (which is part of ImageMagick)."],
     :graphdir => ["$statedir/graphs", "Where to store dot-outputted graphs."],
     :http_compression => [false, "Allow http compression in REST communication with the master.
       This setting might improve performance for agent -> master communications over slow WANs.
       Your puppetmaster needs to support compression (usually by activating some settings in a reverse-proxy
       in front of the puppetmaster, which rules out webrick).
       It is harmless to activate this settings if your master doesn't support
       compression, but if it supports it, this setting might reduce performance on high-speed LANs."]
   )
 
   setdefaults(:inspect,
       :archive_files => [false, "During an inspect run, whether to archive files whose contents are audited to a file bucket."],
       :archive_file_server => ["$server", "During an inspect run, the file bucket server to archive files to if archive_files is set."]
   )
 
   # Plugin information.
 
     setdefaults(
     :main,
     :plugindest => ["$libdir",
       "Where Puppet should store plugins that it pulls down from the central
       server."],
     :pluginsource => ["puppet://$server/plugins",
       "From where to retrieve plugins.  The standard Puppet `file` type
       is used for retrieval, so anything that is a valid file source can
       be used here."],
     :pluginsync => [false, "Whether plugins should be synced with the central server."],
 
     :pluginsignore => [".svn CVS .git", "What files to ignore when pulling down plugins."]
   )
 
   # Central fact information.
 
     setdefaults(
     :main,
     :factpath => {:default => "$vardir/lib/facter:$vardir/facts",
       :desc => "Where Puppet should look for facts.  Multiple directories should
         be colon-separated, like normal PATH variables.",
 
       :call_on_define => true, # Call our hook with the default value, so we always get the value added to facter.
       :type => :setting, # Don't consider it a file, because it could be multiple colon-separated files
       :hook => proc { |value| Facter.search(value) if Facter.respond_to?(:search) }},
     :factdest => ["$vardir/facts/",
       "Where Puppet should store facts that it pulls down from the central
       server."],
     :factsource => ["puppet://$server/facts/",
       "From where to retrieve facts.  The standard Puppet `file` type
       is used for retrieval, so anything that is a valid file source can
       be used here."],
     :factsync => [false, "Whether facts should be synced with the central server."],
     :factsignore => [".svn CVS", "What files to ignore when pulling down facts."]
   )
 
 
     setdefaults(
     :tagmail,
     :tagmap => ["$confdir/tagmail.conf", "The mapping between reporting tags and email addresses."],
     :sendmail => [which('sendmail') || '', "Where to find the sendmail binary with which to send email."],
 
     :reportfrom => ["report@" + [Facter["hostname"].value, Facter["domain"].value].join("."), "The 'from' email address for the reports."],
     :smtpserver => ["none", "The server through which to send email reports."]
   )
 
     setdefaults(
     :rails,
     :dblocation => { :default => "$statedir/clientconfigs.sqlite3",
       :mode => 0660,
       :owner => "service",
       :group => "service",
       :desc => "The database cache for client configurations.  Used for
         querying within the language."
     },
     :dbadapter => [ "sqlite3", "The type of database to use." ],
     :dbmigrate => [ false, "Whether to automatically migrate the database." ],
     :dbname => [ "puppet", "The name of the database to use." ],
     :dbserver => [ "localhost", "The database server for caching. Only
       used when networked databases are used."],
     :dbport => [ "", "The database password for caching. Only
       used when networked databases are used."],
     :dbuser => [ "puppet", "The database user for caching. Only
       used when networked databases are used."],
     :dbpassword => [ "puppet", "The database password for caching. Only
       used when networked databases are used."],
     :dbconnections => [ '', "The number of database connections for networked
       databases.  Will be ignored unless the value is a positive integer."],
     :dbsocket => [ "", "The database socket location. Only used when networked
       databases are used.  Will be ignored if the value is an empty string."],
     :railslog => {:default => "$logdir/rails.log",
       :mode => 0600,
       :owner => "service",
       :group => "service",
       :desc => "Where Rails-specific logs are sent"
     },
 
     :rails_loglevel => ["info", "The log level for Rails connections.  The value must be
       a valid log level within Rails.  Production environments normally use `info`
       and other environments normally use `debug`."]
   )
 
     setdefaults(
     :couchdb,
 
     :couchdb_url => ["http://127.0.0.1:5984/puppet", "The url where the puppet couchdb database will be created"]
   )
 
     setdefaults(
     :transaction,
     :tags => ["", "Tags to use to find resources.  If this is set, then
       only resources tagged with the specified tags will be applied.
       Values must be comma-separated."],
     :evaltrace => [false, "Whether each resource should log when it is
       being evaluated.  This allows you to interactively see exactly
       what is being done."],
     :summarize => [false,
 
       "Whether to print a transaction summary."
     ]
   )
 
     setdefaults(
     :main,
     :external_nodes => ["none",
 
       "An external command that can produce node information.  The output
       must be a YAML dump of a hash, and that hash must have one or both of
       `classes` and `parameters`, where `classes` is an array and
       `parameters` is a hash.  For unknown nodes, the commands should
       exit with a non-zero exit code.
 
       This command makes it straightforward to store your node mapping
       information in other data sources like databases."])
 
         setdefaults(
         :ldap,
     :ldapnodes => [false,
       "Whether to search for node configurations in LDAP.  See
       http://projects.puppetlabs.com/projects/puppet/wiki/LDAP_Nodes for more information."],
     :ldapssl => [false,
       "Whether SSL should be used when searching for nodes.
       Defaults to false because SSL usually requires certificates
       to be set up on the client side."],
     :ldaptls => [false,
       "Whether TLS should be used when searching for nodes.
       Defaults to false because TLS usually requires certificates
       to be set up on the client side."],
     :ldapserver => ["ldap",
       "The LDAP server.  Only used if `ldapnodes` is enabled."],
     :ldapport => [389,
       "The LDAP port.  Only used if `ldapnodes` is enabled."],
 
     :ldapstring => ["(&(objectclass=puppetClient)(cn=%s))",
       "The search string used to find an LDAP node."],
     :ldapclassattrs => ["puppetclass",
       "The LDAP attributes to use to define Puppet classes.  Values
       should be comma-separated."],
     :ldapstackedattrs => ["puppetvar",
       "The LDAP attributes that should be stacked to arrays by adding
       the values in all hierarchy elements of the tree.  Values
       should be comma-separated."],
     :ldapattrs => ["all",
       "The LDAP attributes to include when querying LDAP for nodes.  All
       returned attributes are set as variables in the top-level scope.
       Multiple values should be comma-separated.  The value 'all' returns
       all attributes."],
     :ldapparentattr => ["parentnode",
       "The attribute to use to define the parent node."],
     :ldapuser => ["",
       "The user to use to connect to LDAP.  Must be specified as a
       full DN."],
     :ldappassword => ["", "The password to use to connect to LDAP."],
     :ldapbase => ["",
       "The search base for LDAP searches.  It's impossible to provide
       a meaningful default here, although the LDAP libraries might
       have one already set.  Generally, it should be the 'ou=Hosts'
       branch under your main directory."]
   )
 
   setdefaults(:master,
     :storeconfigs => {:default => false, :desc => "Whether to store each client's configuration.  This
       requires ActiveRecord from Ruby on Rails.",
       :call_on_define => true, # Call our hook with the default value, so we always get the libdir set.
       :hook => proc do |value|
         require 'puppet/node'
         require 'puppet/node/facts'
         if value
           require 'puppet/rails'
           raise "StoreConfigs not supported without ActiveRecord 2.1 or higher" unless Puppet.features.rails?
           Puppet::Resource::Catalog.cache_class = :active_record unless Puppet.settings[:async_storeconfigs]
           Puppet::Node::Facts.cache_class = :active_record
           Puppet::Node.cache_class = :active_record
         end
       end
     }
   )
 
   # This doesn't actually work right now.
 
     setdefaults(
     :parser,
 
     :lexical => [false, "Whether to use lexical scoping (vs. dynamic)."],
     :templatedir => ["$vardir/templates",
       "Where Puppet looks for template files.  Can be a list of colon-seperated
       directories."
     ]
   )
 end
diff --git a/lib/puppet/indirector/report/yaml.rb b/lib/puppet/indirector/report/yaml.rb
new file mode 100644
index 000000000..bf7bf4fe5
--- /dev/null
+++ b/lib/puppet/indirector/report/yaml.rb
@@ -0,0 +1,11 @@
+require 'puppet/transaction/report'
+require 'puppet/indirector/yaml'
+
+class Puppet::Transaction::Report::Yaml < Puppet::Indirector::Yaml
+  desc "Store last report as a flat file, serialized using YAML."
+
+  # Force report to be saved there
+  def path(name,ext='.yaml')
+    Puppet[:lastrunreport]
+  end
+end
diff --git a/lib/puppet/transaction/report.rb b/lib/puppet/transaction/report.rb
index 8e04759ad..16fee42ae 100644
--- a/lib/puppet/transaction/report.rb
+++ b/lib/puppet/transaction/report.rb
@@ -1,169 +1,187 @@
 require 'puppet'
 require 'puppet/indirector'
 
 # A class for reporting what happens on each client.  Reports consist of
 # two types of data:  Logs and Metrics.  Logs are the output that each
 # change produces, and Metrics are all of the numerical data involved
 # in the transaction.
 class Puppet::Transaction::Report
   extend Puppet::Indirector
 
   indirects :report, :terminus_class => :processor
 
   attr_accessor :configuration_version
   attr_reader :resource_statuses, :logs, :metrics, :host, :time, :kind, :status
 
   # This is necessary since Marshall doesn't know how to
   # dump hash with default proc (see below @records)
   def self.default_format
     :yaml
   end
 
   def <<(msg)
     @logs << msg
     self
   end
 
   def add_times(name, value)
     @external_times[name] = value
   end
 
   def add_metric(name, hash)
     metric = Puppet::Util::Metric.new(name)
 
     hash.each do |name, value|
       metric.newvalue(name, value)
     end
 
     @metrics[metric.name] = metric
     metric
   end
 
   def add_resource_status(status)
     @resource_statuses[status.resource] = status
   end
 
   def compute_status(resource_metrics, change_metric)
     if (resource_metrics["failed"] || 0) > 0
       'failed'
     elsif change_metric > 0
       'changed'
     else
       'unchanged'
     end
   end
 
   def finalize_report
     resource_metrics = add_metric(:resources, calculate_resource_metrics)
     add_metric(:time, calculate_time_metrics)
     change_metric = calculate_change_metric
     add_metric(:changes, {"total" => change_metric})
     add_metric(:events, calculate_event_metrics)
     @status = compute_status(resource_metrics, change_metric)
   end
 
   def initialize(kind, configuration_version=nil)
     @metrics = {}
     @logs = []
     @resource_statuses = {}
     @external_times ||= {}
     @host = Puppet[:certname]
     @time = Time.now
     @kind = kind
     @report_format = 2
     @puppet_version = Puppet.version
     @configuration_version = configuration_version
     @status = 'failed' # assume failed until the report is finalized
   end
 
   def name
     host
   end
 
-  # Provide a summary of this report.
+  # Provide a human readable textual summary of this report.
   def summary
+    report = raw_summary
+
     ret = ""
+    report.keys.sort { |a,b| a.to_s <=> b.to_s }.each do |key|
+      ret += "#{Puppet::Util::Metric.labelize(key)}:\n"
 
-    @metrics.sort { |a,b| a[1].label <=> b[1].label }.each do |name, metric|
-      ret += "#{metric.label}:\n"
-      metric.values.sort { |a,b|
+      report[key].keys.sort { |a,b|
         # sort by label
-        if a[0] == :total
+        if a == :total
           1
-        elsif b[0] == :total
+        elsif b == :total
           -1
         else
-          a[1] <=> b[1]
+          report[key][a].to_s <=> report[key][b].to_s
         end
-      }.each do |name, label, value|
+      }.each do |label|
+        value = report[key][label]
         next if value == 0
         value = "%0.2f" % value if value.is_a?(Float)
-        ret += "   %15s %s\n" % [label + ":", value]
+        ret += "   %15s %s\n" % [Puppet::Util::Metric.labelize(label) + ":", value]
       end
     end
     ret
   end
 
+  # Provide a raw hash summary of this report.
+  def raw_summary
+    report = {}
+
+    @metrics.each do |name, metric|
+      key = metric.name.to_s
+      report[key] = {}
+      metric.values.each do |name, label, value|
+        report[key][name.to_s] = value
+      end
+      report[key]["total"] = 0 unless key == "time" or report[key].include?("total")
+    end
+    (report["time"] ||= {})["last_run"] = Time.now.tv_sec
+    report
+  end
+
   # Based on the contents of this report's metrics, compute a single number
   # that represents the report. The resulting number is a bitmask where
   # individual bits represent the presence of different metrics.
   def exit_status
     status = 0
     status |= 2 if @metrics["changes"]["total"] > 0
     status |= 4 if @metrics["resources"]["failed"] > 0
     status
   end
 
   def to_yaml_properties
     (instance_variables - ["@external_times"]).sort
   end
 
   private
 
   def calculate_change_metric
     resource_statuses.map { |name, status| status.change_count || 0 }.inject(0) { |a,b| a+b }
   end
 
   def calculate_event_metrics
     metrics = Hash.new(0)
     metrics["total"] = 0
     resource_statuses.each do |name, status|
       metrics["total"] += status.events.length
       status.events.each do |event|
         metrics[event.status] += 1
       end
     end
 
     metrics
   end
 
   def calculate_resource_metrics
     metrics = Hash.new(0)
     metrics["total"] = resource_statuses.length
 
     resource_statuses.each do |name, status|
-
       Puppet::Resource::Status::STATES.each do |state|
         metrics[state.to_s] += 1 if status.send(state)
       end
     end
 
     metrics
   end
 
   def calculate_time_metrics
     metrics = Hash.new(0)
     resource_statuses.each do |name, status|
       type = Puppet::Resource.new(name).type
       metrics[type.to_s.downcase] += status.evaluation_time if status.evaluation_time
     end
 
     @external_times.each do |name, value|
       metrics[name.to_s.downcase] = value
     end
 
     metrics["total"] = metrics.values.inject(0) { |a,b| a+b }
 
     metrics
   end
 end
diff --git a/lib/puppet/util/metric.rb b/lib/puppet/util/metric.rb
index 09bbb6137..835e1d610 100644
--- a/lib/puppet/util/metric.rb
+++ b/lib/puppet/util/metric.rb
@@ -1,188 +1,186 @@
 # included so we can test object types
 require 'puppet'
 
 # A class for handling metrics.  This is currently ridiculously hackish.
 class Puppet::Util::Metric
 
   attr_accessor :type, :name, :value, :label
   attr_writer :values
 
   attr_writer :basedir
 
   # Return a specific value
   def [](name)
     if value = @values.find { |v| v[0] == name }
       return value[2]
     else
       return 0
     end
   end
 
   def basedir
     if defined?(@basedir)
       @basedir
     else
       Puppet[:rrddir]
     end
   end
 
   def create(start = nil)
     Puppet.settings.use(:main, :metrics)
 
     start ||= Time.now.to_i - 5
 
     args = []
 
     if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
       @rrd = RRDtool.new(self.path)
     end
 
     values.each { |value|
       # the 7200 is the heartbeat -- this means that any data that isn't
       # more frequently than every two hours gets thrown away
       args.push "DS:#{value[0]}:GAUGE:7200:U:U"
     }
     args.push "RRA:AVERAGE:0.5:1:300"
 
     begin
       if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
         @rrd.create( Puppet[:rrdinterval].to_i, start, args)
       else
         RRD.create( self.path, '-s', Puppet[:rrdinterval].to_i.to_s, '-b', start.to_i.to_s, *args)
       end
     rescue => detail
       raise "Could not create RRD file #{path}: #{detail}"
     end
   end
 
   def dump
     if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
       puts @rrd.info
     else
       puts RRD.info(self.path)
     end
   end
 
   def graph(range = nil)
     unless Puppet.features.rrd? || Puppet.features.rrd_legacy?
       Puppet.warning "RRD library is missing; cannot graph metrics"
       return
     end
 
     unit = 60 * 60 * 24
     colorstack = %w{#00ff00 #ff0000 #0000ff #ffff00 #ff99ff #ff9966 #66ffff #990000 #099000 #000990 #f00990 #0f0f0f #555555 #333333 #ffffff}
 
     {:daily => unit, :weekly => unit * 7, :monthly => unit * 30, :yearly => unit * 365}.each do |name, time|
       file = self.path.sub(/\.rrd$/, "-#{name}.png")
       args = [file]
 
       args.push("--title",self.label)
       args.push("--imgformat","PNG")
       args.push("--interlace")
       i = 0
       defs = []
       lines = []
       #p @values.collect { |s,l| s }
       values.zip(colorstack).each { |value,color|
         next if value.nil?
         # this actually uses the data label
         defs.push("DEF:#{value[0]}=#{self.path}:#{value[0]}:AVERAGE")
         lines.push("LINE2:#{value[0]}#{color}:#{value[1]}")
       }
       args << defs
       args << lines
       args.flatten!
       if range
         if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
           args.push("--start",range[0],"--end",range[1])
         else
           args.push("--start",range[0].to_i.to_s,"--end",range[1].to_i.to_s)
         end
       else
         if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
           args.push("--start", Time.now.to_i - time, "--end", Time.now.to_i)
         else
           args.push("--start", (Time.now.to_i - time).to_s, "--end", Time.now.to_i.to_s)
         end
       end
 
       begin
         #Puppet.warning "args = #{args}"
         if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
           RRDtool.graph( args )
         else
           RRD.graph( *args )
         end
       rescue => detail
         Puppet.err "Failed to graph #{self.name}: #{detail}"
       end
     end
   end
 
   def initialize(name,label = nil)
     @name = name.to_s
 
-    @label = label || labelize(name)
+    @label = label || self.class.labelize(name)
 
     @values = []
   end
 
   def path
     File.join(self.basedir, @name + ".rrd")
   end
 
   def newvalue(name,value,label = nil)
     raise ArgumentError.new("metric name #{name.inspect} is not a string") unless name.is_a? String
-    label ||= labelize(name)
+    label ||= self.class.labelize(name)
     @values.push [name,label,value]
   end
 
   def store(time)
     unless Puppet.features.rrd? || Puppet.features.rrd_legacy?
       Puppet.warning "RRD library is missing; cannot store metrics"
       return
     end
     self.create(time - 5) unless FileTest.exists?(self.path)
 
     if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
       @rrd ||= RRDtool.new(self.path)
     end
 
     # XXX this is not terribly error-resistant
     args = [time]
     temps = []
     values.each { |value|
       #Puppet.warning "value[0]: #{value[0]}; value[1]: #{value[1]}; value[2]: #{value[2]}; "
       args.push value[2]
       temps.push value[0]
     }
     arg = args.join(":")
     template = temps.join(":")
     begin
       if Puppet.features.rrd_legacy? && ! Puppet.features.rrd?
         @rrd.update( template, [ arg ] )
       else
         RRD.update( self.path, '-t', template, arg )
       end
       #system("rrdtool updatev #{self.path} '#{arg}'")
     rescue => detail
       raise Puppet::Error, "Failed to update #{self.name}: #{detail}"
     end
   end
 
   def values
     @values.sort { |a, b| a[1] <=> b[1] }
   end
 
-  private
-
   # Convert a name into a label.
-  def labelize(name)
+  def self.labelize(name)
     name.to_s.capitalize.gsub("_", " ")
   end
 end
 
 # This is necessary because we changed the class path in early 2007,
 # and reports directly yaml-dump these metrics, so both client and server
 # have to agree on the class name.
 Puppet::Metric = Puppet::Util::Metric
diff --git a/spec/integration/configurer_spec.rb b/spec/integration/configurer_spec.rb
index 9a8b66fe4..780c9bbd0 100755
--- a/spec/integration/configurer_spec.rb
+++ b/spec/integration/configurer_spec.rb
@@ -1,35 +1,68 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../spec_helper'
 
 require 'puppet/configurer'
 
 describe Puppet::Configurer do
+  include PuppetSpec::Files
+
   describe "when downloading plugins" do
     it "should use the :pluginsignore setting, split on whitespace, for ignoring remote files" do
       resource = Puppet::Type.type(:notify).new :name => "yay"
       Puppet::Type.type(:file).expects(:new).with { |args| args[:ignore] == Puppet[:pluginsignore].split(/\s+/) }.returns resource
 
       configurer = Puppet::Configurer.new
       configurer.stubs(:download_plugins?).returns true
       configurer.download_plugins
     end
   end
 
   describe "when running" do
-    it "should send a transaction report with valid data" do
-      catalog = Puppet::Resource::Catalog.new
-      catalog.add_resource(Puppet::Type.type(:notify).new(:title => "testing"))
+    before(:each) do
+      @catalog = Puppet::Resource::Catalog.new
+      @catalog.add_resource(Puppet::Type.type(:notify).new(:title => "testing"))
 
-      configurer = Puppet::Configurer.new
+      # Make sure we don't try to persist the local state after the transaction ran, 
+      # because it will fail during test (the state file is in an not existing directory)
+      # and we need the transaction to be successful to be able to produce a summary report
+      @catalog.host_config = false
+
+      @configurer = Puppet::Configurer.new
+    end
+
+    it "should send a transaction report with valid data" do
 
+      @configurer.stubs(:save_last_run_summary)
       Puppet::Transaction::Report.indirection.expects(:save).with do |x, report|
         report.time.class == Time and report.logs.length > 0
       end
 
       Puppet[:report] = true
 
-      configurer.run :catalog => catalog
+      @configurer.run :catalog => @catalog
+    end
+
+    it "should save a correct last run summary" do
+      report = Puppet::Transaction::Report.new("apply")
+      report.stubs(:save)
+
+      Puppet[:lastrunfile] = tmpfile("lastrunfile")
+      Puppet[:report] = true
+
+      @configurer.run :catalog => @catalog, :report => report
+
+      summary = nil
+      File.open(Puppet[:lastrunfile], "r") do |fd|
+        summary = YAML.load(fd.read)
+      end
+
+      summary.should be_a(Hash)
+      %w{time changes events resources}.each do |key|
+        summary.should be_key(key)
+      end
+      summary["time"].should be_key("notify")
+      summary["time"]["last_run"].should >= Time.now.tv_sec
     end
   end
 end
diff --git a/spec/unit/application/agent_spec.rb b/spec/unit/application/agent_spec.rb
index 8f498d4ba..c9d9a4509 100755
--- a/spec/unit/application/agent_spec.rb
+++ b/spec/unit/application/agent_spec.rb
@@ -1,585 +1,592 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/agent'
 require 'puppet/application/agent'
 require 'puppet/network/server'
 require 'puppet/network/handler'
 require 'puppet/daemon'
 
 describe Puppet::Application::Agent do
   before :each do
     @puppetd = Puppet::Application[:agent]
     @puppetd.stubs(:puts)
     @daemon = stub_everything 'daemon'
     Puppet::Daemon.stubs(:new).returns(@daemon)
     @agent = stub_everything 'agent'
     Puppet::Agent.stubs(:new).returns(@agent)
     @puppetd.preinit
     Puppet::Util::Log.stubs(:newdestination)
     Puppet::Util::Log.stubs(:level=)
 
     Puppet::Node.stubs(:terminus_class=)
     Puppet::Node.stubs(:cache_class=)
     Puppet::Node::Facts.stubs(:terminus_class=)
   end
 
   it "should operate in agent run_mode" do
     @puppetd.class.run_mode.name.should == :agent
   end
 
   it "should ask Puppet::Application to parse Puppet configuration file" do
     @puppetd.should_parse_config?.should be_true
   end
 
   it "should declare a main command" do
     @puppetd.should respond_to(:main)
   end
 
   it "should declare a onetime command" do
     @puppetd.should respond_to(:onetime)
   end
 
   it "should declare a fingerprint command" do
     @puppetd.should respond_to(:fingerprint)
   end
 
   it "should declare a preinit block" do
     @puppetd.should respond_to(:preinit)
   end
 
   describe "in preinit" do
     it "should catch INT" do
       Signal.expects(:trap).with { |arg,block| arg == :INT }
 
       @puppetd.preinit
     end
 
     it "should init client to true" do
       @puppetd.preinit
 
       @puppetd.options[:client].should be_true
     end
 
     it "should init fqdn to nil" do
       @puppetd.preinit
 
       @puppetd.options[:fqdn].should be_nil
     end
 
     it "should init serve to []" do
       @puppetd.preinit
 
       @puppetd.options[:serve].should == []
     end
 
     it "should use MD5 as default digest algorithm" do
       @puppetd.preinit
 
       @puppetd.options[:digest].should == :MD5
     end
 
     it "should not fingerprint by default" do
       @puppetd.preinit
 
       @puppetd.options[:fingerprint].should be_false
     end
   end
 
   describe "when handling options" do
     before do
       @puppetd.command_line.stubs(:args).returns([])
     end
 
     [:centrallogging, :disable, :enable, :debug, :fqdn, :test, :verbose, :digest].each do |option|
       it "should declare handle_#{option} method" do
         @puppetd.should respond_to("handle_#{option}".to_sym)
       end
 
       it "should store argument value when calling handle_#{option}" do
         @puppetd.options.expects(:[]=).with(option, 'arg')
         @puppetd.send("handle_#{option}".to_sym, 'arg')
       end
     end
 
     it "should set an existing handler on server" do
       Puppet::Network::Handler.stubs(:handler).with("handler").returns(true)
 
       @puppetd.handle_serve("handler")
       @puppetd.options[:serve].should == [ :handler ]
     end
 
     it "should set client to false with --no-client" do
       @puppetd.handle_no_client(nil)
       @puppetd.options[:client].should be_false
     end
 
     it "should set waitforcert to 0 with --onetime and if --waitforcert wasn't given" do
       Puppet[:onetime] = true
       Puppet::SSL::Host.any_instance.expects(:wait_for_cert).with(0)
       @puppetd.setup_host
     end
 
     it "should use supplied waitforcert when --onetime is specified" do
       Puppet[:onetime] = true
       @puppetd.handle_waitforcert(60)
       Puppet::SSL::Host.any_instance.expects(:wait_for_cert).with(60)
       @puppetd.setup_host
     end
 
     it "should use a default value for waitforcert when --onetime and --waitforcert are not specified" do
       Puppet::SSL::Host.any_instance.expects(:wait_for_cert).with(120)
       @puppetd.setup_host
     end
 
     it "should set the log destination with --logdest" do
       @puppetd.options.stubs(:[]=).with { |opt,val| opt == :setdest }
       Puppet::Log.expects(:newdestination).with("console")
 
       @puppetd.handle_logdest("console")
     end
 
     it "should put the setdest options to true" do
       @puppetd.options.expects(:[]=).with(:setdest,true)
 
       @puppetd.handle_logdest("console")
     end
 
     it "should parse the log destination from the command line" do
       @puppetd.command_line.stubs(:args).returns(%w{--logdest /my/file})
 
       Puppet::Util::Log.expects(:newdestination).with("/my/file")
 
       @puppetd.parse_options
     end
 
     it "should store the waitforcert options with --waitforcert" do
       @puppetd.options.expects(:[]=).with(:waitforcert,42)
 
       @puppetd.handle_waitforcert("42")
     end
 
     it "should set args[:Port] with --port" do
       @puppetd.handle_port("42")
       @puppetd.args[:Port].should == "42"
     end
 
   end
 
   describe "during setup" do
     before :each do
       @puppetd.options.stubs(:[])
       Puppet.stubs(:info)
       FileTest.stubs(:exists?).returns(true)
       Puppet.stubs(:[])
       Puppet.stubs(:[]=)
       Puppet.stubs(:[]).with(:libdir).returns("/dev/null/lib")
       Puppet.settings.stubs(:print_config?)
       Puppet.settings.stubs(:print_config)
       Puppet::SSL::Host.stubs(:ca_location=)
       Puppet::Transaction::Report.stubs(:terminus_class=)
+      Puppet::Transaction::Report.stubs(:cache_class=)
       Puppet::Resource::Catalog.stubs(:terminus_class=)
       Puppet::Resource::Catalog.stubs(:cache_class=)
       Puppet::Node::Facts.stubs(:terminus_class=)
       @host = stub_everything 'host'
       Puppet::SSL::Host.stubs(:new).returns(@host)
       Puppet.stubs(:settraps)
     end
 
     describe "with --test" do
       before :each do
         Puppet.settings.stubs(:handlearg)
         @puppetd.options.stubs(:[]=)
       end
 
       it "should call setup_test" do
         @puppetd.options.stubs(:[]).with(:test).returns(true)
         @puppetd.expects(:setup_test)
         @puppetd.setup
       end
 
       it "should set options[:verbose] to true" do
         @puppetd.options.expects(:[]=).with(:verbose,true)
         @puppetd.setup_test
       end
       it "should set options[:onetime] to true" do
         Puppet.expects(:[]=).with(:onetime,true)
         @puppetd.setup_test
       end
       it "should set options[:detailed_exitcodes] to true" do
         @puppetd.options.expects(:[]=).with(:detailed_exitcodes,true)
         @puppetd.setup_test
       end
     end
 
     it "should call setup_logs" do
       @puppetd.expects(:setup_logs)
       @puppetd.setup
     end
 
     describe "when setting up logs" do
       before :each do
         Puppet::Util::Log.stubs(:newdestination)
       end
 
       it "should set log level to debug if --debug was passed" do
         @puppetd.options.stubs(:[]).with(:debug).returns(true)
 
         Puppet::Util::Log.expects(:level=).with(:debug)
 
         @puppetd.setup_logs
       end
 
       it "should set log level to info if --verbose was passed" do
         @puppetd.options.stubs(:[]).with(:verbose).returns(true)
 
         Puppet::Util::Log.expects(:level=).with(:info)
 
         @puppetd.setup_logs
       end
 
       [:verbose, :debug].each do |level|
         it "should set console as the log destination with level #{level}" do
           @puppetd.options.stubs(:[]).with(level).returns(true)
 
           Puppet::Util::Log.expects(:newdestination).with(:console)
 
           @puppetd.setup_logs
         end
       end
 
       it "should set syslog as the log destination if no --logdest" do
         @puppetd.options.stubs(:[]).with(:setdest).returns(false)
 
         Puppet::Util::Log.expects(:newdestination).with(:syslog)
 
         @puppetd.setup_logs
       end
 
     end
 
     it "should print puppet config if asked to in Puppet config" do
       @puppetd.stubs(:exit)
       Puppet.settings.stubs(:print_configs?).returns(true)
 
       Puppet.settings.expects(:print_configs)
 
       @puppetd.setup
     end
 
     it "should exit after printing puppet config if asked to in Puppet config" do
       Puppet.settings.stubs(:print_configs?).returns(true)
 
       lambda { @puppetd.setup }.should raise_error(SystemExit)
     end
 
     it "should set a central log destination with --centrallogs" do
       @puppetd.options.stubs(:[]).with(:centrallogs).returns(true)
       Puppet.stubs(:[]).with(:server).returns("puppet.reductivelabs.com")
       Puppet::Util::Log.stubs(:newdestination).with(:syslog)
 
       Puppet::Util::Log.expects(:newdestination).with("puppet.reductivelabs.com")
 
       @puppetd.setup
     end
 
     it "should use :main, :puppetd, and :ssl" do
       Puppet.settings.expects(:use).with(:main, :agent, :ssl)
 
       @puppetd.setup
     end
 
     it "should install a remote ca location" do
       Puppet::SSL::Host.expects(:ca_location=).with(:remote)
 
       @puppetd.setup
     end
 
     it "should install a none ca location in fingerprint mode" do
       @puppetd.options.stubs(:[]).with(:fingerprint).returns(true)
       Puppet::SSL::Host.expects(:ca_location=).with(:none)
 
       @puppetd.setup
     end
 
     it "should tell the report handler to use REST" do
       Puppet::Transaction::Report.expects(:terminus_class=).with(:rest)
 
       @puppetd.setup
     end
 
+    it "should tell the report handler to cache locally as yaml" do
+      Puppet::Transaction::Report.expects(:cache_class=).with(:yaml)
+
+      @puppetd.setup
+    end
+
     it "should change the catalog_terminus setting to 'rest'" do
       Puppet.expects(:[]=).with(:catalog_terminus, :rest)
       @puppetd.setup
     end
 
     it "should tell the catalog handler to use cache" do
       Puppet::Resource::Catalog.expects(:cache_class=).with(:yaml)
 
       @puppetd.setup
     end
 
     it "should change the facts_terminus setting to 'facter'" do
       Puppet.expects(:[]=).with(:facts_terminus, :facter)
 
       @puppetd.setup
     end
 
     it "should create an agent" do
       Puppet::Agent.stubs(:new).with(Puppet::Configurer)
 
       @puppetd.setup
     end
 
     [:enable, :disable].each do |action|
       it "should delegate to enable_disable_client if we #{action} the agent" do
         @puppetd.options.stubs(:[]).with(action).returns(true)
         @puppetd.expects(:enable_disable_client).with(@agent)
 
         @puppetd.setup
       end
     end
 
     describe "when enabling or disabling agent" do
       [:enable, :disable].each do |action|
         it "should call client.#{action}" do
           @puppetd.stubs(:exit)
           @puppetd.options.stubs(:[]).with(action).returns(true)
 
           @agent.expects(action)
 
           @puppetd.enable_disable_client(@agent)
         end
       end
 
       it "should finally exit" do
         lambda { @puppetd.enable_disable_client(@agent) }.should raise_error(SystemExit)
       end
     end
 
     it "should inform the daemon about our agent if :client is set to 'true'" do
       @puppetd.options.expects(:[]).with(:client).returns true
       @daemon.expects(:agent=).with(@agent)
       @puppetd.setup
     end
 
     it "should not inform the daemon about our agent if :client is set to 'false'" do
       @puppetd.options[:client] = false
       @daemon.expects(:agent=).never
       @puppetd.setup
     end
 
     it "should daemonize if needed" do
       Puppet.stubs(:[]).with(:daemonize).returns(true)
 
       @daemon.expects(:daemonize)
 
       @puppetd.setup
     end
 
     it "should wait for a certificate" do
       @puppetd.options.stubs(:[]).with(:waitforcert).returns(123)
       @host.expects(:wait_for_cert).with(123)
 
       @puppetd.setup
     end
 
     it "should not wait for a certificate in fingerprint mode" do
       @puppetd.options.stubs(:[]).with(:fingerprint).returns(true)
       @puppetd.options.stubs(:[]).with(:waitforcert).returns(123)
       @host.expects(:wait_for_cert).never
 
       @puppetd.setup
     end
 
     it "should setup listen if told to and not onetime" do
       Puppet.stubs(:[]).with(:listen).returns(true)
       @puppetd.options.stubs(:[]).with(:onetime).returns(false)
 
       @puppetd.expects(:setup_listen)
 
       @puppetd.setup
     end
 
     describe "when setting up listen" do
       before :each do
         Puppet.stubs(:[]).with(:authconfig).returns('auth')
         FileTest.stubs(:exists?).with('auth').returns(true)
         File.stubs(:exist?).returns(true)
         @puppetd.options.stubs(:[]).with(:serve).returns([])
         @puppetd.stubs(:exit)
         @server = stub_everything 'server'
         Puppet::Network::Server.stubs(:new).returns(@server)
       end
 
 
       it "should exit if no authorization file" do
         Puppet.stubs(:err)
         FileTest.stubs(:exists?).with('auth').returns(false)
 
         @puppetd.expects(:exit)
 
         @puppetd.setup_listen
       end
 
       it "should create a server to listen on at least the Runner handler" do
         Puppet::Network::Server.expects(:new).with { |args| args[:xmlrpc_handlers] == [:Runner] }
 
         @puppetd.setup_listen
       end
 
       it "should create a server to listen for specific handlers" do
         @puppetd.options.stubs(:[]).with(:serve).returns([:handler])
         Puppet::Network::Server.expects(:new).with { |args| args[:xmlrpc_handlers] == [:handler] }
 
         @puppetd.setup_listen
       end
 
       it "should use puppet default port" do
         Puppet.stubs(:[]).with(:puppetport).returns(:port)
 
         Puppet::Network::Server.expects(:new).with { |args| args[:port] == :port }
 
         @puppetd.setup_listen
       end
     end
   end
 
 
   describe "when running" do
     before :each do
       @puppetd.agent = @agent
       @puppetd.daemon = @daemon
       @puppetd.options.stubs(:[]).with(:fingerprint).returns(false)
     end
 
     it "should dispatch to fingerprint if --fingerprint is used" do
       @puppetd.options.stubs(:[]).with(:fingerprint).returns(true)
 
       @puppetd.stubs(:fingerprint)
       @puppetd.run_command
     end
 
     it "should dispatch to onetime if --onetime is used" do
       @puppetd.options.stubs(:[]).with(:onetime).returns(true)
 
       @puppetd.stubs(:onetime)
       @puppetd.run_command
     end
 
     it "should dispatch to main if --onetime and --fingerprint are not used" do
       @puppetd.options.stubs(:[]).with(:onetime).returns(false)
 
       @puppetd.stubs(:main)
       @puppetd.run_command
     end
 
     describe "with --onetime" do
 
       before :each do
         @agent.stubs(:run).returns(:report)
         @puppetd.options.stubs(:[]).with(:client).returns(:client)
         @puppetd.options.stubs(:[]).with(:detailed_exitcodes).returns(false)
         @puppetd.stubs(:exit).with(0)
         Puppet.stubs(:newservice)
       end
 
       it "should exit if no defined --client" do
         $stderr.stubs(:puts)
         @puppetd.options.stubs(:[]).with(:client).returns(nil)
 
         @puppetd.expects(:exit).with(43)
 
         @puppetd.onetime
       end
 
       it "should setup traps" do
         @daemon.expects(:set_signal_traps)
 
         @puppetd.onetime
       end
 
       it "should let the agent run" do
         @agent.expects(:run).returns(:report)
 
         @puppetd.onetime
       end
 
       it "should finish by exiting with 0 error code" do
         @puppetd.expects(:exit).with(0)
 
         @puppetd.onetime
       end
 
       describe "and --detailed-exitcodes" do
         before :each do
           @puppetd.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
         end
 
         it "should exit with report's computed exit status" do
           Puppet.stubs(:[]).with(:noop).returns(false)
           report = stub 'report', :exit_status => 666
           @agent.stubs(:run).returns(report)
           @puppetd.expects(:exit).with(666)
 
           @puppetd.onetime
         end
 
         it "should exit with the report's computer exit status, even if --noop is set." do
           Puppet.stubs(:[]).with(:noop).returns(true)
           report = stub 'report', :exit_status => 666
           @agent.stubs(:run).returns(report)
           @puppetd.expects(:exit).with(666)
 
           @puppetd.onetime
         end
       end
     end
 
     describe "with --fingerprint" do
       before :each do
         @cert = stub_everything 'cert'
         @puppetd.options.stubs(:[]).with(:fingerprint).returns(true)
         @puppetd.options.stubs(:[]).with(:digest).returns(:MD5)
         @host = stub_everything 'host'
         @puppetd.stubs(:host).returns(@host)
       end
 
       it "should fingerprint the certificate if it exists" do
         @host.expects(:certificate).returns(@cert)
         @cert.expects(:fingerprint).with(:MD5).returns "fingerprint"
         @puppetd.fingerprint
       end
 
       it "should fingerprint the certificate request if no certificate have been signed" do
         @host.expects(:certificate).returns(nil)
         @host.expects(:certificate_request).returns(@cert)
         @cert.expects(:fingerprint).with(:MD5).returns "fingerprint"
         @puppetd.fingerprint
       end
 
       it "should display the fingerprint" do
         @host.stubs(:certificate).returns(@cert)
         @cert.stubs(:fingerprint).with(:MD5).returns("DIGEST")
 
         Puppet.expects(:notice).with("DIGEST")
 
         @puppetd.fingerprint
       end
     end
 
     describe "without --onetime and --fingerprint" do
       before :each do
         Puppet.stubs(:notice)
         @puppetd.options.stubs(:[]).with(:client)
       end
 
       it "should start our daemon" do
         @daemon.expects(:start)
 
         @puppetd.main
       end
     end
   end
 end
diff --git a/spec/unit/application/apply_spec.rb b/spec/unit/application/apply_spec.rb
index d4f39abe0..67edd4ed7 100755
--- a/spec/unit/application/apply_spec.rb
+++ b/spec/unit/application/apply_spec.rb
@@ -1,420 +1,426 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/application/apply'
 require 'puppet/file_bucket/dipper'
 require 'puppet/configurer'
 
 describe Puppet::Application::Apply do
   before :each do
     @apply = Puppet::Application[:apply]
     Puppet::Util::Log.stubs(:newdestination)
     Puppet::Util::Log.stubs(:level=)
   end
 
   [:debug,:loadclasses,:verbose,:use_nodes,:detailed_exitcodes].each do |option|
     it "should declare handle_#{option} method" do
       @apply.should respond_to("handle_#{option}".to_sym)
     end
 
     it "should store argument value when calling handle_#{option}" do
       @apply.options.expects(:[]=).with(option, 'arg')
       @apply.send("handle_#{option}".to_sym, 'arg')
     end
   end
 
   it "should set the code to the provided code when :execute is used" do
     @apply.options.expects(:[]=).with(:code, 'arg')
     @apply.send("handle_execute".to_sym, 'arg')
   end
 
   it "should ask Puppet::Application to parse Puppet configuration file" do
     @apply.should_parse_config?.should be_true
   end
 
   describe "when applying options" do
 
     it "should set the log destination with --logdest" do
       Puppet::Log.expects(:newdestination).with("console")
 
       @apply.handle_logdest("console")
     end
 
     it "should put the logset options to true" do
       @apply.options.expects(:[]=).with(:logset,true)
 
       @apply.handle_logdest("console")
     end
   end
 
   describe "during setup" do
 
     before :each do
       Puppet::Log.stubs(:newdestination)
       Puppet::Log.stubs(:level=)
       Puppet.stubs(:parse_config)
       Puppet::FileBucket::Dipper.stubs(:new)
       STDIN.stubs(:read)
+      Puppet::Transaction::Report.stubs(:cache_class=)
 
       @apply.options.stubs(:[]).with(any_parameters)
     end
 
     it "should set show_diff on --noop" do
       Puppet.stubs(:[]=)
       Puppet.stubs(:[]).with(:config)
       Puppet.stubs(:[]).with(:noop).returns(true)
 
       Puppet.expects(:[]=).with(:show_diff, true)
 
       @apply.setup
     end
 
     it "should set console as the log destination if logdest option wasn't provided" do
       Puppet::Log.expects(:newdestination).with(:console)
 
       @apply.setup
     end
 
     it "should set INT trap" do
       Signal.expects(:trap).with(:INT)
 
       @apply.setup
     end
 
     it "should set log level to debug if --debug was passed" do
       @apply.options.stubs(:[]).with(:debug).returns(true)
 
       Puppet::Log.expects(:level=).with(:debug)
 
       @apply.setup
     end
 
     it "should set log level to info if --verbose was passed" do
       @apply.options.stubs(:[]).with(:verbose).returns(true)
 
       Puppet::Log.expects(:level=).with(:info)
 
       @apply.setup
     end
 
     it "should print puppet config if asked to in Puppet config" do
       @apply.stubs(:exit)
       Puppet.settings.stubs(:print_configs?).returns(true)
 
       Puppet.settings.expects(:print_configs)
 
       @apply.setup
     end
 
     it "should exit after printing puppet config if asked to in Puppet config" do
       Puppet.settings.stubs(:print_configs?).returns(true)
 
       lambda { @apply.setup }.should raise_error(SystemExit)
     end
 
+    it "should tell the report handler to cache locally as yaml" do
+      Puppet::Transaction::Report.expects(:cache_class=).with(:yaml)
+
+      @apply.setup
+    end
   end
 
   describe "when executing" do
 
     it "should dispatch to parseonly if parseonly is set" do
       @apply.stubs(:options).returns({})
       Puppet.stubs(:[]).with(:parseonly).returns(true)
 
       @apply.expects(:parseonly)
       @apply.run_command
     end
 
     it "should dispatch to 'apply' if it was called with 'apply'" do
       @apply.options[:catalog] = "foo"
 
       @apply.expects(:apply)
       @apply.run_command
     end
 
     it "should dispatch to main if parseonly is not set" do
       @apply.stubs(:options).returns({})
       Puppet.stubs(:[]).with(:parseonly).returns(false)
 
       @apply.expects(:main)
       @apply.run_command
     end
 
     describe "the parseonly command" do
       before :each do
         Puppet.stubs(:[]).with(:environment)
         Puppet.stubs(:[]).with(:manifest).returns("site.pp")
         Puppet.stubs(:err)
         @apply.stubs(:exit)
         @apply.options.stubs(:[]).with(:code).returns "some code"
         @collection = stub_everything
         Puppet::Resource::TypeCollection.stubs(:new).returns(@collection)
       end
 
       it "should use a Puppet Resource Type Collection to parse the file" do
         @collection.expects(:perform_initial_import)
         @apply.parseonly
       end
 
       it "should exit with exit code 0 if no error" do
         @apply.expects(:exit).with(0)
         @apply.parseonly
       end
 
       it "should exit with exit code 1 if error" do
         @collection.stubs(:perform_initial_import).raises(Puppet::ParseError)
         @apply.expects(:exit).with(1)
         @apply.parseonly
       end
 
       it "should exit with exit code 1 if error, even if --noop is set" do
         Puppet[:noop] = true
         @collection.stubs(:perform_initial_import).raises(Puppet::ParseError)
         @apply.expects(:exit).with(1)
         @apply.parseonly
       end
     end
 
     describe "the main command" do
       before :each do
         Puppet.stubs(:[])
         Puppet.settings.stubs(:use)
         Puppet.stubs(:[]).with(:prerun_command).returns ""
         Puppet.stubs(:[]).with(:postrun_command).returns ""
         Puppet.stubs(:[]).with(:trace).returns(true)
 
         @apply.options.stubs(:[])
 
         @facts = stub_everything 'facts'
         Puppet::Node::Facts.stubs(:find).returns(@facts)
 
         @node = stub_everything 'node'
         Puppet::Node.stubs(:find).returns(@node)
 
         @catalog = stub_everything 'catalog'
         @catalog.stubs(:to_ral).returns(@catalog)
         Puppet::Resource::Catalog.stubs(:find).returns(@catalog)
 
         STDIN.stubs(:read)
 
         @transaction = stub_everything 'transaction'
         @catalog.stubs(:apply).returns(@transaction)
 
         @apply.stubs(:exit)
 
         Puppet::Util::Storage.stubs(:load)
         Puppet::Configurer.any_instance.stubs(:save_last_run_summary) # to prevent it from trying to write files
       end
 
       it "should set the code to run from --code" do
         @apply.options.stubs(:[]).with(:code).returns("code to run")
         Puppet.expects(:[]=).with(:code,"code to run")
 
         @apply.main
       end
 
       it "should set the code to run from STDIN if no arguments" do
         @apply.command_line.stubs(:args).returns([])
         STDIN.stubs(:read).returns("code to run")
 
         Puppet.expects(:[]=).with(:code,"code to run")
 
         @apply.main
       end
 
       it "should set the manifest if a file is passed on command line and the file exists" do
         File.stubs(:exist?).with('site.pp').returns true
         @apply.command_line.stubs(:args).returns(['site.pp'])
 
         Puppet.expects(:[]=).with(:manifest,"site.pp")
 
         @apply.main
       end
 
       it "should raise an error if a file is passed on command line and the file does not exist" do
         File.stubs(:exist?).with('noexist.pp').returns false
         @apply.command_line.stubs(:args).returns(['noexist.pp'])
         lambda { @apply.main }.should raise_error(RuntimeError, 'Could not find file noexist.pp')
       end
 
       it "should set the manifest to the first file and warn other files will be skipped" do
         File.stubs(:exist?).with('starwarsIV').returns true
         File.expects(:exist?).with('starwarsI').never
         @apply.command_line.stubs(:args).returns(['starwarsIV', 'starwarsI', 'starwarsII'])
 
         Puppet.expects(:[]=).with(:manifest,"starwarsIV")
         Puppet.expects(:warning).with('Only one file can be applied per run.  Skipping starwarsI, starwarsII')
 
         @apply.main
       end
 
       it "should collect the node facts" do
         Puppet::Node::Facts.expects(:find).returns(@facts)
 
         @apply.main
       end
 
       it "should raise an error if we can't find the node" do
         Puppet::Node::Facts.expects(:find).returns(nil)
 
         lambda { @apply.main }.should raise_error
       end
 
       it "should look for the node" do
         Puppet::Node.expects(:find).returns(@node)
 
         @apply.main
       end
 
       it "should raise an error if we can't find the node" do
         Puppet::Node.expects(:find).returns(nil)
 
         lambda { @apply.main }.should raise_error
       end
 
       it "should merge in our node the loaded facts" do
         @facts.stubs(:values).returns("values")
 
         @node.expects(:merge).with("values")
 
         @apply.main
       end
 
       it "should load custom classes if loadclasses" do
         @apply.options.stubs(:[]).with(:loadclasses).returns(true)
         Puppet.stubs(:[]).with(:classfile).returns("/etc/puppet/classes.txt")
         FileTest.stubs(:exists?).with("/etc/puppet/classes.txt").returns(true)
         FileTest.stubs(:readable?).with("/etc/puppet/classes.txt").returns(true)
         File.stubs(:read).with("/etc/puppet/classes.txt").returns("class")
 
         @node.expects(:classes=)
 
         @apply.main
       end
 
       it "should compile the catalog" do
         Puppet::Resource::Catalog.expects(:find).returns(@catalog)
 
         @apply.main
       end
 
       it "should transform the catalog to ral" do
 
         @catalog.expects(:to_ral).returns(@catalog)
 
         @apply.main
       end
 
       it "should finalize the catalog" do
         @catalog.expects(:finalize)
 
         @apply.main
       end
 
       it "should call the prerun and postrun commands on a Configurer instance" do
         Puppet::Configurer.any_instance.expects(:execute_prerun_command)
         Puppet::Configurer.any_instance.expects(:execute_postrun_command)
 
         @apply.main
       end
 
       it "should apply the catalog" do
         @catalog.expects(:apply).returns(stub_everything('transaction'))
 
         @apply.main
       end
 
       describe "with detailed_exitcodes" do
         it "should exit with report's computed exit status" do
           Puppet.stubs(:[]).with(:noop).returns(false)
           @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
           Puppet::Transaction::Report.any_instance.stubs(:exit_status).returns(666)
           @apply.expects(:exit).with(666)
 
           @apply.main
         end
 
         it "should exit with report's computed exit status, even if --noop is set" do
           Puppet.stubs(:[]).with(:noop).returns(true)
           @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
           Puppet::Transaction::Report.any_instance.stubs(:exit_status).returns(666)
           @apply.expects(:exit).with(666)
 
           @apply.main
         end
 
         it "should always exit with 0 if option is disabled" do
           Puppet.stubs(:[]).with(:noop).returns(false)
           @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(false)
           report = stub 'report', :exit_status => 666
           @transaction.stubs(:report).returns(report)
           @apply.expects(:exit).with(0)
 
           @apply.main
         end
 
         it "should always exit with 0 if --noop" do
           Puppet.stubs(:[]).with(:noop).returns(true)
           @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
           report = stub 'report', :exit_status => 666
           @transaction.stubs(:report).returns(report)
           @apply.expects(:exit).with(0)
 
           @apply.main
         end
       end
     end
 
     describe "the 'apply' command" do
       it "should read the catalog in from disk if a file name is provided" do
         @apply.options[:catalog] = "/my/catalog.pson"
         File.expects(:read).with("/my/catalog.pson").returns "something"
         Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,'something').returns Puppet::Resource::Catalog.new
         @apply.apply
       end
 
       it "should read the catalog in from stdin if '-' is provided" do
         @apply.options[:catalog] = "-"
         $stdin.expects(:read).returns "something"
         Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,'something').returns Puppet::Resource::Catalog.new
         @apply.apply
       end
 
       it "should deserialize the catalog from the default format" do
         @apply.options[:catalog] = "/my/catalog.pson"
         File.stubs(:read).with("/my/catalog.pson").returns "something"
         Puppet::Resource::Catalog.stubs(:default_format).returns :rot13_piglatin
         Puppet::Resource::Catalog.stubs(:convert_from).with(:rot13_piglatin,'something').returns Puppet::Resource::Catalog.new
         @apply.apply
       end
 
       it "should fail helpfully if deserializing fails" do
         @apply.options[:catalog] = "/my/catalog.pson"
         File.stubs(:read).with("/my/catalog.pson").returns "something syntacically invalid"
         lambda { @apply.apply }.should raise_error(Puppet::Error)
       end
 
       it "should convert plain data structures into a catalog if deserialization does not do so" do
         @apply.options[:catalog] = "/my/catalog.pson"
         File.stubs(:read).with("/my/catalog.pson").returns "something"
         Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,"something").returns({:foo => "bar"})
         Puppet::Resource::Catalog.expects(:pson_create).with({:foo => "bar"}).returns(Puppet::Resource::Catalog.new)
         @apply.apply
       end
 
       it "should convert the catalog to a RAL catalog and use a Configurer instance to apply it" do
         @apply.options[:catalog] = "/my/catalog.pson"
         File.stubs(:read).with("/my/catalog.pson").returns "something"
         catalog = Puppet::Resource::Catalog.new
         Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,'something').returns catalog
         catalog.expects(:to_ral).returns "mycatalog"
 
         configurer = stub 'configurer'
         Puppet::Configurer.expects(:new).returns configurer
         configurer.expects(:run).with(:catalog => "mycatalog")
 
         @apply.apply
       end
     end
   end
 end
diff --git a/spec/unit/configurer_spec.rb b/spec/unit/configurer_spec.rb
index cf73a3706..a4b627c08 100755
--- a/spec/unit/configurer_spec.rb
+++ b/spec/unit/configurer_spec.rb
@@ -1,478 +1,526 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke Kanies on 2007-11-12.
 #  Copyright (c) 2007. All rights reserved.
 
 require File.dirname(__FILE__) + '/../spec_helper'
 require 'puppet/configurer'
 
 describe Puppet::Configurer do
   before do
     Puppet.settings.stubs(:use).returns(true)
     @agent = Puppet::Configurer.new
   end
 
   it "should include the Plugin Handler module" do
     Puppet::Configurer.ancestors.should be_include(Puppet::Configurer::PluginHandler)
   end
 
   it "should include the Fact Handler module" do
     Puppet::Configurer.ancestors.should be_include(Puppet::Configurer::FactHandler)
   end
 
   it "should use the puppetdlockfile as its lockfile path" do
     Puppet.settings.expects(:value).with(:puppetdlockfile).returns("/my/lock")
     Puppet::Configurer.lockfile_path.should == "/my/lock"
   end
 
   describe "when executing a pre-run hook" do
     it "should do nothing if the hook is set to an empty string" do
       Puppet.settings[:prerun_command] = ""
       Puppet::Util.expects(:exec).never
 
       @agent.execute_prerun_command
     end
 
     it "should execute any pre-run command provided via the 'prerun_command' setting" do
       Puppet.settings[:prerun_command] = "/my/command"
       Puppet::Util.expects(:execute).with { |args| args[0] == "/my/command" }
 
       @agent.execute_prerun_command
     end
 
     it "should fail if the command fails" do
       Puppet.settings[:prerun_command] = "/my/command"
       Puppet::Util.expects(:execute).raises Puppet::ExecutionFailure
 
       lambda { @agent.execute_prerun_command }.should raise_error(Puppet::Configurer::CommandHookError)
     end
   end
 
   describe "when executing a post-run hook" do
     it "should do nothing if the hook is set to an empty string" do
       Puppet.settings[:postrun_command] = ""
       Puppet::Util.expects(:exec).never
 
       @agent.execute_postrun_command
     end
 
     it "should execute any post-run command provided via the 'postrun_command' setting" do
       Puppet.settings[:postrun_command] = "/my/command"
       Puppet::Util.expects(:execute).with { |args| args[0] == "/my/command" }
 
       @agent.execute_postrun_command
     end
 
     it "should fail if the command fails" do
       Puppet.settings[:postrun_command] = "/my/command"
       Puppet::Util.expects(:execute).raises Puppet::ExecutionFailure
 
       lambda { @agent.execute_postrun_command }.should raise_error(Puppet::Configurer::CommandHookError)
     end
   end
 end
 
 describe Puppet::Configurer, "when executing a catalog run" do
   before do
     Puppet.settings.stubs(:use).returns(true)
     @agent = Puppet::Configurer.new
     @agent.stubs(:prepare)
     @agent.stubs(:facts_for_uploading).returns({})
     @catalog = Puppet::Resource::Catalog.new
     @catalog.stubs(:apply)
     @agent.stubs(:retrieve_catalog).returns @catalog
+    @agent.stubs(:save_last_run_summary)
 
     Puppet::Util::Log.stubs(:newdestination)
     Puppet::Util::Log.stubs(:close)
   end
 
   it "should prepare for the run" do
     @agent.expects(:prepare)
 
     @agent.run
   end
 
   it "should initialize a transaction report if one is not provided" do
     report = Puppet::Transaction::Report.new("apply")
     Puppet::Transaction::Report.expects(:new).returns report
 
     @agent.run
   end
 
   it "should pass the new report to the catalog" do
     report = Puppet::Transaction::Report.new("apply")
     Puppet::Transaction::Report.stubs(:new).returns report
     @catalog.expects(:apply).with{|options| options[:report] == report}
 
     @agent.run
   end
 
   it "should use the provided report if it was passed one" do
     report = Puppet::Transaction::Report.new("apply")
     Puppet::Transaction::Report.expects(:new).never
     @catalog.expects(:apply).with{|options| options[:report] == report}
 
     @agent.run(:report => report)
   end
 
   it "should set the report as a log destination" do
     report = Puppet::Transaction::Report.new("apply")
     Puppet::Transaction::Report.expects(:new).returns report
 
     Puppet::Util::Log.expects(:newdestination).with(report)
 
     @agent.run
   end
 
   it "should retrieve the catalog" do
     @agent.expects(:retrieve_catalog)
 
     @agent.run
   end
 
   it "should log a failure and do nothing if no catalog can be retrieved" do
     @agent.expects(:retrieve_catalog).returns nil
 
     Puppet.expects(:err).with "Could not retrieve catalog; skipping run"
 
     @agent.run
   end
 
   it "should apply the catalog with all options to :run" do
     @agent.expects(:retrieve_catalog).returns @catalog
 
     @catalog.expects(:apply).with { |args| args[:one] == true }
     @agent.run :one => true
   end
 
   it "should accept a catalog and use it instead of retrieving a different one" do
     @agent.expects(:retrieve_catalog).never
 
     @catalog.expects(:apply)
     @agent.run :one => true, :catalog => @catalog
   end
 
   it "should benchmark how long it takes to apply the catalog" do
     @agent.expects(:benchmark).with(:notice, "Finished catalog run")
 
     @agent.expects(:retrieve_catalog).returns @catalog
 
     @catalog.expects(:apply).never # because we're not yielding
     @agent.run
   end
 
   it "should execute post-run hooks after the run" do
     @agent.expects(:execute_postrun_command)
 
     @agent.run
   end
 
   it "should send the report" do
     report = Puppet::Transaction::Report.new("apply")
     Puppet::Transaction::Report.expects(:new).returns(report)
     @agent.expects(:send_report).with { |r, trans| r == report }
 
     @agent.run
   end
 
   it "should send the transaction report with a reference to the transaction if a run was actually made" do
     report = Puppet::Transaction::Report.new("apply")
     Puppet::Transaction::Report.expects(:new).returns(report)
 
     trans = stub 'transaction'
     @catalog.expects(:apply).returns trans
 
     @agent.expects(:send_report).with { |r, t| t == trans }
 
     @agent.run :catalog => @catalog
   end
 
   it "should send the transaction report even if the catalog could not be retrieved" do
     @agent.expects(:retrieve_catalog).returns nil
 
     report = Puppet::Transaction::Report.new("apply")
     Puppet::Transaction::Report.expects(:new).returns(report)
     @agent.expects(:send_report)
 
     @agent.run
   end
 
   it "should send the transaction report even if there is a failure" do
     @agent.expects(:retrieve_catalog).raises "whatever"
 
     report = Puppet::Transaction::Report.new("apply")
     Puppet::Transaction::Report.expects(:new).returns(report)
     @agent.expects(:send_report)
 
     lambda { @agent.run }.should raise_error
   end
 
   it "should remove the report as a log destination when the run is finished" do
     report = Puppet::Transaction::Report.new("apply")
     Puppet::Transaction::Report.expects(:new).returns(report)
 
     Puppet::Util::Log.expects(:close).with(report)
 
     @agent.run
   end
 
   it "should return the report as the result of the run" do
     report = Puppet::Transaction::Report.new("apply")
     Puppet::Transaction::Report.expects(:new).returns(report)
 
     @agent.run.should equal(report)
   end
 end
 
 describe Puppet::Configurer, "when sending a report" do
+  include PuppetSpec::Files
+
   before do
     Puppet.settings.stubs(:use).returns(true)
     @configurer = Puppet::Configurer.new
+    Puppet[:lastrunfile] = tmpfile('last_run_file')
 
     @report = Puppet::Transaction::Report.new("apply")
     @trans = stub 'transaction'
   end
 
   it "should finalize the report" do
     @report.expects(:finalize_report)
     @configurer.send_report(@report, @trans)
   end
 
   it "should print a report summary if configured to do so" do
     Puppet.settings[:summarize] = true
 
     @report.expects(:summary).returns "stuff"
 
     @configurer.expects(:puts).with("stuff")
     @configurer.send_report(@report, nil)
   end
 
   it "should not print a report summary if not configured to do so" do
     Puppet.settings[:summarize] = false
 
     @configurer.expects(:puts).never
     @configurer.send_report(@report, nil)
   end
 
   it "should save the report if reporting is enabled" do
     Puppet.settings[:report] = true
 
     @report.expects(:save)
     @configurer.send_report(@report, nil)
   end
 
   it "should not save the report if reporting is disabled" do
     Puppet.settings[:report] = false
 
     @report.expects(:save).never
     @configurer.send_report(@report, nil)
   end
 
+  it "should save the last run summary if reporting is enabled" do
+    Puppet.settings[:report] = true
+
+    @configurer.expects(:save_last_run_summary).with(@report)
+    @configurer.send_report(@report, nil)
+  end
+
+  it "should save the last run summary if reporting is disabled" do
+    Puppet.settings[:report] = false
+
+    @configurer.expects(:save_last_run_summary).with(@report)
+    @configurer.send_report(@report, nil)
+  end
+
   it "should log but not fail if saving the report fails" do
     Puppet.settings[:report] = true
 
     @report.expects(:save).raises "whatever"
 
     Puppet.expects(:err)
     lambda { @configurer.send_report(@report, nil) }.should_not raise_error
   end
 end
 
+describe Puppet::Configurer, "when saving the summary report file" do
+  before do
+    Puppet.settings.stubs(:use).returns(true)
+    @configurer = Puppet::Configurer.new
+
+    @report = stub 'report'
+    @trans = stub 'transaction'
+    @lastrunfd = stub 'lastrunfd'
+    Puppet::Util::FileLocking.stubs(:writelock).yields(@lastrunfd)
+  end
+
+  it "should write the raw summary to the lastrunfile setting value" do
+    Puppet::Util::FileLocking.expects(:writelock).with(Puppet[:lastrunfile], 0660)
+    @configurer.save_last_run_summary(@report)
+  end
+
+  it "should write the raw summary as yaml" do
+    @report.expects(:raw_summary).returns("summary")
+    @lastrunfd.expects(:print).with(YAML.dump("summary"))
+    @configurer.save_last_run_summary(@report)
+  end
+
+  it "should log but not fail if saving the last run summary fails" do
+    Puppet::Util::FileLocking.expects(:writelock).raises "exception"
+    Puppet.expects(:err)
+    lambda { @configurer.save_last_run_summary(@report) }.should_not raise_error
+  end
+
+end
+
 describe Puppet::Configurer, "when retrieving a catalog" do
   before do
     Puppet.settings.stubs(:use).returns(true)
     @agent = Puppet::Configurer.new
     @agent.stubs(:facts_for_uploading).returns({})
 
     @catalog = Puppet::Resource::Catalog.new
 
     # this is the default when using a Configurer instance
     Puppet::Resource::Catalog.indirection.stubs(:terminus_class).returns :rest
 
     @agent.stubs(:convert_catalog).returns @catalog
   end
 
   describe "and configured to only retrieve a catalog from the cache" do
     before do
       Puppet.settings[:use_cached_catalog] = true
     end
 
     it "should first look in the cache for a catalog" do
       Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
       Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.never
 
       @agent.retrieve_catalog.should == @catalog
     end
 
     it "should compile a new catalog if none is found in the cache" do
       Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
       Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
 
       @agent.retrieve_catalog.should == @catalog
     end
   end
 
   describe "when not using a REST terminus for catalogs" do
     it "should not pass any facts when retrieving the catalog" do
       @agent.expects(:facts_for_uploading).never
       Puppet::Resource::Catalog.expects(:find).with { |name, options|
         options[:facts].nil?
       }.returns @catalog
 
       @agent.retrieve_catalog
     end
   end
 
   describe "when using a REST terminus for catalogs" do
     it "should pass the prepared facts and the facts format as arguments when retrieving the catalog" do
       @agent.expects(:facts_for_uploading).returns(:facts => "myfacts", :facts_format => :foo)
       Puppet::Resource::Catalog.expects(:find).with { |name, options|
         options[:facts] == "myfacts" and options[:facts_format] == :foo
       }.returns @catalog
 
       @agent.retrieve_catalog
     end
   end
 
   it "should use the Catalog class to get its catalog" do
     Puppet::Resource::Catalog.expects(:find).returns @catalog
 
     @agent.retrieve_catalog
   end
 
   it "should use its certname to retrieve the catalog" do
     Facter.stubs(:value).returns "eh"
     Puppet.settings[:certname] = "myhost.domain.com"
     Puppet::Resource::Catalog.expects(:find).with { |name, options| name == "myhost.domain.com" }.returns @catalog
 
     @agent.retrieve_catalog
   end
 
   it "should default to returning a catalog retrieved directly from the server, skipping the cache" do
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
 
     @agent.retrieve_catalog.should == @catalog
   end
 
   it "should log and return the cached catalog when no catalog can be retrieved from the server" do
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
 
     Puppet.expects(:notice)
 
     @agent.retrieve_catalog.should == @catalog
   end
 
   it "should not look in the cache for a catalog if one is returned from the server" do
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_terminus] == true }.never
 
     @agent.retrieve_catalog.should == @catalog
   end
 
   it "should return the cached catalog when retrieving the remote catalog throws an exception" do
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.raises "eh"
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
 
     @agent.retrieve_catalog.should == @catalog
   end
 
   it "should log and return nil if no catalog can be retrieved from the server and :usecacheonfailure is disabled" do
     Puppet.stubs(:[])
     Puppet.expects(:[]).with(:usecacheonfailure).returns false
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
 
     Puppet.expects(:warning)
 
     @agent.retrieve_catalog.should be_nil
   end
 
   it "should return nil if no cached catalog is available and no catalog can be retrieved from the server" do
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
 
     @agent.retrieve_catalog.should be_nil
   end
 
   it "should convert the catalog before returning" do
     Puppet::Resource::Catalog.stubs(:find).returns @catalog
 
     @agent.expects(:convert_catalog).with { |cat, dur| cat == @catalog }.returns "converted catalog"
     @agent.retrieve_catalog.should == "converted catalog"
   end
 
   it "should return nil if there is an error while retrieving the catalog" do
     Puppet::Resource::Catalog.expects(:find).at_least_once.raises "eh"
 
     @agent.retrieve_catalog.should be_nil
   end
 end
 
 describe Puppet::Configurer, "when converting the catalog" do
   before do
     Puppet.settings.stubs(:use).returns(true)
     @agent = Puppet::Configurer.new
 
     @catalog = Puppet::Resource::Catalog.new
     @oldcatalog = stub 'old_catalog', :to_ral => @catalog
   end
 
   it "should convert the catalog to a RAL-formed catalog" do
     @oldcatalog.expects(:to_ral).returns @catalog
 
     @agent.convert_catalog(@oldcatalog, 10).should equal(@catalog)
   end
 
   it "should finalize the catalog" do
     @catalog.expects(:finalize)
 
     @agent.convert_catalog(@oldcatalog, 10)
   end
 
   it "should record the passed retrieval time with the RAL catalog" do
     @catalog.expects(:retrieval_duration=).with 10
 
     @agent.convert_catalog(@oldcatalog, 10)
   end
 
   it "should write the RAL catalog's class file" do
     @catalog.expects(:write_class_file)
 
     @agent.convert_catalog(@oldcatalog, 10)
   end
 end
 
 describe Puppet::Configurer, "when preparing for a run" do
   before do
     Puppet.settings.stubs(:use).returns(true)
     @agent = Puppet::Configurer.new
     @agent.stubs(:dostorage)
     @agent.stubs(:download_fact_plugins)
     @agent.stubs(:download_plugins)
     @agent.stubs(:execute_prerun_command)
     @facts = {"one" => "two", "three" => "four"}
   end
 
   it "should initialize the metadata store" do
     @agent.class.stubs(:facts).returns(@facts)
     @agent.expects(:dostorage)
     @agent.prepare({})
   end
 
   it "should download fact plugins" do
     @agent.expects(:download_fact_plugins)
 
     @agent.prepare({})
   end
 
   it "should download plugins" do
     @agent.expects(:download_plugins)
 
     @agent.prepare({})
   end
 
   it "should perform the pre-run commands" do
     @agent.expects(:execute_prerun_command)
     @agent.prepare({})
   end
 end
diff --git a/spec/unit/indirector/report/yaml_spec.rb b/spec/unit/indirector/report/yaml_spec.rb
new file mode 100644
index 000000000..610c9ae43
--- /dev/null
+++ b/spec/unit/indirector/report/yaml_spec.rb
@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/transaction/report'
+require 'puppet/indirector/report/yaml'
+
+describe Puppet::Transaction::Report::Yaml do
+  it "should be a subclass of the Yaml terminus" do
+    Puppet::Transaction::Report::Yaml.superclass.should equal(Puppet::Indirector::Yaml)
+  end
+
+  it "should have documentation" do
+    Puppet::Transaction::Report::Yaml.doc.should_not be_nil
+  end
+
+  it "should be registered with the report indirection" do
+    indirection = Puppet::Indirector::Indirection.instance(:report)
+    Puppet::Transaction::Report::Yaml.indirection.should equal(indirection)
+  end
+
+  it "should have its name set to :yaml" do
+    Puppet::Transaction::Report::Yaml.name.should == :yaml
+  end
+
+  it "should inconditionnally save/load from the --lastrunreport setting" do
+    indirection = stub 'indirection', :name => :my_yaml, :register_terminus_type => nil
+    Puppet::Indirector::Indirection.stubs(:instance).with(:my_yaml).returns(indirection)
+    store_class = Class.new(Puppet::Transaction::Report::Yaml) do
+      def self.to_s
+        "MyYaml::MyType"
+      end
+    end
+    store = store_class.new
+
+    store.path(:me).should == Puppet[:lastrunreport]
+  end
+end
diff --git a/spec/unit/transaction/report_spec.rb b/spec/unit/transaction/report_spec.rb
index 766d4f14d..81efa340e 100755
--- a/spec/unit/transaction/report_spec.rb
+++ b/spec/unit/transaction/report_spec.rb
@@ -1,290 +1,301 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/transaction/report'
 
 describe Puppet::Transaction::Report do
   before do
     Puppet::Util::Storage.stubs(:store)
   end
 
   it "should set its host name to the certname" do
     Puppet.settings.expects(:value).with(:certname).returns "myhost"
     Puppet::Transaction::Report.new("apply").host.should == "myhost"
   end
 
   it "should return its host name as its name" do
     r = Puppet::Transaction::Report.new("apply")
     r.name.should == r.host
   end
 
   it "should create an initialization timestamp" do
     Time.expects(:now).returns "mytime"
     Puppet::Transaction::Report.new("apply").time.should == "mytime"
   end
 
   it "should take a 'kind' as an argument" do
     Puppet::Transaction::Report.new("inspect").kind.should == "inspect"
   end
 
   it "should take a 'configuration_version' as an argument" do
     Puppet::Transaction::Report.new("inspect", "some configuration version").configuration_version.should == "some configuration version"
   end
 
   it "should be able to set configuration_version" do
     report = Puppet::Transaction::Report.new("inspect")
     report.configuration_version = "some version"
     report.configuration_version.should == "some version"
   end
 
   describe "when accepting logs" do
     before do
       @report = Puppet::Transaction::Report.new("apply")
     end
 
     it "should add new logs to the log list" do
       @report << "log"
       @report.logs[-1].should == "log"
     end
 
     it "should return self" do
       r = @report << "log"
       r.should equal(@report)
     end
   end
 
   describe "when accepting resource statuses" do
     before do
       @report = Puppet::Transaction::Report.new("apply")
     end
 
     it "should add each status to its status list" do
       status = stub 'status', :resource => "foo"
       @report.add_resource_status status
       @report.resource_statuses["foo"].should equal(status)
     end
   end
 
   describe "when using the indirector" do
     it "should redirect :find to the indirection" do
       @indirection = stub 'indirection', :name => :report
       Puppet::Transaction::Report.stubs(:indirection).returns(@indirection)
       @indirection.expects(:find)
       Puppet::Transaction::Report.find(:report)
     end
 
     it "should redirect :save to the indirection" do
       Facter.stubs(:value).returns("eh")
       @indirection = stub 'indirection', :name => :report
       Puppet::Transaction::Report.stubs(:indirection).returns(@indirection)
       report = Puppet::Transaction::Report.new("apply")
       @indirection.expects(:save)
       report.save
     end
 
     it "should default to the 'processor' terminus" do
       Puppet::Transaction::Report.indirection.terminus_class.should == :processor
     end
 
     it "should delegate its name attribute to its host method" do
       report = Puppet::Transaction::Report.new("apply")
       report.expects(:host).returns "me"
       report.name.should == "me"
     end
 
     after do
       Puppet::Util::Cacher.expire
     end
   end
 
   describe "when computing exit status" do
     it "should produce 2 if changes are present" do
       report = Puppet::Transaction::Report.new("apply")
       report.add_metric("changes", {"total" => 1})
       report.add_metric("resources", {"failed" => 0})
       report.exit_status.should == 2
     end
 
     it "should produce 4 if failures are present" do
       report = Puppet::Transaction::Report.new("apply")
       report.add_metric("changes", {"total" => 0})
       report.add_metric("resources", {"failed" => 1})
       report.exit_status.should == 4
     end
 
     it "should produce 6 if both changes and failures are present" do
       report = Puppet::Transaction::Report.new("apply")
       report.add_metric("changes", {"total" => 1})
       report.add_metric("resources", {"failed" => 1})
       report.exit_status.should == 6
     end
   end
 
   describe "before finalizing the report" do
     it "should have a status of 'failed'" do
       report = Puppet::Transaction::Report.new("apply")
       report.status.should == 'failed'
     end
   end
 
   describe "when finalizing the report" do
     before do
       @report = Puppet::Transaction::Report.new("apply")
     end
 
     def metric(name, value)
       if metric = @report.metrics[name.to_s]
         metric[value]
       else
         nil
       end
     end
 
     def add_statuses(count, type = :file)
       count.times do |i|
         status = Puppet::Resource::Status.new(Puppet::Type.type(type).new(:title => "/my/path#{i}"))
         yield status if block_given?
         @report.add_resource_status status
       end
     end
 
 
     [:time, :resources, :changes, :events].each do |type|
       it "should add #{type} metrics" do
         @report.finalize_report
         @report.metrics[type.to_s].should be_instance_of(Puppet::Transaction::Metric)
       end
     end
 
     describe "for resources" do
       it "should provide the total number of resources" do
         add_statuses(3)
 
         @report.finalize_report
         metric(:resources, "total").should == 3
       end
 
       Puppet::Resource::Status::STATES.each do |state|
         it "should provide the number of #{state} resources as determined by the status objects" do
           add_statuses(3) { |status| status.send(state.to_s + "=", true) }
 
           @report.finalize_report
           metric(:resources, state.to_s).should == 3
         end
       end
 
       it "should mark the report as 'failed' if there are failing resources" do
         add_statuses(1) { |status| status.failed = true }
         @report.finalize_report
         @report.status.should == 'failed'
       end
     end
 
     describe "for changes" do
       it "should provide the number of changes from the resource statuses and mark the report as 'changed'" do
         add_statuses(3) { |status| 3.times { status << Puppet::Transaction::Event.new(:status => 'success') } }
         @report.finalize_report
         metric(:changes, "total").should == 9
         @report.status.should == 'changed'
       end
 
       it "should provide a total even if there are no changes, and mark the report as 'unchanged'" do
         @report.finalize_report
         metric(:changes, "total").should == 0
         @report.status.should == 'unchanged'
       end
     end
 
     describe "for times" do
       it "should provide the total amount of time for each resource type" do
         add_statuses(3, :file) do |status|
           status.evaluation_time = 1
         end
         add_statuses(3, :exec) do |status|
           status.evaluation_time = 2
         end
         add_statuses(3, :mount) do |status|
           status.evaluation_time = 3
         end
 
         @report.finalize_report
 
         metric(:time, "file").should == 3
         metric(:time, "exec").should == 6
         metric(:time, "mount").should == 9
       end
 
       it "should add any provided times from external sources" do
         @report.add_times :foobar, 50
         @report.finalize_report
         metric(:time, "foobar").should == 50
       end
 
       it "should have a total time" do
         add_statuses(3, :file) do |status|
           status.evaluation_time = 1.25
         end
         @report.add_times :config_retrieval, 0.5
         @report.finalize_report
         metric(:time, "total").should == 4.25
       end
     end
 
     describe "for events" do
       it "should provide the total number of events" do
         add_statuses(3) do |status|
           3.times { |i| status.add_event(Puppet::Transaction::Event.new :status => 'success') }
         end
         @report.finalize_report
         metric(:events, "total").should == 9
       end
 
       it "should provide the total even if there are no events" do
         @report.finalize_report
         metric(:events, "total").should == 0
       end
 
       Puppet::Transaction::Event::EVENT_STATUSES.each do |status_name|
         it "should provide the number of #{status_name} events" do
           add_statuses(3) do |status|
             3.times do |i|
               event = Puppet::Transaction::Event.new
               event.status = status_name
               status.add_event(event)
             end
           end
 
           @report.finalize_report
           metric(:events, status_name).should == 9
         end
       end
     end
   end
 
   describe "when producing a summary" do
     before do
       resource = Puppet::Type.type(:notify).new(:name => "testing")
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource resource
       trans = catalog.apply
 
       @report = trans.report
       @report.finalize_report
     end
 
-    %w{Changes Total Resources}.each do |main|
-      it "should include information on #{main} in the summary" do
+    %w{changes time resources events}.each do |main|
+      it "should include the key #{main} in the raw summary hash" do
+        @report.raw_summary.should be_key main
+      end
+    end
+
+    it "should include the last run time in the raw summary hash" do
+      Time.stubs(:now).returns(Time.utc(2010,11,10,12,0,24))
+      @report.raw_summary["time"]["last_run"].should == 1289390424
+    end
+
+    %w{Changes Total Resources Time Events}.each do |main|
+      it "should include information on #{main} in the textual summary" do
         @report.summary.should be_include(main)
       end
     end
   end
 
   describe "when outputting yaml" do
     it "should not include @external_times" do
       report = Puppet::Transaction::Report.new('apply')
       report.add_times('config_retrieval', 1.0)
       report.to_yaml_properties.should_not include('@external_times')
     end
   end
 end