puppet 0.25.5 → 2.6.0

data/lib/puppet/agent/locker.rb

@@ -3,40 +3,38 @@ require 'puppet/util/pidlock'
 # Break out the code related to locking the agent.  This module is just
 # included into the agent, but having it here makes it easier to test.
 module Puppet::Agent::Locker
-    # Let the daemon run again, freely in the filesystem.
-    def enable
-        lockfile.unlock(:anonymous => true)
-    end
+  # Let the daemon run again, freely in the filesystem.
+  def enable
+    lockfile.unlock(:anonymous => true)
+  end
 
-    # Stop the daemon from making any catalog runs.
-    def disable
-        lockfile.lock(:anonymous => true)
-    end
+  # Stop the daemon from making any catalog runs.
+  def disable
+    lockfile.lock(:anonymous => true)
+  end
 
-    # Yield if we get a lock, else do nothing.  Return
-    # true/false depending on whether we get the lock.
-    def lock
-        if lockfile.lock
-            begin
-                yield
-            ensure
-                lockfile.unlock
-            end
-            return true
-        else
-            return false
-        end
+  # Yield if we get a lock, else do nothing.  Return
+  # true/false depending on whether we get the lock.
+  def lock
+    if lockfile.lock
+      begin
+        yield
+      ensure
+        lockfile.unlock
+      end
+      return true
+    else
+      return false
     end
+  end
 
-    def lockfile
-        unless defined?(@lockfile)
-            @lockfile = Puppet::Util::Pidlock.new(lockfile_path)
-        end
+  def lockfile
+    @lockfile ||= Puppet::Util::Pidlock.new(lockfile_path)
 
-        @lockfile
-    end
+    @lockfile
+  end
 
-    def running?
-        lockfile.locked?
-    end
+  def running?
+    lockfile.locked?
+  end
 end

data/lib/puppet/application.rb

@@ -1,32 +1,34 @@
-require 'puppet'
 require 'optparse'
 
 # This class handles all the aspects of a Puppet application/executable
 # * setting up options
 # * setting up logs
 # * choosing what to run
+# * representing execution status
 #
 # === Usage
-# The application is a Puppet::Application object that register itself in the list
-# of available application. Each application needs a +name+ and a getopt +options+
-# description array.
+# An application is a subclass of Puppet::Application.
 #
-# The executable uses the application object like this:
+# For legacy compatibility,
 #      Puppet::Application[:example].run
+# is equivalent to
+#      Puppet::Application::Example.new.run
 #
 #
-# Puppet::Application.new(:example) do
+# class Puppet::Application::Example << Puppet::Application
 #
-#     preinit do
+#     def preinit
 #         # perform some pre initialization
 #         @all = false
 #     end
 #
-#     # dispatch is called to know to what command to call
-#     dispatch do
-#         ARGV.shift
+#     # run_command is called to actually run the specified command
+#     def run_command
+#         send Puppet::Util::CommandLine.new.args.shift
 #     end
 #
+#     # option uses metaprogramming to create a method
+#     # and also tells the option parser how to invoke that method
 #     option("--arg ARGUMENT") do |v|
 #         @args << v
 #     end
@@ -39,18 +41,18 @@ require 'optparse'
 #         @all = v
 #     end
 #
-#     unknown do |opt,arg|
+#     def handle_unknown(opt,arg)
 #         # last chance to manage an option
 #         ...
 #         # let's say to the framework we finally handle this option
 #         true
 #     end
 #
-#     command(:read) do
+#     def read
 #         # read action
 #     end
 #
-#     command(:write) do
+#     def write
 #         # writeaction
 #     end
 #
@@ -86,228 +88,318 @@ require 'optparse'
 # to be run.
 # If it doesn't exist, it defaults to execute the +main+ command if defined.
 #
-class Puppet::Application
+# === Execution state
+# The class attributes/methods of Puppet::Application serve as a global place to set and query the execution
+# status of the application: stopping, restarting, etc.  The setting of the application status does not directly
+# aftect its running status; it's assumed that the various components within the application will consult these
+# settings appropriately and affect their own processing accordingly.  Control operations (signal handlers and
+# the like) should set the status appropriately to indicate to the overall system that it's the process of
+# stopping or restarting (or just running as usual).
+#
+# So, if something in your application needs to stop the process, for some reason, you might consider:
+#
+#  def stop_me!
+#      # indicate that we're stopping
+#      Puppet::Application.stop!
+#      # ...do stuff...
+#  end
+#
+# And, if you have some component that involves a long-running process, you might want to consider:
+#
+#  def my_long_process(giant_list_to_munge)
+#      giant_list_to_munge.collect do |member|
+#          # bail if we're stopping
+#          return if Puppet::Application.stop_requested?
+#          process_member(member)
+#      end
+#  end
+module Puppet
+class Application
+  require 'puppet/util'
+  include Puppet::Util
+
+  DOCPATTERN = File.expand_path(File.dirname(__FILE__) + "/util/command_line/*" )
+
+  class << self
     include Puppet::Util
 
