puppet 4.1.0 → 5.0.0

data/lib/puppet/application.rb

@@ -75,7 +75,7 @@ module Puppet
 # Refer to +OptionParser+ documentation for the exact format.
 # * If the option method is given a block, this one will be called whenever
 # the option is encountered in the command-line argument.
-# * If the option method has no block, a default functionnality will be used, that
+# * If the option method has no block, a default functionality will be used, that
 # stores the argument (or true/false if the option doesn't require an argument) in
 # the global (to the application) options array.
 # * If a given option was not defined by a the +option+ method, but it exists as a Puppet settings:
@@ -83,7 +83,7 @@ module Puppet
 #  * if +unknown+ wasn't used, then the option/argument is handed to Puppet.settings.handlearg for
 #    a default behavior
 #
-# --help is managed directly by the Puppet::Application class, but can be overriden.
+# --help is managed directly by the Puppet::Application class, but can be overridden.
 #
 # === Setup
 # Applications can use the setup block to perform any initialization.
@@ -228,7 +228,7 @@ class Application
       begin
         require @loader.expand(application_name.to_s.downcase)
       rescue LoadError => e
-        Puppet.log_and_raise(e, "Unable to find application '#{application_name}'. #{e}")
+        Puppet.log_and_raise(e, _("Unable to find application '%{application_name}'. %{error}") % { application_name: application_name, error: e })
       end
 
       class_name = Puppet::Util::ConstantInflector.file2constant(application_name.to_s)
@@ -249,7 +249,7 @@ class Application
       ################################################################
 
       if clazz.nil?
-        raise Puppet::Error.new("Unable to load application class '#{class_name}' from file 'puppet/application/#{application_name}.rb'")
+        raise Puppet::Error.new(_("Unable to load application class '%{class_name}' from file 'puppet/application/%{application_name}.rb'") % { class_name: class_name, application_name: application_name })
       end
 
       return clazz
@@ -322,6 +322,15 @@ class Application
     @options = {}
   end
 
+  # call in setup of subclass to deprecate an application
+  def deprecate
+    @deprecated = true
+  end
+
+  def deprecated?
+    @deprecated
+  end
+
   # Execute the application.
   # @api public
   # @return [void]
@@ -330,22 +339,27 @@ class Application
     # I don't really like the names of these lifecycle phases.  It would be nice to change them to some more meaningful
     # names, and make deprecated aliases.  --cprice 2012-03-16
 
-    exit_on_fail("get application-specific default settings") do
+    exit_on_fail(_("get application-specific default settings")) do
       initialize_app_defaults
     end
 
     Puppet::ApplicationSupport.push_application_context(self.class.run_mode)
 
-    exit_on_fail("initialize")                                   { preinit }
-    exit_on_fail("parse application options")                    { parse_options }
-    exit_on_fail("prepare for execution")                        { setup }
-    exit_on_fail("configure routes from #{Puppet[:route_file]}") { configure_indirector_routes }
-    exit_on_fail("log runtime debug info")                       { log_runtime_environment }
-    exit_on_fail("run")                                          { run_command }
+    exit_on_fail(_("initialize"))                                   { preinit }
+    exit_on_fail(_("parse application options"))                    { parse_options }
+    exit_on_fail(_("prepare for execution"))                        { setup }
+
+    if deprecated?
+      Puppet.deprecation_warning(_("`puppet %{name}` is deprecated and will be removed in a future release.") % { name: name })
+    end
+
+    exit_on_fail(_("configure routes from %{route_file}") % { route_file: Puppet[:route_file] }) { configure_indirector_routes }
+    exit_on_fail(_("log runtime debug info"))                       { log_runtime_environment }
+    exit_on_fail(_("run"))                                          { run_command }
   end
 
   def main
-    raise NotImplementedError, "No valid command or main"
+    raise NotImplementedError, _("No valid command or main")
   end
 
   def run_command
