puppet 8.5.0-x64-mingw32 → 8.6.0-x64-mingw32

data/lib/puppet/application/device.rb

@@ -263,115 +263,114 @@ class Puppet::Application::Device < Puppet::Application
       end
       devices.collect do |_devicename, device|
         # TODO when we drop support for ruby < 2.5 we can remove the extra block here
-        begin
-          device_url = URI.parse(device.url)
-          # Handle nil scheme & port
-          scheme = "#{device_url.scheme}://" if device_url.scheme
-          port = ":#{device_url.port}" if device_url.port
-
-          # override local $vardir and $certname
-          Puppet[:ssldir] = ::File.join(Puppet[:deviceconfdir], device.name, 'ssl')
-          Puppet[:confdir] = ::File.join(Puppet[:devicedir], device.name)
-          Puppet[:libdir] = options[:libdir] || ::File.join(Puppet[:devicedir], device.name, 'lib')
-          Puppet[:vardir] = ::File.join(Puppet[:devicedir], device.name)
-          Puppet[:certname] = device.name
-          ssl_context = nil
-
-          # create device directory under $deviceconfdir
-          Puppet::FileSystem.dir_mkpath(Puppet[:ssldir]) unless Puppet::FileSystem.dir_exist?(Puppet[:ssldir])
-
-          # this will reload and recompute default settings and create device-specific sub vardir
-          Puppet.settings.use :main, :agent, :ssl
-
-          # Workaround for PUP-8736: store ssl certs outside the cache directory to prevent accidental removal and keep the old path as symlink
-          optssldir = File.join(Puppet[:confdir], 'ssl')
-          Puppet::FileSystem.symlink(Puppet[:ssldir], optssldir) unless Puppet::FileSystem.exist?(optssldir)
-
-          unless options[:resource] || options[:facts] || options[:apply]
-            # Since it's too complicated to fix properly in the default settings, we workaround for PUP-9642 here.
-            # See https://github.com/puppetlabs/puppet/pull/7483#issuecomment-483455997 for details.
-            # This has to happen after `settings.use` above, so the directory is created and before `setup_host` below, where the SSL
-            # routines would fail with access errors
-            if Puppet.features.root? && !Puppet::Util::Platform.windows?
-              user = Puppet::Type.type(:user).new(name: Puppet[:user]).exists? ? Puppet[:user] : nil
-              group = Puppet::Type.type(:group).new(name: Puppet[:group]).exists? ? Puppet[:group] : nil
-              Puppet.debug("Fixing perms for #{user}:#{group} on #{Puppet[:confdir]}")
-              FileUtils.chown(user, group, Puppet[:confdir]) if user || group
-            end
 
-            ssl_context = setup_context
+        device_url = URI.parse(device.url)
+        # Handle nil scheme & port
+        scheme = "#{device_url.scheme}://" if device_url.scheme
+        port = ":#{device_url.port}" if device_url.port
+
+        # override local $vardir and $certname
+        Puppet[:ssldir] = ::File.join(Puppet[:deviceconfdir], device.name, 'ssl')
+        Puppet[:confdir] = ::File.join(Puppet[:devicedir], device.name)
+        Puppet[:libdir] = options[:libdir] || ::File.join(Puppet[:devicedir], device.name, 'lib')
+        Puppet[:vardir] = ::File.join(Puppet[:devicedir], device.name)
+        Puppet[:certname] = device.name
+        ssl_context = nil
+
+        # create device directory under $deviceconfdir
+        Puppet::FileSystem.dir_mkpath(Puppet[:ssldir]) unless Puppet::FileSystem.dir_exist?(Puppet[:ssldir])
+
+        # this will reload and recompute default settings and create device-specific sub vardir
+        Puppet.settings.use :main, :agent, :ssl
+
+        # Workaround for PUP-8736: store ssl certs outside the cache directory to prevent accidental removal and keep the old path as symlink
+        optssldir = File.join(Puppet[:confdir], 'ssl')
+        Puppet::FileSystem.symlink(Puppet[:ssldir], optssldir) unless Puppet::FileSystem.exist?(optssldir)
+
+        unless options[:resource] || options[:facts] || options[:apply]
+          # Since it's too complicated to fix properly in the default settings, we workaround for PUP-9642 here.
+          # See https://github.com/puppetlabs/puppet/pull/7483#issuecomment-483455997 for details.
+          # This has to happen after `settings.use` above, so the directory is created and before `setup_host` below, where the SSL
+          # routines would fail with access errors
+          if Puppet.features.root? && !Puppet::Util::Platform.windows?
+            user = Puppet::Type.type(:user).new(name: Puppet[:user]).exists? ? Puppet[:user] : nil
+            group = Puppet::Type.type(:group).new(name: Puppet[:group]).exists? ? Puppet[:group] : nil
+            Puppet.debug("Fixing perms for #{user}:#{group} on #{Puppet[:confdir]}")
+            FileUtils.chown(user, group, Puppet[:confdir]) if user || group
+          end
+
+          ssl_context = setup_context
 
