puppet 5.5.22 → 6.0.0

data/lib/puppet/indirector/terminus.rb

@@ -112,7 +112,7 @@ class Puppet::Indirector::Terminus
     # Return all terminus classes for a given indirection.
     def terminus_classes(indirection_name)
       setup_instance_loading indirection_name
-      instance_loader(indirection_name).files_to_load.map do |file|
+      instance_loader(indirection_name).files_to_load(Puppet.lookup(:current_environment)).map do |file|
         File.basename(file).chomp(".rb").intern
       end
     end

data/lib/puppet/indirector/yaml.rb

@@ -9,7 +9,7 @@ class Puppet::Indirector::Yaml < Puppet::Indirector::Terminus
     return nil unless Puppet::FileSystem.exist?(file)
 
     begin
-      return fix(Puppet::Util::Yaml.load_file(file))
+      return load_file(file)
     rescue Puppet::Util::Yaml::YamlLoadError => detail
       raise Puppet::Error, _("Could not parse YAML data for %{indirection} %{request}: %{detail}") % { indirection: indirection.name, request: request.key, detail: detail }, detail.backtrace
     end
@@ -51,13 +51,13 @@ class Puppet::Indirector::Yaml < Puppet::Indirector::Terminus
 
   def search(request)
     Dir.glob(path(request.key,'')).collect do |file|
-      fix(Puppet::Util::Yaml.load_file(file))
+      load_file(file)
     end
   end
 
   protected
 
-  def fix(object)
-    object
+  def load_file(file)
+    Puppet::Util::Yaml.safe_load_file(file, [model, Symbol])
   end
 end

data/lib/puppet/info_service/task_information_service.rb

@@ -23,10 +23,14 @@ class Puppet::InfoService::TaskInformationService
 
     task = pup_module.tasks.find { |t| t.name == task_name }
     if task.nil?
-      raise Puppet::Module::Task::TaskNotFound, _("Task %{task_name} not found in module %{module_name}.") %
-                                                 {task_name: task_name, module_name: module_name}
+      raise Puppet::Module::Task::TaskNotFound.new(task_name, module_name)
     end
 
-    {:metadata_file => task.metadata_file, :files => task.files}
+    begin
+      task.validate
+      {:metadata => task.metadata, :files => task.files}
+    rescue Puppet::Module::Task::Error => err
+      { :metadata => nil, :files => [], :error => err.to_h }
+    end
   end
 end

data/lib/puppet/interface.rb

@@ -96,7 +96,7 @@ class Puppet::Interface
         if Puppet::Interface::FaceCollection[name, :current]
           raise Puppet::Error, "Could not find version #{version} of #{name}"
         else
-          raise Puppet::Error, "Could not find Puppet Face #{name}"
+          raise Puppet::Error, "Could not find Puppet Face #{name.to_s}"
         end
       end
 
@@ -170,7 +170,7 @@ class Puppet::Interface
   # @return [void]
   # @api private
   def load_actions
-    loader.loadall
+    loader.loadall(Puppet.lookup(:current_environment))
   end
 
   # Returns a string representation with the face's name and version
@@ -234,5 +234,4 @@ class Puppet::Interface
     define_method(name, proc)
     instance_method(name)
   end
-  private_class_method :__add_method
 end

data/lib/puppet/interface/action.rb

@@ -1,4 +1,4 @@
-require 'puppet/util/methodhelper'
+# coding: utf-8
 require 'prettyprint'
 
 # This represents an action that is attached to a face. Actions should
@@ -7,12 +7,11 @@ require 'prettyprint'
 # {Puppet::Interface::ActionBuilder} in the supplied block.
 # @api private
 class Puppet::Interface::Action
-  include Puppet::Util::MethodHelper
   extend  Puppet::Interface::DocGen
   include Puppet::Interface::FullDocs
 
   # @api private
-  def initialize(face, name, attrs = {})
+  def initialize(face, name)
     raise "#{name.inspect} is an invalid action name" unless name.to_s =~ /^[a-z]\w*$/
     @face    = face
     @name    = name.to_sym
@@ -23,8 +22,6 @@ class Puppet::Interface::Action
     @authors = []
     @license  = 'All Rights Reserved'
 