@@ -357,8 +371,10 @@ class Application
   end
 
   def setup_logs
-    if options[:debug] || options[:verbose]
-      Puppet::Util::Log.newdestination(:console)
+    unless options[:setdest]
+      if options[:debug] || options[:verbose]
+        Puppet::Util::Log.newdestination(:console)
+      end
     end
 
     set_log_level
@@ -456,7 +472,7 @@ class Application
   end
 
   def help
-    "No help available for puppet #{name}"
+    _("No help available for puppet %{app_name}") % { app_name: name }
   end
 end
 end

data/lib/puppet/application_support.rb

@@ -36,7 +36,7 @@ module Puppet
     end
 
     # Reads the routes YAML settings from the file specified by Puppet[:route_file]
-    # and resets indirector terminii for the current application class if listed.
+    # and resets indirector termini for the current application class if listed.
     #
     # For instance, PE uses this to set the master facts terminus
     # to 'puppetdb' and its cache terminus to 'yaml'.

data/lib/puppet/compilable_resource_type.rb

@@ -0,0 +1,15 @@
+require 'puppet'
+# The CompilableResourceType module should be either included in a class or used as a class extension
+# to mark that the instance used as the 'resource type' of a resource instance
+# is an object that is compatible with Puppet::Type's API wrt. compiling.
+# Puppet Resource Types written in Ruby use a meta programmed Ruby Class as the type. Those classes
+# are subtypes of Puppet::Type. Meta data (Pcore/puppet language) based resource types uses instances of
+# a class instead.
+# 
+module Puppet::CompilableResourceType
+  # All 3.x resource types implemented in Ruby using Puppet::Type respond true.
+  # Other kinds of implementations should reimplement and return false.
+  def is_3x_ruby_plugin?
+    true
+  end
+end

data/lib/puppet/configurer/downloader.rb

@@ -6,7 +6,7 @@ class Puppet::Configurer::Downloader
 
   # Evaluate our download, returning the list of changed values.
   def evaluate
-    Puppet.info "Retrieving #{name}"
+    Puppet.info _("Retrieving %{name}") % { name: name }
 
     files = []
     begin
@@ -17,7 +17,7 @@ class Puppet::Configurer::Downloader
         end
       end
     rescue Puppet::Error => detail
-      Puppet.log_exception(detail, "Could not retrieve #{name}: #{detail}")
+      Puppet.log_exception(detail, _("Could not retrieve %{name}: %{detail}") % { name: name, detail: detail })
     end
     files
   end

data/lib/puppet/configurer/fact_handler.rb

@@ -21,7 +21,7 @@ module Puppet::Configurer::FactHandler
     rescue SystemExit,NoMemoryError
       raise
     rescue Exception => detail
-      message = "Could not retrieve local facts: #{detail}"
+      message = _("Could not retrieve local facts: %{detail}") % { detail: detail }
       Puppet.log_exception(detail, message)
       raise Puppet::Error, message, detail.backtrace
     end
@@ -30,8 +30,17 @@ module Puppet::Configurer::FactHandler
   def facts_for_uploading
     facts = find_facts
 
-    text = facts.render(:pson)
-
-    {:facts_format => :pson, :facts => CGI.escape(text)}
+    # NOTE: :facts specified as parameters are URI encoded here,
+    # then  encoded for a second time depending on their length:
+    #
+    # <= 1024 characters sent via query string of a HTTP GET, additionally query string encoded
+    # > 1024 characters sent in POST data, additionally x-www-form-urlencoded
+    # so it's only important that encoding method here return original values
+    # correctly when CGI.unescape called against it (in compiler code)
+    if Puppet[:preferred_serialization_format] == "pson"
+      {:facts_format => :pson, :facts => Puppet::Util.uri_query_encode(facts.render(:pson)) }
+    else
+      {:facts_format => 'application/json', :facts => Puppet::Util.uri_query_encode(facts.render(:json)) }
+    end
   end
 end

