opswalrus 1.0.40 → 1.0.43

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43969fb5bd89993b9f4fb4c127d8a63f7d074d79d08104609b3a43d4df3f6457
-  data.tar.gz: beca6e40dcabbe38815ef6ac2fe6581895ba8ea2dcb27ab314ad22d5ff2d47cd
+  metadata.gz: c95b5c18a56463ccb9dd8db68875978eb57e3e5311a73825e27b1c893486d1ec
+  data.tar.gz: '05889e0f2398083e580406575914265488eb97ce98db67aeac92536dc6bc1294'
 SHA512:
-  metadata.gz: be45244077503ac67da072c8d41cad8800553cb9dc243d49904de29588c20a93317543b3d2d2d97a8c7a74ca0a1abc6c0d2fa5d4187b1fe34d863e1e3e558218
-  data.tar.gz: 3cd42b3c126aef7dcec443c7f14fe9ee308da1d153148430b2413fe4166c4a214c43b0e368b485a4b3dd6cddf9c3047f778e55dbd4b99dc79697d75eaf910c72
+  metadata.gz: 8147ed4fa64cdd0c8125ef6c885fac72075fe4e211e8b31275b7961689d370f44ea10cde45f83df352e35dab4d06c1a4cadd063286bb34d9d29312f8a943213c
+  data.tar.gz: fdb7a00079382392fc1631f85a64f8939936e9731586fed8c9a63c42557f59540665889376f4e2deec382c08c39d32bab52ce9e62dabbfd50eba87bd1d1397be

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    opswalrus (1.0.40)
+    opswalrus (1.0.43)
       bcrypt_pbkdf (~> 1.1)
       binding_of_caller (~> 1.0)
       citrus (~> 3.0)

data/lib/opswalrus/bootstrap.sh

@@ -27,7 +27,7 @@ if [ -x $RTX ]; then
 
       # make sure the latest opswalrus gem is installed
       # todo: figure out how to install this differently, so that test versions will work
-      # gem install opswalrus
+      gem install opswalrus
       # $GEM_CMD install opswalrus
       $RTX reshim
 

data/lib/opswalrus/host.rb

@@ -1,5 +1,6 @@
 require "set"
 require "sshkit"
+require "stringio"
 require "tempfile"
 
 require_relative "interaction_handlers"
@@ -30,12 +31,12 @@ module OpsWalrus
             # we know we're dealing with a package dependency reference, so we want to run an ops file contained within the bundle directory,
             # therefore, we want to reference the specified ops file with respect to the bundle dir
             when PackageDependencyReference
-              RemoteImportInvocationContext.new(@runtime_env, self, namespace_or_ops_file, true, prompt_for_sudo_password: !!ssh_password)
+              RemoteImportInvocationContext.new(@runtime_env, self, namespace_or_ops_file, true, ops_prompt_for_sudo_password: !!ssh_password)
 
             # we know we're dealing with a directory reference or OpsFile reference outside of the bundle dir, so we want to reference
             # the specified ops file with respect to the root directory, and not with respect to the bundle dir
             when DirectoryReference, OpsFileReference
-              RemoteImportInvocationContext.new(@runtime_env, self, namespace_or_ops_file, false, prompt_for_sudo_password: !!ssh_password)
+              RemoteImportInvocationContext.new(@runtime_env, self, namespace_or_ops_file, false, ops_prompt_for_sudo_password: !!ssh_password)
             end
 
             invocation_context._invoke(*args, **kwargs)
@@ -56,7 +57,7 @@ module OpsWalrus
             namespace_or_ops_file = @runtime_env.resolve_sibling_symbol(ops_file, symbol_name)
             App.instance.trace "namespace_or_ops_file=#{namespace_or_ops_file.to_s}"
 
-            invocation_context = RemoteImportInvocationContext.new(@runtime_env, self, namespace_or_ops_file, false, prompt_for_sudo_password: !!ssh_password)
+            invocation_context = RemoteImportInvocationContext.new(@runtime_env, self, namespace_or_ops_file, false, ops_prompt_for_sudo_password: !!ssh_password)
             invocation_context._invoke(*args, **kwargs)
           end
           methods_defined << symbol_name
@@ -143,7 +144,7 @@ module OpsWalrus
     end
 
     # returns the tuple: [stdout, stderr, exit_status]
