bolt 0.20.0 → 0.20.2

data/vendored/puppet/lib/puppet/application/script.rb

@@ -0,0 +1,261 @@
+require 'puppet/application'
+require 'puppet/configurer'
+require 'puppet/util/profiler/aggregate'
+require 'puppet/parser/script_compiler'
+
+class Puppet::Application::Script < Puppet::Application
+
+  option("--debug","-d")
+  option("--execute EXECUTE","-e") do |arg|
+    options[:code] = arg
+  end
+  option("--test","-t")
+  option("--verbose","-v")
+
+  option("--logdest LOGDEST", "-l") do |arg|
+    handle_logdest_arg(arg)
+  end
+
+  def summary
+    _("Run a puppet manifests as a script without compiling a catalog")
+  end
+
+  def help
+    <<-HELP
+
+puppet-script(8) -- #{summary}
+========
+
+SYNOPSIS
+--------
+Runs a puppet language script without compiling a catalog.
+
+
+USAGE
+-----
+puppet script [-h|--help] [-V|--version] [-d|--debug] [-v|--verbose]
+  [-e|--execute]
+  [-l|--logdest syslog|eventlog|<FILE>|console] [--noop]
+  <file>
+
+
+DESCRIPTION
+-----------
+This is a standalone puppet script runner tool; use it to run puppet code
+without compiling a catalog.
+
+When provided with a modulepath, via command line or config file, puppet
+script can load functions, types, tasks and plans from modules.
+
+OPTIONS
+-------
+Note that any setting that's valid in the configuration
+file is also a valid long argument. For example, 'environment' is a
+valid setting, so you can specify '--environment mytest'
+as an argument.
+
+See the configuration file documentation at
+https://docs.puppetlabs.com/puppet/latest/reference/configuration.html for the
+full list of acceptable parameters. A commented list of all
+configuration options can also be generated by running puppet with
+'--genconfig'.
+
+* --debug:
+  Enable full debugging.
+
+* --help:
+  Print this help message
+
+
+* --logdest:
+  Where to send log messages. Choose between 'syslog' (the POSIX syslog
+  service), 'eventlog' (the Windows Event Log), 'console', or the path to a log
+  file. Defaults to 'console'.
+
+  A path ending with '.json' will receive structured output in JSON format. The
+  log file will not have an ending ']' automatically written to it due to the
+  appending nature of logging. It must be appended manually to make the content
+  valid JSON.
+
+* --noop:
+  Use 'noop' mode where Puppet runs in a no-op or dry-run mode. This
+  is useful for seeing what changes Puppet will make without actually
+  executing the changes. Applies to tasks only.
+
+* --execute:
+  Execute a specific piece of Puppet code
+
+* --verbose:
+  Print extra information.
+
+EXAMPLE
+-------
+    $ puppet script -l /tmp/manifest.log manifest.pp
+    $ puppet script --modulepath=/root/dev/modules -e 'notice("hello world")'
+
+
+AUTHOR
+------
+Henrik Lindberg
+
+
+COPYRIGHT
+---------
+Copyright (c) 2017 Puppet Inc., LLC Licensed under the Apache 2.0 License
+
+    HELP
+  end
+
+  def app_defaults
+    super.merge({
+      :default_file_terminus => :file_server,
+    })
+  end
+
+  def run_command
+    if Puppet.features.bolt?
+      Puppet.override(:bolt_executor => Bolt::Executor.new) do
+        main
+      end
+    else
+      raise _("Bolt must be installed to use the script application")
+    end
+  end
+
+  def main
+    # The tasks feature is always on
+    Puppet[:tasks] = true
+
+    # Set the puppet code or file to use.
+    if options[:code] || command_line.args.length == 0
+      Puppet[:code] = options[:code] || STDIN.read
+    else
+      manifest = command_line.args.shift
+      raise _("Could not find file %{manifest}") % { manifest: manifest } unless Puppet::FileSystem.exist?(manifest)
+      Puppet.warning(_("Only one file can be used per run. Skipping %{files}") % { files: command_line.args.join(', ') }) if command_line.args.size > 0
+    end
+
+    unless Puppet[:node_name_fact].empty?
+      # Collect the facts specified for that node
+      unless facts = Puppet::Node::Facts.indirection.find(Puppet[:node_name_value])
+        raise _("Could not find facts for %{node}") % { node: Puppet[:node_name_value] }
+      end
+
+      Puppet[:node_name_value] = facts.values[Puppet[:node_name_fact]]
+      facts.name = Puppet[:node_name_value]
+    end
+
+    # Find the Node
+    unless node = Puppet::Node.indirection.find(Puppet[:node_name_value])
+      raise _("Could not find node %{node}") % { node: Puppet[:node_name_value] }
+    end
+
+    configured_environment = node.environment || Puppet.lookup(:current_environment)
+
+    apply_environment = manifest ?
+      configured_environment.override_with(:manifest => manifest) :
+      configured_environment
+
+    # Modify the node descriptor to use the special apply_environment.
+    # It is based on the actual environment from the node, or the locally
+    # configured environment if the node does not specify one.
+    # If a manifest file is passed on the command line, it overrides
+    # the :manifest setting of the apply_environment.
+    node.environment = apply_environment
+
+    # TRANSLATION, the string "For puppet script" is not user facing
+    Puppet.override({:current_environment => apply_environment}, "For puppet script") do
+      # Merge in the facts.
+      node.merge(facts.values) if facts
+
+      # Add server facts so $server_facts[environment] exists when doing a puppet script
+      # SCRIPT TODO: May be needed when running scripts under orchestrator. Leave it for now.
+      #
+      node.add_server_facts({})
+
+      begin
+        # Compile the catalog
+
+        # When compiling, the compiler traps and logs certain errors
+        # Those that do not lead to an immediate exit are caught by the general
+        # rule and gets logged.
+        #
+        begin
+          # support the following features when evaluating puppet code
+          # * $facts with facts from host running the script
+          # * $settings with 'settings::*' namespace populated, and '$settings::all_local' hash
+          # * $trusted as setup when using puppet apply
+          # * an environment
+          #
+
+          # fixup trusted information
+          node.sanitize()
+
+          compiler = Puppet::Parser::ScriptCompiler.new(node.environment, node.name)
+          topscope = compiler.topscope
+
+          # When scripting the trusted data are always local, but set them anyway
+          topscope.set_trusted(node.trusted_data)
+
+          # Server facts are always about the local node's version etc.
+          topscope.set_server_facts(node.server_facts)
+
+          # Set $facts for the node running the script
+          facts_hash = node.facts.nil? ? {} : node.facts.values
+          topscope.set_facts(facts_hash)
+
+          # create the $settings:: variables
+          topscope.merge_settings(node.environment.name, false)
+
+          compiler.compile()
+
+        rescue Puppet::ParseErrorWithIssue, Puppet::Error
+          # already logged and handled by the compiler for these two cases
+          exit(1)
+        end
+
+        exit(0)
+      rescue => detail
+        Puppet.log_exception(detail)
+        exit(1)
+      end
+    end
+
+  ensure
+    if @profiler
+      Puppet::Util::Profiler.remove_profiler(@profiler)
+      @profiler.shutdown
+    end
+  end
+
+  def setup
+
+    exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
+
+    Puppet::Util::Log.newdestination(:console) unless options[:setdest]
+
+    Signal.trap(:INT) do
+      $stderr.puts _("Exiting")
+      exit(1)
+    end
+
+    # TODO: This skips applying the settings catalog for these settings, but
+    # the effect of doing this is unknown. It may be that it only works if there is a puppet
+    # installed where a settings catalog have already been applied...
+    # This saves 1/5th of the startup time
+
+#    Puppet.settings.use :main, :agent, :ssl
+
+    # When running a script, the catalog is not relevant, and neither is caching of it
+    Puppet::Resource::Catalog.indirection.cache_class = nil
+
+    # we do not want the last report to be persisted
+    Puppet::Transaction::Report.indirection.cache_class = nil
+
+    set_log_level
+
+    if Puppet[:profile]
+      @profiler = Puppet::Util::Profiler.add_profiler(Puppet::Util::Profiler::Aggregate.new(Puppet.method(:info), "script"))
+    end
+  end
+end

