puppet 3.5.1-x86-mingw32 → 3.6.0.rc1-x86-mingw32

data/lib/puppet/pops/loader/null_loader.rb

@@ -0,0 +1,44 @@
+# The null loader is empty and delegates everything to its parent if it has one.
+#
+class Puppet::Pops::Loader::NullLoader < Puppet::Pops::Loader::Loader
+  attr_reader :loader_name
+
+  # Construct a NullLoader, optionally with a parent loader
+  #
+  def initialize(parent_loader=nil, loader_name = "null-loader")
+    @loader_name = loader_name
+    @parent = parent_loader
+  end
+
+  # Has parent if one was set when constructed
+  def parent
+    @parent
+  end
+
+  def load_typed(typed_name)
+    if @parent.nil?
+      nil
+    else
+      @parent.load_typed(typed_name)
+    end
+  end
+
+  # Has no entries on its own - always nil
+  def get_entry(typed_name)
+    nil
+  end
+
+  # Finds nothing, there are no entries
+  def find(name)
+    nil
+  end
+
+  # Cannot store anything
+  def set_entry(typed_name, value, origin = nil)
+    nil
+  end
+
+  def to_s()
+    "(NullLoader '#{loader_name}')"
+  end
+end

data/lib/puppet/pops/loader/ruby_function_instantiator.rb

@@ -0,0 +1,34 @@
+# The RubyFunctionInstantiator instantiates a Puppet::Functions::Function given the ruby source
+# that calls Puppet::Functions.create_function.
+#
+class Puppet::Pops::Loader::RubyFunctionInstantiator
+  # Produces an instance of the Function class with the given typed_name, or fails with an error if the
+  # given ruby source does not produce this instance when evaluated.
+  #
+  # @param loader [Puppet::Pops::Loader::Loader] The loader the function is associated with
+  # @param typed_name [Puppet::Pops::Loader::TypedName] the type / name of the function to load
+  # @param source_ref [URI, String] a reference to the source / origin of the ruby code to evaluate
+  # @param ruby_code_string [String] ruby code in a string
+  #
+  # @return [Puppet::Pops::Functions.Function] - an instantiated function with global scope closure associated with the given loader
+  #
+  def self.create(loader, typed_name, source_ref, ruby_code_string)
+    unless ruby_code_string.is_a?(String) && ruby_code_string =~ /Puppet\:\:Functions\.create_function/
+      raise ArgumentError, "The code loaded from #{source_ref} does not seem to be a Puppet 4x API function - no create_function call."
+    end
+    created = eval(ruby_code_string)
+    unless created.is_a?(Class)
+      raise ArgumentError, "The code loaded from #{source_ref} did not produce a Function class when evaluated. Got '#{created.class}'"
+    end
+    unless created.name.to_s == typed_name.name()
+      raise ArgumentError, "The code loaded from #{source_ref} produced mis-matched name, expected '#{typed_name.name}', got #{created.name}"
+    end
+    # create the function instance - it needs closure (scope), and loader (i.e. where it should start searching for things
+    # when calling functions etc.
+    # It should be bound to global scope
+
+    # TODO: Cheating wrt. scope - assuming it is found in the context
+    closure_scope = Puppet.lookup(:global_scope) { {} }
+    created.new(closure_scope, loader.private_loader)
+  end
+end

data/lib/puppet/pops/loader/ruby_legacy_function_instantiator.rb

