puppet 0.25.5 → 2.6.0

data/lib/puppet/configurer/downloader.rb

@@ -2,78 +2,78 @@ require 'puppet/configurer'
 require 'puppet/resource/catalog'
 
 class Puppet::Configurer::Downloader
-    attr_reader :name, :path, :source, :ignore
+  attr_reader :name, :path, :source, :ignore
 
-    # Determine the timeout value to use.
-    def self.timeout
-        timeout = Puppet[:configtimeout]
-        case timeout
-        when String
-            if timeout =~ /^\d+$/
-                timeout = Integer(timeout)
-            else
-                raise ArgumentError, "Configuration timeout must be an integer"
-            end
-        when Integer # nothing
-        else
-            raise ArgumentError, "Configuration timeout must be an integer"
-        end
-
-        return timeout
+  # Determine the timeout value to use.
+  def self.timeout
+    timeout = Puppet[:configtimeout]
+    case timeout
+    when String
+      if timeout =~ /^\d+$/
+        timeout = Integer(timeout)
+      else
+        raise ArgumentError, "Configuration timeout must be an integer"
+      end
+    when Integer # nothing
+    else
+      raise ArgumentError, "Configuration timeout must be an integer"
     end
 
-    # Evaluate our download, returning the list of changed values.
-    def evaluate
-        Puppet.info "Retrieving #{name}"
+    timeout
+  end
 
-        files = []
-        begin
-            Timeout.timeout(self.class.timeout) do
-                catalog.apply do |trans|
-                    trans.changed?.find_all do |resource|
-                        yield resource if block_given?
-                        files << resource[:path]
-                    end
-                end
-            end
-        rescue Puppet::Error, Timeout::Error => detail
-            puts detail.backtrace if Puppet[:debug]
-            Puppet.err "Could not retrieve #{name}: %s" % detail
-        end
+  # Evaluate our download, returning the list of changed values.
+  def evaluate
+    Puppet.info "Retrieving #{name}"
 
-        return files
+    files = []
+    begin
+      Timeout.timeout(self.class.timeout) do
+        catalog.apply do |trans|
+          trans.changed?.find_all do |resource|
+            yield resource if block_given?
+            files << resource[:path]
+          end
+        end
+      end
+    rescue Puppet::Error, Timeout::Error => detail
+      puts detail.backtrace if Puppet[:debug]
+      Puppet.err "Could not retrieve #{name}: #{detail}"
     end
 
-    def initialize(name, path, source, ignore = nil)
-        @name, @path, @source, @ignore = name, path, source, ignore
-    end
+    files
+  end
 
-    def catalog
-        catalog = Puppet::Resource::Catalog.new
-        catalog.add_resource(file)
-        catalog
-    end
+  def initialize(name, path, source, ignore = nil)
+    @name, @path, @source, @ignore = name, path, source, ignore
+  end
 
-    def file
-        args = default_arguments.merge(:path => path, :source => source)
-        args[:ignore] = ignore.split if ignore
-        Puppet::Type.type(:file).new(args)
-    end
+  def catalog
+    catalog = Puppet::Resource::Catalog.new
+    catalog.add_resource(file)
+    catalog
+  end
 
-    private
+  def file
+    args = default_arguments.merge(:path => path, :source => source)
+    args[:ignore] = ignore.split if ignore
+    Puppet::Type.type(:file).new(args)
+  end
 
-    def default_arguments
-        {
-            :path => path,
-            :recurse => true,
-            :source => source,
-            :tag => name,
-            :owner => Process.uid,
-            :group => Process.gid,
-            :purge => true,
-            :force => true,
-            :backup => false,
-            :noop => false
-        }
-    end
+  private
+
+  def default_arguments
+    {
+      :path => path,
+      :recurse => true,
+      :source => source,
+      :tag => name,
+      :owner => Process.uid,
+      :group => Process.gid,
+      :purge => true,
+      :force => true,
+      :backup => false,
+      :noop => false
+    }
+  end
 end

data/lib/puppet/configurer/fact_handler.rb

@@ -6,67 +6,67 @@ require 'puppet/configurer/downloader'
 # just included into the agent, but having it here makes it
 # easier to test.
 module Puppet::Configurer::FactHandler
-    def download_fact_plugins?
-        Puppet[:factsync]
-    end
+  def download_fact_plugins?
+    Puppet[:factsync]
+  end
 
