opswalrus 1.0.0 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 052a555c9674e3835b9609c8b5040ed4c1a7fa5d78cc746b9bad9a64d610a2cd
-  data.tar.gz: e9c6dbad4a3d82cb5d59d823bdfe9f9533628a5deba6ac379164fb77518c3489
+  metadata.gz: cf572dd5c13457782bb8256a38f4572ba897a7bb37ab4da0220fd3a69866b8ad
+  data.tar.gz: 6ebc7681b98c3bc745b310eee40f866b8d6d328c37b50552b409ca1362b07889
 SHA512:
-  metadata.gz: febce81b7caa90a615a87443cc62a1cfc47642922d6a3b585b6d8fbdb545c29d4ca3d031e9dcfcc6d87eb7852b16b13d353e2089ea9cec156f4be017b943feb2
-  data.tar.gz: 384aadc1dc7fcb3311d49262b221679a3447c3c55a0154f97a880882ab3ed45510757b71be1a2e564cbff8ac433c63bef7808be6a1a6735c3e1587a11ee32d9f
+  metadata.gz: 2be383a35f09b51d6e42be8280eaf3760d8735aea0b747406e9258b237dc38b55594a56000a88d2a1c398ae7de56d1391903eed0d1c542850f9bd4f167348c9c
+  data.tar.gz: 71f1f58d4dda0533fdbd8fd35612daae8f2ad8390ae215d2d437432b6ab801c9ed87f614eb54c018db3ccbe72806625f38471d16b7edbff72ddfed376530437b

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    opswalrus (1.0.0)
+    opswalrus (1.0.1)
       bcrypt_pbkdf
       citrus
       ed25519

data/lib/opswalrus/app.rb

@@ -39,6 +39,8 @@ module OpsWalrus
       @instance ||= new(*args)
     end
 
+    LOCAL_SUDO_PASSWORD_PROMPT = "[ops] Enter sudo password to run sudo in local environment: "
+
 
     attr_reader :local_hostname
 
@@ -119,7 +121,7 @@ module OpsWalrus
     end
 
     def prompt_sudo_password
-      password = IO::console.getpass("[ops] Enter sudo password to run sudo in local environment: ")
+      password = IO::console.getpass(LOCAL_SUDO_PASSWORD_PROMPT)
       set_sudo_password(password)
       nil
     end
@@ -207,46 +209,52 @@ module OpsWalrus
       tmp_dir = nil
 
       case
+      when Dir.exist?(package_or_ops_file_reference)
+        dir = package_or_ops_file_reference
+        ops_file_path, operation_kv_args = find_entry_point_ops_file_in_dir(dir, package_operation_and_args)
+        [ops_file_path, operation_kv_args, tmp_dir]
       when File.exist?(package_or_ops_file_reference)
         first_filepath = package_or_ops_file_reference.to_pathname.realpath
-        ops_file_path = case first_filepath.extname.downcase
+
+        ops_file_path, operation_kv_args = case first_filepath.extname.downcase
         when ".ops"
-          first_filepath
+          [first_filepath, package_operation_and_args]
         when ".zip"
-          tmp_dir = Dir.mktmpdir.to_pathname
+          tmp_dir = Dir.mktmpdir.to_pathname    # this is the temporary bundle root dir
 
           # unzip the bundle into the temp directory
           DirZipper.unzip(first_filepath, tmp_dir)
 
-          relative_ops_path = package_operation_and_args.slice!(0, 1).first
-
-          tmp_dir.join(relative_ops_path)
+          find_entry_point_ops_file_in_dir(tmp_dir, package_operation_and_args)
         else
           raise Error, "Unknown file type for entrypoint: #{first_filepath}"
         end
-        operation_kv_args = package_operation_and_args
-        [ops_file_path, operation_kv_args, tmp_dir ]
+
+        # operation_kv_args = package_operation_and_args
+        [ops_file_path, operation_kv_args, tmp_dir]
       when repo_url = git_repo?(package_or_ops_file_reference)
         destination_package_path = bundler.download_git_package(repo_url)
 
