puppet 0.24.7 → 0.24.8

data/lib/puppet/parser/functions/sprintf.rb

@@ -0,0 +1,17 @@
+module Puppet::Parser::Functions
+    newfunction(:sprintf, :type => :rvalue,
+		:doc => "\
+	Perform printf-style formatting of text.
+
+	The first parameter is format string describing how the rest of the
+	parameters should be formatted.  See the documentation for the
+	``Kernel::sprintf()`` function in Ruby for all the details.
+	") \
+    do |args|
+	if args.length < 1
+	    raise Puppet::ParseError, 'sprintf() needs at least one argument'
+	end
+	fmt = args.shift()
+	return sprintf(fmt, *args)
+    end
+end

data/lib/puppet/parser/functions/versioncmp.rb

@@ -0,0 +1,10 @@
+require 'puppet/util/package'
+
+Puppet::Parser::Functions::newfunction(:versioncmp,  :doc => "Compares two versions.") do |args|
+
+    unless args.length == 2
+        raise Puppet::ParseError, "versioncmp should have 2 arguments"
+    end
+
+    return Puppet::Util::Package.versioncmp(args[0], args[1])
+end

data/lib/puppet/parser/resource.rb

@@ -4,13 +4,17 @@ class Puppet::Parser::Resource
     require 'puppet/parser/resource/param'
     require 'puppet/parser/resource/reference'
     require 'puppet/util/tagging'
+    require 'puppet/file_collection/lookup'
+
+    include Puppet::FileCollection::Lookup
+
     include Puppet::Util
     include Puppet::Util::MethodHelper
     include Puppet::Util::Errors
     include Puppet::Util::Logging
     include Puppet::Util::Tagging
 
-    attr_accessor :source, :line, :file, :scope, :rails_id
+    attr_accessor :source, :scope, :rails_id
     attr_accessor :virtual, :override, :translated
 
     attr_reader :exported, :evaluated, :params
@@ -181,11 +185,11 @@ class Puppet::Parser::Resource
             hash
         end
         
-        db_resource.ar_hash_merge(db_resource.get_params_hash(db_resource.param_values), updated_params,
+        db_resource.ar_hash_merge(db_resource.get_params_hash(), updated_params,
                                   :create => Proc.new { |name, parameter|
                                       parameter.to_rails(db_resource)
                                   }, :delete => Proc.new { |values|
-                                      values.each { |value| db_resource.param_values.delete(value) }
+                                      values.each { |value| Puppet::Rails::ParamValue.delete(value['id']) }
                                   }, :modify => Proc.new { |db, mem|
                                       mem.modify_rails_values(db)
                                   })
@@ -194,13 +198,13 @@ class Puppet::Parser::Resource
             hash[tag] = tag
             hash
         }
-            
+
         db_resource.ar_hash_merge(db_resource.get_tag_hash(), 
                                   updated_tags,
                                   :create => Proc.new { |name, tag|
                                       db_resource.add_resource_tag(name)
                                   }, :delete => Proc.new { |tag|
-                                      db_resource.resource_tags.delete(tag)
+                                      Puppet::Rails::ResourceTag.delete(tag['id'])
                                   }, :modify => Proc.new { |db, mem|
                                       # nothing here
                                   })
@@ -437,7 +441,7 @@ class Puppet::Parser::Resource
             # 'type' isn't a valid column name, so we have to use another name.
             to = (param == :type) ? :restype : param
             if value = self.send(param)
-                hash[to] = value 
+                hash[to] = value
             end
             hash
         end

data/lib/puppet/parser/resource/param.rb

@@ -1,10 +1,14 @@
+require 'puppet/file_collection/lookup'
+
  # The parameters we stick in Resources.
 class Puppet::Parser::Resource::Param
-    attr_accessor :name, :value, :source, :line, :file, :add
+    attr_accessor :name, :value, :source, :add
     include Puppet::Util
     include Puppet::Util::Errors
     include Puppet::Util::MethodHelper
 
+    include Puppet::FileCollection::Lookup
+
     def initialize(hash)
         set_options(hash)
         requiredopts(:name, :value, :source)
@@ -12,7 +16,7 @@ class Puppet::Parser::Resource::Param
     end
 
     def inspect
-        "#<#{self.class} @name => #{name}, @value => #{value}, @source => #{source.name}>"
+        "#<#{self.class} @name => #{name}, @value => #{value}, @source => #{source.name}, @line => #{line}>"
     end
 
     def line_to_i
@@ -39,7 +43,6 @@ class Puppet::Parser::Resource::Param
 
         param_name = Puppet::Rails::ParamName.find_or_create_by_name(self.name.to_s)
         line_number = line_to_i()
-
         return values.collect do |v|
             db_resource.param_values.create(:value => v,
                                            :line => line_number,
@@ -48,18 +51,18 @@ class Puppet::Parser::Resource::Param
     end
 
     def modify_rails_values(db_values)
-        #dev_warn if db_values.nil? || db_values.empty? 
+        #dev_warn if db_values.nil? || db_values.empty?
 
         values_to_remove(db_values).each { |remove_me|
-            Puppet::Rails::ParamValue.delete(remove_me.id)
+            Puppet::Rails::ParamValue.delete(remove_me['id'])
         }
         line_number = line_to_i()
-        values_to_add(db_values).each { |add_me| 
-            db_resource = db_values[0].resource
-            db_param_name = db_values[0].param_name
-            db_resource.param_values.create(:value => add_me,
+        db_param_name = db_values[0]['param_name_id']
+        values_to_add(db_values).each { |add_me|
+            Puppet::Rails::ParamValue.create(:value => add_me,
                                            :line => line_number,
-                                           :param_name => db_param_name)
+                                           :param_name_id => db_param_name,
+                                           :resource_id => db_values[0]['resource_id'] )
         }
     end
     
@@ -79,9 +82,9 @@ class Puppet::Parser::Resource::Param
         values = munge_for_rails(value)
         line_number = line_to_i()
         db_values.collect do |db|
-            db unless (db.line == line_number && 
+            db unless (db['line'] == line_number && 
                        values.find { |v| 
-                         compare(v,db.value)
+                         compare(v,db['value'])
                        } )
         end.compact
     end
@@ -90,8 +93,8 @@ class Puppet::Parser::Resource::Param
         values = munge_for_rails(value)
         line_number = line_to_i()
         values.collect do |v|
-            v unless db_values.find { |db| (compare(v,db.value) && 
-                                         line_number == db.line) }
+            v unless db_values.find { |db| (compare(v,db['value']) && 
+                                         line_number == db['line']) }
         end.compact
     end
 end

data/lib/puppet/parser/resource/reference.rb

@@ -1,7 +1,9 @@
 require 'puppet/resource_reference'
+require 'puppet/file_collection/lookup'
 
 # A reference to a resource.  Mostly just the type and title.
 class Puppet::Parser::Resource::Reference < Puppet::ResourceReference
+    include Puppet::FileCollection::Lookup
     include Puppet::Util::MethodHelper
     include Puppet::Util::Errors
 

data/lib/puppet/parser/scope.rb

@@ -52,11 +52,11 @@ class Puppet::Parser::Scope
         if value.is_a?(String)
             if value =~ /^-?\d+(:?\.\d+|(:?\.\d+)?e\d+)$/
                 return value.to_f
-            elsif value =~ /^0x\d+/i
+            elsif value =~ /^0x[0-9a-f]+$/i
                 return value.to_i(16)
-            elsif value =~ /^0\d+/i
+            elsif value =~ /^0[0-7]+$/
                 return value.to_i(8)
-            elsif value =~ /^-?\d+/
+            elsif value =~ /^-?\d+$/
                 return value.to_i
             else
                 return nil

data/lib/puppet/property/list.rb

@@ -10,7 +10,11 @@ module Puppet
             end
 
             def is_to_s(currentvalue)
-                currentvalue.join(delimiter)
+                if currentvalue == :absent
+                    return "absent"
+                else
+                    return currentvalue.join(delimiter)
+                end
             end
 
             def membership

data/lib/puppet/provider/augeas/augeas.rb

@@ -20,13 +20,17 @@
 require 'augeas' if Puppet.features.augeas?
 
 Puppet::Type.type(:augeas).provide(:augeas) do
-#class Puppet::Provider::Augeas < Puppet::Provider
     include Puppet::Util
-    
-    confine :true => Puppet.features.augeas?   
-    
+
+    confine :true => Puppet.features.augeas?
+
     has_features :parse_commands, :need_to_run?,:execute_changes
 
+    SAVE_NOOP = "noop"
+    SAVE_OVERWRITE = "overwrite"
+
+    attr_accessor :aug
+
     # Extracts an 2 dimensional array of commands which are in the
     # form of command path value.
     # The input can be
@@ -38,10 +42,27 @@ Puppet::Type.type(:augeas).provide(:augeas) do
         if data.is_a?(String)
             data.each_line do |line|
                 cmd_array = Array.new()
-                tokens = line.split(" ")
-                cmd = tokens.shift()
-                file = tokens.shift()
-                other = tokens.join(" ")
+                single = line.index("'")
+                double = line.index('"')
+                tokens = nil
+                delim = " "
+                if ((single != nil) or (double != nil))
+                    single = 99999 if single == nil
+                    double = 99999 if double == nil
+                    delim = '"' if double < single
+                    delim = "'" if single < double
+                end
+                tokens = line.split(delim)
+                # If the length of tokens is 2, thn that means the pattern was
+                # command file "some text", therefore we need to re-split
+                # the first line
+                if tokens.length == 2
+                    tokens = (tokens[0].split(" ")) << tokens[1]
+                end
+                cmd = tokens.shift().strip()
+                delim = "" if delim == " "
+                file = tokens.shift().strip()
+                other = tokens.join(" ").strip()
                 cmd_array << cmd if !cmd.nil?
                 cmd_array << file if !file.nil?
                 cmd_array << other if other != ""
@@ -52,19 +73,34 @@ Puppet::Type.type(:augeas).provide(:augeas) do
                 commands.concat(parse_commands(datum))
             end
         end
-
         return commands
     end
 
+
     def open_augeas
-        flags = 0
-        (flags = 1 << 2 ) if self.resource[:type_check] == :true
-        root = self.resource[:root]
-        load_path = self.resource[:load_path]
-        debug("Opening augeas with root #{root}, lens path #{load_path}, flags #{flags}")
-        Augeas.open(root, load_path,flags)
+        if (@aug.nil?)
+            flags = 0
+            (flags = 1 << 2 ) if self.resource[:type_check] == :true
+            root = self.resource[:root]
+            load_path = self.resource[:load_path]
+            debug("Opening augeas with root #{root}, lens path #{load_path}, flags #{flags}")
+            @aug = Augeas.open(root, load_path,flags)
+
+            if (self.get_augeas_version() >= "0.3.6")
+                debug("Augeas version #{self.get_augeas_version()} is installed")
+            end
+        end
+        @aug
+    end
+
+    def close_augeas
+        if (!@aug.nil?)
+            @aug.close()
+            debug("Closed the augeas connection")
+            @aug = nil;
+        end
     end
-    
+
     # Used by the need_to_run? method to process get filters. Returns
     # true if there is a match, false if otherwise
     # Assumes a syntax of get /files/path [COMPARATOR] value
@@ -79,8 +115,7 @@ Puppet::Type.type(:augeas).provide(:augeas) do
         arg = cmd_array.join(" ")
 
         #check the value in augeas
-        aug = open_augeas()
-        result = aug.get(path) || ''
+        result = @aug.get(path) || ''
         unless result.nil?
             case comparator
                 when "!=":
@@ -94,8 +129,8 @@ Puppet::Type.type(:augeas).provide(:augeas) do
             end
         end
         return_value
-    end    
-    
+    end
+
     # Used by the need_to_run? method to process match filters. Returns
     # true if there is a match, false if otherwise
     def process_match(cmd_array)
@@ -108,10 +143,9 @@ Puppet::Type.type(:augeas).provide(:augeas) do
         verb = cmd_array.shift()
 
         #Get the values from augeas
-        aug = open_augeas()
-        result = aug.match(path) || ''
+        result = @aug.match(path) || ''
         # Now do the work
-        if (!result.nil?)
+        unless (result.nil?)
             case verb
                 when "size":
                     fail("Invalid command: #{cmd_array.join(" ")}") if cmd_array.length != 2
@@ -132,11 +166,26 @@ Puppet::Type.type(:augeas).provide(:augeas) do
             end
         end
         return_value
-    end    
-    
+    end
+
+    def get_augeas_version
+        return @aug.get("/augeas/version") || ""
+    end
+
+    def set_augeas_save_mode(mode)
+        return @aug.set("/augeas/save", mode)
+    end
+
+    def files_changed?
+        saved_files = @aug.match("/augeas/events/saved")
+        return saved_files.size() > 0
+    end
+
     # Determines if augeas acutally needs to run.
     def need_to_run?
+        force = resource[:force]
         return_value = true
+        self.open_augeas()
         filter = resource[:onlyif]
         unless (filter == "")
             cmd_array = filter.split
@@ -152,38 +201,91 @@ Puppet::Type.type(:augeas).provide(:augeas) do
                 fail("Error sending command '#{command}' with params #{cmd_array[1..-1].inspect}/#{e.message}")
             end
         end
-        return_value
-    end 
-    
-    # Actually execute the augeas changes.
+
+        unless (force)
+            # If we have a verison of augeas which is at least 0.3.6 then we
+            # can make the changes now, see if changes were made, and
+            # actually do the save.
+            if ((return_value) and (self.get_augeas_version() >= "0.3.6"))
+                debug("Will attempt to save and only run if files changed")
+                self.set_augeas_save_mode(SAVE_NOOP)
+                self.do_execute_changes()
+                save_result = @aug.save()
+                saved_files = @aug.match("/augeas/events/saved")
+                if ((save_result) and (not files_changed?))
+                    debug("Skipping becuase no files were changed")
+                    return_value = false
+                else
+                    debug("Files changed, should execute")
+                end
+            end
+        end
+        self.close_augeas()
+        return return_value
+    end
+
     def execute_changes
-        aug = open_augeas
-        commands = resource[:changes]
+        # Re-connect to augeas, and re-execute the changes
+        self.open_augeas()
+        if (self.get_augeas_version() >= "0.3.6")
+            self.set_augeas_save_mode(SAVE_OVERWRITE)
+        end
+
+        self.do_execute_changes()
+
+        success = @aug.save()
+        if (success != true)
+            fail("Save failed with return code #{success}")
+        end
+        self.close_augeas()
+
+        return :executed
+    end
+
+    # Actually execute the augeas changes.
+    def do_execute_changes
+        commands = resource[:changes].clone()
         context = resource[:context]
         commands.each do |cmd_array|
+            cmd_array = cmd_array.clone()
             fail("invalid command #{cmd_array.join[" "]}") if cmd_array.length < 2
             command = cmd_array[0]
             cmd_array.shift()
-            cmd_array[0]=File.join(context, cmd_array[0])
-            debug("sending command '#{command}' with params #{cmd_array.inspect}")
             begin
                 case command
-                    when "set": aug.set(cmd_array[0], cmd_array[1])
-                    when "rm", "remove": aug.rm(cmd_array[0])
-                    when "clear": aug.clear(cmd_array[0])
-                    when "insert", "ins": aug.insert(cmd_array[0])
+                    when "set":
+                        cmd_array[0]=File.join(context, cmd_array[0])
+                        debug("sending command '#{command}' with params #{cmd_array.inspect}")
+                        @aug.set(cmd_array[0], cmd_array[1])
+                    when "rm", "remove":
+                        cmd_array[0]=File.join(context, cmd_array[0])
+                        debug("sending command '#{command}' with params #{cmd_array.inspect}")
+                        @aug.rm(cmd_array[0])
+                    when "clear":
+                        cmd_array[0]=File.join(context, cmd_array[0])
+                        debug("sending command '#{command}' with params #{cmd_array.inspect}")
+                        @aug.clear(cmd_array[0])
+                    when "insert", "ins"
+                        ext_array = cmd_array[1].split(" ") ;
+                        if cmd_array.size < 2 or ext_array.size < 2
+                            fail("ins requires 3 parameters")
+                        end
+                        label = cmd_array[0]
+                        where = ext_array[0]
+                        path = File.join(context, ext_array[1])
+                        case where
+                            when "before": before = true
+                            when "after": before = false
+                            else fail("Invalid value '#{where}' for where param")
+                        end
+                        debug("sending command '#{command}' with params #{[label, where, path].inspect()}")
+                        aug.insert(path, label, before)
                     else fail("Command '#{command}' is not supported")
                 end
             rescue Exception => e
                 fail("Error sending command '#{command}' with params #{cmd_array.inspect}/#{e.message}")
             end
         end
-        success = aug.save()
-        if (success != true)
-            fail("Save failed with return code #{success}")
-        end
+    end
 
-        return :executed    
-    end   
-    
 end