-    def find_facts
-        # This works because puppetd configures Facts to use 'facter' for
-        # finding facts and the 'rest' terminus for caching them.  Thus, we'll
-        # compile them and then "cache" them on the server.
-        begin
-            reload_facter()
-            Puppet::Node::Facts.find(Puppet[:certname])
-        rescue SystemExit,NoMemoryError
-            raise
-        rescue Exception => detail
-            puts detail.backtrace if Puppet[:trace]
-            raise Puppet::Error, "Could not retrieve local facts: %s" % detail
-        end
+  def find_facts
+    # This works because puppet agent configures Facts to use 'facter' for
+    # finding facts and the 'rest' terminus for caching them.  Thus, we'll
+    # compile them and then "cache" them on the server.
+    begin
+      reload_facter
+      Puppet::Node::Facts.find(Puppet[:certname])
+    rescue SystemExit,NoMemoryError
+      raise
+    rescue Exception => detail
+      puts detail.backtrace if Puppet[:trace]
+      raise Puppet::Error, "Could not retrieve local facts: #{detail}"
     end
+  end
 
-    def facts_for_uploading
-        facts = find_facts
-        #format = facts.class.default_format
-
-        if facts.support_format?(:b64_zlib_yaml)
-            format = :b64_zlib_yaml
-        else
-            format = :yaml
-        end
-
-        text = facts.render(format)
+  def facts_for_uploading
+    facts = find_facts
+    #format = facts.class.default_format
 
-        return {:facts_format => format, :facts => CGI.escape(text)}
+    if facts.support_format?(:b64_zlib_yaml)
+      format = :b64_zlib_yaml
+    else
+      format = :yaml
     end
 
-    # Retrieve facts from the central server.
-    def download_fact_plugins
-        return unless download_fact_plugins?
+    text = facts.render(format)
 
-        # Deprecated prior to 0.25, as of 5/19/2008
-        Puppet.warning "Fact syncing is deprecated as of 0.25 -- use 'pluginsync' instead"
+    {:facts_format => format, :facts => CGI.escape(text)}
+  end
 
-        Puppet::Configurer::Downloader.new("fact", Puppet[:factdest], Puppet[:factsource], Puppet[:factsignore]).evaluate
-    end
+  # Retrieve facts from the central server.
+  def download_fact_plugins
+    return unless download_fact_plugins?
+
+    # Deprecated prior to 0.25, as of 5/19/2008
+    Puppet.warning "Fact syncing is deprecated as of 0.25 -- use 'pluginsync' instead"
 
-    # Clear out all of the loaded facts and reload them from disk.
-    # NOTE: This is clumsy and shouldn't be required for later (1.5.x) versions
-    # of Facter.
-    def reload_facter
-        Facter.clear
+    Puppet::Configurer::Downloader.new("fact", Puppet[:factdest], Puppet[:factsource], Puppet[:factsignore]).evaluate
+  end
 
-        # Reload everything.
-        if Facter.respond_to? :loadfacts
-            Facter.loadfacts
-        elsif Facter.respond_to? :load
-            Facter.load
-        else
-            Puppet.warning "You should upgrade your version of Facter to at least 1.3.8"
-        end
+  # Clear out all of the loaded facts and reload them from disk.
+  # NOTE: This is clumsy and shouldn't be required for later (1.5.x) versions
+  # of Facter.
+  def reload_facter
+    Facter.clear
 
-        # This loads all existing facts and any new ones.  We have to remove and
-        # reload because there's no way to unload specific facts.
-        Puppet::Node::Facts::Facter.load_fact_plugins()
+    # Reload everything.
+    if Facter.respond_to? :loadfacts
+      Facter.loadfacts
+    elsif Facter.respond_to? :load
+      Facter.load
+    else
+      Puppet.warning "You should upgrade your version of Facter to at least 1.3.8"
     end
+
+    # This loads all existing facts and any new ones.  We have to remove and
+    # reload because there's no way to unload specific facts.
+    Puppet::Node::Facts::Facter.load_fact_plugins
+  end
 end

data/lib/puppet/configurer/plugin_handler.rb

@@ -2,27 +2,27 @@
 # just included into the agent, but having it here makes it
 # easier to test.
 module Puppet::Configurer::PluginHandler