-            unless options[:libdir]
-              Puppet.override(ssl_context: ssl_context) do
-                Puppet::Configurer::PluginHandler.new.download_plugins(env) if Puppet::Configurer.should_pluginsync?
-              end
+          unless options[:libdir]
+            Puppet.override(ssl_context: ssl_context) do
+              Puppet::Configurer::PluginHandler.new.download_plugins(env) if Puppet::Configurer.should_pluginsync?
             end
           end
+        end
 
-          # this inits the device singleton, so that the facts terminus
-          # and the various network_device provider can use it
-          Puppet::Util::NetworkDevice.init(device)
-
-          if options[:resource]
-            type, name = parse_args(command_line.args)
-            Puppet.info _("retrieving resource: %{resource} from %{target} at %{scheme}%{url_host}%{port}%{url_path}") % { resource: type, target: device.name, scheme: scheme, url_host: device_url.host, port: port, url_path: device_url.path }
-            resources = find_resources(type, name)
-            if options[:to_yaml]
-              data = resources.map do |resource|
-                resource.prune_parameters(:parameters_to_include => @extra_params).to_hiera_hash
-              end.inject(:merge!)
-              text = YAML.dump(type.downcase => data)
-            else
-              text = resources.map do |resource|
-                resource.prune_parameters(:parameters_to_include => @extra_params).to_manifest.force_encoding(Encoding.default_external)
-              end.join("\n")
-            end
-            (puts text)
-            0
-          elsif options[:facts]
-            Puppet.info _("retrieving facts from %{target} at %{scheme}%{url_host}%{port}%{url_path}") % { resource: type, target: device.name, scheme: scheme, url_host: device_url.host, port: port, url_path: device_url.path }
-            remote_facts = Puppet::Node::Facts.indirection.find(name, :environment => env)
-            # Give a proper name to the facts
-            remote_facts.name = remote_facts.values['clientcert']
-            renderer = Puppet::Network::FormatHandler.format(:console)
-            puts renderer.render(remote_facts)
-            0
-          elsif options[:apply]
-            # avoid reporting to server
-            Puppet::Transaction::Report.indirection.terminus_class = :yaml
-            Puppet::Resource::Catalog.indirection.cache_class = nil
-
-            require_relative '../../puppet/application/apply'
-            begin
-              Puppet[:node_terminus] = :plain
-              Puppet[:catalog_terminus] = :compiler
-              Puppet[:catalog_cache_terminus] = nil
-              Puppet[:facts_terminus] = :network_device
-              Puppet.override(:network_device => true) do
-                Puppet::Application::Apply.new(Puppet::Util::CommandLine.new('puppet', ["apply", options[:apply]])).run_command
-              end
-            end
+        # this inits the device singleton, so that the facts terminus
+        # and the various network_device provider can use it
+        Puppet::Util::NetworkDevice.init(device)
+
+        if options[:resource]
+          type, name = parse_args(command_line.args)
+          Puppet.info _("retrieving resource: %{resource} from %{target} at %{scheme}%{url_host}%{port}%{url_path}") % { resource: type, target: device.name, scheme: scheme, url_host: device_url.host, port: port, url_path: device_url.path }
+          resources = find_resources(type, name)
+          if options[:to_yaml]
+            data = resources.map do |resource|
+              resource.prune_parameters(:parameters_to_include => @extra_params).to_hiera_hash
+            end.inject(:merge!)
+            text = YAML.dump(type.downcase => data)
           else