data/lib/puppet/configurer/plugin_handler.rb

@@ -12,12 +12,14 @@ class Puppet::Configurer::PluginHandler
   def download_plugins(environment)
     plugin_downloader = @factory.create_plugin_downloader(environment)
 
-    if Puppet.features.external_facts?
-      plugin_fact_downloader = @factory.create_plugin_facts_downloader(environment)
-      plugin_fact_downloader.evaluate
-    end
+    result = []
 
-    plugin_downloader.evaluate
+    plugin_fact_downloader = @factory.create_plugin_facts_downloader(environment)
+    result += plugin_fact_downloader.evaluate
+
+    result += plugin_downloader.evaluate
     Puppet::Util::Autoload.reload_changed
+
+    result
   end
 end

data/lib/puppet/configurer.rb

@@ -19,7 +19,19 @@ class Puppet::Configurer
 
   # Provide more helpful strings to the logging that the Agent does
   def self.to_s
-    "Puppet configuration client"
+    _("Puppet configuration client")
+  end
+
+  def self.should_pluginsync?
+    if Puppet.settings.set_by_cli?(:pluginsync) || Puppet.settings.set_by_config?(:pluginsync)
+      Puppet[:pluginsync]
+    else
+      if Puppet[:use_cached_catalog]
+        false
+      else
+        true
+      end
+    end
   end
 
   def execute_postrun_command
@@ -35,40 +47,59 @@ class Puppet::Configurer
       Puppet::Util::Storage.load
       @compile_time ||= Puppet::Util::Storage.cache(:configuration)[:compile_time]
   rescue => detail
-    Puppet.log_exception(detail, "Removing corrupt state file #{Puppet[:statefile]}: #{detail}")
+    Puppet.log_exception(detail, _("Removing corrupt state file %{file}: %{detail}") % { file: Puppet[:statefile], detail: detail })
     begin
       Puppet::FileSystem.unlink(Puppet[:statefile])
       retry
     rescue => detail
-      raise Puppet::Error.new("Cannot remove #{Puppet[:statefile]}: #{detail}", detail)
+      raise Puppet::Error.new(_("Cannot remove %{file}: %{detail}") % { file: Puppet[:statefile], detail: detail }, detail)
     end
   end
 
-  def initialize(factory = Puppet::Configurer::DownloaderFactory.new)
-    Puppet.settings.use(:main, :ssl, :agent)
-
+  def initialize(factory = Puppet::Configurer::DownloaderFactory.new, transaction_uuid = nil, job_id = nil)
     @running = false
     @splayed = false
+    @cached_catalog_status = 'not_used'
     @environment = Puppet[:environment]
-    @transaction_uuid = SecureRandom.uuid
+    @transaction_uuid = transaction_uuid || SecureRandom.uuid
+    @job_id = job_id
+    @static_catalog = true
+    @checksum_type = Puppet[:supported_checksum_types]
     @handler = Puppet::Configurer::PluginHandler.new(factory)
   end
 
   # Get the remote catalog, yo.  Returns nil if no catalog can be found.
   def retrieve_catalog(query_options)
     query_options ||= {}
-    # First try it with no cache, then with the cache.
-    unless (Puppet[:use_cached_catalog] and result = retrieve_catalog_from_cache(query_options)) or result = retrieve_new_catalog(query_options)
-      if ! Puppet[:usecacheonfailure]
-        Puppet.warning "Not using cache on failed catalog"
-        return nil
+    if (Puppet[:use_cached_catalog] && result = retrieve_catalog_from_cache(query_options))
+      @cached_catalog_status = 'explicitly_requested'
+
+      Puppet.info _("Using cached catalog from environment '%{environment}'") % { environment: result.environment }
+    else
+      result = retrieve_new_catalog(query_options)
+
+      if !result
+        if !Puppet[:usecacheonfailure]
+          Puppet.warning _("Not using cache on failed catalog")
+          return nil
+        end
+
+        result = retrieve_catalog_from_cache(query_options)
+
+        if result
+          # don't use use cached catalog if it doesn't match server specified environment
+          if @node_environment && result.environment != @environment
+            Puppet.err _("Not using cached catalog because its environment '%{catalog_env}' does not match '%{local_env}'") % { catalog_env: result.environment, local_env: @environment }
+            return nil
+          end
+
+          @cached_catalog_status = 'on_failure'
+          Puppet.info _("Using cached catalog from environment '%{catalog_env}'") % { catalog_env: result.environment }
+        end
       end
