puppet 3.7.0-x64-mingw32

data/lib/puppet/parser/parser_factory.rb

@@ -0,0 +1,76 @@
+module Puppet; end
+
+module Puppet::Parser
+  # The ParserFactory makes selection of parser possible.
+  # Currently, it is possible to switch between two different parsers:
+  # * classic_parser, the parser in 3.1
+  # * eparser, the Expression Based Parser
+  #
+  class ParserFactory
+    # Produces a parser instance for the given environment
+    def self.parser(environment)
+      if Puppet[:parser] == 'future'
+        evaluating_parser(environment)
+      else
+        classic_parser(environment)
+      end
+    end
+
+    # Creates an instance of the classic parser.
+    #
+    def self.classic_parser(environment)
+      # avoid expensive require if already loaded
+      require 'puppet/parser' unless defined? Puppet::Parser::Parser
+      Puppet::Parser::Parser.new(environment)
+    end
+
+    # Creates an instance of an E4ParserAdapter that adapts an
+    # EvaluatingParser to the 3x way of parsing.
+    #
+    def self.evaluating_parser(file_watcher)
+      # Since RGen is optional, test that it is installed
+      assert_rgen_installed()
+      unless defined?(Puppet::Pops::Parser::E4ParserAdapter)
+        require 'puppet/parser/e4_parser_adapter'
+        require 'puppet/pops/parser/code_merger'
+      end
+      E4ParserAdapter.new(file_watcher)
+    end
+
+    # Asserts that RGen >= 0.6.6 is installed by checking that certain behavior is available.
+    # Note that this assert is expensive as it also requires puppet/pops (if not already loaded).
+    #
+    def self.assert_rgen_installed
+      @@asserted ||= false
+      return if @@asserted
+      @@asserted = true
+      begin
+        require 'rgen/metamodel_builder'
+      rescue LoadError
+        raise Puppet::DevError.new("The gem 'rgen' version >= 0.7.0 is required when using the setting '--parser future'. Please install 'rgen'.")
+      end
+      # Since RGen is optional, there is nothing specifying its version.
+      # It is not installed in any controlled way, so not possible to use gems to check (it may be installed some other way).
+      # Instead check that "eContainer, and eContainingFeature" has been installed.
+      require 'puppet/pops'
+      begin
+        litstring = Puppet::Pops::Model::LiteralString.new();
+        container = Puppet::Pops::Model::ArithmeticExpression.new();
+        container.left_expr = litstring
+        raise "no eContainer" if litstring.eContainer() != container
+        raise "no eContainingFeature" if litstring.eContainingFeature() != :left_expr
+      rescue => e
+        # TODO: RGen can raise exceptions for other reasons!
+        raise Puppet::DevError.new("The gem 'rgen' version >= 0.7.0 is required when using '--parser future'. An older version is installed, please update.")
+      end
+    end
+
+    def self.code_merger
+      if Puppet[:parser] == 'future'
+        Puppet::Pops::Parser::CodeMerger.new
+      else
+        Puppet::Parser::CodeMerger.new
+      end
+    end
+  end
+end

data/lib/puppet/parser/parser_support.rb