-            Puppet.info _("starting applying configuration to %{target} at %{scheme}%{url_host}%{port}%{url_path}") % { target: device.name, scheme: scheme, url_host: device_url.host, port: port, url_path: device_url.path }
-
-            overrides = {}
-            overrides[:ssl_context] = ssl_context if ssl_context
-            Puppet.override(overrides) do
-              configurer = Puppet::Configurer.new
-              configurer.run(:network_device => true, :pluginsync => false)
+            text = resources.map do |resource|
+              resource.prune_parameters(:parameters_to_include => @extra_params).to_manifest.force_encoding(Encoding.default_external)
+            end.join("\n")
+          end
+          (puts text)
+          0
+        elsif options[:facts]
+          Puppet.info _("retrieving facts from %{target} at %{scheme}%{url_host}%{port}%{url_path}") % { resource: type, target: device.name, scheme: scheme, url_host: device_url.host, port: port, url_path: device_url.path }
+          remote_facts = Puppet::Node::Facts.indirection.find(name, :environment => env)
+          # Give a proper name to the facts
+          remote_facts.name = remote_facts.values['clientcert']
+          renderer = Puppet::Network::FormatHandler.format(:console)
+          puts renderer.render(remote_facts)
+          0
+        elsif options[:apply]
+          # avoid reporting to server
+          Puppet::Transaction::Report.indirection.terminus_class = :yaml
+          Puppet::Resource::Catalog.indirection.cache_class = nil
+
+          require_relative '../../puppet/application/apply'
+          begin
+            Puppet[:node_terminus] = :plain
+            Puppet[:catalog_terminus] = :compiler
+            Puppet[:catalog_cache_terminus] = nil
+            Puppet[:facts_terminus] = :network_device
+            Puppet.override(:network_device => true) do
+              Puppet::Application::Apply.new(Puppet::Util::CommandLine.new('puppet', ["apply", options[:apply]])).run_command
             end
           end
-        rescue => detail
-          Puppet.log_exception(detail)
-          # If we rescued an error, then we return 1 as the exit code
-          1
-        ensure
-          Puppet[:libdir] = libdir
-          Puppet[:vardir] = vardir
-          Puppet[:confdir] = confdir
-          Puppet[:ssldir] = ssldir
-          Puppet[:certname] = certname
+        else
+          Puppet.info _("starting applying configuration to %{target} at %{scheme}%{url_host}%{port}%{url_path}") % { target: device.name, scheme: scheme, url_host: device_url.host, port: port, url_path: device_url.path }
+
+          overrides = {}
+          overrides[:ssl_context] = ssl_context if ssl_context
+          Puppet.override(overrides) do
+            configurer = Puppet::Configurer.new
+            configurer.run(:network_device => true, :pluginsync => false)
+          end
         end
+      rescue => detail
+        Puppet.log_exception(detail)
+        # If we rescued an error, then we return 1 as the exit code
+        1
+      ensure
+        Puppet[:libdir] = libdir
+        Puppet[:vardir] = vardir
+        Puppet[:confdir] = confdir
+        Puppet[:ssldir] = ssldir
+        Puppet[:certname] = certname
       end
     end
 

data/lib/puppet/application/doc.rb

@@ -122,7 +122,7 @@ class Puppet::Application::Doc < Puppet::Application
   end
 
   def run_command
-    return [:rdoc].include?(options[:mode]) ? send(options[:mode]) : other
+    [:rdoc].include?(options[:mode]) ? send(options[:mode]) : other
   end
 
   def rdoc

data/lib/puppet/application/face_base.rb

@@ -74,7 +74,7 @@ class Puppet::Application::FaceBase < Puppet::Application
     # non-option word to use as the action.
     action_name = nil
     index       = -1
-    until action_name or (index += 1) >= command_line.args.length do
+    until action_name or (index += 1) >= command_line.args.length
       item = command_line.args[index]
       if item =~ /^-/
         option = @face.options.find do |name|
@@ -88,7 +88,7 @@ class Puppet::Application::FaceBase < Puppet::Application
           # when we get there. --daniel 2011-04-04
           if option.takes_argument? and !item.index('=')
             index += 1 unless
-              (option.optional_argument? and command_line.args[index + 1] =~ /^-/)
+              option.optional_argument? and command_line.args[index + 1] =~ /^-/
           end
         else
           option = find_global_settings_argument(item)
@@ -103,9 +103,9 @@ class Puppet::Application::FaceBase < Puppet::Application
           else
             option = find_application_argument(item)
             if option
-              index += 1 if (option[:argument] and not option[:optional])
+              index += 1 if option[:argument] and !(option[:optional])
             else
-              raise OptionParser::InvalidOption.new(item.sub(/=.*$/, ''))
+              raise OptionParser::InvalidOption, item.sub(/=.*$/, '')
             end
           end
         end
@@ -164,7 +164,7 @@ class Puppet::Application::FaceBase < Puppet::Application
         pattern.match item and return object
       end
     end
