puppet 0.18.4 → 0.22.4

data/lib/puppet/parser/ast/tag.rb

@@ -1,3 +1,5 @@
+require 'puppet/parser/ast/branch'
+
 class Puppet::Parser::AST
     # The code associated with a class.  This is different from components
     # in that each class is a singleton -- only one will exist for a given
@@ -23,4 +25,4 @@ class Puppet::Parser::AST
     end
 end
 
-# $Id: tag.rb 1113 2006-04-17 16:15:33Z luke $
+# $Id: tag.rb 1835 2006-11-08 05:22:24Z luke $

data/lib/puppet/parser/ast/vardef.rb

@@ -1,8 +1,12 @@
+require 'puppet/parser/ast/branch'
+
 class Puppet::Parser::AST
     # Define a variable.  Stores the value in the current scope.
     class VarDef < AST::Branch
         attr_accessor :name, :value
 
+        @settor = true
+
         # Look up our name and value, and store them appropriately.  The
         # lexer strips off the syntax stuff like '$'.
         def evaluate(hash)
@@ -10,18 +14,8 @@ class Puppet::Parser::AST
             name = @name.safeevaluate(:scope => scope)
             value = @value.safeevaluate(:scope => scope)
 
-            begin
-                scope.setvar(name,value)
-            rescue Puppet::ParseError => except
-                except.line = self.line
-                except.file = self.file
-                raise except
-            rescue => detail
-                error = Puppet::ParseError.new(detail)
-                error.line = self.line
-                error.file = self.file
-                error.backtrace = detail.backtrace
-                raise error
+            parsewrap do
+                scope.setvar(name,value, @file, @line)
             end
         end
 
@@ -43,3 +37,5 @@ class Puppet::Parser::AST
     end
 
 end
+
+# $Id: vardef.rb 2237 2007-02-28 00:07:41Z luke $

data/lib/puppet/parser/collector.rb

