puppet 5.3.7-x64-mingw32 → 5.4.0-x64-mingw32

data/lib/puppet/configurer.rb

@@ -8,7 +8,6 @@ require 'securerandom'
 class Puppet::Configurer
   require 'puppet/configurer/fact_handler'
   require 'puppet/configurer/plugin_handler'
-  require 'puppet/configurer/downloader_factory'
 
   include Puppet::Configurer::FactHandler
 
@@ -56,7 +55,7 @@ class Puppet::Configurer
     end
   end
 
-  def initialize(factory = Puppet::Configurer::DownloaderFactory.new, transaction_uuid = nil, job_id = nil)
+  def initialize(transaction_uuid = nil, job_id = nil)
     @running = false
     @splayed = false
     @cached_catalog_status = 'not_used'
@@ -65,7 +64,7 @@ class Puppet::Configurer
     @job_id = job_id
     @static_catalog = true
     @checksum_type = Puppet[:supported_checksum_types]
-    @handler = Puppet::Configurer::PluginHandler.new(factory)
+    @handler = Puppet::Configurer::PluginHandler.new()
   end
 
   # Get the remote catalog, yo.  Returns nil if no catalog can be found.
@@ -380,7 +379,7 @@ class Puppet::Configurer
               :transaction_uuid => @transaction_uuid,
               :fail_on_404 => false)
           found = true
-        rescue Exception => e
+        rescue
           # Nothing to see here
         end
       end

data/lib/puppet/configurer/plugin_handler.rb

@@ -3,28 +3,45 @@
 # easier to test.
 require 'puppet/configurer'
 
-
 class Puppet::Configurer::PluginHandler
   SUPPORTED_LOCALES_MOUNT_AGENT_VERSION = Gem::Version.new("5.3.4")
 
-  def initialize(factory)
-    @factory = factory
-  end
-
-  # Retrieve facts from the central server.
   def download_plugins(environment)
-    plugin_downloader = @factory.create_plugin_downloader(environment)
-    plugin_fact_downloader = @factory.create_plugin_facts_downloader(environment)
+    source_permissions = Puppet.features.microsoft_windows? ? :ignore : :use
+
+    plugin_downloader = Puppet::Configurer::Downloader.new(
+      "plugin",
+      Puppet[:plugindest],
+      Puppet[:pluginsource],
+      Puppet[:pluginsignore],
+      environment
+    )
+    plugin_fact_downloader = Puppet::Configurer::Downloader.new(
+      "pluginfacts",
+      Puppet[:pluginfactdest],
+      Puppet[:pluginfactsource],
+      Puppet[:pluginsignore],
+      environment,
+      source_permissions
+    )
+
     result = []
     result += plugin_fact_downloader.evaluate
     result += plugin_downloader.evaluate
 
     server_agent_version = Puppet.lookup(:server_agent_version) { "0.0" }
     if Gem::Version.new(server_agent_version) >= SUPPORTED_LOCALES_MOUNT_AGENT_VERSION
-      locales_downloader = @factory.create_locales_downloader(environment)
+      locales_downloader = Puppet::Configurer::Downloader.new(
+        "locales",
+        Puppet[:localedest],
+        Puppet[:localesource],
+        Puppet[:pluginsignore] + " *.pot config.yaml",
+        environment
+      )
       result += locales_downloader.evaluate
     end
 
+
     Puppet::Util::Autoload.reload_changed
 
     result

data/lib/puppet/context.rb

@@ -52,7 +52,7 @@ class Puppet::Context
     elsif block
       block.call
     else
-      raise UndefinedBindingError, _("Unable to lookup '%{name}'") % { name: name }
+      raise UndefinedBindingError, _("no '%{name}' in %{table} at top of %{stack}") % { name: name, table: @table.inspect, stack: @stack.inspect }
     end
   end
 

data/lib/puppet/datatypes.rb

