opswalrus 1.0.38 → 1.0.40

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a8829f40ddadca854579786cb5c26aa6d67967afe3805930028cd9d65565267
-  data.tar.gz: d3bc1e8772b1f52cac6ff4625509eede301cb4cffc686eae9a12f4013d55c412
+  metadata.gz: 43969fb5bd89993b9f4fb4c127d8a63f7d074d79d08104609b3a43d4df3f6457
+  data.tar.gz: beca6e40dcabbe38815ef6ac2fe6581895ba8ea2dcb27ab314ad22d5ff2d47cd
 SHA512:
-  metadata.gz: 14f5e7f7efc6651e506110ccde42a403e9fd69fe0a64d4ca44b4e5622da92900d21a88191437fad7b73fc52e880af02a2ebfc5f3b2035d83c006efd9a86cca13
-  data.tar.gz: 15149d50ef7c8ae277d2fd8044fc6f096b5472a1b565978231d82568fa3db6b60dfa6c405ba1c5cceb86a415914f2096405e9c32c0ba6692c5fa2b28c023d33f
+  metadata.gz: be45244077503ac67da072c8d41cad8800553cb9dc243d49904de29588c20a93317543b3d2d2d97a8c7a74ca0a1abc6c0d2fa5d4187b1fe34d863e1e3e558218
+  data.tar.gz: 3cd42b3c126aef7dcec443c7f14fe9ee308da1d153148430b2413fe4166c4a214c43b0e368b485a4b3dd6cddf9c3047f778e55dbd4b99dc79697d75eaf910c72

data/Gemfile.lock

@@ -1,8 +1,7 @@
 PATH
   remote: .
   specs:
-    opswalrus (1.0.38)
-      amazing_print (~> 1.5)
+    opswalrus (1.0.40)
       bcrypt_pbkdf (~> 1.1)
       binding_of_caller (~> 1.0)
       citrus (~> 3.0)
@@ -20,7 +19,6 @@ GEM
   specs:
     addressable (2.8.5)
       public_suffix (>= 2.0.2, < 6.0)
-    amazing_print (1.5.0)
     bcrypt_pbkdf (1.1.0)
     binding_of_caller (1.0.0)
       debug_inspector (>= 0.0.1)

data/lib/opswalrus/app.rb

@@ -49,7 +49,6 @@ module OpsWalrus
       # @logger.debug Style.yellow("debug"), foo: "bar", baz: {qux: "quux"}
       # @logger.trace Style.yellow("trace"), foo: "bar", baz: {qux: "quux"}
 
-      @verbose = false
       @sudo_user = nil
       @sudo_password = nil
       @identity_file_paths = []
@@ -124,38 +123,53 @@ module OpsWalrus
       @logger.level = log_level
     end
 
-    def verbose?
-      [:info, :debug, :trace].include? @logger.level
-    end
-
-    def debug?
-      [:debug, :trace].include? @logger.level
-    end
-
     def fatal(*args)
       @logger.fatal(*args)
     end
+    def fatal?
+      @logger.fatal?
+    end
 
     def error(*args)
       @logger.error(*args)
     end
+    def error?
+      @logger.error?
+    end
 
     def warn(*args)
       @logger.warn(*args)
     end
+    alias_method :important, :warn    # warn means important
+    def warn?
+      @logger.warn?
+    end
 
-    def log(*args)
+    def info(*args)
       @logger.info(*args)
     end
-    alias_method :info, :log
+    alias_method :log, :info
+    def info?
+      @logger.info?
+    end
 
     def debug(*args)
       @logger.debug(*args)
     end
+    def debug?
+      @logger.debug?
+    end
 
     def trace(*args)
       @logger.trace(*args)
     end
+    def trace?
+      @logger.trace?
+    end
+
+    def verbose?
+      info? || debug? || trace?
+    end
 
     def set_pwd(pwd)
       @pwd = pwd.to_pathname
@@ -181,7 +195,6 @@ module OpsWalrus
     def prompt_sudo_password
       password = IO::console.getpass(LOCAL_SUDO_PASSWORD_PROMPT)
       set_sudo_password(password)
-      # puts "sudo password = |#{password}|"
       nil
     end
 
@@ -223,25 +236,19 @@ module OpsWalrus
 
       ops_file = load_entry_point_ops_file(ops_file_path, tmp_bundle_root_dir)
 
-      if @verbose
-        puts "Running: #{ops_file.ops_file_path}"
-      end
+      debug "Running: #{ops_file.ops_file_path}"
 
       op = OperationRunner.new(self, ops_file)
       result = op.run(operation_kv_args, params_json_hash: @params)
       exit_status = result.exit_status
 
-      if @verbose
-        puts "Op exit_status"
-        puts exit_status
+      debug "Op exit_status"
+      debug exit_status
 