-    def shell!(desc_or_cmd = nil, cmd = nil, block = nil, input: nil, log_level: nil)
+    def shell!(desc_or_cmd = nil, cmd = nil, block = nil, input: nil, log_level: nil, ops_prompt_for_sudo_password: false)
       # description = nil
 
       return ["", "", 0] if !desc_or_cmd && !cmd && !block    # we were told to do nothing; like hitting enter at the bash prompt; we can do nothing successfully
@@ -171,14 +172,17 @@ module OpsWalrus
 
       cmd_id = Random.uuid.split('-').first
       # if App.instance.report_mode?
-      puts Style.green("*" * 80)
-      print Style.blue(host)
-      print " (#{Style.blue(self.alias)})" if self.alias
-      print " | #{Style.magenta(description)}" if description
-      puts
-      print Style.yellow(cmd_id)
-      print Style.green.bold(" > ")
-      puts Style.yellow(cmd)
+      output_block = StringIO.open do |io|
+        io.print Style.blue(host)
+        io.print " (#{Style.blue(self.alias)})" if self.alias
+        io.print " | #{Style.magenta(description)}" if description
+        io.puts
+        io.print Style.yellow(cmd_id)
+        io.print Style.green.bold(" > ")
+        io.puts Style.yellow(cmd)
+        io.string
+      end
+      puts output_block
 
         # puts Style.green("*" * 80)
         # if self.alias
@@ -196,35 +200,40 @@ module OpsWalrus
       out, err, exit_status = if App.instance.dry_run?
         ["", "", 0]
       else
-        sshkit_cmd = execute_cmd(cmd, input: input)
+        sshkit_cmd = execute_cmd(cmd, input_mapping: input, ops_prompt_for_sudo_password: ops_prompt_for_sudo_password)
         [sshkit_cmd.full_stdout, sshkit_cmd.full_stderr, sshkit_cmd.exit_status]
       end
       t2 = Time.now
       seconds = t2 - t1
 
-      if App.instance.info? || log_level == :info
-        puts Style.cyan(out)
-        puts Style.red(err)
-      elsif App.instance.debug? || log_level == :debug
-        puts Style.cyan(out)
-        puts Style.red(err)
-      elsif App.instance.trace? || log_level == :trace
-        puts Style.cyan(out)
-        puts Style.red(err)
-      end
-      print Style.yellow(cmd_id)
-      print Style.blue(" | Finished in #{seconds} seconds with exit status ")
-      if exit_status == 0
-        puts Style.green("#{exit_status} (#{exit_status == 0 ? 'success' : 'failure'})")
-      else
-        puts Style.red("#{exit_status} (#{exit_status == 0 ? 'success' : 'failure'})")
+      output_block = StringIO.open do |io|
+        if App.instance.info? || log_level == :info
+          io.puts Style.cyan(out)
+          io.puts Style.red(err)
+        elsif App.instance.debug? || log_level == :debug
+          io.puts Style.cyan(out)
+          io.puts Style.red(err)
+        elsif App.instance.trace? || log_level == :trace
+          io.puts Style.cyan(out)
+          io.puts Style.red(err)
+        end
+        io.print Style.yellow(cmd_id)
+        io.print Style.blue(" | Finished in #{seconds} seconds with exit status ")
+        if exit_status == 0
+          io.puts Style.green("#{exit_status} (#{exit_status == 0 ? 'success' : 'failure'})")
+        else
+          io.puts Style.red("#{exit_status} (#{exit_status == 0 ? 'success' : 'failure'})")
+        end
+        io.puts Style.green("*" * 80)
+        io.string
       end
+      puts output_block
 
       [out, err, exit_status]
     end
 
     # runs the specified ops command with the specified command arguments
-    def run_ops(ops_command, ops_command_options = nil, command_arguments, in_bundle_root_dir: true)
+    def run_ops(ops_command, ops_command_options = nil, command_arguments, in_bundle_root_dir: true, ops_prompt_for_sudo_password: false)
       local_hostname_for_remote_host = if self.alias
         "#{host} (#{self.alias})"
       else
@@ -245,11 +254,11 @@ module OpsWalrus
       cmd << " #{@tmp_bundle_root_dir}" if in_bundle_root_dir
       cmd << " #{command_arguments}" unless command_arguments.empty?
 