@@ -0,0 +1,195 @@
+# I pulled this into a separate file, because I got
+# tired of rebuilding the parser.rb file all the time.
+require 'forwardable'
+
+class Puppet::Parser::Parser
+  extend Forwardable
+
+  require 'puppet/parser/functions'
+  require 'puppet/parser/files'
+  require 'puppet/resource/type_collection'
+  require 'puppet/resource/type_collection_helper'
+  require 'puppet/resource/type'
+  require 'monitor'
+
+  AST = Puppet::Parser::AST
+
+  include Puppet::Resource::TypeCollectionHelper
+
+  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)
+    obj ||= @lexer
+
+    message += " on line #{obj.line}"
+    if file = obj.file
+      message += " in file #{file}"
+    end
+
+    message
+  end
+
+  # Create an AST array containing a single element
+  def aryfy(arg)
+    ast AST::ASTArray, :children => [arg]
+  end
+
+  # Create an AST block containing a single element
+  def block(arg)
+    ast AST::BlockExpression, :children => [arg]
+  end
+
+  # Create an AST object, and automatically add the file and line information if
+  # available.
+  def ast(klass, hash = {})
+    klass.new ast_context(klass.use_docs, hash[:line]).merge(hash)
+  end
+
+  def ast_context(include_docs = false, ast_line = nil)
+    result = {
+      :line => ast_line || lexer.line,
+      :file => lexer.file
+    }
+    result[:doc] = lexer.getcomment(result[:line]) if include_docs
+    result
+  end
+
+  # The fully qualifed name, with the full namespace.
+  def classname(name)
+    [@lexer.namespace, name].join("::").sub(/^::/, '')
+  end
+
+  def clear
+    initvars
+  end
+
+  # Raise a Parse error.
+  def error(message, options = {})
+    if @lexer.expected
+      message += "; expected '%s'"
+    end
+    except = Puppet::ParseError.new(message)
+    except.line = options[:line] || @lexer.line
+    except.file = options[:file] || @lexer.file
+
+    raise except
+  end
+
+  def_delegators :@lexer, :file, :string=
+
+  def file=(file)
+    unless Puppet::FileSystem.exist?(file)
+      unless file =~ /\.pp$/
+        file = file + ".pp"
+      end
+    end
+    raise Puppet::AlreadyImportedError, "Import loop detected for #{file}" if known_resource_types.watching_file?(file)
+
+    watch_file(file)
+    @lexer.file = file
+  end
+
+  def_delegators :known_resource_types, :hostclass, :definition, :node, :nodes?
+  def_delegators :known_resource_types, :find_hostclass, :find_definition
+  def_delegators :known_resource_types, :watch_file, :version
+
+  def import(file)
+    deprecation_location_text =
+    if @lexer.file && @lexer.line
+      " at #{@lexer.file}:#{@lexer.line}"
+    elsif @lexer.file
+      " in file #{@lexer.file}"
+    elsif @lexer.line
+      " at #{@lexer.line}"
+    end
+
+    Puppet.deprecation_warning("The use of 'import' is deprecated#{deprecation_location_text}. See http://links.puppetlabs.com/puppet-import-deprecation")
+    if @lexer.file
+      # use a path relative to the file doing the importing
+      dir = File.dirname(@lexer.file)
+    else
+      # otherwise assume that everything needs to be from where the user is
+      # executing this command. Normally, this would be in a "puppet apply -e"
+      dir = Dir.pwd
+    end
+
+    known_resource_types.loader.import(file, dir)
+  end
+
+  def initialize(env)
+    @environment = env
+    initvars
+  end
+
+  # Initialize or reset all of our variables.
+  def initvars
+    @lexer = Puppet::Parser::Lexer.new
+  end
+
+  # Split an fq name into a namespace and name
+  def namesplit(fullname)
+    ary = fullname.split("::")
+    n = ary.pop || ""
+    ns = ary.join("::")
+    return ns, n
+  end
+
+  def on_error(token,value,stack)
+    if token == 0 # denotes end of file
+      value = 'end of file'
+    else
+      value = "'#{value[:value]}'"
+    end
+    error = "Syntax error at #{value}"
+
+    if brace = @lexer.expected
+      error += "; expected '#{brace}'"
+    end
+
+    except = Puppet::ParseError.new(error)
+    except.line = @lexer.line
+    except.file = @lexer.file if @lexer.file
+
+    raise except
+  end
+
+  # how should I do error handling here?
+  def parse(string = nil)
+    if self.file =~ /\.rb$/
+      main = parse_ruby_file
+    else
+      self.string = string if string
+      begin
+        @yydebug = false
+        main = yyparse(@lexer,:scan)
+      rescue Puppet::ParseError => except
+        except.line ||= @lexer.line
+        except.file ||= @lexer.file
+        except.pos ||= @lexer.pos
+        raise except
+      rescue => except
+        raise Puppet::ParseError.new(except.message, @lexer.file, @lexer.line, nil, except)
+      end
+    end
+    # Store the results as the top-level class.
+    return Puppet::Parser::AST::Hostclass.new('', :code => main)
+  ensure
+    @lexer.clear
+  end
+
+  def parse_ruby_file
+    Puppet.deprecation_warning("Use of the Ruby DSL is deprecated.")
+
+    # Execute the contents of the file inside its own "main" object so
+    # that it can call methods in the resource type API.
+    main_object = Puppet::DSL::ResourceTypeAPI.new
+    main_object.instance_eval(File.read(self.file))
+
+    # Then extract any types that were created.
+    Puppet::Parser::AST::BlockExpression.new :children => main_object.instance_eval { @__created_ast_objects__ }
+  end
+end

