puppet 0.16.0 → 0.18.4

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

@@ -3,7 +3,7 @@ class Puppet::Parser::AST
     # specified node, and this parse tree is only ever looked up when
     # a client connects.
     class NodeDef < AST::Branch
-        attr_accessor :names, :code, :parentclass, :keyword
+        attr_accessor :names, :code, :parentclass, :keyword, :scope
 
         def each
             [@names,@code].each { |child| yield child }

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

@@ -2,7 +2,7 @@ class Puppet::Parser::AST
     # Any normal puppet object declaration.  Can result in a class or a 
     # component, in addition to builtin types.
     class ObjectDef < AST::Branch
-        attr_accessor :name, :type
+        attr_accessor :name, :type, :collectable
         attr_reader :params
 
         # probably not used at all
@@ -55,23 +55,40 @@ class Puppet::Parser::AST
                 raise error
             end
 
+            hash = {}
+            # Evaluate all of the specified params.
+            @params.each { |param|
+                ary = param.safeevaluate(:scope => scope)
+                hash[ary[0]] = ary[1]
+            }
+
             objnames = [nil]
-            # Autogenerate the name if one was not passed.
+            # Determine our name if we have one.
             if self.name
                 objnames = @name.safeevaluate(:scope => scope)
                 # it's easier to always use an array, even for only one name
                 unless objnames.is_a?(Array)
                     objnames = [objnames]
                 end
-            end
+            else
+                # See if they specified the name as a parameter instead of as a
+                # normal name (i.e., before the colon).
+                unless object # we're a builtin
+                    if objclass = Puppet::Type.type(objtype)
+                        namevar = objclass.namevar
 
-            hash = {}
+                        tmp = hash["name"] || hash[namevar.to_s] 
 
-            # then set all of the specified params
-            @params.each { |param|
-                ary = param.safeevaluate(:scope => scope)
-                hash[ary[0]] = ary[1]
-            }
+                        if tmp
+                            objnames = [tmp]
+                        end
+                    else
+                        # this should never happen, because we've already
+                        # typechecked, but it's no real problem if it does happen.
+                        # We just end up with an object with no name.
+                    end
+                end
+            end
 
             # this is where our implicit iteration takes place;
             # if someone passed an array as the name, then we act
@@ -91,7 +108,8 @@ class Puppet::Parser::AST
                         :name => objname,
                         :arguments => hash,
                         :file => @file,
-                        :line => @line
+                        :line => @line,
+                        :collectable => self.collectable
                     )
                 rescue Puppet::ParseError => except
                     except.line = self.line

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

@@ -19,7 +19,10 @@ class Puppet::Parser::AST
 
             default = nil
 