-      shell!(cmd, log_level: :info)
+      shell!(cmd, log_level: :info, ops_prompt_for_sudo_password: ops_prompt_for_sudo_password)
     end
 
     def desc(msg)
-      puts msg.mustache(2)    # we use two here, because one stack frame accounts for the call from the ops script into HostProxy#desc
+      puts Style.green(msg.mustache(2))    # we use two here, because one stack frame accounts for the call from the ops script into HostProxy#desc
     end
 
     def env(*args, **kwargs)
@@ -414,16 +423,28 @@ module OpsWalrus
       @tmp_ssh_key_files = []
     end
 
-    def execute(*args, input: nil)
-      @runtime_env.handle_input(input, ssh_password) do |interaction_handler|
+    def execute(*args, input_mapping: nil, ops_prompt_for_sudo_password: false)
+      sudo_password_args = {}
+      sudo_password_args[:sudo_password] = ssh_password unless ops_prompt_for_sudo_password
+      sudo_password_args[:ops_sudo_password] = ssh_password if ops_prompt_for_sudo_password
+      @runtime_env.handle_input(input_mapping, **sudo_password_args) do |interaction_handler|
         # @sshkit_backend.capture(*args, interaction_handler: interaction_handler, verbosity: SSHKit.config.output_verbosity)
+        App.instance.debug("Host#execute_cmd(#{args.inspect}) with input mappings #{interaction_handler.input_mappings.inspect} given sudo_password_args: #{sudo_password_args.inspect})")
         @sshkit_backend.capture(*args, interaction_handler: interaction_handler)
       end
     end
 
-    def execute_cmd(*args, input: nil)
-      @runtime_env.handle_input(input, ssh_password) do |interaction_handler|
-        # @sshkit_backend.execute_cmd(*args, interaction_handler: interaction_handler, verbosity: SSHKit.config.output_verbosity)
+    def execute_cmd(*args, input_mapping: nil, ops_prompt_for_sudo_password: false)
+      # we only want one of the sudo password interaction handlers:
+      # if we're running an ops script on the remote host and we've passed the --pass flag in our invocation of the ops command on the remote host,
+      #   then we want to specify the sudo password via the ops_sudo_password argument to #handle_input
+      # if we're running a command on the remote host via #shell!, and we aren't running the ops command with the --pass flag,
+      #   then we want to specify the sudo password via the sudo_password argument to #handle_input
+      sudo_password_args = {}
+      sudo_password_args[:sudo_password] = ssh_password unless ops_prompt_for_sudo_password
+      sudo_password_args[:ops_sudo_password] = ssh_password if ops_prompt_for_sudo_password
+      @runtime_env.handle_input(input_mapping, **sudo_password_args) do |interaction_handler|
+        App.instance.debug("Host#execute_cmd(#{args.inspect}) with input mappings #{interaction_handler.input_mappings.inspect} given sudo_password_args: #{sudo_password_args.inspect})")
         @sshkit_backend.execute_cmd(*args, interaction_handler: interaction_handler)
       end
     end

data/lib/opswalrus/interaction_handlers.rb

@@ -3,6 +3,8 @@ require 'sshkit'
 module OpsWalrus
 
   class ScopedMappingInteractionHandler
+    STANDARD_SUDO_PASSWORD_PROMPT = /\[sudo\] password for .*?:\s*/
+
     attr_accessor :input_mappings   # Hash[ String | Regex => String ]
 
     # log_level is one of: :fatal, :error, :warn, :info, :debug, :trace
@@ -11,41 +13,48 @@ module OpsWalrus
       @input_mappings = mapping
     end
 
-    # temporarily adds a sudo password mapping to the interaction handler while the given block is being evaluated
-    # when the given block returns, then the temporary mapping is removed from the interaction handler
-    # def with_sudo_password(password, &block)
-    #   with_mapping({
-    #     /\[sudo\] password for .*?:\s*/ => "#{password}\n",
-    #     App::LOCAL_SUDO_PASSWORD_PROMPT => "#{password}\n",
-    #     # /\s+/ => nil,     # unnecessary
-    #   }, &block)
-    # end
-
-    # sudo_password : String
+    # sudo_password : String | Nil
     def self.mapping_for_sudo_password(sudo_password)