-        ops_file_path = nil
-        base_path = Pathname.new(destination_package_path)
-        path_parts = 0
-        package_operation_and_args.each do |candidate_path_arg|
-          candidate_base_path = base_path.join(candidate_path_arg)
-          candidate_ops_file = candidate_base_path.sub_ext(".ops")
-          if candidate_ops_file.exist?
-            path_parts += 1
-            ops_file_path = candidate_ops_file
-            break
-          elsif candidate_base_path.exist?
-            path_parts += 1
-          else
-            raise Error, "Operation not found in #{repo_url}: #{candidate_base_path}"
-          end
-          base_path = candidate_base_path
-        end
-        operation_kv_args = package_operation_and_args.drop(path_parts)
+        ops_file_path, operation_kv_args = find_entry_point_ops_file_in_dir(destination_package_path, package_operation_and_args)
+
+        # ops_file_path = nil
+        # base_path = Pathname.new(destination_package_path)
+        # path_parts = 0
+        # package_operation_and_args.each do |candidate_path_arg|
+        #   candidate_base_path = base_path.join(candidate_path_arg)
+        #   candidate_ops_file = candidate_base_path.sub_ext(".ops")
+        #   if candidate_ops_file.exist?
+        #     path_parts += 1
+        #     ops_file_path = candidate_ops_file
+        #     break
+        #   elsif candidate_base_path.exist?
+        #     path_parts += 1
+        #   else
+        #     raise Error, "Operation not found in #{repo_url}: #{candidate_base_path}"
+        #   end
+        #   base_path = candidate_base_path
+        # end
+        # operation_kv_args = package_operation_and_args.drop(path_parts)
 
         # for an original package_operation_and_args of ["github.com/davidkellis/my-package", "operation1", "arg1:val1", "arg2:val2", "arg3:val3"]
         # we return: [ "#{pwd}/#{Bundler::BUNDLE_DIR}/github-com-davidkellis-my-package/operation1.ops", ["arg1:val1", "arg2:val2", "arg3:val3"] ]
@@ -256,6 +264,31 @@ module OpsWalrus
       end
     end
 
+    # returns pair of the form: [ ops_file_path, operation_kv_args ]
+    def find_entry_point_ops_file_in_dir(base_dir, package_operation_and_args)
+      ops_file_path = nil
+      base_path = Pathname.new(base_dir)
+
+      path_parts = 0
+      package_operation_and_args.each do |candidate_path_arg|
+        candidate_base_path = base_path.join(candidate_path_arg)
+        candidate_ops_file = candidate_base_path.sub_ext(".ops")
+        if candidate_ops_file.exist?
+          path_parts += 1
+          ops_file_path = candidate_ops_file
+          break
+        elsif candidate_base_path.exist?
+          path_parts += 1
+        else
+          raise Error, "Operation not found in: #{candidate_base_path}"
+        end
+        base_path = candidate_base_path
+      end
+      operation_kv_args = package_operation_and_args.drop(path_parts)
+
+      [ops_file_path, operation_kv_args]
+    end
+
     # git_repo?("davidkellis/arborist") -> "https://github.com/davidkellis/arborist"
     # returns the repo URL
     def git_repo?(repo_reference)
@@ -268,6 +301,10 @@ module OpsWalrus
       working_repo_reference
     end
 
+    # def is_dir_git_repo?(dir_path)
+    #   Git.ls_remote(reference) rescue nil
+    # end
+
     def bundle_status
     end
 

data/lib/opswalrus/host.rb

@@ -53,17 +53,67 @@ module OpsWalrus
     #   execute('eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"')
     # end
 
-    def run_ops(cmd)
-      shell!("/home/linuxbrew/.linuxbrew/bin/gem exec opswalrus ops #{cmd}")
+    # runs the specified ops command with the specified command arguments
+    def run_ops(command, command_arguments, in_bundle_root_dir: true)
+      if in_bundle_root_dir
+        # e.g. /home/linuxbrew/.linuxbrew/bin/gem exec -g opswalrus ops bundle unzip tmpops.zip
+        shell!("/home/linuxbrew/.linuxbrew/bin/gem exec -g opswalrus ops #{command} #{@tmp_bundle_root_dir} #{command_arguments}")
+      else
+        shell!("/home/linuxbrew/.linuxbrew/bin/gem exec -g opswalrus ops #{command} #{command_arguments}")
+      end
     end
 
   end
 
+  class HostProxyOpsFileInvocationBuilder
+    def initialize(host_proxy, is_invocation_a_call_to_package_in_bundle_dir = false)
+      @host_proxy = host_proxy
+      @is_invocation_a_call_to_package_in_bundle_dir = is_invocation_a_call_to_package_in_bundle_dir
+      @method_chain = []
+    end
+
+    def method_missing(method_name, *args, **kwargs)
+      @method_chain << method_name.to_s
+
+      if args.empty? && kwargs.empty?   # when there are no args and no kwargs, we are just drilling down through another namespace
+        self
+      else
+        # when there are args or kwargs, then the method invocation represents an attempt to run an OpsFile on a remote host,
+        # so we want to build up a command and send it to the remote host via HostDSL#run_ops
+        @method_chain.unshift(Bundler::BUNDLE_DIR) if @is_invocation_a_call_to_package_in_bundle_dir
+
+        # path_to_ops_file_basename = @method_chain.join(File::Separator)
+        # remote_run_command_args << path_to_ops_file_basename
+
+        remote_run_command_args = @method_chain.join(" ")
+
+        unless args.empty?
+          remote_run_command_args << " "
+          remote_run_command_args << args.join(" ")
+        end
+
+        unless kvargs.empty?
+          remote_run_command_args << " "
+          remote_run_command_args << kvargs.map{|k,v| "#{k}=#{v}" }.join(" ") unless kvargs.empty?
+        end
+
+        @host_proxy.run_ops(:run, remote_run_command_args)
+      end
+    end
+  end
+
+  # the subclasses of HostProxy will define methods that handle method dispatch via HostProxyOpsFileInvocationBuilder objects
   class HostProxy
