opswalrus 1.0.49 → 1.0.50

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90e3b3e2c7e0255ef069e30d31e2125c5bf6fd9c22a15e4aa2057f5265aa6873
-  data.tar.gz: 58346bbbcfe19a98add4a83b8936f75c911155f872cf35ecaf56ce32679c1123
+  metadata.gz: 20cc50a607aa6aec146b62eb5dbef09a908c5485f8e0d3dbc39cf5bf9a92895e
+  data.tar.gz: b27cdf6497c28f6ced9be489365003bad03ddb02e6c1285e76c45e6a5ee5d52b
 SHA512:
-  metadata.gz: bde3099dff40f9f00add304bac22a5cf62521a68ed3c9481d7de9ae28f3d520c4457097c3be60fbb569e6c32de4fdc101e620fd5a2ad832d335b638245dcd93e
-  data.tar.gz: a1b4a440fd1d9512efe0cdef6110f3849afab3ad3253140dfa253bb30d7fac606a0de6b814f3611e0c063366a9478a2b4fc3ae5e3c962b02d6c76f2dd815dbb2
+  metadata.gz: ec22d55f8417db680b98d0651855fd83589f0b2428c26be7279f7a2b62582120f4eafdb473b4df9004f98934508cf46f9686a1a28fe8c2adf83eadc82b2a0a38
+  data.tar.gz: 7eb26d1957c2c8115ccaa06b497418f635a4876279c7a4ee5e16eea10546d80303af209a585d4b69ad02f15cca5ce0ea468af86e974947c6283a7998bd8e6426

data/Gemfile.lock

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

data/lib/opswalrus/_shell.ops

@@ -0,0 +1,9 @@
+params:
+  command: string
+...
+ssh_noprep in: :sequence do
+# ssh_noprep do
+  command = params.command
+  desc "Running `#{command}` on #{to_s} (alias=#{self.alias})"
+  shell(command)
+end

data/lib/opswalrus/app.rb

@@ -31,7 +31,7 @@ module OpsWalrus
       @instance ||= new(*args)
     end
 
-    LOCAL_SUDO_PASSWORD_PROMPT = "[ops] Enter sudo password to run sudo in local environment: "
+    LOCAL_SUDO_PASSWORD_PROMPT = "[opswalrus] Please enter sudo password to run sudo in local environment: "
 
 
     attr_reader :local_hostname
@@ -56,7 +56,7 @@ module OpsWalrus
       @inventory_tag_selections = []
       @params = nil
       @pwd = pwd.to_pathname
-      @bundler = Bundler.new(@pwd)
+      @bundler = Bundler.new(self, @pwd)
       @local_hostname = "localhost"
       @mode = :report     # :report | :script
       @dry_run = false
@@ -173,7 +173,7 @@ module OpsWalrus
 
     def set_pwd(pwd)
       @pwd = pwd.to_pathname
-      @bundler = Bundler.new(@pwd)
+      @bundler = Bundler.new(self, @pwd)
     end
 
     def pwd
@@ -217,23 +217,46 @@ module OpsWalrus
 
     def bootstrap()
       set_pwd(__FILE__.to_pathname.dirname)
-      bootstrap_ops_file = OpsFile.new(self, __FILE__.to_pathname.dirname.join("bootstrap.ops"))
+      bootstrap_ops_file = OpsFile.new(self, __FILE__.to_pathname.dirname.join("_bootstrap.ops"))
       op = OperationRunner.new(self, bootstrap_ops_file)
       op.run([], params_json_hash: @params)
     end
 
+    def shell(command)
+      set_pwd(__FILE__.to_pathname.dirname)
+      shell_ops_file = OpsFile.new(self, __FILE__.to_pathname.dirname.join("_shell.ops"))
+      op = OperationRunner.new(self, shell_ops_file)
+      puts "running #{command}"
+      result = op.run([], params_json_hash: {"command" => command})
+      puts "result class=#{result.class}"
+      exit_status = result.exit_status
+      stdout = JSON.pretty_generate(result.value)
+      output = if exit_status == 0
+        Style.green(stdout)
+      else
+        Style.red(stdout)
+      end
+      puts output
+      exit_status
+    rescue Error => e
+      puts "Error: #{e.message}"
+      1
+    end
+
     # args is of the form ["github.com/davidkellis/my-package/sub-package1", "operation1", "arg1:val1", "arg2:val2", "arg3:val3"]
     # if the first argument is the path to a .ops file, then treat it as a local path, and add the containing package
     #   to the load path
     # otherwise, copy the
     # returns the exit status code that the script should terminate with
