bolt 3.1.0 → 3.3.0

data/lib/bolt/pal/yaml_plan/step/script.rb

@@ -6,35 +6,50 @@ module Bolt
       class Step
         class Script < Step
           def self.allowed_keys
-            super + Set['script', 'parameters', 'arguments']
+            super + Set['arguments', 'pwsh_params']
+          end
+
+          def self.option_keys
+            Set['catch_errors', 'env_vars', 'run_as']
           end
 
           def self.required_keys
-            Set['targets']
+            Set['script', 'targets']
           end
 
-          def initialize(step_body)
+          def self.validate_step_keys(body, number)
             super
-            @script = step_body['script']
-            @parameters = step_body.fetch('parameters', {})
-            @arguments = step_body.fetch('arguments', [])
+
+            if body.key?('arguments') && !body['arguments'].nil? && !body['arguments'].is_a?(Array)
+              raise StepError.new('arguments key must be an array', body['name'], number)
+            end
+
+            if body.key?('pwsh_params') && !body['pwsh_params'].nil? && !body['pwsh_params'].is_a?(Hash)
+              raise StepError.new('pwsh_params key must be a hash', body['name'], number)
+            end
           end
 
-          def transpile
-            code = String.new("  ")
-            code << "$#{@name} = " if @name
+          # Returns an array of arguments to pass to the step's function call
+          #
+          private def format_args(body)
+            args        = body['arguments'] || []
+            pwsh_params = body['pwsh_params'] || {}
 
-            options = @parameters.dup
-            options['arguments'] = @arguments unless @arguments.empty?
+            opts = format_options(body)
+            opts = opts.merge('arguments' => args) if args.any?
+            opts = opts.merge('pwsh_params' => pwsh_params) if pwsh_params.any?
 
-            fn = 'run_script'
-            args = [@script, @targets]
-            args << @description if @description
-            args << options unless options.empty?
+            args = [body['script'], body['targets']]
+            args << body['description'] if body['description']
+            args << opts if opts.any?
 
-            code << function_call(fn, args)
+            args
+          end
 
-            code << "\n"
+          # Returns the function corresponding to the step
+          #
+          private def function
+            'run_script'
           end
         end
       end

data/lib/bolt/pal/yaml_plan/step/task.rb

@@ -6,31 +6,34 @@ module Bolt
       class Step
         class Task < Step
           def self.allowed_keys
-            super + Set['task', 'parameters']
+            super + Set['parameters']
           end
 
-          def self.required_keys
-            Set['targets']
+          def self.option_keys
+            Set['catch_errors', 'noop', 'run_as']
           end
 
-          def initialize(step_body)
-            super
-            @task = step_body['task']
-            @parameters = step_body.fetch('parameters', {})
+          def self.required_keys
+            Set['targets', 'task']
           end
 
-          def transpile
-            code = String.new("  ")
-            code << "$#{@name} = " if @name
+          # Returns an array of arguments to pass to the step's function call
+          #
+          private def format_args(body)
+            opts   = format_options(body)
+            params = (body['parameters'] || {}).merge(opts)
 
-            fn = 'run_task'
-            args = [@task, @targets]
-            args << @description if @description
-            args << @parameters unless @parameters.empty?
+            args = [body['task'], body['targets']]
+            args << body['description'] if body['description']
+            args << params if params.any?
 
-            code << function_call(fn, args)
+            args
+          end
 
-            code << "\n"
+          # Returns the function corresponding to the step
+          #
+          private def function
+            'run_task'
           end
         end
       end

data/lib/bolt/pal/yaml_plan/step/upload.rb

@@ -5,31 +5,30 @@ module Bolt
     class YamlPlan
       class Step
         class Upload < Step
-          def self.allowed_keys
-            super + Set['destination', 'upload']
+          def self.option_keys
+            Set['catch_errors', 'run_as']
           end
 
           def self.required_keys
-            Set['upload', 'destination', 'targets']
+            Set['destination', 'targets', 'upload']
           end
 
