puppet 0.24.8 → 0.24.9

data/CHANGELOG

@@ -1,3 +1,6 @@
+0.24.9
+    Fix for temporary file issues (https://bugzilla.redhat.com/show_bug.cgi?id=502881)
+
 0.24.8
     Fixed #2077 - ralsh user broken on OSX
     

data/Rakefile

@@ -163,6 +163,9 @@ namespace :ci do
     ENV['CI_REPORTS'] = 'results'
   end
 
+  desc "Run all CI tests"
+  task :all => [:unit, :spec]
+
   desc "Run CI Unit tests"
   task :unit => [:prep, 'ci:setup:testunit'] do
      sh "cd test; rake test; exit 0"

data/ext/puppet-test

@@ -53,6 +53,11 @@
 # list::
 #   List all available tests.
 #
+# node::
+#  Specify the node to use.  This is useful for looking up cached yaml data
+#  in your :clientyaml directory, and forcing a specific host's configuration to
+#  get compiled.
+#
 # pause::
 #  Pause before starting test (useful for testing with dtrace).
 #
@@ -216,7 +221,7 @@ end
 
 Suite.new :local_catalog, "Local catalog handling" do
     def prepare
-        @node = Puppet::Node.find(Puppet[:certname])
+        @node = Puppet::Node.find($options[:nodes][0])
     end
 
     newtest :compile, "Compiled catalog" do
@@ -233,15 +238,10 @@ Suite.new :remote_catalog, "Remote catalog handling" do
             fail "Could not read client certificate"
         end
 
-        # Use the facts from the cache, to skip the time it takes
-        # to load them.
-        @client.dostorage
-        @facts = Puppet::Util::Storage.cache(:configuration)[:facts] || {}
-
-        if @facts.empty?
-            if tmp = Puppet::Node::Facts.find("me")
-                @facts = tmp.values
-            end
+        if tmp = Puppet::Node::Facts.find($options[:nodes][0])
+            @facts = tmp.values
+        else
+            raise "Could not find facts for %s" % $optins[:nodes][0]
         end
 
         if host = $options[:fqdn]
@@ -374,6 +374,7 @@ $cmdargs = [
 	[ "--test",      "-t",			GetoptLong::REQUIRED_ARGUMENT ],
 	[ "--pause",	 "-p",			GetoptLong::NO_ARGUMENT ],
 	[ "--repeat",    "-r",			GetoptLong::REQUIRED_ARGUMENT ],
+	[ "--node",      "-n",			GetoptLong::REQUIRED_ARGUMENT ],
 	[ "--debug",	 "-d",			GetoptLong::NO_ARGUMENT ],
 	[ "--help",		 "-h",			GetoptLong::NO_ARGUMENT ],
 	[ "--list",	     "-l",			GetoptLong::NO_ARGUMENT ],
@@ -385,11 +386,16 @@ $cmdargs = [
 Puppet.settings.addargs($cmdargs)
 Puppet::Util::Log.newdestination(:console)
 
+Puppet::Node.terminus_class = :plain
+Puppet::Node.cache_class = :yaml
+Puppet::Node::Facts.terminus_class = :facter
+Puppet::Node::Facts.cache_class = :yaml
+
 result = GetoptLong.new(*$cmdargs)
 
 $args = {}
 
-$options = {:repeat => 1, :fork => 0, :pause => false}
+$options = {:repeat => 1, :fork => 0, :pause => false, :nodes => []}
 
 begin
     explicit_waitforcert = false
@@ -443,6 +449,8 @@ begin
                 $options[:file] = arg
             when "--pause"
                 $options[:pause] = true
+            when "--node"
+                $options[:nodes] << arg
             when "--list"
                 Suite.suites.sort { |a,b| a.to_s <=> b.to_s }.each do |suite_name|
                     suite = Suite[suite_name]
@@ -463,6 +471,8 @@ end
 # Now parse the config
 Puppet.parse_config
 
+$options[:nodes] << Puppet.settings[:certname] if $options[:nodes].empty?
+
 $args[:Server] = Puppet[:server]
 
 unless $options[:test]
@@ -481,5 +491,3 @@ Suite.run($options[:test])
 if $options[:fork] > 0
     Process.waitall
 end
-
-# $Id$

data/lib/puppet.rb

@@ -25,7 +25,7 @@ require 'puppet/util/suidmanager'
 # it's also a place to find top-level commands like 'debug'
 
 module Puppet
-    PUPPETVERSION = '0.24.8'
+    PUPPETVERSION = '0.24.9'
 
     def Puppet.version
         return PUPPETVERSION

data/lib/puppet/daemon.rb

@@ -30,7 +30,7 @@ module Puppet::Daemon
             $stderr.reopen $stdout
             Puppet::Util::Log.reopen
         rescue => detail
-            File.open("/tmp/daemonout", "w") { |f|
+            Puppet::Util.secure_open("/tmp/daemonout", "w") { |f|
                 f.puts "Could not start %s: %s" % [Puppet[:name], detail]
             }
             Puppet.err "Could not start %s: %s" % [Puppet[:name], detail]

data/lib/puppet/parser/functions.rb

@@ -92,7 +92,7 @@ module Functions
             #ret += "%s\n%s\n" % [name, hash[:type]]
             ret += "%s\n%s\n" % [name, "-" * name.to_s.length]
             if hash[:doc]
-                ret += hash[:doc].gsub(/\n\s*/, ' ')
+                ret += Puppet::Util::Docs.scrub(hash[:doc])
             else
                 ret += "Undocumented.\n"
             end

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

@@ -1,63 +1,39 @@
 module Puppet::Parser::Functions
     newfunction(:regsubst, :type => :rvalue,
-		:doc => "\
-	Perform regexp replacement on a string.
+		:doc => "
+                Perform regexp replacement on a string. Parameters (in order):
 
-	Parameters (in order):
+:str:  The string to operate on.
 
-	:str:
-		The string to operate on.
+:regexp:  The regular expression matching the string.  If you want it anchored at the start and or end of the string, you must do that with ^ and $ yourself.
 
-	:regexp:
-		The regular expression matching the string.  If you want it
-		anchored at the start and/or end of the string, you must do
-		that with ^ and $ yourself.
+:replacement:  Replacement string. Can contain back references to what was matched using 0, 1, and so on.
 
-	:replacement:
-		Replacement string.  Can contain back references to what was
-		matched using \\0, \\1, and so on.
+:flags:  Optional. String of single letter flags for how the regexp is interpreted:
 
-	:flags:
-		Optional.  String of single letter flags for how the regexp
-		is interpreted:
+    - **E**         Extended regexps
+    - **I**         Ignore case in regexps
+    - **M**         Multiline regexps
+    - **G**         Global replacement; all occurrences of the regexp in the string will be replaced.  Without this, only the first occurrence will be replaced.
 
-		- **E**
-			Extended regexps
-		- **I**
-			Ignore case in regexps
-		- **M**
-			Multiline regexps
-		- **G**
-			Global replacement; all occurances of the regexp in
-			the string will be replaced.  Without this, only the
-			first occurance will be replaced.
+:lang:  Optional.  How to handle multibyte characters.  A single-character string with the following values:
+     
+     - **N**         None
+     - **E**         EUC
+     - **S**         SJIS
+     - **U**         UTF-8
 
-	:lang:
-		Optional.  How to handle multibyte characters.  A
-		single-character string with the following values:
+**Examples**
 
-		- **N**
-			None
-		- **E**
-			EUC
-		- **S**
-			SJIS
-		- **U**
-			UTF-8
+Get the third octet from the node's IP address::
 
-	**Examples**
+    $i3 = regsubst($ipaddress,'^([0-9]+)[.]([0-9]+)[.]([0-9]+)[.]([0-9]+)$','\\3')
 
-	Get the third octet from the node's IP address: ::
+Put angle brackets around each octet in the node's IP address::
 
-	    $i3 = regsubst($ipaddress,
-			   '^([0-9]+)[.]([0-9]+)[.]([0-9]+)[.]([0-9]+)$',
-			   '\\\\3')
-
-	Put angle brackets around each octet in the node's IP address: ::
-
-	    $x = regsubst($ipaddress, '([0-9]+)', '<\\\\1>', 'G')
-	") \
-    do |args|
+    $x = regsubst($ipaddress, '([0-9]+)', '<\\1>', 'G')
+") \
+        do |args|
 	flag_mapping = {
 	    "E" => Regexp::EXTENDED,
 	    "I" => Regexp::IGNORECASE,

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

@@ -1,13 +1,8 @@
 module Puppet::Parser::Functions
     newfunction(:sprintf, :type => :rvalue,
-		:doc => "\
-	Perform printf-style formatting of text.
+		: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|
+                         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

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

@@ -18,6 +18,7 @@
 # Author: Bryan Kearney <bkearney@redhat.com>
 
 require 'augeas' if Puppet.features.augeas?
+require 'strscan'
 
 Puppet::Type.type(:augeas).provide(:augeas) do
     include Puppet::Util
@@ -29,6 +30,22 @@ Puppet::Type.type(:augeas).provide(:augeas) do
     SAVE_NOOP = "noop"
     SAVE_OVERWRITE = "overwrite"
 
+    COMMANDS = {
+      "set" => [ :path, :string ],
+      "rm" => [ :path ],
+      "clear" => [ :path ],
+      "insert" => [ :string, :string, :path ],
+      "get" => [ :path, :comparator, :string ],
+      "match" => [ :path, :glob ],
+      "size" => [:comparator, :int],
+      "include" => [:string],
+      "eq" => [:glob],
+      "noteq" => [:glob]
+    }
+
+    COMMANDS["ins"] = COMMANDS["insert"]
+    COMMANDS["remove"] = COMMANDS["rm"]    
+
     attr_accessor :aug
 
     # Extracts an 2 dimensional array of commands which are in the
@@ -38,42 +55,76 @@ Puppet::Type.type(:augeas).provide(:augeas) do
     # - A string with many commands per line
     # - An array of strings.
     def parse_commands(data)
-        commands = Array.new()
+        context = resource[:context]
+        # Add a trailing / if it is not there
+        if (context.length > 0)
+            context << "/" if context[-1, 1] != "/"
+        end
+
         if data.is_a?(String)
-            data.each_line do |line|
-                cmd_array = Array.new()
-                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]
+            s = data
+            data = []
+            s.each_line { |line| data << line }
+        end
+        args = []
+        data.each do |line|
+            argline = []
+            sc = StringScanner.new(line)
+            cmd = sc.scan(/\w+/)
+            formals = COMMANDS[cmd]
+            fail("Unknown command #{cmd}") unless formals
+            argline << cmd
+            narg = 0
+            formals.each do |f|
+                sc.skip(/\s+/)
+                narg += 1
+                if f == :path
+                    start = sc.pos
+                    nbracket = 0
+                    begin
+                        sc.skip(/[^\]\[\s]+/)
+                        ch = sc.getch
+                        nbracket += 1 if ch == "["
+                        nbracket -= 1 if ch == "]"
+                        fail("unmatched [") if nbracket < 0
+                    end until nbracket == 0 && (sc.eos? || ch =~ /\s/)
+                        len = sc.pos - start
+                        len -= 1 unless sc.eos?
+                    unless p = sc.string[start, len]
+                        fail("missing path argument #{narg} for #{cmd}")
+                    end
+                    if p[0,1] != "$" && p[0,1] != "/"
+                        argline << context + p
+                    else
+                        argline << p
+                    end
+                elsif f == :string
+                    delim = sc.peek(1)
+                    if delim == "'" || delim == "\""
+                        sc.getch
+                        argline << sc.scan(/([^\\#{delim}]|(\\.))*/)
+                        sc.getch
+                    else
+                        argline << sc.scan(/[^\s]+/)
+                    end
+                    unless argline[-1]
+                        fail(raise Exception, "missing string argument #{narg} for #{cmd}")
+                    end
+                elsif f == :comparator
+                    argline << sc.scan(/(==|!=|=~|<|<=|>|>=)/)
+                    unless argline[-1]
+                        puts sc.rest() 
+                        fail(raise Exception, "invalid comparator for command #{cmd}")
+                    end
+                elsif f == :int
+                    argline << sc.scan(/\d+/).to_i
+                elsif f== :glob
+                    argline << sc.rest()
                 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 != ""
-                commands << cmd_array
-            end
-        elsif data.is_a?(Array)
-            data.each do |datum|
-                commands.concat(parse_commands(datum))
             end
+            args << argline
         end
-        return commands
+        return args
     end
 
 
@@ -137,10 +188,13 @@ Puppet::Type.type(:augeas).provide(:augeas) do
         return_value = false
 
         #validate and tear apart the command
-        fail("Invalid command: #{cmd_array.join(" ")}") if cmd_array.length < 4
+        fail("Invalid command: #{cmd_array.join(" ")}") if cmd_array.length < 3
         cmd = cmd_array.shift()
         path = cmd_array.shift()
-        verb = cmd_array.shift()
+
+        # Need to break apart the clause
+        clause_array = parse_commands(cmd_array.shift())[0]
+        verb = clause_array.shift()
 
         #Get the values from augeas
         result = @aug.match(path) || ''
@@ -148,21 +202,29 @@ Puppet::Type.type(:augeas).provide(:augeas) do
         unless (result.nil?)
             case verb
                 when "size":
-                    fail("Invalid command: #{cmd_array.join(" ")}") if cmd_array.length != 2
-                    comparator = cmd_array.shift()
-                    arg = cmd_array.shift().to_i
+                    fail("Invalid command: #{cmd_array.join(" ")}") if clause_array.length != 2
+                    comparator = clause_array.shift()
+                    arg = clause_array.shift()
                     return_value = true if (result.size.send(comparator, arg))
                 when "include":
-                    arg = cmd_array.join(" ")
+                    arg = clause_array.shift()
                     return_value = true if result.include?(arg)
-                when "==":
+                when "eq":
                     begin
-                        arg = cmd_array.join(" ")
+                        arg = clause_array.shift()
                         new_array = eval arg
                         return_value = true if result == new_array
                     rescue
                         fail("Invalid array in command: #{cmd_array.join(" ")}")
                     end
+                when "noteq":
+                    begin
+                        arg = clause_array.shift()
+                        new_array = eval arg
+                        return_value = true if result != new_array
+                    rescue
+                        fail("Invalid array in command: #{cmd_array.join(" ")}")
+                    end                    
             end
         end
         return_value
@@ -188,11 +250,9 @@ Puppet::Type.type(:augeas).provide(:augeas) do
         self.open_augeas()
         filter = resource[:onlyif]
         unless (filter == "")
-            cmd_array = filter.split
+            cmd_array = parse_commands(filter)[0]
             command = cmd_array[0];
-            cmd_array[1]= File.join(resource[:context], cmd_array[1])
             begin
-                data = nil
                 case command
                     when "get" then return_value = process_get(cmd_array)
                     when "match" then return_value = process_match(cmd_array)
@@ -244,35 +304,26 @@ Puppet::Type.type(:augeas).provide(:augeas) do
 
     # Actually execute the augeas changes.
     def do_execute_changes
-        commands = resource[:changes].clone()
-        context = resource[:context]
+        commands = parse_commands(resource[:changes])
         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()
             begin
                 case command
                     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])
+                        where = cmd_array[1]
+                        path = cmd_array[2]
                         case where
                             when "before": before = true
                             when "after": before = false