-    @@applications = {}
-    class << self
-        include Puppet::Util
-    end
+    attr_accessor :run_status
 
-    attr_reader :options, :opt_parser
+    def clear!
+      self.run_status = nil
+    end
 
-    def self.[](name)
-        name = symbolize(name)
-        @@applications[name]
+    def stop!
+      self.run_status = :stop_requested
     end
 
-    def should_parse_config
-        @parse_config = true
+    def restart!
+      self.run_status = :restart_requested
     end
 
-    def should_not_parse_config
-        @parse_config = false
+    # Indicates that Puppet::Application.restart! has been invoked and components should
+    # do what is necessary to facilitate a restart.
+    def restart_requested?
+      :restart_requested == run_status
     end
 
-    def should_parse_config?
-        unless @parse_config.nil?
-            return @parse_config
-        end
-        @parse_config = true
+    # Indicates that Puppet::Application.stop! has been invoked and components should do what is necessary
+    # for a clean stop.
+    def stop_requested?
+      :stop_requested == run_status
     end
 
-    # used to declare a new command
-    def command(name, &block)
-        meta_def(symbolize(name), &block)
+    # Indicates that one of stop! or start! was invoked on Puppet::Application, and some kind of process
+    # shutdown/short-circuit may be necessary.
+    def interrupted?
+      [:restart_requested, :stop_requested].include? run_status
     end
 
-    # used as a catch-all for unknown option
-    def unknown(&block)
-        meta_def(:handle_unknown, &block)
+    # Indicates that Puppet::Application believes that it's in usual running run_mode (no stop/restart request
+    # currently active).
+    def clear?
+      run_status.nil?
     end
 
-    # used to declare code that handle an option
-    def option(*options, &block)
-        long = options.find { |opt| opt =~ /^--/ }.gsub(/^--(?:\[no-\])?([^ =]+).*$/, '\1' ).gsub('-','_')
-        fname = "handle_#{long}"
-        if (block_given?)
-            meta_def(symbolize(fname), &block)
-        else
-            meta_def(symbolize(fname)) do |value|
-                self.options["#{long}".to_sym] = value
-            end
-        end
-        @opt_parser.on(*options) do |value|
-            self.send(symbolize(fname), value)
-        end
+    # Only executes the given block if the run status of Puppet::Application is clear (no restarts, stops,
+    # etc. requested).
+    # Upon block execution, checks the run status again; if a restart has been requested during the block's
+    # execution, then controlled_run will send a new HUP signal to the current process.
+    # Thus, long-running background processes can potentially finish their work before a restart.
+    def controlled_run(&block)
+      return unless clear?
+      result = block.call
+      Process.kill(:HUP, $PID) if restart_requested?
+      result
     end
 
-    # used to declare accessor in a more natural way in the
-    # various applications
-    def attr_accessor(*args)
-        args.each do |arg|
-            meta_def(arg) do
-                instance_variable_get("@#{arg}".to_sym)
-            end
-            meta_def("#{arg}=") do |value|
-                instance_variable_set("@#{arg}".to_sym, value)
-            end
-        end
+    def should_parse_config
+      @parse_config = true
     end
 
-    # used to declare code run instead the default setup
-    def setup(&block)
-        meta_def(:run_setup, &block)
+    def should_not_parse_config
+      @parse_config = false
     end
 
-    # used to declare code to choose which command to run
-    def dispatch(&block)
-        meta_def(:get_command, &block)
+    def should_parse_config?
+      @parse_config = true if ! defined?(@parse_config)
+      @parse_config
     end
 
-    # used to execute code before running anything else
-    def preinit(&block)
-        meta_def(:run_preinit, &block)
+    # used to declare code that handle an option
+    def option(*options, &block)
+      long = options.find { |opt| opt =~ /^--/ }.gsub(/^--(?:\[no-\])?([^ =]+).*$/, '\1' ).gsub('-','_')
+      fname = symbolize("handle_#{long}")
+      if (block_given?)
+        define_method(fname, &block)
+      else
+        define_method(fname) do |value|
+          self.options["#{long}".to_sym] = value
+        end
+      end
+      self.option_parser_commands << [options, fname]
     end
 
