puppet 5.1.0-x64-mingw32 → 5.2.0-x64-mingw32

data/lib/puppet/file_serving/configuration.rb

@@ -5,6 +5,7 @@ require 'puppet/file_serving/mount/file'
 require 'puppet/file_serving/mount/modules'
 require 'puppet/file_serving/mount/plugins'
 require 'puppet/file_serving/mount/pluginfacts'
+require 'puppet/file_serving/mount/tasks'
 
 class Puppet::FileServing::Configuration
   require 'puppet/file_serving/configuration/parser'
@@ -82,6 +83,8 @@ class Puppet::FileServing::Configuration
     @mounts["plugins"].allow('*') if @mounts["plugins"].empty?
     @mounts["pluginfacts"] ||= Mount::PluginFacts.new("pluginfacts")
     @mounts["pluginfacts"].allow('*') if @mounts["pluginfacts"].empty?
+    @mounts["tasks"] ||= Mount::Tasks.new("tasks")
+    @mounts["tasks"].allow('*') if @mounts["tasks"].empty?
   end
 
   # Read the configuration file.

data/lib/puppet/file_serving/configuration/parser.rb

@@ -92,6 +92,8 @@ class Puppet::FileServing::Configuration::Parser
       mount = Mount::Modules.new(name)
     when "plugins"
       mount = Mount::Plugins.new(name)
+    when "tasks"
+      mount = Mount::Tasks.new(name)
     else
       mount = Mount::File.new(name)
     end

data/lib/puppet/file_serving/mount/tasks.rb

@@ -0,0 +1,21 @@
+require 'puppet/file_serving/mount'
+
+class Puppet::FileServing::Mount::Tasks < Puppet::FileServing::Mount
+  def find(path, request)
+    raise _("No task specified") if path.to_s.empty?
+    module_name, task_path = path.split("/", 2)
+    return nil unless mod = request.environment.module(module_name)
+
+    mod.task_file(task_path)
+  end
+
+  def search(path, request)
+    if result = find(path, request)
+      [result]
+    end
+  end
+
+  def valid?
+    true
+  end
+end

data/lib/puppet/functions/epp.rb

@@ -21,6 +21,9 @@
 # `epp('apache/vhost/_docroot.epp', { 'docroot' => '/var/www/html',
 # 'virtual_docroot' => '/var/www/example' })`
 #
+# This function can also accept an absolute path, which can load a template file
+# from anywhere on disk.
+#
 # Puppet produces a syntax error if you pass more parameters than are declared in
 # the template's parameter tag. When passing parameters to a template that
 # contains a parameter tag, use the same names as the tag's declared parameters.

data/lib/puppet/functions/lookup.rb

@@ -96,7 +96,8 @@
 # * `{'strategy' => 'deep', <DEEP OPTION> => <VALUE>, ...}` --- Same as `'deep'`,
 # but can adjust the merge with additional options. The available options are:
 #     * `'knockout_prefix'` (string or undef) --- A string prefix to indicate a
-#     value should be _removed_ from the final result. Defaults to `undef`, which
+#     value should be _removed_ from the final result. If a value is exactly equal
+#     to the prefix, it will knockout the entire element. Defaults to `undef`, which
 #     disables this feature.
 #     * `'sort_merged_arrays'` (boolean) --- Whether to sort all arrays that are
 #     merged together. Defaults to `false`.

data/lib/puppet/generate/models/type/property.rb

@@ -40,7 +40,7 @@ module Puppet
             values = property.value_collection.instance_variable_get('@values') || {}
             values.each do |_, value|
               if value.regex?
-                regexes << "/#{value.name.source.gsub(/\//, '\/')}/"
+                regexes << Puppet::Pops::Types::StringConverter.convert(value.name, '%p')
                 next
               end
 

data/lib/puppet/gettext/config.rb

