puppet 0.24.6 → 0.24.7

data/lib/puppet/parser/parser_support.rb

@@ -18,6 +18,7 @@ class Puppet::Parser::Parser
     attr_reader :version, :environment
     attr_accessor :files
 
+    attr_accessor :lexer
 
     # Add context to a message; useful for error messages and such.
     def addcontext(message, obj = nil)
@@ -56,7 +57,9 @@ class Puppet::Parser::Parser
             end
         end
 
-        return klass.new(hash)
+        k = klass.new(hash)
+        k.doc = lexer.getcomment if !k.nil? and k.use_docs and k.doc.empty?
+        return k
     end
 
     # The fully qualifed name, with the full namespace.
@@ -272,6 +275,7 @@ class Puppet::Parser::Parser
         end
         code = options[:code]
         parent = options[:parent]
+        doc = options[:doc]
 
         # If the class is already defined, then add code to it.
         if other = @astset.classes[name]
@@ -291,15 +295,25 @@ class Puppet::Parser::Parser
                 if tmp == ""
                     tmp = "main"
                 end
-                
+
                 Puppet.debug addcontext("Adding code to %s" % tmp)
                 # Else, add our code to it.
                 if other.code and code
+                    # promote if neededcodes to ASTArray so that we can append code
+                    # ASTArray knows how to evaluate its members.
+                    other.code = ast AST::ASTArray, :children => [other.code] unless other.code.is_a?(AST::ASTArray)
+                    code = ast AST::ASTArray, :children => [code] unless code.is_a?(AST::ASTArray)
                     other.code.children += code.children
                 else
                     other.code ||= code
                 end
             end
+
+            if other.doc and doc
+                other.doc += doc
+            else
+                other.doc ||= doc
+            end
         else
             # Define it anew.
             # Note we're doing something somewhat weird here -- we're setting
@@ -308,6 +322,8 @@ class Puppet::Parser::Parser
             args = {:namespace => name, :classname => name, :parser => self}
             args[:code] = code if code
             args[:parentclass] = parent if parent
+            args[:doc] = doc
+
             @astset.classes[name] = ast AST::HostClass, args
         end
 
@@ -332,7 +348,8 @@ class Puppet::Parser::Parser
             :arguments => options[:arguments],
             :code => options[:code],
             :parser => self,
-            :classname => name
+            :classname => name,
+            :doc => options[:doc]
         }
 
         [:code, :arguments].each do |param|
@@ -346,6 +363,7 @@ class Puppet::Parser::Parser
     # table, not according to namespaces.
     def newnode(names, options = {})
         names = [names] unless names.instance_of?(Array)
+        doc = lexer.getcomment
         names.collect do |name|
             name = name.to_s.downcase
             if other = @astset.nodes[name]
@@ -354,7 +372,8 @@ class Puppet::Parser::Parser
             name = name.to_s if name.is_a?(Symbol)
             args = {
                 :name => name,
-                :parser => self
+                :parser => self,
+                :doc => doc
             }
             if options[:code]
                 args[:code] = options[:code]
@@ -395,6 +414,7 @@ class Puppet::Parser::Parser
             self.string = string
         end
         begin
+            @yydebug = false
             main = yyparse(@lexer,:scan)
         rescue Racc::ParseError => except
             error = Puppet::ParseError.new(except)

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

@@ -37,7 +37,7 @@ class Puppet::Parser::Resource::Reference < Puppet::ResourceReference
                 if self.title == :main
                     tmp = @scope.findclass("")
                 else
-                    unless tmp = @scope.findclass(self.title)
+                    unless tmp = @scope.parser.classes[self.title]
                         fail Puppet::ParseError, "Could not find class '%s'" % self.title
                     end
                 end
@@ -46,8 +46,9 @@ class Puppet::Parser::Resource::Reference < Puppet::ResourceReference
                     fail Puppet::ParseError, "Could not find node '%s'" % self.title
                 end
             else # normal definitions
-                # We have to swap these variables around so the errors are right.
-                tmp = @scope.finddefine(self.type)
+                # The resource type is capitalized, so we have to downcase.  Really,
+                # we should have a better interface for finding these, but eh.
+                tmp = @scope.parser.definitions[self.type.downcase]
             end
 
             if tmp

data/lib/puppet/parser/templatewrapper.rb

@@ -1,33 +1,18 @@
 # A simple wrapper for templates, so they don't have full access to
 # the scope objects.
 class Puppet::Parser::TemplateWrapper
-    attr_accessor :scope, :file
+    attr_accessor :scope, :file, :string
     include Puppet::Util
     Puppet::Util.logmethods(self)
 
-    def initialize(scope, filename)
+    def initialize(scope)
         @__scope__ = scope
-        @__file__ = Puppet::Module::find_template(filename, scope.compiler.environment)
-
-        unless FileTest.exists?(file)
-            raise Puppet::ParseError,
-                "Could not find template %s" % file
-        end
-
-        # We'll only ever not have a parser in testing, but, eh.
-        if scope.parser
-            scope.parser.watch_file(file)
-        end
     end
 
     def scope
         @__scope__
     end
 
-    def file
-        @__file__
-    end
-
     # Should return true if a variable is defined, false if it is not
     def has_variable?(name)
         if scope.lookupvar(name.to_s, false) != :undefined
@@ -77,11 +62,34 @@ class Puppet::Parser::TemplateWrapper
         end
     end
 
-    def result
+    def file=(filename)
+        @file = Puppet::Module::find_template(filename, scope.compiler.environment)
+
+        unless FileTest.exists?(file)
+            raise Puppet::ParseError,
+                "Could not find template %s" % file
+        end
+
+        # We'll only ever not have a parser in testing, but, eh.
+        if scope.parser
+            scope.parser.watch_file(file)
+        end
+
+        @string = File.read(file)
+    end
+
+    def result(string = nil)
+        if string
+            self.string = string
+            template_source = "inline template"
+        else
+            template_source = file
+        end
+
         # Expose all the variables in our scope as instance variables of the
         # current object, making it possible to access them without conflict
         # to the regular methods.