@@ -0,0 +1,213 @@
+# Data types in the Puppet Language can have implementations written in Ruby
+# and distributed in puppet modules. A data type can be declared together with
+# its implementation by creating a file in 'lib/puppet/functions/<modulename>'.
+# The name of the file must be the downcased name of the data type followed by
+# the extension '.rb'.
+#
+# A data type is created by calling {Puppet::DataTypes.create_type(<type name>)}
+# and passing it a block that defines the data type interface and implementation.
+#
+# Data types are namespaced inside the modules that contains them. The name of the
+# data type is prefixed with the name of the module. As with all type names, each
+# segment of the name must start with an uppercase letter.
+#
+# @example A simple data type
+#   Puppet::DataTypes.create_type('Auth::User') do
+#     interface <<-PUPPET
+#       attributes => {
+#         name => String,
+#         email => String
+#       }
+#     PUPPET
+#   end
+#
+# The above example does not declare an implementation which makes it equivalent
+# to adding the following contents in a file named 'user.pp' under the 'types' directory
+# of the module root.
+#
+#   type Auth::User = Object[
+#     attributes => {
+#       name => String,
+#       email => String
+#     }]
+#
+# Both declarations are valid and will be found by the module loader.
+#
+# Structure of a data type
+# ---
+#
+# A Data Type consists of an interface and an implementation. Unless a registered implementation
+# is found, the type system will automatically generate one. An  automatically generated
+# implementation is all that is needed when the interface fully  defines the behaviour (for
+# example in the common case when the data type has no other behaviour than having attributes).
+#
+# When the automatically generated implementation is not sufficient, one must be implemented and
+# registered. The implementation can either be done next to the interface definition by passing
+# a block to `implementation`, or map to an existing implementation class by passing the class
+# as an argument to `implementation_class`. An implementation class does not have to be special
+# in other respects than that it must implemented the type's interface. This makes it possible
+# to use existing Ruby data types as data types in the puppet language.
+#
+# Note that when using `implementation_class` there can only be one such implementation across
+# all environments managed by one puppet server and you must handle and install these
+# implementations as if they are part of the puppet platform. In contrast; the type
+# implementations that are done inside of the type's definition are safe to use in different
+# versions in different environments (given that they do not need additional external logic to
+# be loaded).
+#
+# When using an `implementation_class` it is sometimes desirable to load this class from the
+# 'lib' directory of the module. The method `load_file` is provided to facilitate such a load.
+# The `load_file` will use the `Puppet::Util::Autoload` to search for the given file in the 'lib'
+# directory of the current environment and the 'lib' directory in each included module.
+#
+# @example Adding implementation on top of the generated type using `implementation`
+#   Puppet::DataTypes.create_type('Auth::User') do
+#     interface <<-PUPPET
+#       attributes => {
+#         name => String,
+#         email => String,
+#         year_of_birth => Integer,
+#         age => { type => Integer, kind => derived }
+#       }
+#       PUPPET
+#
+#     implementation do
+#       def age
+#         DateTime.now.year - @year_of_birth
+#       end
+#     end
+#   end
+#
+# @example Appointing an already existing implementation class
+#
+# Assumes the following class is declared under 'lib/puppetx/auth' in the module:
+#
+#   class PuppetX::Auth::User
+#     attr_reader :name, :year_of_birth
+#     def initialize(name, year_of_birth)
+#       @name = name
+#       @year_of_birth = year_of_birth
+#     end
+#
+#     def age
+#       DateTime.now.year - @year_of_birth
+#     end
+#
+#     def send_text(sender, text)
+#       sender.send_text_from(@name, text)
+#     end
+#   end
+#
+# Then the type declaration can look like this:
+#
+#   Puppet::DataTypes.create_type('Auth::User') do
+#     interface <<-PUPPET
+#       attributes => {
+#         name => String,
+#         email => String,
+#         year_of_birth => Integer,
+#         age => { type => Integer, kind => derived }
+#       },
+#       functions => {
+#         send_text => Callable[Sender, String[1]]
+#       }
+#       PUPPET
+#
+#     # This load_file is optional and only needed in case
+#     # the implementation is not loaded by other means.
+#     load_file 'puppetx/auth/user'
+#
+#     implementation_class PuppetX::Auth::User
+#   end
+#
+module Puppet::DataTypes
+  def self.create_type(type_name, &block)
+    # Ruby < 2.1.0 does not have method on Binding, can only do eval
+    # and it will fail unless protected with an if defined? if the local
+    # variable does not exist in the block's binder.
+    #
+    begin
+      loader = block.binding.eval('loader_injected_arg if defined?(loader_injected_arg)')
+      create_loaded_type(type_name, loader, &block)
+    rescue StandardError => e
+      raise ArgumentError, _("Data Type Load Error for type '%{type_name}': %{message}") % {type_name: type_name, message: e.message}
+    end
+
+  end
+
+  def self.create_loaded_type(type_name, loader, &block)
+    builder = TypeBuilder.new(type_name.to_s)
+    api = TypeBuilderAPI.new(builder).freeze
+    api.instance_eval(&block)
+    builder.create_type(loader)
+  end
+
+  # @api private
+  class TypeBuilder
+    attr_accessor :interface, :implementation, :implementation_class
+
+    def initialize(type_name)
+      @type_name = type_name
+      @implementation = nil
+      @implementation_class = nil
+    end
+
+    def create_type(loader)
+      raise ArgumentError, _('a data type must have an interface') unless @interface.is_a?(String)
+      created_type = Puppet::Pops::Types::PObjectType.new(
+        @type_name,
+        Puppet::Pops::Parser::EvaluatingParser.new.parse_string("{ #{@interface} }").body)
+
+      if !@implementation_class.nil?
+        if @implementation_class < Puppet::Pops::Types::PuppetObject
+          @implementation_class.instance_eval do
+            include Puppet::Pops::Types::PuppetObject
+            @_pcore_type = created_type
+
+            def self._pcore_type
+              @_pcore_type
+            end
+          end
+        else
+          Puppet::Pops::Loaders.implementation_registry.register_implementation(created_type, @implementation_class, loader)
+        end
+        created_type.implementation_class = @implementation_class
+      elsif !@implementation.nil?
+        created_type.implementation_override = @implementation
+      end
+      created_type
+    end
+
+    def has_implementation?
+      !(@implementation_class.nil? && @implementation.nil?)
+    end
+  end
+
+  # The TypeBuilderAPI class exposes only those methods that the builder API provides
+  # @api public
+  class TypeBuilderAPI
+    # @api private
+    def initialize(type_builder)
+      @type_builder = type_builder
+    end
+
+    def interface(type_string)
+      raise ArgumentError, _('a data type can only have one interface') unless @type_builder.interface.nil?
+      @type_builder.interface = type_string
+    end
+
+    def implementation(&block)
+      raise ArgumentError, _('a data type can only have one implementation') if @type_builder.has_implementation?
+      @type_builder.implementation = block
+    end
+
+    def implementation_class(ruby_class)
+      raise ArgumentError, _('a data type can only have one implementation') if @type_builder.has_implementation?
+      @type_builder.implementation_class = ruby_class
+    end
+
+    def load_file(file_name)
+      Puppet::Util::Autoload.load_file(file_name, nil)
+    end
+  end
+end