data/lib/puppet/parser/relationship.rb

@@ -0,0 +1,62 @@
+class Puppet::Parser::Relationship
+  attr_accessor :source, :target, :type
+
+  PARAM_MAP = {:relationship => :before, :subscription => :notify}
+
+  def arrayify(resources)
+    case resources
+    when Puppet::Parser::Collector
+      resources.collected.values
+    when Array
+      resources
+    else
+      [resources]
+    end
+  end
+
+  def evaluate(catalog)
+    arrayify(source).each do |s|
+      arrayify(target).each do |t|
+        mk_relationship(s, t, catalog)
+      end
+    end
+  end
+
+  def initialize(source, target, type)
+    @source, @target, @type = source, target, type
+  end
+
+  def param_name
+    PARAM_MAP[type] || raise(ArgumentError, "Invalid relationship type #{type}")
+  end
+
+  def mk_relationship(source, target, catalog)
+    # REVISIT: In Ruby 1.8 we applied `to_s` to source and target, rather than
+    # `join` without an argument.  In 1.9 the behaviour of Array#to_s changed,
+    # and it gives a different representation than just concat the stringified
+    # elements.
+    #
+    # This restores the behaviour, but doesn't address the underlying question
+    # of what would happen when more than one item was passed in that array.
+    # (Hint: this will not end well.)
+    #
+    # See http://projects.puppetlabs.com/issues/12076 for the ticket tracking
+    # the fact that we should dig out the sane version of this behaviour, then
+    # implement it - where we don't risk breaking a stable release series.
+    # --daniel 2012-01-21
+    source = source.is_a?(Array) ? source.join : source.to_s
+    target = target.is_a?(Array) ? target.join : target.to_s
+
+    unless source_resource = catalog.resource(source)
+      raise ArgumentError, "Could not find resource '#{source}' for relationship on '#{target}'"
+    end
+    unless catalog.resource(target)
+      raise ArgumentError, "Could not find resource '#{target}' for relationship from '#{source}'"
+    end
+    Puppet.debug "Adding relationship from #{source} to #{target} with '#{param_name}'"
+    if source_resource[param_name].class != Array
+      source_resource[param_name] = [source_resource[param_name]].compact
+    end
+    source_resource[param_name] << target
+  end
+end

data/lib/puppet/parser/resource.rb

