openbolt 9.0.0.pre.rc1 → 9.0.0

data/lib/bolt/transport/choria.rb

@@ -6,6 +6,8 @@ require 'digest/sha2'
 require 'json'
 require 'securerandom'
 require 'shellwords'
+require_relative '../../bolt/node/errors'
+require_relative '../../bolt/shell'
 require_relative '../../bolt/transport/base'
 
 module Bolt
@@ -21,15 +23,19 @@ module Bolt
     #
     #   bolt_tasks agent only: Only run_task works, via the bolt_tasks agent
     #     which downloads task files from an OpenVox/Puppet Server and executes
-    #     them via task_wrapper. All other operations fail with an actionable
-    #     error directing the user to install the shell agent.
+    #     them via task_wrapper. All other operations fail with an error that
+    #     names the agent they need.
     #
     #   shell agent installed (>= 1.2.1): run_command, run_script, and
     #     run_task work. run_task uses the bolt_tasks agent by default.
     #     To run local tasks via the shell agent, set task-agent to 'shell'
     #     in project config or specify --choria-task-agent shell.
     #
-    #   Upload, download, and plans are not yet supported.
+    #   file_transfer agent installed (>= 1.0.0): upload and download work.
+    #     The controller needs the agent module's client files, which carry
+    #     the client library the transport uses.
+    #
+    #   Plans are not yet supported.
     class Choria < Base
       def initialize
         super
@@ -45,10 +51,9 @@ module Bolt
         @default_collective = nil
       end
 
-      # Advertise both shell and powershell so tasks with either requirement
-      # can be selected. The per-target selection happens in
-      # select_implementation below, which picks the right feature set based
-      # on the target's detected OS.
+      # Task selection does not use this list, since select_implementation
+      # below overrides the Base method that reads it. The list is kept for
+      # apply_prep, which reads a transport's provided features.
       def provided_features
         %w[shell powershell]
       end
@@ -69,6 +74,29 @@ module Bolt
         impl
       end
 
+      # Groups the targets by the implementation each selects. A target
+      # without a suitable implementation gets its error result instead of
+      # failing the whole batch.
+      #
+      # @param targets [Array<Bolt::Target>] Targets to run the task on
+      # @param task [Bolt::Task] Task with the implementations to select from
+      # @param result_opts [Hash] Options passed through to emit_results (:action, :name, :position)
+      # @param callback [Proc] Called with :node_result events
+      # @return [Array] 2-element array:
+      #   - [Hash{Hash => Array<Bolt::Target>}] Each implementation and the targets that selected it
+      #   - [Array<Bolt::Result>] Error results for the targets without an implementation
+      def group_by_implementation(targets, task, result_opts, &callback)
+        selected = {}
+        failures = {}
+        targets.each do |target|
+          selected[target] = select_implementation(target, task)
+        rescue Bolt::NoImplementationError => e
+          logger.debug { "No suitable implementation of #{task.name} for #{target.safe_name}" }
+          failures[target] = error_output(e.message, e.kind)
+        end
+        [selected.keys.group_by { |target| selected[target] }, emit_results(failures, **result_opts, &callback)]
+      end
+
       # Group targets by collective so each batch uses a single RPC client
       # scope. MCollective RPC calls are published to a collective-specific
       # NATS subject, so targets in different collectives must be in separate
@@ -107,7 +135,6 @@ module Bolt
         logger.debug { "Task #{task.name} routing: agent: #{chosen_agent}, #{capable.size} capable / #{targets.size - capable.size} incapable" }
 
         unless capable.empty?
-          capable.each { |target| callback&.call(type: :node_start, target: target) }
           arguments = unwrap_sensitive_args(arguments)
 
           results += case chosen_agent
@@ -148,12 +175,18 @@ module Bolt
       # @param callback [Proc] Called with :node_start and :node_result events
       # @return [Array<Bolt::Result>] Results for all targets
       def batch_task_with(targets, task, target_mapping, options = {}, position = [], &callback)
-        # Pre-warm the agent cache so individual batch_task calls are cache hits
+        # Pre-warm the agent cache so individual batch_task calls are cache hits.
+        # A target that did not answer has no cache entry, and batch_task would
+        # discover it again and wait out the timeout again, so it gets its
+        # error here instead.
         configure_client(targets.first)
-        discover_agents(targets)
+        discovery_failures = discover_agents(targets)
+        discovered, silent = targets.partition { |target| discovered?(target) }
 
-        results = []
-        targets.each do |target|
+        silent_errors = silent.to_h { |target| [target, discovery_failures[target] || undiscovered_error(target)] }
+        silent.each { |target| callback&.call(type: :node_start, target: target) }
+        results = emit_results(silent_errors, action: 'task', name: task.name, position: position, &callback)
+        discovered.each do |target|
           results += batch_task([target], task, target_mapping[target], options, position, &callback)
         end
         results
@@ -169,29 +202,59 @@ module Bolt
         first_target = targets.first
         configure_client(first_target)
 
-        response = rpc_request('rpcutil', targets, 'rpcutil.ping') do |client|
+        # A target that denies the caller still answers, so it counts as connected.
+        response = rpc_request('rpcutil', targets, 'rpcutil.ping', accept_aborted: true) do |client|
           client.ping
         end
         response[:responded].length == targets.length
-      rescue StandardError => e
-        raise if e.is_a?(Bolt::Error)
+      end
+
+      # The single-target methods of the transport API. The remote transport
+      # calls run_task for its run-on target.
+
+      def run_command(target, command, options = {}, position = [])
+        batch_command([target], command, options, position).first
+      end
 