-      result = retrieve_catalog_from_cache(query_options)
     end
 
-    return nil unless result
-
-    convert_catalog(result, @duration)
+    result
   end
 
   # Convert a plain resource catalog into our full host catalog.
@@ -102,22 +133,42 @@ class Puppet::Configurer
   def prepare_and_retrieve_catalog(options, query_options)
     # set report host name now that we have the fact
     options[:report].host = Puppet[:node_name_value]
+    query_options[:transaction_uuid] = @transaction_uuid
+    query_options[:job_id] = @job_id
+    query_options[:static_catalog] = @static_catalog
+
+    # Query params don't enforce ordered evaluation, so munge this list into a
+    # dot-separated string.
+    query_options[:checksum_type] = @checksum_type.join('.')
 
-    unless catalog = (options.delete(:catalog) || retrieve_catalog(query_options))
-      Puppet.err "Could not retrieve catalog; skipping run"
-      return
+    # apply passes in ral catalog
+    catalog = options.delete(:catalog)
+    return catalog if catalog
+
+    # retrieve_catalog returns json catalog
+    catalog = retrieve_catalog(query_options)
+    return convert_catalog(catalog, @duration) if catalog
+
+    Puppet.err _("Could not retrieve catalog; skipping run")
+    nil
+  end
+
+  def prepare_and_retrieve_catalog_from_cache
+    result = retrieve_catalog_from_cache({:transaction_uuid => @transaction_uuid, :static_catalog => @static_catalog})
+    if result
+      Puppet.info _("Using cached catalog from environment '%{catalog_env}'") % { catalog_env: result.environment }
+      return convert_catalog(result, @duration)
     end
-    catalog
+    nil
   end
 
-  # Retrieve (optionally) and apply a catalog. If a catalog is passed in
-  # the options, then apply that one, otherwise retrieve it.
+  # Apply supplied catalog and return associated application report
   def apply_catalog(catalog, options)
     report = options[:report]
     begin
       report.configuration_version = catalog.version
 
-      benchmark(:notice, "Applied catalog") do
+      benchmark(:notice, _("Applied catalog")) do
         catalog.apply(options)
       end
     ensure
@@ -131,9 +182,45 @@ class Puppet::Configurer
   # which accepts :tags and :ignoreschedules.
   def run(options = {})
     pool = Puppet::Network::HTTP::Pool.new(Puppet[:http_keepalive_timeout])
+    # We create the report pre-populated with default settings for
+    # environment and transaction_uuid very early, this is to ensure
+    # they are sent regardless of any catalog compilation failures or
+    # exceptions.
+    options[:report] ||= Puppet::Transaction::Report.new(nil, @environment, @transaction_uuid, @job_id)
+    report = options[:report]
+    init_storage
+
+    Puppet::Util::Log.newdestination(report)
+
     begin
       Puppet.override(:http_pool => pool) do