+    attr_accessor :_host
+
     def initialize(host)
-      @host = host
+      @_host = host
     end
-    def method_missing()
+
+    # the subclasses of this class will define methods that handle method dispatch via HostProxyOpsFileInvocationBuilder objects
+
+    def method_missing(name, ...)
+      @_host.send(name, ...)
     end
   end
 
@@ -141,12 +191,17 @@ module OpsWalrus
       })
     end
 
-    def set_ssh_connection(sshkit_backend)
+    def set_ssh_session_connection(sshkit_backend)
       @sshkit_backend = sshkit_backend
     end
 
-    def clear_ssh_connection
-      @sskit_backend = nil
+    def set_ssh_session_tmp_bundle_root_dir(tmp_bundle_root_dir)
+      @tmp_bundle_root_dir = tmp_bundle_root_dir
+    end
+
+    def clear_ssh_session
+      @sshkit_backend = nil
+      @tmp_bundle_root_dir = nil
     end
 
     def execute(*args)
@@ -168,10 +223,6 @@ module OpsWalrus
       @sshkit_backend.download!(remote_path.to_s, local_path.to_s)
     end
 
-    def run
-
-    end
-
   end
 
 end

data/lib/opswalrus/interaction_handlers.rb

@@ -25,6 +25,7 @@ module OpsWalrus
     def interaction_handler
       SSHKit::MappingInteractionHandler.new({
         /\[sudo\] password for .*?:\s*/ => "#{@sudo_password}\n",
+        App::LOCAL_SUDO_PASSWORD_PROMPT => "#{@sudo_password}\n",
         # /\s+/ => nil,     # unnecessary
       }, :info)
     end

data/lib/opswalrus/ops_file.rb

@@ -115,7 +115,7 @@ module OpsWalrus
     end
 
     def invoke(runtime_env, params_hash)
-      puts "invoking: #{ops_file_path}"
+      # puts "invoking: #{ops_file_path}"
       script.invoke(runtime_env, params_hash)
     end
 
@@ -146,7 +146,7 @@ module OpsWalrus
       @local_symbol_table ||= begin
         local_symbol_table = {}
 
-        local_symbol_table.merge(imports)
+        local_symbol_table.merge!(imports)
 
         # this is the import for the private lib directory if it exists
         if private_lib_dir.exist?

data/lib/opswalrus/ops_file_script.rb

@@ -8,6 +8,7 @@ require 'stringio'
 require 'sshkit'
 require 'sshkit/dsl'
 
+require_relative 'host'
 require_relative 'sshkit_ext'
 require_relative 'walrus_lang'
 
@@ -71,24 +72,24 @@ module OpsWalrus
   end
 
   class Env
-    # params : Hash
-    def initialize(params)
-      @params = params
+    # env : Hash
+    def initialize(env)
+      @env = env
     end
 
     def [](key)
       key = key.to_s if key.is_a? Symbol
-      @params[key]
+      @env[key]
     end
 
     def dig(*keys)
       keys = keys.map {|key| key.is_a?(Integer) ? key : key.to_s }
-      @params.dig(*keys)
+      @env.dig(*keys)
     end
 
     def method_missing(name, *args, **kwargs, &block)
-      if @params.respond_to?(name)
-        @params.method(name).call(*args, **kwargs, &block)
+      if @env.respond_to?(name)
+        @env.method(name).call(*args, **kwargs, &block)
       else
         value = self[name]
         case value
@@ -107,10 +108,9 @@ module OpsWalrus
   # SCRIPT
 
   module DSL
-    # include SSHKit::DSL
-
     def ssh(*args, **kwargs, &block)
-      hosts = inventory(*args, **kwargs)
+      host_proxy_class = @ops_file_script.host_proxy_class
+      hosts = inventory(*args, **kwargs).map {|host| host_proxy_class.new(host) }
       sshkit_hosts = hosts.map(&:sshkit_host)
       sshkit_host_to_ops_host_map = sshkit_hosts.zip(hosts).to_h
       runtime_env = @runtime_env