-          def initialize(step_body)
-            super
-            @source = step_body['upload']
-            @destination = step_body['destination']
-          end
-
-          def transpile
-            code = String.new("  ")
-            code << "$#{@name} = " if @name
+          # Returns an array of arguments to pass to the step's function call
+          #
+          private def format_args(body)
+            opts = format_options(body)
 
-            fn = 'upload_file'
-            args = [@source, @destination, @targets]
-            args << @description if @description
+            args = [body['upload'], body['destination'], body['targets']]
+            args << body['description'] if body['description']
+            args << opts if opts.any?
 
-            code << function_call(fn, args)
+            args
+          end
 
-            code << "\n"
+          # Returns the function corresponding to the step
+          #
+          private def function
+            'upload_file'
           end
         end
       end

data/lib/bolt/pal/yaml_plan/transpiler.rb

@@ -29,7 +29,7 @@ module Bolt
 
           plan_string = String.new('')
           plan_string << "# #{plan_object.description}\n" if plan_object.description
-          plan_string << "# WARNING: This is an autogenerated plan. It may not behave as expected.\n"
+          plan_string << "# WARNING: This is an autogenerated plan. It might not behave as expected.\n"
           plan_string << "# @private #{plan_object.private}\n" unless plan_object.private.nil?
           plan_string << "#{param_descriptions}\n" unless param_descriptions.empty?
 

data/lib/bolt/plan_creator.rb

@@ -22,7 +22,7 @@ module Bolt
           Invalid plan name '#{plan_name}'. Plan names are composed of one or more name segments
           separated by double colons '::'.
 
-          Each name segment must begin with a lowercase letter, and may only include lowercase
+          Each name segment must begin with a lowercase letter, and can only include lowercase
           letters, digits, and underscores.
 
           Examples of valid plan names:

data/lib/bolt/project_manager.rb

@@ -143,7 +143,7 @@ module Bolt
       @outputter.print_message("Migrating project #{@config.project.path}\n\n")
 
       @outputter.print_action_step(
-        "Migrating a Bolt project may make irreversible changes to the project's "\
+        "Migrating a Bolt project might make irreversible changes to the project's "\
         "configuration and inventory files. Before continuing, make sure the "\
         "project has a backup or uses a version control system."
       )

data/lib/bolt/project_manager/module_migrator.rb

@@ -66,7 +66,7 @@ module Bolt
         # Attempt to resolve dependencies
         begin
           @outputter.print_message('')
-          @outputter.print_action_step("Resolving module dependencies, this may take a moment")
+          @outputter.print_action_step("Resolving module dependencies, this might take a moment")
           puppetfile = Bolt::ModuleInstaller::Resolver.new.resolve(specs)
         rescue Bolt::Error => e
           @outputter.print_action_error("#{e.message}\nSkipping module migration.")

data/lib/bolt/shell.rb

@@ -8,6 +8,22 @@ module Bolt
       @target = target
       @conn = conn
       @logger = Bolt::Logger.logger(@target.safe_name)
+
+      if Bolt::Logger.stream
+        Bolt::Logger.warn_once("stream_experimental",
+                               "The 'stream' option is experimental, and might "\
+                               "include breaking changes between minor versions.")
+        @stream_logger = Bolt::Logger.logger(:stream)
+        # Don't send stream messages to the parent logger
+        @stream_logger.additive = false
+
+        # Log stream messages without any other data or color
+        pattern = Logging.layouts.pattern(pattern: '%m\n')
+        @stream_logger.appenders = Logging.appenders.stdout(
+          'console',
+          layout: pattern
+        )
+      end
     end
 
     def run_command(*_args)

data/lib/bolt/shell/bash.rb

@@ -12,7 +12,6 @@ module Bolt
         super
 
         @run_as = nil
-
         @sudo_id = SecureRandom.uuid
         @sudo_password = @target.options['sudo-password'] || @target.password
       end
@@ -54,19 +53,35 @@ module Bolt
 
       def download(source, destination, options = {})
         running_as(options[:run_as]) do
