puppet 0.16.0 → 0.18.4

data/lib/puppet/client/ca.rb

@@ -1,4 +1,4 @@
-class Puppet::Client::CAClient < Puppet::Client::ProxyClient
+class Puppet::Client::CA < Puppet::Client::ProxyClient
     @drivername = :CA
 
     # set up the appropriate interface methods
@@ -18,4 +18,4 @@ class Puppet::Client::CAClient < Puppet::Client::ProxyClient
     end
 end
 
-# $Id: ca.rb 965 2006-03-02 07:30:14Z luke $
+# $Id: ca.rb 1160 2006-05-02 04:30:40Z luke $

data/lib/puppet/client/dipper.rb

@@ -3,6 +3,8 @@ module Puppet
         # The client class for filebuckets.
         class Dipper < Puppet::Client
             @drivername = :Bucket
+
+            @handler = Puppet::Server::FileBucket
             
             attr_accessor :name
 
@@ -10,7 +12,7 @@ module Puppet
             def initialize(hash = {})
                 if hash.include?(:Path)
                     bucket = Puppet::Server::FileBucket.new(
-                        :Bucket => hash[:Path]
+                        :Path => hash[:Path]
                     )
                     hash.delete(:Path)
                     hash[:Bucket] = bucket
@@ -24,13 +26,7 @@ module Puppet
                 unless FileTest.exists?(file)
                     raise(BucketError, "File %s does not exist" % file)
                 end
-                contents = File.read(file)
-                string = Base64.encode64(contents)
-
-                sum = @driver.addfile(string,file)
-                string = ""
-                contents = ""
-                return sum
+                return @driver.addfile(Base64.encode64(File.read(file)),file)
             end
 
             # Restore the file
@@ -77,4 +73,4 @@ module Puppet
     end
 end
 
-# $Id: dipper.rb 1113 2006-04-17 16:15:33Z luke $
+# $Id: dipper.rb 1224 2006-05-25 06:24:44Z luke $

data/lib/puppet/client/master.rb

@@ -2,7 +2,11 @@
 require 'sync'
 
 class Puppet::Client::MasterClient < Puppet::Client
-    @@sync = Sync.new
+    unless defined? @@sync
+        @@sync = Sync.new
+    end
+
+    @handler = Puppet::Server::Master
 
     Puppet.setdefaults("puppetd",
         :puppetdlockfile => [ "$statedir/puppetdlock",
@@ -13,18 +17,49 @@ class Puppet::Client::MasterClient < Puppet::Client
             new configurations, where you want to fix the broken configuration
             rather than reverting to a known-good one."
         ]
+    )
 
+    Puppet.setdefaults(:puppetd,
+        :reportserver => ["$server",
+            "The server to which to send transaction reports."
+        ],
+        :report => [false,
+            "Whether to send reports after every transaction."
+        ]
+    )
 