+      password_response = sudo_password && ::SSHKit::InteractionHandler::Password.new("#{sudo_password}\n")
       {
-        /\[sudo\] password for .*?:\s*/ => "#{sudo_password}\n",
-        App::LOCAL_SUDO_PASSWORD_PROMPT => "#{sudo_password}\n",
+        STANDARD_SUDO_PASSWORD_PROMPT => password_response,
+      }
+    end
+
+    # sudo_password : String | Nil
+    def self.mapping_for_ops_sudo_prompt(sudo_password)
+      password_response = sudo_password && ::SSHKit::InteractionHandler::Password.new("#{sudo_password}\n")
+      {
+        App::LOCAL_SUDO_PASSWORD_PROMPT => password_response,
       }
     end
 
     # temporarily adds the specified input mapping to the interaction handler while the given block is being evaluated
     # when the given block returns, then the temporary mapping is removed from the interaction handler
     #
-    # mapping : Hash[ String | Regex => String ]
-    def with_mapping(mapping, sudo_password = nil)
-      mapping ||= {}
+    # mapping : Hash[ String | Regex => String ] | Nil
+    def with_mapping(mapping = nil, sudo_password: nil, ops_sudo_password: nil, inherit_existing_mappings: false)
+      new_mapping = inherit_existing_mappings ? @input_mappings : {}
 
-      raise ArgumentError.new("mapping must be a Hash") unless mapping.is_a?(Hash)
+      if mapping
+        raise ArgumentError.new("mapping must be a Hash") unless mapping.is_a?(Hash)
+        new_mapping.merge!(mapping)
+      end
 
-      if sudo_password
-        mapping.merge!(ScopedMappingInteractionHandler.mapping_for_sudo_password(sudo_password))
+      # ops_sudo_password takes precedence over sudo_password
+      password_mappings = if ops_sudo_password
+        ScopedMappingInteractionHandler.mapping_for_ops_sudo_prompt(ops_sudo_password).
+          merge(ScopedMappingInteractionHandler.mapping_for_sudo_password(nil))
+      elsif sudo_password
+        ScopedMappingInteractionHandler.mapping_for_sudo_password(sudo_password).
+          merge(ScopedMappingInteractionHandler.mapping_for_ops_sudo_prompt(nil))
       end
+      new_mapping.merge!(password_mappings) if password_mappings
 
-      if mapping.empty?
+      if new_mapping.empty?
         yield self
       else
-        yield ScopedMappingInteractionHandler.new(@input_mappings.merge(mapping), @log_level)
+        yield ScopedMappingInteractionHandler.new(new_mapping, @log_level)
       end
     end
 
@@ -56,7 +65,18 @@ module OpsWalrus
       @input_mappings.merge!(mapping)
     end
 
-    def on_data(_command, stream_name, data, channel)
+    # cmd, :stdout, data, stdin
+    # the return value from on_data is returned to Command#call_interaction_handler which is then returned verbatim
+    # to Command#on_stdout, which is then returned verbatim to the backend that called #on_stdout, and in my case
+    # that is LocalPty#handle_data_for_stdout.
+    # So, LocalPty#handle_data_for_stdout -> Command#on_stdout -> Command#call_interaction_handler -> ScopedMappingInteractionHandler#on_data
+    # which means that if I return that a password was emitted from this method, then back in LocalPty#handle_data_for_stdout
+    # I can discard the subsequent line that I read from stdout in order to read and immediately discard the password
+    # that this interaction handler emits.
+    #
+    # This method returns the data that is emitted to the response channel as a result of having processed the output
+    # from a command that the interaction handler was expecting.
+    def on_data(_command, stream_name, data, response_channel)
       response_data = begin
         first_matching_key_value_pair = @input_mappings.find {|k, _v| k === data }
         first_matching_key_value_pair&.last
@@ -67,14 +87,18 @@ module OpsWalrus
       else
         debug(Style.cyan("Handling #{stream_name} message #{data}"))
         debug(Style.cyan("Sending response #{response_data}"))