-    set_options(attrs)
-
     # @options collects the added options in the order they're declared.
     # @options_hash collects the options keyed by alias for quick lookups.
     @options        = []

data/lib/puppet/interface/face_collection.rb

@@ -6,7 +6,9 @@ module Puppet::Interface::FaceCollection
   def self.faces
     unless @loaded
       @loaded = true
-      names = @loader.files_to_load.map {|fn| ::File.basename(fn, '.rb')}.uniq
+      names = @loader.files_to_load(Puppet.lookup(:current_environment)).map do |fn|
+        ::File.basename(fn, '.rb')
+      end.uniq
       names.each {|name| self[name, :current]}
     end
     @faces.keys.select {|name| @faces[name].length > 0 }

data/lib/puppet/loaders.rb

@@ -9,9 +9,11 @@ module Puppet
       require 'puppet/pops/loader/gem_support'
       require 'puppet/pops/loader/module_loaders'
       require 'puppet/pops/loader/dependency_loader'
+      require 'puppet/pops/loader/null_loader'
       require 'puppet/pops/loader/static_loader'
       require 'puppet/pops/loader/runtime3_type_loader'
       require 'puppet/pops/loader/ruby_function_instantiator'
+      require 'puppet/pops/loader/ruby_legacy_function_instantiator'
       require 'puppet/pops/loader/ruby_data_type_instantiator'
       require 'puppet/pops/loader/puppet_function_instantiator'
       require 'puppet/pops/loader/type_definition_instantiator'

data/lib/puppet/metatype/manager.rb

@@ -50,7 +50,7 @@ module Manager
   # @return [void]
   #
   def loadall
-    typeloader.loadall
+    typeloader.loadall(Puppet.lookup(:current_environment))
   end
 
   # Defines a new type or redefines an existing type with the given name.
@@ -93,8 +93,6 @@ module Manager
       end
     end
 