-    def run(package_operation_and_args)
+    def run(package_operation_and_args, update_bundle: false)
       return 0 if package_operation_and_args.empty?
 
       ops_file_path, operation_kv_args, tmp_bundle_root_dir = get_entry_point_ops_file_and_args(package_operation_and_args)
 
       ops_file = load_entry_point_ops_file(ops_file_path, tmp_bundle_root_dir)
 
+      bundler.update if update_bundle
+
       debug "Running: #{ops_file.ops_file_path}"
 
       op = OperationRunner.new(self, ops_file)

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
 
@@ -60,6 +60,9 @@ if echo $OS | grep -q 'ubuntu'; then
 elif echo $OS | grep -q 'fedora'; then
   sudo dnf groupinstall -y 'Development Tools'
   sudo dnf -yq install procps-ng curl file git
+elif echo $OS | grep -q 'rocky'; then
+  sudo dnf groupinstall -y 'Development Tools'
+  sudo dnf -yq install procps-ng curl file git
 elif echo $OS | grep -q 'arch'; then
   sudo pacman -Syu --noconfirm --needed base-devel procps-ng curl file git
 else
@@ -121,6 +124,9 @@ if echo $OS | grep -q 'ubuntu'; then
 elif echo $OS | grep -q 'fedora'; then
   # from https://github.com/rbenv/ruby-build/wiki#suggested-build-environment
   sudo yum install -y gcc patch bzip2 openssl-devel libyaml-devel libffi-devel readline-devel zlib-devel gdbm-devel ncurses-devel
+elif echo $OS | grep -q 'rocky'; then
+  sudo yum --enablerepo=powertools install -y libyaml-devel libffi-devel
+  sudo yum install -y gcc patch bzip2 openssl-devel libyaml-devel libffi-devel readline-devel zlib-devel gdbm-devel ncurses-devel
 elif echo $OS | grep -q 'arch'; then
   # from https://github.com/rbenv/ruby-build/wiki#suggested-build-environment
   sudo pacman -Syu --noconfirm --needed base-devel rust libffi libyaml openssl zlib
@@ -150,6 +156,9 @@ if echo $OS | grep -q 'ubuntu'; then
   sudo needrestart -q -r a
 elif echo $OS | grep -q 'fedora'; then
   sudo dnf -yq install age
+elif echo $OS | grep -q 'rocky'; then
+  sudo curl -o /usr/local/bin/age https://dl.filippo.io/age/latest?for=linux/amd64
+  sudo chmod 755 /usr/local/bin/age
 elif echo $OS | grep -q 'arch'; then
   sudo pacman -Syu --noconfirm --needed age
 else

data/lib/opswalrus/bundler.rb

@@ -11,9 +11,11 @@ module OpsWalrus
 
     include Traversable
 
+    attr_accessor :app
     attr_accessor :pwd
 
-    def initialize(working_directory_path)
+    def initialize(app, working_directory_path)
+      @app = app
       @pwd = working_directory_path.to_pathname
       @bundle_dir = @pwd.join(BUNDLE_DIR)
     end
@@ -53,20 +55,25 @@ module OpsWalrus
     #   bundler_for_package.include_directory_in_bundle_as_self_pkg(pwd)
     # end
 
-    def update
+    def update()
       delete_pwd_bundle_directory
       ensure_pwd_bundle_directory_exists
 
       package_yaml_files = pwd.glob("./**/package.yaml") - pwd.glob("./**/#{BUNDLE_DIR}/**/package.yaml")
       package_files_within_pwd = package_yaml_files.map {|path| PackageFile.new(path.realpath) }
 
-      download_dependency_tree(*package_files_within_pwd)
+      download_package_dependency_tree(package_files_within_pwd)
+
+      ops_files = pwd.glob("./**/*.ops") - pwd.glob("./**/#{BUNDLE_DIR}/**/*.ops")
+      ops_files_within_pwd = ops_files.map {|path| OpsFile.new(@app, path.realpath) }
+
+      download_import_dependencies(ops_files_within_pwd)
     end
 