@@ -0,0 +1,70 @@
+require 'puppet/util/platform'
+
+module Puppet::GettextConfig
+  LOCAL_PATH = File.absolute_path('../../../locales', File.dirname(__FILE__))
+  POSIX_PATH = File.absolute_path('../../../../../share/locale', File.dirname(__FILE__))
+  WINDOWS_PATH = File.absolute_path('../../../../../../../puppet/share/locale', File.dirname(__FILE__))
+
+  # Search for puppet gettext config files
+  # @return [String] path to the config, or nil if not found
+  def self.puppet_locale_path
+    if File.exist?(LOCAL_PATH)
+      return LOCAL_PATH
+    elsif Puppet::Util::Platform.windows? && File.exist?(WINDOWS_PATH)
+      return WINDOWS_PATH
+    elsif !Puppet::Util::Platform.windows? && File.exist?(POSIX_PATH)
+      return POSIX_PATH
+    else
+      nil
+    end
+  end
+
+  # Determine which translation file format to use
+  # @param conf_path [String] the path to the gettext config file
+  # @return [Symbol] :mo if in a package structure, :po otherwise
+  def self.translation_mode(conf_path)
+    if WINDOWS_PATH == conf_path || POSIX_PATH == conf_path
+      return :mo
+    else
+      return :po
+    end
+  end
+
+  # Attempt to initialize the gettext-setup gem
+  # @param path [String] to gettext config file
+  # @param file_format [Symbol] translation file format to use, either :po or :mo
+  # @return true if initialization succeeded, false otherwise
+  def self.initialize(conf_file_location, file_format)
+    unless file_format == :po || file_format == :mo
+      raise Puppet::Error, "Unsupported translation file format #{file_format}; please use :po or :mo"
+    end
+
+    begin
+      require 'gettext-setup'
+      require 'locale'
+
+      if conf_file_location && File.exists?(conf_file_location)
+        if GettextSetup.method(:initialize).parameters.count == 1
+          # For use with old gettext-setup gem versions, will load PO files only
+          GettextSetup.initialize(conf_file_location)
+        else
+          GettextSetup.initialize(conf_file_location, :file_format => file_format)
+        end
+        # Only change this once.
+        # Because negotiate_locales will only return a non-default locale if
+        # the system locale matches a translation set actually available for the
+        # given gettext project, we don't want this to get set back to default if
+        # we load a module that doesn't have translations, but Puppet does have
+        # translations for the user's locale.
+        if FastGettext.locale == GettextSetup.default_locale
+          FastGettext.locale = GettextSetup.negotiate_locale(Locale.current.language)
+        end
+        true
+      else
+        false
+      end
+    rescue LoadError
+      false
+    end
+  end
+end

data/lib/puppet/gettext/stubs.rb

@@ -0,0 +1,11 @@
+# These stub the translation methods noramlly brought in
+# by FastGettext. Used when Gettext could not be properly
+# initialized.
+def _(msg)
+  msg
+end
+
+def n_(*args, &block)
+  plural = args[2] == 1 ? args[0] : args[1]
+  block ? block.call : plural
+end

data/lib/puppet/indirector/request.rb

@@ -199,7 +199,7 @@ class Puppet::Indirector::Request
       if primary_server = Puppet.settings[:server_list][0]
         bound_server = primary_server[0]
       else
-        bound_server = nil
+        bound_server = Puppet.settings[:server]
       end
     end
 
@@ -209,11 +209,11 @@ class Puppet::Indirector::Request
       if primary_server = Puppet.settings[:server_list][0]
         bound_port = primary_server[1]
       else
-        bound_port = nil
+        bound_port = Puppet.settings[:masterport]
       end
     end
-    self.server = default_server || bound_server || Puppet.settings[:server]
-    self.port   = default_port || bound_port || Puppet.settings[:masterport]
+    self.server = default_server || bound_server
+    self.port   = default_port || bound_port
 
     Puppet.debug "No more servers left, falling back to #{self.server}:#{self.port}" if Puppet.settings[:use_srv_records]
 

data/lib/puppet/info_service.rb

@@ -1,7 +1,17 @@
 
 module Puppet::InfoService
   require 'puppet/info_service/class_information_service'
