bolt 0.19.1 → 0.20.0

data/vendored/puppet/lib/puppet/parser/compiler/catalog_validator.rb

@@ -1,33 +0,0 @@
-# Abstract class for a catalog validator that can be registered with the compiler to run at
-# a certain stage.
-class Puppet::Parser::Compiler
-  class CatalogValidator
-    PRE_FINISH = :pre_finish
-    FINAL = :final
-
-    # Returns true if the validator should run at the given stage. The default
-    # implementation will only run at stage `FINAL`
-    #
-    # @param stage [Symbol] One of the stage constants defined in this class
-    # @return [Boolean] true if the validator should run at the given stage
-    #
-    def self.validation_stage?(stage)
-      FINAL.equal?(stage)
-    end
-
-    attr_reader :catalog
-
-    # @param catalog [Puppet::Resource::Catalog] The catalog to validate
-    def initialize(catalog)
-      @catalog = catalog
-    end
-
-    # Validate some aspect of the catalog and raise a `CatalogValidationError` on failure
-    def validate
-    end
-  end
-
-  class CatalogValidationError < Puppet::Error
-    include Puppet::ExternalFileError
-  end
-end

data/vendored/puppet/lib/puppet/parser/compiler/catalog_validator/env_relationship_validator.rb

@@ -1,64 +0,0 @@
-class Puppet::Parser::Compiler
-  # Validator that asserts that all capability resources that are referenced by 'consume' or 'require' has
-  # been exported by some other resource in the environment
-  class CatalogValidator::EnvironmentRelationshipValidator < CatalogValidator
-
-    def validate
-      assumed_exports = {}
-      exported = {}
-      catalog.resources.each do |resource|
-        next unless resource.is_a?(Puppet::Parser::Resource)
-        resource.eachparam do |param|
-          pclass = Puppet::Type.metaparamclass(param.name)
-          validate_relationship(resource, param, assumed_exports, exported) if !pclass.nil? && pclass < Puppet::Type::RelationshipMetaparam
-        end
-      end
-      assumed_exports.each_pair do |key, (param, cap)|
-        raise CatalogValidationError.new(_("Capability '%{cap}' referenced by '%{param}' is never exported") % { cap: cap, param: param.name }, param.file, param.line) unless exported.include?(key)
-      end
-      nil
-    end
-
-    private
-
-    def validate_relationship(resource, param, assumed_exports, exported)
-      case param.name
-      when :require, :consume
-        add_capability_ref(param, param.value, assumed_exports)
-      when :export
-        add_exported(resource, param, param.value, exported)
-      end
-    end
-
-    def add_capability_ref(param, value, assumed_exports)
-      case value
-      when Array
-        value.each { |v| add_capability_ref(param, v, assumed_exports) }
-      when Puppet::Resource
-        rt = value.resource_type
-        unless rt.nil? || !rt.is_capability?
-          title_key = catalog.title_key_for_ref(value.ref)
-          assumed_exports[title_key] = [param, value]
-        end
-        nil
-      end
-    end
-
-    def add_exported(resource, param, value, hash)
-      case value
-      when Array
-        value.each { |v| add_exported(resource, param, v, hash) }
-      when Puppet::Resource
-        rt = value.resource_type
-        unless rt.nil? || !rt.is_capability?
-          title_key = catalog.title_key_for_ref(value.ref)
-          if hash.include?(title_key)
-            raise CatalogValidationError.new(_("'%{value}' is exported by both '%{hash}' and '%{resource}'") % { value: value, hash: hash[title_key], resource: resource }, param.file, param.line)
-          else
-            hash[title_key] = resource
-          end
-        end
-      end
-    end
-  end
-end

data/vendored/puppet/lib/puppet/parser/compiler/catalog_validator/relationship_validator.rb