-        run_internal(options)
+
+        # Skip failover logic if the server_list setting is empty
+        if Puppet.settings[:server_list].nil? || Puppet.settings[:server_list].empty?
+          do_failover = false;
+        else
+          do_failover = true
+        end
+        # When we are passed a catalog, that means we're in apply
+        # mode. We shouldn't try to do any failover in that case.
+        if options[:catalog].nil? && do_failover
+          found = find_functional_server()
+          server = found[:server]
+          if server.nil?
+            Puppet.warning _("Could not select a functional puppet master")
+            server = [nil, nil]
+          end
+          Puppet.override(:server => server[0], :serverport => server[1]) do
+            if !server.first.nil?
+              Puppet.debug "Selected master: #{server[0]}:#{server[1]}"
+              report.master_used = "#{server[0]}:#{server[1]}"
+            end
+
+            run_internal(options.merge(:node => found[:node]))
+          end
+        else
+          run_internal(options)
+        end
       end
     ensure
       pool.close
@@ -141,26 +228,43 @@ class Puppet::Configurer
   end
 
   def run_internal(options)
-    # We create the report pre-populated with default settings for
-    # environment and transaction_uuid very early, this is to ensure
-    # they are sent regardless of any catalog compilation failures or
-    # exceptions.
-    options[:report] ||= Puppet::Transaction::Report.new("apply", nil, @environment, @transaction_uuid)
     report = options[:report]
-    init_storage
 
-    Puppet::Util::Log.newdestination(report)
+    # If a cached catalog is explicitly requested, attempt to retrieve it. Skip the node request,
+    # don't pluginsync and switch to the catalog's environment if we successfully retrieve it.
+    if Puppet[:use_cached_catalog]
+      if catalog = prepare_and_retrieve_catalog_from_cache
+        options[:catalog] = catalog
+        @cached_catalog_status = 'explicitly_requested'
+
+        if @environment != catalog.environment && !Puppet[:strict_environment_mode]
+          Puppet.notice _("Local environment: '%{local_env}' doesn't match the environment of the cached catalog '%{catalog_env}', switching agent to '%{catalog_env}'.") % { local_env: @environment, catalog_env: catalog.environment }
+          @environment = catalog.environment
+        end
+
+        report.environment = @environment
+      else
+        # Don't try to retrieve a catalog from the cache again after we've already
+        # failed to do so the first time.
+        Puppet[:use_cached_catalog] = false
+        Puppet[:usecacheonfailure] = false
+        options[:pluginsync] = Puppet::Configurer.should_pluginsync?
+      end
+    end
 
     begin
       unless Puppet[:node_name_fact].empty?
         query_options = get_facts(options)
       end
 
+      configured_environment = Puppet[:environment] if Puppet.settings.set_by_config?(:environment)
+
       # We only need to find out the environment to run in if we don't already have a catalog
-      unless options[:catalog]
+      unless (options[:catalog] || Puppet[:strict_environment_mode])
         begin