@@ -0,0 +1,181 @@
+# An object that collects stored objects from the central cache and returns
+# them to the current host, yo.
+class Puppet::Parser::Collector
+    attr_accessor :type, :scope, :vquery, :rquery, :form, :resources
+
+    # Collect exported objects.
+    def collect_exported
+        # First get everything from the export table.  Just reuse our
+        # collect_virtual method but tell it to use 'exported? for the test.
+        resources = collect_virtual(true).reject { |r| ! r.virtual? }
+
+        count = 0
+
+        unless @scope.host
+            raise Puppet::DevError, "Cannot collect resources for a nil host"
+        end
+
+        # We're going to collect objects from rails, but we don't want any
+        # objects from this host.
+        unless ActiveRecord::Base.connected?
+            Puppet::Rails.init
+        end
+        host = Puppet::Rails::Host.find_by_name(@scope.host)
+
+        args = {}
+        if host
+            args[:conditions] = "host_id != #{host.id}"
+        else
+            #Puppet.info "Host %s is uninitialized" % @scope.host
+        end
+
+        # Now look them up in the rails db.  When we support attribute comparison
+        # and such, we'll need to vary the conditions, but this works with no
+        # attributes, anyway.
+        time = Puppet::Util.thinmark do
+            Puppet::Rails::Resource.find_all_by_restype_and_exported(@type, true,
+                args
+            ).each do |obj|
+                if resource = export_resource(obj)
+                    count += 1
+                    resources << resource
+                end
+            end
+        end
+
+        scope.debug("Collected %s %s resource%s in %.2f seconds" %
+            [count, @type, count == 1 ? "" : "s", time])
+
+        return resources
+    end
+
+    def collect_resources
+        unless @resources.is_a?(Array)
+            @resources = [@resources]
+        end
+        method = "collect_#{form.to_s}_resources"
+        send(method)
+    end
+
+    def collect_exported_resources
+        raise Puppet::ParseError,
+            "realize() is not yet implemented for exported resources"
+    end
+
+    # Collect resources directly; this is the result of using 'realize',
+    # which specifies resources, rather than using a normal collection.
+    def collect_virtual_resources
+        result = @resources.dup.collect do |ref|
+            if res = @scope.findresource(ref.to_s)
+                @resources.delete(ref)
+                res
+            end
+        end.reject { |r| r.nil? }.each do |res|
+            res.virtual = false
+        end
+
+        # If there are no more resources to find, delete this from the list
+        # of collections.
+        if @resources.empty?
+            @scope.collections.delete(self)
+        end
+
+        return result
+    end
+
+    # Collect just virtual objects, from our local configuration.
+    def collect_virtual(exported = false)
+        if exported
+            method = :exported?
+        else
+            method = :virtual?
+        end
+        scope.resources.find_all do |resource|
+            resource.type == @type and resource.send(method) and match?(resource)
+        end
+    end
+
+    # Call the collection method, mark all of the returned objects as non-virtual,
+    # and then delete this object from the list of collections to evaluate.
+    def evaluate
+        if self.resources
+            if objects = collect_resources and ! objects.empty?
+                return objects
+            else
+                return false
+            end
+        else
+            method = "collect_#{@form.to_s}"
+            objects = send(method).each { |obj| obj.virtual = false }
+            if objects.empty?
+                return false
+            else
+                return objects
+            end
+        end
+
+#        if objects and ! objects.empty?
+#            objects.each { |r| r.virtual = false }
+#            return objects
+#        else
+#            return false
+#        end
+    end
+
+    def initialize(scope, type, equery, vquery, form)
+        @scope = scope
+        @type = type
+        @equery = equery
+        @vquery = vquery
+        @form = form
+        @tests = []
+    end
+
+    # Does the resource match our tests?  We don't yet support tests,
+    # so it's always true at the moment.
+    def match?(resource)
+        if self.vquery
+            return self.vquery.call(resource)
+        else
+            return true
+        end
+    end
+
+    def export_resource(obj)
+        if existing = @scope.findresource(obj.restype, obj.title)
+            # See if we exported it; if so, just move on
+            if @scope.host == obj.host.name
+                return nil
+            else
+                # Next see if we've already collected this resource
+                if existing.rails_id == obj.id
+                    # This is the one we've already collected
+                    return nil
+                else
+                    raise Puppet::ParseError,
+                        "Exported resource %s cannot override local resource" %
+                        [obj.ref]
+                end
+            end
+        end
+
+        begin
+            resource = obj.to_resource(self.scope)
+            
+            # XXX Because the scopes don't expect objects to return values,
+            # we have to manually add our objects to the scope.  This is
+            # �ber-lame.
+            scope.setresource(resource)
+        rescue => detail
+            if Puppet[:trace]
+                puts detail.backtrace
+            end
+            raise
+        end
+        resource.exported = false
+
+        return resource
+    end
+end
+
+# $Id: collector.rb 2215 2007-02-18 20:09:35Z luke $

data/lib/puppet/parser/functions.rb

@@ -1,4 +1,5 @@
 # Grr
+require 'puppet/util/autoload'
 require 'puppet/parser/scope'
 
 module Puppet::Parser
@@ -6,10 +7,25 @@ module Functions
     # A module for managing parser functions.  Each specified function
     # becomes an instance method on the Scope class.
 
+    class << self
+        include Puppet::Util
+    end
+
+    def self.autoloader
+        unless defined? @autoloader
+            @autoloader = Puppet::Util::Autoload.new(self,
+                "puppet/parser/functions",
+                :wrap => false
+            )
+        end
+
+        @autoloader
+    end
+
     # Create a new function type.
-    def self.newfunction(name, ftype = :statement, &block)
+    def self.newfunction(name, options = {}, &block)
         @functions ||= {}
-        name = name.intern if name.is_a? String
+        name = symbolize(name)
 
         if @functions.include? name
             raise Puppet::DevError, "Function %s already defined" % name
@@ -21,6 +37,8 @@ module Functions
             eval("module FCollection; end")
         end
 
+        ftype = options[:type] || :statement
+
         unless ftype == :statement or ftype == :rvalue
             raise Puppet::DevError, "Invalid statement type %s" % ftype.inspect
         end
@@ -31,11 +49,18 @@ module Functions
         # Someday we'll support specifying an arity, but for now, nope
         #@functions[name] = {:arity => arity, :type => ftype}
         @functions[name] = {:type => ftype, :name => fname}
+        if options[:doc]
+            @functions[name][:doc] = options[:doc]
+        end
     end
 
     # Determine if a given name is a function
     def self.function(name)
