opswalrus 1.0.6 → 1.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6a371b7cd41b84c0ea93f89180204ea580b2a8d20c9d8686639663e6bf31379
-  data.tar.gz: b27a653685068ba101cb89990a3fcd74b4eab39337f9592f35b9cc41f0014a48
+  metadata.gz: b0c1c00f88ff00a4f7eb735a634ea35e1e8818b44fffdccea7a2347bac78e199
+  data.tar.gz: fe54254076c753cfeaf26906fa0f7475bd11807c0ac70d4067da03653b0f774c
 SHA512:
-  metadata.gz: 5928f1f07bc4ddd13f630c3967a73a196ec21999cbc1cf5d30247bd24dbec940c7fe207ff37520158b787ef635a70b41add3c6f3614d1000881ddda509361f3d
-  data.tar.gz: e89db2ddc7e4b97dfcd2df4e01d2a525e0a5a8757283d1de2f136c8dd3fa64a4f04aa6daaf1efe81d812c622dc2572df996b19aa66dcb9cf664826b4c38a82b9
+  metadata.gz: 28244a51a465941731663e9db3901049d36d1fa385a16b4c5ed9254c31fa62ca44012c2d776ef5b6d1d06906c012802b1352e166d72d28b3ec0aa6f9e27073f5
+  data.tar.gz: 39ccb70ca9dc5b2ecf67b1ab29adb7ccc79cb43ad57d256be0deb68b49909bc4c5cd4ddc2871e68aeeb374ed3d0202c365094536e7933f61c3ecf700a2178076

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    opswalrus (1.0.6)
+    opswalrus (1.0.7)
       bcrypt_pbkdf (~> 1.1)
       citrus (~> 3.0)
       ed25519 (~> 1.3)

data/build.ops

@@ -7,6 +7,8 @@ imports:
 
 version = params.version
 
+exit 1, "version parameter must be specified" unless version
+
 template = <<TEMPLATE
 module OpsWalrus
   VERSION = "{{ version }}"
@@ -17,4 +19,22 @@ puts "Write version.rb for version #{version}"
 core.template.write(path: "./lib/opswalrus/version.rb", template: template, variables: {version: version})
 
 sh("Build gem") { 'gem build opswalrus.gemspec' }
+bw_status_output = sh("Check whether Bitwarden is locked or not") { 'bw status' }
+# the status command currently exhibits an error in which it emits 'mac failed.' some number of times, so we need to filter that out
+# see:
+# - https://community.bitwarden.com/t/what-does-mac-failed-mean-exactly/29208
+# - https://github.com/bitwarden/cli/issues/88
+# - https://github.com/vwxyzjn/portwarden/issues/22
+# ❯ bw status
+# mac failed.
+# {"serverUrl":"...","lastSync":"2023-08-17T19:14:09.384Z","userEmail":"...","userId":"...","status":"locked"}
+bw_status_output = bw_status_output.gsub('mac failed.', '').strip
+bw_status_json = bw_status_output.parse_json
+
+if bw_status_json['status'] != 'unlocked'
+  exit 0, "Bitwarden is not unlocked. Please unlock bitwarden with: bw unlock"
+end
+
+totp = sh("Get Rubygems OTP") { 'bw get totp Rubygems' }
+sh("Push gem", input: {"You have enabled multi-factor authentication. Please enter OTP code." => "#{totp}\n"}) { 'gem push opswalrus-{{ version }}.gem' }
 sh("Build docker image") { 'docker build -t opswalrus/ops:{{ version }} .' }

data/lib/opswalrus/app.rb

@@ -7,6 +7,7 @@ require "socket"
 require "stringio"
 require "yaml"
 require "pathname"
+require_relative "patches"
 require_relative "git"
 require_relative "host"
 require_relative "hosts_file"
@@ -14,21 +15,6 @@ require_relative "operation_runner"
 require_relative "bundler"
 require_relative "package_file"
 
-class String
-  def escape_single_quotes
-    gsub("'"){"\\'"}
-  end
-
-  def to_pathname
-    Pathname.new(self)
-  end
-end
-
-class Pathname
-  def to_pathname
-    self
-  end
-end
 
 module OpsWalrus
   class Error < StandardError
@@ -131,6 +117,7 @@ module OpsWalrus
     def prompt_sudo_password
       password = IO::console.getpass(LOCAL_SUDO_PASSWORD_PROMPT)
       set_sudo_password(password)