+  require 'puppet/info_service/task_information_service'
+
   def self.classes_per_environment(env_file_hash)
     Puppet::InfoService::ClassInformationService.new.classes_per_environment(env_file_hash)
   end
+
+  def self.tasks_per_environment(environment_name)
+    Puppet::InfoService::TaskInformationService.tasks_per_environment(environment_name)
+  end
+
+  def self.task_data(environment_name, module_name, task_name)
+    Puppet::InfoService::TaskInformationService.task_data(environment_name, module_name, task_name)
+  end
 end

data/lib/puppet/info_service/task_information_service.rb

@@ -0,0 +1,32 @@
+class Puppet::InfoService::TaskInformationService
+  require 'puppet/module'
+
+  def self.tasks_per_environment(environment_name)
+    # get the actual environment object, raise error if the named env doesn't exist
+    env = Puppet.lookup(:environments).get!(environment_name)
+    env.modules.map do |mod|
+      mod.tasks.map do |task|
+        {:module => {:name => task.module.name}, :name => task.name}
+      end
+    end.flatten
+  end
+
+  def self.task_data(environment_name, module_name, task_name)
+    # raise EnvironmentNotFound if applicable
+    Puppet.lookup(:environments).get!(environment_name)
+
+    pup_module = Puppet::Module.find(module_name, environment_name)
+    if pup_module.nil?
+      raise Puppet::Module::MissingModule, _("Module %{module_name} not found in environment %{environment_name}.") %
+                                            {module_name: module_name, environment_name: environment_name}
+    end
+
+    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}
+    end
+
+    {:metadata_file => task.metadata_file, :files => task.files}
+  end
+end

data/lib/puppet/module.rb

@@ -1,4 +1,5 @@
 require 'puppet/util/logging'
+require 'puppet/module/task'
 require 'json'
 require 'semantic_puppet/gem_version'
 
@@ -79,7 +80,7 @@ class Puppet::Module
     end
   end
 
-  attr_reader :name, :environment, :path, :metadata
+  attr_reader :name, :environment, :path, :metadata, :tasks
   attr_writer :environment
 
   attr_accessor :dependencies, :forge_name
@@ -97,15 +98,7 @@ class Puppet::Module
     @absolute_path_to_manifests = Puppet::FileSystem::PathPattern.absolute(manifests)
 
     # i18n initialization for modules
-    if Puppet::GETTEXT_AVAILABLE
-      begin
-        initialize_i18n
-      rescue Exception => e
-        Puppet.warning _("GettextSetup initialization for %{module_name} failed with: %{error_message}") % { module_name: name, error_message: e.message }
-      end
-    else
-      Puppet.warning _("GettextSetup is not available, skipping GettextSetup initialization for %{module_name}.") % { module_name: name }
-    end
+    initialize_i18n
   end
 
   # @deprecated The puppetversion module metadata field is no longer used.
@@ -169,6 +162,39 @@ class Puppet::Module
     end
   end
 
+  def tasks_directory
+    subpath("tasks")
+  end
+
+  def tasks
+    return @tasks if instance_variable_defined?(:@tasks)
+
+    if Puppet::FileSystem.exist?(tasks_directory)
+      @tasks = Puppet::Module::Task.tasks_in_module(self)
+    else
+      @tasks = []
+    end
+  end
+
+  # This is a re-implementation of the Filetypes singular type method (e.g.
+  # `manifest('my/manifest.pp')`. We don't implement the full filetype "API" for
+  # tasks since tasks don't map 1:1 onto files.
+  def task_file(name)
+    # If 'file' is nil then they're asking for the base path.
+    # This is used for things like fileserving.
+    if name
+      full_path = File.join(tasks_directory, name)
+    else
+      full_path = tasks_directory
+    end
+
+    if Puppet::FileSystem.exist?(full_path)
+      return full_path
+    else
+      return nil
+    end
+  end
+
   def license_file
     return @license_file if defined?(@license_file)
 
@@ -403,7 +429,7 @@ class Puppet::Module
     locales_path = File.absolute_path('locales', path)
 
     begin
