puppet 0.16.0 → 0.18.4

data/lib/puppet/client/pelement.rb

@@ -1,20 +1,65 @@
-class Puppet::Client::FileClient < Puppet::Client::ProxyClient
-    @drivername = :FileServer
+class Puppet::Client::PElement < Puppet::Client
+    @drivername = :PElementServer
 
-    # set up the appropriate interface methods
-    @handler = Puppet::Server::FileServer
+    @handler = Puppet::Server::PElement
 
-    self.mkmethods
+    def apply(bucket)
+
+        case bucket
+        when Puppet::TransObject
+            tmp = Puppet::TransBucket.new
+            tmp.push bucket
+            bucket = tmp
+            bucket.name = Facter["hostname"].value
+            bucket.type = "pelement"
+        when Puppet::TransBucket
+            # nothing
+        else
+            raise Puppet::DevError, "You must pass a transportable object, not a %s" %
+                bucket.class
+        end
+
+        unless @local
+            bucket = Base64.encode64(YAML::dump(bucket))
+        end
+        report = @driver.apply(bucket, "yaml")
+
+        return report
+    end
+
+    def describe(type, name, retrieve = false, ignore = false)
+        Puppet.info "Describing %s[%s]" % [type, name]
+        text = @driver.describe(type, name, retrieve, ignore, "yaml")
+
+        object = nil
+        if @local
+            object = text
+        else
+            object = YAML::load(Base64.decode64(text))
+        end
+
+        return object
+    end
 
     def initialize(hash = {})
-        if hash.include?(:FileServer)
-            unless hash[:FileServer].is_a?(Puppet::Server::FileServer)
-                raise Puppet::DevError, "Must pass an actual FS object"
+        if hash.include?(:PElementServer)
+            unless hash[:PElementServer].is_a?(Puppet::Server::PElement)
+                raise Puppet::DevError, "Must pass an actual PElement server object"
             end
         end
 
         super(hash)
     end
+
+    def list(type, ignore = false, base = false)
+        bucket = @driver.list(type, ignore, base, "yaml")
+
+        unless @local
+            bucket = YAML::load(Base64.decode64(bucket))
+        end
+
+        return bucket
+    end
 end
 
-# $Id: pelement.rb 1123 2006-04-20 05:14:13Z luke $
+# $Id: pelement.rb 1145 2006-04-28 04:08:38Z luke $

data/lib/puppet/client/proxy.rb

@@ -6,10 +6,11 @@ class Puppet::Client::ProxyClient < Puppet::Client
         interface = @handler.interface
         namespace = interface.prefix
 