@@ -1,57 +0,0 @@
-class Puppet::Parser::Compiler
-  # Validator that asserts that only 'require', 'consume', and 'export' is used when declaring relationships
-  # to capability resources.
-  class CatalogValidator::RelationshipValidator < CatalogValidator
-    def validate
-      catalog.resources.each do |resource|
-        next unless resource.is_a?(Puppet::Parser::Resource)
-        next if resource.virtual?
-        resource.eachparam do |param|
-          pclass = Puppet::Type.metaparamclass(param.name)
-          validate_relationship(param) if !pclass.nil? && pclass < Puppet::Type::RelationshipMetaparam
-        end
-      end
-      nil
-    end
-
-    private
-
-    # A hash lookup is 6x avg times faster than find among 3 values.
-    CAPABILITY_ACCEPTED_METAPARAMS = {:require => true, :consume => true, :export => true}.freeze
-
-    def validate_relationship(param)
-      # when relationship is to a capability
-      if has_capability?(param.value)
-        unless CAPABILITY_ACCEPTED_METAPARAMS[param.name]
-          raise CatalogValidationError.new(
-            _("'%{param}' is not a valid relationship to a capability") % { param: param.name },
-              param.file, param.line)
-        end
-      else
-        # all other relationships requires the referenced resource to exist
-        refs = param.value.is_a?(Array) ? param.value.flatten : [param.value]
-        refs.each do |r|
-          next if r.nil? || r == :undef
-          unless catalog.resource(r.to_s)
-            msg = _("Could not find resource '%{res}' in parameter '%{param}'") % { res: r.to_s, param: param.name.to_s }
-            raise CatalogValidationError.new(msg, param.file, param.line)
-          end
-        end
-      end
-    end
-
-    def has_capability?(value)
-      case value
-      when Array
-        value.find { |v| has_capability?(v) }
-      when Puppet::Resource
-        rt = value.resource_type
-        !rt.nil? && rt.is_capability?
-      else
-        false
-      end
-    end
-  end
-end
-
-

data/vendored/puppet/lib/puppet/parser/compiler/catalog_validator/site_validator.rb

@@ -1,20 +0,0 @@
-class Puppet::Parser::Compiler
-  # Validator that asserts that only application components can appear inside a site.
-  class CatalogValidator::SiteValidator < CatalogValidator
-    def self.validation_stage?(stage)
-      PRE_FINISH.equal?(stage)
-    end
-
-    def validate
-      the_site_resource = catalog.resource('Site', 'site')
-      return unless the_site_resource
-
-      catalog.downstream_from_vertex(the_site_resource).keys.each do |r|
-        unless r.is_application_component? || r.resource_type.application?
-          raise CatalogValidationError.new(_("Only application components can appear inside a site - %{res} is not allowed") % { res: r }, r.file, r.line)
-        end
-      end
-    end
-  end
-end
-

data/vendored/puppet/lib/puppet/parser/e4_parser_adapter.rb

@@ -1,60 +0,0 @@
-require 'puppet/pops'
-
-module Puppet
-module Parser
-# Adapts an egrammar/eparser to respond to the public API of the classic parser
-# and makes use of the new evaluator.
-#
-class E4ParserAdapter
-
-  def initialize
-    @file = ''
-    @string = ''
-    @use = :unspecified
-  end
-
-  def file=(file)
-    @file = file
-    @use = :file
-  end
-
-  def parse(string = nil)
-    self.string= string if string
-    parser = Pops::Parser::EvaluatingParser.singleton
-    model =
-    if @use == :string
-      # Parse with a source_file to set in created AST objects (it was either given, or it may be unknown
-      # if caller did not set a file and the present a string.
-      #
-      parser.parse_string(@string, @file || "unknown-source-location")
-    else
-      parser.parse_file(@file)
-    end
-
-    # the parse_result may be
-    # * empty / nil (no input)
-    # * a Model::Program
-    # * a Model::Expression
-    #
-    args = {}
-    Pops::Model::AstTransformer.new(@file).merge_location(args, model)
-
-    ast_code =
-    if model.is_a? Pops::Model::Program
-      AST::PopsBridge::Program.new(model, args)
-    else
-      args[:value] = model
-      AST::PopsBridge::Expression.new(args)
-    end
-
-    # Create the "main" class for the content - this content will get merged with all other "main" content
-    AST::Hostclass.new('', :code => ast_code)
-  end
-
-  def string=(string)
-    @string = string
-    @use = :string
-  end
-end
-end
-end

data/vendored/puppet/lib/puppet/parser/environment_compiler.rb

