puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/parser/compiler.rb

@@ -0,0 +1,476 @@
+require 'puppet/node'
+require 'puppet/resource/catalog'
+require 'puppet/util/errors'
+
+require 'puppet/resource/type_collection_helper'
+
+# Maintain a graph of scopes, along with a bunch of data
+# about the individual catalog we're compiling.
+class Puppet::Parser::Compiler
+  include Puppet::Util
+  include Puppet::Util::Errors
+  include Puppet::Resource::TypeCollectionHelper
+
+  def self.compile(node)
+    # We get these from the environment and only cache them in a thread
+    # variable for the duration of the compilation.  If nothing else is using
+    # the thread, though, we can leave 'em hanging round with no ill effects,
+    # and this is safer than cleaning them at the end and assuming that will
+    # stick until the next entry to this function.
+    Thread.current[:known_resource_types] = nil
+    Thread.current[:env_module_directories] = nil
+
+    # ...and we actually do the compile now we have caching ready.
+    new(node).compile.to_resource
+  rescue => detail
+    puts detail.backtrace if Puppet[:trace]
+    raise Puppet::Error, "#{detail} on node #{node.name}"
+ end
+
+  attr_reader :node, :facts, :collections, :catalog, :resources, :relationships, :topscope
+
+  # Add a collection to the global list.
+  def add_collection(coll)
+    @collections << coll
+  end
+
+  def add_relationship(dep)
+    @relationships << dep
+  end
+
+  # Store a resource override.
+  def add_override(override)
+    # If possible, merge the override in immediately.
+    if resource = @catalog.resource(override.ref)
+      resource.merge(override)
+    else
+      # Otherwise, store the override for later; these
+      # get evaluated in Resource#finish.
+      @resource_overrides[override.ref] << override
+    end
+  end
+
+  # Store a resource in our resource table.
+  def add_resource(scope, resource)
+    @resources << resource
+
+    # Note that this will fail if the resource is not unique.
+    @catalog.add_resource(resource)
+
+    if resource.type.to_s.downcase != "class" && resource[:stage]
+      raise ArgumentError, "Only classes can set 'stage'; normal resources like #{resource} cannot change run stage"
+    end
+
+    # Stages should not be inside of classes.  They are always a
+    # top-level container, regardless of where they appear in the
+    # manifest.
+    return if resource.type.to_s.downcase == "stage"
+
+    # This adds a resource to the class it lexically appears in in the
+    # manifest.
+    if resource.type.to_s.downcase != "class"
+      return @catalog.add_edge(scope.resource, resource)
+    end
+  end
+
+  # Do we use nodes found in the code, vs. the external node sources?
+  def ast_nodes?
+    known_resource_types.nodes?
+  end
+
+  # Store the fact that we've evaluated a class
+  def add_class(name)
+    @catalog.add_class(name) unless name == ""
+  end
+
+
+  # Return a list of all of the defined classes.
+  def classlist
+    @catalog.classes
+  end
+
+  # Compiler our catalog.  This mostly revolves around finding and evaluating classes.
+  # This is the main entry into our catalog.
+  def compile
+    # Set the client's parameters into the top scope.
+    set_node_parameters
+    create_settings_scope
+
+    evaluate_main
+
+    evaluate_ast_node
+
+    evaluate_node_classes
+
+    evaluate_generators
+
+    finish
+
+    fail_on_unevaluated
+
+    @catalog
+  end
+
+  # LAK:FIXME There are no tests for this.
+  def delete_collection(coll)
+    @collections.delete(coll) if @collections.include?(coll)
+  end
+
+  # Return the node's environment.
+  def environment
+    unless defined?(@environment)
+      @environment = (node.environment and node.environment != "") ? node.environment : nil
+    end
+    Puppet::Node::Environment.current = @environment
+    @environment
+  end
+
+  # Evaluate all of the classes specified by the node.
+  def evaluate_node_classes
+    evaluate_classes(@node.classes, @node_scope || topscope)
+  end
+
+  # Evaluate each specified class in turn.  If there are any classes we can't
+  # find, raise an error.  This method really just creates resource objects
+  # that point back to the classes, and then the resources are themselves
+  # evaluated later in the process.
+  def evaluate_classes(classes, scope, lazy_evaluate = true)
+    raise Puppet::DevError, "No source for scope passed to evaluate_classes" unless scope.source
+    param_classes = nil
+    # if we are a param class, save the classes hash
+    # and transform classes to be the keys
+    if classes.class == Hash
+      param_classes = classes
+      classes = classes.keys
+    end
+    classes.each do |name|
+      # If we can find the class, then make a resource that will evaluate it.
+      if klass = scope.find_hostclass(name)
+
+        if param_classes
+          resource = klass.ensure_in_catalog(scope, param_classes[name] || {})
+        else
+          next if scope.class_scope(klass)
+          resource = klass.ensure_in_catalog(scope)
+        end
+
+        # If they've disabled lazy evaluation (which the :include function does),
+        # then evaluate our resource immediately.
+        resource.evaluate unless lazy_evaluate
+      else
+        raise Puppet::Error, "Could not find class #{name} for #{node.name}"
+      end
+    end
+  end
+
+  def evaluate_relationships
+    @relationships.each { |rel| rel.evaluate(catalog) }
+  end
+
+  # Return a resource by either its ref or its type and title.
+  def findresource(*args)
+    @catalog.resource(*args)
+  end
+
+  def initialize(node, options = {})
+    @node = node
+
+    options.each do |param, value|
+      begin
+        send(param.to_s + "=", value)
+      rescue NoMethodError
+        raise ArgumentError, "Compiler objects do not accept #{param}"
+      end
+    end
+
+    initvars
+  end
+
+  # Create a new scope, with either a specified parent scope or
+  # using the top scope.
+  def newscope(parent, options = {})
+    parent ||= topscope
+    options[:compiler] = self
+    scope = Puppet::Parser::Scope.new(options)
+    scope.parent = parent
+    scope
+  end
+
+  # Return any overrides for the given resource.
+  def resource_overrides(resource)
+    @resource_overrides[resource.ref]
+  end
+
+  private
+
+  # If ast nodes are enabled, then see if we can find and evaluate one.
+  def evaluate_ast_node
+    return unless ast_nodes?
+
+    # Now see if we can find the node.
+    astnode = nil
+    @node.names.each do |name|
+      break if astnode = known_resource_types.node(name.to_s.downcase)
+    end
+
+    unless (astnode ||= known_resource_types.node("default"))
+      raise Puppet::ParseError, "Could not find default node or by name with '#{node.names.join(", ")}'"
+    end
+
+    # Create a resource to model this node, and then add it to the list
+    # of resources.
+    resource = astnode.ensure_in_catalog(topscope)
+
+    resource.evaluate
+
+    @node_scope = topscope.class_scope(astnode)
+  end
+
+  # Evaluate our collections and return true if anything returned an object.
+  # The 'true' is used to continue a loop, so it's important.
+  def evaluate_collections
+    return false if @collections.empty?
+
+    found_something = false
+    exceptwrap do
+      # We have to iterate over a dup of the array because
+      # collections can delete themselves from the list, which
+      # changes its length and causes some collections to get missed.
+      @collections.dup.each do |collection|
+        found_something = true if collection.evaluate
+      end
+    end
+
+    found_something
+  end
+
+  # Make sure all of our resources have been evaluated into native resources.
+  # We return true if any resources have, so that we know to continue the
+  # evaluate_generators loop.
+  def evaluate_definitions
+    exceptwrap do
+      !unevaluated_resources.each { |resource| resource.evaluate }.empty?
+    end
+  end
+
+  # Iterate over collections and resources until we're sure that the whole
+  # compile is evaluated.  This is necessary because both collections
+  # and defined resources can generate new resources, which themselves could
+  # be defined resources.
+  def evaluate_generators
+    count = 0
+    loop do
+      done = true
+
+      # Call collections first, then definitions.
+      done = false if evaluate_collections
+      done = false if evaluate_definitions
+      break if done
+
+      count += 1
+
+      if count > 1000
+        raise Puppet::ParseError, "Somehow looped more than 1000 times while evaluating host catalog"
+      end
+    end
+  end
+
+  # Find and evaluate our main object, if possible.
+  def evaluate_main
+    @main = known_resource_types.find_hostclass([""], "") || known_resource_types.add(Puppet::Resource::Type.new(:hostclass, ""))
+    @topscope.source = @main
+    @main_resource = Puppet::Parser::Resource.new("class", :main, :scope => @topscope, :source => @main)
+    @topscope.resource = @main_resource
+
+    add_resource(@topscope, @main_resource)
+
+    @main_resource.evaluate
+  end
+
+  # Make sure the entire catalog is evaluated.
+  def fail_on_unevaluated
+    fail_on_unevaluated_overrides
+    fail_on_unevaluated_resource_collections
+  end
+
+  # If there are any resource overrides remaining, then we could
+  # not find the resource they were supposed to override, so we
+  # want to throw an exception.
+  def fail_on_unevaluated_overrides
+    remaining = []
+    @resource_overrides.each do |name, overrides|
+      remaining.concat overrides
+    end
+
+    unless remaining.empty?
+      fail Puppet::ParseError,
+        "Could not find resource(s) %s for overriding" % remaining.collect { |o|
+          o.ref
+        }.join(", ")
+    end
+  end
+
+  # Make sure we don't have any remaining collections that specifically
+  # look for resources, because we want to consider those to be
+  # parse errors.
+  def fail_on_unevaluated_resource_collections
+    remaining = []
+    @collections.each do |coll|
+      # We're only interested in the 'resource' collections,
+      # which result from direct calls of 'realize'.  Anything
+      # else is allowed not to return resources.
+      # Collect all of them, so we have a useful error.
+      if r = coll.resources
+        if r.is_a?(Array)
+          remaining += r
+        else
+          remaining << r
+        end
+      end
+    end
+
+    raise Puppet::ParseError, "Failed to realize virtual resources #{remaining.join(', ')}" unless remaining.empty?
+  end
+
+  # Make sure all of our resources and such have done any last work
+  # necessary.
+  def finish
+    evaluate_relationships
+
+    resources.each do |resource|
+      # Add in any resource overrides.
+      if overrides = resource_overrides(resource)
+        overrides.each do |over|
+          resource.merge(over)
+        end
+
+        # Remove the overrides, so that the configuration knows there
+        # are none left.
+        overrides.clear
+      end
+
+      resource.finish if resource.respond_to?(:finish)
+    end
+
+    add_resource_metaparams
+  end
+
+  def add_resource_metaparams
+    unless main = catalog.resource(:class, :main)
+      raise "Couldn't find main"
+    end
+
+    names = []
+    Puppet::Type.eachmetaparam do |name|
+      next if Puppet::Parser::Resource.relationship_parameter?(name)
+      names << name
+    end
+
+    data = {}
+    catalog.walk(main, :out) do |source, target|
+      if source_data = data[source] || metaparams_as_data(source, names)
+        # only store anything in the data hash if we've actually got
+        # data
+        data[source] ||= source_data
+        source_data.each do |param, value|
+          target[param] = value if target[param].nil?
+        end
+        data[target] = source_data.merge(metaparams_as_data(target, names))
+      end
+
+      target.tag(*(source.tags))
+    end
+  end
+
+  def metaparams_as_data(resource, params)
+    data = nil
+    params.each do |param|
+      unless resource[param].nil?
+        # Because we could be creating a hash for every resource,
+        # and we actually probably don't often have any data here at all,
+        # we're optimizing a bit by only creating a hash if there's
+        # any data to put in it.
+        data ||= {}
+        data[param] = resource[param]
+      end
+    end
+    data
+  end
+
+  # Set up all of our internal variables.
+  def initvars
+    # The list of objects that will available for export.
+    @exported_resources = {}
+
+    # The list of overrides.  This is used to cache overrides on objects
+    # that don't exist yet.  We store an array of each override.
+    @resource_overrides = Hash.new do |overs, ref|
+      overs[ref] = []
+    end
+
+    # The list of collections that have been created.  This is a global list,
+    # but they each refer back to the scope that created them.
+    @collections = []
+
+    # The list of relationships to evaluate.
+    @relationships = []
+
+    # For maintaining the relationship between scopes and their resources.
+    @catalog = Puppet::Resource::Catalog.new(@node.name)
+    @catalog.version = known_resource_types.version
+
+    # Create our initial scope and a resource that will evaluate main.
+    @topscope = Puppet::Parser::Scope.new(:compiler => self)
+
+    @main_stage_resource = Puppet::Parser::Resource.new("stage", :main, :scope => @topscope)
+    @catalog.add_resource(@main_stage_resource)
+
+    # local resource array to maintain resource ordering
+    @resources = []
+
+    # Make sure any external node classes are in our class list
+    if @node.classes.class == Hash
+      @catalog.add_class(*@node.classes.keys)
+    else
+      @catalog.add_class(*@node.classes)
+    end
+  end
+
+  # Set the node's parameters into the top-scope as variables.
+  def set_node_parameters
+    node.parameters.each do |param, value|
+      @topscope.setvar(param, value)
+    end
+
+    # These might be nil.
+    catalog.client_version = node.parameters["clientversion"]
+    catalog.server_version = node.parameters["serverversion"]
+  end
+
+  def create_settings_scope
+    unless settings_type = environment.known_resource_types.hostclass("settings")
+      settings_type = Puppet::Resource::Type.new :hostclass, "settings"
+      environment.known_resource_types.add(settings_type)
+    end
+
+    settings_resource = Puppet::Parser::Resource.new("class", "settings", :scope => @topscope)
+
+    @catalog.add_resource(settings_resource)
+
+    settings_type.evaluate_code(settings_resource)
+
+    scope = @topscope.class_scope(settings_type)
+
+    Puppet.settings.each do |name, setting|
+      next if name.to_s == "name"
+      scope.setvar name.to_s, environment[name]
+    end
+  end
+
+  # Return an array of all of the unevaluated resources.  These will be definitions,
+  # which need to get evaluated into native resources.
+  def unevaluated_resources
+    # The order of these is significant for speed due to short-circuting
+    resources.reject { |resource| resource.evaluated? or resource.virtual? or resource.builtin_type? }
+  end
+end