-    def download_plugins?
-        Puppet[:pluginsync]
-    end
+  def download_plugins?
+    Puppet[:pluginsync]
+  end
 
-    # Retrieve facts from the central server.
-    def download_plugins
-        return nil unless download_plugins?
-        Puppet::Configurer::Downloader.new("plugin", Puppet[:plugindest], Puppet[:pluginsource], Puppet[:pluginsignore]).evaluate.each { |file| load_plugin(file) }
-    end
+  # Retrieve facts from the central server.
+  def download_plugins
+    return nil unless download_plugins?
+    Puppet::Configurer::Downloader.new("plugin", Puppet[:plugindest], Puppet[:pluginsource], Puppet[:pluginsignore]).evaluate.each { |file| load_plugin(file) }
+  end
 
-    def load_plugin(file)
-        return unless FileTest.exist?(file)
-        return if FileTest.directory?(file)
+  def load_plugin(file)
+    return unless FileTest.exist?(file)
+    return if FileTest.directory?(file)
 
-        begin
-            Puppet.info "Loading downloaded plugin %s" % file
-            load file
-        rescue SystemExit,NoMemoryError
-            raise
-        rescue Exception => detail
-            Puppet.err "Could not load downloaded file %s: %s" % [file, detail]
-        end
+    begin
+      Puppet.info "Loading downloaded plugin #{file}"
+      load file
+    rescue SystemExit,NoMemoryError
+      raise
+    rescue Exception => detail
+      Puppet.err "Could not load downloaded file #{file}: #{detail}"
     end
+  end
 end

data/lib/puppet/daemon.rb

@@ -1,133 +1,130 @@
 require 'puppet'
 require 'puppet/util/pidlock'
 require 'puppet/external/event-loop'
+require 'puppet/application'
 
 # A module that handles operations common to all daemons.  This is included
 # into the Server and Client base classes.
 class Puppet::Daemon
-    attr_accessor :agent, :server, :argv
+  attr_accessor :agent, :server, :argv
 
-    def daemonname
-        Puppet[:name]
-    end
+  def daemonname
+    Puppet[:name]
+  end
 
-    # Put the daemon into the background.
-    def daemonize
-        if pid = fork()
-            Process.detach(pid)
-            exit(0)
-        end
-
-        create_pidfile()
-
-        # Get rid of console logging
-        Puppet::Util::Log.close(:console)
-
-        Process.setsid
-        Dir.chdir("/")
-        begin
-            $stdin.reopen "/dev/null"
-            $stdout.reopen "/dev/null", "a"
-            $stderr.reopen $stdout
-            Puppet::Util::Log.reopen
-        rescue => detail
-            Puppet.err "Could not start %s: %s" % [Puppet[:name], detail]
-            Puppet::Util::secure_open("/tmp/daemonout", "w") { |f|
-                f.puts "Could not start %s: %s" % [Puppet[:name], detail]
-            }
-            exit(12)
-        end
+  # Put the daemon into the background.
+  def daemonize
+    if pid = fork
+      Process.detach(pid)
+      exit(0)
     end
 
-    # Create a pidfile for our daemon, so we can be stopped and others
-    # don't try to start.
-    def create_pidfile
-        Puppet::Util.sync(Puppet[:name]).synchronize(Sync::EX) do
-            unless Puppet::Util::Pidlock.new(pidfile).lock
-                raise "Could not create PID file: %s" % [pidfile]
-            end
-        end
+    create_pidfile
+
+    # Get rid of console logging
+    Puppet::Util::Log.close(:console)
+
+    Process.setsid
+    Dir.chdir("/")
+    begin
+      $stdin.reopen "/dev/null"
+      $stdout.reopen "/dev/null", "a"
+      $stderr.reopen $stdout
+      Puppet::Util::Log.reopen
+    rescue => detail
+      Puppet.err "Could not start #{Puppet[:name]}: #{detail}"
+      Puppet::Util::secure_open("/tmp/daemonout", "w") { |f|
+        f.puts "Could not start #{Puppet[:name]}: #{detail}"
+      }
+      exit(12)
     end
+  end
 
-    # Provide the path to our pidfile.
-    def pidfile
-        Puppet[:pidfile]
+  # Create a pidfile for our daemon, so we can be stopped and others
+  # don't try to start.
+  def create_pidfile
+    Puppet::Util.sync(Puppet[:name]).synchronize(Sync::EX) do
+      raise "Could not create PID file: #{pidfile}" unless Puppet::Util::Pidlock.new(pidfile).lock
     end