data/lib/puppet/datatypes/error.rb

@@ -0,0 +1,21 @@
+Puppet::DataTypes.create_type('Error') do
+  interface <<-PUPPET
+    type_parameters => {
+      kind => Optional[Variant[String,Regexp,Type[Enum],Type[Pattern],Type[NotUndef],Type[Undef]]],
+      issue_code => Optional[Variant[String,Regexp,Type[Enum],Type[Pattern],Type[NotUndef],Type[Undef]]]
+    },
+    attributes => {
+      msg => String[1],
+      kind => { type => Optional[String[1]], value => undef },
+      details => { type => Optional[Hash[String[1],Data]], value => undef },
+      issue_code => { type => Optional[String[1]], value => undef },
+    },
+    functions => {
+      message => Callable[[], String[1]]
+    }
+    PUPPET
+
+  require 'puppet/datatypes/impl/error'
+
+  implementation_class Puppet::DataTypes::Error
+end

data/lib/puppet/datatypes/impl/error.rb

@@ -0,0 +1,40 @@
+class Puppet::DataTypes::Error
+  attr_reader :msg, :kind, :issue_code, :details
+  alias message msg
+
+  def self.from_asserted_hash(hash)
+    new(hash['msg'], hash['kind'], hash['details'], hash['issue_code'])
+  end
+
+  def _pcore_init_hash
+    result = { 'msg' => @msg }
+    result['kind'] = @kind unless @kind.nil?
+    result['details'] = @details unless @details.nil?
+    result['issue_code'] = @issue_code unless @issue_code.nil?
+    result
+  end
+
+  def initialize(msg, kind = nil, details = nil, issue_code = nil)
+    @msg = msg
+    @kind = kind
+    @details = details
+    @issue_code = issue_code
+  end
+
+  def eql?(o)
+    self.class.equal?(o.class) &&
+      @msg == o.msg &&
+      @kind == o.kind &&
+      @issue_code == o.issue_code &&
+      @details == o.details
+  end
+  alias == eql?
+
+  def hash
+    @msg.hash ^ @kind.hash ^ @issue_code.hash
+  end
+
+  def to_s
+    Puppet::Pops::Types::StringConverter.singleton.convert(self)
+  end
+end

data/lib/puppet/defaults.rb

@@ -1,3 +1,5 @@
+require 'puppet/util/platform'
+
 module Puppet
 
   def self.default_diffargs
@@ -8,6 +10,28 @@ module Puppet
     end
   end
 