-        puts "Op output"
-        puts JSON.pretty_generate(result.value)
-      end
+      debug "Op output"
+      debug JSON.pretty_generate(result.value)
 
-      if script_mode?
-        puts JSON.pretty_generate(result.value)
-      end
+      puts JSON.pretty_generate(result.value)
 
       exit_status
     ensure

data/lib/opswalrus/bootstrap.sh

@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 
 export PATH="$HOME/.local/share/rtx/bin:$PATH"    # this is key for activating rtx without running `eval "$($RTX activate bash)"`
+# eval "$(rtx activate bash)"
 RTX="$HOME/.local/share/rtx/bin/rtx"
 rtx_init() { eval "$($RTX activate bash)"; }
 # RTX_RUBY="$HOME/.local/share/rtx/bin/rtx x ruby -- ruby"
@@ -27,7 +28,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_CMD install opswalrus
+      # $GEM_CMD install opswalrus
       $RTX reshim
 
       exit 0

data/lib/opswalrus/cli.rb

@@ -22,19 +22,17 @@ module OpsWalrus
     on_error do |exception|
       next(false) if exception.is_a? GLI::CustomExit
 
-      puts "catchall exception handler:"
-      puts exception.message
-      puts exception.backtrace.join("\n")
+      $app.fatal "catchall exception handler:"
+      $app.fatal exception.message
+      $app.fatal exception.backtrace.join("\n")
       false   # disable built-in exception handling
     end
 
     program_desc 'ops is an operation runner'
 
-    desc 'Be verbose'
-    switch [:v, :verbose]
-
-    desc 'Turn on debug mode'
-    switch [:d, :debug]
+    switch [:v, :verbose], desc: "Verbose output"
+    switch :debug, desc: "Debug output"
+    switch :trace, desc: "Trace output"
 
     switch :noop, desc: "Perform a dry run"
     switch :dryrun, desc: "Perform a dry run"
@@ -63,8 +61,7 @@ module OpsWalrus
           hosts = global_options[:hosts]
           tags = global_options[:tags]
 
-          log_level = global_options[:debug] && :trace || global_options[:verbose] && :debug || :info
-          $app.set_log_level(log_level)
+          $app.set_log_level(global_options[:trace] && :trace || global_options[:debug] && :debug || global_options[:verbose] && :info || :warn)
 
           $app.report_inventory(hosts, tags: tags)
         end
@@ -131,8 +128,7 @@ module OpsWalrus
       c.switch :dry_run, desc: "Perform a dry run"
 
       c.action do |global_options, options, args|
-        log_level = global_options[:debug] && :trace || global_options[:verbose] && :debug || :info
-        $app.set_log_level(log_level)
+        $app.set_log_level(global_options[:trace] && :trace || global_options[:debug] && :debug || global_options[:verbose] && :info || :warn)
 
         hosts = global_options[:hosts]
         tags = global_options[:tags]
@@ -168,8 +164,7 @@ module OpsWalrus
       c.switch :dry_run, desc: "Perform a dry run"
 
       c.action do |global_options, options, args|
-        log_level = global_options[:debug] && :trace || global_options[:verbose] && :debug || :info
-        $app.set_log_level(log_level)
+        $app.set_log_level(global_options[:trace] && :trace || global_options[:debug] && :debug || global_options[:verbose] && :info || :warn)
 
         hosts = global_options[:hosts]
         $app.set_inventory_hosts(hosts)
@@ -213,8 +208,7 @@ module OpsWalrus
       long_desc 'Download and bundle the latest versions of dependencies for the current package'
       c.command :update do |update|
         update.action do |global_options, options, args|
-          log_level = global_options[:debug] && :trace || global_options[:verbose] && :debug || :info
-          $app.set_log_level(log_level)
+          $app.set_log_level(global_options[:trace] && :trace || global_options[:debug] && :debug || global_options[:verbose] && :info || :warn)
 
           $app.bundle_update
         end
@@ -234,8 +228,7 @@ module OpsWalrus
         unzip.flag [:o, :output], desc: "Specify the output directory"
 
         unzip.action do |global_options, options, args|
-          log_level = global_options[:debug] && :trace || global_options[:verbose] && :debug || :info
-          $app.set_log_level(log_level)
+          $app.set_log_level(global_options[:trace] && :trace || global_options[:debug] && :debug || global_options[:verbose] && :info || :warn)
 
           output_dir = options[:output]
           zip_file_path = args.first

data/lib/opswalrus/host.rb

@@ -51,7 +51,6 @@ module OpsWalrus
       sibling_symbol_table |= ops_file.dirname.glob("*").select(&:directory?).map {|dir_path| dir_path.basename.to_s }    # Namespaces
       sibling_symbol_table.each do |symbol_name|
         unless methods_defined.include? symbol_name