-    # downloads all transitive package dependencies associated with ops_files
+    # downloads all transitive package dependencies associated with ops_files_and_package_files
     # all downloaded packages are placed into @bundle_dir
-    def download_dependency_tree(*ops_files_and_package_files)
-      package_files = ops_files_and_package_files.map(&:package_file).compact.uniq
+    def download_package_dependency_tree(*ops_files_and_package_files)
+      package_files = ops_files_and_package_files.flatten.map(&:package_file).compact.uniq
 
       package_files.each do |root_package_file|
         pre_order_traverse(root_package_file) do |package_file|
@@ -78,11 +85,29 @@ module OpsWalrus
       end
     end
 
+    def download_import_dependencies(*ops_files)
+      ops_files.flatten.each do |ops_file|
+        ops_file.imports.each do |local_name, import_reference|
+          case import_reference
+          when PackageDependencyReference, DynamicPackageImportReference
+            package_reference = import_reference.package_reference
+            download_package(ops_file.dirname, ops_file.ops_file_path, package_reference)
+          when DirectoryReference
+            # noop
+          when OpsFileReference
+            # noop
+          end
+        end
+      end
+    end
+
     # returns the array of the destination directories that the packages that ops_file depend on were downloaded to
     # e.g. [dir_path1, dir_path2, dir_path3, ...]
     def download_package_dependencies(package_file)
+      containing_directory = package_file.containing_directory
+      package_file_source = package_file.package_file_path
       package_file.dependencies.map do |local_name, package_reference|
-        download_package(package_file, package_reference)
+        download_package(containing_directory, package_file_source, package_reference)
       end
     end
 
@@ -107,7 +132,9 @@ module OpsWalrus
 
     # This method downloads a package_url that is a dependency referenced in the specified package_file
     # returns the destination directory that the package was downloaded to
-    def download_package(package_file, package_reference)
+    #
+    # relative_base_path is the relative base path that any relative file paths captured in the package_reference should be evaluated relative to
+    def download_package(relative_base_path, source_of_package_reference, package_reference)
       ensure_pwd_bundle_directory_exists
 
       local_name = package_reference.local_name
@@ -116,22 +143,25 @@ module OpsWalrus
 
       destination_package_path = @bundle_dir.join(package_reference.import_resolution_dirname)
 
-      App.instance.log("Downloading #{package_reference} referenced in #{package_file.package_file_path} to #{destination_package_path}")
+      # App.instance.log("Downloading #{package_reference} referenced in #{package_file.package_file_path} to #{destination_package_path}")
+      App.instance.log("Downloading #{package_reference} referenced in #{source_of_package_reference} to #{destination_package_path}")
 
       # we return early here under the assumption that an already downloaded package/version combo will not
       # differ if we download it again multiple times to the same location
       if destination_package_path.exist?
-        App.instance.log("Skipping #{package_reference} referenced in #{package_file.package_file_path} since it already has been downloaded to #{destination_package_path}")
+        App.instance.log("Skipping #{package_reference} referenced in #{source_of_package_reference} since it already has been downloaded to #{destination_package_path}")
         return destination_package_path
       end
       # FileUtils.remove_dir(destination_package_path) if destination_package_path.exist?
 
-      download_package_contents(package_file, local_name, package_url, version, destination_package_path)
+      # download_package_contents(package_file.containing_directory, local_name, package_url, version, destination_package_path)
+      download_package_contents(relative_base_path, local_name, package_url, version, destination_package_path)
 
       destination_package_path
     end
 
-    def download_package_contents(package_file, local_name, package_url, version, destination_package_path)
+    # relative_base_path is a Pathname
+    def download_package_contents(relative_base_path, local_name, package_url, version, destination_package_path)
       package_path = package_url.to_pathname
       package_path = package_path.to_s.gsub(/^~/, Dir.home).to_pathname
       App.instance.trace("download_package_contents #{package_path}")
@@ -148,7 +178,7 @@ module OpsWalrus
         end
       end
       if package_path.relative?                                                          # relative path reference
-        rebased_path = package_file.containing_directory.join(package_path)
+        rebased_path = relative_base_path.join(package_path)
         if rebased_path.exist?
           return case
           when rebased_path.directory?

data/lib/opswalrus/cli.rb

@@ -131,11 +131,46 @@ module OpsWalrus
         $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)
+
         tags = global_options[:tags]
