puppet 4.0.0 → 4.9.1

data/lib/puppet/parameter.rb

@@ -295,6 +295,10 @@ class Puppet::Parameter
   #
   attr_accessor :parent
 
+  # @!attribute [rw] sensitive
+  #   @return [true, false] If this parameter has been tagged as sensitive.
+  attr_accessor :sensitive
+
   # Returns a string representation of the resource's containment path in
   # the catalog.
   # @return [String]
@@ -376,7 +380,7 @@ class Puppet::Parameter
     tmp
   end
 
-  # Returns an array of strings representing the containment heirarchy
+  # Returns an array of strings representing the containment hierarchy
   # (types/classes) that make up the path to the resource from the root
   # of the catalog.  This is mostly used for logging purposes.
   #
@@ -479,7 +483,7 @@ class Puppet::Parameter
   #   calls both validate and munge on the given value, so no late binding.
   #
   # The given value is validated and then munged (if munging has been specified). The result is store
-  # as the value of this arameter.
+  # as the value of this parameter.
   # @return [Object] The given `value` after munging.
   # @raise (see #validate)
   #
@@ -501,7 +505,7 @@ class Puppet::Parameter
 
   # @return [Array<Symbol>] Returns an array of the associated resource's symbolic tags (including the parameter itself).
   # Returns an array of the associated resource's symbolic tags (including the parameter itself).
-  # At a minimun, the array contains the name of the parameter. If the associated resource
+  # At a minimum, the array contains the name of the parameter. If the associated resource
   # has tags, these tags are also included in the array.
   # @todo The original comment says = _"The properties need to return tags so that logs correctly
   #   collect them."_ what if anything of that is of interest to document. Should tags and their relationship
@@ -522,6 +526,22 @@ class Puppet::Parameter
     name.to_s
   end
 
+  # Formats the given string and conditionally redacts the provided interpolation variables, depending on if
+  # this property is sensitive.
+  #
+  # @note Because the default implementation of Puppet::Property#is_to_s returns the current value as-is, it
+  #   doesn't necessarily return a string. For the sake of sanity we just cast everything to a string for
+  #   interpolation so we don't introduce issues with unexpected property values.
+  #
+  # @see String#format
+  # @param fmt [String] The format string to interpolate.
+  # @param args [Array<String>] One or more strings to conditionally redact and interpolate into the format string.
+  #
+  # @return [String]
+  def format(fmt, *args)
+    fmt % args.map { |arg| @sensitive ? "[redacted]" : arg.to_s }
+  end
+
   # Produces a String with the value formatted for display to a human.
   # When the parameter value is a:
   #

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

@@ -23,6 +23,11 @@ class Puppet::Parser::AST::PopsBridge
       Puppet::Pops::Model::ModelTreeDumper.new.dump(@value)
     end
 
+    def source_text
+      source_adapter = Puppet::Pops::Utils.find_closest_positioned(@value)
+      source_adapter ? source_adapter.extract_text() : nil
+    end
+
     def evaluate(scope)
       object = @@evaluator.evaluate(scope, @value)
       @@evaluator.convert_to_3x(object, scope)
@@ -56,6 +61,19 @@ class Puppet::Parser::AST::PopsBridge
     end
   end
 
+  class ExpressionSupportingReturn < Expression
+    def initialize args
+      super
+    end
+
+    def evaluate(scope)
+      return catch(:return) do
+        return catch(:next) do
+          return super(scope)
+        end
+      end
+    end
+  end
   # Bridges the top level "Program" produced by the pops parser.
   # Its main purpose is to give one point where all definitions are instantiated (actually defined since the
   # Puppet 3x terminology is somewhat misleading - the definitions are instantiated, but instances of the created types
@@ -83,8 +101,26 @@ class Puppet::Parser::AST::PopsBridge
           instantiate_HostClassDefinition(d, modname)
         when Puppet::Pops::Model::ResourceTypeDefinition
           instantiate_ResourceTypeDefinition(d, modname)
+        when Puppet::Pops::Model::CapabilityMapping
+          instantiate_CapabilityMapping(d, modname)
         when Puppet::Pops::Model::NodeDefinition
           instantiate_NodeDefinition(d, modname)