-    def initialize(name, banner = nil, &block)
-        @opt_parser = OptionParser.new(banner)
+    def banner(banner = nil)
+      @banner ||= banner
+    end
 
-        name = symbolize(name)
+    def option_parser_commands
+      @option_parser_commands ||= (
+        superclass.respond_to?(:option_parser_commands) ? superclass.option_parser_commands.dup : []
+      )
+      @option_parser_commands
+    end
 
-        init_default
+    def find(name)
+        self.const_get(name.to_s.capitalize)
+    rescue
+        puts "Unable to find application '#{name.to_s}'."
+        Kernel::exit(1)
+    end
 
-        @options = {}
+    def [](name)
+      find(name).new
+    end
 
-        instance_eval(&block) if block_given?
+    # Sets or gets the run_mode name. Sets the run_mode name if a mode_name is
+    # passed. Otherwise, gets the run_mode or a default run_mode
+    #
+    def run_mode( mode_name = nil)
+      return @run_mode if @run_mode and not mode_name
 
-        @@applications[name] = self
+      require 'puppet/util/run_mode'
+      @run_mode = Puppet::Util::RunMode[ mode_name || :user ]
     end
+  end
 
-    # initialize default application behaviour
-    def init_default
-        setup do
-            default_setup
-        end
+  attr_reader :options, :command_line
 
-        dispatch do
-            :main
-        end
+  # Every app responds to --version
+  option("--version", "-V") do |arg|
+    puts "#{Puppet.version}"
+    exit
+  end
 
-        # empty by default
-        preinit do
-        end
+  # Every app responds to --help
+  option("--help", "-h") do |v|
+    help
+  end
 
-        option("--version", "-V") do |arg|
-            puts "%s" % Puppet.version
-            exit
-        end
+  def should_parse_config?
+    self.class.should_parse_config?
+  end
 
-        option("--help", "-h") do |v|
-            help
-        end
-    end
+  # override to execute code before running anything else
+  def preinit
+  end
 
-    # This is the main application entry point
-    def run
-        exit_on_fail("initialize") { run_preinit }
-        exit_on_fail("parse options") { parse_options }
-        exit_on_fail("parse configuration file") { Puppet.settings.parse } if should_parse_config?
-        exit_on_fail("prepare for execution") { run_setup }
-        exit_on_fail("run") { run_command }
-    end
+  def option_parser
+    return @option_parser if defined?(@option_parser)
 
-    def main
-        raise NotImplementedError, "No valid command or main"
-    end
+    @option_parser = OptionParser.new(self.class.banner)
 
-    def run_command
-        if command = get_command() and respond_to?(command)
-            send(command)
-        else
-            main
-        end
+    self.class.option_parser_commands.each do |options, fname|
+      @option_parser.on(*options) do |value|
+        self.send(fname, value)
+      end
+    end
+    @option_parser.default_argv = self.command_line.args
+    @option_parser
+  end
+
+  def initialize(command_line = nil)
+    require 'puppet/util/command_line'
+    @command_line = command_line || Puppet::Util::CommandLine.new
+    @run_mode = self.class.run_mode
+    @options = {}
+
+    $puppet_application_mode = @run_mode
+    $puppet_application_name = name
+
+    if Puppet.respond_to? :settings
+      # This is to reduce the amount of confusion in rspec
+      # because it might have loaded defaults.rb before the globals were set
+      # and thus have the wrong defaults for the current application
+      Puppet.settings.set_value(:confdir, Puppet.run_mode.conf_dir, :mutable_defaults)
+      Puppet.settings.set_value(:vardir, Puppet.run_mode.var_dir, :mutable_defaults)
+      Puppet.settings.set_value(:name, Puppet.application_name.to_s, :mutable_defaults)
+      Puppet.settings.set_value(:logdir, Puppet.run_mode.logopts, :mutable_defaults)
+      Puppet.settings.set_value(:rundir, Puppet.run_mode.run_dir, :mutable_defaults)
+      Puppet.settings.set_value(:mode, Puppet.run_mode.name.to_s, :mutable_defaults)
     end
 
-    def default_setup
-        # Handle the logging settings
-        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
-
-        unless options[:setdest]
-            Puppet::Util::Log.newdestination(:syslog)
-        end
+    require 'puppet'
+  end
+
+  # This is the main application entry point
+  def run
+    exit_on_fail("initialize") { preinit }
+    exit_on_fail("parse options") { parse_options }
+    exit_on_fail("parse configuration file") { Puppet.settings.parse } if should_parse_config?
+    exit_on_fail("prepare for execution") { setup }
+    exit_on_fail("run") { run_command }
+  end
+
+  def main
+    raise NotImplementedError, "No valid command or main"
+  end
+
+  def run_command
+    main
+  end
+
+  def setup
+    # Handle the logging settings
+    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
 
