puppet 0.25.5 → 2.6.0

data/lib/puppet.rb

@@ -1,6 +1,6 @@
 # Try to load rubygems.  Hey rubygems, I hate you.
 begin
-    require 'rubygems'
+  require 'rubygems'
 rescue LoadError
 end
 
@@ -9,11 +9,11 @@ require 'singleton'
 require 'facter'
 require 'puppet/error'
 require 'puppet/util'
-require 'puppet/util/log'
 require 'puppet/util/autoload'
 require 'puppet/util/settings'
 require 'puppet/util/feature'
 require 'puppet/util/suidmanager'
+require 'puppet/util/run_mode'
 
 #------------------------------------------------------------
 # the top-level module
@@ -24,155 +24,142 @@ require 'puppet/util/suidmanager'
 # it's also a place to find top-level commands like 'debug'
 
 module Puppet
-    PUPPETVERSION = '0.25.5'
+  PUPPETVERSION = '2.6.0'
 
-    def Puppet.version
-        return PUPPETVERSION
-    end
+  def Puppet.version
+    PUPPETVERSION
+  end
 
-    class << self
-        include Puppet::Util
-        attr_reader :features
-        attr_writer :name
-    end
+  class << self
+    include Puppet::Util
+    attr_reader :features
+    attr_writer :name
+  end
 
-    # the hash that determines how our system behaves
-    @@settings = Puppet::Util::Settings.new
-
-    # The services running in this process.
-    @services ||= []
-
-    # define helper messages for each of the message levels
-    Puppet::Util::Log.eachlevel { |level|
-        define_method(level,proc { |args|
-            if args.is_a?(Array)
-                args = args.join(" ")
-            end
-            Puppet::Util::Log.create(
-                :level => level,
-                :message => args
-            )
-        })
-        module_function level
-    }
-
-    # I keep wanting to use Puppet.error
-    # XXX this isn't actually working right now
-    alias :error :err
-
-    # The feature collection
-    @features = Puppet::Util::Feature.new('puppet/feature')
-
-    # Load the base features.
-    require 'puppet/feature/base'
-
-    # Store a new default value.
-    def self.setdefaults(section, hash)
-        @@settings.setdefaults(section, hash)
-    end
+  # the hash that determines how our system behaves
+  @@settings = Puppet::Util::Settings.new
 
-    # configuration parameter access and stuff
-    def self.[](param)
-        case param
-        when :debug
-            if Puppet::Util::Log.level == :debug
-                return true
-            else
-                return false
-            end
-        else
-            return @@settings[param]
-        end
-    end
+  # The services running in this process.
+  @services ||= []
 
-    # configuration parameter access and stuff
-    def self.[]=(param,value)
-        @@settings[param] = value
-    end
+  require 'puppet/util/logging'
 
-    def self.clear
-        @@settings.clear
-    end
+  extend Puppet::Util::Logging
 
-    def self.debug=(value)
-        if value
-            Puppet::Util::Log.level=(:debug)
-        else
-            Puppet::Util::Log.level=(:notice)
-        end
-    end
+  # The feature collection
+  @features = Puppet::Util::Feature.new('puppet/feature')
 
-    def self.settings
-        @@settings
-    end
+  # Load the base features.
+  require 'puppet/feature/base'
 
-    # Load all of the configuration parameters.
-    require 'puppet/defaults'
+  # Store a new default value.
+  def self.setdefaults(section, hash)
+    @@settings.setdefaults(section, hash)
+  end
 
-    def self.genmanifest
-        if Puppet[:genmanifest]
-            puts Puppet.settings.to_manifest
-            exit(0)
-        end
+  # configuration parameter access and stuff
+  def self.[](param)
+    case param
+    when :debug
+      return Puppet::Util::Log.level == :debug
+    else
+      return @@settings[param]
     end
-
-    # Parse the config file for this process.
-    def self.parse_config
-        Puppet.settings.parse
+  end
+
+  # configuration parameter access and stuff
+  def self.[]=(param,value)
+    @@settings[param] = value
+  end
+
+  def self.clear
+    @@settings.clear
+  end
+
+  def self.debug=(value)
+    if value
+      Puppet::Util::Log.level=(:debug)
+    else
+      Puppet::Util::Log.level=(:notice)
     end
+  end
 