-        if channel.respond_to?(:send_data)  # Net SSH Channel
-          channel.send_data(response_data)
-        elsif channel.respond_to?(:write)   # Local IO
-          channel.write(response_data)
+        if response_channel.respond_to?(:send_data)  # Net SSH Channel
+          App.instance.trace "writing: #{response_data.to_s} to Net SSH Channel"
+          response_channel.send_data(response_data.to_s)
+        elsif response_channel.respond_to?(:write)   # Local IO (stdin)
+          App.instance.trace "writing: #{response_data.to_s} to pty stdin"
+          response_channel.write(response_data.to_s)
         else
           raise "Unable to write response data to channel #{channel.inspect} - does not support '#send_data' or '#write'"
         end
       end
+
+      response_data
     end
 
     private
@@ -89,49 +113,49 @@ module OpsWalrus
 
   end
 
-  class PasswdInteractionHandler
-    def on_data(command, stream_name, data, channel)
-      case data
-      when '(current) UNIX password: '
-        channel.send_data("old_pw\n")
-      when 'Enter new UNIX password: ', 'Retype new UNIX password: '
-        channel.send_data("new_pw\n")
-      when 'passwd: password updated successfully'
-      else
-        raise "Unexpected stderr #{stderr}"
-    end
-    end
-  end
-
-  class SudoPasswordMapper
-    def initialize(sudo_password)
-      @sudo_password = sudo_password
-    end
-
-    def interaction_handler
-      SSHKit::MappingInteractionHandler.new({
-        /\[sudo\] password for .*?:\s*/ => "#{@sudo_password}\n",
-        App::LOCAL_SUDO_PASSWORD_PROMPT => "#{@sudo_password}\n",
-        # /\s+/ => nil,     # unnecessary
-      }, :info)
-    end
-  end
-
-  class SudoPromptInteractionHandler
-    def on_data(command, stream_name, data, channel)
-      case data
-      when /\[sudo\] password for/
-        if channel.respond_to?(:send_data)  # Net::SSH channel
-          channel.send_data("conquer\n")
-        elsif channel.respond_to?(:write)   # IO
-          channel.write("conquer\n")
-        end
-      when /\s+/
-        nil
-      else
-        raise "Unexpected prompt: #{data} on stream #{stream_name} and channel #{channel.inspect}"
-      end
-    end
-  end
+  # class PasswdInteractionHandler
+  #   def on_data(command, stream_name, data, channel)
+  #     case data
+  #     when '(current) UNIX password: '
+  #       channel.send_data("old_pw\n")
+  #     when 'Enter new UNIX password: ', 'Retype new UNIX password: '
+  #       channel.send_data("new_pw\n")
+  #     when 'passwd: password updated successfully'
+  #     else
+  #       raise "Unexpected stderr #{stderr}"
+  #   end
+  #   end
+  # end
+
+  # class SudoPasswordMapper
+  #   def initialize(sudo_password)
+  #     @sudo_password = sudo_password
+  #   end
+
+  #   def interaction_handler
+  #     SSHKit::MappingInteractionHandler.new({
+  #       /\[sudo\] password for .*?:\s*/ => "#{@sudo_password}\n",
+  #       App::LOCAL_SUDO_PASSWORD_PROMPT => "#{@sudo_password}\n",
+  #       # /\s+/ => nil,     # unnecessary
+  #     }, :info)
+  #   end
+  # end
+
+  # class SudoPromptInteractionHandler
+  #   def on_data(command, stream_name, data, channel)
+  #     case data
+  #     when /\[sudo\] password for/
+  #       if channel.respond_to?(:send_data)  # Net::SSH channel
+  #         channel.send_data("conquer\n")
+  #       elsif channel.respond_to?(:write)   # IO
+  #         channel.write("conquer\n")
+  #       end
+  #     when /\s+/
+  #       nil
+  #     else
+  #       raise "Unexpected prompt: #{data} on stream #{stream_name} and channel #{channel.inspect}"
+  #     end
+  #   end
+  # end
 
 end

data/lib/opswalrus/invocation.rb

@@ -26,7 +26,7 @@ module OpsWalrus
   end
 
   class RemoteImportInvocationContext < ImportInvocationContext