+      # puts "sudo password = |#{password}|"
       nil
     end
 

data/lib/opswalrus/host.rb

@@ -7,18 +7,18 @@ module OpsWalrus
 
   module HostDSL
     # returns the stdout from the command
-    def sh(desc_or_cmd = nil, cmd = nil, stdin: nil, &block)
-      out, err, status = *shell!(desc_or_cmd, cmd, block, stdin: stdin)
+    def sh(desc_or_cmd = nil, cmd = nil, input: nil, &block)
+      out, err, status = *shell!(desc_or_cmd, cmd, block, input: input)
       out
     end
 
     # returns the tuple: [stdout, stderr, exit_status]
-    def shell(desc_or_cmd = nil, cmd = nil, stdin: nil, &block)
-      shell!(desc_or_cmd, cmd, block, stdin: stdin)
+    def shell(desc_or_cmd = nil, cmd = nil, input: nil, &block)
+      shell!(desc_or_cmd, cmd, block, input: input)
     end
 
     # returns the tuple: [stdout, stderr, exit_status]
-    def shell!(desc_or_cmd = nil, cmd = nil, block = nil, stdin: nil)
+    def shell!(desc_or_cmd = nil, cmd = nil, block = nil, input: 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
@@ -45,7 +45,7 @@ module OpsWalrus
       # puts "shell: #{cmd.inspect}"
       # puts "sudo_password: #{sudo_password}"
 
-      sshkit_cmd = execute_cmd(cmd)
+      sshkit_cmd = execute_cmd(cmd, input: input)
 
       [sshkit_cmd.full_stdout, sshkit_cmd.full_stderr, sshkit_cmd.exit_status]
     end
@@ -203,6 +203,10 @@ module OpsWalrus
       })
     end
 
+    def set_runtime_env(runtime_env)
+      @runtime_env = runtime_env
+    end
+
     def set_ssh_session_connection(sshkit_backend)
       @sshkit_backend = sshkit_backend
     end
@@ -212,18 +216,27 @@ module OpsWalrus
     end
 
     def clear_ssh_session
+      @runtime_env = nil
       @sshkit_backend = nil
       @tmp_bundle_root_dir = nil
     end
 
-    def execute(*args)
+    def execute(*args, input: nil)
       # puts "interaction handler responds with: #{ssh_password}"
-      @sshkit_backend.capture(*args, interaction_handler: SudoPasswordMapper.new(ssh_password).interaction_handler, verbosity: :info)
+      # @sshkit_backend.capture(*args, interaction_handler: SudoPasswordMapper.new(ssh_password).interaction_handler, verbosity: :info)
       # @sshkit_backend.capture(*args, interaction_handler: SudoPromptInteractionHandler.new, verbosity: :info)
+
+      @runtime_env.handle_input(input, ssh_password) do |interaction_handler|
+        @sshkit_backend.capture(*args, interaction_handler: interaction_handler, verbosity: :info)
+      end
+
     end
 
-    def execute_cmd(*args)
-      @sshkit_backend.execute_cmd(*args, interaction_handler: SudoPasswordMapper.new(ssh_password).interaction_handler, verbosity: :info)
+    def execute_cmd(*args, input: nil)
+      # @sshkit_backend.execute_cmd(*args, interaction_handler: SudoPasswordMapper.new(ssh_password).interaction_handler, verbosity: :info)
+      @runtime_env.handle_input(input, ssh_password) do |interaction_handler|
+        @sshkit_backend.execute_cmd(*args, interaction_handler: interaction_handler, verbosity: :info)
+      end
     end
 
     def upload(local_path_or_io, remote_path)

data/lib/opswalrus/interaction_handlers.rb

@@ -2,6 +2,91 @@ require 'sshkit'
 
 module OpsWalrus
 