+        $app.set_inventory_tags(tags)
+
+        id_files = global_options[:id]
+        id_files = OpsWalrus.env_specified_age_ids if id_files.empty?
+
+        $app.set_identity_files(id_files)
+
+        dry_run = [:noop, :dryrun, :dry_run].any? {|sym| global_options[sym] || options[sym] }
+        $app.dry_run! if dry_run
+
+        $app.bootstrap()
+      end
+    end
 
+    desc "Run a shell command on one or more remote hosts"
+    long_desc 'Run a shell command on one or more remote hosts'
+    command :shell do |c|
+      c.switch :pass, desc: "Prompt for a sudo password"
+      c.flag [:u, :user], desc: "Specify the user that the operation will run as"
+
+      # dry run
+      c.switch :noop, desc: "Perform a dry run"
+      c.switch :dryrun, desc: "Perform a dry run"
+      c.switch :dry_run, desc: "Perform a dry run"
+
+      c.action do |global_options, options, args|
+        $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)
+
+        tags = global_options[:tags]
         $app.set_inventory_tags(tags)
 
+        user = options[:user]
+        $app.set_sudo_user(user) if user
+
         id_files = global_options[:id]
         id_files = OpsWalrus.env_specified_age_ids if id_files.empty?
 
@@ -144,7 +179,13 @@ module OpsWalrus
         dry_run = [:noop, :dryrun, :dry_run].any? {|sym| global_options[sym] || options[sym] }
         $app.dry_run! if dry_run
 
-        $app.bootstrap()
+        if options[:pass]
+          $app.prompt_sudo_password
+        end
+
+        exit_status = $app.shell(args.join(" "))
+
+        exit_now!("error", exit_status) unless exit_status == 0
       end
     end
 
@@ -152,6 +193,7 @@ module OpsWalrus
     long_desc 'Run the specified operation found within the specified package'
     arg 'args', :multiple
     command :run do |c|
+      c.switch [:b, :bundle], desc: "Update bundle prior to running the specified operation"
       c.switch :pass, desc: "Prompt for a sudo password"
       c.switch :script, desc: "Script mode"
 
@@ -194,7 +236,7 @@ module OpsWalrus
           $app.script_mode!
         end
 
-        exit_status = $app.run(args)
+        exit_status = $app.run(args, update_bundle: options[:bundle])
 
         exit_now!("error", exit_status) unless exit_status == 0
       end

data/lib/opswalrus/host.rb

@@ -30,7 +30,7 @@ module OpsWalrus
             invocation_context = case import_reference
             # 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
+            when PackageDependencyReference, DynamicPackageImportReference
               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
@@ -261,12 +261,12 @@ module OpsWalrus
 
       # 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}"
-      if App.instance.info?
-        cmd << " --verbose"
+      if App.instance.trace?
+        cmd << " --trace"
       elsif App.instance.debug?
         cmd << " --debug"
-      elsif App.instance.trace?
-        cmd << " --trace"
+      elsif App.instance.info?
+        cmd << " --verbose"
       end
       cmd << " #{ops_command.to_s}"
       cmd << " #{ops_command_options.to_s}" if ops_command_options
@@ -300,32 +300,56 @@ module OpsWalrus
       @props[name] || @default_props[name]
     end
 
+    def ssh_session
+      @sshkit_backend
+    end
+
   end
 
   class Host
     include HostDSL
 
-    def initialize(name_or_ip_or_cidr, tags = [], props = {}, default_props = {}, hosts_file)
-      @name_or_ip_or_cidr = name_or_ip_or_cidr
+    # ssh_uri is a string of the form:
+    # - hostname
+    # - user@hostname
+    # - hostname:port
+    # - user@hostname:port
+    def initialize(ssh_uri, tags = [], props = {}, default_props = {}, hosts_file = nil)
+      @ssh_uri = ssh_uri
+      @host = nil
       @tags = tags.to_set
       @props = props.is_a?(Array) ? {"tags" => props} : props.to_h
       @default_props = default_props
       @hosts_file = hosts_file
       @tmp_ssh_key_files = []
+      parse_ssh_uri!
+    end
+
+    def parse_ssh_uri!
+      if match = /^\s*((?<user>.*?)@)?(?<host>.*?)(:(?<port>[0-9]+))?\s*$/.match(@ssh_uri)
+        @host ||= match[:host] if match[:host]
+        @props["user"] ||= match[:user] if match[:user]
+        @props["port"] ||= match[:port].to_i if match[:port]
+      end
     end
 
     # secret_ref: SecretRef
     # returns the decrypted value referenced by the supplied SecretRef
     def dereference_secret_if_needed(secret_ref)
       if secret_ref.is_a? SecretRef