-          # puts "2. defining: #{symbol_name}(...)"
           klass.define_method(symbol_name) do |*args, **kwargs, &block|
             App.instance.trace "resolving implicit import: #{symbol_name}"
             namespace_or_ops_file = @runtime_env.resolve_sibling_symbol(ops_file, symbol_name)
@@ -144,7 +143,7 @@ module OpsWalrus
     end
 
     # returns the tuple: [stdout, stderr, exit_status]
-    def shell!(desc_or_cmd = nil, cmd = nil, block = nil, input: nil)
+    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
@@ -170,61 +169,95 @@ module OpsWalrus
 
       #cmd = Shellwords.escape(cmd)
 
-      if App.instance.report_mode?
-        puts Style.green("*" * 80)
-        if self.alias
-          print "[#{Style.blue(self.alias)} | #{Style.blue(host)}] "
-        else
-          print "[#{Style.blue(host)}] "
-        end
-        print "#{description}: " if description
-        puts Style.yellow(cmd)
-      end
+      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)
+
+        # puts Style.green("*" * 80)
+        # if self.alias
+        #   print "[#{Style.blue(self.alias)} | #{Style.blue(host)}] "
+        # else
+        #   print "[#{Style.blue(host)}] "
+        # end
+        # print "#{description}: " if description
+        # puts Style.yellow("[#{cmd_id}] #{cmd}")
+      # end
 
       return unless cmd && !cmd.strip.empty?
 
-      # puts "shell: #{cmd}"
-      # puts "shell: #{cmd.inspect}"
-      # puts "sudo_password: #{sudo_password}"
-
-      if App.instance.dry_run?
+      t1 = Time.now
+      out, err, exit_status = if App.instance.dry_run?
         ["", "", 0]
       else
         sshkit_cmd = execute_cmd(cmd, input: input)
         [sshkit_cmd.full_stdout, sshkit_cmd.full_stderr, sshkit_cmd.exit_status]
       end
-    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'})")
+      end
 
-    # def init_brew
-    #   execute('eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"')
-    # end
+      [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, verbose: false)
-      # e.g. /home/linuxbrew/.linuxbrew/bin/gem exec -g opswalrus ops bundle unzip tmpops.zip
-      # e.g. /home/linuxbrew/.linuxbrew/bin/gem exec -g opswalrus ops run echo.ops args:foo args:bar
-
-      # cmd = "/home/linuxbrew/.linuxbrew/bin/gem exec -g opswalrus ops"
+    def run_ops(ops_command, ops_command_options = nil, command_arguments, in_bundle_root_dir: true)
       local_hostname_for_remote_host = if self.alias
-        "#{self.alias} | #{host}"
+        "#{host} (#{self.alias})"
       else
         host
       end
 
-      # cmd = "OPSWALRUS_LOCAL_HOSTNAME='#{local_hostname_for_remote_host}'; /home/linuxbrew/.linuxbrew/bin/gem exec --conservative -g opswalrus ops"
       # cmd = "OPS_GEM=\"#{OPS_GEM}\" OPSWALRUS_LOCAL_HOSTNAME='#{local_hostname_for_remote_host}'; $OPS_GEM exec --conservative -g opswalrus ops"
       cmd = "OPSWALRUS_LOCAL_HOSTNAME='#{local_hostname_for_remote_host}' eval #{OPS_CMD}"
-      cmd << " -v" if verbose
+      if App.instance.info?
+        cmd << " --verbose"
+      elsif App.instance.debug?
+        cmd << " --debug"
+      elsif App.instance.trace?
+        cmd << " --trace"
+      end
       cmd << " #{ops_command.to_s}"
       cmd << " #{ops_command_options.to_s}" if ops_command_options
       cmd << " #{@tmp_bundle_root_dir}" if in_bundle_root_dir
       cmd << " #{command_arguments}" unless command_arguments.empty?
 
-      shell!(cmd)
+      shell!(cmd, log_level: :info)
     end
 
     def desc(msg)
-      puts msg.mustache(1)
+      puts 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)
+      @ops_file_script.env(*args, **kwargs)
+    end
+
+    def params(*args, **kwargs)
+      @ops_file_script.params(*args, **kwargs)
     end
 
     def host_prop(name)
@@ -360,6 +393,10 @@ module OpsWalrus
       @runtime_env = runtime_env
     end
 
+    def set_ops_file_script(ops_file_script)
+      @ops_file_script = ops_file_script
+    end
+
     def set_ssh_session_connection(sshkit_backend)
       @sshkit_backend = sshkit_backend
     end
@@ -370,6 +407,7 @@ module OpsWalrus
 
     def clear_ssh_session
       @runtime_env = nil
+      ops_file_script = nil
       @sshkit_backend = nil
       @tmp_bundle_root_dir = nil
       @tmp_ssh_key_files.each {|tmpfile| tmpfile.close() rescue nil; File.unlink(tmpfile) rescue nil }