-        benchmark(:debug, "Bound template variables for #{file}") do
+        benchmark(:debug, "Bound template variables for #{template_source}") do
             scope.to_hash.each { |name, value| 
                 if name.kind_of?(String)
                     realname = name.gsub(/[^\w]/, "_")
@@ -93,8 +101,8 @@ class Puppet::Parser::TemplateWrapper
         end
 
         result = nil
-        benchmark(:debug, "Interpolated template #{file}") do
-            template = ERB.new(File.read(file), 0, "-")
+        benchmark(:debug, "Interpolated template #{template_source}") do
+            template = ERB.new(self.string, 0, "-")
             result = template.result(binding)
         end
 
@@ -102,7 +110,7 @@ class Puppet::Parser::TemplateWrapper
     end
 
     def to_s
-        "template[%s]" % file
+        "template[%s]" % (file ? file : "inline")
     end
 end
 

data/lib/puppet/property.rb

@@ -485,7 +485,7 @@ class Property < Puppet::Parameter
             end
 
             # This doc will probably get overridden
-            @doc ||= "The basic property that the object should be in."
+            @doc ||= "The basic property that the resource should be in."
         end
 
         def self.inherited(sub)

data/lib/puppet/property/list.rb

@@ -28,6 +28,11 @@ module Puppet
                 @resource[membership] == :inclusive
             end
 
+            #dearrayify was motivated because to simplify the implementation of the OrderedList property
+            def dearrayify(array)
+                array.sort.join(delimiter)
+            end
+
             def should
                 unless defined? @should and @should
                     return nil
@@ -39,7 +44,7 @@ module Puppet
                     members = add_should_with_current(members, retrieve)
                 end
 
-                members.sort.join(delimiter)
+                dearrayify(members)
             end
 
             def delimiter
@@ -57,7 +62,7 @@ module Puppet
 
             def prepare_is_for_comparison(is)
                 if is.is_a? Array
-                    is = is.sort.join(delimiter)
+                    is = dearrayify(is)
                 end
                 is
             end

data/lib/puppet/property/ordered_list.rb

@@ -0,0 +1,22 @@
+require 'puppet/property/list'
+
+module Puppet
+    class Property
+        class OrderedList < List
+
+            def add_should_with_current(should, current)
+                if current.is_a?(Array)
+                    #tricky trick
+                    #Preserve all the current items in the list
+                    #but move them to the back of the line
+                    should = should + (current - should)
+                end
+                should
+            end
+
+            def dearrayify(array)
+                array.join(delimiter)
+            end
+        end
+    end
+end

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

@@ -0,0 +1,189 @@
+#--
+#  Copyright (C) 2008 Red Hat Inc.
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public
+#  License as published by the Free Software Foundation; either
+#  version 2 of the License, or (at your option) any later version.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public
+#  License along with this library; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+#
+# Author: Bryan Kearney <bkearney@redhat.com>
+
+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?   
+    
+    has_features :parse_commands, :need_to_run?,:execute_changes
+
+    # Extracts an 2 dimensional array of commands which are in the
+    # form of command path value.
+    # The input can be
+    # - A string with one command
+    # - A string with many commands per line
+    # - An array of strings.
+    def parse_commands(data)
+        commands = Array.new()
+        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(" ")
+                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
+        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)
+    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
+    def process_get(cmd_array)
+        return_value = false
+
+        #validate and tear apart the command
+        fail ("Invalid command: #{cmd_array.join(" ")}") if cmd_array.length < 4
+        cmd = cmd_array.shift()
+        path = cmd_array.shift()
+        comparator = cmd_array.shift()
+        arg = cmd_array.join(" ")
+
+        #check the value in augeas
+        aug = open_augeas()
+        result = aug.get(path) || ''
+        unless result.nil?
+            case comparator
+                when "!=":
+                    return_value = true if !(result == arg)
+                when "=~":
+                    regex = Regexp.new(arg)
+                    loc = result=~ regex
+                    return_value = true if ! loc.nil?
+                else
+                    return_value = true if (result.send(comparator, arg))
+            end
+        end
+        return_value
+    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)
+        return_value = false
+
+        #validate and tear apart the command
+        fail("Invalid command: #{cmd_array.join(" ")}") if cmd_array.length < 4
+        cmd = cmd_array.shift()
+        path = cmd_array.shift()
+        verb = cmd_array.shift()
+
+        #Get the values from augeas
+        aug = open_augeas()
+        result = aug.match(path) || ''
+        # Now do the work
+        if (!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
+                    return_value = true if (result.size.send(comparator, arg))
+                when "include":
+                    arg = cmd_array.join(" ")
+                    return_value = true if result.include?(arg)
+                when "==":
+                    begin
+                        arg = cmd_array.join(" ")
+                        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
+    end    
+    
+    # Determines if augeas acutally needs to run.
+    def need_to_run?
+        return_value = true
+        filter = resource[:onlyif]
+        unless (filter == "")
+            cmd_array = filter.split
+            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)
+                end
+            rescue Exception => e
+                fail("Error sending command '#{command}' with params #{cmd_array[1..-1].inspect}/#{e.message}")
+            end
+        end
+        return_value
+    end 
+    
+    # Actually execute the augeas changes.
+    def execute_changes
+        aug = open_augeas
+        commands = resource[:changes]
+        context = resource[:context]
+        commands.each do |cmd_array|
+            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])
+                    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
+
+        return :executed    
+    end   
+    
+end