+        when Puppet::Pops::Model::SiteDefinition
+            instantiate_SiteDefinition(d, modname)
+        when Puppet::Pops::Model::FunctionDefinition
+          # The 3x logic calling this will not know what to do with the result, it is compacted away at the end
+          instantiate_FunctionDefinition(d, modname)
+          next
+        when Puppet::Pops::Model::TypeAlias
+          # The 3x logic calling this will not know what to do with the result, it is compacted away at the end
+          instantiate_TypeAlias(d, modname)
+          next
+        when Puppet::Pops::Model::TypeMapping
+          # The 3x logic calling this will not know what to do with the result, it is compacted away at the end
+          instantiate_TypeMapping(d, modname)
+          next
+        when Puppet::Pops::Model::Application
+          instantiate_ApplicationDefinition(d, modname)
         else
           raise Puppet::ParseError, "Internal Error: Unknown type of definition - got '#{d.class}'"
         end
@@ -151,26 +187,49 @@ class Puppet::Parser::AST::PopsBridge
     end
 
     # Produces a hash with data for Definition and HostClass
-    def args_from_definition(o, modname)
+    def args_from_definition(o, modname, expr_class = Expression)
       args = {
        :arguments => o.parameters.collect {|p| instantiate_Parameter(p) },
        :argument_types => create_type_map(o),
        :module_name => modname
       }
       unless is_nop?(o.body)
-        args[:code] = Expression.new(:value => o.body)
+        args[:code] = expr_class.new(:value => o.body)
       end
       @ast_transformer.merge_location(args, o)
     end
 
     def instantiate_HostClassDefinition(o, modname)
-      args = args_from_definition(o, modname)
+      args = args_from_definition(o, modname, ExpressionSupportingReturn)
       args[:parent] = absolute_reference(o.parent_class)
       Puppet::Resource::Type.new(:hostclass, o.name, @context.merge(args))
     end
 
     def instantiate_ResourceTypeDefinition(o, modname)
-      Puppet::Resource::Type.new(:definition, o.name, @context.merge(args_from_definition(o, modname)))
+      instance = Puppet::Resource::Type.new(:definition, o.name, @context.merge(args_from_definition(o, modname, ExpressionSupportingReturn)))
+      Puppet::Pops::Loaders.register_runtime3_type(instance.name, Puppet::Pops::Adapters::SourcePosAdapter.adapt(o).to_uri)
+      instance
+    end
+
+    def instantiate_CapabilityMapping(o, modname)
+      # Use an intermediate 'capability_mapping' type to pass this info to the compiler where the
+      # actual mapping takes place
+      Puppet::Resource::Type.new(:capability_mapping, "#{o.component} #{o.kind} #{o.capability}", { :arguments => {
+        'component'     => o.component,
+        'kind'          => o.kind,
+        'blueprint'     => {
+          :capability => o.capability,
+          :mappings   => o.mappings.reduce({}) do |memo, mapping|
+            memo[mapping.attribute_name] =
+              Expression.new(:value => mapping.value_expr)
+            memo
+          end
+      }}})
+    end
+
+    def instantiate_ApplicationDefinition(o, modname)
+      args = args_from_definition(o, modname)
+      Puppet::Resource::Type.new(:application, o.name, @context.merge(args))
     end
 
     def instantiate_NodeDefinition(o, modname)
@@ -183,47 +242,62 @@ class Puppet::Parser::AST::PopsBridge
       unless is_nop?(o.parent)
         args[:parent] = @ast_transformer.hostname(o.parent)
       end
+      args = @ast_transformer.merge_location(args, o)
 
       host_matches = @ast_transformer.hostname(o.host_matches)
-      @ast_transformer.merge_location(args, o)
       host_matches.collect do |name|
         Puppet::Resource::Type.new(:node, name, @context.merge(args))
       end
     end
 
+    def instantiate_SiteDefinition(o, modname)
+      args = { :module_name => modname }
+
+      unless is_nop?(o.body)
+        args[:code] = Expression.new(:value => o.body)
+      end
+
+      args = @ast_transformer.merge_location(args, o)
+      Puppet::Resource::Type.new(:site, 'site', @context.merge(args))
+    end
+
     # Propagates a found Function to the appropriate loader.
     # This is for 4x evaluator/loader
     #
     def instantiate_FunctionDefinition(function_definition, modname)
-      loaders = (Puppet.lookup(:loaders) { nil })
-      unless loaders
-        raise Puppet::ParseError, "Internal Error: Puppet Context ':loaders' missing - cannot define any functions"
-      end
-      loader =
-      if modname.nil? || modname == ""
-        # TODO : Later when functions can be private, a decision is needed regarding what that means.
-        #        A private environment loader could be used for logic outside of modules, then only that logic
-        #        would see the function.
-        #
-        # Use the private loader, this function may see the environment's dependencies (currently, all modules)
-        loaders.private_environment_loader()
-      else
-        # TODO : Later check if function is private, and then add it to
-        #        private_loader_for_module
-        #
-        loaders.public_loader_for_module(modname)
-      end
-      unless loader
-        raise Puppet::ParseError, "Internal Error: did not find public loader for module: '#{modname}'"
-      end
+      loader = Puppet::Pops::Loaders.find_loader(modname)
 