@@ -0,0 +1,109 @@
+# The RubyLegacyFunctionInstantiator loads a 3x function and turns it into a 4x function
+# that is called with 3x semantics (values are transformed to be 3x compliant).
+#
+# The code is loaded from a string obtained by reading the 3x function ruby code into a string
+# and then passing it to the loaders class method `create`. When Puppet[:biff] == true, the
+# 3x Puppet::Parser::Function.newfunction method relays back to this function loader's
+# class method legacy_newfunction which creates a Puppet::Functions class wrapping the 
+# 3x function's block into a method in a function class derived from Puppet::Function.
+# This class is then returned, and the Legacy loader continues the same way as it does
+# for a 4x function.
+#
+# TODO: Wrapping of Scope
+#   The 3x function expects itself to be Scope. It passes itself as scope to other parts of the runtime,
+#   it expects to find all sorts of information in itself, get/set variables, get compiler, get environment
+#   etc.
+# TODO: Transformation of arguments to 3x compliant objects
+#
+class Puppet::Pops::Loader::RubyLegacyFunctionInstantiator
+
+  # Produces an instance of the Function class with the given typed_name, or fails with an error if the
+  # given ruby source does not produce this instance when evaluated.
+  #
+  # @param loader [Puppet::Pops::Loader::Loader] The loader the function is associated with
+  # @param typed_name [Puppet::Pops::Loader::TypedName] the type / name of the function to load
+  # @param source_ref [URI, String] a reference to the source / origin of the ruby code to evaluate
+  # @param ruby_code_string [String] ruby code in a string
+  #
+  # @return [Puppet::Pops::Functions.Function] - an instantiated function with global scope closure associated with the given loader
+  #
+  def self.create(loader, typed_name, source_ref, ruby_code_string)
+    # Old Ruby API supports calling a method via ::
+    # this must also be checked as well as call with '.'
+    #
+    unless ruby_code_string.is_a?(String) && ruby_code_string =~ /Puppet\:\:Parser\:\:Functions(?:\.|\:\:)newfunction/
+      raise ArgumentError, "The code loaded from #{source_ref} does not seem to be a Puppet 3x API function - no newfunction call."
+    end
+
+    # The evaluation of the 3x function creation source should result in a call to the legacy_newfunction
+    #
+    created = eval(ruby_code_string)
+    unless created.is_a?(Class)
+      raise ArgumentError, "The code loaded from #{source_ref} did not produce a Function class when evaluated. Got '#{created.class}'"
+    end
+    unless created.name.to_s == typed_name.name()
+      raise ArgumentError, "The code loaded from #{source_ref} produced mis-matched name, expected '#{typed_name.name}', got #{created.name}"
+    end
+    # create the function instance - it needs closure (scope), and loader (i.e. where it should start searching for things
+    # when calling functions etc.
+    # It should be bound to global scope
+
+    # TODO: Cheating wrt. scope - assuming it is found in the context
+    closure_scope = Puppet.lookup(:global_scope) { {} }
+    created.new(closure_scope, loader)
+  end
+
+  # This is a new implementation of the method that is used in 3x to create a function.
+  # The arguments are the same as those passed to Puppet::Parser::Functions.newfunction, hence its
+  # deviation from regular method naming practice.
+  #
+  def self.legacy_newfunction(name, options, &block)
+
+    # 3x api allows arity to be specified, if unspecified it is 0 or more arguments
+    # arity >= 0, is an exact count
+    # airty < 0 is the number of required arguments -1 (i.e. -1 is 0 or more)
+    # (there is no upper cap, there is no support for optional values, or defaults)
+    #
+    arity = options[:arity] || -1
+    if arity >= 0
+      min_arg_count = arity
+      max_arg_count = arity
+    else
+      min_arg_count = (arity + 1).abs
+      # infinity
+      max_arg_count = :default
+    end
+
+    # Create a 4x function wrapper around the 3x Function
+    created_function_class = Puppet::Functions.create_function(name) do
+      # define a method on the new Function class with the same name as the function, but
+      # padded with __ because the function may represent a ruby method with the same name that
+      # expects to have inherited from Kernel, and then Object.
+      # (This can otherwise lead to infinite recursion, or that an ArgumentError is raised).
+      #
+      __name__ = :"__#{name}__"
+      define_method(__name__, &block)
+
+      # Define the method that is called from dispatch - this method just changes a call
+      # with multiple unknown arguments to passing all in an array (since this is expected in the 3x API).
+      # We want the call to be checked for type and number of arguments so cannot call the function
+      # defined by the block directly since it is defined to take a single argument.
+      #
+      define_method(:__relay__call__) do |*args|
+        # dup the args since the function may destroy them
+        # TODO: Should convert arguments to 3x, now :undef is send to the function
+        send(__name__, args.dup)
+      end
+
+      # Define a dispatch that performs argument type/count checking
+      #
+      dispatch :__relay__call__ do
+        # Use Puppet Type Object (not Optional[Object] since the 3x API passes undef as empty string).
+        param 'Object', 'args'
+        # Specify arg count (transformed from 3x function arity specification).
+        arg_count(min_arg_count, max_arg_count)
+      end
+    end
+    created_function_class
+  end
+end