-    options = symbolize_options(options)
-
     # Then create the class.
 
     klass = genclass(
@@ -123,10 +121,10 @@ module Manager
 
     # Now set up autoload any providers that might exist for this type.
 
-    klass.providerloader = Puppet::Util::Autoload.new(klass, "puppet/provider/#{klass.name}")
+    klass.providerloader = Puppet::Util::Autoload.new(klass, "puppet/provider/#{klass.name.to_s}")
 
     # We have to load everything so that we can figure out the default provider.
-    klass.providerloader.loadall Puppet.lookup(:current_environment)
+    klass.providerloader.loadall(Puppet.lookup(:current_environment))
     klass.providify unless klass.providers.empty?
 
     loc = block_given? ? block.source_location : nil

data/lib/puppet/module.rb

@@ -56,29 +56,8 @@ class Puppet::Module
   end
 
   # @api private
-  def self.parse_range(range, strict)
-    @parse_range_method ||= SemanticPuppet::VersionRange.method(:parse)
-    if @parse_range_method.arity == 1
-      @semver_gem_version ||= SemanticPuppet::Version.parse(SemanticPuppet::VERSION)
-
-      # Give user a heads-up if the desired strict setting cannot be honored
-      if strict
-        if @semver_gem_version.major < 1
-          Puppet.warn_once('strict_version_ranges', 'version_range_cannot_be_strict',
-            _('VersionRanges will never be strict when using non-vendored SemanticPuppet gem, version %{version}') % { version: @semver_gem_version},
-            :default, :default, :notice)
-        end
-      else
-        if @semver_gem_version.major >= 1
-          Puppet.warn_once('strict_version_ranges', 'version_range_always_strict',
-            _('VersionRanges will always be strict when using non-vendored SemanticPuppet gem, version %{version}') % { version: @semver_gem_version},
-            :default, :default, :notice)
-        end
-      end
-      @parse_range_method.call(range)
-    else
-      @parse_range_method.call(range, strict)
-    end
+  def self.parse_range(range)
+    SemanticPuppet::VersionRange.parse(range)
   end
 
   attr_reader :name, :environment, :path, :metadata, :tasks
@@ -87,10 +66,9 @@ class Puppet::Module
   attr_accessor :dependencies, :forge_name
   attr_accessor :source, :author, :version, :license, :summary, :description, :project_page
 
-  def initialize(name, path, environment, strict_semver = true)
+  def initialize(name, path, environment)
     @name = name
     @path = path
-    @strict_semver = strict_semver
     @environment = environment
 
     assert_validity
@@ -225,7 +203,7 @@ class Puppet::Module
     @metadata = data = read_metadata
     return if data.empty?
 
-    @forge_name = data['name'].tr('-', '/') if data['name']
+    @forge_name = data['name'].gsub('-', '/') if data['name']
 
     [:source, :author, :version, :license, :dependencies].each do |attr|
       value = data[attr.to_s]
@@ -406,7 +384,7 @@ class Puppet::Module
 
       if version_string
         begin
-          required_version_semver_range = self.class.parse_range(version_string, @strict_semver)
+          required_version_semver_range = self.class.parse_range(version_string)
           actual_version_semver = SemanticPuppet::Version.parse(dep_mod.version)
         rescue ArgumentError
           error_details[:reason] = :non_semantic_version
@@ -432,10 +410,6 @@ class Puppet::Module
     self.environment == other.environment
   end
 
-  def strict_semver?
-    @strict_semver
-  end
-
   private
 
   def wanted_manifests_from(pattern)

data/lib/puppet/module/task.rb

@@ -2,12 +2,50 @@ require 'puppet/util/logging'
 
 class Puppet::Module
   class Task
-    class Error < Puppet::Error; end
-    class InvalidName < Error; end
-    class InvalidFile < Error; end
-    class TaskNotFound < Error; end
+    class Error < Puppet::Error
+      attr_accessor :kind, :details
+      def initialize(message, kind, details = nil)
+        super(message)
+        @details = details || {}
+        @kind = kind
+      end
+
+      def to_h
+        {
+          msg: message,
+          kind: kind,
+          details: details
+        }
+      end
+    end
+
+    class InvalidName < Error
+      def initialize(name)
+        msg = _("Task names must start with a lowercase letter and be composed of only lowercase letters, numbers, and underscores")
+        super(msg, 'puppet.tasks/invalid-name')
+      end
+    end
+
+    class InvalidFile < Error
+      def initialize(msg)
+        super(msg, 'puppet.tasks/invalid-file')
+      end
+    end
+
+    class InvalidTask < Error
+    end
+    class InvalidMetadata < Error
+    end
+    class TaskNotFound < Error
+      def initialize(task_name, module_name)
+        msg = _("Task %{task_name} not found in module %{module_name}.") %
+          {task_name: task_name, module_name: module_name}
+        super(msg, 'puppet.tasks/task-not-found', { 'name' => task_name })
+      end
+    end
 
     FORBIDDEN_EXTENSIONS = %w{.conf .md}
+    MOUNTS = %w[lib files tasks]
 
     def self.is_task_name?(name)
       return true if name =~ /^[a-z][a-z0-9_]*$/
@@ -24,6 +62,113 @@ class Puppet::Module
       return true
     end
 
+    def self.get_file_details(path, mod)
+      # This gets the path from the starting point onward
+      # For files this should be the file subpath from the metadata
+      # For directories it should be the directory subpath plus whatever we globbed
+      # Partition matches on the first instance it finds of the parameter
+      name = "#{mod.name}#{path.partition(mod.path).last}"
+
+      { "name" => name, "path" =>  path }
+    end
+
+    # Find task's required lib files and retrieve paths
+    # for both 'files' and 'implementation:files' metadata keys
+    def self.find_files(files, mod)
+      env = mod.environment.respond_to?(:name) ? mod.environment.name : 'production'
+
+      file_list = files.flat_map do |file|
+        module_name, mount, endpath = file.split("/", 3)
+        # If there's a mount directory with no trailing slash this will be nil
+        # We want it to be empty to construct a path
+        endpath ||= ''
+
+        pup_module = Puppet::Module.find(module_name, env)
+        if pup_module.nil?
+          msg = _("Could not find module %{module_name} containing task file %{filename}" %
+                  {module_name: module_name, filename: endpath})
+          raise InvalidMetadata.new(msg, 'puppet.tasks/invalid-metadata')
+        end
+
+        unless MOUNTS.include? mount
+          msg = _("Files must be saved in module directories that Puppet makes available via mount points: %{mounts}" %
+                  {mounts: MOUNTS.join(', ')})
+          raise InvalidMetadata.new(msg, 'puppet.tasks/invalid-metadata')
+        end
+
+        path = File.join(pup_module.path, mount, endpath)
+        unless File.absolute_path(path) == File.path(path).chomp('/')
+          msg = _("File pathnames cannot include relative paths")
+          raise InvalidMetadata.new(msg, 'puppet.tasks/invalid-metadata')
+        end
+
+        unless File.exist?(path)
+          msg = _("Could not find %{path} on disk" % { path: path })
+          raise InvalidFile.new(msg)
+        end
+
+        last_char = file[-1] == '/'
+        if File.directory?(path)
+          unless last_char
+            msg = _("Directories specified in task metadata must include a trailing slash: %{dir}" % { dir: file } )
+            raise InvalidMetadata.new(msg, 'puppet.tasks/invalid-metadata')
+          end
+          dir_files = Dir.glob("#{path}**/*").select { |f| File.file?(f) }
+          files = dir_files.map { |f| get_file_details(f, pup_module) }
+        else
+          if last_char
+            msg = _("Files specified in task metadata cannot include a trailing slash: %{file}" % { file: file } )
+            raise InvalidMetadata.new(msg, 'puppet.task/invalid-metadata')
+          end
+          files = get_file_details(path, pup_module)
+        end
+
+        files
+      end
+      return file_list
+    end
+
+    # Copied from TaskInstantiator so we can use the Error classes here
+    # TODO: harmonize on one implementation
+    # Executables list should contain the full path of all possible implementation files
+    def self.find_implementations(name, directory, metadata, executables)
+      basename = name.split('::')[1] || 'init'
+      # If 'implementations' is defined, it needs to mention at least one
+      # implementation, and everything it mentions must exist.
+      metadata ||= {}
+      if metadata.key?('implementations')
+        unless metadata['implementations'].is_a?(Array)
+          msg = _("Task metadata for task %{name} does not specify implementations as an array" % { name: name })
+          raise InvalidMetadata.new(msg, 'puppet.tasks/invalid-metadata')
+        end
+
+        implementations = metadata['implementations'].map do |impl|
+          path = executables.find { |real_impl| File.basename(real_impl) == impl['name'] }
+          unless path
+            msg = _("Task metadata for task %{name} specifies missing implementation %{implementation}" % { name: name, implementation: impl['name'] })
+            raise InvalidTask.new(msg, 'puppet.tasks/missing-implementation', { missing: [impl['name']] } )
+          end
+          { "name" => impl['name'], "requirements" => impl.fetch('requirements', []), "path" => path }
+        end
+        return implementations
+      end
+
+      # If implementations isn't defined, then we use executables matching the
+      # task name, and only one may exist.
+      implementations = executables.select { |impl| File.basename(impl, '.*') == basename }
+      if implementations.empty?
+        msg = _('No source besides task metadata was found in directory %{directory} for task %{name}') %
+          { name: name, directory: directory }
+        raise InvalidTask.new(msg, 'puppet.tasks/no-implementation')
+      elsif implementations.length > 1
+        msg =_("Multiple executables were found in directory %{directory} for task %{name}; define 'implementations' in metadata to differentiate between them") %
+          { name: name, directory: implementations[0] }
+        raise InvalidTask.new(msg, 'puppet.tasks/multiple-implementations')
+      end
+
+      [{ "name" => File.basename(implementations.first), "path" => implementations.first, "requirements" => [] }]
+    end
+
     def self.is_tasks_metadata_filename?(name)
       is_tasks_filename?(name) && name.end_with?('.json')
     end
@@ -33,37 +178,73 @@ class Puppet::Module
     end
 
     def self.tasks_in_module(pup_module)
-      Dir.glob(File.join(pup_module.tasks_directory, '*'))
+      task_files = Dir.glob(File.join(pup_module.tasks_directory, '*'))
         .keep_if { |f| is_tasks_filename?(f) }
-        .group_by { |f| task_name_from_path(f) }
-        .map { |task, files| new_with_files(pup_module, task, files) }
-    end
 
-    attr_reader :name, :module, :metadata_file, :files
+      module_executables = task_files.reject(&method(:is_tasks_metadata_filename?)).map.to_a
 
-    def initialize(pup_module, task_name, files, metadata_file = nil)
-      if !Puppet::Module::Task.is_task_name?(task_name)
-        raise InvalidName, _("Task names must start with a lowercase letter and be composed of only lowercase letters, numbers, and underscores")
+      tasks = task_files.group_by { |f| task_name_from_path(f) }
+
+      tasks.map do |task, executables|
+        new_with_files(pup_module, task, executables, module_executables)
       end
+    end
 
-      all_files = metadata_file.nil? ? files : files + [metadata_file]
-      all_files.each do |f|
-        if !f.start_with?(pup_module.tasks_directory)
-          msg = _("The file '%{path}' is not located in the %{module_name} module's tasks directory") %
-                       {path: f.to_s, module_name: pup_module.name}
+    attr_reader :name, :module, :metadata_file, :metadata
 
-          # we can include some extra context for the log message:
-          Puppet.err(msg + " (#{pup_module.tasks_directory})")
-          raise InvalidFile, msg
-        end
+    # file paths must be relative to the modules task directory
+    def initialize(pup_module, task_name,  module_executables, metadata_file = nil)
+      if !Puppet::Module::Task.is_task_name?(task_name)
+        raise InvalidName, _("Task names must start with a lowercase letter and be composed of only lowercase letters, numbers, and underscores")
       end
 
       name = task_name == "init" ? pup_module.name : "#{pup_module.name}::#{task_name}"
 
       @module = pup_module
       @name = name
-      @metadata_file = metadata_file if metadata_file
-      @files = files
+      @metadata_file = metadata_file
+      @module_executables = module_executables || []
+    end
+
+    def read_metadata(file)
+      Puppet::Util::Json.load(Puppet::FileSystem.read(file, :encoding => 'utf-8')) if file
+    rescue SystemCallError, IOError => err
+      msg = _("Error reading metadata: %{message}" % {message: err.message})
+      raise InvalidMetadata.new(msg, 'puppet.tasks/unreadable-metadata')
+    rescue Puppet::Util::Json::ParseError => err
+      raise InvalidMetadata.new(err.message, 'puppet.tasks/unparseable-metadata')
+    end
+
+    def metadata
+      @metadata ||= read_metadata(@metadata_file)
+    end
+
+    def implementations
+      @implementations ||= self.class.find_implementations(@name, @module.tasks_directory, metadata, @module_executables)
+    end
+
+    def files
+      md = metadata
+      outer_files = []
+      impl_lib_files = []
+      lib_files = []
+
+      unless md.nil?
+        outer_files = md['files'] if md.key?('files')
+        # There's definitely a more elegant way to do this...
+        if md.key?('implementations')
+          md['implementations'].each { |impl| impl_lib_files << impl['files'] if impl.key?('files') }
+        end
+        lib_files = self.class.find_files((impl_lib_files.flatten.uniq + outer_files).uniq, @module)
+      end
+      task_file = implementations.map {|imp| { 'name' => imp['name'], 'path' => imp['path'] } }
+      # PXP agent relies on 'impls' (which is the task file) being first if there is no metadata
+      task_file + lib_files
+    end
+
+    def validate
+      implementations
+      true
     end
 
     def ==(other)
@@ -71,16 +252,13 @@ class Puppet::Module
       self.module == other.module
     end
 
-    def self.new_with_files(pup_module, name, tasks_files)
-      files = tasks_files.map do |filename|
-        File.join(pup_module.tasks_directory, File.basename(filename))
-      end
-
-      metadata_files, exe_files = files.partition { |f| is_tasks_metadata_filename?(f) }
-      Puppet::Module::Task.new(pup_module, name, exe_files, metadata_files.first)
+    def self.new_with_files(pup_module, name, task_files, module_executables)
+      metadata_file = task_files.find { |f| is_tasks_metadata_filename?(f) }
+      Puppet::Module::Task.new(pup_module, name, module_executables, metadata_file)
     end
     private_class_method :new_with_files
 
+    # Abstracted here so we can add support for subdirectories later
     def self.task_name_from_path(path)
       return File.basename(path, '.*')
     end