bolt 0.19.1 → 0.20.0

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

@@ -1,261 +0,0 @@
-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

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

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

@@ -1,62 +0,0 @@
-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

@@ -1,40 +0,0 @@
-# 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

@@ -1,15 +0,0 @@
-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

@@ -1,464 +0,0 @@
-# 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