-          # Target OS may be either Unix or Windows. Without knowing the target OS before-hand
-          # we can't assume whether the path separator is '/' or '\'. Assume we're connecting
-          # to a target with Unix and then check if the path exists after downloading.
           download = File.join(destination, Bolt::Util.unix_basename(source))
 
-          conn.download_file(source, destination, download)
+          # If using run-as, the file is copied to a tmpdir and chowned to the
+          # connecting user. This is a workaround for limitations in net-ssh that
+          # only allow for downloading files as the connecting user, which is a
+          # problem for users who cannot connect to targets as the root user.
+          # This temporary copy should *always* be deleted.
+          if run_as
+            with_tmpdir(force_cleanup: true) do |dir|
+              tmpfile = File.join(dir.to_s, Bolt::Util.unix_basename(source))
+
+              result = execute(['cp', '-r', source, dir.to_s], sudoable: true)
+
+              if result.exit_code != 0
+                message = "Could not copy file '#{source}' to temporary directory '#{dir}': #{result.stderr.string}"
+                raise Bolt::Node::FileError.new(message, 'CP_ERROR')
+              end
+
+              # We need to force the chown, otherwise this will just return
+              # without doing anything since the chown user is the same as the
+              # connecting user.
+              dir.chown(conn.user, force: true)
 
-          # If the download path doesn't exist, then the file was likely downloaded from Windows
-          # using a source path with backslashes (e.g. 'C:\Users\Administrator\foo'). The file
-          # should be saved to the expected location, so update the download path assuming a
-          # Windows basename so the result shows the correct local path.
-          unless File.exist?(download)
-            download = File.join(destination, Bolt::Util.windows_basename(source))
+              conn.download_file(tmpfile, destination, download)
+            end
+          # If not using run-as, we can skip creating a temporary copy and just
+          # download the file directly.
+          else
+            conn.download_file(source, destination, download)
           end
 
           Bolt::Result.for_download(target, source, destination, download)
@@ -145,7 +160,10 @@ module Bolt
 
             dir.chown(run_as)
 
-            execute_options[:stdin] = stdin
+            # Don't pass parameters on stdin if using a tty, as the parameters are
+            # already part of the wrapper script.
+            execute_options[:stdin] = stdin unless stdin && target.options['tty']
+
             execute_options[:sudoable] = true if run_as
             output = execute(remote_task_path, **execute_options)
           end
@@ -291,12 +309,12 @@ module Bolt
 
       # A helper to create and delete a tmpdir on the remote system. Yields the
       # directory name.
-      def with_tmpdir
+      def with_tmpdir(force_cleanup: false)
         dir = make_tmpdir
         yield dir
       ensure
         if dir
-          if target.options['cleanup']
+          if target.options['cleanup'] || force_cleanup
             dir.delete
           else
             Bolt::Logger.warn("skip_cleanup", "Skipping cleanup of tmpdir #{dir}")
@@ -390,14 +408,23 @@ module Bolt
           # See if we can read from out or err, or write to in
           ready_read, ready_write, = select(read_streams.keys, write_stream, nil, timeout)
 
-          # Read from out and err
           ready_read&.each do |stream|
+            stream_name = stream == out ? 'out' : 'err'
             # Check for sudo prompt
-            read_streams[stream] << if use_sudo
-                                      check_sudo(stream, inp, options[:stdin])
-                                    else
-                                      stream.readpartial(CHUNK_SIZE)
-                                    end
+            to_print = if use_sudo
+                         check_sudo(stream, inp, options[:stdin])
+                       else
+                         stream.readpartial(CHUNK_SIZE)
+                       end
+
+            if !to_print.chomp.empty? && @stream_logger
+              formatted = to_print.lines.map do |msg|
+                "[#{@target.safe_name}] #{stream_name}: #{msg.chomp}"
+              end.join("\n")
+              @stream_logger.warn(formatted)
+            end
+
+            read_streams[stream] << to_print
           rescue EOFError
           end
 
@@ -445,7 +472,7 @@ module Bolt
         when 0
           @logger.trace { "Command `#{command_str}` returned successfully" }
         when 126