-            @values = [@values] unless @values.instance_of? AST::ASTArray
+            #@values = [@values] unless @values.instance_of? AST::ASTArray
+            unless @values.instance_of? AST::ASTArray or @values.instance_of? Array
+                @values = [@values]
+            end
 
             # Then look for a match in the options.
             @values.each { |obj|

data/lib/puppet/parser/functions.rb

@@ -0,0 +1,145 @@
+# Grr
+require 'puppet/parser/scope'
+
+module Puppet::Parser
+module Functions
+    # A module for managing parser functions.  Each specified function
+    # becomes an instance method on the Scope class.
+
+    # Create a new function type.
+    def self.newfunction(name, ftype = :statement, &block)
+        @functions ||= {}
+        name = name.intern if name.is_a? String
+
+        if @functions.include? name
+            raise Puppet::DevError, "Function %s already defined" % name
+        end
+
+        # We want to use a separate, hidden module, because we don't want
+        # people to be able to call them directly.
+        unless defined? FCollection
+            eval("module FCollection; end")
+        end
+
+        unless ftype == :statement or ftype == :rvalue
+            raise Puppet::DevError, "Invalid statement type %s" % ftype.inspect
+        end
+
+        fname = "function_" + name.to_s
+        Puppet::Parser::Scope.send(:define_method, fname, &block)
+
+        # Someday we'll support specifying an arity, but for now, nope
+        #@functions[name] = {:arity => arity, :type => ftype}
+        @functions[name] = {:type => ftype, :name => fname}
+    end
+
+    # Determine if a given name is a function
+    def self.function(name)
+        name = name.intern if name.is_a? String
+
+        if @functions.include? name
+            return @functions[name][:name]
+        else
+            return false
+        end
+    end
+
+    # Determine if a given function returns a value or not.
+    def self.rvalue?(name)
+        name = name.intern if name.is_a? String
+
+        if @functions.include? name
+            case @functions[name][:type]
+            when :statement: return false
+            when :rvalue: return true
+            end
+        else
+            return false
+        end
+    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
+            end
+        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
+        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|
+        classlist = self.classlist
+
+        retval = true
+        vals.each do |val|
+            unless classlist.include?(val) or self.tags.include?(val)
+                retval = false
+                break
+            end
+        end
+
+        return retval
+    end
+
+    # Test whether a given class or definition is defined
+    newfunction(:defined, :rvalue) do |vals|
+        retval = true
+
+        vals.each do |val|
+            unless builtintype?(val) or lookuptype(val)
+                retval = false
+                break
+            end
+        end
+
+        return retval
+    end
+
+    newfunction(:fail, :statement) 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|
+        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)
+
+            begin
+                wrapper.result()
+            rescue => detail
+                raise Puppet::ParseError,
+                    "Failed to parse template %s: %s" %
+                        [file, detail]
+            end
+        end.join("")
+    end
+end
+end
+
+# $Id: functions.rb 1383 2006-07-11 16:52:20Z luke $

data/lib/puppet/parser/interpreter.rb