@@ -378,13 +416,15 @@ module OpsWalrus
 
     def execute(*args, input: nil)
       @runtime_env.handle_input(input, ssh_password) do |interaction_handler|
-        @sshkit_backend.capture(*args, interaction_handler: interaction_handler, verbosity: :info)
+        # @sshkit_backend.capture(*args, interaction_handler: interaction_handler, verbosity: SSHKit.config.output_verbosity)
+        @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: :info)
+        # @sshkit_backend.execute_cmd(*args, interaction_handler: interaction_handler, verbosity: SSHKit.config.output_verbosity)
+        @sshkit_backend.execute_cmd(*args, interaction_handler: interaction_handler)
       end
     end
 

data/lib/opswalrus/hosts_file.rb

@@ -168,20 +168,18 @@ module OpsWalrus
 
     def decrypt(decrypted_file_path = nil)
       decrypted_file_path ||= @hosts_file_path
-      puts "Decrypting #{@hosts_file_path} -> #{decrypted_file_path}."
+      App.instance.debug "Decrypting #{@hosts_file_path} -> #{decrypted_file_path}."
       raise("Path to age identity not specified") if App.instance.identity_file_paths.empty?
       decrypt_secrets!
       File.write(decrypted_file_path, to_yaml)
-      # puts to_yaml
     end
 
     def encrypt(encrypted_file_path = nil)
       encrypted_file_path ||= @hosts_file_path
-      puts "Encrypting #{@hosts_file_path} -> #{encrypted_file_path}."
+      App.instance.debug "Encrypting #{@hosts_file_path} -> #{encrypted_file_path}."
       raise("Path to age identity not specified") if App.instance.identity_file_paths.empty?
       encrypt_secrets!
       File.write(encrypted_file_path, to_yaml)
-      # puts to_yaml
     end
   end
 
@@ -231,7 +229,7 @@ module OpsWalrus
       when Array
         ref.map {|audience_id_reference| dereference(audience_id_reference) }.flatten.compact.uniq
       when Nil
-        puts "ID #{audience_id_reference} does not appear in the list of known public key identifiers"
+        App.instance.warn "ID #{audience_id_reference} does not appear in the list of known public key identifiers"
         nil
       else
         raise "ID reference #{audience_id_reference} corresponds to an unknown type of public key or transitive ID reference: #{ref.inspect}"
@@ -372,7 +370,6 @@ module OpsWalrus
       # coder.represent_scalar(nil, @public_key)
 
       # coder.scalar = @public_key
-      # puts @ids.inspect
       single_line_ids = @ids.join(", ")
       if single_line_ids.size <= 80
         coder['ids'] = single_line_ids

data/lib/opswalrus/interaction_handlers.rb

@@ -85,9 +85,6 @@ module OpsWalrus
 
     def debug(message)
       App.instance.debug(message)
-      if [:fatal, :error, :warn, :info, :debug, :trace].include? @log_level
-        SSHKit.config.output.send(@log_level, message)
-      end
     end
 
   end

data/lib/opswalrus/local_non_blocking_backend.rb

@@ -39,7 +39,7 @@ module SSHKit
                 handle_data_for_stdout(output, cmd, buffer, stdin, true)
                 stdout.close
               rescue => e
-                puts "closing PTY due to unexpected error: #{e.message}"
+                App.instance.error "closing PTY due to unexpected error: #{e.message}"
                 handle_data_for_stdout(output, cmd, buffer, stdin, true)
                 stdout.close
                 # puts e.message
@@ -73,7 +73,7 @@ module SSHKit
                 handle_data_for_stderr(output, cmd, buffer, stdin, true)
                 stderr.close
               rescue => e
-                puts "closing PTY due to unexpected error: #{e.message}"
+                App.instance.error "closing PTY due to unexpected error: #{e.message}"
                 handle_data_for_stderr(output, cmd, buffer, stdin, true)
                 stderr.close
                 # puts e.message

data/lib/opswalrus/local_pty_backend.rb

@@ -44,7 +44,7 @@ module SSHKit
                 handle_data_for_stdout(output, cmd, buffer, stdin, true)
                 stdout.close
               rescue => e
-                puts "closing PTY due to unexpected error: #{e.message}"
+                App.instance.error "closing PTY due to unexpected error: #{e.message}"
                 handle_data_for_stdout(output, cmd, buffer, stdin, true)
                 stdout.close
                 # puts e.message

data/lib/opswalrus/operation_runner.rb

@@ -83,10 +83,8 @@ module OpsWalrus
     def run(runtime_kv_args, params_json_hash: nil)
       params_hash = build_params_hash(runtime_kv_args, params_json_hash: params_json_hash)
 
-      if app.debug?
-        App.instance.trace "Script:"
-        App.instance.trace @entry_point_ops_file.script
-      end
+      App.instance.trace "Script:"
+      App.instance.trace @entry_point_ops_file.script
 
       result = begin
         # update the bundle for the package