data/vendored/puppet/lib/puppet/application/status.rb

@@ -0,0 +1,4 @@
+require 'puppet/application/indirection_base'
+
+class Puppet::Application::Status < Puppet::Application::IndirectionBase
+end

data/vendored/puppet/lib/puppet/application_support.rb

@@ -0,0 +1,62 @@
+require 'yaml'
+
+require 'puppet'
+require 'puppet/node/environment'
+require 'puppet/file_system'
+require 'puppet/indirector'
+
+module Puppet
+  module ApplicationSupport
+
+    # Pushes a Puppet Context configured with a remote environment for an agent
+    # (one that exists at the master end), and a regular environment for other
+    # modes. The configuration is overridden with options from the command line
+    # before being set in a pushed Puppet Context.
+    #
+    # @param run_mode [Puppet::Util::RunMode] Puppet's current Run Mode.
+    # @param environment_mode [Symbol] optional, Puppet's
+    #   current Environment Mode. Defaults to :local
+    # @return [void]
+    # @api private
+    def self.push_application_context(run_mode, environment_mode = :local)
+      Puppet.push_context(Puppet.base_context(Puppet.settings), "Update for application settings (#{run_mode})")
+      # This use of configured environment is correct, this is used to establish
+      # the defaults for an application that does not override, or where an override
+      # has not been made from the command line.
+      #
+      configured_environment_name = Puppet[:environment]
+      if run_mode.name == :agent
+        configured_environment = Puppet::Node::Environment.remote(configured_environment_name)
+      elsif environment_mode == :not_required
+        configured_environment =
+          Puppet.lookup(:environments).get(configured_environment_name) || Puppet::Node::Environment.remote(configured_environment_name)
+      else
+        configured_environment = Puppet.lookup(:environments).get!(configured_environment_name)
+      end
+      configured_environment = configured_environment.override_from_commandline(Puppet.settings)
+
+      # Setup a new context using the app's configuration
+      Puppet.push_context({:current_environment => configured_environment},
+                          "Update current environment from application's configuration")
+    end
+
+    # Reads the routes YAML settings from the file specified by Puppet[:route_file]
+    # 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'.
+    #
+    # @param application_name [String] The name of the current application.
+    # @return [void]
+    # @api private
+    def self.configure_indirector_routes(application_name)
+      route_file = Puppet[:route_file]
+      if Puppet::FileSystem.exist?(route_file)
+        routes = YAML.load_file(route_file)
+        application_routes = routes[application_name]
+        Puppet::Indirector.configure_routes(application_routes) if application_routes
+      end
+    end
+
+  end
+end