@@ -0,0 +1,277 @@
+require 'puppet/resource'
+
+# The primary difference between this class and its
+# parent is that this class has rules on who can set
+# parameters
+class Puppet::Parser::Resource < Puppet::Resource
+  require 'puppet/parser/resource/param'
+  require 'puppet/util/tagging'
+  require 'puppet/parser/yaml_trimmer'
+  require 'puppet/resource/type_collection_helper'
+
+  include Puppet::Resource::TypeCollectionHelper
+
+  include Puppet::Util
+  include Puppet::Util::MethodHelper
+  include Puppet::Util::Errors
+  include Puppet::Util::Logging
+  include Puppet::Parser::YamlTrimmer
+
+  attr_accessor :source, :scope, :collector_id
+  attr_accessor :virtual, :override, :translated, :catalog, :evaluated
+  attr_accessor :file, :line
+
+  attr_reader :exported, :parameters
+
+  # Determine whether the provided parameter name is a relationship parameter.
+  def self.relationship_parameter?(name)
+    @relationship_names ||= Puppet::Type.relationship_params.collect { |p| p.name }
+    @relationship_names.include?(name)
+  end
+
+  # Set up some boolean test methods
+  def translated?; !!@translated; end
+  def override?;   !!@override;   end
+  def evaluated?;  !!@evaluated;  end
+
+  def [](param)
+    param = param.intern
+    if param == :title
+      return self.title
+    end
+    if @parameters.has_key?(param)
+      @parameters[param].value
+    else
+      nil
+    end
+  end
+
+  def eachparam
+    @parameters.each do |name, param|
+      yield param
+    end
+  end
+
+  def environment
+    scope.environment
+  end
+
+  # Process the  stage metaparameter for a class.   A containment edge
+  # is drawn from  the class to the stage.   The stage for containment
+  # defaults to main, if none is specified.
+  def add_edge_to_stage
+    return unless self.class?
+
+    unless stage = catalog.resource(:stage, self[:stage] || (scope && scope.resource && scope.resource[:stage]) || :main)
+      raise ArgumentError, "Could not find stage #{self[:stage] || :main} specified by #{self}"
+    end
+
+    self[:stage] ||= stage.title unless stage.title == :main
+    catalog.add_edge(stage, self)
+  end
+
+  # Retrieve the associated definition and evaluate it.
+  def evaluate
+    return if evaluated?
+    @evaluated = true
+    if klass = resource_type and ! builtin_type?
+      finish
+      evaluated_code = klass.evaluate_code(self)
+
+      return evaluated_code
+    elsif builtin?
+      devfail "Cannot evaluate a builtin type (#{type})"
+    else
+      self.fail "Cannot find definition #{type}"
+    end
+  end
+
+  # Mark this resource as both exported and virtual,
+  # or remove the exported mark.
+  def exported=(value)
+    if value
+      @virtual = true
+      @exported = value
+    else
+      @exported = value
+    end
+  end
+
+  # Do any finishing work on this object, called before evaluation or
+  # before storage/translation.
+  def finish
+    return if finished?
+    @finished = true
+    add_defaults
+    add_scope_tags
+    validate
+  end
+
+  # Has this resource already been finished?
+  def finished?
+    @finished
+  end
+
+  def initialize(*args)
+    raise ArgumentError, "Resources require a hash as last argument" unless args.last.is_a? Hash
+    raise ArgumentError, "Resources require a scope" unless args.last[:scope]
+    super
+
+    @source ||= scope.source
+  end
+
+  # Is this resource modeling an isomorphic resource type?
+  def isomorphic?
+    if builtin_type?
+      return resource_type.isomorphic?
+    else
+      return true
+    end
+  end
+
+  # Merge an override resource in.  This will throw exceptions if
+  # any overrides aren't allowed.
+  def merge(resource)
+    # Test the resource scope, to make sure the resource is even allowed
+    # to override.
+    unless self.source.object_id == resource.source.object_id || resource.source.child_of?(self.source)
+      raise Puppet::ParseError.new("Only subclasses can override parameters", resource.line, resource.file)
+    end
+    # Some of these might fail, but they'll fail in the way we want.
+    resource.parameters.each do |name, param|
+      override_parameter(param)
+    end
+  end
+
+  # This only mattered for clients < 0.25, which we don't support any longer.
+  # ...but, since this hasn't been deprecated, and at least some functions
+  # used it, deprecate now rather than just eliminate. --daniel 2012-07-15
+  def metaparam_compatibility_mode?
+    Puppet.deprecation_warning "metaparam_compatibility_mode? is obsolete since < 0.25 clients are really, really not supported any more"
+    false
+  end
+
+  def name
+    self[:name] || self.title
+  end
+
+  # A temporary occasion, until I get paths in the scopes figured out.
+  alias path to_s
+
+  # Define a parameter in our resource.
+  # if we ever receive a parameter named 'tag', set
+  # the resource tags with its value.
+  def set_parameter(param, value = nil)
+    if ! value.nil?
+      param = Puppet::Parser::Resource::Param.new(
+        :name => param, :value => value, :source => self.source
+      )
+    elsif ! param.is_a?(Puppet::Parser::Resource::Param)
+      raise ArgumentError, "Received incomplete information - no value provided for parameter #{param}"
+    end
+
+    tag(*param.value) if param.name == :tag
+
+    # And store it in our parameter hash.
+    @parameters[param.name] = param
+  end
+  alias []= set_parameter
+
+  def to_hash
+    @parameters.inject({}) do |hash, ary|
+      param = ary[1]
+      # Skip "undef" and nil values.
+      hash[param.name] = param.value if param.value != :undef && !param.value.nil?
+      hash
+    end
+  end
+
+  # Convert this resource to a RAL resource.
+  def to_ral
+    copy_as_resource.to_ral
+  end
+
+  # Is the receiver tagged with the given tags?
+  # This match takes into account the tags that a resource will inherit from its container
+  # but have not been set yet.
+  # It does *not* take tags set via resource defaults as these will *never* be set on
+  # the resource itself since all resources always have tags that are automatically
+  # assigned.
+  #
+  def tagged?(*tags)
+    super || ((scope_resource = scope.resource) && scope_resource != self && scope_resource.tagged?(tags))
+  end
+
+  private
+
+  # Add default values from our definition.
+  def add_defaults
+    scope.lookupdefaults(self.type).each do |name, param|
+      unless @parameters.include?(name)
+        self.debug "Adding default for #{name}"
+
+        @parameters[name] = param.dup
+      end
+    end
+  end
+
+  def add_scope_tags
+    if scope_resource = scope.resource
+      tag(*scope_resource.tags)
+    end
+  end
+
+  # Accept a parameter from an override.
+  def override_parameter(param)
+    # This can happen if the override is defining a new parameter, rather
+    # than replacing an existing one.
+    (set_parameter(param) and return) unless current = @parameters[param.name]
+
+    # The parameter is already set.  Fail if they're not allowed to override it.
+    unless param.source.child_of?(current.source)
+      msg = "Parameter '#{param.name}' is already set on #{self}"
+      msg += " by #{current.source}" if current.source.to_s != ""
+      if current.file or current.line
+        fields = []
+        fields << current.file if current.file
+        fields << current.line.to_s if current.line
+        msg += " at #{fields.join(":")}"
+      end
+      msg += "; cannot redefine"
+      raise Puppet::ParseError.new(msg, param.line, param.file)
+    end
+
+    # If we've gotten this far, we're allowed to override.
+
+    # Merge with previous value, if the parameter was generated with the +>
+    # syntax.  It's important that we use a copy of the new param instance
+    # here, not the old one, and not the original new one, so that the source
+    # is registered correctly for later overrides but the values aren't
+    # implcitly shared when multiple resources are overrriden at once (see
+    # ticket #3556).
+    if param.add
+      param = param.dup
+      param.value = [current.value, param.value].flatten
+    end
+
+    set_parameter(param)
+  end
+
+  # Make sure the resource's parameters are all valid for the type.
+  def validate
+    @parameters.each do |name, param|
+      validate_parameter(name)
+    end
+  rescue => detail
+    self.fail Puppet::ParseError, detail.to_s + " on #{self}", detail
+  end
+
+  def extract_parameters(params)
+    params.each do |param|
+      # Don't set the same parameter twice
+      self.fail Puppet::ParseError, "Duplicate parameter '#{param.name}' for on #{self}" if @parameters[param.name]
+
+      set_parameter(param)
+    end
+  end
+end