data/lib/vendor/puppet/parser/files.rb

@@ -0,0 +1,88 @@
+require 'puppet/module'
+require 'puppet/parser/parser'
+
+# This is a silly central module for finding
+# different kinds of files while parsing.  This code
+# doesn't really belong in the Puppet::Module class,
+# but it doesn't really belong anywhere else, either.
+module Puppet::Parser::Files
+  module_function
+
+  # Return a list of manifests (as absolute filenames) that match +pat+
+  # with the current directory set to +cwd+. If the first component of
+  # +pat+ does not contain any wildcards and is an existing module, return
+  # a list of manifests in that module matching the rest of +pat+
+  # Otherwise, try to find manifests matching +pat+ relative to +cwd+
+  def find_manifests(start, options = {})
+    cwd = options[:cwd] || Dir.getwd
+    module_name, pattern = split_file_path(start)
+    begin
+      if mod = Puppet::Module.find(module_name, options[:environment])
+        return [mod.name, mod.match_manifests(pattern)]
+      end
+    rescue Puppet::Module::InvalidName
+      # Than that would be a "no."
+    end
+    abspat = File::expand_path(start, cwd)
+    [nil, Dir.glob(abspat + (File.extname(abspat).empty? ? '{.pp,.rb}' : '' )).uniq.reject { |f| FileTest.directory?(f) }]
+  end
+
+  # Find the concrete file denoted by +file+. If +file+ is absolute,
+  # return it directly. Otherwise try to find it as a template in a
+  # module. If that fails, return it relative to the +templatedir+ config
+  # param.
+  # In all cases, an absolute path is returned, which does not
+  # necessarily refer to an existing file
+  def find_template(template, environment = nil)
+    if template == File.expand_path(template)
+      return template
+    end
+
+    if template_paths = templatepath(environment)
+      # If we can find the template in :templatedir, we return that.
+      template_paths.collect { |path|
+        File::join(path, template)
+      }.each do |f|
+        return f if FileTest.exist?(f)
+      end
+    end
+
+    # check in the default template dir, if there is one
+    if td_file = find_template_in_module(template, environment)
+      return td_file
+    end
+
+    nil
+  end
+
+  def find_template_in_module(template, environment = nil)
+    path, file = split_file_path(template)
+
+    # Because templates don't have an assumed template name, like manifests do,
+    # we treat templates with no name as being templates in the main template
+    # directory.
+    return nil unless file
+
+    if mod = Puppet::Module.find(path, environment) and t = mod.template(file)
+      return t
+    end
+    nil
+  end
+
+  # Return an array of paths by splitting the +templatedir+ config
+  # parameter.
+  def templatepath(environment = nil)
+    dirs = Puppet.settings.value(:templatedir, environment).split(File::PATH_SEPARATOR)
+    dirs.select do |p|
+      File::directory?(p)
+    end
+  end
+
+  # Split the path into the module and the rest of the path, or return
+  # nil if the path is empty or absolute (starts with a /).
+  # This method can return nil & anyone calling it needs to handle that.
+  def split_file_path(path)
+    path.split(File::SEPARATOR, 2) unless path == "" or Puppet::Util.absolute_path?(path)
+  end
+
+end