-      GettextSetup.initialize(locales_path)
+      Puppet::GettextConfig.initialize(locales_path, :po)
       Puppet.debug "#{module_name} initialized for i18n: #{GettextSetup.translation_repositories[module_name]}"
     rescue
       config_path = File.absolute_path('config.yaml', locales_path)
@@ -414,7 +440,12 @@ class Puppet::Module
   private
 
   def i18n_initialized?(module_name)
-    GettextSetup.translation_repositories.has_key? module_name
+    begin
+      GettextSetup.translation_repositories.has_key? module_name
+    rescue NameError
+      # GettextSetup not yet initialized
+      false
+    end
   end
 
   def wanted_manifests_from(pattern)

data/lib/puppet/module/task.rb

@@ -0,0 +1,90 @@
+require 'json'
+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
+
+    FORBIDDEN_EXTENSIONS = %w{.conf .md}
+
+    def self.is_task_name?(name)
+      return true if name =~ /^[a-z][a-z0-9_]*$/
+      return false
+    end
+
+    # Determine whether a file has a legal name for either a task's executable or metadata file.
+    def self.is_tasks_filename?(path)
+      name_less_extension = File.basename(path, '.*')
+      return false if not is_task_name?(name_less_extension)
+      FORBIDDEN_EXTENSIONS.each do |ext|
+        return false if path.end_with?(ext)
+      end
+      return true
+    end
+
+    def self.is_tasks_metadata_filename?(name)
+      is_tasks_filename?(name) && name.end_with?('.json')
+    end
+
+    def self.is_tasks_executable_filename?(name)
+      is_tasks_filename?(name) && !name.end_with?('.json')
+    end
+
+    def self.tasks_in_module(pup_module)
+      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
+
+    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")
+      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}
+
+          # we can include some extra context for the log message:
+          Puppet.err(msg + " (#{pup_module.tasks_directory})")
+          raise InvalidFile, msg
+        end
+      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
+    end
+
+    def ==(other)
+      self.name == other.name &&
+      self.module == other.module
+    end
+
+    private
+
+    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)
+    end
+
+    def self.task_name_from_path(path)
+      return File.basename(path, '.*')
+    end
+  end
+end

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

@@ -70,6 +70,6 @@ class Puppet::Parser::AST::Regex < Puppet::Parser::AST::Leaf
   end
 
   def to_s
-    "/#{@value.source}/"
+    Puppet::Pops::Types::PRegexpType.regexp_to_s_with_delimiters(@value)
   end
 end

data/lib/puppet/parser/functions/dig.rb

@@ -3,7 +3,8 @@ Puppet::Parser::Functions::newfunction(
   :type => :rvalue,
   :arity => -1,
   :doc => <<-DOC
-Returns a value for a sequence of given keys/indexes into a structure.
+Returns a value for a sequence of given keys/indexes into a structure, such as
+an array or hash.
 This function is used to "dig into" a complex data structure by
 using a sequence of keys / indexes to access a value from which
 the next key/index is accessed recursively.
@@ -13,15 +14,23 @@ The first encountered `undef` value or key stops the "dig" and `undef` is return
 An error is raised if an attempt is made to "dig" into
 something other than an `undef` (which immediately returns `undef`), an `Array` or a `Hash`.
 
+
+
 **Example:** Using `dig`
 
 ```puppet
 $data = {a => { b => [{x => 10, y => 20}, {x => 100, y => 200}]}}
-notice $data.dig(a, b, 1, x)
+notice $data.dig('a', 'b', 1, 'x')
 ```
 
 Would notice the value 100.
 
+This is roughly equivalent to `$data['a']['b'][1]['x']`. However, a standard
+index will return an error and cause catalog compilation failure if any parent
+of the final key (`'x'`) is `undef`. The `dig` function will return undef,
+rather than failing catalog compilation. This allows you to check if data
+exists in a structure without mandating that it always exists.
+
 * Since 4.5.0
 DOC
 ) do |args|