puppet 0.24.9 → 0.25.0

data/lib/puppet/agent.rb

@@ -0,0 +1,134 @@
+require 'sync'
+require 'puppet/external/event-loop'
+
+# A general class for triggering a run of another
+# class.
+class Puppet::Agent
+    require 'puppet/agent/locker'
+    include Puppet::Agent::Locker
+
+    require 'puppet/agent/runner'
+
+    attr_reader :client_class, :client, :needing_restart, :splayed
+    attr_accessor :stopping
+
+    def configure_delayed_restart
+        @needing_restart = true
+    end
+
+    # Just so we can specify that we are "the" instance.
+    def initialize(client_class)
+        @splayed = false
+
+        @client_class = client_class
+    end
+
+    def lockfile_path
+        client_class.lockfile_path
+    end
+
+    def needing_restart?
+        @needing_restart
+    end
+
+    def restart
+        configure_delayed_restart and return if running?
+        Process.kill(:HUP, $$)
+        @needing_restart = false
+    end
+
+    # Perform a run with our client.
+    def run(*args)
+        if running?
+            Puppet.notice "Run of %s already in progress; skipping" % client_class
+            return
+        end
+        if stopping?
+            Puppet.notice "In shutdown progress; skipping run"
+            return
+        end
+        splay
+        with_client do |client|
+            begin
+                sync.synchronize { lock { client.run(*args) } }
+            rescue => detail
+                puts detail.backtrace if Puppet[:trace]
+                Puppet.err "Could not run %s: %s" % [client_class, detail]
+            end
+        end
+    end
+
+    def stop
+        if self.stopping?
+            Puppet.notice "Already in shutdown"
+            return
+        end
+        self.stopping = true
+        if client and client.respond_to?(:stop)
+            begin
+                client.stop
+            rescue
+                puts detail.backtrace if Puppet[:trace]
+                Puppet.err "Could not stop %s: %s" % [client_class, detail]
+            end
+        end
+    ensure
+        self.stopping = false
+    end
+
+    def stopping?
+        stopping
+    end
+
+    # Have we splayed already?
+    def splayed?
+        splayed
+    end
+
+    # Sleep when splay is enabled; else just return.
+    def splay
+        return unless Puppet[:splay]
+        return if splayed?
+
+        time = rand(Integer(Puppet[:splaylimit]) + 1)
+        Puppet.info "Sleeping for %s seconds (splay is enabled)" % time
+        sleep(time)
+        @splayed = true
+    end
+
+    # Start listening for events.  We're pretty much just listening for
+    # timer events here.
+    def start
+        # Create our timer.  Puppet will handle observing it and such.
+        timer = EventLoop::Timer.new(:interval => Puppet[:runinterval], :tolerance => 1, :start? => true) do
+            run()
+        end
+
+        # Run once before we start following the timer
+        timer.sound_alarm
+    end
+
+    def sync
+        unless defined?(@sync) and @sync
+            @sync = Sync.new
+        end
+        @sync
+    end
+
+    private
+
+    # Create and yield a client instance, keeping a reference
+    # to it during the yield.
+    def with_client
+        begin
+            @client = client_class.new
+        rescue => details
+            puts detail.backtrace if Puppet[:trace]
+            Puppet.err "Could not create instance of %s: %s" % [client_class, details]
+            return
+        end
+        yield @client
+    ensure
+        @client = nil
+    end
+end

data/lib/puppet/agent/locker.rb

@@ -0,0 +1,42 @@
+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
+
+    # 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
+    end
+
+    def lockfile
+        unless defined?(@lockfile)
+            @lockfile = Puppet::Util::Pidlock.new(lockfile_path)
+        end
+
+        @lockfile
+    end
+
+    def running?
+        lockfile.locked?
+    end
+end

data/lib/puppet/agent/runner.rb

@@ -0,0 +1,65 @@
+require 'puppet/agent'
+require 'puppet/configurer'
+require 'puppet/indirector'
+
+# A basic class for running the agent.  Used by
+# puppetrun to kick off agents remotely.
+class Puppet::Agent::Runner
+    extend Puppet::Indirector
+    indirects :runner, :terminus_class => :rest
+
+    attr_reader :status, :background, :options
+
+    def agent
+        Puppet::Agent.new(Puppet::Configurer)
+    end
+
+    def background?
+        background
+    end
+
+    def initialize(options = {})
+        if options.include?(:background)
+            @background = options[:background]
+            options.delete(:background)
+        end
+
+        valid_options = [:tags, :ignoreschedules]
+        options.each do |key, value|
+            raise ArgumentError, "Runner does not accept %s" % key unless valid_options.include?(key)
+        end
+
+        @options = options
+    end
+
+    def log_run
+        msg = ""
+        msg += "triggered run" %
+        if options[:tags]
+            msg += " with tags %s" % options[:tags]
+        end
+
+        if options[:ignoreschedules]
+            msg += " ignoring schedules"
+        end
+
+        Puppet.notice msg
+    end
+
+    def run
+        if agent.running?
+            @status = "running"
+            return
+        end
+
+        log_run()
+
+        if background?
+            Thread.new { agent.run(options) }
+        else
+            agent.run(options)
+        end
+
+        @status = "success"
+    end
+end

data/lib/puppet/application.rb