@@ -112,7 +110,7 @@ module OpsWalrus
         Invocation::Error.new(e)
       end
 
-      if app.debug? && result.failure?
+      if result.failure?
         App.instance.debug "Ops script error details:"
         App.instance.debug "Error: #{result.value}"
         App.instance.debug "Status code: #{result.exit_status}"

data/lib/opswalrus/ops_file.rb

@@ -47,8 +47,7 @@ module OpsWalrus
     end
 
     def lazy_load_file
-      # puts "OpsFile#lazy_load_file for #{ops_file_path}"
-      # puts caller
+      App.instance.trace "OpsFile#lazy_load_file for #{@ops_file_path}"
       yaml, ruby_script = if @ops_file_path.exist?
         parse(File.read(@ops_file_path))
       end || ["", ""]
@@ -166,7 +165,7 @@ module OpsWalrus
       package_uri = import_str
       if Git.repo?(package_uri)                                                         # ops file has imported an ad-hoc git repo
         destination_package_path = app.bundler.dynamic_package_path_for_git_package(package_uri)
-        # puts "DynamicPackageImportReference: #{local_name} -> #{destination_package_path}"
+        App.instance.trace "DynamicPackageImportReference: #{local_name} -> #{destination_package_path}"
         return DynamicPackageImportReference.new(local_name, DynamicPackageReference.new(local_name, package_uri, nil))
       end
 

data/lib/opswalrus/ops_file_script.rb

@@ -110,7 +110,7 @@ module OpsWalrus
       sibling_symbol_table_names = Set.new
       sibling_symbol_table_names |= ops_file.dirname.glob("*.ops").map {|ops_file_path| ops_file_path.basename(".ops").to_s }   # OpsFiles
       sibling_symbol_table_names |= ops_file.dirname.glob("*").select(&:directory?).map {|dir_path| dir_path.basename.to_s }    # Namespaces
-      # puts "sibling_symbol_table_names=#{sibling_symbol_table_names}"
+      # App.instance.trace "sibling_symbol_table_names=#{sibling_symbol_table_names}"
       App.instance.trace "methods_defined=#{methods_defined}"
       sibling_symbol_table_names.each do |symbol_name|
         unless methods_defined.include? symbol_name
@@ -134,19 +134,16 @@ module OpsWalrus
       # - @params
       # - #host_proxy_class
       # - #backend
-      # - #debug?
-      # - #verbose?
       # - all the dynamically defined methods in the subclass of Invocation
       invoke_method_definition = <<~INVOKE_METHOD
         def _invoke(runtime_env, hashlike_params)
           @runtime_env = runtime_env
           @params = InvocationParams.new(hashlike_params)
-          params = @params
           #{ruby_script}
         end
       INVOKE_METHOD
 
-      invoke_method_line_count_prior_to_ruby_script_from_ops_file = 4
+      invoke_method_line_count_prior_to_ruby_script_from_ops_file = 3
       klass.module_eval(invoke_method_definition, ops_file.ops_file_path.to_s, ops_file.script_line_offset - invoke_method_line_count_prior_to_ruby_script_from_ops_file)
 
       klass
@@ -161,20 +158,13 @@ module OpsWalrus
       @ops_file = ops_file
       @script = ruby_script
       @runtime_env = nil    # this is set at the very first line of #_invoke
+      @params = nil         # this is set at the very first line of #_invoke
     end
 
     def backend
       @runtime_env.pty
     end
 
-    def debug?
-      @runtime_env.debug?
-    end
-
-    def verbose?
-      @runtime_env.verbose?
-    end
-
     def host_proxy_class
       @ops_file.host_proxy_class
     end
@@ -184,6 +174,15 @@ module OpsWalrus
       raise "Not implemented in base class."
     end
 
+    def params(*keys, default: nil)
+      keys = keys.map(&:to_s)
+      if keys.empty?
+        @params
+      else
+        @params.dig(*keys) || default
+      end
+    end
+
     def to_s
       @script
     end

data/lib/opswalrus/ops_file_script_dsl.rb

@@ -1,5 +1,6 @@
 require 'shellwords'
 require 'stringio'
+require 'random/formatter'
 
 require 'sshkit'
 require 'sshkit/dsl'
@@ -73,28 +74,28 @@ module OpsWalrus
 
           retval
         rescue SSHKit::Command::Failed => e
-          puts "[!] Command failed:"
-          puts e.message
+          App.instance.error "[!] Command failed:"
+          App.instance.error e.message
         rescue Net::SSH::ConnectionTimeout
-          puts "[!] The host '#{host}' not alive!"
+          App.instance.error "[!] The host '#{host}' not alive!"
         rescue Net::SSH::Timeout
-          puts "[!] The host '#{host}' disconnected/timeouted unexpectedly!"
+          App.instance.error "[!] The host '#{host}' disconnected/timeouted unexpectedly!"
         rescue Errno::ECONNREFUSED