-          if node = Puppet::Node.indirection.find(Puppet[:node_name_value],
+          if node = options[:node] || Puppet::Node.indirection.find(Puppet[:node_name_value],
               :environment => Puppet::Node::Environment.remote(@environment),
+              :configured_environment => configured_environment,
               :ignore_cache => true,
               :transaction_uuid => @transaction_uuid,
               :fail_on_404 => true)
@@ -171,15 +275,19 @@ class Puppet::Configurer
               node.environment = Puppet::Node::Environment.remote(node.environment_name)
             end
 
+            @node_environment = node.environment.to_s
+
             if node.environment.to_s != @environment
-              Puppet.warning "Local environment: \"#{@environment}\" doesn't match server specified node environment \"#{node.environment}\", switching agent to \"#{node.environment}\"."
+              Puppet.notice _("Local environment: '%{local_env}' doesn't match server specified node environment '%{node_env}', switching agent to '%{node_env}'.") % { local_env: @environment, node_env: node.environment }
               @environment = node.environment.to_s
               report.environment = @environment
               query_options = nil
+            else
+              Puppet.info _("Using configured environment '%{env}'") % { env: @environment }
             end
           end
         rescue StandardError => detail
-          Puppet.warning("Unable to fetch my node definition, but the agent run will continue:")
+          Puppet.warning(_("Unable to fetch my node definition, but the agent run will continue:"))
           Puppet.warning(detail)
         end
       end
@@ -197,12 +305,17 @@ class Puppet::Configurer
       Puppet.push_context({:current_environment => local_node_environment}, "Local node environment for configurer transaction")
 
       query_options = get_facts(options) unless query_options
-      query_options[:transaction_uuid] = @transaction_uuid
+      query_options[:configured_environment] = configured_environment
 
       unless catalog = prepare_and_retrieve_catalog(options, query_options)
         return nil
       end
 
+      if Puppet[:strict_environment_mode] && catalog.environment != @environment
+        Puppet.err _("Not using catalog because its environment '%{catalog_env}' does not match agent specified environment '%{local_env}' and strict_environment_mode is set") % { catalog_env: catalog.environment, local_env: @environment }
+        return nil
+      end
+
       # Here we set the local environment based on what we get from the
       # catalog. Since a change in environment means a change in facts, and
       # facts may be used to determine which catalog we get, we need to
@@ -210,46 +323,75 @@ class Puppet::Configurer
       tries = 0
       while catalog.environment and not catalog.environment.empty? and catalog.environment != @environment
         if tries > 3
-          raise Puppet::Error, "Catalog environment didn't stabilize after #{tries} fetches, aborting run"
+          raise Puppet::Error, _("Catalog environment didn't stabilize after %{tries} fetches, aborting run") % { tries: tries }
         end
-        Puppet.warning "Local environment: \"#{@environment}\" doesn't match server specified environment \"#{catalog.environment}\", restarting agent run with environment \"#{catalog.environment}\""
+        Puppet.notice _("Local environment: '%{local_env}' doesn't match server specified environment '%{catalog_env}', restarting agent run with environment '%{catalog_env}'") % { local_env: @environment, catalog_env: catalog.environment }
         @environment = catalog.environment
         report.environment = @environment
 
         query_options = get_facts(options)
-        query_options[:transaction_uuid] = @transaction_uuid
+        query_options[:configured_environment] = configured_environment
 
         return nil unless catalog = prepare_and_retrieve_catalog(options, query_options)
         tries += 1
       end
 
       execute_prerun_command or return nil
+
+      options[:report].code_id = catalog.code_id
+      options[:report].catalog_uuid = catalog.catalog_uuid
+      options[:report].cached_catalog_status = @cached_catalog_status
       apply_catalog(catalog, options)
       report.exit_status
     rescue => detail
-      Puppet.log_exception(detail, "Failed to apply catalog: #{detail}")
+      Puppet.log_exception(detail, _("Failed to apply catalog: %{detail}") % { detail: detail })
       return nil
     ensure
       execute_postrun_command or return nil
     end
   ensure
-    # Between Puppet runs we need to forget the cached values.  This lets us
-    # pick up on new functions installed by gems or new modules being added
-    # without the daemon being restarted.
-    $env_module_directories = nil
-
+    report.cached_catalog_status ||= @cached_catalog_status
     Puppet::Util::Log.close(report)
     send_report(report)
     Puppet.pop_context
   end
   private :run_internal
 
+  def find_functional_server()
+    configured_environment = Puppet[:environment] if Puppet.settings.set_by_config?(:environment)
+
+    node = nil
+    selected_server = Puppet.settings[:server_list].find do |server|
+      # Puppet.override doesn't return the result of its block, so we
+      # need to handle this manually
+      found = false
+      server[1] ||= Puppet[:masterport]
+      Puppet.override(:server => server[0], :serverport => server[1]) do
+        begin
+          node = Puppet::Node.indirection.find(Puppet[:node_name_value],
+              :environment => Puppet::Node::Environment.remote(@environment),
+              :configured_environment => configured_environment,
+              :ignore_cache => true,
+              :transaction_uuid => @transaction_uuid,
+              :fail_on_404 => false)
+          found = true
+        rescue Exception => e
+          # Nothing to see here
+        end
+      end
+      found
+    end
+    { :node => node,
+      :server => selected_server }
+  end
+  private :find_functional_server
+
   def send_report(report)
     puts report.summary if Puppet[:summarize]
     save_last_run_summary(report)
     Puppet::Transaction::Report.indirection.save(report, nil, :environment => Puppet::Node::Environment.remote(@environment)) if Puppet[:report]
   rescue => detail
-    Puppet.log_exception(detail, "Could not send report: #{detail}")
+    Puppet.log_exception(detail, _("Could not send report: %{detail}") % { detail: detail })
   end
 
   def save_last_run_summary(report)
@@ -258,7 +400,7 @@ class Puppet::Configurer
       fh.print YAML.dump(report.raw_summary)
     end
   rescue => detail
-    Puppet.log_exception(detail, "Could not save last run local report: #{detail}")
+    Puppet.log_exception(detail, _("Could not save last run local report: %{detail}") % { detail: detail })
   end
 
   private
@@ -270,7 +412,7 @@ class Puppet::Configurer
       Puppet::Util::Execution.execute([command])
       true
     rescue => detail
-      Puppet.log_exception(detail, "Could not run command from #{setting}: #{detail}")
+      Puppet.log_exception(detail, _("Could not run command from %{setting}: %{detail}") % { setting: setting, detail: detail })
       false
     end
   end
@@ -281,10 +423,9 @@ class Puppet::Configurer
       result = Puppet::Resource::Catalog.indirection.find(Puppet[:node_name_value],
         query_options.merge(:ignore_terminus => true, :environment => Puppet::Node::Environment.remote(@environment)))
     end
-    Puppet.notice "Using cached catalog"
     result
   rescue => detail
-    Puppet.log_exception(detail, "Could not retrieve catalog from cache: #{detail}")
+    Puppet.log_exception(detail, _("Could not retrieve catalog from cache: %{detail}") % { detail: detail })
     return nil
   end
 
@@ -296,7 +437,7 @@ class Puppet::Configurer
     end
     result
   rescue StandardError => detail
-    Puppet.log_exception(detail, "Could not retrieve catalog from remote server: #{detail}")
+    Puppet.log_exception(detail, _("Could not retrieve catalog from remote server: %{detail}") % { detail: detail })
     return nil
   end
 

data/lib/puppet/context/trusted_information.rb

@@ -17,17 +17,35 @@ class Puppet::Context::TrustedInformation
   # @return [Hash{Object => Object}]
   attr_reader :extensions
 
+  # The domain name derived from the validated certificate name
+  #
+  # @return [String]
+  attr_reader :domain
+
+  # The hostname derived from the validated certificate name
+  #
+  # @return [String]
+  attr_reader :hostname
+
   def initialize(authenticated, certname, extensions)
     @authenticated = authenticated.freeze
     @certname = certname.freeze
     @extensions = extensions.freeze
+    if @certname
+      hostname, domain = @certname.split('.', 2)
+    else
+      hostname = nil
+      domain = nil
+    end
+    @hostname = hostname.freeze
+    @domain = domain.freeze
   end
 
   def self.remote(authenticated, node_name, certificate)
     if authenticated
       extensions = {}
       if certificate.nil?
-        Puppet.info('TrustedInformation expected a certificate, but none was given.')
+        Puppet.info(_('TrustedInformation expected a certificate, but none was given.'))
       else
         extensions = Hash[certificate.custom_extensions.collect do |ext|
           [ext['oid'].freeze, ext['value'].freeze]
@@ -50,7 +68,9 @@ class Puppet::Context::TrustedInformation
     {
       'authenticated'.freeze => authenticated,
       'certname'.freeze => certname,
-      'extensions'.freeze => extensions
+      'extensions'.freeze => extensions,
+      'hostname'.freeze => hostname,
+      'domain'.freeze => domain,
     }.freeze
   end
 end