@@ -0,0 +1,313 @@
+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
+#
+# === 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.
+#
+# The executable uses the application object like this:
+#      Puppet::Application[:example].run
+#
+#
+# Puppet::Application.new(:example) do
+#
+#     preinit do
+#         # perform some pre initialization
+#         @all = false
+#     end
+#
+#     # dispatch is called to know to what command to call
+#     dispatch do
+#         ARGV.shift
+#     end
+#
+#     option("--arg ARGUMENT") do |v|
+#         @args << v
+#     end
+#
+#     option("--debug", "-d") do |v|
+#         @debug = v
+#     end
+#
+#     option("--all", "-a:) do |v|
+#         @all = v
+#     end
+#
+#     unknown do |opt,arg|
+#         # last chance to manage an option
+#         ...
+#         # let's say to the framework we finally handle this option
+#         true
+#     end
+#
+#     command(:read) do
+#         # read action
+#     end
+#
+#     command(:write) do
+#         # writeaction
+#     end
+#
+# end
+#
+# === Preinit
+# The preinit block is the first code to be called in your application, before option parsing,
+# setup or command execution.
+#
+# === Options
+# Puppet::Application uses +OptionParser+ to manage the application options.
+# Options are defined with the +option+ method to which are passed various
+# arguments, including the long option, the short option, a description...
+# Refer to +OptionParser+ documentation for the exact format.
+# * If the option method is given a block, this one will be called whenever
+# the option is encountered in the command-line argument.
+# * If the option method has no block, a default functionnality will be used, that
+# stores the argument (or true/false if the option doesn't require an argument) in
+# the global (to the application) options array.
+# * If a given option was not defined by a the +option+ method, but it exists as a Puppet settings:
+#  * if +unknown+ was used with a block, it will be called with the option name and argument
+#  * if +unknown+ wasn't used, then the option/argument is handed to Puppet.settings.handlearg for
+#    a default behavior
+#
+# --help is managed directly by the Puppet::Application class, but can be overriden.
+#
+# === Setup
+# Applications can use the setup block to perform any initialization.
+# The defaul +setup+ behaviour is to: read Puppet configuration and manage log level and destination
+#
+# === What and how to run
+# If the +dispatch+ block is defined it is called. This block should return the name of the registered command
+# to be run.
+# If it doesn't exist, it defaults to execute the +main+ command if defined.
+#
+class Puppet::Application
+    include Puppet::Util
+
+    @@applications = {}
+    class << self
+        include Puppet::Util
+    end
+
+    attr_reader :options, :opt_parser
+
+    def self.[](name)
+        name = symbolize(name)
+        @@applications[name]
+    end
+
+    def should_parse_config
+        @parse_config = true
+    end
+
+    def should_not_parse_config
+        @parse_config = false
+    end
+
+    def should_parse_config?
+        unless @parse_config.nil?
+            return @parse_config
+        end
+        @parse_config = true
+    end
+
+    # used to declare a new command
+    def command(name, &block)
+        meta_def(symbolize(name), &block)
+    end
+
+    # used as a catch-all for unknown option
+    def unknown(&block)
+        meta_def(:handle_unknown, &block)
+    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
+    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
+    end
+
+    # used to declare code run instead the default setup
+    def setup(&block)
+        meta_def(:run_setup, &block)
+    end
+
+    # used to declare code to choose which command to run
+    def dispatch(&block)
+        meta_def(:get_command, &block)
+    end
+
+    # used to execute code before running anything else
+    def preinit(&block)
+        meta_def(:run_preinit, &block)
+    end
+
+    def initialize(name, banner = nil, &block)
+        @opt_parser = OptionParser.new(banner)
+
+        name = symbolize(name)
+
+        init_default
+
+        @options = {}
+
+        instance_eval(&block) if block_given?
+
+        @@applications[name] = self
+    end
+
+    # initialize default application behaviour
+    def init_default
+        setup do
+            default_setup
+        end
+
+        dispatch do
+            :main
+        end
+
+        # empty by default
+        preinit do
+        end
+
+        option("--version", "-V") do |arg|
+            puts "%s" % Puppet.version
+            exit
+        end
+
+        option("--help", "-h") do |v|
+            help
+        end
+    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 main
+        raise NotImplementedError, "No valid command or main"
+    end
+
+    def run_command
+        if command = get_command() and respond_to?(command)
+            send(command)
+        else
+            main
+        end
+    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
+    end
+
+    def parse_options
+        # get all puppet options
+        optparse_opt = []
+        optparse_opt = Puppet.settings.optparse_addargs(optparse_opt)
+
+        # convert them to OptionParser format
+        optparse_opt.each do |option|
+            @opt_parser.on(*option) do |arg|
+                handlearg(option[0], arg)
+            end
+        end
+
+        # scan command line argument
+        begin
+            @opt_parser.parse!
+        rescue OptionParser::ParseError => detail
+            $stderr.puts detail
+            $stderr.puts "Try '#{$0} --help'"
+            exit(1)
+        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
+    end
+
+    # this is used for testing
+    def self.exit(code)
+        exit(code)
+    end
+
+    def help
+        if Puppet.features.usage?
+            ::RDoc::usage && exit
+        else
+            puts "No help available unless you have RDoc::usage installed"
+            exit
+        end
+    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
+end