+        raise "Host #{self} not read from hosts file so no secrets can be dereferenced." unless @hosts_file
         @hosts_file.read_secret(secret_ref.to_s)
       else
         secret_ref
       end
     end
 
+    def ssh_uri
+      @ssh_uri
+    end
+
     def host
-      @name_or_ip_or_cidr
+      @host
     end
 
     def alias
@@ -337,7 +361,7 @@ module OpsWalrus
     end
 
     def ssh_port
-      @props["port"] || @default_props["port"]
+      @props["port"] || @default_props["port"] || 22
     end
 
     def ssh_user
@@ -346,6 +370,9 @@ module OpsWalrus
 
     def ssh_password
       password = @props["password"] || @default_props["password"]
+      password ||= begin
+        @props["password"] = IO::console.getpass("[opswalrus] Please enter ssh password to connect to #{ssh_user}@#{host}:#{ssh_port}: ")
+      end
       dereference_secret_if_needed(password)
     end
 
@@ -354,7 +381,7 @@ module OpsWalrus
     end
 
     def hash
-      @name_or_ip_or_cidr.hash
+      @ssh_uri.hash
     end
 
     def eql?(other)
@@ -362,7 +389,7 @@ module OpsWalrus
     end
 
     def to_s
-      @name_or_ip_or_cidr
+      @ssh_uri
     end
 
     def tag!(*tags)
@@ -396,7 +423,7 @@ module OpsWalrus
       # the various options for net-ssh are captured in https://net-ssh.github.io/ssh/v1/chapter-2.html
       @sshkit_host ||= ::SSHKit::Host.new({
         hostname: host,
-        port: ssh_port || 22,
+        port: ssh_port,
         user: ssh_user || raise("No ssh user specified to connect to #{host}"),
         password: ssh_password,
         keys: keys
@@ -415,6 +442,7 @@ module OpsWalrus
         if key_file_path_or_in_memory_key_text.is_a? SecretRef    # we're dealing with an in-memory key file; we need to write it to a tempfile
           tempfile = Tempfile.create
           @tmp_ssh_key_files << tempfile
+          raise "Host #{self} not read from hosts file so no secrets can be written." unless @hosts_file
           key_file_contents = @hosts_file.read_secret(key_file_path_or_in_memory_key_text.to_s)
           tempfile.write(key_file_contents)
           tempfile.close   # we want to close the file without unlinking so that the editor can write to it

data/lib/opswalrus/interaction_handlers.rb

@@ -4,6 +4,7 @@ module OpsWalrus
 
   class ScopedMappingInteractionHandler
     STANDARD_SUDO_PASSWORD_PROMPT = /\[sudo\] password for .*?:\s*/
+    STANDARD_SSH_PASSWORD_PROMPT = /.*?@.*?'s password:\s*/
 
     attr_accessor :input_mappings   # Hash[ String | Regex => String ]
 
@@ -13,6 +14,14 @@ module OpsWalrus
       @input_mappings = mapping
     end
 
+    # sudo_password : String | Nil
+    def self.mapping_for_ssh_password_prompt(ssh_password)
+      password_response = ssh_password && ::SSHKit::InteractionHandler::Password.new("#{ssh_password}\n")
+      {
+        STANDARD_SSH_PASSWORD_PROMPT => password_response,
+      }
+    end
+
     # sudo_password : String | Nil
     def self.mapping_for_sudo_password(sudo_password)
       password_response = sudo_password && ::SSHKit::InteractionHandler::Password.new("#{sudo_password}\n")
@@ -51,7 +60,7 @@ module OpsWalrus
       end
       new_mapping.merge!(password_mappings) if password_mappings
 
-      if new_mapping.empty?
+      if new_mapping.empty? || new_mapping == @input_mappings
         yield self
       else
         yield ScopedMappingInteractionHandler.new(new_mapping, @log_level)

data/lib/opswalrus/invocation.rb

@@ -137,9 +137,10 @@ module OpsWalrus
           json_kwargs_tempfile.close rescue nil
           File.unlink(json_kwargs_tempfile) rescue nil
         end
-        if remote_json_kwargs_tempfile_basename
-          @host_proxy.execute(:rm, "-f", remote_json_kwargs_tempfile_basename)
-        end
+        # todo: make sure this cleanup is present
+        # if remote_json_kwargs_tempfile_basename
+        #   @host_proxy.execute(:rm, "-f", remote_json_kwargs_tempfile_basename)
+        # end
       end
     end
   end

data/lib/opswalrus/ops_file.rb

@@ -163,7 +163,7 @@ module OpsWalrus
       end
 
       package_uri = import_str
-      if Git.repo?(package_uri)                                                         # ops file has imported an ad-hoc git repo
+      if package_uri = 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)
         App.instance.trace "DynamicPackageImportReference: #{local_name} -> #{destination_package_path}"
         return DynamicPackageImportReference.new(local_name, DynamicPackageReference.new(local_name, package_uri, nil))

data/lib/opswalrus/ops_file_script_dsl.rb

@@ -47,11 +47,6 @@ module OpsWalrus
   end
 
 
-  # BootstrapLinuxHostShellScript = <<~SCRIPT
-  #   #!/usr/bin/env bash
-  #   ...
-  # SCRIPT
-
   module OpsFileScriptDSL
     def ssh_noprep(*args, **kwargs, &block)
       runtime_env = @runtime_env
@@ -59,48 +54,55 @@ 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
       # on sshkit_hosts do |sshkit_host|
       SSHKit::Coordinator.new(sshkit_hosts).each(in: kwargs[:in] || :parallel) do |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]