data/lib/vendor/puppet/parser/functions/create_resources.rb

@@ -0,0 +1,75 @@
+Puppet::Parser::Functions::newfunction(:create_resources, :doc => <<-'ENDHEREDOC') do |args|
+    Converts a hash into a set of resources and adds them to the catalog.
+
+    This function takes two mandatory arguments: a resource type, and a hash describing
+    a set of resources. The hash should be in the form `{title => {parameters} }`:
+
+        # A hash of user resources:
+        $myusers = {
+          'nick' => { uid    => '1330',
+                      group  => allstaff,
+                      groups => ['developers', 'operations', 'release'], }
+          'dan'  => { uid    => '1308',
+                      group  => allstaff,
+                      groups => ['developers', 'prosvc', 'release'], }
+        }
+
+        create_resources(user, $myusers)
+
+    A third, optional parameter may be given, also as a hash:
+
+        $defaults = {
+          'ensure'   => present,
+          'provider' => 'ldap',
+        }
+
+        create_resources(user, $myusers, $defaults)
+
+    The values given on the third argument are added to the parameters of each resource
+    present in the set given on the second argument. If a parameter is present on both
+    the second and third arguments, the one on the second argument takes precedence.
+
+    This function can be used to create defined resources and classes, as well
+    as native resources.
+  ENDHEREDOC
+  raise ArgumentError, ("create_resources(): wrong number of arguments (#{args.length}; must be 2 or 3)") if args.length < 2 || args.length > 3
+
+  # figure out what kind of resource we are
+  type_of_resource = nil
+  type_name = args[0].downcase
+  if type_name == 'class'
+    type_of_resource = :class
+  else
+    if resource = Puppet::Type.type(type_name.to_sym)
+      type_of_resource = :type
+    elsif resource = find_definition(type_name.downcase)
+      type_of_resource = :define
+    else
+      raise ArgumentError, "could not create resource of unknown type #{type_name}"
+    end
+  end
+  # iterate through the resources to create
+  defaults = args[2] || {}
+  args[1].each do |title, params|
+    params = Puppet::Util.symbolizehash(defaults.merge(params))
+    raise ArgumentError, 'params should not contain title' if(params[:title])
+    case type_of_resource
+    # JJM The only difference between a type and a define is the call to instantiate_resource
+    # for a defined type.
+    when :type, :define
+      p_resource = Puppet::Parser::Resource.new(type_name, title, :scope => self, :source => resource)
+      {:name => title}.merge(params).each do |k,v|
+        p_resource.set_parameter(k,v)
+      end
+      if type_of_resource == :define then
+        resource.instantiate_resource(self, p_resource)
+      end
+      compiler.add_resource(self, p_resource)
+    when :class
+      klass = find_hostclass(title)
+      raise ArgumentError, "could not find hostclass #{title}" unless klass
+      klass.ensure_in_catalog(self, params)
+      compiler.catalog.add_class(title)
+    end
+  end
+end

