diff --git a/acceptance/tests/ticket_7117_broke_env_criteria_authconf.rb b/acceptance/tests/ticket_7117_broke_env_criteria_authconf.rb
index 79f56c07a..07b427306 100644
--- a/acceptance/tests/ticket_7117_broke_env_criteria_authconf.rb
+++ b/acceptance/tests/ticket_7117_broke_env_criteria_authconf.rb
@@ -1,46 +1,55 @@
 test_name "#7117 Broke the environment criteria in auth.conf"
 
 # add to auth.conf
 add_2_authconf = %q{
 path /
 environment override
 auth any
 allow *
 }
 
 step "Save original auth.conf file and create a temp auth.conf"
 on master, "cp #{config['puppetpath']}/auth.conf /tmp/auth.conf-7117; echo '#{add_2_authconf}' > #{config['puppetpath']}/auth.conf"
 
 # Kill running Puppet Master -- should not be running at this point
 step "Master: kill running Puppet Master"
 on master, "ps -U puppet | awk '/puppet/ { print \$1 }' | xargs kill || echo \"Puppet Master not running\""
 step "Master: Start Puppet Master"
 on master, puppet_master("--certdnsnames=\"puppet:$(hostname -s):$(hostname -f)\" --verbose --noop")
 # allow Master to start and initialize environment
 
 step "Verify Puppet Master is ready to accept connections"
 host=agents.first
 time1 = Time.new
 until
   on(host, "curl -k https://#{master}:8140") do
     sleep 1
   end
 time2 = Time.new
 elapsed = time2 - time1
 Log.notify "Slept for #{elapsed} seconds waiting for Puppet Master to become ready"
 
-
+step "Verify Puppet Master is ready to accept connections"
+host=agents.first
+time1 = Time.new
+until
+  on(host, "curl -k https://#{master}:8140") do
+    sleep 1
+  end
+time2 = Time.new
+elapsed = time2 - time1
+Log.notify "Slept for #{elapsed} seconds waiting for Puppet Master to become ready"
 
 # Run test on Agents
 step "Agent: agent --test"
 on agents, puppet_agent("--test")
 
 step "Fetch agent facts from Puppet Master"
 agents.each do |host|
   on(host, "curl -k -H \"Accept: yaml\" https://#{master}:8140/override/facts/\`hostname -f\`") do
     assert_match(/--- !ruby\/object:Puppet::Node::Facts/, stdout, "Agent Facts not returned for #{host}") 
   end
 end
 
 step "Restore original auth.conf file"
 on master, "cp -f /tmp/auth.conf-7117 #{config['puppetpath']}/auth.conf"
diff --git a/lib/puppet/application/agent.rb b/lib/puppet/application/agent.rb
index 19849c57a..06a158fb3 100644
--- a/lib/puppet/application/agent.rb
+++ b/lib/puppet/application/agent.rb
@@ -1,481 +1,493 @@
 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 help
     <<-HELP
 
 puppet-agent(8) -- The puppet agent daemon
 ========
 
 SYNOPSIS
 --------
 Retrieves the client configuration from the puppet master and applies it to
 the local host.
 
 This service may be run as a daemon, run periodically using cron (or something
 similar), or run interactively for testing purposes.
 
 
 USAGE
 -----
 puppet agent  [-D|--daemonize|--no-daemonize] [-d|--debug]
   [--detailed-exitcodes] [--disable] [--enable] [-h|--help]
   [--certname <host name>] [-l|--logdest syslog|<file>|console]
   [-o|--onetime] [--serve <handler>] [-t|--test] [--noop]
   [--digest <digest>] [--fingerprint] [-V|--version]
   [-v|--verbose] [-w|--waitforcert <seconds>]
 
 
 DESCRIPTION
 -----------
 This is the main puppet client. Its job is to retrieve the local
 machine's configuration from a remote server and apply it. In order to
 successfully communicate with the remote server, the client must have a
 certificate signed by a certificate authority that the server trusts;
 the recommended method for this, at the moment, is to run a certificate
 authority as part of the puppet server (which is the default). The
 client will connect and request a signed certificate, and will continue
 connecting until it receives one.
 
 Once the client has a signed certificate, it will retrieve its
 configuration and apply it.
 
 
 USAGE NOTES
 -----------
 'puppet agent' does its best to find a compromise between interactive
 use and daemon use. Run with no arguments and no configuration, it will
 go into the background, attempt to get a signed certificate, and retrieve
 and apply its configuration every 30 minutes.
 
 Some flags are meant specifically for interactive use -- in particular,
 'test', 'tags' or 'fingerprint' are useful. 'test' enables verbose
 logging, causes the daemon to stay in the foreground, exits if the
 server's configuration is invalid (this happens if, for instance, you've
 left a syntax error on the server), and exits after running the
 configuration once (rather than hanging around as a long-running
 process).
 
 'tags' allows you to specify what portions of a configuration you want
 to apply. Puppet elements are tagged with all of the class or definition
 names that contain them, and you can use the 'tags' flag to specify one
 of these names, causing only configuration elements contained within
 that class or definition to be applied. This is very useful when you are
 testing new configurations -- for instance, if you are just starting to
 manage 'ntpd', you would put all of the new elements into an 'ntpd'
 class, and call puppet with '--tags ntpd', which would only apply that
 small portion of the configuration during your testing, rather than
 applying the whole thing.
 
 'fingerprint' is a one-time flag. In this mode 'puppet agent' will run
 once and display on the console (and in the log) the current certificate
 (or certificate request) fingerprint. Providing the '--digest' option
 allows to use a different digest algorithm to generate the fingerprint.
 The main use is to verify that before signing a certificate request on
 the master, the certificate request the master received is the same as
 the one the client sent (to prevent against man-in-the-middle attacks
 when signing certificates).
 
 
 OPTIONS
 -------
 Note that any configuration parameter that's valid in the configuration
 file is also a valid long argument. For example, 'server' is a valid
 configuration parameter, so you can specify '--server <servername>' as
 an argument.
 
 See the configuration file documentation at
 http://docs.puppetlabs.com/references/stable/configuration.html for the
 full list of acceptable parameters. A commented list of all
 configuration options can also be generated by running puppet agent with
 '--genconfig'.
 
 * --daemonize:
   Send the process into the background. This is the default.
 
 * --no-daemonize:
   Do not send the process into the background.
 
 * --debug:
   Enable full debugging.
 
 * --digest:
   Change the certificate fingerprinting digest algorithm. The default is
   MD5. Valid values depends on the version of OpenSSL installed, but
   should always at least contain MD5, MD2, SHA1 and SHA256.
 
 * --detailed-exitcodes:
   Provide transaction information via exit codes. If this is enabled, an
   exit code of '2' means there were changes, and an exit code of '4'
   means that there were failures during the transaction. This option
   only makes sense in conjunction with --onetime.
 
 * --disable:
   Disable working on the local system. This puts a lock file in place,
   causing 'puppet agent' not to work on the system until the lock file
   is removed. This is useful if you are testing a configuration and do
   not want the central configuration to override the local state until
   everything is tested and committed.
 
   'puppet agent' uses the same lock file while it is running, so no more
   than one 'puppet agent' process is working at a time.
 
   'puppet agent' exits after executing this.
 
 * --enable:
   Enable working on the local system. This removes any lock file,
   causing 'puppet agent' to start managing the local system again
   (although it will continue to use its normal scheduling, so it might
   not start for another half hour).
 
   'puppet agent' exits after executing this.
 
 * --certname:
   Set the certname (unique ID) of the client. The master reads this
   unique identifying string, which is usually set to the node's
   fully-qualified domain name, to determine which configurations the
   node will receive. Use this option to debug setup problems or
   implement unusual node identification schemes.
 
 * --help:
   Print this help message
 
 * --logdest:
   Where to send messages. Choose between syslog, the console, and a log
   file. Defaults to sending messages to syslog, or the console if
   debugging or verbosity is enabled.
 
 * --no-client:
   Do not create a config client. This will cause the daemon to run
   without ever checking for its configuration automatically, and only
   makes sense
 
 * --onetime:
   Run the configuration once. Runs a single (normally daemonized) Puppet
   run. Useful for interactively running puppet agent when used in
   conjunction with the --no-daemonize option.
 
 * --fingerprint:
   Display the current certificate or certificate signing request
   fingerprint and then exit. Use the '--digest' option to change the
   digest algorithm used.
 
 * --serve:
   Start another type of server. By default, 'puppet agent' will start a
   service handler that allows authenticated and authorized remote nodes
   to trigger the configuration to be pulled down and applied. You can
   specify any handler here that does not require configuration, e.g.,
   filebucket, ca, or resource. The handlers are in
   'lib/puppet/network/handler', and the names must match exactly, both
   in the call to 'serve' and in 'namespaceauth.conf'.
 
 * --test:
   Enable the most common options used for testing. These are 'onetime',
   'verbose', 'ignorecache', 'no-daemonize', 'no-usecacheonfailure',
   'detailed-exit-codes', 'no-splay', and 'show_diff'.
 
 * --noop:
   Use 'noop' mode where the daemon runs in a no-op or dry-run mode. This
   is useful for seeing what changes Puppet will make without actually
   executing the changes.
 
 * --verbose:
   Turn on verbose reporting.
 
 * --version:
   Print the puppet version number and exit.
 
 * --waitforcert:
   This option only matters for daemons that do not yet have certificates
   and it is enabled by default, with a value of 120 (seconds). This
   causes 'puppet agent' to connect to the server every 2 minutes and ask
   it to sign a certificate request. This is useful for the initial setup
   of a puppet client. You can turn off waiting for certificates by
   specifying a time of 0.
 
 
 EXAMPLE
 -------
     $ puppet agent --server puppet.domain.com
 
 
+DIAGNOSTICS
+-----------
+
+Puppet agent accepts the following signals:
+
+* SIGHUP:
+  Restart the puppet agent daemon.
+* SIGINT and SIGTERM:
+  Shut down the puppet agent daemon.
+* SIGUSR1: 
+  Immediately retrieve and apply configurations from the puppet master.
+
 AUTHOR
 ------
 Luke Kanies
 
 
 COPYRIGHT
 ---------
 Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
     HELP
   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[:rest_authconfig])
       Puppet.err "Will not start without authorization file #{Puppet[:rest_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.indirection.terminus_class = :rest
     # we want the last report to be persisted locally
     Puppet::Transaction::Report.indirection.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.indirection.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/face_base.rb b/lib/puppet/application/face_base.rb