-          puts "[!] Incorrect port #{port} for #{host}"
+          App.instance.error "[!] Incorrect port #{port} for #{host}"
         rescue Net::SSH::HostKeyMismatch => e
-          puts "[!] The host fingerprint does not match the last observed fingerprint for #{host}"
-          puts e.message
-          puts "You might try `ssh-keygen -f ~/.ssh/known_hosts -R \"#{host}\"`"
+          App.instance.error "[!] The host fingerprint does not match the last observed fingerprint for #{host}"
+          App.instance.error e.message
+          App.instance.error "You might try `ssh-keygen -f ~/.ssh/known_hosts -R \"#{host}\"`"
         rescue Net::SSH::AuthenticationFailed
-          puts "Wrong Password: #{host} | #{user}:#{password}"
+          App.instance.error "Wrong Password: #{host} | #{user}:#{password}"
         rescue Net::SSH::Authentication::DisallowedMethod
-          puts "[!] The host '#{host}' doesn't accept password authentication method."
+          App.instance.error "[!] The host '#{host}' doesn't accept password authentication method."
         rescue Errno::EHOSTUNREACH => e
-          puts "[!] The host '#{host}' is unreachable"
+          App.instance.error "[!] The host '#{host}' is unreachable"
         rescue => e
-          puts e.class
-          puts e.message
-          puts e.backtrace.join("\n")
+          App.instance.error e.class
+          App.instance.error e.message
+          App.instance.error e.backtrace.join("\n")
         ensure
           host.clear_ssh_session
         end
@@ -107,7 +108,7 @@ module OpsWalrus
       hosts = inventory(*args, **kwargs).map {|host| host_proxy_class.new(runtime_env, host) }
       sshkit_hosts = hosts.map(&:sshkit_host)
       sshkit_host_to_ops_host_map = sshkit_hosts.zip(hosts).to_h
-      local_host = self
+      ops_file_script = local_host = self
       # bootstrap_shell_script = BootstrapLinuxHostShellScript
       # on sshkit_hosts do |sshkit_host|
       SSHKit::Coordinator.new(sshkit_hosts).each(in: kwargs[:in] || :parallel) do |sshkit_host|
@@ -116,6 +117,7 @@ module OpsWalrus
 
         begin
           host.set_runtime_env(runtime_env)
+          host.set_ops_file_script(ops_file_script)
           host.set_ssh_session_connection(self)  # self is an instance of one of the subclasses of SSHKit::Backend::Abstract, e.g. SSHKit::Backend::Netssh
 
           host._bootstrap_host
@@ -123,28 +125,28 @@ module OpsWalrus
 
           retval
         rescue SSHKit::Command::Failed => e
-          puts "[!] Command failed:"
-          puts e.message
+          App.instance.error "[!] Command failed:"
+          App.instance.error e.message
         rescue Net::SSH::ConnectionTimeout
-          puts "[!] The host '#{host}' not alive!"
+          App.instance.error "[!] The host '#{host}' not alive!"
         rescue Net::SSH::Timeout
-          puts "[!] The host '#{host}' disconnected/timeouted unexpectedly!"
+          App.instance.error "[!] The host '#{host}' disconnected/timeouted unexpectedly!"
         rescue Errno::ECONNREFUSED
-          puts "[!] Incorrect port #{port} for #{host}"
+          App.instance.error "[!] Incorrect port #{port} for #{host}"
         rescue Net::SSH::HostKeyMismatch => e
-          puts "[!] The host fingerprint does not match the last observed fingerprint for #{host}"
-          puts e.message
-          puts "You might try `ssh-keygen -f ~/.ssh/known_hosts -R \"#{host}\"`"
+          App.instance.error "[!] The host fingerprint does not match the last observed fingerprint for #{host}"
+          App.instance.error e.message
+          App.instance.error "You might try `ssh-keygen -f ~/.ssh/known_hosts -R \"#{host}\"`"
         rescue Net::SSH::AuthenticationFailed
-          puts "Wrong Password: #{host} | #{user}:#{password}"
+          App.instance.error "Wrong Password: #{host} | #{user}:#{password}"
         rescue Net::SSH::Authentication::DisallowedMethod
-          puts "[!] The host '#{host}' doesn't accept password authentication method."
+          App.instance.error "[!] The host '#{host}' doesn't accept password authentication method."
         rescue Errno::EHOSTUNREACH => e
-          puts "[!] The host '#{host}' is unreachable"
+          App.instance.error "[!] The host '#{host}' is unreachable"
         rescue => e
-          puts e.class
-          puts e.message
-          puts e.backtrace.join("\n")
+          App.instance.error e.class
+          App.instance.error e.message
+          App.instance.error e.backtrace.join("\n")
         ensure
           host.clear_ssh_session
         end