+
         interface.methods.each { |ary|
             method = ary[0]
             Puppet.debug "%s: defining %s.%s" % [self, namespace, method]
-            self.send(:define_method,method) { |*args|
+            define_method(method) { |*args|
                 begin
                     @driver.send(method, *args)
                 rescue XMLRPC::FaultException => detail
@@ -24,4 +25,4 @@ class Puppet::Client::ProxyClient < Puppet::Client
     end
 end
 
-# $Id: proxy.rb 848 2006-01-24 06:01:58Z luke $
+# $Id: proxy.rb 1145 2006-04-28 04:08:38Z luke $

data/lib/puppet/client/reporter.rb

@@ -0,0 +1,34 @@
+class Puppet::Client::Reporter < Puppet::Client
+    @drivername = :Report
+
+    # set up the appropriate interface methods
+    @handler = Puppet::Server::Report
+
+    def initialize(hash = {})
+        if hash.include?(:Report)
+            hash[:Report] = Puppet::Server::Report.new()
+        end
+
+        super(hash)
+    end
+
+    # Send our report.  We get the transaction report and convert it to YAML
+    # as appropriate.
+    def report(transreport)
+        report = YAML.dump(transreport)
+
+        unless self.local
+            report = CGI.escape(report)
+        end
+
+        # Now send the report
+        file = nil
+        benchmark(:info, "Sent transaction report") do
+            file = @driver.report(report)
+        end
+
+        file
+    end
+end
+
+# $Id: reporter.rb 1422 2006-07-22 03:32:56Z luke $

data/lib/puppet/client/runner.rb

@@ -0,0 +1,17 @@
+class Puppet::Client::Runner < Puppet::Client::ProxyClient
+    @drivername = :Runner
+
+    # set up the appropriate interface methods
+    @handler = Puppet::Server::Runner
+    self.mkmethods
+
+    def initialize(hash = {})
+        if hash.include?(:Runner)
+            hash[:Runner] = Puppet::Server::Runner.new()
+        end
+
+        super(hash)
+    end
+end
+
+# $Id: runner.rb 1212 2006-05-18 20:41:54Z luke $

data/lib/puppet/config.rb

@@ -9,30 +9,39 @@ class Config
 
     @@sync = Sync.new
 
+    attr_reader :file, :timer
 
     # Retrieve a config value
     def [](param)
         param = symbolize(param)
+
+        # Yay, recursion.
+        self.reparse() unless param == :filetimeout
         if @config.include?(param)
             if @config[param]
                 val = @config[param].value
                 return val
             end
         else
-            raise ArgumentError, "Invalid argument %s" % param
+            raise ArgumentError, "Undefined configuration parameter '%s'" % param
         end
     end
 
     # Set a config value.  This doesn't set the defaults, it sets the value itself.
     def []=(param, value)
-        param = symbolize(param)
-        unless @config.include?(param)
-            raise Puppet::Error, "Unknown configuration parameter %s" % param.inspect
-        end
-        unless @order.include?(param)
-            @order << param
+        @@sync.synchronize do # yay, thread-safe
+            param = symbolize(param)
+            unless @config.include?(param)
+                raise Puppet::Error,
+                    "Unknown configuration parameter %s" % param.inspect
+            end
+            unless @order.include?(param)
+                @order << param
+            end
+            @config[param].value = value
         end
-        @config[param].value = value
+
+        return value
     end
 
     # A simplified equality operator.
@@ -50,6 +59,10 @@ class Config
     # understand, and add them to the passed option list.
     def addargs(options)
         require 'getoptlong'
+
+        # Hackish, but acceptable.  Copy the current ARGV for restarting.
+        Puppet.args = ARGV.dup
+
         # Add all of the config parameters as valid options.
         self.each { |param, obj|
             if self.boolean?(param)
@@ -87,12 +100,19 @@ class Config
         end
     end
 
-    # Remove all set values.
-    def clear
+    # Remove all set values, potentially skipping cli values.
+    def clear(exceptcli = false)
         @config.each { |name, obj|
-            obj.clear
+            unless exceptcli and obj.setbycli
+                obj.clear
+            end
         }
-        @used = []
+
+        # Don't clear the 'used' in this case, since it's a config file reparse,
+        # and we want to retain this info.
+        unless exceptcli
+            @used = []
+        end
     end
 
     # This is mostly just used for testing.
@@ -100,15 +120,6 @@ class Config
         @used = []
     end
 
-    def symbolize(param)
-        case param
-        when String: return param.intern
-        when Symbol: return param
-        else
-            raise ArgumentError, "Invalid param type %s" % param.class
-        end
-    end
-
     def each
         @order.each { |name|
             if @config.include?(name)
@@ -143,12 +154,7 @@ class Config
 
     # Handle a command-line argument.
     def handlearg(opt, value = nil)
-        if value == "true"
-            value = true
-        end
-        if value == "false"
-            value = false
-        end
+        value = mungearg(value) if value
         str = opt.sub(/^--/,'')
         bool = true
         newstr = str.sub(/^no-/, '')
@@ -171,6 +177,11 @@ class Config
         end
     end
 
+    def include?(name)
+        name = name.intern if name.is_a? String
+        @config.include?(name)
+    end
+
     # Create a new config object
     def initialize
         @order = []
@@ -196,6 +207,18 @@ class Config
         end
     end
 
+    # Convert arguments appropriately.
+    def mungearg(value)
+        # Handle different data types correctly
+        return case value
+            when /^false$/i: false
+            when /^true$/i: true
+            when /^\d+$/i: Integer(value)
+            else
+                value.gsub(/^["']|["']$/,'')
+        end
+    end
+
     # Return all of the parameters associated with a given section.
     def params(section)
         section = section.intern if section.is_a? String
@@ -209,23 +232,31 @@ class Config
     # Parse a configuration file.
     def parse(file)
         text = nil
-        @file = file
+
+        if file.is_a? Puppet::ParsedFile
+            @file = file
+        else
+            @file = Puppet::ParsedFile.new(file)
+        end
+
+        # Create a timer so that this.
+        settimer()
 
         begin
-            text = File.read(file)
+            text = File.read(@file.file)
         rescue Errno::ENOENT
             raise Puppet::Error, "No such file %s" % file
         rescue Errno::EACCES
             raise Puppet::Error, "Permission denied to file %s" % file
         end
 
-        # Store it for later, in a way that we can test and such.
-        @file = Puppet::ParsedFile.new(file)
-
         @values = Hash.new { |names, name|
             names[name] = {}
         }
 
+        # Get rid of the values set by the file, keeping cli values.
+        self.clear(true)
+
         section = "puppet"
         metas = %w{owner group mode}
         values = Hash.new { |hash, key| hash[key] = {} }
@@ -236,7 +267,7 @@ class Config
             when /^\s*$/: next # Skip blanks
             when /^\s*(\w+)\s*=\s*(.+)$/: # settings
                 var = $1.intern
-                value = $2
+                value = mungearg($2)
 
                 # Mmm, "special" attributes
                 if metas.include?(var.to_s)
@@ -288,15 +319,15 @@ class Config
         case value
         when true, false, "true", "false":
             klass = CBoolean
-        when /^\$/, /^\//:
+        when /^\$\w+\//, /^\//:
             klass = CFile
         when String, Integer, Float: # nothing
             klass = CElement
         else
             raise Puppet::Error, "Invalid value '%s' for %s" % [value.inspect, hash[:name]]
         end
+        hash[:parent] = self
         element = klass.new(hash)
-        element.parent = self
 
         @order << element.name
 
@@ -313,6 +344,27 @@ class Config
         }
     end
 
+    # Reparse our config file, if necessary.
+    def reparse
+        if defined? @file and @file.changed?
+            Puppet.notice "Reparsing %s" % @file.file
+            @@sync.synchronize do
+                parse(@file)
+            end
+            reuse()
+        end
+    end
+
+    def reuse
+        return unless defined? @used
+        @@sync.synchronize do # yay, thread-safe
+            @used.each do |section|
+                @used.delete(section)
+                self.use(section)
+            end
+        end
+    end
+
     # Get a list of objects per section
     def sectionlist
         sectionlist = []
@@ -410,6 +462,28 @@ class Config
         }
     end
 
+    # Create a timer to check whether the file should be reparsed.
+    def settimer
+        if Puppet[:filetimeout] > 0
+            @timer = Puppet.newtimer(
+                :interval => Puppet[:filetimeout],
+                :tolerance => 1,
+                :start? => true
+            ) do
+                self.reparse()
+            end
+        end
+    end
+
+    def symbolize(param)
+        case param
+        when String: return param.intern
+        when Symbol: return param
+        else
+            raise ArgumentError, "Invalid param type %s" % param.class
+        end
+    end
+
     # Convert our list of objects into a component that can be applied.
     def to_component
         transport = self.to_transportable
@@ -452,8 +526,8 @@ Generated on #{Time.now}.
         }
 
         topbucket = Puppet::TransBucket.new
-        if defined? @file and @file
-            topbucket.name = @file
+        if defined? @file.file and @file.file
+            topbucket.name = @file.file
         else
             topbucket.name = "configtop"
         end
@@ -480,16 +554,6 @@ Generated on #{Time.now}.
         return manifest
     end
 
-    def reuse
-        return unless defined? @used
-        @@sync.synchronize do # yay, thread-safe
-            @used.each do |section|
-                @used.delete(section)
-                self.use(section)
-            end
-        end
-    end
-
     # Create the necessary objects to use a section.  This is idempotent;
     # you can 'use' a section as many times as you want.
     def use(*sections)
@@ -518,12 +582,22 @@ Generated on #{Time.now}.
             objects = bucket.to_type
 
             objects.finalize
+            tags = nil
+            if Puppet[:tags]
+                tags = Puppet[:tags]
+                Puppet[:tags] = ""
+            end
             trans = objects.evaluate
             trans.evaluate
+            if tags
+                Puppet[:tags] = tags
+            end
 
             # Remove is a recursive process, so it's sufficient to just call
             # it on the component.
-            objects.remove
+            objects.remove(true)
+
+            objects = nil
 
             runners.each { |s| @used << s }
         end
@@ -618,8 +692,9 @@ Generated on #{Time.now}.
             if value =~ /\$(\w+)/
                 parent = $1
                 if pval = @parent[parent]
-                    newval = value.sub(/\$#{parent}/, pval)
-                    return File.join(newval.split("/"))
+                    newval = value.to_s.sub(/\$#{parent.to_s}/, pval.to_s)
+                    #return File.join(newval.split("/"))
+                    return newval
                 else
                     raise Puppet::DevError, "Could not find value for %s" % parent
                 end
@@ -634,6 +709,10 @@ Generated on #{Time.now}.
 
         # Create the new element.  Pretty much just sets the name.
         def initialize(args = {})
+            if args.include?(:parent)
+                self.parent = args[:parent]
+                args.delete(:parent)
+            end
             args.each do |param, value|
                 method = param.to_s + "="
                 unless self.respond_to? method
@@ -802,7 +881,7 @@ Generated on #{Time.now}.
             obj[:loglevel] = "debug"
 
             if self.section
-                obj.tags = ["puppet", "configuration", self.section]
+                obj.tags += ["puppet", "configuration", self.section, self.name]
             end
             objects << obj
             objects
@@ -812,9 +891,11 @@ Generated on #{Time.now}.
         def validate(value)
             return true unless value.is_a? String
             value.scan(/\$(\w+)/) { |name|
-                name = name[0]
-                unless @parent[name]
-                    raise Puppet::Error, "'%s' is unset" % name
+                name = $1
+                unless @parent.include?(name)
+                    raise ArgumentError,
+                        "Configuration parameter '%s' is undefined" %
+                        name
                 end
             }
         end
@@ -835,4 +916,4 @@ Generated on #{Time.now}.
 end
 end
 
-# $Id: config.rb 1111 2006-04-12 17:36:14Z luke $
+# $Id: config.rb 1421 2006-07-21 23:12:51Z luke $