-    def initialize(runtime_env, host_proxy, namespace_or_ops_file, is_invocation_a_call_to_package_in_bundle_dir = false, prompt_for_sudo_password: nil)
+    def initialize(runtime_env, host_proxy, namespace_or_ops_file, is_invocation_a_call_to_package_in_bundle_dir = false, ops_prompt_for_sudo_password: nil)
       @runtime_env = runtime_env
       @host_proxy = host_proxy
       @initial_namespace_or_ops_file = @namespace_or_ops_file = namespace_or_ops_file
@@ -39,7 +39,7 @@ module OpsWalrus
         @namespace_or_ops_file.basename
       end
       @method_chain = [initial_method_name]
-      @prompt_for_sudo_password = prompt_for_sudo_password
+      @ops_prompt_for_sudo_password = ops_prompt_for_sudo_password
     end
 
     def method_missing(name, *args, **kwargs, &block)
@@ -123,12 +123,12 @@ module OpsWalrus
 
         # invoke the ops command on the remote host to run the specified ops script on the remote host
         ops_command_options = ""
-        ops_command_options << "--pass" if @prompt_for_sudo_password
+        ops_command_options << "--pass" if @ops_prompt_for_sudo_password
         ops_command_options << " --params #{remote_json_kwargs_tempfile_basename}" if remote_json_kwargs_tempfile_basename
         retval = if ops_command_options.empty?
-          @host_proxy.run_ops(:run, remote_run_command_args)
+          @host_proxy.run_ops(:run, remote_run_command_args, ops_prompt_for_sudo_password: @ops_prompt_for_sudo_password)
         else
-          @host_proxy.run_ops(:run, ops_command_options, remote_run_command_args)
+          @host_proxy.run_ops(:run, ops_command_options, remote_run_command_args, ops_prompt_for_sudo_password: @ops_prompt_for_sudo_password)
         end
 
         retval

data/lib/opswalrus/local_pty_backend.rb

@@ -1,6 +1,5 @@
 require 'open3'
 require 'pty'
-require 'fileutils'
 
 module SSHKit
 
@@ -14,6 +13,8 @@ module SSHKit
       def execute_command(cmd)
         output.log_command_start(cmd.with_redaction)
         cmd.started = Time.now
+        # stderr_reader, stderr_writer = IO.pipe
+        # PTY.spawn(cmd.to_command, err: stderr_writer.fileno) do |stdout, stdin, pid|
         PTY.spawn(cmd.to_command) do |stdout, stdin, pid|
           stdout_thread = Thread.new do
             # debug_log = StringIO.new
@@ -30,7 +31,7 @@ module SSHKit
                 # puts "nonblocking1. buffer=#{buffer} partial_buffer=#{partial_buffer}"
                 buffer = handle_data_for_stdout(output, cmd, buffer, stdin, false)
                 # puts "nonblocking2. buffer=#{buffer} partial_buffer=#{partial_buffer}"
-              rescue IO::WaitReadable, Errno::EAGAIN, Errno::EWOULDBLOCK
+              rescue IO::WaitReadable, Errno::EAGAIN, Errno::EWOULDBLOCK, IO::EAGAINWaitReadable
                 # puts "blocking. buffer=#{buffer} partial_buffer=#{partial_buffer}"
                 buffer = handle_data_for_stdout(output, cmd, buffer, stdin, true)
                 IO.select([stdout])
@@ -60,33 +61,46 @@ module SSHKit
           end
           stdout_thread.join
           _pid, status = Process.wait2(pid)
+          # stderr_writer.close
+          # output.log_command_data(cmd, :stderr, stderr_reader.read)
           cmd.exit_status = status.exitstatus
           output.log_command_exit(cmd)
         end
+      # ensure
+      #   stderr_reader.close
       end
 
       # returns [complete lines, new buffer]
       def split_buffer(buffer)
-        lines = buffer.split(/(\r\n)|\r|\n/)
+        # lines = buffer.split(/(\r\n)|\r|\n/)
+        lines = buffer.lines("\r\n").flat_map {|line| line.lines("\r") }.flat_map {|line| line.lines("\n") }
         buffer = lines.pop
         [lines, buffer]
       end
 