-      # Instantiate Function, and store it in the environment loader
+      # Instantiate Function, and store it in the loader
       typed_name, f = Puppet::Pops::Loader::PuppetFunctionInstantiator.create_from_model(function_definition, loader)
       loader.set_entry(typed_name, f, Puppet::Pops::Adapters::SourcePosAdapter.adapt(function_definition).to_uri)
 
       nil # do not want the function to inadvertently leak into 3x
     end
 
+    # Propagates a found TypeAlias to the appropriate loader.
+    # This is for 4x evaluator/loader
+    #
+    def instantiate_TypeAlias(type_alias, modname)
+      loader = Puppet::Pops::Loaders.find_loader(modname)
+
+      # Bind the type alias to the loader using the alias
+      Puppet::Pops::Loader::TypeDefinitionInstantiator.create_from_model(type_alias, loader)
+
+      nil # do not want the type alias to inadvertently leak into 3x
+    end
+
+    # Adds the TypeMapping to the ImplementationRegistry
+    # This is for 4x evaluator/loader
+    #
+    def instantiate_TypeMapping(type_mapping, modname)
+      loader = Puppet::Pops::Loaders.find_loader(modname)
+      tf = Puppet::Pops::Types::TypeParser.singleton
+      lhs = tf.interpret(type_mapping.type_expr, loader)
+      rhs = tf.interpret_any(type_mapping.mapping_expr, loader)
+      Puppet::Pops::Loaders.implementation_registry.register_type_mapping(lhs, rhs, loader)
+      nil
+    end
+
     def code()
       Expression.new(:value => @value)
     end

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

@@ -5,6 +5,11 @@ class Puppet::Parser::AST::Resource < Puppet::Parser::AST::Branch
 
   attr_accessor :type, :instances, :exported, :virtual
 
+  def initialize(argshash)
+    Puppet.warn_once('deprecation', 'AST::Resource', 'Use of Puppet::Parser::AST::Resource is deprecated and not fully functional')
+    super(argshash)
+  end
+
   # Evaluates resources by adding them to the compiler for lazy evaluation
   # and returning the produced resource references.
   #

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

@@ -2,5 +2,9 @@
 # title and a set of parameters.
 #
 class Puppet::Parser::AST::ResourceInstance < Puppet::Parser::AST::Branch
-    attr_accessor :title, :parameters
+  attr_accessor :title, :parameters
+  def initialize(argshash)
+    Puppet.warn_once('deprecation', 'AST::ResourceInstance', 'Use of Puppet::Parser::AST::ResourceInstance is deprecated')
+    super(argshash)
+  end
 end

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

@@ -3,6 +3,11 @@
 class Puppet::Parser::AST::ResourceParam < Puppet::Parser::AST::Branch
   attr_accessor :value, :param, :add
 
+  def initialize(argshash)
+    Puppet.warn_once('deprecation', 'AST::ResourceParam', 'Use of Puppet::Parser::AST::ResourceParam is deprecated and not fully functional')
+    super(argshash)
+  end
+
   def each
     [@param, @value].each { |child| yield child }
   end

data/lib/puppet/parser/ast.rb

@@ -29,6 +29,11 @@ class Puppet::Parser::AST
     # is called so many times during parsing.
     begin
       return self.evaluate(scope)
+    rescue Puppet::Pops::Evaluator::PuppetStopIteration => detail
+      raise detail
+#      # Only deals with StopIteration from the break() function as a general
+#      # StopIteration is a general runtime problem
+#      raise Puppet::ParseError.new(detail.message, detail.file, detail.line, detail)
     rescue Puppet::Error => detail
       raise adderrorcontext(detail)
     rescue => detail

data/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.name}' is never exported", 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[title_key]}' and '#{resource}'", param.file, param.line)
+          else
+            hash[title_key] = resource
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+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)
+        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.name}' is not a valid relationship to a capability", 
+              param.file, param.line)
+        end
+      elsif Puppet[:strict] != :off
+        # all other relationships requires the referenced resource to exist when mode is strict
+        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 '#{r.to_s}' in parameter '#{param.name.to_s}'"
+            if Puppet[:strict] == :error
+              raise CatalogValidationError.new(msg, param.file, param.line)
+            else
+              Puppet.warn_once(:undefined_resources, r.to_s, msg, param.file, param.line)
+            end
+          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/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 - #{r} is not allowed", r.file, r.line)
+        end
+      end
+    end
+  end
+end
+

data/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