index 7a5ce3400..ea5ba4aaf 100644
--- a/lib/puppet/application/face_base.rb
+++ b/lib/puppet/application/face_base.rb
@@ -1,232 +1,246 @@
 require 'puppet/application'
 require 'puppet/face'
 require 'optparse'
 require 'pp'
 
 class Puppet::Application::FaceBase < Puppet::Application
   should_parse_config
   run_mode :agent
 
   option("--debug", "-d") do |arg|
     Puppet::Util::Log.level = :debug
   end
 
   option("--verbose", "-v") do
     Puppet::Util::Log.level = :info
   end
 
   option("--render-as FORMAT") do |format|
     self.render_as = format.to_sym
   end
 
   option("--mode RUNMODE", "-r") do |arg|
     raise "Invalid run mode #{arg}; supported modes are user, agent, master" unless %w{user agent master}.include?(arg)
     self.class.run_mode(arg.to_sym)
     set_run_mode self.class.run_mode
   end
 
 
   attr_accessor :face, :action, :type, :arguments, :render_as
 
   def render_as=(format)
     if format == :json then
       @render_as = Puppet::Network::FormatHandler.format(:pson)
     else
       @render_as = Puppet::Network::FormatHandler.format(format)
     end
     @render_as or raise ArgumentError, "I don't know how to render '#{format}'"
   end
 
   def render(result)
     # Invoke the rendering hook supplied by the user, if appropriate.
     if hook = action.when_rendering(render_as.name)
       result = hook.call(result)
     end
 
     render_as.render(result)
   end
 
   def preinit
     super
     Signal.trap(:INT) do
       $stderr.puts "Cancelling Face"
       exit(0)
     end
   end
 
   def parse_options
     # We need to parse enough of the command line out early, to identify what
     # the action is, so that we can obtain the full set of options to parse.
 
     # REVISIT: These should be configurable versions, through a global
     # '--version' option, but we don't implement that yet... --daniel 2011-03-29
     @type = self.class.name.to_s.sub(/.+:/, '').downcase.to_sym
     @face = Puppet::Face[@type, :current]
 
     # Now, walk the command line and identify the action.  We skip over
     # arguments based on introspecting the action and all, and find the first
     # non-option word to use as the action.
-    action = nil
-    index  = -1
-    until @action or (index += 1) >= command_line.args.length do
+    action_name = nil
+    index       = -1
+    until action_name or (index += 1) >= command_line.args.length do
       item = command_line.args[index]
       if item =~ /^-/ then
         option = @face.options.find do |name|
           item =~ /^-+#{name.to_s.gsub(/[-_]/, '[-_]')}(?:[ =].*)?$/
         end
         if option then
           option = @face.get_option(option)
           # If we have an inline argument, just carry on.  We don't need to
           # care about optional vs mandatory in that case because we do a real
           # parse later, and that will totally take care of raising the error
           # when we get there. --daniel 2011-04-04
           if option.takes_argument? and !item.index('=') then
             index += 1 unless
               (option.optional_argument? and command_line.args[index + 1] =~ /^-/)
           end
         elsif option = find_global_settings_argument(item) then
           unless Puppet.settings.boolean? option.name then
             # As far as I can tell, we treat non-bool options as always having
             # a mandatory argument. --daniel 2011-04-05
             index += 1          # ...so skip the argument.
           end
         elsif option = find_application_argument(item) then
-          index += 1 if (option[:argument] and option[:optional])
+          index += 1 if (option[:argument] and not option[:optional])
         else
           raise OptionParser::InvalidOption.new(item.sub(/=.*$/, ''))
         end
       else
-        @action = @face.get_action(item.to_sym)
+        # Stash away the requested action name for later, and try to fetch the
+        # action object it represents; if this is an invalid action name that
+        # will be nil, and handled later.
+        action_name = item.to_sym
+        @action = @face.get_action(action_name)
       end
     end
 
     if @action.nil?
       if @action = @face.get_default_action() then
         @is_default_action = true
       else