-        name = name.intern if name.is_a? String
+        name = symbolize(name)
+
+        unless @functions.include? name
+            autoloader.load(name)
+        end
 
         if @functions.include? name
             return @functions[name][:name]
@@ -44,9 +69,33 @@ module Functions
         end
     end
 
+    def self.functiondocs
+        autoloader.loadall
+
+        ret = ""
+
+        @functions.sort { |a,b| a[0].to_s <=> b[0].to_s }.each do |name, hash|
+            #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*/, ' ')
+            else
+                ret += "Undocumented.\n"
+            end
+
+            ret += "\n\n- **Type**: %s\n\n" % hash[:type]
+        end
+
+        return ret
+    end
+
+    def self.functions
+        @functions.keys
+    end
+
     # Determine if a given function returns a value or not.
     def self.rvalue?(name)
-        name = name.intern if name.is_a? String
+        name = symbolize(name)
 
         if @functions.include? name
             case @functions[name][:type]
@@ -59,36 +108,42 @@ module Functions
     end
 
     # Include the specified classes
-    newfunction(:include) do |vals|
-        vals.each do |val|
-            if objecttype = lookuptype(val)
-                # It's a defined type, so set it into the scope so it can
-                # be evaluated.
-                setobject(
-                    :type => val,
-                    :arguments => {}
-                )
-            else
-                raise Puppet::ParseError, "Unknown class %s" % val
+    newfunction(:include, :doc => "Evaluate one or more classes.") do |vals|
+        klasses = evalclasses(*vals)
+
+        missing = vals.find_all do |klass|
+            ! klasses.include?(klass)
+        end
+
+        unless missing.empty?
+            # Throw an error if we didn't evaluate all of the classes.
+            str = "Could not find class"
+            if missing.length > 1
+                str += "es"
+            end
+
+            str += " " + missing.join(", ")
+
+            if n = namespaces and ! n.empty? and n != [""]
+                str += " in namespaces %s" % @namespaces.join(", ")
             end
+            self.fail Puppet::ParseError, str
         end
     end
 
     # Tag the current scope with each passed name