@@ -172,15 +174,6 @@ module OpsWalrus
       throw :exit_now, result
     end
 
-    def env(*keys)
-      keys = keys.map(&:to_s)
-      if keys.empty?
-        @runtime_env.env
-      else
-        @runtime_env.env.dig(*keys)
-      end
-    end
-
     # currently, import may only be used to import a package that is referenced in the script's package file
     # I may decide to extend this to work with dynamic package references
     #
@@ -190,7 +183,6 @@ module OpsWalrus
       package_reference = ops_file.package_file&.dependency(local_package_name)
       raise Error, "Unknown package reference: #{local_package_name}" unless package_reference
       import_reference = PackageDependencyReference.new(local_package_name, package_reference)
-      # puts "import: #{import_reference.inspect}"
       namespace_or_ops_file = @runtime_env.resolve_import_reference(ops_file, import_reference)
       raise SymbolResolutionError, "Import reference '#{import_reference.summary}' not in load path for #{ops_file.ops_file_path}" unless namespace_or_ops_file
       invocation_context = LocalImportInvocationContext.new(@runtime_env, namespace_or_ops_file)
@@ -198,19 +190,19 @@ module OpsWalrus
       # invocation_context._invoke(*args, **kwargs)
     end
 
-    # def params(*keys, default: nil)
-    #   keys = keys.map(&:to_s)
-    #   if keys.empty?
-    #     @params
-    #   else
-    #     @params.dig(*keys) || default
-    #   end
-    # end
-
     def desc(msg)
       puts msg.mustache(1)
     end
 
+    def env(*keys)
+      keys = keys.map(&:to_s)
+      if keys.empty?
+        @runtime_env.env
+      else
+        @runtime_env.env.dig(*keys)
+      end
+    end
+
     # runs the given command
     # returns the stdout from the command
     def sh(desc_or_cmd = nil, cmd = nil, input: nil, &block)
@@ -231,7 +223,7 @@ module OpsWalrus
     end
 
     # returns the tuple: [stdout, stderr, exit_status]
-    def shell!(desc_or_cmd = nil, cmd = nil, block = nil, input: nil)
+    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
@@ -258,31 +250,55 @@ module OpsWalrus
 
       #cmd = Shellwords.escape(cmd)
 
-      # puts "shell! self: #{self.inspect}"
+      cmd_id = Random.uuid.split('-').first
 
-      if App.instance.report_mode?
-        puts Style.green("*" * 80)
-        print "[#{Style.blue(@runtime_env.local_hostname)}] "
-        print "#{description}: " if description
-        puts Style.yellow(cmd)
-      end
+      # 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
 
       return unless cmd && !cmd.strip.empty?
 
-      if App.instance.dry_run?
+      t1 = Time.now
+      out, err, exit_status = if App.instance.dry_run?
         ["", "", 0]
       else
         sshkit_cmd = @runtime_env.handle_input(input) do |interaction_handler|
           # self is a Module instance that is serving as the evaluation context in an instance of a subclass of an Invocation; see Invocation#evaluate
-          backend.execute_cmd(cmd, interaction_handler: interaction_handler, verbosity: :info)
+          # backend.execute_cmd(cmd, interaction_handler: interaction_handler, verbosity: SSHKit.config.output_verbosity)
+          backend.execute_cmd(cmd, interaction_handler: interaction_handler)
         end
         [sshkit_cmd.full_stdout, sshkit_cmd.full_stderr, sshkit_cmd.exit_status]
       end
-    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'})")
+      end
+
 
-    # def init_brew
-    #   execute('eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"')
-    # end
+      [out, err, exit_status]
+    end
 
   end
 

data/lib/opswalrus/runtime_environment.rb

@@ -207,12 +207,12 @@ module OpsWalrus
     def resolve_import_reference(origin_ops_file, import_reference)
       resolved_namespace_or_ops_file = case import_reference
       when PackageDependencyReference
-        # puts "root namespace: #{@root_namespace.symbol_table}"
+        # App.instance.trace "root namespace: #{@root_namespace.symbol_table}"
         @root_namespace.resolve_symbol(import_reference.package_reference.import_resolution_dirname)   # returns the Namespace associated with the bundled package import_resolution_dirname (i.e. the local name)
       when DynamicPackageImportReference
         dynamic_package_reference = import_reference.package_reference
         @dynamic_package_additions_memo[dynamic_package_reference] ||= begin
-          # puts "Downloading dynamic package: #{dynamic_package_reference.inspect}"
+          # App.instance.trace "Downloading dynamic package: #{dynamic_package_reference.inspect}"
           App.instance.debug("Downloading dynamic package: #{dynamic_package_reference}")
           dynamically_added_package_dir = @runtime_env.app.bundler.download_git_package(dynamic_package_reference.package_uri, dynamic_package_reference.version)
           dynamically_add_new_package_dir(dynamically_added_package_dir)