@@ -1,199 +0,0 @@
-require 'puppet/parser/compiler'
-
-class Puppet::Parser::EnvironmentCompiler < Puppet::Parser::Compiler
-  def self.compile(env, code_id=nil)
-    begin
-      env.check_for_reparse
-
-      node = Puppet::Node.new(env)
-      node.environment = env
-      new(node, :code_id => code_id).compile
-    rescue => detail
-      message = _("%{detail} in environment %{env}") % { detail: detail, env: env.name }
-      Puppet.log_exception(detail, message)
-      raise Puppet::Error, message, detail.backtrace
-    end
-  end
-
-  def initialize(node, options = {})
-    super
-    @overridden_functions = {}
-  end
-
-  def add_function_overrides
-    add_function_override('hiera_include', proc { Puppet.debug "Ignoring hiera_include() during environment catalog compilation" })
-  end
-
-  def add_function_override(func_name, override)
-    typed_name = Puppet::Pops::Loader::TypedName.new(:function, func_name)
-    loader = loaders.puppet_system_loader
-
-    # Remove and preserve existing entry. A `nil` is also preserved to indicate
-    # an override that didn't replace a loaded function.
-    entry = loader.get_entry(typed_name)
-    existing = entry.nil? ? nil : entry.value
-    loader.remove_entry(typed_name) unless existing.nil?
-    @overridden_functions[typed_name] = existing
-
-    # Add the override to the loader
-    loader.set_entry(typed_name, override)
-  end
-
-  def remove_function_overrides
-    loader = loaders.puppet_system_loader
-    @overridden_functions.each_pair do |typed_name, overridden|
-      loader.remove_entry(typed_name)
-      loader.set_entry(typed_name, overridden) unless overridden.nil?
-    end
-  end
-
-  def add_catalog_validators
-    super
-    add_catalog_validator(CatalogValidator::SiteValidator)
-    add_catalog_validator(CatalogValidator::EnvironmentRelationshipValidator)
-  end
-
-  def compile
-    add_function_overrides
-    begin
-      Puppet.override(@context_overrides, _("For compiling environment catalog %{env}") % { env: environment.name }) do
-        @catalog.environment_instance = environment
-
-        Puppet::Util::Profiler.profile(_("Env Compile: Created settings scope"), [:compiler, :create_settings_scope]) { create_settings_scope }
-
-        Puppet::Util::Profiler.profile(_("Env Compile: Evaluated main"), [:compiler, :evaluate_main]) { evaluate_main }
-
-        Puppet::Util::Profiler.profile(_("Env Compile: Evaluated site"), [:compiler, :evaluate_site]) { evaluate_site }
-
-        Puppet::Util::Profiler.profile(_("Env Compile: Evaluated application instances"), [:compiler, :evaluate_applications]) { evaluate_applications }
-
-        Puppet::Util::Profiler.profile(_("Env Compile: Prune"), [:compiler, :prune_catalog]) { prune_catalog }
-
-        Puppet::Util::Profiler.profile(_("Env Compile: Validate Catalog pre-finish"), [:compiler, :validate_pre_finish]) do
-          validate_catalog(CatalogValidator::PRE_FINISH)
-        end
-
-        Puppet::Util::Profiler.profile(_("Env Compile: Finished catalog"), [:compiler, :finish_catalog]) { finish }
-
-        fail_on_unevaluated
-
-        Puppet::Util::Profiler.profile(_("Env Compile: Validate Catalog final"), [:compiler, :validate_final]) do
-          validate_catalog(CatalogValidator::FINAL)
-        end
-
-        if block_given?
-          yield @catalog
-        else
-          @catalog
-        end
-      end
-    ensure
-      remove_function_overrides
-    end
-  end
-
-  # @api private
-  def prune_catalog
-    prune_env_catalog
-  end
-
-  # Prunes the catalog by dropping all resources that are not contained under the Site (if a site expression is used).
-  # As a consequence all edges to/from dropped resources are also dropped.
-  # Once the pruning is performed, this compiler returns the pruned list when calling the #resources method.
-  # The pruning does not alter the order of resources in the resources list.
-  #
-  def prune_env_catalog
-    # Everything under Class[main], that is not under (inclusive of) Site[site] should be pruned as those resources
-    # are intended for nodes in a node catalog.
-    #
-    the_main_class_resource = @catalog.resource('Class', '')
-    the_site_resource = @catalog.resource('Site', 'site')
-
-    # Get downstream vertexes returns a hash where the keys are the resources and values nesting level
-    rooted_in_main = @catalog.downstream_from_vertex(the_main_class_resource).keys
-
-    to_be_removed =
-    if the_site_resource
-      keep_from_site = @catalog.downstream_from_vertex(the_site_resource).keys
-      keep_from_site << the_site_resource
-      rooted_in_main - keep_from_site
-    else
-      rooted_in_main
-    end
-
-    @catalog.remove_resource(*to_be_removed)
-    # The compiler keeps a list of added resources, this shadows that list with the now pruned result
-    @pruned_resources = @catalog.resources
-  end
-
-  def add_resource(scope, resource)
-    @resources << resource
-    @catalog.add_resource(resource)
-
-    if !resource.class? && resource[:stage]
-      raise ArgumentError, _("Only classes can set 'stage'; normal resources like %{resource} cannot change run stage") % { resource: resource }
-    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.stage?
-
-    # This adds a resource to the class it lexically appears in in the
-    # manifest.
-    unless resource.class?
-      @catalog.add_edge(scope.resource, resource)
-    end
-    resource.mark_unevaluated_consumer if is_capability_consumer?(resource)
-    assert_app_in_site(scope, resource)
-  end
-
-  def evaluate_ast_node()
-    # Do nothing, the environment catalog is not built for a particular node.
-  end
-
-  def on_empty_site
-    Puppet.warning(_("Environment Compiler: Could not find a site definition to evaluate"))
-  end
-
-  def evaluate_applications
-    exceptwrap do
-      resources.select { |resource| type = resource.resource_type; type.is_a?(Puppet::Resource::Type) && type.application? }.each do |resource|
-        Puppet::Util::Profiler.profile(_("Evaluated application %{resource}") % { resource: resource }, [:compiler, :evaluate_resource, resource]) do
-          resource.evaluate
-        end
-      end
-    end
-  end
-
-  def evaluate_classes(titles, scope, lazy)
-    # Always lazy in an Environment compilation
-    super(titles, scope, true)
-  end
-
-  # Overrides the regular compiler to be able to return the list of resources after a prune
-  # has taken place in the graph representation. Before a prune, the list is the same as in the regular
-  # compiler
-  #
-  def resources
-    @pruned_resources || super
-  end
-
-  def is_capability?(value)
-    if value.is_a?(Array)
-      value.find { |ev| is_capability?(ev) }
-    elsif value.is_a?(Puppet::Resource)
-      rstype = value.resource_type
-      rstype.nil? ? false : rstype.is_capability?
-    else
-      false
-    end
-  end
-  private :is_capability?
-
-  def is_capability_consumer?(resource)
-    resource.eachparam { |param| return true if (param.name == :consume || param.name == :require) && is_capability?(param.value) }
-    false
-  end
-  private :is_capability_consumer?
-end

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