-    newfunction(:tag) do |vals|
-        vals.each do |val|
-            # Some hackery, because the tags are stored by object id
-            # for singletonness.
-            self.setclass(val.object_id, val)
-        end
-
-        # Also add them as tags
+    newfunction(:tag, :doc => "Add the specified tags to the containing class
+    or definition.  All contained objects will then acquire that tag, also.
+    ") do |vals|
         self.tag(*vals)
     end
 
     # Test whether a given tag is set.  This functions as a big OR -- if any of the
     # specified tags are unset, we return false.
-    newfunction(:tagged, :rvalue) do |vals|
+    newfunction(:tagged, :type => :rvalue, :doc => "A boolean function that
+    tells you whether the current container is tagged with the specified tags.
+    The tags are ANDed, so thta all of the specified tags must be included for
+    the function to return true.") do |vals|
         classlist = self.classlist
 
         retval = true
@@ -103,32 +158,54 @@ module Functions
     end
 
     # Test whether a given class or definition is defined
-    newfunction(:defined, :rvalue) do |vals|
-        retval = true
-
+    newfunction(:defined, :type => :rvalue, :doc => "Determine whether a given
+    type is defined, either as a native type or a defined type, or whether a class is defined.
+    This is useful for checking whether a class is defined and only including it if it is.") do |vals|
+        result = false
         vals.each do |val|
-            unless builtintype?(val) or lookuptype(val)
-                retval = false
-                break
+            case val
+            when String:
+                # For some reason, it doesn't want me to return from here.
+                if Puppet::Type.type(val) or finddefine(val) or findclass(val)
+                    result = true
+                    break
+                end
+            when Puppet::Parser::Resource::Reference:
+                if findresource(val.to_s)
+                    result = true
+                    break
+                end
+            else
+                raise ArgumentError, "Invalid argument of type %s to 'defined'" % val.class
             end
         end
-
-        return retval
+        result
     end
 
-    newfunction(:fail, :statement) do |vals|
+    newfunction(:fail, :doc => "Fail with a parse error.") do |vals|
         vals = vals.collect { |s| s.to_s }.join(" ") if vals.is_a? Array
         raise Puppet::ParseError, vals.to_s
     end
 
-    newfunction(:template, :rvalue) do |vals|
+    # Runs a newfunction to create a function for each of the log levels
+    Puppet::Util::Log.levels.each do |level|      
+        newfunction(level, :doc => "Log a message on the server at level
+        #{level.to_s}.") do |vals| 
+            send(level, vals.join(" ")) 
+        end 
+    end
+
+    newfunction(:template, :type => :rvalue, :doc => "Evaluate a template and
+    return its value.  See [the templating docs](/trac/puppet/wiki/PuppetTemplating)
+    for more information.  Note that if multiple templates are specified, their
+    output is all concatenated and returned as the output of the function.") do |vals|
         require 'erb'
 
         vals.collect do |file|
             # Use a wrapper, so the template can't get access to the full
             # Scope object.
             debug "Retrieving template %s" % file
-            wrapper = Puppet::Parser::Scope::TemplateWrapper.new(self, file)
+            wrapper = Puppet::Parser::TemplateWrapper.new(self, file)
 
             begin
                 wrapper.result()
@@ -139,7 +216,85 @@ module Functions
             end
         end.join("")
     end
+
+    # This is just syntactic sugar for a collection, although it will generally
+    # be a good bit faster.
+    newfunction(:realize, :doc => "Make a virtual object real.  This is useful
+        when you want to know the name of the virtual object and don't want to
+        bother with a full collection.  It is slightly faster than a collection,
+        and, of course, is a bit shorter.  You must pass the object using a
+        reference; e.g.: ``realize User[luke]``." ) do |vals|
+        coll = Puppet::Parser::Collector.new(self, :nomatter, nil, nil, :virtual)
+        vals = [vals] unless vals.is_a?(Array)
+        coll.resources = vals
+
+        newcollection(coll)
+    end
+
+    newfunction(:search, :doc => "Add another namespace for this class to search.
+        This allows you to create classes with sets of definitions and add
+        those classes to another class's search path.") do |vals|
+        vals.each do |val|
+            add_namespace(val)
+        end
+    end
+
+    newfunction(:file, :type => :rvalue,
+        :doc => "Return the contents of a file.  Multiple files
+        can be passed, and the first file that exists will be read in.") do |vals|
+            ret = nil
+            vals.each do |file|
+                unless file =~ /^#{File::SEPARATOR}/
+                    raise Puppet::ParseError, "Files must be fully qualified"
+                end
+                if FileTest.exists?(file)
+                    ret = File.read(file)
+                    break
+                end
+            end
+            if ret
+                ret
+            else
+                raise Puppet::ParseError, "Could not find any files from %s" %
+                    vals.join(", ")
+            end
+    end
+
+    newfunction(:generate, :type => :rvalue,
+        :doc => "Calls an external command and returns the results of the
+        command.  Any arguments are passed to the external command as
+        arguments.  If the generator does not exit with return code of 0,
+        the generator is considered to have failed and a parse error is
+        thrown.  Generators can only have file separators, alphanumerics, dashes,
+        and periods in them.  This function will attempt to protect you from
+        malicious generator calls (e.g., those with '..' in them), but it can
+        never be entirely safe.  No subshell is used to execute
+        generators, so all shell metacharacters are passed directly to
+        the generator.") do |args|
+
+            unless args[0] =~ /^#{File::SEPARATOR}/
+                raise Puppet::ParseError, "Generators must be fully qualified"
+            end
+
+            unless args[0] =~ /^[-#{File::SEPARATOR}\w.]+$/
+                raise Puppet::ParseError,
+                    "Generators can only contain alphanumerics, file separators, and dashes"
+            end
+
+            if args[0] =~ /\.\./
+                raise Puppet::ParseError,
+                    "Can not use generators with '..' in them."
+            end
+
+            begin
+                output = Puppet::Util.execute(args)
+            rescue Puppet::ExecutionFailure => detail
+                raise Puppet::ParseError, "Failed to execute generator %s: %s" %
+                    [args[0], detail]
+            end
+            output
+    end
 end
 end
 
-# $Id: functions.rb 1383 2006-07-11 16:52:20Z luke $
+# $Id: functions.rb 2406 2007-04-23 06:16:10Z luke $