+  class ScopedMappingInteractionHandler
+    attr_accessor :input_mappings   # Hash[ String | Regex => String ]
+
+    def initialize(mapping, log_level = nil)
+      @log_level = log_level
+      @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
+    def mapping_for_sudo_password(sudo_password)
+      {
+        /\[sudo\] password for .*?:\s*/ => "#{sudo_password}\n",
+        App::LOCAL_SUDO_PASSWORD_PROMPT => "#{sudo_password}\n",
+        # /\s+/ => nil,     # unnecessary
+      }
+    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 ||= {}
+
+      raise ArgumentError.new("mapping must be a Hash") unless mapping.is_a?(Hash)
+
+      if sudo_password
+        mapping.merge!(mapping_for_sudo_password(sudo_password))
+      end
+
+      if mapping.empty?
+        yield self
+      else
+        yield ScopedMappingInteractionHandler.new(@input_mappings.merge(mapping), @log_level)
+      end
+    end
+
+    # adds the specified input mapping to the interaction handler
+    #
+    # mapping : Hash[ String | Regex => String ]
+    def add_mapping(mapping)
+      @input_mappings.merge!(mapping)
+    end
+
+    def on_data(_command, stream_name, data, channel)
+      log("Looking up response for #{stream_name} message #{data.inspect}")
+
+      response_data = begin
+        first_matching_key_value_pair = @input_mappings.find {|k, _v| k === data }
+        first_matching_key_value_pair&.last
+      end
+
+      if response_data.nil?
+        log("Unable to find interaction handler mapping for #{stream_name}: #{data.inspect} so no response was sent")
+      else
+        log("Sending #{response_data.inspect}")
+        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)
+        else
+          raise "Unable to write response data to channel #{channel.inspect} - does not support '#send_data' or '#write'"
+        end
+      end
+    end
+
+    private
+
+    def log(message)
+      # puts message
+      SSHKit.config.output.send(@log_level, message) unless @log_level.nil?
+    end
+
+  end
+
   class PasswdInteractionHandler
     def on_data(command, stream_name, data, channel)
       # puts data

data/lib/opswalrus/local_pty_backend.rb

@@ -16,12 +16,16 @@ module SSHKit
         cmd.started = Time.now
         PTY.spawn(cmd.to_command) do |stdout, stdin, pid|
           stdout_thread = Thread.new do
+            # debug_log = StringIO.new
             buffer = ""
             partial_buffer = ""
             while !stdout.closed?
+              # debug_log.puts "!!!\nbuffer=#{buffer}|EOL|\npartial=#{partial_buffer}|EOL|"
               # puts "9" * 80
               begin
-                stdout.read_nonblock(4096, partial_buffer)
+                # partial_buffer = ""
+                # stdout.read_nonblock(4096, partial_buffer)
+                partial_buffer = stdout.read_nonblock(4096)
                 buffer << partial_buffer
                 # puts "nonblocking1. buffer=#{buffer} partial_buffer=#{partial_buffer}"
                 buffer = handle_data_for_stdout(output, cmd, buffer, stdin, false)
@@ -48,6 +52,10 @@ module SSHKit
               end
             end
             # puts "end!"
+            # debug_log.puts "!!!\nbuffer=#{buffer}|EOL|\npartial=#{partial_buffer}|EOL|"
+
+            # puts "*" * 80
+            # puts debug_log.string
 
           end
           stdout_thread.join
@@ -59,12 +67,14 @@ module SSHKit
 
       # returns [complete lines, new buffer]
       def split_buffer(buffer)
-        lines = buffer.split(/(\r\n)\r|\n/)
+        lines = buffer.split(/(\r\n)|\r|\n/)
         buffer = lines.pop
         [lines, buffer]
       end
 
       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|

data/lib/opswalrus/ops_file_script.rb

@@ -121,13 +121,15 @@ module OpsWalrus
       # bootstrap_shell_script = BootstrapLinuxHostShellScript
       # on sshkit_hosts do |sshkit_host|
       SSHKit::Coordinator.new(sshkit_hosts).each(in: kwargs[:in] || :parallel) do |sshkit_host|
-        host = sshkit_host_to_ops_host_map[sshkit_host]
 
+        # in this context, self is an instance of one of the subclasses of SSHKit::Backend::Abstract, e.g. SSHKit::Backend::Netssh
+
+        host = sshkit_host_to_ops_host_map[sshkit_host]
         # puts "#{host.alias} / #{host}:"
 
         begin
-          # in this context, self is an instance of one of the subclasses of SSHKit::Backend::Abstract, e.g. SSHKit::Backend::Netssh
-          host.set_ssh_session_connection(self)
+          host.set_runtime_env(runtime_env)
+          host.set_ssh_session_connection(self)  # self is an instance of one of the subclasses of SSHKit::Backend::Abstract, e.g. SSHKit::Backend::Netssh
 
           # copy over bootstrap shell script
           # io = StringIO.new(bootstrap_shell_script)
@@ -199,11 +201,14 @@ module OpsWalrus
       @runtime_env.app.inventory(tags)
     end
 
-    def exit(exit_status)
+    def exit(exit_status, message = nil)
+      if message
+        puts message
+      end
       result = if exit_status == 0
