puppet 0.25.5 → 2.6.0

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

@@ -1,207 +0,0 @@
-require 'puppet/parser/ast/branch'
-
-require 'puppet/util/warnings'
-
-# The AST class for defined types, which is also the base class
-# nodes and classes.
-class Puppet::Parser::AST::Definition < Puppet::Parser::AST::Branch
-    include Puppet::Util::Warnings
-    class << self
-        attr_accessor :name
-    end
-
-    associates_doc
-
-    # The class name
-    @name = :definition
-
-    attr_accessor :classname, :arguments, :code, :scope, :keyword
-    attr_accessor :exported, :namespace, :parser, :virtual, :name
-
-    attr_reader :parentclass
-
-    def child_of?(klass)
-        false
-    end
-
-    def get_classname(scope)
-        self.classname
-    end
-
-    # Create a resource that knows how to evaluate our actual code.
-    def evaluate(scope)
-        resource = Puppet::Parser::Resource.new(:type => self.class.name, :title => get_classname(scope), :scope => scope, :source => scope.source)
-
-        scope.catalog.tag(*resource.tags)
-
-        scope.compiler.add_resource(scope, resource)
-
-        return resource
-    end
-
-    # Now evaluate the code associated with this class or definition.
-    def evaluate_code(resource)
-        # Create a new scope.
-        scope = subscope(resource.scope, resource)
-
-        set_resource_parameters(scope, resource)
-
-        if self.code
-            return self.code.safeevaluate(scope)
-        else
-            return nil
-        end
-    end
-
-    def initialize(hash = {})
-        @arguments = nil
-        @parentclass = nil
-        super
-
-        # Convert the arguments to a hash for ease of later use.
-        if @arguments
-            unless @arguments.is_a? Array
-                @arguments = [@arguments]
-            end
-            oldargs = @arguments
-            @arguments = {}
-            oldargs.each do |arg, val|
-                @arguments[arg] = val
-            end
-        else
-            @arguments = {}
-        end
-
-        # Deal with metaparams in the argument list.
-        @arguments.each do |arg, defvalue|
-            next unless Puppet::Type.metaparamclass(arg)
-            if defvalue
-                warnonce "%s is a metaparam; this value will inherit to all contained resources" % arg
-            else
-                raise Puppet::ParseError, "%s is a metaparameter; please choose another parameter name in the %s definition" % [arg, self.classname]
-            end
-        end
-    end
-
-    def find_parentclass
-        @parser.find_hostclass(namespace, parentclass)
-    end
-
-    # Set our parent class, with a little check to avoid some potential
-    # weirdness.
-    def parentclass=(name)
-        if name == self.classname
-            parsefail "Parent classes must have dissimilar names"
-        end
-
-        @parentclass = name
-    end
-
-    # Hunt down our class object.
-    def parentobj
-        return nil unless @parentclass
-
-        # Cache our result, since it should never change.
-        unless defined?(@parentobj)
-            unless tmp = find_parentclass
-                parsefail "Could not find %s parent %s" % [self.class.name, @parentclass]
-            end
-
-            if tmp == self
-                parsefail "Parent classes must have dissimilar names"
-            end
-
-            @parentobj = tmp
-        end
-        @parentobj
-    end
-
-    # Create a new subscope in which to evaluate our code.
-    def subscope(scope, resource)
-        args = {
-            :resource => resource,
-            :keyword => self.keyword,
-            :namespace => self.namespace,
-            :source => self
-        }
-
-        oldscope = scope
-        scope = scope.newscope(args)
-        scope.source = self
-
-        return scope
-    end
-
-    def to_s
-        classname
-    end
-
-    # Check whether a given argument is valid.  Searches up through
-    # any parent classes that might exist.
-    def validattr?(param)
-        param = param.to_s
-
-        if @arguments.include?(param)
-            # It's a valid arg for us
-            return true
-        elsif param == "name"
-            return true
-#            elsif defined? @parentclass and @parentclass
-#                # Else, check any existing parent
-#                if parent = @scope.lookuptype(@parentclass) and parent != []
-#                    return parent.validarg?(param)
-#                elsif builtin = Puppet::Type.type(@parentclass)
-#                    return builtin.validattr?(param)
-#                else
-#                    raise Puppet::Error, "Could not find parent class %s" %
-#                        @parentclass
-#                end
-        elsif Puppet::Type.metaparam?(param)
-            return true
-        else
-            # Or just return false
-            return false
-        end
-    end
-
-    private
-
-    # Set any arguments passed by the resource as variables in the scope.
-    def set_resource_parameters(scope, resource)
-        args = symbolize_options(resource.to_hash || {})
-
-        # Verify that all required arguments are either present or
-        # have been provided with defaults.
-        if self.arguments
-            self.arguments.each { |arg, default|
-                arg = arg.to_sym
-                unless args.include?(arg)
-                    if defined? default and ! default.nil?
-                        default = default.safeevaluate scope
-                        args[arg] = default
-                        #Puppet.debug "Got default %s for %s in %s" %
-                        #    [default.inspect, arg.inspect, @name.inspect]
-                    else
-                        parsefail "Must pass %s to %s of type %s" %
-                                [arg, resource.title, @classname]
-                    end
-                end
-            }
-        end
-
-        # Set each of the provided arguments as variables in the
-        # definition's scope.
-        args.each { |arg,value|
-            unless validattr?(arg)
-                parsefail "%s does not accept attribute %s" % [@classname, arg]
-            end
-
-            exceptwrap do
-                scope.setvar(arg.to_s, args[arg])
-            end
-        }
-
-        scope.setvar("title", resource.title) unless args.include? :title
-        scope.setvar("name", resource.name) unless args.include? :name
-    end
-end

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