-    # XXX this should all be done using puppet objects, not using
-    # normal mkdir
-    def self.recmkdir(dir,mode = 0755)
-        if FileTest.exist?(dir)
-            return false
-        else
-            tmp = dir.sub(/^\//,'')
-            path = [File::SEPARATOR]
-            tmp.split(File::SEPARATOR).each { |dir|
-                path.push dir
-                if ! FileTest.exist?(File.join(path))
-                    begin
-                        Dir.mkdir(File.join(path), mode)
-                    rescue Errno::EACCES => detail
-                        Puppet.err detail.to_s
-                        return false
-                    rescue => detail
-                        Puppet.err "Could not create %s: %s" % [path, detail.to_s]
-                        return false
-                    end
-                elsif FileTest.directory?(File.join(path))
-                    next
-                else FileTest.exist?(File.join(path))
-                    raise Puppet::Error, "Cannot create %s: basedir %s is a file" %
-                        [dir, File.join(path)]
-                end
-            }
-            return true
-        end
-    end
+  def self.settings
+    @@settings
+  end
 
-    # Create a new type.  Just proxy to the Type class.
-    def self.newtype(name, options = {}, &block)
-        Puppet::Type.newtype(name, options, &block)
-    end
+  def self.run_mode
+    $puppet_application_mode || Puppet::Util::RunMode[:user]
+  end
 
-    # Retrieve a type by name.  Just proxy to the Type class.
-    def self.type(name)
-        # LAK:DEP Deprecation notice added 12/17/2008
-        Puppet.warning "Puppet.type is deprecated; use Puppet::Type.type"
-        Puppet::Type.type(name)
+  def self.application_name
+    $puppet_application_name ||= "apply"
+  end
+
+  # Load all of the configuration parameters.
+  require 'puppet/defaults'
+
+  def self.genmanifest
+    if Puppet[:genmanifest]
+      puts Puppet.settings.to_manifest
+      exit(0)
+    end
+  end
+
+  # Parse the config file for this process.
+  def self.parse_config
+    Puppet.settings.parse
+  end
+
+  # XXX this should all be done using puppet objects, not using
+  # normal mkdir
+  def self.recmkdir(dir,mode = 0755)
+    if FileTest.exist?(dir)
+      return false
+    else
+      tmp = dir.sub(/^\//,'')
+      path = [File::SEPARATOR]
+      tmp.split(File::SEPARATOR).each { |dir|
+        path.push dir
+        if ! FileTest.exist?(File.join(path))
+          begin
+            Dir.mkdir(File.join(path), mode)
+          rescue Errno::EACCES => detail
+            Puppet.err detail.to_s
+            return false
+          rescue => detail
+            Puppet.err "Could not create #{path}: #{detail}"
+            return false
+          end
+        elsif FileTest.directory?(File.join(path))
+          next
+        else FileTest.exist?(File.join(path))
+          raise Puppet::Error, "Cannot create #{dir}: basedir #{File.join(path)} is a file"
+        end
+      }
+      return true
     end
+  end
+
+  # Create a new type.  Just proxy to the Type class.
+  def self.newtype(name, options = {}, &block)
+    Puppet::Type.newtype(name, options, &block)
+  end
+
+  # Retrieve a type by name.  Just proxy to the Type class.
+  def self.type(name)
+    # LAK:DEP Deprecation notice added 12/17/2008
+    Puppet.warning "Puppet.type is deprecated; use Puppet::Type.type"
+    Puppet::Type.type(name)
+  end
 end
 
 require 'puppet/type'
+require 'puppet/parser'
+require 'puppet/resource'
 require 'puppet/network'
 require 'puppet/ssl'
 require 'puppet/module'
 require 'puppet/util/storage'
-require 'puppet/parser/interpreter'
-
-if Puppet[:storeconfigs]
-    require 'puppet/rails'
-end
-
+require 'puppet/status'
+require 'puppet/file_bucket/file'

data/lib/puppet/agent.rb

@@ -1,138 +1,105 @@
 require 'sync'
 require 'puppet/external/event-loop'
+require 'puppet/application'
 
 # A general class for triggering a run of another
 # class.
 class Puppet::Agent
-    require 'puppet/agent/locker'
-    include Puppet::Agent::Locker
+  require 'puppet/agent/locker'
+  include Puppet::Agent::Locker
 
-    require 'puppet/agent/runner'
+  attr_reader :client_class, :client, :splayed
 
-    attr_reader :client_class, :client, :needing_restart, :splayed
-    attr_accessor :stopping
+  # Just so we can specify that we are "the" instance.
+  def initialize(client_class)
+    @splayed = false
 
-    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 SystemExit,NoMemoryError
-                raise
-            rescue Exception => detail
-                puts detail.backtrace if Puppet[:trace]
-                Puppet.err "Could not run %s: %s" % [client_class, detail]
-            end
-        end
-    end
+    @client_class = client_class
+  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
+  def lockfile_path
+    client_class.lockfile_path
+  end
 
-    # Sleep when splay is enabled; else just return.
-    def splay
-        return unless Puppet[:splay]
-        return if splayed?
+  def needing_restart?
+    Puppet::Application.restart_requested?
+  end
 
-        time = rand(Integer(Puppet[:splaylimit]) + 1)
-        Puppet.info "Sleeping for %s seconds (splay is enabled)" % time
-        sleep(time)
-        @splayed = true
+  # Perform a run with our client.
+  def run(*args)
+    if running?
+      Puppet.notice "Run of #{client_class} already in progress; skipping"
+      return
     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()
+    result = nil
+    block_run = Puppet::Application.controlled_run do
+      splay
+      with_client do |client|
+        begin
+          sync.synchronize { lock { result = client.run(*args) } }
+        rescue => detail
+          puts detail.backtrace if Puppet[:trace]
+          Puppet.err "Could not run #{client_class}: #{detail}"
         end
-
-        # Run once before we start following the timer
-        timer.sound_alarm
+      end
+      true
     end
-
-    def sync
-        unless defined?(@sync) and @sync
-            @sync = Sync.new
-        end
-        @sync
+    Puppet.notice "Shutdown/restart in progress; skipping run" unless block_run
+    result
+  end
+
+  def stopping?
+    Puppet::Application.stop_requested?
+  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 #{time} seconds (splay is enabled)"
+    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
 
-    private
-
-    # Create and yield a client instance, keeping a reference
-    # to it during the yield.
-    def with_client
-        begin
-            @client = client_class.new
-        rescue SystemExit,NoMemoryError
-            raise
-        rescue Exception => detail
-            puts detail.backtrace if Puppet[:trace]
-            Puppet.err "Could not create instance of %s: %s" % [client_class, detail]
-            return
-        end
-        yield @client
-    ensure
-        @client = nil
+    # Run once before we start following the timer
+    timer.sound_alarm
+  end
+
+  def sync
+    @sync ||= Sync.new
+  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 SystemExit,NoMemoryError
+      raise
+    rescue Exception => detail
+      puts detail.backtrace if Puppet[:trace]
+      Puppet.err "Could not create instance of #{client_class}: #{detail}"
+      return
     end
+    yield @client
+  ensure
+    @client = nil
+  end
 end