-        Puppet.err "#{face.name} does not have a default action, and no action was given"
-        Puppet.err Puppet::Face[:help, :current].help(@face.name)
+        # REVISIT: ...and this horror thanks to our log setup, which doesn't
+        # initialize destinations until the setup method, which we will never
+        # reach.  We could also just print here, but that is actually a little
+        # uglier and nastier in the long term, in which we should do log setup
+        # earlier if at all possible. --daniel 2011-05-31
+        Puppet::Util::Log.newdestination(:console)
+
+        face   = @face.name
+        action = action_name.nil? ? 'default' : "'#{action_name}'"
+        msg = "'#{face}' has no #{action} action.  See `puppet help #{face}`."
+        Puppet.err(msg)
+
         exit false
       end
     end
 
     # Now we can interact with the default option code to build behaviour
     # around the full set of options we now know we support.
     @action.options.each do |option|
       option = @action.get_option(option) # make it the object.
       self.class.option(*option.optparse) # ...and make the CLI parse it.
     end
 
     # ...and invoke our parent to parse all the command line options.
     super
   end
 
   def find_global_settings_argument(item)
     Puppet.settings.each do |name, object|
       object.optparse_args.each do |arg|
         next unless arg =~ /^-/
         # sadly, we have to emulate some of optparse here...
         pattern = /^#{arg.sub('[no-]', '').sub(/[ =].*$/, '')}(?:[ =].*)?$/
         pattern.match item and return object
       end
     end
     return nil                  # nothing found.
   end
 
   def find_application_argument(item)
     self.class.option_parser_commands.each do |options, function|
       options.each do |option|
         next unless option =~ /^-/
         pattern = /^#{option.sub('[no-]', '').sub(/[ =].*$/, '')}(?:[ =].*)?$/
         next unless pattern.match(item)
         return {
           :argument => option =~ /[ =]/,
           :optional => option =~ /[ =]\[/
         }
       end
     end
     return nil                  # not found
   end
 
   def setup
     Puppet::Util::Log.newdestination :console
 
     @arguments = command_line.args
 
     # Note: because of our definition of where the action is set, we end up
     # with it *always* being the first word of the remaining set of command
     # line arguments.  So, strip that off when we construct the arguments to
     # pass down to the face action. --daniel 2011-04-04
     # Of course, now that we have default actions, we should leave the
     # "action" name on if we didn't actually consume it when we found our
     # action.
     @arguments.delete_at(0) unless @is_default_action
 
     # We copy all of the app options to the end of the call; This allows each
     # action to read in the options.  This replaces the older model where we
     # would invoke the action with options set as global state in the
     # interface object.  --daniel 2011-03-28
     @arguments << options
 
     # If we don't have a rendering format, set one early.
     self.render_as ||= (@action.render_as || :console)
   end
 
 
   def main
     status = false
 
     # Call the method associated with the provided action (e.g., 'find').
     unless @action
       puts Puppet::Face[:help, :current].help(@face.name)
       raise "#{face} does not respond to action #{arguments.first}"
     end
 
     # We need to do arity checking here because this is generic code
     # calling generic methods – that have argument defaulting.  We need to
     # make sure we don't accidentally pass the options as the first
     # argument to a method that takes one argument.  eg:
     #
     #   puppet facts find
     #   => options => {}
     #      @arguments => [{}]
     #   => @face.send :bar, {}
     #
     #   def face.bar(argument, options = {})
     #   => bar({}, {})  # oops!  we thought the options were the
     #                   # positional argument!!
     #
     # We could also fix this by making it mandatory to pass the options on
     # every call, but that would make the Ruby API much more annoying to
     # work with; having the defaulting is a much nicer convention to have.
     #
     # We could also pass the arguments implicitly, by having a magic
     # 'options' method that was visible in the scope of the action, which
     # returned the right stuff.
     #
     # That sounds attractive, but adds complications to all sorts of
     # things, especially when you think about how to pass options when you
     # are writing Ruby code that calls multiple faces.  Especially if
     # faces are involved in that. ;)
     #
     # --daniel 2011-04-27
     if (arity = @action.positional_arg_count) > 0
       unless (count = arguments.length) == arity then
         s = arity == 2 ? '' : 's'
         raise ArgumentError, "puppet #{@face.name} #{@action.name} takes #{arity-1} argument#{s}, but you gave #{count-1}"
       end
     end
 
     result = @face.send(@action.name, *arguments)
     puts render(result) unless result.nil?
     status = true
 
   rescue Exception => detail
     puts detail.backtrace if Puppet[:trace]
     Puppet.err detail.to_s
     Puppet.err "Try 'puppet help #{@face.name} #{@action.name}' for usage"
 
   ensure
     exit status
   end
 end
diff --git a/lib/puppet/application/faces.rb b/lib/puppet/application/faces.rb
deleted file mode 100644
index 3145da821..000000000
--- a/lib/puppet/application/faces.rb
+++ /dev/null
@@ -1,122 +0,0 @@
-require 'puppet/application'
-require 'puppet/face'
-
-class Puppet::Application::Faces < Puppet::Application
-
-  should_parse_config
-  run_mode :agent
-
-  option("--debug", "-d") do |arg|
-    Puppet::Util::Log.level = :debug
-  end
-
-  option("--verbose", "-v") do
-    Puppet::Util::Log.level = :info
-  end
-
-  def help
-    <<-HELP
-puppet-faces(8) -- List available Faces and actions
-========
-
-SYNOPSIS
---------
-Lists the available subcommands (with applicable terminuses and/or actions)
-provided by the Puppet Faces API. This information is automatically read
-from the Puppet code present on the system. By default, the output includes
-all terminuses and actions.
-
-USAGE
------
-puppet faces [-d|--debug] [-v|--verbose] [actions|terminuses]
-
-OPTIONS
--------
-Note that any configuration option valid in the configuration file is also
-a valid long argument. See the configuration file documentation at
-http://docs.puppetlabs.com/references/stable/configuration.html for the
-full list of acceptable parameters. A commented list of all
-configuration options can also be generated by running puppet agent with
-'--genconfig'.
-
-* --verbose:
-  Sets the log level to "info." This option has no tangible effect at the time
-  of this writing.
-
-* --debug:
-  Sets the log level to "debug." This option has no tangible effect at the time
-  of this writing.
-
-AUTHOR
-------
-Puppet Labs
-
-COPYRIGHT
----------
-Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
-
-    HELP
-  end
-
-  def list(*arguments)
-    if arguments.empty?
-      arguments = %w{terminuses actions}
-    end
-    faces.each do |name|
-      str = "#{name}:\n"
-      if arguments.include?("terminuses")
-        begin
-          terms = Puppet::Indirector::Face.terminus_classes(name.to_sym)
-          str << "\tTerminuses: #{terms.join(", ")}\n"
-        rescue => detail
-          puts detail.backtrace if Puppet[:trace]
-          $stderr.puts "Could not load terminuses for #{name}: #{detail}"
-        end
-      end
-
-      if arguments.include?("actions")
-        begin
-          actions = actions(name.to_sym)
-          str << "\tActions: #{actions.join(", ")}\n"
-        rescue => detail
-          puts detail.backtrace if Puppet[:trace]
-          $stderr.puts "Could not load actions for #{name}: #{detail}"
-        end
-      end
-
-      print str
-    end
-  end
-
-  attr_accessor :name, :arguments
-
-  def main
-    list(*arguments)
-  end
-
-  def setup
-    Puppet::Util::Log.newdestination :console
-
-    load_applications # Call this to load all of the apps
-
-    @arguments = command_line.args
-    @arguments ||= []
-  end
-
-  def faces
-    Puppet::Face.faces
-  end
-
-  def actions(indirection)
-    return [] unless face = Puppet::Face[indirection, '0.0.1']
-    face.load_actions
-    return face.actions.sort { |a, b| a.to_s <=> b.to_s }
-  end
-
-  def load_applications
-    command_line.available_subcommands.each do |app|
-      command_line.require_application app
-    end
-  end
-end
-
diff --git a/lib/puppet/application/help.rb b/lib/puppet/application/help.rb
index 4829a2036..66baa462e 100644
--- a/lib/puppet/application/help.rb
+++ b/lib/puppet/application/help.rb
@@ -1,7 +1,4 @@
 require 'puppet/application/face_base'
 
 class Puppet::Application::Help < Puppet::Application::FaceBase
-  # Meh.  Disable the default behaviour, which is to inspect the
-  # string and return that – not so helpful. --daniel 2011-04-11
-  def render(result) result end
 end
diff --git a/lib/puppet/application/man.rb b/lib/puppet/application/man.rb
new file mode 100644
index 000000000..1ecc4d691
--- /dev/null
+++ b/lib/puppet/application/man.rb
@@ -0,0 +1,4 @@
+require 'puppet/application/face_base'
+
+class Puppet::Application::Man < Puppet::Application::FaceBase
+end
diff --git a/lib/puppet/application/master.rb b/lib/puppet/application/master.rb
index a90829ae0..18425c8bc 100644
--- a/lib/puppet/application/master.rb
+++ b/lib/puppet/application/master.rb
@@ -1,231 +1,241 @@
 require 'puppet/application'
 
 class Puppet::Application::Master < Puppet::Application
 
   should_parse_config
   run_mode :master
 
   option("--debug", "-d")
   option("--verbose", "-v")
 
   # internal option, only to be used by ext/rack/config.ru
   option("--rack")
 
   option("--compile host",  "-c host") do |arg|
     options[:node] = arg
   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("--parseonly") do
     puts "--parseonly has been removed. Please use 'puppet parser validate <manifest>'"
     exit 1
   end
 
   def help
     <<-HELP
 
 puppet-master(8) -- The puppet master daemon
 ========
 
 SYNOPSIS
 --------
 The central puppet server. Functions as a certificate authority by
 default.
 
 
 USAGE
 -----
 puppet master [-D|--daemonize|--no-daemonize] [-d|--debug] [-h|--help]
   [-l|--logdest <file>|console|syslog] [-v|--verbose] [-V|--version]
   [--compile <node-name>]
 
 
 DESCRIPTION
 -----------
 This command starts an instance of puppet master, running as a daemon
 and using Ruby's built-in Webrick webserver. Puppet master can also be
 managed by other application servers; when this is the case, this
 executable is not used.
 
 
 OPTIONS
 -------
 Note that any configuration parameter that's valid in the configuration
 file is also a valid long argument. For example, 'ssldir' is a valid
 configuration parameter, so you can specify '--ssldir <directory>' as an
 argument.
 
 See the configuration file documentation at
 http://docs.puppetlabs.com/references/stable/configuration.html for the
 full list of acceptable parameters. A commented list of all
 configuration options can also be generated by running puppet master
 with '--genconfig'.
 
 * --daemonize:
   Send the process into the background. This is the default.
 
 * --no-daemonize:
   Do not send the process into the background.
 
 * --debug:
   Enable full debugging.
 
 * --help:
   Print this help message.
 
 * --logdest:
   Where to send messages. Choose between syslog, the console, and a log
   file. Defaults to sending messages to syslog, or the console if
   debugging or verbosity is enabled.
 
 * --verbose:
   Enable verbosity.
 
 * --version:
   Print the puppet version number and exit.
 
 * --compile:
   Compile a catalogue and output it in JSON from the puppet master. Uses
   facts contained in the $vardir/yaml/ directory to compile the catalog.
 
 
 EXAMPLE
 -------
   puppet master
 
+DIAGNOSTICS
+-----------
+
+When running as a standalone daemon, puppet master accepts the
+following signals:
+
+* SIGHUP:
+  Restart the puppet master server.
+* SIGINT and SIGTERM:
+  Shut down the puppet master server.
 
 AUTHOR
 ------
 Luke Kanies
 
 
 COPYRIGHT
 ---------
 Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
     HELP
   end
 
   def preinit
     Signal.trap(:INT) do
       $stderr.puts "Cancelling startup"
       exit(0)
     end
 
     # Create this first-off, so we have ARGV
     require 'puppet/daemon'
     @daemon = Puppet::Daemon.new
     @daemon.argv = ARGV.dup
   end
 
   def run_command
     if options[:node]
       compile
     else
       main
     end
   end
 
   def compile
     Puppet::Util::Log.newdestination :console
     raise ArgumentError, "Cannot render compiled catalogs without pson support" unless Puppet.features.pson?
     begin
       unless catalog = Puppet::Resource::Catalog.indirection.find(options[:node])
         raise "Could not compile catalog for #{options[:node]}"
       end
 
       jj catalog.to_resource
     rescue => detail
       $stderr.puts detail
       exit(30)
     end
     exit(0)
   end
 
   def main
     require 'etc'
     require 'puppet/file_serving/content'
     require 'puppet/file_serving/metadata'
 
     xmlrpc_handlers = [:Status, :FileServer, :Master, :Report, :Filebucket]
 
     xmlrpc_handlers << :CA if Puppet[:ca]
 
     # Make sure we've got a localhost ssl cert
     Puppet::SSL::Host.localhost
 
     # And now configure our server to *only* hit the CA for data, because that's
     # all it will have write access to.
     Puppet::SSL::Host.ca_location = :only if Puppet::SSL::CertificateAuthority.ca?
 
     if Puppet.features.root?
       begin
         Puppet::Util.chuser
       rescue => detail
         puts detail.backtrace if Puppet[:trace]
         $stderr.puts "Could not change user to #{Puppet[:user]}: #{detail}"
         exit(39)
       end
     end
 
     unless options[:rack]
       require 'puppet/network/server'
       @daemon.server = Puppet::Network::Server.new(:xmlrpc_handlers => xmlrpc_handlers)
       @daemon.daemonize if Puppet[:daemonize]
     else
       require 'puppet/network/http/rack'
       @app = Puppet::Network::HTTP::Rack.new(:xmlrpc_handlers => xmlrpc_handlers, :protocols => [:rest, :xmlrpc])
     end
 
     Puppet.notice "Starting Puppet master version #{Puppet.version}"
 
     unless options[:rack]
       @daemon.start
     else
       return @app
     end
   end
 
   def setup
     # Handle the logging settings.
     if options[:debug] or options[:verbose]
       if options[:debug]
         Puppet::Util::Log.level = :debug
       else
         Puppet::Util::Log.level = :info
       end
 
       unless Puppet[:daemonize] or options[:rack]
         Puppet::Util::Log.newdestination(:console)
         options[:setdest] = true
       end
     end
 
     Puppet::Util::Log.newdestination(:syslog) unless options[:setdest]
 
     exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
 
     Puppet.settings.use :main, :master, :ssl, :metrics
 
     # Cache our nodes in yaml.  Currently not configurable.
     Puppet::Node.indirection.cache_class = :yaml
 
     # Configure all of the SSL stuff.
     if Puppet::SSL::CertificateAuthority.ca?
       Puppet::SSL::Host.ca_location = :local
       Puppet.settings.use :ca
       Puppet::SSL::CertificateAuthority.instance
     else
       Puppet::SSL::Host.ca_location = :none
     end
   end
 end
diff --git a/lib/puppet/face/help/man.erb b/lib/puppet/face/help/man.erb
index 899d0166c..6f21fe413 100644
--- a/lib/puppet/face/help/man.erb
+++ b/lib/puppet/face/help/man.erb
@@ -1,133 +1,132 @@
 puppet-<%= face.name %>(8) -- <%= face.summary || "Unknown face." %>
 <%= '=' * (_erbout.length - 1) %>
 
 <% if face.synopsis -%>
 SYNOPSIS
 --------
 <%= face.synopsis %>
 
 <% end
    if face.description -%>
 DESCRIPTION
 -----------
 <%= face.description.strip %>
 
 <% end -%>
 OPTIONS
 -------
 Note that any configuration parameter that's valid in the configuration
 file is also a valid long argument, although it may or may not be
 relevant to the present action. For example, `server` is a valid
 configuration parameter, so you can specify `--server <servername>` as
 an argument.
 
 See the configuration file documentation at
 <http://docs.puppetlabs.com/references/stable/configuration.html> for the
 full list of acceptable parameters. A commented list of all
 configuration options can also be generated by running puppet with
 `--genconfig`.
 
 * --mode MODE:
   The run mode to use for the current action. Valid modes are `user`, `agent`,
   and `master`.
 * --render-as FORMAT:
   The format in which to render output. The most common formats are `json`,
   `s` (string), and `yaml`, but other options such as `dot` are
   sometimes available.
 * --verbose:
   Whether to log verbosely.
 * --debug:
   Whether to log debug information.
 <% unless face.options.empty?
      face.options.sort.each do |name|
        option = face.get_option name -%>
 <%= "* " + option.optparse.join(" | " ) %>:
 <%= option.description.gsub(/^/, '  ') || '  ' + option.summary %>
 <%   end
    end -%>
 
 ACTIONS
 -------
 <% face.actions.each do |actionname|
      action = face.get_action(actionname) -%>
 * `<%= action.name.to_s %>` - <%= action.summary %>:
 <%   if action.synopsis -%>
   `SYNOPSIS`
 
   <%= action.synopsis %>
 
 <%   end -%>
 <%   if action.description -%>
   `DESCRIPTION`
 
 <%= action.description.gsub(/^/, '  ') %>
 <%   end
      unique_options = action.options - face.options
      unless unique_options.empty? -%>
   `OPTIONS`
 
 <%     unique_options.sort.each do |name|
          option = action.get_option name
          text = option.description || option.summary -%>
   <%= '<' + option.optparse.join("> | <") + '>' %> -
 <%= text.gsub(/^/, '  ') %>
 <%     end -%>
 
 <%   end -%>
 <%   if action.returns -%>
   `RETURNS`
 
 <%= action.returns.gsub(/^/, '  ') %>
 
 <%   end
      if action.notes -%>
   `NOTES`
 
 <%= action.notes.gsub(/^/, '  ') %>
 
 <%   end
    end
    if face.examples or face.actions.any? {|actionname| face.get_action(actionname).examples} -%>
 EXAMPLES
 --------
 <% end
    if face.examples -%>
 <%= face.examples %>
 
 <% end
    face.actions.each do |actionname|
      action = face.get_action(actionname)
      if action.examples -%>
 `<%= action.name.to_s %>`
 
 <%= action.examples.strip %>
 <%   end
    end -%>
 
 <% if face.notes or face.respond_to? :indirection -%>
 NOTES
 -----
 <% if face.notes -%>
 <%= face.notes.strip %>
 
 <% end # notes
 if face.respond_to? :indirection -%>
 This is an indirector face, which exposes `find`, `search`, `save`, and
 `destroy` actions for an indirected subsystem of Puppet. Valid termini
 for this face include:
 
 * `<%= face.class.terminus_classes(face.indirection.name).join("`\n* `") %>`
 
 <% end # indirection
    end # notes or indirection
    unless face.authors.empty? -%>
 AUTHOR
 ------
 <%= face.authors.join("\n").gsub(/^/, ' * ') %>
 
 <% end -%>
 COPYRIGHT AND LICENSE
 ---------------------
 <%= face.copyright %>
 <%= face.license %>
-
diff --git a/lib/puppet/face/man.rb b/lib/puppet/face/man.rb
new file mode 100644
index 000000000..38b9202eb
--- /dev/null
+++ b/lib/puppet/face/man.rb
@@ -0,0 +1,95 @@
+require 'puppet/face'
+require 'puppet/util'
+require 'pathname'
+require 'erb'
+
+Puppet::Face.define(:man, '0.0.1') do
+  copyright "Puppet Labs", 2011
+  license   "Apache 2 license; see COPYING"
+
+  summary "Display Puppet subcommand manual pages."
+
+  description <<-EOT
+    The man face, when invoked from the command line, tries very hard to
+    behave nicely for interactive use.  If possible, it delegates to the
+    ronn(1) command to format the output as a real manual page.
+
+    If ronn(1) is not available, it will use the first of `$MANPAGER`,
+    `$PAGER`, `less`, `most`, or `more` to paginate the (human-readable)
+    input text for the manual page.
+
+    We do try hard to ensure that this behaves correctly when used as
+    part of a pipeline.  (Well, we delegate to tools that do the right
+    thing, which is more or less the same.)
+  EOT
+
+  notes <<-EOT
+    We strongly encourage you to install the `ronn` gem on your system,
+    or otherwise make it available, so that we can display well structured
+    output from this face.
+  EOT
+
+  action(:man) do
+    summary "Display the manual page for a face."
+    arguments "<face>"
+    returns "The man data, in markdown format, suitable for consumption by Ronn."
+    examples <<-'EOT'
+      Get the manual page for a face:
+
+      $ puppet man facts
+    EOT
+
+    default
+    when_invoked do |name, options|
+      if legacy_applications.include? name then
+        return Puppet::Application[name].help
+      end
+
+      face = Puppet::Face[name.to_sym, :current]
+
+      file = (Pathname(__FILE__).dirname + "help" + 'man.erb')
+      erb = ERB.new(file.read, nil, '-')
+      erb.filename = file.to_s
+
+      # Run the ERB template in our current binding, including all the local
+      # variables we established just above. --daniel 2011-04-11
+      return erb.result(binding)
+    end
+
+
+    when_rendering :console do |text|
+      # OK, if we have Ronn on the path we can delegate to it and override the
+      # normal output process.  Otherwise delegate to a pager on the raw text,
+      # otherwise we finally just delegate to our parent.  Oh, well.
+      ENV['LESS'] ||= 'FRSX'    # emulate git...
+
+      ronn  = Puppet::Util.which('ronn')
+      pager = [ENV['MANPAGER'], ENV['PAGER'], 'less', 'most', 'more'].
+        detect {|x| x and x.length > 0 and Puppet::Util.which(x) }
+
+      if ronn then
+        # ronn is a stupid about pager selection, we can be smarter. :)
+        if pager then ENV['PAGER'] = pager end
+
+        args  = "--man --manual='Puppet Manual' --organization='Puppet Labs, LLC'"
+        IO.popen("#{ronn} #{args}", 'w') do |fh| fh.write text end
+
+        ''                      # suppress local output, neh?
+      elsif pager then
+        IO.popen(pager, 'w') do |fh| fh.write text end
+        ''
+      else
+        text
+      end
+    end
+  end
+
+  def legacy_applications
+    # The list of applications, less those that are duplicated as a face.
+    Puppet::Util::CommandLine.available_subcommands.reject do |appname|
+      Puppet::Face.face? appname.to_sym, :current or
+        # ...this is a nasty way to exclude non-applications. :(
+        %w{face_base indirection_base}.include? appname
+    end
+  end
+end
diff --git a/lib/puppet/indirector/face.rb b/lib/puppet/indirector/face.rb
index f6c36e31d..756306a2f 100644
--- a/lib/puppet/indirector/face.rb
+++ b/lib/puppet/indirector/face.rb
@@ -1,125 +1,125 @@
 require 'puppet/face'
 
 class Puppet::Indirector::Face < Puppet::Face
   option "--terminus TERMINUS" do
     summary "The indirector terminus to use for this action."
     description <<-EOT
       Indirector faces expose indirected subsystems of Puppet. These
       subsystems are each able to retrieve and alter a specific type of data
       (with the familiar actions of `find`, `search`, `save`, and `destroy`)
       from an arbitrary number of pluggable backends. In Puppet parlance,
       these backends are called terminuses.
-      
+
       Almost all indirected subsystems have a `rest` terminus that interacts
       with the puppet master's data. Most of them have additional terminuses
       for various local data models, which are in turn used by the indirected
       subsystem on the puppet master whenever it receives a remote request.
-      
+
       The terminus for an action is often determined by context, but
       occasionally needs to be set explicitly. See the "Notes" section of this
       face's manpage for more details.
     EOT
 
     before_action do |action, args, options|
       set_terminus(options[:terminus])
     end
 
     after_action do |action, args, options|
       indirection.reset_terminus_class
     end
   end
 
   def self.indirections
     Puppet::Indirector::Indirection.instances.collect { |t| t.to_s }.sort
   end
 
   def self.terminus_classes(indirection)
     Puppet::Indirector::Terminus.terminus_classes(indirection.to_sym).collect { |t| t.to_s }.sort
   end
 
   def call_indirection_method(method, key, options)
     begin
       result = indirection.__send__(method, key, options)
     rescue => detail
       puts detail.backtrace if Puppet[:trace]
       raise "Could not call '#{method}' on '#{indirection_name}': #{detail}"
     end
 
     return result
   end
 
   action :destroy do
     summary "Delete an object."
     arguments "<key>"
     when_invoked { |key, options| call_indirection_method(:destroy, key, options) }
   end
 
   action :find do
     summary "Retrieve an object by name."
     arguments "<key>"
     when_invoked { |key, options| call_indirection_method(:find, key, options) }
   end
 
   action :save do
     summary "Create or overwrite an object."
     arguments "<object>"
     description <<-EOT
       Create or overwrite an object. Save actions cannot currently be
       invoked from the command line, and are for API use only.
     EOT
     when_invoked { |key, options| call_indirection_method(:save, key, options) }
   end
 
   action :search do
     summary "Search for an object or retrieve multiple objects."
     arguments "<query>"
     when_invoked { |key, options| call_indirection_method(:search, key, options) }
   end
 
   # Print the configuration for the current terminus class
   action :info do
     summary "Print the default terminus class for this face."
     description <<-EOT
       Prints the default terminus class for this face. Note that
       different run modes may have different default terminuses.
     EOT
 
     when_invoked do |*args|
       if t = indirection.terminus_class
         puts "Run mode '#{Puppet.run_mode.name}': #{t}"
       else
         $stderr.puts "No default terminus class for run mode '#{Puppet.run_mode.name}'"
       end
     end
   end
 
   attr_accessor :from
 
   def indirection_name
     @indirection_name || name.to_sym
   end
 
   # Here's your opportunity to override the indirection name.  By default it
   # will be the same name as the face.
   def set_indirection_name(name)
     @indirection_name = name
   end
 
   # Return an indirection associated with a face, if one exists;
   # One usually does.
   def indirection
     unless @indirection
       @indirection = Puppet::Indirector::Indirection.instance(indirection_name)
       @indirection or raise "Could not find terminus for #{indirection_name}"
     end
     @indirection
   end
 
   def set_terminus(from)
     begin
       indirection.terminus_class = from
     rescue => detail
       raise "Could not set '#{indirection.name}' terminus to '#{from}' (#{detail}); valid terminus types are #{self.class.terminus_classes(indirection.name).join(", ") }"
     end
   end
 end
diff --git a/lib/puppet/interface/action_manager.rb b/lib/puppet/interface/action_manager.rb
index c5eb8e08a..fbf588d7d 100644
--- a/lib/puppet/interface/action_manager.rb
+++ b/lib/puppet/interface/action_manager.rb
@@ -1,67 +1,70 @@
 require 'puppet/interface/action'
 
 module Puppet::Interface::ActionManager
   # Declare that this app can take a specific action, and provide
   # the code to do so.
   def action(name, &block)
     require 'puppet/interface/action_builder'
 
     @actions ||= {}
     @default_action ||= nil
     raise "Action #{name} already defined for #{self}" if action?(name)
     action = Puppet::Interface::ActionBuilder.build(self, name, &block)
     if action.default
       raise "Actions #{@default_action.name} and #{name} cannot both be default" if @default_action
       @default_action = action
     end
     @actions[action.name] = action
   end
 
   # This is the short-form of an action definition; it doesn't use the
   # builder, just creates the action directly from the block.
   def script(name, &block)
     @actions ||= {}
     raise "Action #{name} already defined for #{self}" if action?(name)
     @actions[name] = Puppet::Interface::Action.new(self, name, :when_invoked => block)
   end
 
   def actions
     @actions ||= {}
     result = @actions.keys
 
     if self.is_a?(Class) and superclass.respond_to?(:actions)
       result += superclass.actions
     elsif self.class.respond_to?(:actions)
       result += self.class.actions
     end
-    result.sort
+    # We need to uniq the result, because we duplicate actions when they are
+    # fetched to ensure that they have the correct bindings; they shadow the
+    # parent, and uniq implements that. --daniel 2011-06-01
+    result.uniq.sort
   end
 
   def get_action(name)
     @actions ||= {}
     result = @actions[name.to_sym]
     if result.nil?
       if self.is_a?(Class) and superclass.respond_to?(:get_action)
         found = superclass.get_action(name)
       elsif self.class.respond_to?(:get_action)
         found = self.class.get_action(name)
       end
 
       if found then
         # This is not the nicest way to make action equivalent to the Ruby
         # Method object, rather than UnboundMethod, but it will do for now,
         # and we only have to make this change in *one* place. --daniel 2011-04-12
         result = @actions[name.to_sym] = found.__dup_and_rebind_to(self)
       end
     end
     return result
   end
 
   def get_default_action
     @default_action
   end
 
   def action?(name)
     actions.include?(name.to_sym)
   end
 end
diff --git a/lib/puppet/reference/configuration.rb b/lib/puppet/reference/configuration.rb
index 6581427ff..18efb6fe7 100644
--- a/lib/puppet/reference/configuration.rb
+++ b/lib/puppet/reference/configuration.rb
@@ -1,144 +1,69 @@
 config = Puppet::Util::Reference.newreference(:configuration, :depth => 1, :doc => "A reference for all configuration parameters") do
   docs = {}
   Puppet.settings.each do |name, object|
     docs[name] = object
   end
 
   str = ""
   docs.sort { |a, b|
     a[0].to_s <=> b[0].to_s
   }.each do |name, object|
     # Make each name an anchor
     header = name.to_s
     str += h(header, 3)
 
     # Print the doc string itself
     begin
       str += object.desc.gsub(/\n/, " ")
     rescue => detail
       puts detail.backtrace
       puts detail
     end
     str += "\n\n"
 
     # Now print the data about the item.
     str += ""
     val = object.default
     if name.to_s == "vardir"
       val = "/var/lib/puppet"
     elsif name.to_s == "confdir"
       val = "/etc/puppet"
     end
 
     # Leave out the section information; it was apparently confusing people.
     #str += "- **Section**: #{object.section}\n"
     unless val == ""
       str += "- *Default*: #{val}\n"
     end
     str += "\n"
   end
 
   return str
 end
 
-config.header = "
-## Specifying Configuration Parameters
-
-### On The Command-Line
-
-Every Puppet executable (with the exception of `puppetdoc`) accepts all of
-the parameters below, but not all of the arguments make sense for every executable.
-
-I have tried to be as thorough as possible in the descriptions of the
-arguments, so it should be obvious whether an argument is appropriate or not.
-
-These parameters can be supplied to the executables either as command-line
-options or in the configuration file.  For instance, the command-line
-invocation below would set the configuration directory to `/private/puppet`:
-
-    $ puppet agent --confdir=/private/puppet
-
-Note that boolean options are turned on and off with a slightly different
-syntax on the command line:
-
-    $ puppet agent --storeconfigs
-
-    $ puppet agent --no-storeconfigs
-
-The invocations above will enable and disable, respectively, the storage of
-the client configuration.
-
-### Configuration Files
-
-As mentioned above, the configuration parameters can also be stored in a
-configuration file, located in the configuration directory.  As root, the
-default configuration directory is `/etc/puppet`, and as a regular user, the
-default configuration directory is `~user/.puppet`.  As of 0.23.0, all
-executables look for `puppet.conf` in their configuration directory
-(although they previously looked for separate files).  For example,
-`puppet.conf` is located at `/etc/puppet/puppet.conf` as `root` and
-`~user/.puppet/puppet.conf` as a regular user by default.
-
-All executables will set any parameters set within the `[main]` section,
-and each executable will also use one of the `[master]`, `[agent]`.
-
-#### File Format
-
-The file follows INI-style formatting.  Here is an example of a very simple
-`puppet.conf` file:
-
-    [main]
-      confdir = /private/puppet
-      storeconfigs = true
-
-Note that boolean parameters must be explicitly specified as `true` or
-`false` as seen above.
-
-If you need to change file or directory parameters (e.g., reset the mode or owner), do
-so within curly braces on the same line:
-
-    [main]
-      vardir = /new/vardir {owner = root, mode = 644}
-
-If you're starting out with a fresh configuration, you may wish to let
-the executable generate a template configuration file for you by invoking
-the executable in question with the `--genconfig` command.  The executable
-will print a template configuration to standard output, which can be
-redirected to a file like so:
-
-    $ puppet agent --genconfig > /etc/puppet/puppet.conf
-
-Note that this invocation will replace the contents of any pre-existing
-`puppet.conf` file, so make a backup of your present config if it contains
-valuable information.
-
-Like the `--genconfig` argument, the executables also accept a `--genmanifest`
-argument, which will generate a manifest that can be used to manage all of
-Puppet's directories and files and prints it to standard output.  This can
-likewise be redirected to a file:
-
-    $ puppet agent --genmanifest > /etc/puppet/manifests/site.pp
-
-Puppet can also create user and group accounts for itself (one `puppet` group
-and one `puppet` user) if it is invoked as `root` with the `--mkusers` argument:
-
-    $ puppet master --mkusers
-
-## Signals
-
-The `puppet agent` and `puppet master` executables catch some signals for special
-handling.  Both daemons catch (`SIGHUP`), which forces the server to restart
-tself.  Predictably, interrupt and terminate (`SIGINT` and `SIGTERM`) will shut
-down the server, whether it be an instance of `puppet agent` or `puppet master`.
-
-Sending the `SIGUSR1` signal to an instance of `puppet agent` will cause it to
-immediately begin a new configuration transaction with the server.  This
-signal has no effect on `puppet master`.
-
-## Configuration Parameter Reference
-
-Below is a list of all documented parameters.  Not all of them are valid with all
-Puppet executables, but the executables will ignore any inappropriate values.
-
-"
-
+config.header = <<EOT
+## Configuration Settings
+
+* Each of these settings can be specified in `puppet.conf` or on the
+  command line.
+* When using boolean settings on the command line, use `--setting` and
+  `--no-setting` instead of `--setting (true|false)`.
+* Settings can be interpolated as `$variables` in other settings; `$environment`
+  is special, in that puppet master will interpolate each agent node's
+  environment instead of its own.
+* Multiple values should be specified as comma-separated lists; multiple
+  directories should be separated with the system path separator (usually
+  a colon).
+* Settings that take a single file or directory can optionally set the owner,
+  group, and mode for their value: `rundir = $vardir/run { owner = puppet,
+  group = puppet, mode = 644 }`
+* The Puppet executables will ignore any setting that isn't relevant to
+  their function.
+
+See the [configuration guide][confguide] for more details.
+
+[confguide]: http://docs.puppetlabs.com/guides/configuring.html
+
+* * *
+
+EOT
diff --git a/lib/puppet/util/command_line.rb b/lib/puppet/util/command_line.rb
index 8190f8ac1..244e2c2c9 100644
--- a/lib/puppet/util/command_line.rb
+++ b/lib/puppet/util/command_line.rb
@@ -1,108 +1,189 @@
 require "puppet/util/plugins"
 
 module Puppet
   module Util
     class CommandLine
 
       LegacyName = Hash.new{|h,k| k}.update(
         'agent'      => 'puppetd',
         'cert'       => 'puppetca',
         'doc'        => 'puppetdoc',
         'filebucket' => 'filebucket',
         'apply'      => 'puppet',
         'describe'   => 'pi',
         'queue'      => 'puppetqd',
         'resource'   => 'ralsh',
         'kick'       => 'puppetrun',
         'master'     => 'puppetmasterd',
         'device'     => 'puppetdevice'
       )
 
       def initialize(zero = $0, argv = ARGV, stdin = STDIN)
         @zero  = zero
         @argv  = argv.dup
         @stdin = stdin
 
         @subcommand_name, @args = subcommand_and_args(@zero, @argv, @stdin)
         Puppet::Plugins.on_commandline_initialization(:command_line_object => self)
       end
 
       attr :subcommand_name
       attr :args
 
       def appdir
         File.join('puppet', 'application')
       end
 
       def self.available_subcommands
         absolute_appdirs = $LOAD_PATH.collect do |x|
           File.join(x,'puppet','application')
         end.select{ |x| File.directory?(x) }
         absolute_appdirs.inject([]) do |commands, dir|
           commands + Dir[File.join(dir, '*.rb')].map{|fn| File.basename(fn, '.rb')}
         end.uniq
       end
       # available_subcommands was previously an instance method, not a class
       # method, and we have an unknown number of user-implemented applications
       # that depend on that behaviour.  Forwarding allows us to preserve a
       # backward compatible API. --daniel 2011-04-11
       def available_subcommands
         self.class.available_subcommands
       end
 
       def require_application(application)
         require File.join(appdir, application)
       end
 
       def execute
         if subcommand_name and available_subcommands.include?(subcommand_name) then
           require_application subcommand_name
           app = Puppet::Application.find(subcommand_name).new(self)
           Puppet::Plugins.on_application_initialization(:appliation_object => self)
+
+          # See the note in 'warn_later' down below. --daniel 2011-06-01
+          if $delayed_deprecation_warning_for_p_u_cl.is_a? String then
+            Puppet.deprecation_warning($delayed_deprecation_warning_for_p_u_cl)
+            $delayed_deprecation_warning_for_p_u_cl = true
+          end
+
           app.run
         elsif execute_external_subcommand then
           # Logically, we shouldn't get here, but we do, so whatever.  We just
           # return to the caller.  How strange we are. --daniel 2011-04-11
         else
           unless subcommand_name.nil? then
             puts "Error: Unknown Puppet subcommand '#{subcommand_name}'"
           end
           puts "See 'puppet help' for help on available puppet subcommands"
         end
       end
 
       def execute_external_subcommand
         external_command = "puppet-#{subcommand_name}"
 
         require 'puppet/util'
         path_to_subcommand = Puppet::Util.which(external_command)
         return false unless path_to_subcommand
 
         system(path_to_subcommand, *args)
         true
       end
 
       def legacy_executable_name
         LegacyName[ subcommand_name ]
       end
 
       private
 
       def subcommand_and_args(zero, argv, stdin)
         zero = File.basename(zero, '.rb')
 
         if zero == 'puppet'
           case argv.first
-          when nil;              [ stdin.tty? ? nil : "apply", argv] # ttys get usage info
-          when "--help", "-h";         [nil,     argv] # help should give you usage, not the help for `puppet apply`
-          when /^-|\.pp$|\.rb$/; ["apply", argv]
-          else [ argv.first, argv[1..-1] ]
+          when nil then
+            if stdin.tty? then
+              [nil, argv]       # ttys get usage info
+            else
+              # Killed for 2.7.0 --daniel 2011-06-01
+              warn_later <<EOM
+Implicit invocation of 'puppet apply' by redirection into 'puppet' is deprecated,
+and will be removed in the 2.8 series. Please invoke 'puppet apply' directly
+in the future.
+EOM
+              ["apply", argv]
+            end
+          when "--help", "-h" then
+            # help should give you usage, not the help for `puppet apply`
+            [nil, argv]
+          when /^-|\.pp$|\.rb$/ then
+            # Killed for 2.7.0 --daniel 2011-06-01
+            warn_later <<EOM
+Implicit invocation of 'puppet apply' by passing files (or flags) directly
+to 'puppet' is deprecated, and will be removed in the 2.8 series.  Please
+invoke 'puppet apply' directly in the future.
+EOM
+            ["apply", argv]
+          else
+            [argv.first, argv[1..-1]]
           end
         else
-          [ zero, argv ]
+          [zero, argv]
         end
       end
 
+      # So, this is more than a little bit of a horror.  You see, the process
+      # of bootstrapping Puppet is ... complex.  This file, like many of our
+      # early initialization files, has an incestuous relationship between the
+      # order of files loaded, code executed at load time, and code executed
+      # in other files at runtime.
+      #
+      # When we construct this object we have not yet actually loaded the
+      # global puppet object, so we can't use any methods in it.  That
+      # includes all the logging stuff, which is used by the deprecation
+      # warning subsystem.
+      #
+      # On the other hand, we can't just load the logging system, because that
+      # depends on the top level Puppet module being bootstrapped.  It doesn't
+      # actually load the stuff it uses, though, for hysterical raisins.
+      #
+      # Finally, we can't actually just load the top level Puppet module.
+      # This one is precious: it turns out that some of the code loaded in the
+      # top level Puppet module has a dependency on the run mode values.
+      #
+      # Run mode is set correctly *only* when the application is loaded, and
+      # if it is wrong when the top level code is brought in we end up with
+      # the wrong settings scattered through some of the defaults.
+      #
+      # Which means that we have a dependency cycle that runs:
+      # 1. The binary creates an instance of P::U::CL.
+      # 2. That identifies the application to load.
+      # 3. It does, then instantiates the application.
+      #    4. That sets the run-mode.
+      #    5. That then loads the top level Puppet module.
+      # 6. Finally, we get to where we can use the top level stuff
+      #
+      # So, essentially, we see a dependency between runtime code in this
+      # file, run-time code in the application, and load-time code in the top
+      # level module.
+      #
+      # Which leads me to our current horrible hack: we stash away the message
+      # we wanted to log about deprecation, then send it to our logging system
+      # once we have done enough bootstrapping that it will, y'know, actually
+      # work.
+      #
+      # I would have liked to fix this, but that is going to be a whole pile
+      # of work digging through and decrufting all the global state from the
+      # local state, and working out what depends on what else in the product.
+      #
+      # Oh, and we use a global because we have *two* instances of a P::U::CL
+      # object during the startup sequence.  I don't know why.
+      #
+      # Maybe, one day, when I am not behind a deadline to ship code.
+      # --daniel 2011-06-01
+      def warn_later(text)
+        return if $delayed_deprecation_warning_for_p_u_cl
+        $delayed_deprecation_warning_for_p_u_cl = text
+      end
     end
   end
 end
diff --git a/spec/lib/puppet/face/basetest.rb b/spec/lib/puppet/face/basetest.rb
index 9398f5b2d..e5c9a9dc5 100755
--- a/spec/lib/puppet/face/basetest.rb
+++ b/spec/lib/puppet/face/basetest.rb
@@ -1,41 +1,46 @@
 require 'puppet/face'
 
 Puppet::Face.define(:basetest, '0.0.1') do
   copyright "Puppet Labs", 2011
   license   "Apache 2 license; see COPYING"
   summary "This is just so tests don't fail"
 
   option "--[no-]boolean"
   option "--mandatory ARGUMENT"
 
   action :foo do
     option("--action")
     when_invoked do |*args| args.length end
   end
 
   action :return_true do
     summary "just returns true"
     when_invoked do |options| true end
   end
 
   action :return_false do
     summary "just returns false"
     when_invoked do |options| false end
   end
 
   action :return_nil do
     summary "just returns nil"
     when_invoked do |options| nil end
   end
 
   action :raise do
     summary "just raises an exception"
     when_invoked do |options| raise ArgumentError, "your failure" end
   end
 
   action :with_s_rendering_hook do
     summary "has a rendering hook for 's'"
     when_invoked do |options| "this is not the hook you are looking for" end
     when_rendering :s do |value| "you invoked the 's' rendering hook" end
   end
+
+  action :count_args do
+    summary "return the count of arguments given"
+    when_invoked do |*args| args.length - 1 end
+  end
 end
diff --git a/spec/shared_behaviours/documentation_on_faces.rb b/spec/shared_behaviours/documentation_on_faces.rb
index 1106d4cca..204b173a5 100644
--- a/spec/shared_behaviours/documentation_on_faces.rb
+++ b/spec/shared_behaviours/documentation_on_faces.rb
@@ -1,263 +1,263 @@
 # encoding: UTF-8
 shared_examples_for "documentation on faces" do
   defined?(Attrs) or
     Attrs = [:summary, :description, :examples, :short_description, :notes, :author]
 
   defined?(SingleLineAttrs) or
     SingleLineAttrs = [:summary, :author]
 
   # Simple, procedural tests that apply to a bunch of methods.
   Attrs.each do |attr|
     it "should accept a #{attr}" do
       expect { subject.send("#{attr}=", "hello") }.not_to raise_error
       subject.send(attr).should == "hello"
     end
 
     it "should accept a long (single line) value for #{attr}" do
       text = "I never know when to stop with the word banana" + ("na" * 1000)
       expect { subject.send("#{attr}=", text) }.to_not raise_error
       subject.send(attr).should == text
     end
   end
 
   Attrs.each do |getter|
     setter = "#{getter}=".to_sym
     context "#{getter}" do
       it "should strip leading whitespace on a single line" do
         subject.send(setter, "  death to whitespace")
         subject.send(getter).should == "death to whitespace"
       end
 
       it "should strip trailing whitespace on a single line" do
         subject.send(setter, "death to whitespace  ")
         subject.send(getter).should == "death to whitespace"
       end
 
       it "should strip whitespace at both ends at once" do
         subject.send(setter, "  death to whitespace  ")
         subject.send(getter).should == "death to whitespace"
       end
 
       multiline_text = "with\nnewlines"
       if SingleLineAttrs.include? getter then
         it "should not accept multiline values" do
           expect { subject.send(setter, multiline_text) }.
             to raise_error ArgumentError, /#{getter} should be a single line/
           subject.send(getter).should be_nil
         end
       else
         it "should accept multiline values" do
           expect { subject.send(setter, multiline_text) }.not_to raise_error
           subject.send(getter).should == multiline_text
         end
 
         [1, 2, 4, 7, 25].each do |length|
           context "#{length} chars indent" do
             indent = ' ' * length
 
             it "should strip leading whitespace on multiple lines" do
               text = "this\nis\the\final\outcome"
               subject.send(setter, text.gsub(/^/, indent))
               subject.send(getter).should == text
             end
 
             it "should not remove formatting whitespace, only global indent" do
               text = "this\n  is\n    the\n  ultimate\ntest\n"
               subject.send(setter, text.gsub(/^/, indent))
               subject.send(getter).should == text
             end
           end
         end
 
         it "should strip whitespace with a blank line" do
           subject.send(setter, "  this\n\n  should outdent\n")
           subject.send(getter).should == "this\n\nshould outdent\n"
         end
       end
     end
   end
 
   describe "#short_description" do
     it "should return the set value if set after description" do
       subject.description = "hello\ngoodbye"
       subject.short_description = "whatever"
       subject.short_description.should == "whatever"
     end
 
     it "should return the set value if set before description" do
       subject.short_description = "whatever"
       subject.description = "hello\ngoodbye"
       subject.short_description.should == "whatever"
     end
 
     it "should return nothing if not set and no description" do
       subject.short_description.should be_nil
     end
 
     it "should return the first paragraph of description if not set (where it is one line long)" do
       subject.description = "hello"
       subject.short_description.should == subject.description
     end
 
     it "should return the first paragraph of description if not set (where there is no paragraph break)" do
       subject.description = "hello\ngoodbye"
       subject.short_description.should == subject.description
     end
 
     it "should return the first paragraph of description if not set (where there is a paragraph break)" do
       subject.description = "hello\ngoodbye\n\nmore\ntext\nhere\n\nfinal\nparagraph"
       subject.short_description.should == "hello\ngoodbye"
     end
 
     it "should trim a very, very long first paragraph and add ellipsis" do
       line = "this is a very, very, very long long line full of text\n"
       subject.description = line * 20 + "\n\nwhatever, dude."
 
       subject.short_description.should == (line * 5).chomp + ' [...]'
     end
-    
+
     it "should trim a very very long only paragraph even if it is followed by a new paragraph" do
       line = "this is a very, very, very long long line full of text\n"
       subject.description = line * 20
-      
+
       subject.short_description.should == (line * 5).chomp + ' [...]'
     end
   end
 
   describe "multiple authors" do
     authors = %w{John Paul George Ringo}
 
     context "in the DSL" do
       it "should support multiple authors" do
 
         authors.each {|name| subject.author name }
         subject.authors.should =~ authors
 
         subject.author.should == authors.join("\n")
       end
 
       it "should reject author as an array" do
         expect { subject.author ["Foo", "Bar"] }.
           to raise_error ArgumentError, /author must be a string/
       end
     end
 
     context "#author=" do
       it "should accept a single name" do
         subject.author = "Fred"
         subject.author.should == "Fred"
       end
 
       it "should accept an array of names" do
         subject.author = authors
         subject.authors.should =~ authors
         subject.author.should == authors.join("\n")
       end
 
       it "should not append when set multiple times" do
         subject.author = "Fred"
         subject.author = "John"
         subject.author.should == "John"
       end
 
       it "should reject arrays with embedded newlines" do
         expect { subject.author = ["Fred\nJohn"] }.
           to raise_error ArgumentError, /author should be a single line/
       end
     end
   end
 
   describe "#license" do
     it "should default to reserving rights" do
       subject.license.should =~ /All Rights Reserved/
     end
 
     it "should accept an arbitrary license string on the object" do
       subject.license = "foo"
       subject.license.should == "foo"
     end
 
     it "should accept symbols to specify existing licenses..."
   end
 
   describe "#copyright" do
     it "should fail with just a name" do
       expect { subject.copyright("invalid") }.
         to raise_error ArgumentError, /copyright takes the owners names, then the years covered/
     end
 
     [1997, "1997"].each do |year|
       it "should accept an entity name and a #{year.class.name} year" do
         subject.copyright("me", year)
         subject.copyright.should =~ /\bme\b/
         subject.copyright.should =~ /#{year}/
       end
 
       it "should accept multiple entity names and a #{year.class.name} year" do
         subject.copyright ["me", "you"], year
         subject.copyright.should =~ /\bme\b/
         subject.copyright.should =~ /\byou\b/
         subject.copyright.should =~ /#{year}/
       end
     end
 
     ["1997-2003", "1997 - 2003", 1997..2003].each do |range|
       it "should accept a #{range.class.name} range of years" do
         subject.copyright("me", range)
         subject.copyright.should =~ /\bme\b/
         subject.copyright.should =~ /1997-2003/
       end
 
       it "should accept a #{range.class.name} range of years" do
         subject.copyright ["me", "you"], range
         subject.copyright.should =~ /\bme\b/
         subject.copyright.should =~ /\byou\b/
         subject.copyright.should =~ /1997-2003/
       end
     end
 
     [[1997, 2003], ["1997", 2003], ["1997", "2003"]].each do |input|
       it "should accept the set of years #{input.inspect} in an array" do
         subject.copyright "me", input
         subject.copyright.should =~ /\bme\b/
         subject.copyright.should =~ /1997, 2003/
       end
 
       it "should accept the set of years #{input.inspect} in an array" do
         subject.copyright ["me", "you"], input
         subject.copyright.should =~ /\bme\b/
         subject.copyright.should =~ /\byou\b/
         subject.copyright.should =~ /1997, 2003/
       end
     end
 
     it "should warn if someone does math accidentally on the range of years" do
       expect { subject.copyright "me", 1997-2003 }.
         to raise_error ArgumentError, /copyright with a year before 1970 is very strange; did you accidentally add or subtract two years\?/
     end
 
     it "should accept complex copyright years" do
       years = [1997, 1999, 2000..2002, 2005].reverse
       subject.copyright "me", years
       subject.copyright.should =~ /\bme\b/
       subject.copyright.should =~ /1997, 1999, 2000-2002, 2005/
     end
   end
 
   # Things that are automatically generated.
   [:name, :options, :synopsis].each do |attr|
     describe "##{attr}" do
       it "should not allow you to set #{attr}" do
         subject.should_not respond_to :"#{attr}="
       end
 
       it "should have a #{attr}" do
         subject.send(attr).should_not be_nil
       end
 
       it "'s #{attr} should not be empty..." do
         subject.send(attr).should_not == ''
       end
     end
   end
 end
diff --git a/spec/unit/application/face_base_spec.rb b/spec/unit/application/face_base_spec.rb
index 3318e061e..0a4a86be6 100755
--- a/spec/unit/application/face_base_spec.rb
+++ b/spec/unit/application/face_base_spec.rb
@@ -1,332 +1,360 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/application/face_base'
 require 'tmpdir'
 
 class Puppet::Application::FaceBase::Basetest < Puppet::Application::FaceBase
 end
 
 describe Puppet::Application::FaceBase do
   let :app do
     app = Puppet::Application::FaceBase::Basetest.new
     app.command_line.stubs(:subcommand_name).returns('subcommand')
     Puppet::Util::Log.stubs(:newdestination)
     app
   end
 
   describe "#find_global_settings_argument" do
     it "should not match --ca to --ca-location" do
       option = mock('ca option', :optparse_args => ["--ca"])
       Puppet.settings.expects(:each).yields(:ca, option)
 
       app.find_global_settings_argument("--ca-location").should be_nil
     end
   end
 
   describe "#parse_options" do
     before :each do
       app.command_line.stubs(:args).returns %w{}
     end
 
     describe "with just an action" do
       before :all do
         # We have to stub Signal.trap to avoid a crazy mess where we take
         # over signal handling and make it impossible to cancel the test
         # suite run.
         #
         # It would be nice to fix this elsewhere, but it is actually hard to
         # capture this in rspec 2.5 and all. :(  --daniel 2011-04-08
         Signal.stubs(:trap)
         app.command_line.stubs(:args).returns %w{foo}
         app.preinit
         app.parse_options
       end
 
       it "should set the face based on the type" do
         app.face.name.should == :basetest
       end
 
       it "should find the action" do
         app.action.should be
         app.action.name.should == :foo
       end
     end
 
+    it "should stop if the first thing found is not an action" do
+      app.command_line.stubs(:args).returns %w{banana count_args}
+      expect { app.run }.to exit_with 1
+      @logs.first.message.should =~ /has no 'banana' action/
+    end
+
     it "should use the default action if not given any arguments" do
       app.command_line.stubs(:args).returns []
       action = stub(:options => [], :render_as => nil)
       Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
       app.stubs(:main)
       app.run
       app.action.should == action
       app.arguments.should == [ { } ]
     end
 
     it "should use the default action if not given a valid one" do
       app.command_line.stubs(:args).returns %w{bar}
       action = stub(:options => [], :render_as => nil)
       Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
       app.stubs(:main)
       app.run
       app.action.should == action
       app.arguments.should == [ 'bar', { } ]
     end
 
     it "should have no action if not given a valid one and there is no default action" do
       app.command_line.stubs(:args).returns %w{bar}
       Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
       app.stubs(:main)
       expect { app.run }.to exit_with 1
-      @logs.first.message.should =~ /does not have a default action/
+      @logs.first.message.should =~ /has no 'bar' action./
+    end
+
+    [%w{something_I_cannot_do},
+     %w{something_I_cannot_do argument}].each do |input|
+      it "should report unknown actions nicely" do
+        app.command_line.stubs(:args).returns input
+        Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
+        app.stubs(:main)
+        expect { app.run }.to exit_with 1
+        @logs.first.message.should =~ /has no 'something_I_cannot_do' action/
+      end
+    end
+
+    [%w{something_I_cannot_do --unknown-option},
+     %w{something_I_cannot_do argument --unknown-option}].each do |input|
+      it "should report unknown actions even if there are unknown options" do
+        app.command_line.stubs(:args).returns input
+        Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
+        app.stubs(:main)
+        expect { app.run }.to exit_with 1
+        @logs.first.message.should =~ /has no 'something_I_cannot_do' action/
+      end
     end
 
     it "should report a sensible error when options with = fail" do
       app.command_line.stubs(:args).returns %w{--action=bar foo}
       expect { app.preinit; app.parse_options }.
         to raise_error OptionParser::InvalidOption, /invalid option: --action/
     end
 
     it "should fail if an action option is before the action" do
       app.command_line.stubs(:args).returns %w{--action foo}
       expect { app.preinit; app.parse_options }.
         to raise_error OptionParser::InvalidOption, /invalid option: --action/
     end
 
     it "should fail if an unknown option is before the action" do
       app.command_line.stubs(:args).returns %w{--bar foo}
       expect { app.preinit; app.parse_options }.
         to raise_error OptionParser::InvalidOption, /invalid option: --bar/
     end
 
     it "should fail if an unknown option is after the action" do
       app.command_line.stubs(:args).returns %w{foo --bar}
       expect { app.preinit; app.parse_options }.
         to raise_error OptionParser::InvalidOption, /invalid option: --bar/
     end
 
     it "should accept --bar as an argument to a mandatory option after action" do
       app.command_line.stubs(:args).returns %w{foo --mandatory --bar}
       app.preinit
       app.parse_options
       app.action.name.should == :foo
       app.options.should == { :mandatory => "--bar" }
     end
 
     it "should accept --bar as an argument to a mandatory option before action" do
       app.command_line.stubs(:args).returns %w{--mandatory --bar foo}
       app.preinit
       app.parse_options
       app.action.name.should == :foo
       app.options.should == { :mandatory => "--bar" }
     end
 
     it "should not skip when --foo=bar is given" do
       app.command_line.stubs(:args).returns %w{--mandatory=bar --bar foo}
       expect { app.preinit; app.parse_options }.
         to raise_error OptionParser::InvalidOption, /invalid option: --bar/
     end
 
     { "boolean options before" => %w{--trace foo},
       "boolean options after"  => %w{foo --trace}
     }.each do |name, args|
       it "should accept global boolean settings #{name} the action" do
         app.command_line.stubs(:args).returns args
         app.preinit
         app.parse_options
         Puppet[:trace].should be_true
       end
     end
 
     { "before" => %w{--syslogfacility user1 foo},
       " after" => %w{foo --syslogfacility user1}
     }.each do |name, args|
       it "should accept global settings with arguments #{name} the action" do
         app.command_line.stubs(:args).returns args
         app.preinit
         app.parse_options
         Puppet[:syslogfacility].should == "user1"
       end
     end
 
     it "should handle application-level options", :'fails_on_ruby_1.9.2' => true do
-      app.command_line.stubs(:args).returns %w{basetest --verbose return_true}
+      app.command_line.stubs(:args).returns %w{--verbose return_true}
       app.preinit
       app.parse_options
       app.face.name.should == :basetest
     end
   end
 
   describe "#setup" do
     it "should remove the action name from the arguments" do
       app.command_line.stubs(:args).returns %w{--mandatory --bar foo}
       app.preinit
       app.parse_options
       app.setup
       app.arguments.should == [{ :mandatory => "--bar" }]
     end
 
     it "should pass positional arguments" do
       app.command_line.stubs(:args).returns %w{--mandatory --bar foo bar baz quux}
       app.preinit
       app.parse_options
       app.setup
       app.arguments.should == ['bar', 'baz', 'quux', { :mandatory => "--bar" }]
     end
   end
 
   describe "#main" do
     before :each do
       app.stubs(:puts)          # don't dump text to screen.
 
       app.face      = Puppet::Face[:basetest, '0.0.1']
       app.action    = app.face.get_action(:foo)
       app.arguments = ["myname", "myarg"]
     end
 
     it "should send the specified verb and name to the face" do
       app.face.expects(:foo).with(*app.arguments)
       expect { app.main }.to exit_with 0
     end
 
     it "should lookup help when it cannot do anything else" do
       app.action = nil
       Puppet::Face[:help, :current].expects(:help).with(:basetest)
       expect { app.main }.to exit_with 1
     end
 
     it "should use its render method to render any result" do
       app.expects(:render).with(app.arguments.length + 1)
       expect { app.main }.to exit_with 0
     end
   end
 
   describe "error reporting" do
     before :each do
       app.stubs(:puts)          # don't dump text to screen.
 
       app.render_as = :json
       app.face      = Puppet::Face[:basetest, '0.0.1']
       app.arguments = [{}]      # we always have options in there...
     end
 
     it "should exit 0 when the action returns true" do
       app.action    = app.face.get_action :return_true
       expect { app.main }.to exit_with 0
     end
 
     it "should exit 0 when the action returns false" do
       app.action = app.face.get_action :return_false
       expect { app.main }.to exit_with 0
     end
 
     it "should exit 0 when the action returns nil" do
       app.action = app.face.get_action :return_nil
       expect { app.main }.to exit_with 0
     end
 
     it "should exit non-0 when the action raises" do
       app.action = app.face.get_action :return_raise
       expect { app.main }.not_to exit_with 0
     end
   end
 
   describe "#render" do
     before :each do
       app.face      = Puppet::Face[:basetest, '0.0.1']
       app.action    = app.face.get_action(:foo)
     end
 
     context "default rendering" do
       before :each do app.setup end
 
       ["hello", 1, 1.0].each do |input|
         it "should just return a #{input.class.name}" do
           app.render(input).should == input
         end
       end
 
       [[1, 2], ["one"], [{ 1 => 1 }]].each do |input|
         it "should render #{input.class} using JSON" do
           app.render(input).should == input.to_pson.chomp
         end
       end
 
       it "should render a non-trivially-keyed Hash with using JSON" do
         hash = { [1,2] => 3, [2,3] => 5, [3,4] => 7 }
         app.render(hash).should == hash.to_pson.chomp
       end
 
       it "should render a {String,Numeric}-keyed Hash into a table" do
         object = Object.new
         hash = { "one" => 1, "two" => [], "three" => {}, "four" => object,
           5 => 5, 6.0 => 6 }
 
         # Gotta love ASCII-betical sort order.  Hope your objects are better
         # structured for display than my test one is. --daniel 2011-04-18
         app.render(hash).should == <<EOT
 5      5
 6.0    6
 four   #{object.to_pson.chomp}
 one    1
 three  {}
 two    []
 EOT
       end
 
       it "should render a hash nicely with a multi-line value" do
         pending "Moving to PSON rather than PP makes this unsupportable."
         hash = {
           "number" => { "1" => '1' * 40, "2" => '2' * 40, '3' => '3' * 40 },
           "text"   => { "a" => 'a' * 40, 'b' => 'b' * 40, 'c' => 'c' * 40 }
         }
         app.render(hash).should == <<EOT
 number  {"1"=>"1111111111111111111111111111111111111111",
          "2"=>"2222222222222222222222222222222222222222",
          "3"=>"3333333333333333333333333333333333333333"}
 text    {"a"=>"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
          "b"=>"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
          "c"=>"cccccccccccccccccccccccccccccccccccccccc"}
 EOT
       end
 
       it "should invoke the action rendering hook while rendering" do
         app.action.set_rendering_method_for(:console, proc { |value| "bi-winning!" })
         app.render("bi-polar?").should == "bi-winning!"
       end
 
       it "should render JSON when asked for json" do
         app.render_as = :json
         json = app.render({ :one => 1, :two => 2 })
         json.should =~ /"one":\s*1\b/
         json.should =~ /"two":\s*2\b/
         PSON.parse(json).should == { "one" => 1, "two" => 2 }
       end
     end
 
     it "should fail early if asked to render an invalid format" do
-      app.command_line.stubs(:args).returns %w{--render-as interpretive-dance help help}
+      app.command_line.stubs(:args).returns %w{--render-as interpretive-dance return_true}
       # We shouldn't get here, thanks to the exception, and our expectation on
       # it, but this helps us fail if that slips up and all. --daniel 2011-04-27
       Puppet::Face[:help, :current].expects(:help).never
 
       expect {
         expect { app.run }.to exit_with 1
       }.to have_printed(/I don't know how to render 'interpretive-dance'/)
     end
 
     it "should work if asked to render a NetworkHandler format" do
-      app.command_line.stubs(:args).returns %w{dummy find dummy --render-as yaml}
+      app.command_line.stubs(:args).returns %w{count_args a b c --render-as yaml}
       expect {
         expect { app.run }.to exit_with 0
       }.to have_printed(/--- 3/)
     end
 
     it "should invoke when_rendering hook 's' when asked to render-as 's'" do
       app.command_line.stubs(:args).returns %w{with_s_rendering_hook --render-as s}
       app.action = app.face.get_action(:with_s_rendering_hook)
       expect {
         expect { app.run }.to exit_with 0
       }.to have_printed(/you invoked the 's' rendering hook/)
     end
   end
 end
diff --git a/spec/unit/application/faces_spec.rb b/spec/unit/application/faces_spec.rb
deleted file mode 100755
index cc159b6a5..000000000
--- a/spec/unit/application/faces_spec.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/usr/bin/env rspec
-require 'spec_helper'
-require 'puppet/application/faces'
-
-describe Puppet::Application::Faces do
-  it "should be an application" do
-    Puppet::Application::Faces.superclass.should equal(Puppet::Application)
-  end
-
-  it "should always call 'list'" do
-    subject.expects(:list)
-    subject.main
-  end
-end
diff --git a/spec/unit/interface/action_manager_spec.rb b/spec/unit/interface/action_manager_spec.rb
index e357a5fa1..3a84e4f83 100755
--- a/spec/unit/interface/action_manager_spec.rb
+++ b/spec/unit/interface/action_manager_spec.rb
@@ -1,256 +1,282 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 # This is entirely an internal class for Interface, so we have to load it instead of our class.
 require 'puppet/interface'
 require 'puppet/face'
 
 class ActionManagerTester
   include Puppet::Interface::ActionManager
 end
 
 describe Puppet::Interface::ActionManager do
   subject { ActionManagerTester.new }
 
   describe "when included in a class" do
     it "should be able to define an action" do
       subject.action(:foo) do
         when_invoked { |options| "something "}
       end
     end
 
     it "should be able to define a 'script' style action" do
       subject.script :bar do |options|
         "a bar is where beer is found"
       end
     end
 
     it "should be able to list defined actions" do
       subject.action(:foo) do
         when_invoked { |options| "something" }
       end
       subject.action(:bar) do
         when_invoked { |options| "something" }
       end
 
       subject.actions.should =~ [:foo, :bar]
     end
 
     it "should list 'script' actions" do
       subject.script :foo do |options| "foo" end
       subject.actions.should =~ [:foo]
     end
 
     it "should list both script and normal actions" do
       subject.action :foo do
         when_invoked do |options| "foo" end
       end
       subject.script :bar do |options| "a bar is where beer is found" end
 
       subject.actions.should =~ [:foo, :bar]
     end
 
     it "should be able to indicate when an action is defined" do
       subject.action(:foo) do
         when_invoked { |options| "something" }
       end
 
       subject.should be_action(:foo)
     end
 
     it "should indicate an action is defined for script actions" do
       subject.script :foo do |options| "foo" end
       subject.should be_action :foo
     end
 
     it "should correctly treat action names specified as strings" do
       subject.action(:foo) do
         when_invoked { |options| "something" }
       end
 
       subject.should be_action("foo")
     end
   end
 
   describe "when used to extend a class" do
     subject { Class.new.extend(Puppet::Interface::ActionManager) }
 
     it "should be able to define an action" do
       subject.action(:foo) do
         when_invoked { |options| "something "}
       end
     end
 
     it "should be able to list defined actions" do
       subject.action(:foo) do
         when_invoked { |options| "something" }
       end
       subject.action(:bar) do
         when_invoked { |options| "something" }
       end
 
       subject.actions.should include(:bar)
       subject.actions.should include(:foo)
     end
 
     it "should be able to indicate when an action is defined" do
       subject.action(:foo) { when_invoked do |options| true end }
       subject.should be_action(:foo)
     end
   end
 
   describe "when used both at the class and instance level" do
     before do
       @klass = Class.new do
         include Puppet::Interface::ActionManager
         extend Puppet::Interface::ActionManager
         def __invoke_decorations(*args) true end
         def options() [] end
       end
       @instance = @klass.new
     end
 
     it "should be able to define an action at the class level" do
       @klass.action(:foo) do
         when_invoked { |options| "something "}
       end
     end
 
     it "should create an instance method when an action is defined at the class level" do
       @klass.action(:foo) do
         when_invoked { |options| "something" }
       end
       @instance.foo.should == "something"
     end
 
     it "should be able to define an action at the instance level" do
       @instance.action(:foo) do
         when_invoked { |options| "something "}
       end
     end
 
     it "should create an instance method when an action is defined at the instance level" do
       @instance.action(:foo) do
         when_invoked { |options| "something" }
       end
       @instance.foo.should == "something"
     end
 
     it "should be able to list actions defined at the class level" do
       @klass.action(:foo) do
         when_invoked { |options| "something" }
       end
       @klass.action(:bar) do
         when_invoked { |options| "something" }
       end
 
       @klass.actions.should include(:bar)
       @klass.actions.should include(:foo)
     end
 
     it "should be able to list actions defined at the instance level" do
       @instance.action(:foo) do
         when_invoked { |options| "something" }
       end
       @instance.action(:bar) do
         when_invoked { |options| "something" }
       end
 
       @instance.actions.should include(:bar)
       @instance.actions.should include(:foo)
     end
 
     it "should be able to list actions defined at both instance and class level" do
       @klass.action(:foo) do
         when_invoked { |options| "something" }
       end
       @instance.action(:bar) do
         when_invoked { |options| "something" }
       end
 
       @instance.actions.should include(:bar)
       @instance.actions.should include(:foo)
     end
 
     it "should be able to indicate when an action is defined at the class level" do
       @klass.action(:foo) do
         when_invoked { |options| "something" }
       end
       @instance.should be_action(:foo)
     end
 
     it "should be able to indicate when an action is defined at the instance level" do
       @klass.action(:foo) do
         when_invoked { |options| "something" }
       end
       @instance.should be_action(:foo)
     end
 
-    it "should list actions defined in superclasses" do
-      @subclass = Class.new(@klass)
-      @instance = @subclass.new
+    context "with actions defined in superclass" do
+      before :each do
+        @subclass = Class.new(@klass)
+        @instance = @subclass.new
+
+        @klass.action(:parent) do
+          when_invoked { |options| "a" }
+        end
+        @subclass.action(:sub) do
+          when_invoked { |options| "a" }
+        end
+        @instance.action(:instance) do
+          when_invoked { |options| "a" }
+        end
+      end
+
+      it "should list actions defined in superclasses" do
+        @instance.should be_action(:parent)
+        @instance.should be_action(:sub)
+        @instance.should be_action(:instance)
+      end
 
-      @klass.action(:parent) do
-        when_invoked { |options| "a" }
+      it "should list inherited actions" do
+        @instance.actions.should =~ [:instance, :parent, :sub]
       end
-      @subclass.action(:sub) do
-        when_invoked { |options| "a" }
+
+      it "should not duplicate instance actions after fetching them (#7699)" do
+        @instance.actions.should =~ [:instance, :parent, :sub]
+        @instance.get_action(:instance)
+        @instance.actions.should =~ [:instance, :parent, :sub]
       end
-      @instance.action(:instance) do
-        when_invoked { |options| "a" }
+
+      it "should not duplicate subclass actions after fetching them (#7699)" do
+        @instance.actions.should =~ [:instance, :parent, :sub]
+        @instance.get_action(:sub)
+        @instance.actions.should =~ [:instance, :parent, :sub]
       end
 
-      @instance.should be_action(:parent)
-      @instance.should be_action(:sub)
-      @instance.should be_action(:instance)
+      it "should not duplicate superclass actions after fetching them (#7699)" do
+        @instance.actions.should =~ [:instance, :parent, :sub]
+        @instance.get_action(:parent)
+        @instance.actions.should =~ [:instance, :parent, :sub]
+      end
     end
 
     it "should create an instance method when an action is defined in a superclass" do
       @subclass = Class.new(@klass)
       @instance = @subclass.new
 
       @klass.action(:foo) do
         when_invoked { |options| "something" }
       end
       @instance.foo.should == "something"
     end
   end
 
   describe "#action" do
     it 'should add an action' do
       subject.action(:foo) { when_invoked do |options| true end }
       subject.get_action(:foo).should be_a Puppet::Interface::Action
     end
 
     it 'should support default actions' do
       subject.action(:foo) { when_invoked do |options| true end; default }
       subject.get_default_action.should == subject.get_action(:foo)
     end
 
     it 'should not support more than one default action' do
       subject.action(:foo) { when_invoked do |options| true end; default }
       expect { subject.action(:bar) {
           when_invoked do |options| true end
           default
         }
       }.should raise_error /cannot both be default/
     end
   end
 
   describe "#get_action" do
     let :parent_class do
       parent_class = Class.new(Puppet::Interface)
       parent_class.action(:foo) { when_invoked do |options| true end }
       parent_class
     end
 
     it "should check that we can find inherited actions when we are a class" do
       Class.new(parent_class).get_action(:foo).name.should == :foo
     end
 
     it "should check that we can find inherited actions when we are an instance" do
       instance = parent_class.new(:foo, '0.0.0')
       instance.get_action(:foo).name.should == :foo
     end
   end
 end