data/lib/vendor/puppet/parser/functions/defined.rb

@@ -0,0 +1,49 @@
+# Test whether a given class or definition is defined
+Puppet::Parser::Functions::newfunction(:defined, :type => :rvalue, :doc => "Determine whether
+  a given class or resource type is defined. This function can also determine whether a
+  specific resource has been declared. Returns true or false. Accepts class names,
+  type names, and resource references.
+
+  The `defined` function checks both native and defined types, including types
+  provided as plugins via modules. Types and classes are both checked using their names:
+
+      defined(\"file\")
+      defined(\"customtype\")
+      defined(\"foo\")
+      defined(\"foo::bar\")
+
+  Resource declarations are checked using resource references, e.g.
+  `defined( File['/tmp/myfile'] )`. Checking whether a given resource
+  has been declared is, unfortunately, dependent on the parse order of
+  the configuration, and the following code will not work:
+
+      if defined(File['/tmp/foo']) {
+          notify(\"This configuration includes the /tmp/foo file.\")
+      }
+      file {\"/tmp/foo\":
+          ensure => present,
+      }
+
+  However, this order requirement refers to parse order only, and ordering of
+  resources in the configuration graph (e.g. with `before` or `require`) does not
+  affect the behavior of `defined`.") do |vals|
+    result = false
+    vals = [vals] unless vals.is_a?(Array)
+    vals.each do |val|
+      case val
+      when String
+        if Puppet::Type.type(val) or find_definition(val) or find_hostclass(val)
+          result = true
+          break
+        end
+      when Puppet::Resource
+        if findresource(val.to_s)
+          result = true
+          break
+        end
+      else
+        raise ArgumentError, "Invalid argument of type '#{val.class}' to 'defined'"
+      end
+    end
+    result
+end