-        logger.warn { "Batch connectivity check failed: #{e.class}: #{e.message}" }
-        false
+      def run_script(target, script, arguments, options = {}, position = [])
+        raise_file_error(batch_script([target], script, arguments, options, position).first)
       end
 
-      def upload(_target, _source, _destination, _options = {}, _position = [])
-        raise Bolt::Error.new(
-          'The Choria transport does not yet support upload.',
-          'bolt/choria-unsupported-operation'
-        )
+      # Raises when no implementation of the task suits the target, like the
+      # other transports do. A batch reports that as the target's result.
+      def run_task(target, task, arguments, options = {}, position = [])
+        result = batch_task([target], task, arguments, options, position).first
+        # A result with an object is the task's own, whatever error the task
+        # printed. A failure the transport reports has none.
+        return result if result.object
+
+        raise Bolt::NoImplementationError.new(target, task) if result.error_hash&.dig('kind') == 'bolt/no-implementation'
+
+        raise_file_error(result)
+      end
+
+      def upload(target, source, destination, options = {})
+        batch_upload([target], source, destination, options).first
+      end
+
+      # Downloads into the destination itself. A batch gives each target a
+      # directory of its own under the destination.
+      def download(target, source, destination, _options = {})
+        download_into({ target => destination }, source, []).first
       end
 
-      def download(_target, _source, _destination, _options = {}, _position = [])
-        raise Bolt::Error.new(
-          'The Choria transport does not yet support download.',
-          'bolt/choria-unsupported-operation'
-        )
+      def connected?(target)
+        batch_connected?([target])
+      end
+
+      # Raises when a preparation step failed on the node, like the other
+      # transports do, and returns the result otherwise. A batch reports
+      # that failure as the target's result.
+      def raise_file_error(result)
+        error = result.error_hash
+        raise Bolt::Node::FileError, error['msg'] if error && error['kind'] == 'puppetlabs.tasks/task_file_error'
+
+        result
       end
 
       # Returns the Choria node identity for a target. Uses the transport
@@ -201,6 +264,11 @@ module Bolt
         target.options['host'] || target.host
       end
 
+      # The distinct identities behind the targets, in target order.
+      def identities_of(targets)
+        targets.map { |target| choria_identity(target) }.uniq
+      end
+
       # Returns the collective for a target, used by batches() to group
       # targets. Falls back to the default collective from the loaded config.
       def collective_for(target)
@@ -214,5 +282,6 @@ require_relative 'choria/agent_discovery'
 require_relative 'choria/bolt_tasks'
 require_relative 'choria/client'
 require_relative 'choria/command_builders'
+require_relative 'choria/file_transfer'
 require_relative 'choria/helpers'
 require_relative 'choria/shell'

data/lib/bolt/util.rb

@@ -422,6 +422,19 @@ module Bolt
         path.split(%r{[/\\]}).last
       end
 
+      # Escapes a string for use inside a PowerShell single-quoted string by
+      # doubling every character PowerShell reads as a single quote, which is
+      # the apostrophe and the curly single quotes U+2018 to U+201B. The
+      # string is converted to UTF-8 first, so a quote in another encoding,
+      # such as 0x92 in Windows-1252, is doubled too. A binary string, such
+      # as a command-line argument under the C locale, can't be converted, so
+      # its bytes are read as UTF-8 and the result stays binary.
+      def escape_powershell_single_quotes(str)
+        return str.gsub(/'|\xE2\x80[\x98-\x9B]/n) { |quote| quote * 2 } if str.encoding == Encoding::BINARY
+
+        str.encode('UTF-8').gsub(/['\u{2018}-\u{201B}]/) { |quote| quote * 2 }
+      end
+
       # Prompts yes or no, returning true for yes and false for no.
       #
       def prompt_yes_no(prompt, outputter)

data/lib/bolt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bolt
-  VERSION = '9.0.0-rc1'
+  VERSION = '9.0.0'
 end

data/lib/bolt_spec/plans/mock_executor.rb

@@ -279,6 +279,10 @@ module BoltSpec
         yield
       end
 
+      def run_in_new_fiber
+        yield
+      end
+
       def in_parallel?
         false
       end

data/libexec/apply_catalog.rb

@@ -106,6 +106,9 @@ begin
 
   Puppet.override(overrides) do
     catalog = Puppet::Resource::Catalog.from_data_hash(args['catalog'])
+    # The catalog is named after the Bolt target, and OpenVox 9 logs an error when that
+    # name differs from the node name the agent reports under
+    Puppet[:node_name_value] = catalog.name
     catalog.environment = env.name.to_s
     catalog.environment_instance = env
     if defined?(Puppet::Pops::Evaluator::DeferredResolver)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openbolt
 version: !ruby/object:Gem::Version
-  version: 9.0.0.pre.rc1
+  version: 9.0.0
 platform: ruby
 authors:
 - OpenVox Project
@@ -71,14 +71,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.26'
+        version: '2.28'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.26'
+        version: '2.28'
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -685,6 +685,7 @@ files:
 - lib/bolt/transport/choria/bolt_tasks.rb
 - lib/bolt/transport/choria/client.rb
 - lib/bolt/transport/choria/command_builders.rb
+- lib/bolt/transport/choria/file_transfer.rb
 - lib/bolt/transport/choria/helpers.rb
 - lib/bolt/transport/choria/shell.rb
 - lib/bolt/transport/docker.rb
@@ -749,7 +750,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="