-
-        begin
-          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
-
-          # we run the block in the context of the host proxy object, s.t. `self` within the block evaluates to the host proxy object
-          retval = host.instance_exec(local_host, &block)    # local_host is passed as the argument to the block
-
-          retval
-        rescue SSHKit::Command::Failed => e
-          App.instance.error "[!] Command failed:"
-          App.instance.error e.message
-        rescue Net::SSH::ConnectionTimeout
-          App.instance.error "[!] The host '#{host}' not alive!"
-        rescue Net::SSH::Timeout
-          App.instance.error "[!] The host '#{host}' disconnected/timeouted unexpectedly!"
-        rescue Errno::ECONNREFUSED
-          App.instance.error "[!] Incorrect port #{port} for #{host}"
-        rescue Net::SSH::HostKeyMismatch => e
-          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
-          App.instance.error "Wrong Password: #{host} | #{user}:#{password}"
-        rescue Net::SSH::Authentication::DisallowedMethod
-          App.instance.error "[!] The host '#{host}' doesn't accept password authentication method."
-        rescue Errno::EHOSTUNREACH => e
-          App.instance.error "[!] The host '#{host}' is unreachable"
-        rescue => e
-          App.instance.error e.class
-          App.instance.error e.message
-          App.instance.error e.backtrace.join("\n")
-        ensure
-          host.clear_ssh_session
-        end
-      end
-    end
+        sshkit_backend = self   # self is an instance of one of the subclasses of SSHKit::Backend::Abstract, e.g. SSHKit::Backend::Netssh
+
+        ssh_password_interaction_mapping = host.ssh_password && ScopedMappingInteractionHandler.mapping_for_ssh_password_prompt(host.ssh_password)
+        runtime_env.handle_input(ssh_password_interaction_mapping, inherit_existing_mappings: true) do |interaction_handler|
+          App.instance.debug("OpsFileScriptDSL#ssh input mappings #{interaction_handler.input_mappings.inspect}")
+
+          begin
+            host.set_runtime_env(runtime_env)
+            host.set_ops_file_script(ops_file_script)
+            host.set_ssh_session_connection(sshkit_backend)
+
+            # we run the block in the context of the host proxy object, s.t. `self` within the block evaluates to the host proxy object
+            retval = host.instance_exec(local_host, &block)    # local_host is passed as the argument to the block
+
+            retval
+          rescue SSHKit::Command::Failed => e
+            App.instance.error "[!] Command failed:"
+            App.instance.error e.message
+          rescue Net::SSH::ConnectionTimeout
+            App.instance.error "[!] The host '#{host}' not alive!"
+          rescue Net::SSH::Timeout
+            App.instance.error "[!] The host '#{host}' disconnected/timeouted unexpectedly!"
+          rescue Errno::ECONNREFUSED
+            App.instance.error "[!] Incorrect port #{host.ssh_port} for #{host}"
+          rescue Net::SSH::HostKeyMismatch => e
+            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
+            App.instance.error "Wrong Password: #{host} | #{host.ssh_user}:#{host.ssh_password}"
+          rescue Net::SSH::Authentication::DisallowedMethod
+            App.instance.error "[!] The host '#{host}' doesn't accept password authentication method."
+          rescue Errno::EHOSTUNREACH => e
+            App.instance.error "[!] The host '#{host}' is unreachable"
+          rescue => e
+            App.instance.error e.class
+            App.instance.error e.message
+            App.instance.error e.backtrace.join("\n")
+          ensure
+            host.clear_ssh_session
+          end
+        end # runtime_env.handle_input
+      end # SSHKit::Coordinator
+    end # def ssh
 
     def ssh(*args, **kwargs, &block)
       runtime_env = @runtime_env
