bolt 3.3.0 → 3.7.0

data/lib/bolt/transport/docker.rb

@@ -2,7 +2,7 @@
 
 require 'json'
 require 'shellwords'
-require 'bolt/transport/base'
+require 'bolt/transport/simple'
 
 module Bolt
   module Transport

data/lib/bolt/transport/docker/connection.rb

@@ -34,6 +34,15 @@ module Bolt
           @container_info["Id"]
         end
 
+        def run_cmd(cmd, env_vars)
+          Bolt::Util.exec_docker(cmd, env_vars)
+        end
+
+        private def env_hash
+          # Set the DOCKER_HOST if we are using a non-default service-url
+          @docker_host.nil? ? {} : { 'DOCKER_HOST' => @docker_host }
+        end
+
         def connect
           # We don't actually have a connection, but we do need to
           # check that the container exists and is running.
@@ -54,10 +63,7 @@ module Bolt
         end
 
         def add_env_vars(env_vars)
-          @env_vars = env_vars.each_with_object([]) do |env_var, acc|
-            acc << "--env"
-            acc << "#{env_var[0]}=#{env_var[1]}"
-          end
+          @env_vars = Bolt::Util.format_env_vars_for_cli(env_vars)
         end
 
         # Executes a command inside the target container. This is called from the shell class.
@@ -88,9 +94,9 @@ module Bolt
 
         def upload_file(source, destination)
           @logger.trace { "Uploading #{source} to #{destination}" }
-          _stdout, stderr, status = execute_local_command('cp', [source, "#{container_id}:#{destination}"])
-          unless status.exitstatus.zero?
-            raise "Error writing to container #{container_id}: #{stderr}"
+          _out, err, stat = run_cmd(['cp', source, "#{container_id}:#{destination}"], env_hash)
+          unless stat.exitstatus.zero?
+            raise "Error writing to container #{container_id}: #{err}"
           end
         rescue StandardError => e
           raise Bolt::Node::FileError.new(e.message, 'WRITE_ERROR')
@@ -102,31 +108,14 @@ module Bolt
           # copy the *contents* of the directory.
           # https://docs.docker.com/engine/reference/commandline/cp/
           FileUtils.mkdir_p(destination)
-          _stdout, stderr, status = execute_local_command('cp', ["#{container_id}:#{source}", destination])
-          unless status.exitstatus.zero?
-            raise "Error downloading content from container #{container_id}: #{stderr}"
+          _out, err, stat = run_cmd(['cp', "#{container_id}:#{source}", destination], env_hash)
+          unless stat.exitstatus.zero?
+            raise "Error downloading content from container #{container_id}: #{err}"
           end
         rescue StandardError => e
           raise Bolt::Node::FileError.new(e.message, 'WRITE_ERROR')
         end
 
-        # Executes a Docker CLI command. This is useful for running commands as
-        # part of this class without having to go through the `execute`
-        # function and manage pipes.
-        #
-        # @param subcommand [String] The docker subcommand to run
-        #   e.g. 'inspect' for `docker inspect`
-        # @param arguments [Array] Arguments to pass to the docker command
-        #   e.g. 'src' and 'dest' for `docker cp <src> <dest>
-        # @return [String, String, Process::Status] The output of the command: STDOUT, STDERR, Process Status
-        private def execute_local_command(subcommand, arguments = [])
-          # Set the DOCKER_HOST if we are using a non-default service-url
-          env_hash = @docker_host.nil? ? {} : { 'DOCKER_HOST' => @docker_host }
-          docker_command = [subcommand].concat(arguments)
-
-          Open3.capture3(env_hash, 'docker', *docker_command, { binmode: true })
-        end
-
         # Executes a Docker CLI command and parses the output in JSON format
         #
         # @param subcommand [String] The docker subcommand to run
@@ -134,15 +123,15 @@ module Bolt
         # @param arguments [Array] Arguments to pass to the docker command
         #   e.g. 'src' and 'dest' for `docker cp <src> <dest>
         # @return [Object] Ruby object representation of the JSON string
-        private def execute_local_json_command(subcommand, arguments = [])
-          command_options = ['--format', '{{json .}}'].concat(arguments)
-          stdout, _stderr, _status = execute_local_command(subcommand, command_options)
-          extract_json(stdout)
+        def execute_local_json_command(subcommand, arguments = [])
+          cmd = [subcommand, '--format', '{{json .}}'].concat(arguments)
+          out, _err, _stat = run_cmd(cmd, env_hash)
+          extract_json(out)
         end
 
         # Converts the JSON encoded STDOUT string from the docker cli into ruby objects
         #
-        # @param stdout_string [String] The string to convert
+        # @param stdout [String] The string to convert
         # @return [Object] Ruby object representation of the JSON string
         private def extract_json(stdout)
           # The output from the docker format command is a JSON string per line.