-    return nil                  # nothing found.
+    nil                  # nothing found.
   end
 
   def find_application_argument(item)
@@ -181,7 +181,7 @@ class Puppet::Application::FaceBase < Puppet::Application
         }
       end
     end
-    return nil                  # not found
+    nil                  # not found
   end
 
   def setup
@@ -205,7 +205,7 @@ class Puppet::Application::FaceBase < Puppet::Application
     @arguments << options
 
     # If we don't have a rendering format, set one early.
-    self.render_as ||= (@action.render_as || :console)
+    self.render_as ||= @action.render_as || :console
   end
 
   def main

data/lib/puppet/application/filebucket.rb

@@ -213,7 +213,7 @@ class Puppet::Application::Filebucket < Puppet::Application
   def run_command
     @args = command_line.args
     command = args.shift
-    return send(command) if %w{get backup restore diff list}.include? command
+    return send(command) if %w[get backup restore diff list].include? command
 
     help
   end

data/lib/puppet/application/lookup.rb

@@ -8,7 +8,7 @@ require_relative '../../puppet/parser/compiler'
 class Puppet::Application::Lookup < Puppet::Application
   RUN_HELP = _("Run 'puppet lookup --help' for more details").freeze
   DEEP_MERGE_OPTIONS = '--knock-out-prefix, --sort-merged-arrays, and --merge-hash-arrays'
-  TRUSTED_INFORMATION_FACTS = ["hostname", "domain", "fqdn", "clientcert"].freeze
+  TRUSTED_INFORMATION_FACTS = %w[hostname domain fqdn clientcert].freeze
 
   run_mode :server
 
@@ -354,7 +354,7 @@ class Puppet::Application::Lookup < Puppet::Application
         given_facts = Puppet::Util::Yaml.safe_load_file(fact_file)
       else
         given_facts = Puppet::Util::Json.load_file_if_valid(fact_file)
-        given_facts = Puppet::Util::Yaml.safe_load_file_if_valid(fact_file) unless given_facts
+        given_facts ||= Puppet::Util::Yaml.safe_load_file_if_valid(fact_file)
       end
 
       unless given_facts.instance_of?(Hash)
@@ -369,7 +369,9 @@ class Puppet::Application::Lookup < Puppet::Application
       end
     end
 
-    unless node.is_a?(Puppet::Node) # to allow unit tests to pass a node instance
+    if node.is_a?(Puppet::Node)
+      node.add_extra_facts(given_facts) if given_facts
+    else # to allow unit tests to pass a node instance
       facts = retrieve_node_facts(node, given_facts)
       ni = Puppet::Node.indirection
       tc = ni.terminus_class
@@ -399,8 +401,6 @@ class Puppet::Application::Lookup < Puppet::Application
         node = ni.find(node, facts: facts, environment: Puppet[:environment])
         ni.terminus_class = tc
       end
-    else
-      node.add_extra_facts(given_facts) if given_facts
     end
     node.environment = Puppet[:environment] if Puppet.settings.set_by_cli?(:environment)
     Puppet[:code] = 'undef' unless options[:compile]

data/lib/puppet/application/resource.rb

@@ -15,6 +15,7 @@ class Puppet::Application::Resource < Puppet::Application
   option("--verbose", "-v")
   option("--edit", "-e")
   option("--to_yaml", "-y")
+  option('--fail', '-f')
 
   option("--types", "-t") do |_arg|
     env = Puppet.lookup(:environments).get(Puppet[:environment]) || create_default_environment
@@ -109,6 +110,9 @@ class Puppet::Application::Resource < Puppet::Application
         Output found resources in yaml format, suitable to use with Hiera and
         create_resources.
 
+      * --fail:
+        Fails and returns an exit code of 1 if the resource could not be modified.
+
       EXAMPLE
       -------
       This example uses `puppet resource` to return a Puppet configuration for
@@ -207,7 +211,7 @@ class Puppet::Application::Resource < Puppet::Application
     params = {}
     args.each do |setting|
       if setting =~ /^(\w+)=(.+)$/
-        params[$1] = $2
+        params[::Regexp.last_match(1)] = ::Regexp.last_match(2)
       else
         raise _("Invalid parameter setting %{setting}") % { setting: setting }
       end
@@ -236,8 +240,11 @@ class Puppet::Application::Resource < Puppet::Application
           resource = Puppet::Resource.new(type, name, :parameters => params)
 
           # save returns [resource that was saved, transaction log from applying the resource]