+  def self.default_digest_algorithm
+    Puppet::Util::Platform.fips_enabled? ? 'sha256' : 'md5'
+  end
+
+  def self.valid_digest_algorithms
+    Puppet::Util::Platform.fips_enabled? ?
+      %w[sha256 sha384 sha512 sha224] :
+      %w[md5 sha256 sha384 sha512 sha224]
+  end
+
+  def self.default_file_checksum_types
+    Puppet::Util::Platform.fips_enabled? ?
+      %w[sha256 sha384 sha512 sha224] :
+      %w[md5 sha256 sha384 sha512 sha224]
+  end
+
+  def self.valid_file_checksum_types
+    Puppet::Util::Platform.fips_enabled? ?
+      %w[sha256 sha256lite sha384 sha512 sha224 sha1 sha1lite mtime ctime] :
+      %w[md5 md5lite sha256 sha256lite sha384 sha512 sha224 sha1 sha1lite mtime ctime]
+  end
+
   ############################################################################################
   # NOTE: For information about the available values for the ":type" property of settings,
   #   see the docs for Settings.define_settings
@@ -177,7 +201,9 @@ module Puppet
     :static_catalogs => {
       :default    => true,
       :type       => :boolean,
-      :desc       => "Whether to compile a static catalog."
+      :desc       => "Whether to compile a [static catalog](https://docs.puppet.com/puppet/latest/static_catalogs.html#enabling-or-disabling-static-catalogs),
+        which occurs only on a Puppet Server master when the `code-id-command` and
+        `code-content-command` settings are configured in its `puppetserver.conf` file.",
     },
     :strict_environment_mode => {
       :default    => false,
@@ -919,25 +945,28 @@ attempt to download the CRL.
 EOT
     },
     :digest_algorithm => {
-        :default  => 'md5',
+        :default  => lambda { default_digest_algorithm },
         :type     => :enum,
-        :values => ["md5", "sha256"],
-        :desc     => 'Which digest algorithm to use for file resources and the filebucket.
-                      Valid values are md5, sha256. Default is md5.',
+        :values   => valid_digest_algorithms,
+        :desc     => "Which digest algorithm to use for file resources and the filebucket.
+                      Valid values are #{valid_digest_algorithms.join(', ')}. Default is
+                      #{default_digest_algorithm}.",
     },
     :supported_checksum_types => {
-      :default => ['md5', 'sha256'],
+      :default => lambda { default_file_checksum_types },
       :type    => :array,
-      :desc    => 'Checksum types supported by this agent for use in file resources of a
-                   static catalog. Values must be comma-separated. Valid types are md5,
-                   md5lite, sha256, sha256lite, sha1, sha1lite, mtime, ctime.',
+      :desc    => "Checksum types supported by this agent for use in file resources of a
+                   static catalog. Values must be comma-separated. Valid types are
+                   #{valid_file_checksum_types.join(', ')}. Default is
+                   #{default_file_checksum_types.join(', ')}.",
       :hook    => proc do |value|
         values = munge(value)
-        valid   = ['md5', 'md5lite', 'sha256', 'sha256lite', 'sha1', 'sha1lite', 'mtime', 'ctime']
-        invalid = values.reject {|alg| valid.include?(alg)}
+
+        invalid = values - Puppet.valid_file_checksum_types
         if not invalid.empty?
-          raise ArgumentError, _("Unrecognized checksum types %{invalid} are not supported.") % { invalid: invalid } +
-              ' ' + _("Valid values are %{values}.") % { values: valid }
+          raise ArgumentError, _("Invalid value '%{value}' for parameter %{name}. Allowed values are '%{allowed_values}'") % {
+            value: invalid.first, name: @name, allowed_values: Puppet.valid_file_checksum_types.join("', '")
+          }
         end
       end
     }
@@ -1257,13 +1286,7 @@ EOT
       :desc       => "File that provides mapping between custom SSL oids and user-friendly names"
     },
     :basemodulepath => {
-      :default => lambda do
-        if Puppet::Util::Platform.windows?
-          '$codedir/modules'
-        else
-          '$codedir/modules:/opt/puppetlabs/puppet/modules'
-        end
-      end,
+      :default => "$codedir/modules#{File::PATH_SEPARATOR}/opt/puppetlabs/puppet/modules",
       :type => :path,
       :desc => "The search path for **global** modules. Should be specified as a
         list of directories separated by the system path separator character. (The
@@ -2008,6 +2031,14 @@ EOT
       Causes an evaluation error when referencing unknown variables. (This does not affect
       referencing variables that are explicitly set to undef).
     EOT
+    },
+  :tasks => {
+    :default => false,
+    :type => :boolean,
+    :desc => <<-'EOT'
+      Turns on experimental support for tasks and plans in the puppet language. This is for internal API use only.
+      Do not change this setting.
+    EOT
     }
   )
   define_settings(:puppetdoc,