@@ -1,95 +0,0 @@
-require 'puppet/parser/ast/definition'
-
-# The code associated with a class.  This is different from definitions
-# in that each class is a singleton -- only one will exist for a given
-# node.
-class Puppet::Parser::AST::HostClass < Puppet::Parser::AST::Definition
-
-    associates_doc
-
-    @name = :class
-
-    # Are we a child of the passed class?  Do a recursive search up our
-    # parentage tree to figure it out.
-    def child_of?(klass)
-        return false unless self.parentclass
-
-        if klass == self.parentobj
-            return true
-        else
-            return self.parentobj.child_of?(klass)
-        end
-    end
-
-    # Make sure our parent class has been evaluated, if we have one.
-    def evaluate(scope)
-        if parentclass and ! scope.catalog.resource(self.class.name, parentclass)
-            parent_resource = parentobj.evaluate(scope)
-        end
-
-        # Do nothing if the resource already exists; this makes sure we don't
-        # get multiple copies of the class resource, which helps provide the
-        # singleton nature of classes.
-        if resource = scope.catalog.resource(self.class.name, self.classname)
-            return resource
-        end
-
-        super
-    end
-
-    # Evaluate the code associated with this class.
-    def evaluate_code(resource)
-        scope = resource.scope
-        # Verify that we haven't already been evaluated.  This is
-        # what provides the singleton aspect.
-        if existing_scope = scope.compiler.class_scope(self)
-            Puppet.debug "Class '%s' already evaluated; not evaluating again" % (classname == "" ? "main" : classname)
-            return nil
-        end
-
-        pnames = nil
-        if pklass = self.parentobj
-            parent_resource = resource.scope.compiler.catalog.resource(self.class.name, pklass.classname)
-            # This shouldn't evaluate if the class has already been evaluated.
-            pklass.evaluate_code(parent_resource)
-
-            scope = parent_scope(scope, pklass)
-            pnames = scope.namespaces
-        end
-
-        # Don't create a subscope for the top-level class, since it already
-        # has its own scope.
-        unless resource.title == :main
-            scope = subscope(scope, resource)
-
-            scope.setvar("title", resource.title)
-            scope.setvar("name", resource.name)
-        end
-
-        # Add the parent scope namespaces to our own.
-        if pnames
-            pnames.each do |ns|
-                scope.add_namespace(ns)
-            end
-        end
-
-        # Set the class before we evaluate the code, so that it's set during
-        # the evaluation and can be inspected.
-        scope.compiler.class_set(self.classname, scope)
-
-        # Now evaluate our code, yo.
-        if self.code
-            return self.code.safeevaluate(scope)
-        else
-            return nil
-        end
-    end
-
-    def parent_scope(scope, klass)
-        if s = scope.compiler.class_scope(klass)
-            return s
-        else
-            raise Puppet::DevError, "Could not find scope for %s" % klass.classname
-        end
-    end
-end

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

@@ -1,42 +0,0 @@
-require 'puppet/parser/ast/hostclass'
-
-# The specific code associated with a host.  Nodes are annoyingly unlike
-# other objects.  That's just the way it is, at least for now.
-class Puppet::Parser::AST::Node < Puppet::Parser::AST::HostClass
-
-    associates_doc
-
-    @name = :node
-
-    def initialize(options)
-        @parentclass = nil
-        super
-    end
-
-    def namespace
-        ""
-    end
-
-    # in Regex mode, our classname can't be our Regex.
-    # so we use the currently connected client as our
-    # classname, mimicing exactly what would have happened
-    # if there was a specific node definition for this node.
-    def get_classname(scope)
-        return scope.host if name.regex?
-        classname
-    end
-
-    # Make sure node scopes are marked as such.
-    def subscope(*args)
-        scope = super
-        scope.nodescope = true
-        scope
-    end
-
-    private
-
-    # Search for the object matching our parent class.
-    def find_parentclass
-        @parser.node(parentclass)
-    end
-end

data/lib/puppet/parser/interpreter.rb