-          save_result = Puppet::Resource.indirection.save(resource, key)
-          [save_result.first]
+          save_result, report = Puppet::Resource.indirection.save(resource, key)
+          status = report.resource_statuses[resource.ref]
+          raise "Failed to manage resource #{resource.ref}" if status&.failed? && options[:fail]
+
+          [save_result]
         end
       else
         if type == "file"

data/lib/puppet/application/ssl.rb

@@ -160,7 +160,7 @@ class Puppet::Application::Ssl < Puppet::Application
 
       clean(certname)
     when 'bootstrap'
-      if !Puppet::Util::Log.sendlevel?(:info)
+      unless Puppet::Util::Log.sendlevel?(:info)
         Puppet::Util::Log.level = :info
       end
       @machine.ensure_client_certificate
@@ -192,7 +192,7 @@ class Puppet::Application::Ssl < Puppet::Application
     Puppet.notice _("Submitted certificate request for '%{name}' to %{url}") % { name: Puppet[:certname], url: route.url }
   rescue Puppet::HTTP::ResponseError => e
     if e.response.code == 400
-      raise Puppet::Error.new(_("Could not submit certificate request for '%{name}' to %{url} due to a conflict on the server") % { name: Puppet[:certname], url: route.url })
+      raise Puppet::Error, _("Could not submit certificate request for '%{name}' to %{url} due to a conflict on the server") % { name: Puppet[:certname], url: route.url }
     else
       raise Puppet::Error.new(_("Failed to submit certificate request: %{message}") % { message: e.message }, e)
     end
@@ -234,7 +234,7 @@ class Puppet::Application::Ssl < Puppet::Application
     cert
   rescue Puppet::HTTP::ResponseError => e
     if e.response.code == 404
-      return nil
+      nil
     else
       raise Puppet::Error.new(_("Failed to download certificate: %{message}") % { message: e.message }, e)
     end

data/lib/puppet/application.rb

@@ -180,14 +180,14 @@ class Application
     def option(*options, &block)
       long = options.find { |opt| opt =~ /^--/ }.gsub(/^--(?:\[no-\])?([^ =]+).*$/, '\1').tr('-', '_')
       fname = "handle_#{long}".intern
-      if (block_given?)
+      if block_given?
         define_method(fname, &block)
       else
         define_method(fname) do |value|
-          self.options["#{long}".to_sym] = value
+          self.options[long.to_s.to_sym] = value
         end
       end
-      self.option_parser_commands << [options, fname]
+      option_parser_commands << [options, fname]
     end
 
     def banner(banner = nil)
@@ -242,7 +242,7 @@ class Application
       ####  eventually we need to issue a deprecation warning here,
       ####  and then get rid of this stanza in a subsequent release.
       ################################################################
-      if (clazz.nil?)
+      if clazz.nil?
         class_name = application_name.capitalize
         clazz = try_load_class(class_name)
       end
@@ -251,17 +251,17 @@ class Application
       ################################################################
 
       if clazz.nil?
