bolt 0.0.1 → 0.5.0

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

@@ -0,0 +1,33 @@
+# 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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,199 @@
+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

@@ -0,0 +1,92 @@
+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