+      # todo: we want to allow for cmd.on_stdout to invoke the interactionhandlers, but we want our interaction handler
+      # to be able to indicate that a password has been emitted, and therefore should be read back and omitted from the
+      # logged output because, per https://toasterlovin.com/using-the-pty-class-to-test-interactive-cli-apps-in-ruby/,
+      # the behavior of a PTY is to echo back any input was typed into the pseudoterminal, which means we will need to
+      # discard the input that we type in for password prompts, to ensure that the password is not logged as part
+      # of the stdout that we get back as we read from stdout of the spawned process
       def handle_data_for_stdout(output, cmd, buffer, stdin, is_blocked)
-        # puts "handling data for stdout: #{buffer}"
-
         # we're blocked on reading, so let's process the buffer
         lines, buffer = split_buffer(buffer)
         lines.each do |line|
-          # puts "1" * 80
-          # puts line
-          cmd.on_stdout(stdin, line)
+          ::OpsWalrus::App.instance.trace("line=|>#{line}<|")
+          emitted_response_from_interaction_handler = cmd.on_stdout(stdin, line)
+          if emitted_response_from_interaction_handler.is_a?(::SSHKit::InteractionHandler::Password)
+            ::OpsWalrus::App.instance.trace("emitted password #{emitted_response_from_interaction_handler}")
+          end
           output.log_command_data(cmd, :stdout, line)
         end
         if is_blocked && buffer
-          # puts "2" * 80
-          # puts buffer
-          cmd.on_stdout(stdin, buffer)
+          ::OpsWalrus::App.instance.trace("line=|>#{buffer}<|")
+          emitted_response_from_interaction_handler = cmd.on_stdout(stdin, buffer)
+          if emitted_response_from_interaction_handler.is_a?(::SSHKit::InteractionHandler::Password)
+            ::OpsWalrus::App.instance.trace("emitted password #{emitted_response_from_interaction_handler}")
+          end
           output.log_command_data(cmd, :stdout, buffer)
           buffer = ""
         end

data/lib/opswalrus/ops_file_script_dsl.rb

@@ -191,7 +191,7 @@ module OpsWalrus
     end
 
     def desc(msg)
-      puts msg.mustache(1)
+      puts Style.green(msg.mustache(1))
     end
 
     def env(*keys)
@@ -224,8 +224,6 @@ module OpsWalrus
 
     # returns the tuple: [stdout, stderr, exit_status]
     def shell!(desc_or_cmd = nil, cmd = nil, block = nil, input: nil, log_level: nil)
-      # description = nil
-
       return ["", "", 0] if !desc_or_cmd && !cmd && !block    # we were told to do nothing; like hitting enter at the bash prompt; we can do nothing successfully
 
       description = desc_or_cmd if cmd || block
@@ -245,22 +243,20 @@ module OpsWalrus
       else
         cmd
       end
-      # cmd = WalrusLang.eval(cmd) if !block && cmd =~ /{{.*}}/
-      # cmd = WalrusLang.render(cmd, block.binding) if block && cmd =~ /{{.*}}/
-
       #cmd = Shellwords.escape(cmd)
 
       cmd_id = Random.uuid.split('-').first
 
-      # if App.instance.report_mode?
-      puts Style.green("*" * 80)
-      print Style.blue(@runtime_env.local_hostname)
-      print " | #{Style.magenta(description)}" if description
-      puts
-      print Style.yellow(cmd_id)
-      print Style.green.bold(" > ")
-      puts Style.yellow(cmd)
-      # end
+      output_block = StringIO.open do |io|
+        io.print Style.blue(@runtime_env.local_hostname)
+        io.print " | #{Style.magenta(description)}" if description
+        io.puts
+        io.print Style.yellow(cmd_id)
+        io.print Style.green.bold(" > ")
+        io.puts Style.yellow(cmd)
+        io.string
+      end
+      puts output_block
 
       return unless cmd && !cmd.strip.empty?
 
@@ -278,24 +274,28 @@ module OpsWalrus
       t2 = Time.now
       seconds = t2 - t1
 