@@ -267,15 +267,16 @@ module OpsWalrus
       SSHKit.config.use_format :blackhole
       SSHKit.config.output_verbosity = :info
 
-      if app.debug?
-        SSHKit.config.use_format :pretty
-        # SSHKit.config.use_format :simpletext
-        SSHKit.config.output_verbosity = :debug
-      elsif app.verbose?
-        SSHKit.config.use_format :pretty
-        # SSHKit.config.use_format :dot
-        SSHKit.config.output_verbosity = :info
-      end
+      # 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
 
       SSHKit::Backend::Netssh.configure do |ssh|
         ssh.pty = true                # necessary for interaction with sudo on the remote host
@@ -292,14 +293,6 @@ module OpsWalrus
       SSHKit::Backend::Netssh.pool.idle_timeout = 1   # seconds
     end
 
-    def debug?
-      @app.debug?
-    end
-
-    def verbose?
-      @app.verbose?
-    end
-
     def local_hostname
       @app.local_hostname
     end

data/lib/opswalrus/sshkit_ext.rb

@@ -9,10 +9,10 @@ require_relative 'local_pty_backend'
 module SSHKit
   module Backend
     class Abstract
-      def execute(*args)
-        options = { raise_on_non_zero_exit: false }.merge(args.extract_options!)
-        create_command_and_execute(args, options).success?
-      end
+      # def execute(*args)
+      #   options = { verbosity: :debug, raise_on_non_zero_exit: false }.merge(args.extract_options!)
+      #   create_command_and_execute(args, options).success?
+      # end
 
       def execute_cmd(*args)
         options = { verbosity: :debug, strip: true, raise_on_non_zero_exit: false }.merge(args.extract_options!)
@@ -21,6 +21,12 @@ module SSHKit
     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.38"
+  VERSION = "1.0.40"
 end

data/lib/opswalrus/walrus_lang.rb

@@ -99,7 +99,6 @@ end
 # # m = TemplateLang.parse("abc; {{ 'foo' * bar }} def ")
 # m = WalrusLang::Parser.parse("abc; {{ 'foo{{1+2}}' * bar }} def {{ 4 * 4 }}; def")
 # # m = TemplateLang.parse("a{{b{{c}}d}}e{{f}}g{{h{{i{{j{{k{{l}}m{{n}}o}}p}}}}}}")
-# # puts m.dump
 # puts m.render(binding)
 
 # puts("abc {{ 1 + 2 }} def".mustache)

data/opswalrus.gemspec

@@ -32,7 +32,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   # gem dependencies
-  spec.add_dependency "amazing_print", "~> 1.5"
   spec.add_dependency "binding_of_caller", "~> 1.0"
   spec.add_dependency "citrus", "~> 3.0"
   spec.add_dependency "gli", "~> 2.21"

data/vms/web-ubuntu/Vagrantfile

@@ -20,13 +20,19 @@ Vagrant.configure("2") do |config|
   # Enable provisioning with a shell script. Additional provisioners such as
   # Ansible, Chef, Docker, Puppet and Salt are also available. Please see the
   # documentation for more information about their specific syntax and use.
-  config.vm.provision "shell", inline: <<-SHELL
-    sudo sed -i 's/PasswordAuthentication no/PasswordAuthentication yes/g' /etc/ssh/sshd_config
-    sudo systemctl restart sshd
+  config.vm.provision "shell" do |s|
+    ssh_pub_key = File.readlines("#{Dir.home}/.ssh/id_ops.pub").first.strip
+    s.inline = <<-SHELL
+      echo #{ssh_pub_key} >> /home/vagrant/.ssh/authorized_keys
+      echo #{ssh_pub_key} >> /root/.ssh/authorized_keys
 
-    # change vagrant user to require sudo password
-    sudo sed -i 's/vagrant ALL=(ALL) NOPASSWD:ALL/vagrant ALL=(ALL:ALL) ALL/g' /etc/sudoers.d/vagrant
+      sudo sed -i 's/PasswordAuthentication no/PasswordAuthentication yes/g' /etc/ssh/sshd_config
+      sudo systemctl restart sshd
 
-    # sudo sh -c 'echo root:foo | chpasswd'
-  SHELL
+      # change vagrant user to require sudo password
+      sudo sed -i 's/vagrant ALL=(ALL) NOPASSWD:ALL/vagrant ALL=(ALL:ALL) ALL/g' /etc/sudoers.d/vagrant
+
+      # sudo sh -c 'echo root:foo | chpasswd'
+    SHELL
+  end
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: opswalrus
 version: !ruby/object:Gem::Version
-  version: 1.0.38
+  version: 1.0.40
 platform: ruby
 authors:
 - David Ellis
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-05 00:00:00.000000000 Z
+date: 2023-09-07 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: amazing_print
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.5'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: binding_of_caller
   requirement: !ruby/object:Gem::Requirement