+    Puppet.setdefaults("puppet",
+        :pluginpath => ["$vardir/plugins",
+            "Where Puppet should look for plugins.  Multiple directories should
+            be colon-separated, like normal PATH variables."],
+        :plugindest => ["$vardir/plugins",
+            "Where Puppet should store plugins that it pulls down from the central
+            server."],
+        :pluginsource => ["puppet://$server/plugins",
+            "From where to retrieve plugins.  The standard Puppet ``file`` type
+             is used for retrieval, so anything that is a valid file source can
+             be used here."],
+        :pluginsync => [false,
+            "Whether plugins should be synced with the central server."],
+        :pluginsignore => [".svn CVS",
+            "What files to ignore when pulling down plugins.."]
     )
 
     @drivername = :Master
 
     attr_accessor :objects
 
+    class << self
+        # Puppetd should only have one instance running, and we need a way
+        # to retrieve it.
+        attr_accessor :instance
+        include Puppet::Util
+    end
+
     def self.facts
         facts = {}
         Facter.each { |name,fact|
-            facts[name] = fact.downcase
+            facts[name] = fact.to_s.downcase
         }
 
         # Add our client version to the list of facts, so people can use it
@@ -35,18 +70,23 @@ class Puppet::Client::MasterClient < Puppet::Client
     end
 
     # This method actually applies the configuration.
-    def apply
+    def apply(tags = nil, ignoreschedules = false)
         dostorage()
         unless defined? @objects
             raise Puppet::Error, "Cannot apply; objects not defined"
         end
 
-        # this is a gross hack... but i don't see a good way around it
-        # set all of the variables to empty
-        Puppet::Transaction.init
-
         transaction = @objects.evaluate
-        transaction.toplevel = true
+
+        if tags
+            transaction.tags = tags
+        end
+
+        if ignoreschedules
+            transaction.ignoreschedules = true
+        end
+
+        transaction.addtimes :config_retrieval => @configtime
 
         begin
             transaction.evaluate
@@ -61,11 +101,17 @@ class Puppet::Client::MasterClient < Puppet::Client
         ensure
             Puppet::Storage.store
         end
-        Puppet::Metric.gather
-        Puppet::Metric.tally
-        if Puppet[:rrdgraph] == true
-            Metric.store
-            Metric.graph
+
+        if Puppet[:report]
+            begin
+                report = transaction.report()
+                if Puppet[:rrdgraph] == true
+                    report.graph()
+                end
+                reportclient().report(report)
+            rescue => detail
+                Puppet.err "Reporting failed: %s" % detail
+            end
         end
 
         return transaction
@@ -92,21 +138,29 @@ class Puppet::Client::MasterClient < Puppet::Client
         @cachefile
     end
 
+    def clear
+        #@objects = nil
+        @objects.remove(true)
+        Puppet::Type.allclear
+    end
+
     # Disable running the configuration.  This can be used from the command line, but
     # is also used to make sure only one client is running at a time.
     def disable(running = false)
-        text = nil
-        if running
-            text = Process.pid
-        else
-            text = ""
-            Puppet.notice "Disabling puppetd"
-        end
-        Puppet.config.use(:puppet)
-        begin
-            File.open(Puppet[:puppetdlockfile], "w") { |f| f.puts text }
-        rescue => detail
-            raise Puppet::Error, "Could not lock puppetd: %s" % detail
+        threadlock(:puppetd) do
+            text = nil
+            if running
+                text = Process.pid
+            else
+                text = ""
+                Puppet.notice "Disabling puppetd"
+            end
+            Puppet.config.use(:puppet)
+            begin
+                File.open(Puppet[:puppetdlockfile], "w") { |f| f.puts text }
+            rescue => detail
+                raise Puppet::Error, "Could not lock puppetd: %s" % detail
+            end
         end
     end
 
@@ -130,11 +184,13 @@ class Puppet::Client::MasterClient < Puppet::Client
     # Enable running again.  This can be used from the command line, but
     # is also used to make sure only one client is running at a time.
     def enable(running = false)
-        unless running
-            Puppet.notice "Enabling puppetd"
-        end
-        if FileTest.exists? Puppet[:puppetdlockfile]
-            File.unlink(Puppet[:puppetdlockfile])
+        threadlock(:puppetd) do
+            unless running
+                Puppet.debug "Enabling puppetd"
+            end
+            if FileTest.exists? Puppet[:puppetdlockfile]
+                File.unlink(Puppet[:puppetdlockfile])
+            end
         end
     end
 
@@ -170,6 +226,11 @@ class Puppet::Client::MasterClient < Puppet::Client
             )
         end
 
+        # Retrieve the plugins.
+        if Puppet[:pluginsync]
+            getplugins()
+        end
+
         objects = nil
         if @local
             # If we're local, we don't have to do any of the conversion
@@ -243,6 +304,9 @@ class Puppet::Client::MasterClient < Puppet::Client
         # Clear all existing objects, so we can recreate our stack.
         if defined? @objects
             Puppet::Type.allclear
+
+            # Make sure all of the objects are really gone.
+            @objects.remove(true)
         end
         @objects = nil
 
@@ -255,7 +319,6 @@ class Puppet::Client::MasterClient < Puppet::Client
         if @objects.nil?
             raise Puppet::Error, "Configuration could not be processed"
         end
-        #@objects = objects
 
         # and perform any necessary final actions before we evaluate.
         @objects.finalize
@@ -263,6 +326,16 @@ class Puppet::Client::MasterClient < Puppet::Client
         return @objects
     end
 
+    # Just so we can specify that we are "the" instance.
+    def initialize(*args)
+        super
+
+        @configtime = Time.now
+
+        self.class.instance = self
+        @running = false
+    end
+
     # Make sure only one client runs at a time, and make sure only one thread
     # runs at a time.  However, this does not lock local clients -- you could have
     # as many separate puppet scripts running as you want.
@@ -270,27 +343,48 @@ class Puppet::Client::MasterClient < Puppet::Client
         if @local
             yield
         else
-            @@sync.synchronize(Sync::EX) do
+            #@@sync.synchronize(Sync::EX) do
                 disable(true)
                 begin
                     yield
                 ensure
                     enable(true)
                 end
-            end
+            #end
         end
     end
 
     def locked?
+        return(FileTest.exists? Puppet[:puppetdlockfile])
+    end
+
+    def lockpid
         if FileTest.exists? Puppet[:puppetdlockfile]
             text = File.read(Puppet[:puppetdlockfile]).chomp
             if text =~ /\d+/
-                return text
+                return text.to_i
             else
-                return true
+                return 0
             end
         else
-            return false
+            return 0
+        end
+    end
+
+    # Mark that we should restart.  The Puppet module checks whether we're running,
+    # so this only gets called if we're in the middle of a run.
+    def restart
+        # If we're currently running, then just mark for later
+        Puppet.notice "Received signal to restart; waiting until run is complete"
+        @restart = true
+    end
+
+    # Should we restart?
+    def restart?
+        if defined? @restart
+            @restart
+        else
+            false
         end
     end
 
@@ -304,30 +398,59 @@ class Puppet::Client::MasterClient < Puppet::Client
     end
 
     # The code that actually runs the configuration.  
-    def run
-        if pid = locked?
-            t = ""
-            if pid == true
-                Puppet.notice "Locked by process %s" % pid
+    def run(tags = nil, ignoreschedules = false)
+        # Check if the lock is stale, so we can clear it
+        if locked?
+            pid = lockpid
+
+            if pid != 0
+                begin
+                    Process.kill(0, pid)
+                rescue Errno::ESRCH
+                    # No process with the given PID exists; stale lockfile
+                    File.unlink(Puppet[:puppetdlockfile])
+                    Puppet.notice("Stale lockfile %s left by process %i; removing" %
+                        [Puppet[:puppetdlockfile], pid])
+                    lockpid = false
+                else
+                    Puppet.notice "Locked by process %s" % pid
+                end
             end
+        end
+
+        if locked?
             Puppet.notice "Lock file %s exists; skipping configuration run" %
                 Puppet[:puppetdlockfile]
         else
             lock do
-                self.getconfig
+                @running = true
+                @configtime = thinmark do
+                    self.getconfig
+                end
 
                 if defined? @objects and @objects
                     unless @local
                         Puppet.notice "Starting configuration run"
                     end
                     benchmark(:notice, "Finished configuration run") do
-                        self.apply
+                        self.apply(tags, ignoreschedules)
                     end
                 end
+                @running = false
+            end
+
+            # Did we get HUPped during the run?  If so, then restart now that we're
+            # done with the run.
+            if self.restart?
+                Process.kill(:HUP, $$)
             end
         end
     end
 
+    def running?
+        @running
+    end
+
     # Store the classes in the classfile, but only if we're not local.
     def setclasses(ary)
         if @local
@@ -346,6 +469,63 @@ class Puppet::Client::MasterClient < Puppet::Client
                 [Puppet[:classfile], detail]
         end
     end
+
+    private
+    # Retrieve the plugins from the central server.
+    def getplugins
+        plugins = Puppet::Type.type(:component).create(
+            :name => "plugin_collector"
+        )
+        plugins.push Puppet::Type.type(:file).create(
+            :path => Puppet[:plugindest],
+            :recurse => true,
+            :source => Puppet[:pluginsource],
+            :ignore => Puppet[:pluginsignore].split(/\s+/),
+            :tag => "plugins",
+            :owner => "root"
+        )
+
+        Puppet.info "Retrieving plugins"
+
+
+        begin
+            trans = plugins.evaluate
+            trans.evaluate
+        rescue Puppet::Error => detail
+            if Puppet[:debug]
+                puts detail.backtrace
+            end
+            Puppet.err "Could not retrieve plugins: %s" % detail
+        end
+
+        # Now source all of the changed objects, but only source those
+        # that are top-level.
+        trans.changed?.find_all { |object|
+            File.dirname(object[:path]) == Puppet[:pluginpath]
+        }.each do |object|
+            begin
+                Puppet.info "Loading plugin %s" %
+                    File.basename(object[:path]).sub(".rb",'')
+                load object[:path]
+            rescue => detail
+                Puppet.warning "Could not load %s: %s" %
+                    [object[:path], detail]
+            end
+        end
+
+        # Now clean up after ourselves
+        plugins.remove
+    end
+
+    def reportclient
+        unless defined? @reportclient
+            @reportclient = Puppet::Client::Reporter.new(
+                :Server => Puppet[:reportserver]
+            )
+        end
+
+        @reportclient
+    end
 end
 
-# $Id: master.rb 1129 2006-04-21 19:14:59Z luke $
+# $Id: master.rb 1422 2006-07-22 03:32:56Z luke $