data/lib/puppet/pops/loader/simple_environment_loader.rb

@@ -0,0 +1,20 @@
+# SimpleEnvironmentLoader
+# ===
+# This loader does not load anything and it is populated by the bootstrapping logic that loads
+# the site.pp or equivalent for an environment. It does not restrict the names of what it may contain,
+# and what is loaded here overrides any child loaders (modules).
+#
+class Puppet::Pops::Loader::SimpleEnvironmentLoader < Puppet::Pops::Loader::BaseLoader
+
+  attr_accessor :private_loader
+
+  # Never finds anything, everything "loaded" is set externally
+  def find(typed_name)
+    nil
+  end
+
+  def to_s()
+    "(SimpleEnvironmentLoader '#{loader_name}')"
+  end
+
+end

data/lib/puppet/pops/loader/static_loader.rb

@@ -0,0 +1,69 @@
+  # Static Loader contains constants, basic data types and other types required for the system
+  # to boot.
+  #
+class Puppet::Pops::Loader::StaticLoader < Puppet::Pops::Loader::Loader
+
+  attr_reader :loaded
+  def initialize
+    @loaded = {}
+    create_logging_functions()
+  end
+
+  def load_typed(typed_name)
+    load_constant(typed_name)
+  end
+
+  def get_entry(typed_name)
+    load_constant(typed_name)
+  end
+
+  def find(name)
+    # There is nothing to search for, everything this loader knows about is already available
+    nil
+  end
+
+  def parent
+    nil # at top of the hierarchy
+  end
+
+  def to_s()
+    "(StaticLoader)"
+  end
+  private
+
+  def load_constant(typed_name)
+    @loaded[typed_name]
+  end
+
+  private
+
+  # Creates a function for each of the specified log levels
+  #
+  def create_logging_functions()
+    Puppet::Util::Log.levels.each do |level|
+
+      fc = Puppet::Functions.create_function(level) do
+        # create empty dispatcher to stop it from complaining about missing method since
+        # an override of :call is made instead of using dispatch.
+        dispatch(:log) { }
+
+        # Logs per the specified level, outputs formatted information for arrays, hashes etc.
+        # Overrides the implementation in Function that uses dispatching. This is not needed here
+        # since it accepts 0-n Optional[Object]
+        #
+        define_method(:call) do |scope, *vals|
+          # NOTE: 3x, does this: vals.join(" ")
+          # New implementation uses the evaluator to get proper formatting per type
+          # TODO: uses a fake scope (nil) - fix when :scopes are available via settings
+          mapped = vals.map {|v| Puppet::Pops::Evaluator::EvaluatorImpl.new.string(v, nil) }
+          Puppet.send(level, mapped.join(" "))
+        end
+      end
+
+      typed_name = Puppet::Pops::Loader::Loader::TypedName.new(:function, level)
+      # TODO:closure scope is fake (an empty hash) - waiting for new global scope to be available via lookup of :scopes
+      func = fc.new({},self)
+      @loaded[ typed_name ] = Puppet::Pops::Loader::Loader::NamedEntry.new(typed_name, func, __FILE__)
+    end
+  end
+end

data/lib/puppet/pops/loader/uri_helper.rb

@@ -0,0 +1,22 @@
+module Puppet::Pops::Loader::UriHelper
+  # Raises an exception if specified gem can not be located
+  #
+  def path_for_uri(uri, subdir='lib')
+    case uri.scheme
+    when "gem"
+      begin
+        spec = Gem::Specification.find_by_name(uri.hostname)
+        # if path given append that, else append given subdir
+        File.join(spec.gem_dir, uri.path.empty?() ? subdir : uri.path)
+      rescue StandardError => e
+        raise "TODO TYPE: Failed to located gem #{uri}. #{e.message}"
+      end
+    when "file"
+      File.join(uri.path, subdir)
+    when nil
+      File.join(uri.path, subdir)
+    else
+      raise "Not a valid scheme for a loader: #{uri.scheme}. Use a 'file:' (or just a path), or 'gem://gemname[/path]"
+    end
+  end
+end

data/lib/puppet/pops/loaders.rb