@@ -15,6 +15,14 @@ module Puppet
             Puppet.setdefaults("ldap",
                 :ldapnodes => [false,
                     "Whether to search for node configurations in LDAP."],
+                :ldapssl => [false,
+                    "Whether SSL should be used when searching for nodes.
+                    Defaults to false because SSL usually requires certificates
+                    to be set up on the client side."],
+                :ldaptls => [false,
+                    "Whether TLS should be used when searching for nodes.
+                    Defaults to false because TLS usually requires certificates
+                    to be set up on the client side."],
                 :ldapserver => ["ldap",
                     "The LDAP server.  Only used if ``ldapnodes`` is enabled."],
                 :ldapport => [389,
@@ -38,10 +46,41 @@ module Puppet
                     branch under your main directory."]
             )
 
-            attr_accessor :ast, :filetimeout
+            Puppet.setdefaults(:puppetmaster,
+                :storeconfigs => [false,
+                    "Whether to store each client's configuration.  This
+                     requires ActiveRecord from Ruby on Rails."]
+            )
+
+            attr_accessor :ast
+
+            class << self
+                attr_writer :ldap
+            end
             # just shorten the constant path a bit, using what amounts to an alias
             AST = Puppet::Parser::AST
 
+            # Create an ldap connection.  This is a class method so others can call
+            # it and use the same variables and such.
+            def self.ldap
+                unless defined? @ldap and @ldap
+                    if Puppet[:ldapssl]
+                        @ldap = LDAP::SSLConn.new(Puppet[:ldapserver], Puppet[:ldapport])
+                    elsif Puppet[:ldaptls]
+                        @ldap = LDAP::SSLConn.new(
+                            Puppet[:ldapserver], Puppet[:ldapport], true
+                        )
+                    else
+                        @ldap = LDAP::Conn.new(Puppet[:ldapserver], Puppet[:ldapport])
+                    end
+                    @ldap.set_option(LDAP::LDAP_OPT_PROTOCOL_VERSION, 3)
+                    @ldap.set_option(LDAP::LDAP_OPT_REFERRALS, LDAP::LDAP_OPT_ON)
+                    @ldap.simple_bind(Puppet[:ldapuser], Puppet[:ldappassword])
+                end
+
+                return @ldap
+            end
+
             # create our interpreter
             def initialize(hash)
                 if @code = hash[:Code]
@@ -49,7 +88,6 @@ module Puppet
                 elsif ! @file = hash[:Manifest]
                     raise Puppet::DevError, "You must provide code or a manifest"
                 end
-                @filetimeout = hash[:ParseCheck] || 15
 
                 @lastchecked = 0
 
@@ -59,19 +97,24 @@ module Puppet
                     @usenodes = true
                 end
 
-                @nodesources = hash[:NodeSources] || [:file]
+                # By default, we only search the parse tree.
+                @nodesources = []
+
+                if Puppet[:ldapnodes]
+                    @nodesources << :ldap
+                end
 
-                @nodesources.each { |source|
-                    method = "setup_%s" % source.to_s
-                    if respond_to? method
-                        begin
-                            self.send(method)
-                        rescue => detail
-                            raise Puppet::Error,
-                                "Could not set up node source %s" % source
+                if hash[:NodeSources]
+                    hash[:NodeSources].each do |src|
+                        if respond_to? "nodesearch_#{src.to_s}"
+                            @nodesources << src.to_s.intern
+                        else
+                            Puppet.warning "Node source '#{src}' not supported"
                         end
                     end
-                }
+                end
+
+                @setup = false
 
                 # Set it to either the value or nil.  This is currently only used
                 # by the cfengine module.
@@ -79,40 +122,49 @@ module Puppet
 
                 @local = hash[:Local] || false
 
-                # Create our parser object
-                parsefiles
-            end
-
-            # Connect to the LDAP Server
-            def setup_ldap
-                begin
-                    require 'ldap'
-                rescue LoadError
-                    @ldap = nil
-                    return
+                if hash.include?(:ForkSave)
+                    @forksave = hash[:ForkSave]
+                else
+                    # This is just too dangerous right now.  Sorry, it's going
+                    # to have to be slow.
+                    @forksave = false
                 end
-                begin
-                    @ldap = LDAP::Conn.new(Puppet[:ldapserver], Puppet[:ldapport])
-                    @ldap.set_option(LDAP::LDAP_OPT_PROTOCOL_VERSION, 3)
-                    @ldap.simple_bind(Puppet[:ldapuser], Puppet[:ldappassword])
-                rescue => detail
-                    raise Puppet::Error, "Could not connect to LDAP: %s" % detail
+
+                if Puppet[:storeconfigs]
+                    Puppet::Rails.init
                 end
+
+                @files = []
+
+                # Create our parser object
+                parsefiles
             end
 
-            # Search for our node in the various locations.
+            # Search for our node in the various locations.  This only searches
+            # locations external to the files; the scope is responsible for
+            # searching the parse tree.
             def nodesearch(node)
                 # At this point, stop at the first source that defines
                 # the node
                 @nodesources.each do |source|
                     method = "nodesearch_%s" % source
+                    parent = nil
+                    nodeclasses = nil
                     if self.respond_to? method
                         parent, nodeclasses = self.send(method, node)
-                    end
 
-                    if nodeclasses
-                        Puppet.info "Found %s in %s" % [node, source]
-                        return parent, nodeclasses
+                        if parent or (nodeclasses and !nodeclasses.empty?)
+                            Puppet.info "Found %s in %s" % [node, source]
+                            return parent, nodeclasses
+                        else
+                            # Look for a default node.
+                            parent, nodeclasses = self.send(method, "default")
+                            if parent or (nodeclasses and !nodeclasses.empty?)
+                                Puppet.info "Found default node for %s in %s" %
+                                    [node, source]
+                                return parent, nodeclasses
+                            end
+                        end
                     end
                 end
 
@@ -122,8 +174,16 @@ module Puppet
             # Find the ldap node and extra the info, returning just
             # the critical data.
             def nodesearch_ldap(node)
-                unless defined? @ldap
-                    ldapconnect()
+                unless defined? @ldap and @ldap
+                    setup_ldap()
+                    unless @ldap
+                        Puppet.info "Skipping ldap source; no ldap connection"
+                        return nil, []
+                    end
+                end
+
+                if node =~ /\./
+                    node = node.sub(/\..+/, '')
                 end
 
                 filter = Puppet[:ldapstring]
@@ -146,27 +206,39 @@ module Puppet
                 classes = []
 
                 found = false
-                # We're always doing a sub here; oh well.
-                @ldap.search(Puppet[:ldapbase], 2, filter, sattrs) do |entry|
-                    found = true
-                    if pattr
-                        if values = entry.vals(pattr)
-                            if values.length > 1
-                                raise Puppet::Error,
-                                    "Node %s has more than one parent: %s" %
-                                    [node, values.inspect]
-                            end
-                            unless values.empty?
-                                parent = values.shift
+                count = 0
+                begin
+                    # We're always doing a sub here; oh well.
+                    @ldap.search(Puppet[:ldapbase], 2, filter, sattrs) do |entry|
+                        found = true
+                        if pattr
+                            if values = entry.vals(pattr)
+                                if values.length > 1
+                                    raise Puppet::Error,
+                                        "Node %s has more than one parent: %s" %
+                                        [node, values.inspect]
+                                end
+                                unless values.empty?
+                                    parent = values.shift
+                                end
                             end
                         end
-                    end
 
-                    attrs.each { |attr|
-                        if values = entry.vals(attr)
-                            classes += values
-                        end
-                    }
+                        attrs.each { |attr|
+                            if values = entry.vals(attr)
+                                values.each do |v| classes << v end
+                            end
+                        }
+                    end
+                rescue => detail
+                    if count == 0
+                        # Try reconnecting to ldap
+                        @ldap = nil
+                        setup_ldap()
+                        retry
+                    else
+                        raise Puppet::Error, "LDAP Search failed: %s" % detail
+                    end
                 end
 
                 classes.flatten!
@@ -179,8 +251,30 @@ module Puppet
                 @parsedate
             end
 
+            # Add a new file to check for updateness.
+            def newfile(file)
+                unless @files.find { |f| f.file == file }
+                    @files << Puppet::ParsedFile.new(file)
+                end
+            end
+
             # evaluate our whole tree
             def run(client, facts)
+                # We have to leave this for after initialization because there
+                # seems to be a problem keeping ldap open after a fork.
+                unless @setup
+                    @nodesources.each { |source|
+                        method = "setup_%s" % source.to_s
+                        if respond_to? method
+                            begin
+                                self.send(method)
+                            rescue => detail
+                                raise Puppet::Error,
+                                    "Could not set up node source %s" % source
+                            end
+                        end
+                    }
+                end
                 parsefiles()
 
                 # Really, we should stick multiple names in here
@@ -217,10 +311,14 @@ module Puppet
                     args[:classes] += nodeclasses if nodeclasses
 
                     args[:parentnode] = parent if parent
+
+                    if nodeclasses or parent
+                        args[:searched] = true
+                    end
                 end
 
                 begin
-                    return scope.evaluate(args)
+                    objects = scope.evaluate(args)
                 rescue Puppet::DevError, Puppet::Error, Puppet::ParseError => except
                     raise
                 rescue => except
@@ -232,6 +330,35 @@ module Puppet
                     #end
                     raise error
                 end
+
+                if Puppet[:storeconfigs]
+                    storeconfigs(
+                        :objects => objects,
+                        :host => client,
+                        :facts => facts
+                    )
+                end
+
+                return objects
+            end
+
+            # Connect to the LDAP Server
+            def setup_ldap
+                self.class.ldap = nil
+                begin
+                    require 'ldap'
+                rescue LoadError
+                    Puppet.notice(
+                        "Could not set up LDAP Connection: Missing ruby/ldap libraries"
+                    )
+                    @ldap = nil
+                    return
+                end
+                begin
+                    @ldap = self.class.ldap()
+                rescue => detail
+                    raise Puppet::Error, "Could not connect to LDAP: %s" % detail
+                end
             end
 
             def scope
@@ -240,37 +367,29 @@ module Puppet
 
             private
 
-            # Evaluate the configuration.  If there aren't any nodes defined, then
-            # this doesn't actually do anything, because we have to evaluate the
-            # entire configuration each time we get a connect.
-            def evaluate
-                # FIXME When this produces errors, it should specify which
-                # node caused those errors.
-                if @usenodes
-                    @scope = Puppet::Parser::Scope.new() # no parent scope
-                    @scope.name = "top"
-                    @scope.type = "puppet"
-                    @scope.interp = self
-                    Puppet.debug "Nodes defined"
-                    @ast.safeevaluate(:scope => @scope)
-                else
-                    Puppet.debug "No nodes defined"
-                    return
+            # Check whether any of our files have changed.
+            def checkfiles
+                if @files.find { |f| f.changed?  }
+                    @parsedate = Time.now.to_i
                 end
             end
 
+            # Parse the files, generating our parse tree.  This automatically
+            # reparses only if files are updated, so it's safe to call multiple
+            # times.
             def parsefiles
+                # First check whether there are updates to any non-puppet files
+                # like templates.  If we need to reparse, this will get quashed,
+                # but it needs to be done first in case there's no reparse
+                # but there are other file changes.
+                checkfiles()
+
+                # Check if the parser should reparse.
                 if @file
                     if defined? @parser
-                        # Only check the files every 15 seconds or so, not on
-                        # every single connection
-                        if (Time.now - @lastchecked).to_i >= @filetimeout.to_i
-                            unless @parser.reparse?
-                                @lastchecked = Time.now
-                                return false
-                            end
-                        else
-                            return
+                        unless @parser.reparse?
+                            @lastchecked = Time.now
+                            return false
                         end
                     end
 
@@ -284,6 +403,8 @@ module Puppet
                 end
 
                 if defined? @parser
+                    # If this isn't our first time parsing in this process,
+                    # note that we're reparsing.
                     Puppet.info "Reloading files"
                 end
                 # should i be creating a new parser each time...?
@@ -297,21 +418,57 @@ module Puppet
                 if @local
                     @ast = @parser.parse
                 else
-                    @ast = benchmark(:info, "Parsed manifest") do
-                        @parser.parse
+                    benchmark(:info, "Parsed manifest") do
+                        @ast = @parser.parse
                     end
                 end
 
                 # Mark when we parsed, so we can check freshness
                 @parsedate = Time.now.to_i
                 @lastchecked = Time.now
+            end
+
+            # Store the configs into the database.
+            def storeconfigs(hash)
+                unless defined? ActiveRecord
+                    require 'puppet/rails'
+                    unless defined? ActiveRecord
+                        raise LoadError,
+                            "storeconfigs is enabled but rails is unavailable"
+                    end
+                end
+
+                Puppet::Rails.init
+
+                # Fork the storage, since we don't need the client waiting
+                # on that.  How do I avoid this duplication?
+                if @forksave
+                    fork {
+                        # We store all of the objects, even the collectable ones
+                        benchmark(:info, "Stored configuration for #{hash[:client]}") do
+                            # Try to batch things a bit, by putting them into
+                            # a transaction
+                            Puppet::Rails::Host.transaction do
+                                Puppet::Rails::Host.store(hash)
+                            end
+                        end
+                    }
+                else
+                    # We store all of the objects, even the collectable ones
+                    benchmark(:info, "Stored configuration for #{hash[:client]}") do
+                        Puppet::Rails::Host.transaction do
+                            Puppet::Rails::Host.store(hash)
+                        end
+                    end
+                end
 
-                # Reevaluate the config.  This is what actually replaces the
-                # existing scope.
-                evaluate
+                # Now that we've stored everything, we need to strip out
+                # the collectable objects so that they are not sent on
+                # to the host
+                hash[:objects].collectstrip!
             end
         end
     end
 end
 
-# $Id: interpreter.rb 1103 2006-04-11 17:33:36Z luke $
+# $Id: interpreter.rb 1421 2006-07-21 23:12:51Z luke $