-        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 })
+        raise Puppet::Error, _("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
+      clazz
     end
 
     # Given the fully qualified name of a class, attempt to get the class instance.
     # @param [String] class_name the fully qualified name of the class to try to load
     # @return [Class] the Class instance, or nil? if it could not be loaded.
     def try_load_class(class_name)
-      return self.const_defined?(class_name) ? const_get(class_name) : nil
+      const_defined?(class_name) ? const_get(class_name) : nil
     end
     private :try_load_class
 
@@ -284,7 +284,7 @@ class Application
         Puppet.settings.preferred_run_mode = mode_name
       end
 
-      return @run_mode if @run_mode and not mode_name
+      return @run_mode if @run_mode and !mode_name
 
       require_relative '../puppet/util/run_mode'
       @run_mode = Puppet::Util::RunMode[mode_name || Puppet.settings.preferred_run_mode]
@@ -330,7 +330,7 @@ class Application
   # See also `lib/puppet/util/command_line.rb` for some special case early
   # handling of this.
   option("--version", "-V") do |_arg|
-    puts "#{Puppet.version}"
+    puts Puppet.version
     exit(0)
   end
 
@@ -452,7 +452,7 @@ class Application
   # @return [void]
   # @api public
   def setup_logs
-    handle_logdest_arg(Puppet[:logdest]) if !options[:setdest]
+    handle_logdest_arg(Puppet[:logdest]) unless options[:setdest]
 
     unless options[:setdest]
       if options[:debug] || options[:verbose]
@@ -481,12 +481,10 @@ class Application
     Puppet[:logdest] = arg
 
     logdest.each do |dest|
-      begin
-        Puppet::Util::Log.newdestination(dest)
-        options[:setdest] = true
-      rescue => detail
-        Puppet.log_and_raise(detail, _("Could not set logdest to %{dest}.") % { dest: arg })
-      end
+      Puppet::Util::Log.newdestination(dest)
+      options[:setdest] = true
+    rescue => detail
+      Puppet.log_and_raise(detail, _("Could not set logdest to %{dest}.") % { dest: arg })
     end
   end
 
@@ -555,14 +553,14 @@ class Application
     self.class.option_parser_commands.each do |options, fname|
       option_parser.on(*options) do |value|
         # Call the method that "option()" created.
-        self.send(fname, value)
+        send(fname, value)
       end
     end
 
     # Scan command line.  We just hand any exceptions to our upper levels,
     # rather than printing help and exiting, so that we can meaningfully
     # respond with context-sensitive help if we want to. --daniel 2011-04-12
-    option_parser.parse!(self.command_line.args)
+    option_parser.parse!(command_line.args)
   end
 
   def handlearg(opt, val)

data/lib/puppet/coercion.rb

@@ -37,6 +37,6 @@ module Puppet::Coercion
   # @raise
   # @api private
   def self.boolean_values
-    ['true', 'false', 'yes', 'no']
+    %w[true false yes no]
   end
 end

data/lib/puppet/configurer/downloader.rb

@@ -20,7 +20,7 @@ class Puppet::Configurer::Downloader
           if first_failure
             event = (first_failure.events || []).first
             detail = event ? event.message : 'unknown'
-            raise Puppet::Error.new(_("Failed to retrieve %{name}: %{detail}") % { name: name, detail: detail })
+            raise Puppet::Error, _("Failed to retrieve %{name}: %{detail}") % { name: name, detail: detail }
           end
         end
 
@@ -40,7 +40,12 @@ class Puppet::Configurer::Downloader
   end
 
   def initialize(name, path, source, ignore = nil, environment = nil, source_permissions = :ignore)
-    @name, @path, @source, @ignore, @environment, @source_permissions = name, path, source, ignore, environment, source_permissions
+    @name = name
+    @path = path
+    @source = source
+    @ignore = ignore
+    @environment = environment
+    @source_permissions = source_permissions
   end
 
   def file
@@ -77,10 +82,10 @@ class Puppet::Configurer::Downloader
       :noop => false,
       :max_files => -1
     }
-    if !Puppet::Util::Platform.windows?
+    unless Puppet::Util::Platform.windows?
       defargs[:owner] = Process.uid
       defargs[:group] = Process.gid
     end
-    return defargs
+    defargs
   end
 end

data/lib/puppet/configurer/fact_handler.rb

@@ -13,20 +13,19 @@ module Puppet::Configurer::FactHandler
     # This works because puppet agent configures Facts to use 'facter' for
     # finding facts and the 'rest' terminus for caching them.  Thus, we'll
     # compile them and then "cache" them on the server.
-    begin
-      facts = Puppet::Node::Facts.indirection.find(Puppet[:node_name_value], :environment => Puppet::Node::Environment.remote(@environment))
-      unless Puppet[:node_name_fact].empty?
-        Puppet[:node_name_value] = facts.values[Puppet[:node_name_fact]]
-        facts.name = Puppet[:node_name_value]
-      end
-      facts
-    rescue SystemExit, NoMemoryError
-      raise
-    rescue Exception => detail
-      message = _("Could not retrieve local facts: %{detail}") % { detail: detail }
-      Puppet.log_exception(detail, message)
-      raise Puppet::Error, message, detail.backtrace
+
+    facts = Puppet::Node::Facts.indirection.find(Puppet[:node_name_value], :environment => Puppet::Node::Environment.remote(@environment))
+    unless Puppet[:node_name_fact].empty?
+      Puppet[:node_name_value] = facts.values[Puppet[:node_name_fact]]
+      facts.name = Puppet[:node_name_value]
     end
+    facts
+  rescue SystemExit, NoMemoryError
+    raise
+  rescue Exception => detail
+    message = _("Could not retrieve local facts: %{detail}") % { detail: detail }
+    Puppet.log_exception(detail, message)
+    raise Puppet::Error, message, detail.backtrace
   end
 
   def facts_for_uploading