@@ -1,84 +0,0 @@
-require 'puppet'
-require 'timeout'
-require 'puppet/rails'
-require 'puppet/util/methodhelper'
-require 'puppet/parser/parser'
-require 'puppet/parser/compiler'
-require 'puppet/parser/scope'
-
-# The interpreter is a very simple entry-point class that
-# manages the existence of the parser (e.g., replacing it
-# when files are reparsed).  You can feed it a node and
-# get the node's catalog back.
-class Puppet::Parser::Interpreter
-    include Puppet::Util
-
-    attr_accessor :usenodes
-
-    include Puppet::Util::Errors
-
-    # Determine the configuration version for a given node's environment.
-    def configuration_version(node)
-        parser(node.environment).version
-    end
-
-    # evaluate our whole tree
-    def compile(node)
-        raise Puppet::ParseError, "Could not parse configuration; cannot compile on node %s" % node.name unless env_parser = parser(node.environment)
-        begin
-            return Puppet::Parser::Compiler.new(node, env_parser).compile.to_resource
-        rescue => detail
-            puts detail.backtrace if Puppet[:trace]
-            raise Puppet::Error, detail.to_s + " on node %s" % node.name
-        end
-    end
-
-    # create our interpreter
-    def initialize
-        # The class won't always be defined during testing.
-        if Puppet[:storeconfigs]
-            if Puppet.features.rails?
-                Puppet::Rails.init
-            else
-                raise Puppet::Error, "Rails is missing; cannot store configurations"
-            end
-        end
-
-        @parsers = {}
-    end
-
-    # Return the parser for a specific environment.
-    def parser(environment)
-        if ! @parsers[environment] or @parsers[environment].reparse?
-            # This will throw an exception if it does not succeed.
-            @parsers[environment] = create_parser(environment)
-        end
-        @parsers[environment]
-    end
-
-    private
-
-    # Create a new parser object and pre-parse the configuration.
-    def create_parser(environment)
-        begin
-            parser = Puppet::Parser::Parser.new(:environment => environment)
-            if code = Puppet.settings.uninterpolated_value(:code, environment) and code != ""
-                parser.string = code
-            else
-                file = Puppet.settings.value(:manifest, environment)
-                parser.file = file
-            end
-            parser.parse
-            return parser
-        rescue => detail
-            msg = "Could not parse"
-            if environment and environment != ""
-                msg += " for environment %s" % environment
-            end
-            msg += ": %s" % detail.to_s
-            error = Puppet::Error.new(msg)
-            error.set_backtrace(detail.backtrace)
-            raise error
-        end
-    end
-end

data/lib/puppet/parser/loaded_code.rb

@@ -1,119 +0,0 @@
-class Puppet::Parser::LoadedCode
-    def initialize
-        @hostclasses = {}
-        @definitions = {}
-        @nodes = {}
-
-        # So we can keep a list and match the first-defined regex
-        @node_list = []
-    end
-
-    def add_hostclass(name, code)
-        @hostclasses[munge_name(name)] = code
-    end
-
-    def hostclass(name)
-        @hostclasses[munge_name(name)]
-    end
-
-    def add_node(name, code)
-        name = check_name(name)
-        @node_list << name unless @node_list.include?(name)
-        @nodes[name] = code
-    end
-
-    def node(name)
-        name = check_name(name)
-
-        if node = @nodes[name]
-            return node
-        end
-
-        @node_list.each do |nodename|
-            n = @nodes[nodename]
-            return n if nodename.regex? and nodename.match(name)
-        end
-        nil
-    end
-
-    def node_exists?(name)
-        @nodes[check_name(name)]
-    end
-
-    def nodes?
-        @nodes.length > 0
-    end
-
-    def add_definition(name, code)
-        @definitions[munge_name(name)] = code
-    end
-
-    def definition(name)
-        @definitions[munge_name(name)]
-    end
-
-    def find(namespace, name, type)
-        if r = find_fully_qualified(name, type)
-            return r
-        end
-
-        ary = namespace.split("::")
-
-        while ary.length > 0
-            tmp_namespace = ary.join("::")
-            if r = find_partially_qualified(tmp_namespace, name, type)
-                return r
-            end
-
-            # Delete the second to last object, which reduces our namespace by one.
-            ary.pop
-        end
-
-        send(type, name)
-    end
-
-    def find_node(name)
-        find("", name, :node)
-    end
-
-    def find_hostclass(namespace, name)
-        find(namespace, name, :hostclass)
-    end
-
-    def find_definition(namespace, name)
-        find(namespace, name, :definition)
-    end
-
-    [:hostclasses, :nodes, :definitions].each do |m|
-        define_method(m) do
-            instance_variable_get("@#{m}").dup
-        end
-    end
-
-    private
-
-    def find_fully_qualified(name, type)
-        return nil unless name =~ /^::/
-
-        name = name.sub(/^::/, '')
-
-        send(type, name)
-    end
-
-    def find_partially_qualified(namespace, name, type)
-        send(type, [namespace, name].join("::"))
-    end
-
-    def munge_name(name)
-        name.to_s.downcase
-    end
-
-    # Check that the given (node) name is an HostName instance
-    # We're doing this so that hashing of node in the @nodes hash
-    # is consistent (see AST::HostName#hash and AST::HostName#eql?)
-    # and that the @nodes hash still keep its O(1) get/put properties.
-    def check_name(name)
-        name = Puppet::Parser::AST::HostName.new(:value => name) unless name.is_a?(Puppet::Parser::AST::HostName)
-        name
-    end
-end