-          msg = "\n\nThis may be caused by the default tmpdir being mounted "\
+          msg = "\n\nThis might be caused by the default tmpdir being mounted "\
             "using 'noexec'. See http://pup.pt/task-failure for details and workarounds."
           result_output.stderr << msg
           @logger.trace { "Command #{command_str} failed with exit code #{result_output.exit_code}" }

data/lib/bolt/shell/bash/tmpdir.rb

@@ -24,8 +24,8 @@ module Bolt
           end
         end
 
-        def chown(owner)
-          return if owner.nil? || owner == @owner
+        def chown(owner, force: false)
+          return if owner.nil? || (owner == @owner && !force)
 
           result = @shell.execute(['id', '-g', owner])
           if result.exit_code != 0

data/lib/bolt/shell/powershell.rb

@@ -208,16 +208,21 @@ module Bolt
         arguments = unwrap_sensitive_args(arguments)
         with_tmpdir do |dir|
           script_path = write_executable(dir, script)
-          command = if powershell_file?(script_path)
+          command = if powershell_file?(script_path) && options[:pwsh_params]
+                      # Scripts run with pwsh_params can be run like tasks
+                      Snippets.ps_task(script_path, options[:pwsh_params])
+                    elsif powershell_file?(script_path)
                       Snippets.run_script(arguments, script_path)
                     else
                       path, args = *process_from_extension(script_path)
                       args += escape_arguments(arguments)
                       execute_process(path, args)
                     end
-          command = [*env_declarations(options[:env_vars]), command].join("\r\n") if options[:env_vars]
+          env_assignments = options[:env_vars] ? env_declarations(options[:env_vars]) : []
+          shell_init = options[:pwsh_params] ? Snippets.shell_init : ''
+
+          output = execute([shell_init, *env_assignments, command].join("\r\n"))
 
-          output = execute(command)
           Bolt::Result.for_command(target,
                                    output.stdout.string,
                                    output.stderr.string,
@@ -310,12 +315,26 @@ module Bolt
           # the proper encoding so the string isn't later misinterpreted
           encoding = out.external_encoding
           out.binmode
-          result.stdout << out.read.force_encoding(encoding)
+          to_print = out.read.force_encoding(encoding)
+          if !to_print.chomp.empty? && @stream_logger
+            formatted = to_print.lines.map do |msg|
+              "[#{@target.safe_name}] out: #{msg.chomp}"
+            end.join("\n")
+            @stream_logger.warn(formatted)
+          end
+          result.stdout << to_print
         end
         stderr = Thread.new do
           encoding = err.external_encoding
           err.binmode
-          result.stderr << err.read.force_encoding(encoding)
+          to_print = err.read.force_encoding(encoding)
+          if !to_print.chomp.empty? && @stream_logger
+            formatted = to_print.lines.map do |msg|
+              "[#{@target.safe_name}] err: #{msg.chomp}"
+            end.join("\n")
+            @stream_logger.warn(formatted)
+          end
+          result.stderr << to_print
         end
 
         stdout.join

data/lib/bolt/task.rb

@@ -148,7 +148,7 @@ module Bolt
 
       if unknown_keys.any?
         msg = "Metadata for task '#{@name}' contains unknown keys: #{unknown_keys.join(', ')}."
-        msg += " This could be a typo in the task metadata or may result in incorrect behavior."
+        msg += " This could be a typo in the task metadata or might result in incorrect behavior."
         Bolt::Logger.warn("unknown_task_metadata_keys", msg)
       end
     end

data/lib/bolt/transport/lxd.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'bolt/logger'
+require 'bolt/node/errors'
+require 'bolt/transport/simple'
+
+module Bolt
+  module Transport
+    class LXD < Simple
+      def provided_features
+        ['shell']
+      end
+
+      def with_connection(target, options = {})
+        Bolt::Logger.warn_once("lxd_experimental",
+                               "The LXD transport is experimental, and might "\
+                               "include breaking changes between minor versions.")
+        conn = Connection.new(target, options)
+        conn.connect
+        yield conn
+      end
+    end
+  end
+end
+
+require 'bolt/transport/lxd/connection'