-
-    def reexec
-        raise Puppet::DevError, "Cannot reexec unless ARGV arguments are set" unless argv
-        command = $0 + " " + argv.join(" ")
-        Puppet.notice "Restarting with '%s'" % command
-        stop(:exit => false)
-        exec(command)
+  end
+
+  # Provide the path to our pidfile.
+  def pidfile
+    Puppet[:pidfile]
+  end
+
+  def reexec
+    raise Puppet::DevError, "Cannot reexec unless ARGV arguments are set" unless argv
+    command = $0 + " " + argv.join(" ")
+    Puppet.notice "Restarting with '#{command}'"
+    stop(:exit => false)
+    exec(command)
+  end
+
+  def reload
+    return unless agent
+    if agent.running?
+      Puppet.notice "Not triggering already-running agent"
+      return
     end
 
-    def reload
-        return unless agent
-        if agent.running?
-            Puppet.notice "Not triggering already-running agent"
-            return
-        end
+    agent.run
+  end
 
-        agent.run
+  # Remove the pid file for our daemon.
+  def remove_pidfile
+    Puppet::Util.sync(Puppet[:name]).synchronize(Sync::EX) do
+      locker = Puppet::Util::Pidlock.new(pidfile)
+      locker.unlock or Puppet.err "Could not remove PID file #{pidfile}" if locker.locked?
     end
-
-    # Remove the pid file for our daemon.
-    def remove_pidfile
-        Puppet::Util.sync(Puppet[:name]).synchronize(Sync::EX) do
-            locker = Puppet::Util::Pidlock.new(pidfile)
-            if locker.locked?
-                locker.unlock or Puppet.err "Could not remove PID file %s" % [pidfile]
-            end
-        end
+  end
+
+  def restart
+    Puppet::Application.restart!
+    reexec unless agent and agent.running?
+  end
+
+  def reopen_logs
+    Puppet::Util::Log.reopen
+  end
+
+  # Trap a couple of the main signals.  This should probably be handled
+  # in a way that anyone else can register callbacks for traps, but, eh.
+  def set_signal_traps
+    signals = {:INT => :stop, :TERM => :stop }
+    # extended signals not supported under windows
+    signals.update({:HUP => :restart, :USR1 => :reload, :USR2 => :reopen_logs }) unless Puppet.features.microsoft_windows?
+    signals.each do |signal, method|
+      trap(signal) do
+        Puppet.notice "Caught #{signal}; calling #{method}"
+        send(method)
+      end
     end
+  end
 
-    def restart
-        if agent and agent.running?
-            agent.configure_delayed_restart
-        else
-            reexec
-        end
-    end
+  # Stop everything
+  def stop(args = {:exit => true})
+    Puppet::Application.stop!
 
-    def reopen_logs
-        Puppet::Util::Log.reopen
-    end
+    server.stop if server
 
-    # Trap a couple of the main signals.  This should probably be handled
-    # in a way that anyone else can register callbacks for traps, but, eh.
-    def set_signal_traps
-        {:INT => :stop, :TERM => :stop, :HUP => :restart, :USR1 => :reload, :USR2 => :reopen_logs}.each do |signal, method|
-            trap(signal) do
-                Puppet.notice "Caught #{signal}; calling #{method}"
-                send(method)
-            end
-        end
-    end
+    remove_pidfile
 
-    # Stop everything
-    def stop(args = {:exit => true})
-        server.stop if server
+    Puppet::Util::Log.close_all
 
-        agent.stop if agent
+    exit if args[:exit]
+  end
 
-        remove_pidfile()
+  def start
+    set_signal_traps
 
-        Puppet::Util::Log.close_all
+    create_pidfile
 
-        exit if args[:exit]
-    end
-
-    def start
-        set_signal_traps
-
-        create_pidfile
+    raise Puppet::DevError, "Daemons must have an agent, server, or both" unless agent or server
+    agent.start if agent
+    server.start if server
 
-        raise Puppet::DevError, "Daemons must have an agent, server, or both" unless agent or server
-        agent.start if agent
-        server.start if server
-
-        EventLoop.current.run
-    end
+    EventLoop.current.run
+  end
 end