@@ -114,48 +116,54 @@ module OpsWalrus
       SSHKit::Coordinator.new(sshkit_hosts).each(in: kwargs[:in] || :parallel) do |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]
-
-        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
-
-          stdout, stderr, exit_status = host._bootstrap_host(false)
-          retval = if exit_status == 0
-            host._zip_copy_and_run_ops_bundle(local_host, block)
-          else
-            puts "Failed to bootstrap #{host}. Unable to run operation."
+        sshkit_backend = self   # self is an instance of one of the subclasses of SSHKit::Backend::Abstract, e.g. SSHKit::Backend::Netssh
+
+        ssh_password_interaction_mapping = host.ssh_password && ScopedMappingInteractionHandler.mapping_for_ssh_password_prompt(host.ssh_password)
+        runtime_env.handle_input(ssh_password_interaction_mapping, inherit_existing_mappings: true) do |interaction_handler|
+          App.instance.debug("OpsFileScriptDSL#ssh input mappings #{interaction_handler.input_mappings.inspect}")
+
+          begin
+            host.set_runtime_env(runtime_env)
+            host.set_ops_file_script(ops_file_script)
+            host.set_ssh_session_connection(sshkit_backend)
+
+            stdout, stderr, exit_status = host._bootstrap_host(true)
+            retval = if exit_status == 0
+              host._zip_copy_and_run_ops_bundle(local_host, block)
+            else
+              puts "Failed to bootstrap #{host}. Unable to run operation."
+            end
+
+            retval
+          rescue SSHKit::Command::Failed => e
+            App.instance.error "[!] Command failed:"
+            App.instance.error e.message
+          rescue Net::SSH::ConnectionTimeout
+            App.instance.error "[!] The host '#{host}' not alive!"
+          rescue Net::SSH::Timeout
+            App.instance.error "[!] The host '#{host}' disconnected/timeouted unexpectedly!"
+          rescue Errno::ECONNREFUSED
+            App.instance.error "[!] Incorrect port #{host.ssh_port} for #{host}"
+          rescue Net::SSH::HostKeyMismatch => e
+            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
+            App.instance.error "Wrong Password: #{host} | #{host.ssh_user}:#{host.ssh_password}"
+          rescue Net::SSH::Authentication::DisallowedMethod
+            App.instance.error "[!] The host '#{host}' doesn't accept password authentication method."
+          rescue Errno::EHOSTUNREACH => e
+            App.instance.error "[!] The host '#{host}' is unreachable"
+          rescue => e
+            App.instance.error e.class
+            App.instance.error e.message
+            App.instance.error e.backtrace.join("\n")
+          ensure
+            host.clear_ssh_session
           end
-
-          retval
-        rescue SSHKit::Command::Failed => e
-          App.instance.error "[!] Command failed:"
-          App.instance.error e.message
-        rescue Net::SSH::ConnectionTimeout
-          App.instance.error "[!] The host '#{host}' not alive!"
-        rescue Net::SSH::Timeout
-          App.instance.error "[!] The host '#{host}' disconnected/timeouted unexpectedly!"
-        rescue Errno::ECONNREFUSED
-          App.instance.error "[!] Incorrect port #{port} for #{host}"
-        rescue Net::SSH::HostKeyMismatch => e
-          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
-          App.instance.error "Wrong Password: #{host} | #{user}:#{password}"
-        rescue Net::SSH::Authentication::DisallowedMethod
-          App.instance.error "[!] The host '#{host}' doesn't accept password authentication method."
-        rescue Errno::EHOSTUNREACH => e
-          App.instance.error "[!] The host '#{host}' is unreachable"
-        rescue => e
-          App.instance.error e.class
-          App.instance.error e.message
-          App.instance.error e.backtrace.join("\n")
-        ensure
-          host.clear_ssh_session
-        end
-      end
-    end
+        end # runtime_env.handle_input
+      end # SSHKit::Coordinator
+    end # def ssh
 
     def current_dir
       File.dirname(File.realpath(@runtime_ops_file_path)).to_pathname