-      if App.instance.info? || log_level == :info
-        puts Style.cyan(out)
-        puts Style.red(err)
-      elsif App.instance.debug? || log_level == :debug
-        puts Style.cyan(out)
-        puts Style.red(err)
-      elsif App.instance.trace? || log_level == :trace
-        puts Style.cyan(out)
-        puts Style.red(err)
-      end
-      print Style.yellow(cmd_id)
-      print Style.blue(" | Finished in #{seconds} seconds with exit status ")
-      if exit_status == 0
-        puts Style.green("#{exit_status} (#{exit_status == 0 ? 'success' : 'failure'})")
-      else
-        puts Style.red("#{exit_status} (#{exit_status == 0 ? 'success' : 'failure'})")
+      output_block = StringIO.open do |io|
+        if App.instance.info? || log_level == :info
+          io.puts Style.cyan(out)
+          io.puts Style.red(err)
+        elsif App.instance.debug? || log_level == :debug
+          io.puts Style.cyan(out)
+          io.puts Style.red(err)
+        elsif App.instance.trace? || log_level == :trace
+          io.puts Style.cyan(out)
+          io.puts Style.red(err)
+        end
+        io.print Style.yellow(cmd_id)
+        io.print Style.blue(" | Finished in #{seconds} seconds with exit status ")
+        if exit_status == 0
+          io.puts Style.green("#{exit_status} (#{exit_status == 0 ? 'success' : 'failure'})")
+        else
+          io.puts Style.red("#{exit_status} (#{exit_status == 0 ? 'success' : 'failure'})")
+        end
+        io.puts Style.green("*" * 80)
+        io.string
       end
-
+      puts output_block
 
       [out, err, exit_status]
     end

data/lib/opswalrus/runtime_environment.rb

@@ -258,8 +258,14 @@ module OpsWalrus
 
     # input_mapping : Hash[ String | Regex => String ]
     # sudo_password : String
-    def handle_input(input_mapping, sudo_password = nil, &block)
-      @interaction_handler.with_mapping(input_mapping, sudo_password, &block)
+    def handle_input(input_mapping, sudo_password: nil, ops_sudo_password: nil, inherit_existing_mappings: false, &block)
+      @interaction_handler.with_mapping(
+        input_mapping,
+        sudo_password: sudo_password,
+        ops_sudo_password: ops_sudo_password,
+        inherit_existing_mappings: inherit_existing_mappings,
+        &block
+      )
     end
 
     # configure sshkit globally
@@ -267,16 +273,10 @@ module OpsWalrus
       SSHKit.config.use_format :blackhole
       SSHKit.config.output_verbosity = :info
 
-      # if app.info?
-      #   SSHKit.config.use_format :pretty
-      #   SSHKit.config.output_verbosity = :info
-      # elsif app.debug?
-      #   SSHKit.config.use_format :pretty
-      #   SSHKit.config.output_verbosity = :debug
-      # elsif app.trace?
-      #   SSHKit.config.use_format :pretty
-      #   SSHKit.config.output_verbosity = :debug
-      # end
+      if app.debug? || app.trace?
+        SSHKit.config.use_format :pretty
+        SSHKit.config.output_verbosity = :debug
+      end
 
       SSHKit::Backend::Netssh.configure do |ssh|
         ssh.pty = true                # necessary for interaction with sudo on the remote host

data/lib/opswalrus/sshkit_ext.rb

@@ -7,6 +7,11 @@ require_relative 'local_non_blocking_backend'
 require_relative 'local_pty_backend'
 
 module SSHKit
+  module InteractionHandler
+    class Password < String
+    end
+  end
+
   module Backend
     class Abstract
       # def execute(*args)
@@ -15,18 +20,12 @@ module SSHKit
       # end
 
       def execute_cmd(*args)
-        options = { verbosity: :debug, strip: true, raise_on_non_zero_exit: false }.merge(args.extract_options!)
+        options = { verbosity: :info, strip: true, raise_on_non_zero_exit: false }.merge(args.extract_options!)
         create_command_and_execute(args, options)
       end
     end
   end
 
-  # module Formatter
-  #   class Pretty < Abstract
-
-  #   end
-  # end
-
   module Runner
     class Sequential < Abstract
       def run_backend(host, &block)

data/lib/opswalrus/version.rb

@@ -1,3 +1,3 @@
 module OpsWalrus
-  VERSION = "1.0.40"
+  VERSION = "1.0.43"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opswalrus
 version: !ruby/object:Gem::Version
-  version: 1.0.40
+  version: 1.0.43
 platform: ruby
 authors:
 - David Ellis
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-07 00:00:00.000000000 Z
+date: 2023-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: binding_of_caller