-    def parse_options
-        # get all puppet options
-        optparse_opt = []
-        optparse_opt = Puppet.settings.optparse_addargs(optparse_opt)
+    Puppet::Util::Log.newdestination(:syslog) unless options[:setdest]
+  end
 
-        # convert them to OptionParser format
-        optparse_opt.each do |option|
-            @opt_parser.on(*option) do |arg|
-                handlearg(option[0], arg)
-            end
-        end
+  def parse_options
+    # get all puppet options
+    optparse_opt = []
+    optparse_opt = Puppet.settings.optparse_addargs(optparse_opt)
 
-        # scan command line argument
-        begin
-            @opt_parser.parse!
-        rescue OptionParser::ParseError => detail
-            $stderr.puts detail
-            $stderr.puts "Try '#{$0} --help'"
-            exit(1)
-        end
+    # convert them to OptionParser format
+    optparse_opt.each do |option|
+      self.option_parser.on(*option) do |arg|
+        handlearg(option[0], arg)
+      end
     end
 
-    def handlearg(opt, arg)
-        # rewrite --[no-]option to --no-option if that's what was given
-        if opt =~ /\[no-\]/ and !arg
-            opt = opt.gsub(/\[no-\]/,'no-')
-        end
-        # otherwise remove the [no-] prefix to not confuse everybody
-        opt = opt.gsub(/\[no-\]/, '')
-        unless respond_to?(:handle_unknown) and send(:handle_unknown, opt, arg)
-            # Puppet.settings.handlearg doesn't handle direct true/false :-)
-            if arg.is_a?(FalseClass)
-                arg = "false"
-            elsif arg.is_a?(TrueClass)
-                arg = "true"
-            end
-            Puppet.settings.handlearg(opt, arg)
-        end
+    # scan command line argument
+    begin
+      self.option_parser.parse!
+    rescue OptionParser::ParseError => detail
+      $stderr.puts detail
+      $stderr.puts "Try 'puppet #{command_line.subcommand_name} --help'"
+      exit(1)
     end
+  end
 
-    # this is used for testing
-    def self.exit(code)
-        exit(code)
+  def handlearg(opt, arg)
+    # rewrite --[no-]option to --no-option if that's what was given
+    if opt =~ /\[no-\]/ and !arg
+      opt = opt.gsub(/\[no-\]/,'no-')
     end
-
-    def help
-        if Puppet.features.usage?
-            ::RDoc::usage && exit
-        else
-            puts "No help available unless you have RDoc::usage installed"
-            exit
-        end
+    # otherwise remove the [no-] prefix to not confuse everybody
+    opt = opt.gsub(/\[no-\]/, '')
+    unless respond_to?(:handle_unknown) and send(:handle_unknown, opt, arg)
+      # Puppet.settings.handlearg doesn't handle direct true/false :-)
+      if arg.is_a?(FalseClass)
+        arg = "false"
+      elsif arg.is_a?(TrueClass)
+        arg = "true"
+      end
+      Puppet.settings.handlearg(opt, arg)
     end
-
-    private
-
-    def exit_on_fail(message, code = 1)
-        begin
-            yield
-        rescue RuntimeError, NotImplementedError => detail
-            puts detail.backtrace if Puppet[:trace]
-            $stderr.puts "Could not %s: %s" % [message, detail]
-            exit(code)
-        end
+  end
+
+  # this is used for testing
+  def self.exit(code)
+    exit(code)
+  end
+
+  def name
+    self.class.to_s.sub(/.*::/,"").downcase.to_sym
+  end
+
+  def help
+    if Puppet.features.usage?
+      # RH:FIXME: My goodness, this is ugly.
+      ::RDoc.const_set("PuppetSourceFile", name)
+      #:stopdoc: # Issue #4161
+      def (::RDoc).caller
+        docfile = `grep -l 'Puppet::Application\\[:#{::RDoc::PuppetSourceFile}\\]' #{DOCPATTERN}`.chomp
+        super << "#{docfile}:0"
+      end
+      #:startdoc:
+      ::RDoc::usage && exit
+    else
+      puts "No help available unless you have RDoc::usage installed"
+      exit
     end
+  rescue Errno::ENOENT
+    puts "No help available for puppet #{name}"
+    exit
+  end
+
+  private
+
+  def exit_on_fail(message, code = 1)
+      yield
+  rescue RuntimeError, NotImplementedError => detail
+      puts detail.backtrace if Puppet[:trace]
+      $stderr.puts "Could not #{message}: #{detail}"
+      exit(code)
+  end
+end
 end