-        Success.new(nil)
+        Invocation::Success.new(nil)
       else
-        Error.new(nil, exit_status)
+        Invocation::Error.new(nil, exit_status)
       end
       throw :exit_now, result
     end
@@ -240,18 +245,18 @@ module OpsWalrus
     end
 
     # returns the stdout from the command
-    def sh(desc_or_cmd = nil, cmd = nil, stdin: nil, &block)
-      out, err, status = *shell!(desc_or_cmd, cmd, block, stdin: stdin)
+    def sh(desc_or_cmd = nil, cmd = nil, input: nil, &block)
+      out, err, status = *shell!(desc_or_cmd, cmd, block, input: input)
       out
     end
 
     # returns the tuple: [stdout, stderr, exit_status]
-    def shell(desc_or_cmd = nil, cmd = nil, stdin: nil, &block)
-      shell!(desc_or_cmd, cmd, block, stdin: stdin)
+    def shell(desc_or_cmd = nil, cmd = nil, input: nil, &block)
+      shell!(desc_or_cmd, cmd, block, input: input)
     end
 
     # returns the tuple: [stdout, stderr, exit_status]
-    def shell!(desc_or_cmd = nil, cmd = nil, block = nil, stdin: nil)
+    def shell!(desc_or_cmd = nil, cmd = nil, block = nil, input: 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
@@ -272,8 +277,8 @@ module OpsWalrus
 
       return unless cmd && !cmd.strip.empty?
 
-      sudo_password = @runtime_env.sudo_password
-      sudo_password &&= sudo_password.gsub(/\n+$/,'')     # remove trailing newlines from sudo_password
+      # sudo_password = @runtime_env.sudo_password
+      # sudo_password &&= sudo_password.gsub(/\n+$/,'')     # remove trailing newlines from sudo_password
 
       # puts "shell: #{cmd}"
       # puts "shell: #{cmd.inspect}"
@@ -281,10 +286,14 @@ module OpsWalrus
 
       # sshkit_cmd = SSHKit::Backend::LocalNonBlocking.new {
       # sshkit_cmd = SSHKit::Backend::LocalPty.new {
-      sshkit_cmd = backend.execute_cmd(cmd, interaction_handler: SudoPasswordMapper.new(sudo_password).interaction_handler, verbosity: :info)
+      # sshkit_cmd = backend.execute_cmd(cmd, interaction_handler: SudoPasswordMapper.new(sudo_password).interaction_handler, verbosity: :info)
         # execute_cmd(cmd, interaction_handler: SudoPromptInteractionHandler.new, verbosity: :info)
       # }.run
 
+      sshkit_cmd = @runtime_env.handle_input(input) do |interaction_handler|
+        backend.execute_cmd(cmd, interaction_handler: interaction_handler, verbosity: :info)
+      end
+
       [sshkit_cmd.full_stdout, sshkit_cmd.full_stderr, sshkit_cmd.exit_status]
     end
 

data/lib/opswalrus/runtime_environment.rb

@@ -3,6 +3,7 @@ require 'shellwords'
 require 'socket'
 require 'sshkit'
 
+require_relative 'interaction_handlers'
 require_relative 'traversable'
 require_relative 'walrus_lang'
 
@@ -196,9 +197,27 @@ module OpsWalrus
       @bundle_load_path = LoadPath.new(self, @app.bundle_dir)
       @app_load_path = LoadPath.new(self, @app.pwd)
 
+      @interaction_handler = ScopedMappingInteractionHandler.new({
+        /\[sudo\] password for .*?:\s*/ => "#{sudo_password}\n",
+      })
+
       configure_sshkit
     end
 
+    # def with_sudo_password(password, &block)
+    #   @interaction_handler.with_sudo_password(password, &block)
+    # end
+
+    # 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)
+    end
+
+    # def handle_input_with_sudo_password(input_mapping, password, &block)
+    #   @interaction_handler.with_mapping(input_mapping, password, &block)
+    # end
+
     # configure sshkit globally
     def configure_sshkit
       SSHKit.config.use_format :blackhole

data/lib/opswalrus/version.rb

@@ -1,3 +1,3 @@
 module OpsWalrus
-  VERSION = "1.0.6"
+  VERSION = "1.0.7"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opswalrus
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.0.7
 platform: ruby
 authors:
 - David Ellis
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-17 00:00:00.000000000 Z
+date: 2023-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: citrus