@@ -1,92 +0,0 @@
-module Puppet::Parser::Files
-
-  module_function
-
-  # Return a list of manifests as absolute filenames matching the given
-  # pattern.
-  #
-  # @param pattern [String] A reference for a file in a module. It is the
-  #   format "<modulename>/<file glob>"
-  # @param environment [Puppet::Node::Environment] the environment of modules
-  #
-  # @return [Array(String, Array<String>)] the module name and the list of files found
-  # @api private
-  def find_manifests_in_modules(pattern, environment)
-    module_name, file_pattern = split_file_path(pattern)
-
-    if mod = environment.module(module_name)
-      [mod.name, mod.match_manifests(file_pattern)]
-    else
-      [nil, []]
-    end
-  end
-
-  # Find the path to the given file selector. Files can be selected in
-  # one of two ways:
-  #   * absolute path: the path is simply returned
-  #   * modulename/filename selector: a file is found in the file directory
-  #     of the named module.
-  #
-  # In the second case a nil is returned if there isn't a file found. In the
-  # first case (absolute path), there is no existence check done and so the
-  # path will be returned even if there isn't a file available.
-  #
-  # @param template [String] the file selector
-  # @param environment [Puppet::Node::Environment] the environment in which to search
-  # @return [String, nil] the absolute path to the file or nil if there is no file found
-  #
-  # @api private
-  def find_file(file, environment)
-    find_in_module(file, environment) do |mod,module_file|
-      mod.file(module_file)
-    end
-  end
-
-  # Find the path to the given template selector. Templates can be selected in
-  # a couple of ways:
-  #   * absolute path: the path is simply returned
-  #   * modulename/filename selector: a file is found in the template directory
-  #     of the named module.
-  #
-  # In the last two cases a nil is returned if there isn't a file found. In the
-  # first case (absolute path), there is no existence check done and so the
-  # path will be returned even if there isn't a file available.
-  #
-  # @param template [String] the template selector
-  # @param environment [Puppet::Node::Environment] the environment in which to search
-  # @return [String, nil] the absolute path to the template file or nil if there is no file found
-  #
-  # @api private
-  def find_template(template, environment)
-    find_in_module(template, environment) do |mod,template_file|
-      mod.template(template_file)
-    end
-  end
-
-  # @api private
-  def find_in_module(reference, environment)
-    if Puppet::Util.absolute_path?(reference)
-      reference
-    else
-      path, file = split_file_path(reference)
-      mod = environment.module(path)
-
-      if file && mod
-        yield(mod, file)
-      else
-        nil
-      end
-    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 /).
-  # @api private
-  def split_file_path(path)
-    if path == "" || Puppet::Util.absolute_path?(path)
-      nil
-    else
-      path.split(File::SEPARATOR, 2)
-    end
-  end
-end