data/vendored/puppet/lib/puppet/coercion.rb

@@ -0,0 +1,40 @@
+# Various methods used to coerce values into a canonical form.
+#
+# @api private
+module Puppet::Coercion
+  # Try to coerce various input values into boolean true/false
+  #
+  # Only a very limited subset of values are allowed. This method does not try
+  # to provide a generic "truthiness" system.
+  #
+  # @param value [Boolean, Symbol, String]
+  # @return [Boolean]
+  # @raise
+  # @api private
+  def self.boolean(value)
+    # downcase strings
+    if value.respond_to? :downcase
+      value = value.downcase
+    end
+
+    case value
+    when true, :true, 'true', :yes, 'yes'
+      true
+    when false, :false, 'false', :no, 'no'
+      false
+    else
+      fail('expected a boolean value')
+    end
+  end
+
+  # Return the list of acceptable boolean values.
+  #
+  # This is limited to lower-case, even though boolean() is case-insensitive.
+  #
+  # @return [Array]
+  # @raise
+  # @api private
+  def self.boolean_values
+    ['true', 'false', 'yes', 'no']
+  end
+end

data/vendored/puppet/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/vendored/puppet/lib/puppet/configurer.rb

@@ -0,0 +1,464 @@
+# The client for interacting with the puppetmaster config server.
+require 'sync'
+require 'timeout'
+require 'puppet/network/http_pool'
+require 'puppet/util'
+require 'securerandom'
+
+class Puppet::Configurer
+  require 'puppet/configurer/fact_handler'
+  require 'puppet/configurer/plugin_handler'
+
+  include Puppet::Configurer::FactHandler
+
+  # For benchmarking
+  include Puppet::Util
+
+  attr_reader :compile_time, :environment
+
+  # Provide more helpful strings to the logging that the Agent does
+  def self.to_s
+    _("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
+    execute_from_setting(:postrun_command)
+  end
+
+  def execute_prerun_command
+    execute_from_setting(:prerun_command)
+  end
+
+  # Initialize and load storage
+  def init_storage
+      Puppet::Util::Storage.load
+      @compile_time ||= Puppet::Util::Storage.cache(:configuration)[:compile_time]
+  rescue => 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 %{file}: %{detail}") % { file: Puppet[:statefile], detail: detail }, detail)
+    end
+  end
+
+  def initialize(transaction_uuid = nil, job_id = nil)
+    @running = false
+    @splayed = false
+    @cached_catalog_status = 'not_used'
+    @environment = Puppet[:environment]
+    @transaction_uuid = transaction_uuid || SecureRandom.uuid
+    @job_id = job_id
+    @static_catalog = true
+    @checksum_type = Puppet[:supported_checksum_types]
+    @handler = Puppet::Configurer::PluginHandler.new()
+  end
+
+  # Get the remote catalog, yo.  Returns nil if no catalog can be found.
+  def retrieve_catalog(query_options)
+    query_options ||= {}
+    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
+    end
+
+    result
+  end
+
+  # Convert a plain resource catalog into our full host catalog.
+  def convert_catalog(result, duration)
+    catalog = result.to_ral
+    catalog.finalize
+    catalog.retrieval_duration = duration
+    catalog.write_class_file
+    catalog.write_resource_file
+    catalog
+  end
+
+  def get_facts(options)
+    if options[:pluginsync]
+      remote_environment_for_plugins = Puppet::Node::Environment.remote(@environment)
+      download_plugins(remote_environment_for_plugins)
+
+      Puppet::GettextConfig.reset_text_domain('agent')
+      Puppet::ModuleTranslations.load_from_vardir(Puppet[:vardir])
+    end
+
+    facts_hash = {}
+    if Puppet::Resource::Catalog.indirection.terminus_class == :rest
+      # This is a bit complicated.  We need the serialized and escaped facts,
+      # and we need to know which format they're encoded in.  Thus, we
+      # get a hash with both of these pieces of information.
+      #
+      # facts_for_uploading may set Puppet[:node_name_value] as a side effect
+      facts_hash = facts_for_uploading
+    end
+    facts_hash
+  end
+
+  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('.')
+
+    # 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
+    nil
+  end
+
+  # 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 in %{seconds} seconds")) do
+        catalog.apply(options)
+      end
+    ensure
+      report.finalize_report
+    end
+    report
+  end
+
+  # The code that actually runs the catalog.
+  # This just passes any options on to the catalog,
+  # 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
+
+        # 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
+    end
+  end
+
+  def run_internal(options)
+    report = options[: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]
+      Puppet::GettextConfig.reset_text_domain('agent')
+      Puppet::ModuleTranslations.load_from_vardir(Puppet[:vardir])
+
+      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] || Puppet[:strict_environment_mode])
+        begin
+          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)
+
+            # If we have deserialized a node from a rest call, we want to set
+            # an environment instance as a simple 'remote' environment reference.
+            if !node.has_environment_instance? && node.environment_name
+              node.environment = Puppet::Node::Environment.remote(node.environment_name)
+            end
+
+            @node_environment = node.environment.to_s
+
+            if node.environment.to_s != @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(detail)
+        end
+      end
+
+      current_environment = Puppet.lookup(:current_environment)
+      if current_environment.name == @environment.intern
+        local_node_environment = current_environment
+      else
+        local_node_environment = Puppet::Node::Environment.create(@environment,
+                                         current_environment.modulepath,
+                                         current_environment.manifest,
+                                         current_environment.config_version)
+      end
+      Puppet.push_context({:current_environment => local_node_environment}, "Local node environment for configurer transaction")
+
+      query_options = get_facts(options) unless query_options
+      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
+      # rerun the process if the environment is changed.
+      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") % { tries: tries }
+        end
+        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[: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}") % { detail: detail })
+      return nil
+    ensure
+      execute_postrun_command or return nil
+    end
+  ensure
+    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
+          # 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}") % { detail: detail })
+  end
+
+  def save_last_run_summary(report)
+    mode = Puppet.settings.setting(:lastrunfile).mode
+    Puppet::Util.replace_file(Puppet[:lastrunfile], mode) do |fh|
+      fh.print YAML.dump(report.raw_summary)
+    end
+  rescue => detail
+    Puppet.log_exception(detail, _("Could not save last run local report: %{detail}") % { detail: detail })
+  end
+
+  private
+
+  def execute_from_setting(setting)
+    return true if (command = Puppet[setting]) == ""
+
+    begin
+      Puppet::Util::Execution.execute([command])
+      true
+    rescue => detail
+      Puppet.log_exception(detail, _("Could not run command from %{setting}: %{detail}") % { setting: setting, detail: detail })
+      false
+    end
+  end
+
+  def retrieve_catalog_from_cache(query_options)
+    result = nil
+    @duration = thinmark do
+      result = Puppet::Resource::Catalog.indirection.find(
+        Puppet[:node_name_value],
+        query_options.merge(
+          :ignore_terminus => true,
+          :environment     => Puppet::Node::Environment.remote(@environment)
+        )
+      )
+    end
+    result
+  rescue => detail
+    Puppet.log_exception(detail, _("Could not retrieve catalog from cache: %{detail}") % { detail: detail })
+    return nil
+  end
+
+  def retrieve_new_catalog(query_options)
+    result = nil
+    @duration = thinmark do
+      result = Puppet::Resource::Catalog.indirection.find(
+        Puppet[:node_name_value],
+        query_options.merge(
+          :ignore_cache      => true,
+          # We never want to update the cached Catalog if we're running in noop mode.
+          :ignore_cache_save => Puppet[:noop],
+          :environment       => Puppet::Node::Environment.remote(@environment),
+          :fail_on_404       => true
+        )
+      )
+    end
+    result
+  rescue StandardError => detail
+    Puppet.log_exception(detail, _("Could not retrieve catalog from remote server: %{detail}") % { detail: detail })
+    return nil
+  end
+
+  def download_plugins(remote_environment_for_plugins)
+    @handler.download_plugins(remote_environment_for_plugins)
+  end
+end