@@ -124,7 +124,7 @@ module OpsWalrus
 
         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_connection(self)
+          host.set_ssh_session_connection(self)
 
           # copy over bootstrap shell script
           # io = StringIO.new(bootstrap_shell_script)
@@ -140,9 +140,10 @@ module OpsWalrus
           upload_success = host.upload(zip_bundle_path, "tmpops.zip")
           raise Error, "Unable to upload ops bundle to remote host" unless upload_success
 
-          stdout, stderr, exit_status = host.run_ops("unzip tmpops.zip")
+          stdout, stderr, exit_status = host.run_ops(:bundle, "unzip tmpops.zip", in_bundle_root_dir: false)
           raise Error, "Unable to unzip ops bundle on remote host" unless exit_status == 0
-          tmp_bundle_dir = stdout.strip
+          tmp_bundle_root_dir = stdout.strip
+          host.set_ssh_session_tmp_bundle_root_dir(tmp_bundle_root_dir)
 
           # we run the block in the context of the host, s.t. `self` within the block evaluates to `host`
           retval = host.instance_exec(local_host, &block)    # host is passed as the argument to the block
@@ -179,7 +180,7 @@ module OpsWalrus
           puts e.message
           # puts e.backtrace.join("\n")
         ensure
-          host.clear_ssh_connection
+          host.clear_ssh_session
         end
       end
     end
@@ -291,6 +292,7 @@ module OpsWalrus
       @ops_file = ops_file
       @ruby_script = ruby_script
       @invocation_class = define_invocation_class
+      @host_proxy_class = define_host_proxy_class
     end
 
     def define_invocation_class
@@ -350,6 +352,56 @@ module OpsWalrus
       klass
     end
 
+    def define_host_proxy_class
+      klass = Class.new(HostProxy)
+
+      methods_defined = Set.new
+
+      # define methods for every import in the script
+      ops_file.local_symbol_table.each do |symbol_name, import_reference|
+        unless methods_defined.include? symbol_name
+          # puts "1. defining: #{symbol_name}(...)"
+          klass.define_method(symbol_name) do |*args, **kwargs, &block|
+            invocation_builder = 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
+              HostProxyOpsFileInvocationBuilder.new(self, true)
+
+            # we know we're dealing with a directory reference or OpsFile reference outside of the bundle dir, so we want to reference
+            # the specified ops file with respect to the root directory, and not with respect to the bundle dir
+            when DirectoryReference, OpsFileReference
+              HostProxyOpsFileInvocationBuilder.new(self, false)
+            end
+
+            invocation_builder.send(symbol_name, *args, **kwargs, &block)
+          end
+          methods_defined << symbol_name
+        end
+      end
+
+      # define methods for every Namespace or OpsFile within the namespace that the OpsFile resides within
+      sibling_symbol_table = Set.new
+      sibling_symbol_table |= ops_file.dirname.glob("*.ops").map {|ops_file_path| ops_file_path.basename(".ops").to_s }   # OpsFiles
+      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|
+            invocation_builder = HostProxyOpsFileInvocationBuilder.new(self, false)
+            invocation_builder.invoke(symbol_name, *args, **kwargs, &block)
+          end
+          methods_defined << symbol_name
+        end
+      end
+
+      klass
+    end
+
+    def host_proxy_class
+      @host_proxy_class
+    end
+
     def script
       @ruby_script
     end

data/lib/opswalrus/version.rb

@@ -1,3 +1,3 @@
 module OpsWalrus
-  VERSION = "1.0.0"
+  VERSION = "1.0.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opswalrus
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.2
 platform: ruby
 authors:
 - David Ellis
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-13 00:00:00.000000000 Z
+date: 2023-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: citrus
@@ -114,7 +114,6 @@ email:
 - david@conquerthelawn.com
 executables:
 - ops
-- run_ops_bundle
 extensions: []
 extra_rdoc_files: []
 files:
@@ -125,7 +124,6 @@ files:
 - README.md
 - Rakefile
 - exe/ops
-- exe/run_ops_bundle
 - lib/opswalrus.rb
 - lib/opswalrus/app.rb
 - lib/opswalrus/bootstrap.sh

data/exe/run_ops_bundle

@@ -1,22 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'opswalrus'
-
-def main
-  zip_file_path = ARGV.shift.to_pathname
-
-  exit_status = 0
-
-  Dir.mktmpdir do |dir|
-    dir = dir.to_pathname
-
-    # unzip the bundle into the temp directory
-    OpsWalrus::DirZipper.unzip(zip_file_path, dir)
-
-    exit_status = OpsWalrus::Cli.run(ARGV)
-  end
-
-  exit exit_status
-end
-
-main