@@ -0,0 +1,240 @@
+class Puppet::Pops::Loaders
+  class LoaderError < Puppet::Error; end
+
+  attr_reader :static_loader
+  attr_reader :puppet_system_loader
+  attr_reader :public_environment_loader
+  attr_reader :private_environment_loader
+
+  def initialize(environment)
+    # The static loader can only be changed after a reboot
+    @@static_loader ||= Puppet::Pops::Loader::StaticLoader.new()
+
+    # Create the set of loaders
+    # 1. Puppet, loads from the "running" puppet - i.e. bundled functions, types, extension points and extensions
+    #    Does not change without rebooting the service running puppet.
+    #
+    @@puppet_system_loader ||= create_puppet_system_loader()
+
+    # 2. Environment loader - i.e. what is bound across the environment, may change for each setup
+    #    TODO: loaders need to work when also running in an agent doing catalog application. There is no
+    #    concept of environment the same way as when running as a master (except when doing apply).
+    #    The creation mechanisms should probably differ between the two.
+    #
+    @private_environment_loader = create_environment_loader(environment)
+
+    # 3. module loaders are set up from the create_environment_loader, they register themselves
+  end
+
+  # Clears the cached static and puppet_system loaders (to enable testing)
+  #
+  def self.clear
+    @@static_loader = nil
+    @@puppet_system_loader = nil
+  end
+
+  def static_loader
+    @@static_loader
+  end
+
+  def puppet_system_loader
+    @@puppet_system_loader
+  end
+
+  def public_loader_for_module(module_name)
+    md = @module_resolver[module_name] || (return nil)
+    # Note, this loader is not resolved until there is interest in the visibility of entities from the
+    # perspective of something contained in the module. (Many request may pass through a module loader
+    # without it loading anything.
+    # See {#private_loader_for_module}, and not in {#configure_loaders_for_modules}
+    md.public_loader
+  end
+
+  def private_loader_for_module(module_name)
+    md = @module_resolver[module_name] || (return nil)
+    # Since there is interest in the visibility from the perspective of entities contained in the
+    # module, it must be resolved (to provide this visibility).
+    # See {#configure_loaders_for_modules}
+    unless md.resolved?
+      @module_resolver.resolve(md)
+    end
+    md.private_loader
+  end
+
+  private
+
+  def create_puppet_system_loader()
+    module_name = nil
+    loader_name = 'puppet_system'
+
+    # Puppet system may be installed in a fixed location via RPM, installed as a Gem, via source etc.
+    # The only way to find this across the different ways puppet can be installed is
+    # to search up the path from this source file's __FILE__ location until it finds the parent of
+    # lib/puppet... e.g.. dirname(__FILE__)/../../..  (i.e. <somewhere>/lib/puppet/pops/loaders.rb).
+    #
+    puppet_lib = File.join(File.dirname(__FILE__), '../../..')
+    Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, self, module_name, puppet_lib, loader_name)
+  end
+
+  def create_environment_loader(environment)
+    # This defines where to start parsing/evaluating - the "initial import" (to use 3x terminology)
+    # Is either a reference to a single .pp file, or a directory of manifests. If the environment becomes
+    # a module and can hold functions, types etc. then these are available across all other modules without
+    # them declaring this dependency - it is however valuable to be able to treat it the same way
+    # bindings and other such system related configuration.
+
+    # This is further complicated by the many options available:
+    # - The environment may not have a directory, the code comes from one appointed 'manifest' (site.pp)
+    # - The environment may have a directory and also point to a 'manifest'
+    # - The code to run may be set in settings (code)
+
+    # Further complication is that there is nothing specifying what the visibility is into
+    # available modules. (3x is everyone sees everything).
+    # Puppet binder currently reads confdir/bindings - that is bad, it should be using the new environment support.
+
+    # The environment is not a namespace, so give it a nil "module_name"
+    module_name = nil
+    loader_name = "environment:#{environment.name}"
+    loader = Puppet::Pops::Loader::SimpleEnvironmentLoader.new(puppet_system_loader, loader_name)
+
+    # An environment has a module path even if it has a null loader
+    configure_loaders_for_modules(loader, environment)
+    # modules should see this loader
+    @public_environment_loader = loader
+
+    # Code in the environment gets to see all modules (since there is no metadata for the environment)
+    # but since this is not given to the module loaders, they can not load global code (since they can not
+    # have prior knowledge about this
+    loader = Puppet::Pops::Loader::DependencyLoader.new(loader, "environment", @module_resolver.all_module_loaders())
+
+    # The module loader gets the private loader via a lazy operation to look up the module's private loader.
+    # This does not work for an environment since it is not resolved the same way.
+    # TODO: The EnvironmentLoader could be a specialized loader instead of using a ModuleLoader to do the work.
+    #       This is subject to future design - an Environment may move more in the direction of a Module.
+    @public_environment_loader.private_loader = loader
+    loader
+  end
+
+  def configure_loaders_for_modules(parent_loader, environment)
+    @module_resolver = mr = ModuleResolver.new()
+    environment.modules.each do |puppet_module|
+      # Create data about this module
+      md = LoaderModuleData.new(puppet_module)
+      mr[puppet_module.name] = md
+      md.public_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(parent_loader, self, md.name, md.path, md.name)
+    end
+    # NOTE: Do not resolve all modules here - this is wasteful if only a subset of modules / functions are used
+    #       The resolution is triggered by asking for a module's private loader, since this means there is interest
+    #       in the visibility from that perspective.
+    #       If later, it is wanted that all resolutions should be made up-front (to capture errors eagerly, this
+    #       can be introduced (better for production), but may be irritating in development mode.
+  end
+
+  # =LoaderModuleData
+  # Information about a Module and its loaders.
+  # TODO: should have reference to real model element containing all module data; this is faking it
+  # TODO: Should use Puppet::Module to get the metadata (as a hash) - a somewhat blunt instrument, but that is
+  #       what is available with a reasonable API.
+  #
+  class LoaderModuleData
+
+    attr_accessor :state
+    attr_accessor :public_loader
+    attr_accessor :private_loader
+    attr_accessor :resolutions
+
+    # The Puppet::Module this LoaderModuleData represents in the loader configuration
+    attr_reader :puppet_module
+
+    # @param puppet_module [Puppet::Module] the module instance for the module being represented
+    #
+    def initialize(puppet_module)
+      @state = :initial
+      @puppet_module = puppet_module
+      @resolutions = []
+      @public_loader = nil
+      @private_loader = nil
+    end
+
+    def name
+      @puppet_module.name
+    end
+
+    def version
+      @puppet_module.version
+    end
+
+    def path
+      @puppet_module.path
+    end
+
+    def resolved?
+      @state == :resolved
+    end
+
+    def restrict_to_dependencies?
+      @puppet_module.has_metadata?
+    end
+
+    def unmet_dependencies?
+      @puppet_module.unmet_dependencies.any?
+    end
+
+    def dependency_names
+      @puppet_module.dependencies_as_modules.collect(&:name)
+    end
+  end
+
+  # Resolves module loaders - resolution of model dependencies is done by Puppet::Module
+  #
+  class ModuleResolver
+
+    def initialize()
+      @index = {}
+      @all_module_loaders = nil
+    end
+
+    def [](name)
+      @index[name]
+    end
+
+    def []=(name, module_data)
+      @index[name] = module_data
+    end
+
+    def all_module_loaders
+      @all_module_loaders ||= @index.values.map {|md| md.public_loader }
+    end
+
+    def resolve(module_data)
+      if module_data.resolved?
+        return
+      else
+        module_data.private_loader =
+          if module_data.restrict_to_dependencies?
+            create_loader_with_only_dependencies_visible(module_data)
+          else
+            create_loader_with_all_modules_visible(module_data)
+          end
+      end
+    end
+
+    private
+
+    def create_loader_with_all_modules_visible(from_module_data)
+      Puppet.debug("ModuleLoader: module '#{from_module_data.name}' has unknown dependencies - it will have all other modules visible")
+
+      Puppet::Pops::Loader::DependencyLoader.new(from_module_data.public_loader, from_module_data.name, all_module_loaders())
+    end
+
+    def create_loader_with_only_dependencies_visible(from_module_data)
+      if from_module_data.unmet_dependencies?
+        Puppet.warning("ModuleLoader: module '#{from_module_data.name}' has unresolved dependencies"+
+          " - it will only see those that are resolved."+
+          " Use 'puppet module list --tree' to see information about modules")
+      end
+      dependency_loaders = from_module_data.dependency_names.collect { |name| @index[name].public_loader }
+      Puppet::Pops::Loader::DependencyLoader.new(from_module_data.public_loader, from_module_data.name, dependency_loaders)
+    end
+  end
+end