data/lib/opswalrus/package_file.rb

@@ -72,10 +72,10 @@ module OpsWalrus
       self
     end
 
-    def bundle!
-      bundler_for_package = Bundler.new(dirname)
-      bundler_for_package.update
-    end
+    # def bundle!
+    #   bundler_for_package = Bundler.new(dirname)
+    #   bundler_for_package.update
+    # end
 
     def dirname
       @package_file_path.dirname

data/lib/opswalrus/patches.rb

@@ -38,6 +38,10 @@ class String
   def string!(default: "")
     self
   end
+
+  def integer!(default: 0)
+    to_i
+  end
 end
 
 class Integer
@@ -48,6 +52,10 @@ class Integer
   def string!(default: "")
     to_s
   end
+
+  def integer!(default: 0)
+    self
+  end
 end
 
 class Float
@@ -58,6 +66,10 @@ class Float
   def string!(default: "")
     to_s
   end
+
+  def integer!(default: 0)
+    to_i
+  end
 end
 
 class NilClass
@@ -68,6 +80,10 @@ class NilClass
   def string!(default: "")
     default
   end
+
+  def integer!(default: 0)
+    default
+  end
 end
 
 class TrueClass
@@ -78,6 +94,10 @@ class TrueClass
   def string!(default: "")
     to_s
   end
+
+  def integer!(default: 0)
+    default
+  end
 end
 
 class FalseClass
@@ -88,4 +108,8 @@ class FalseClass
   def string!(default: "")
     to_s
   end
+
+  def integer!(default: 0)
+    default
+  end
 end

data/lib/opswalrus/runtime_environment.rb

@@ -250,6 +250,9 @@ module OpsWalrus
       # host will be managed by the local ScopedMappingInteractionHandler running within the instance of the ops command
       # process on the remote host, and the command host will not have any further opportunity to interactively enter
       # any prompts on the remote host
+      # All that to say that this initial mapping handler will be used to fill in the sudo password for commands running
+      # on the remote host, and it will be the instance of the ops tool running on the remote host that will interactively
+      # fill out the password on the remote host
       interaction_handler_mapping_for_sudo_password = ScopedMappingInteractionHandler.mapping_for_sudo_password(sudo_password)
       @interaction_handler = ScopedMappingInteractionHandler.new(interaction_handler_mapping_for_sudo_password)
 

data/lib/opswalrus/version.rb

@@ -1,3 +1,3 @@
 module OpsWalrus
-  VERSION = "1.0.49"
+  VERSION = "1.0.50"
 end

data/vms/web-ubuntu/Vagrantfile

@@ -23,8 +23,8 @@ Vagrant.configure("2") do |config|
   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
+      # echo #{ssh_pub_key} >> /home/vagrant/.ssh/authorized_keys
+      # echo #{ssh_pub_key} >> /root/.ssh/authorized_keys
 
       sudo sed -i 's/PasswordAuthentication no/PasswordAuthentication yes/g' /etc/ssh/sshd_config
       sudo systemctl restart sshd

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opswalrus
 version: !ruby/object:Gem::Version
-  version: 1.0.49
+  version: 1.0.50
 platform: ruby
 authors:
 - David Ellis
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-14 00:00:00.000000000 Z
+date: 2023-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: binding_of_caller
@@ -184,8 +184,9 @@ files:
 - build.ops
 - exe/ops
 - lib/opswalrus.rb
+- lib/opswalrus/_bootstrap.ops
+- lib/opswalrus/_shell.ops
 - lib/opswalrus/app.rb
-- lib/opswalrus/bootstrap.ops
 - lib/opswalrus/bootstrap.sh
 - lib/opswalrus/bundler.rb
 - lib/opswalrus/cli.rb