data/lib/bolt/transport/lxd/connection.rb

@@ -24,17 +24,17 @@ module Bolt
         end
 
         def container_id
-          "local:#{@target.host}"
+          "#{@target.transport_config['remote']}:#{@target.host}"
         end
 
         def connect
-          out, err, status = execute_local_command(%w[list --format json])
+          out, err, status = execute_local_command(%W[list #{container_id} --format json])
           unless status.exitstatus.zero?
             raise "Error listing available containers: #{err}"
           end
-          containers = JSON.parse(out).map { |c| c['name'] }
-          unless containers.include?(@target.host)
-            raise "Could not find a container with name or ID matching '#{@target.host}'"
+          containers = JSON.parse(out)
+          if containers.empty?
+            raise "Could not find a container with name or ID matching '#{container_id}'"
           end
           @logger.trace("Opened session")
           true

data/lib/bolt/transport/orch.rb

@@ -59,6 +59,18 @@ module Bolt
           # the result otherwise make sure an error is generated
           if state == 'finished' || (result && result['_error'])
             if result['_error']
+              unless result['_error'].is_a?(Hash)
+                result['_error'] = { 'kind' => 'puppetlabs.tasks/task-error',
+                                     'issue_code' => 'TASK_ERROR',
+                                     'msg' => result['_error'],
+                                     'details' => {} }
+              end
+
+              result['_error']['details'] ||= {}
+              unless result['_error']['details'].is_a?(Hash)
+                deets = result['_error']['details']
+                result['_error']['details'] = { 'msg' => deets }
+              end
               file_line = %w[file line].zip(position).to_h.compact
               result['_error']['details'].merge!(file_line) unless result['_error']['details']['file']
             end
@@ -252,11 +264,7 @@ module Bolt
 
         # If we get here, there's no error so we don't need the file or line
         # number
-        Bolt::Result.for_command(target,
-                                 result.value['stdout'],
-                                 result.value['stderr'],
-                                 result.value['exit_code'],
-                                 action, obj, [])
+        Bolt::Result.for_command(target, result.value, action, obj, [])
       end
     end
   end

data/lib/bolt/transport/podman.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'shellwords'
+require 'bolt/transport/base'
+
+module Bolt
+  module Transport
+    class Podman < Docker
+      def with_connection(target)
+        conn = Connection.new(target)
+        conn.connect
+        yield conn
+      end
+    end
+  end
+end
+
+require 'bolt/transport/podman/connection'

data/lib/bolt/transport/podman/connection.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'logging'
+require 'bolt/node/errors'
+
+module Bolt
+  module Transport
+    class Podman < Docker
+      class Connection < Connection
+        attr_reader :user, :target
+
+        def initialize(target)
+          raise Bolt::ValidationError, "Target #{target.safe_name} does not have a host" unless target.host
+          @target = target
+          @user = ENV['USER'] || Etc.getlogin
+          @logger = Bolt::Logger.logger(target.safe_name)
+          @container_info = {}
+          @logger.trace("Initializing podman connection to #{target.safe_name}")
+        end
+
+        def run_cmd(cmd, env_vars)
+          Bolt::Util.exec_podman(cmd, env_vars)
+        end
+
+        def shell
+          @shell ||= if Bolt::Util.windows?
+                       Bolt::Shell::Powershell.new(target, self)
+                     else
+                       Bolt::Shell::Bash.new(target, self)
+                     end
+        end
+
+        def connect
+          # We don't actually have a connection, but we do need to
+          # check that the container exists and is running.
+          ps = execute_local_json_command('ps')
+          container = Array(ps).find { |item|
+            item["ID"].to_s.eql?(@target.host) ||
+              item["Id"].to_s.start_with?(@target.host) ||
+              Array(item["Names"]).include?(@target.host)
+          }
+          raise "Could not find a container with name or ID matching '#{@target.host}'" if container.nil?
+          # Now find the indepth container information
+          id = container["ID"] || container["Id"]
+          output = execute_local_json_command('inspect', [id])
+          # Store the container information for later
+          @container_info = output.first
+          @logger.trace { "Opened session" }
+          true
+        rescue StandardError => e
+          raise Bolt::Node::ConnectError.new(
+            "Failed to connect to #{target.safe_name}: #{e.message}",
+            'CONNECT_ERROR'
+          )
+        end
+
+        # Executes a command inside the target container. This is called from the shell class.
+        #
+        # @param command [string] The command to run
+        def execute(command)
+          args = []
+          args += %w[--interactive]
+          args += %w[--tty] if target.options['tty']
+          args += @env_vars if @env_vars
+
+          if target.options['shell-command'] && !target.options['shell-command'].empty?
+            # escape any double quotes in command
+            command = command.gsub('"', '\"')
+            command = "#{target.options['shell-command']} \"#{command}\""
+          end
+
+          podman_command = %w[podman exec] + args + [container_id] + Shellwords.split(command)
+          @logger.trace { "Executing: #{podman_command.join(' ')}" }
+
+          Open3.popen3(*podman_command)
+        rescue StandardError
+          @logger.trace { "Command aborted" }
+          raise
+        end
+
+        # Converts the JSON encoded STDOUT string from the podman cli into ruby objects
+        #
+        # @param stdout [String] The string to convert
+        # @return [Object] Ruby object representation of the JSON string
+        private def extract_json(stdout)
+          # Podman renders the output in pretty JSON, which results in a newline
+          # appearing in the output before the closing bracket.
+          # should we only get a single line with no newline at all, we also
+          # assume it is a single minified JSON object
+          stdout.strip!
+          newline = stdout.index("\n") || -1
+          bracket = stdout.index('}') || -1
+          JSON.parse(stdout) if bracket > newline
+        end
+      end
+    end
+  end
+end

data/lib/bolt/util.rb

@@ -77,6 +77,14 @@ module Bolt
         File.exist?(path) ? read_yaml_hash(path, file_name) : {}
       end
 
+      def first_runs_free
+        Bolt::Config.user_path + '.first_runs_free'
+      end
+
+      def first_run?
+        Bolt::Config.user_path && !File.exist?(first_runs_free)
+      end
+
       # Accepts a path with either 'plans' or 'tasks' in it and determines
       # the name of the module
       def module_name(path)
@@ -324,6 +332,40 @@ module Bolt
         end
       end
 
+      # Executes a Docker CLI command. This is useful for running commands as
+      # part of this class without having to go through the `execute`
+      # function and manage pipes.
+      #
+      # @param cmd [String] The docker command and arguments to run
+      #   e.g. 'cp <src> <dest>' for `docker cp <src> <dest>`
+      # @return [String, String, Process::Status] The output of the command: STDOUT, STDERR, Process Status
+      def exec_docker(cmd, env = {})
+        Open3.capture3(env, 'docker', *cmd, { binmode: true })
+      end
+
+      # Executes a Podman CLI command. This is useful for running commands as
+      # part of this class without having to go through the `execute`
+      # function and manage pipes.
+      #
+      # @param cmd [String] The podman command and arguments to run
+      #   e.g. 'cp <src> <dest>' for `podman cp <src> <dest>`
+      # @return [String, String, Process::Status] The output of the command: STDOUT, STDERR, Process Status
+      def exec_podman(cmd, env = {})
+        Open3.capture3(env, 'podman', *cmd, { binmode: true })
+      end
+
+      # Formats a map of environment variables to be passed to a command that
+      # accepts repeated `--env` flags
+      #
+      # @param env_vars [Hash] A map of environment variables keys and their values
+      # @return [String]
+      def format_env_vars_for_cli(env_vars)
+        @env_vars = env_vars.each_with_object([]) do |(key, value), acc|
+          acc << "--env"
+          acc << "#{key}=#{value}"
+        end
+      end
+
       def unix_basename(path)
         raise Bolt::ValidationError, "path must be a String, received #{path.class} #{path}" unless path.is_a?(String)
         path.split('/').last

data/lib/bolt/version.rb

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

data/lib/bolt_server/transport_app.rb

@@ -703,6 +703,9 @@ module BoltServer
           connect_plugin = BoltServer::Plugin::PuppetConnectData.new(body['puppet_connect_data'])
           plugins = Bolt::Plugin.setup(context[:config], context[:pal], load_plugins: false)
           plugins.add_plugin(connect_plugin)
+          %w[aws_inventory azure_inventory gcloud_inventory].each do |plugin_name|
+            plugins.add_module_plugin(plugin_name) if plugins.known_plugin?(plugin_name)
+          end
           inventory = Bolt::Inventory.from_config(context[:config], plugins)
           target_list = inventory.get_targets('all').map do |targ|
             targ.to_h.merge({ 'transport' => targ.transport, 'plugin_hooks' => targ.plugin_hooks })

data/lib/bolt_spec/plans/action_stubs/command_stub.rb

@@ -29,7 +29,14 @@ module BoltSpec
       end
 
       def result_for(target, stdout: '', stderr: '')
-        Bolt::Result.for_command(target, stdout, stderr, 0, 'command', '', [])
+        value = {
+          'stdout'        => stdout,
+          'stderr'        => stderr,
+          'merged_output' => "#{stdout}\n#{stderr}".strip,
+          'exit_code'     => 0
+        }
+
+        Bolt::Result.for_command(target, value, 'command', '', [])
       end
 
       # Public methods

data/lib/bolt_spec/plans/action_stubs/script_stub.rb

@@ -35,7 +35,14 @@ module BoltSpec
       end
 
       def result_for(target, stdout: '', stderr: '')
-        Bolt::Result.for_command(target, stdout, stderr, 0, 'script', '', [])
+        value = {
+          'stdout'        => stdout,
+          'stderr'        => stderr,
+          'merged_output' => "#{stdout}\n#{stderr}".strip,
+          'exit_code'     => 0
+        }
+
+        Bolt::Result.for_command(target, value, 'script', '', [])
       end
 
       # Public methods

data/lib/bolt_spec/plans/mock_executor.rb

@@ -17,13 +17,14 @@ module BoltSpec
 
     # Nothing on the executor is 'public'
     class MockExecutor
-      attr_reader :noop, :error_message, :in_parallel
+      attr_reader :noop, :error_message, :in_parallel, :transports, :future
       attr_accessor :run_as, :transport_features, :execute_any_plan
 
       def initialize(modulepath)
         @noop = false
         @run_as = nil
         @in_parallel = false
+        @future = {}
         @error_message = nil
         @allow_apply = false
         @modulepath = [modulepath].flatten.map { |path| File.absolute_path(path) }
@@ -91,6 +92,14 @@ module BoltSpec
         result
       end
 
+      def run_task_with(target_mapping, task, options = {}, _position = [])
+        resultsets = target_mapping.map do |target, arguments|
+          run_task([target], task, arguments, options)
+        end.compact
+
+        Bolt::ResultSet.new(resultsets.map(&:results).flatten)
+      end
+
       def download_file(targets, source, destination, options = {}, _position = [])
         result = nil
         if (doub = @download_doubles[source] || @download_doubles[:default])
@@ -210,16 +219,6 @@ module BoltSpec
         yield
       end
 
-      def report_function_call(_function); end
-
-      def report_bundled_content(_mode, _name); end
-
-      def report_file_source(_plan_function, _source); end
-
-      def report_apply(_statements, _resources); end
-
-      def report_yaml_plan(_plan); end
-
       def publish_event(event)
         if event[:type] == :message
           unless @stub_out_message
@@ -257,6 +256,87 @@ module BoltSpec
         end.new(transport_features)
       end
       # End apply_prep mocking
+
+      # Evaluates a `parallelize()` block and returns the result. Normally,
+      # Bolt's executor wraps this in a Yarn for each object passed to the
+      # `parallelize()` function, and then executes them in parallel before
+      # returning the result from the block. However, in BoltSpec the block is
+      # executed for each object sequentially, and this function returns the
+      # result itself.
+      #
+      def create_yarn(scope, block, object, _index)
+        # Create the new scope
+        newscope = Puppet::Parser::Scope.new(scope.compiler)
+        local = Puppet::Parser::Scope::LocalScope.new
+
+        # Compress the current scopes into a single vars hash to add to the new scope
+        current_scope = scope.effective_symtable(true)
+        until current_scope.nil?
+          current_scope.instance_variable_get(:@symbols)&.each_pair { |k, v| local[k] = v }
+          current_scope = current_scope.parent
+        end
+        newscope.push_ephemerals([local])
+
+        begin
+          result = catch(:return) do
+            args = { block.parameters[0][1].to_s => object }
+            block.closure.call_by_name_with_scope(newscope, args, true)
+          end
+
+          # If we got a return from the block, get it's value
+          # Otherwise the result is the last line from the block
+          result = result.value if result.is_a?(Puppet::Pops::Evaluator::Return)
+
+          # Validate the result is a PlanResult
+          unless Puppet::Pops::Types::TypeParser.singleton.parse('Boltlib::PlanResult').instance?(result)
+            raise Bolt::InvalidParallelResult.new(result.to_s, *Puppet::Pops::PuppetStack.top_of_stack)
+          end
+
+          result
+        rescue Puppet::PreformattedError => e
+          if e.cause.is_a?(Bolt::Error)
+            e.cause
+          else
+            raise e
+          end
+        end
+      end
+
+      # BoltSpec already evaluated the `parallelize()` block for each object
+      # passed to the function, so these results can be returned as-is.
+      #
+      def round_robin(results)
+        results
+      end
+
+      # Public methods on Bolt::Executor that need to be mocked so there aren't
+      # "undefined method" errors.
+
+      def batch_execute(_targets); end
+
+      def finish_plan(_plan_result); end
+
+      def handle_event(_event); end
+
+      def prompt(_prompt, _options); end
+
+      def report_function_call(_function); end
+
+      def report_bundled_content(_mode, _name); end
+
+      def report_file_source(_plan_function, _source); end
+
+      def report_apply(_statements, _resources); end
+
+      def report_yaml_plan(_plan); end
+
+      def shutdown; end
+
+      def start_plan(_plan_context); end
+
+      def subscribe(_subscriber, _types = nil); end
+
+      def unsubscribe(_subscriber, _types = nil); end
     end
   end
 end