opswalrus 1.0.11 → 1.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9504aa3c2b2bb9cb90f0623261750dcf956be5d1ea227b82851260d0fdd425ca
-  data.tar.gz: cc36a65d93bb507cdf5b6041d5c3228f2a3f84acb78bcc8489d9fb925e86b13a
+  metadata.gz: 1199faea66fca54073c2446271ef2c31a8e78e6dd55e7e9de5173baae5da7ac4
+  data.tar.gz: 1bbe73114e2cf1449ad296245d4cf53a2c2f8c523a1652f0ce1776bf742e4438
 SHA512:
-  metadata.gz: f0ff218c83c59ecb04149ec050ab607421aa7f73f566adf079ac55d71748e853d8c8d5606b088bf1a52419cd50fe54da3053eb9ad31bd86131f3afa163a6bbc8
-  data.tar.gz: 64d394b48755699addc20e1528a8806c6e38c4baf7e406ecf39d760a18b04c4a13d6554d0e5955c734c15e04fb18b5ea5e7d51bd29df66674f789e31b8203d28
+  metadata.gz: d4e9a452262cf8a3a82c967bfc5dc9e8b39f87f80b42fb9b641fa764811e2735a78b307cc0c2751c6c185c8223561c0d41b5913b7c62c78d76c020907c8f8286
+  data.tar.gz: 15f772925cb50837543ee0277ca3e4fbee42c0c64e3c0ad28c940617c008d51c4507f3950a3fb28a96086ea8d759368f7b06e04b2f4aaee406a6883cc61956cf

data/Gemfile.lock

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

data/lib/opswalrus/app.rb

@@ -239,25 +239,6 @@ module OpsWalrus
 
         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"] ]
         [ops_file_path, operation_kv_args, tmp_dir]

data/lib/opswalrus/bundler.rb

@@ -109,38 +109,73 @@ module OpsWalrus
       package_url = package_reference.package_uri
       version = package_reference.version
 
-      destination_package_path = @bundle_dir.join(package_reference.dirname)
+      destination_package_path = @bundle_dir.join(package_reference.import_resolution_dirname)
       FileUtils.remove_dir(destination_package_path) if destination_package_path.exist?
 
-      case
-      when package_url =~ /\.git/                               # git reference
-        download_git_package(package_url, version, destination_package_path)
-      when package_url.start_with?("file://")                   # local path
-        path = package_url.sub("file://", "")
-        path = path.to_pathname
-        package_path_to_download = if path.relative?            # relative path
-          package_file.containing_directory.join(path)
-        else                                                    # absolute path
-          path.realpath
-        end
+      download_package_contents(package_file, local_name, package_url, version, destination_package_path)
+      # case
+      # when package_url =~ /\.git/                               # git reference
+      #   download_git_package(package_url, version, destination_package_path)
+      # when package_url.start_with?("file://")                   # local path
+      #   path = package_url.sub("file://", "")
+      #   path = path.to_pathname
+      #   package_path_to_download = if path.relative?            # relative path
+      #     package_file.containing_directory.join(path)
+      #   else                                                    # absolute path
+      #     path.realpath
+      #   end
+
+      #   raise Error, "Package not found: #{package_path_to_download}" unless package_path_to_download.exist?
+      #   FileUtils.cp_r(package_path_to_download, destination_package_path)
+      # when package_url.to_pathname.exist? || package_file.containing_directory.join(package_url).exist?     # local path
+      #   path = package_url.to_pathname
+      #   package_path_to_download = if path.relative?            # relative path
+      #     package_file.containing_directory.join(path)
+      #   else                                                    # absolute path
+      #     path.realpath
+      #   end
+
+      #   raise Error, "Package not found: #{package_path_to_download}" unless File.exist?(package_path_to_download)
+      #   FileUtils.cp_r(package_path_to_download, destination_package_path)
+      # else                                                      # git reference
+      #   download_git_package(package_url, version, destination_package_path)
+      # end
 
-        raise Error, "Package not found: #{package_path_to_download}" unless package_path_to_download.exist?
-        FileUtils.cp_r(package_path_to_download, destination_package_path)
-      when package_url.to_pathname.exist? || package_file.containing_directory.join(package_url).exist?     # local path
-        path = package_url.to_pathname
-        package_path_to_download = if path.relative?            # relative path
-          package_file.containing_directory.join(path)
-        else                                                    # absolute path
-          path.realpath
-        end
+      destination_package_path
+    end
 
-        raise Error, "Package not found: #{package_path_to_download}" unless File.exist?(package_path_to_download)
-        FileUtils.cp_r(package_path_to_download, destination_package_path)
-      else                                                      # git reference
-        download_git_package(package_url, version, destination_package_path)
+    def download_package_contents(package_file, 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
+      if package_path.absolute? && package_path.exist?                                   # absolute path reference
+        return case
+        when package_path.directory?
+          package_path_to_download = package_path.realpath
+          FileUtils.cp_r(package_path_to_download, destination_package_path)
+        when package_path.file?
+          raise Error, "Package reference must be a directory, not a file:: #{local_name}: #{package_path}"
+        else
+          raise Error, "Unknown package reference for absolute path: #{local_name}: #{package_path}"
+        end
+      end
+      if package_path.relative?                                                          # relative path reference
+        rebased_path = package_file.containing_directory.join(package_path)
+        if rebased_path.exist?
+          return case
+          when rebased_path.directory?
+            package_path_to_download = rebased_path.realpath
+            FileUtils.cp_r(package_path_to_download, destination_package_path)
+          when rebased_path.file?
+            raise Error, "Package reference must be a directory, not a file:: #{local_name}: #{package_path}"
+          else
+            raise Error, "Unknown package reference for relative path: #{local_name}: #{package_path}"
+          end
+        end
       end
 
-      destination_package_path
+      if package_uri = Git.repo?(package_url)                                                          # git repo
+        download_git_package(package_uri, version, destination_package_path)
+      end
     end
 
     def download_git_package(package_url, version = nil, destination_package_path = nil)

data/lib/opswalrus/host.rb

@@ -2,6 +2,7 @@ require "set"
 require "sshkit"
 
 require_relative "interaction_handlers"
+require_relative "invocation"
 
 module OpsWalrus
 
@@ -22,10 +23,7 @@ module OpsWalrus
         # 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
 
-        remote_run_command_args = "--script"
-
-        remote_run_command_args << " "
-        remote_run_command_args << @method_chain.join(" ")
+        remote_run_command_args = @method_chain.join(" ")
 
         unless args.empty?
           remote_run_command_args << " "
@@ -44,13 +42,59 @@ module OpsWalrus
           end.join(" ")
         end
 
-        @host_proxy.run_ops(:run, remote_run_command_args)
+        @host_proxy.run_ops(:run, "--script", remote_run_command_args)
       end
     end
   end
 
   # the subclasses of HostProxy will define methods that handle method dispatch via HostProxyOpsFileInvocationBuilder objects
   class HostProxy
+    # def self.define_host_proxy_class(ops_file)
+    #   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 self.define_host_proxy_class(ops_file)
       klass = Class.new(HostProxy)
 
@@ -59,21 +103,40 @@ module OpsWalrus
       # 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
+            # puts "resolving local symbol table entry: #{symbol_name}"
+            namespace_or_ops_file = @runtime_env.resolve_import_reference(ops_file, import_reference)
+            # puts "namespace_or_ops_file=#{namespace_or_ops_file.to_s}"
+
+            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
-              HostProxyOpsFileInvocationBuilder.new(self, true)
+              RemoteImportInvocationContext.new(@runtime_env, self, namespace_or_ops_file, 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)
+              RemoteImportInvocationContext.new(@runtime_env, self, namespace_or_ops_file, false)
             end
 
-            invocation_builder.send(symbol_name, *args, **kwargs, &block)
+            invocation_context._invoke(*args, **kwargs)
+
+
+
+            # 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
@@ -87,8 +150,11 @@ module OpsWalrus
         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)
+            # invocation_builder = HostProxyOpsFileInvocationBuilder.new(self, false)
+            # invocation_builder.invoke(symbol_name, *args, **kwargs, &block)
+
+            invocation_context = RemoteImportInvocationContext.new(@runtime_env, self, namespace_or_ops_file, false)
+            invocation_context._invoke(*args, **kwargs)
           end
           methods_defined << symbol_name
         end
@@ -100,8 +166,9 @@ module OpsWalrus
 
     attr_accessor :_host
 
-    def initialize(host)
+    def initialize(runtime_env, host)
       @_host = host
+      @runtime_env = runtime_env
     end
 
     # the subclasses of this class will define methods that handle method dispatch via HostProxyOpsFileInvocationBuilder objects
@@ -164,13 +231,15 @@ module OpsWalrus
     # end
 
     # runs the specified ops command with the specified command arguments
-    def run_ops(command, command_arguments, in_bundle_root_dir: true, verbose: false)
+    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"
       cmd = "/home/linuxbrew/.linuxbrew/bin/gem exec -g opswalrus ops"
       cmd << " -v" if verbose
-      cmd << " #{command.to_s}"
+      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?
 

data/lib/opswalrus/invocation.rb

@@ -11,8 +11,137 @@
 # require_relative 'sshkit_ext'
 # require_relative 'walrus_lang'
 
-# module OpsWalrus
-
+module OpsWalrus
+
+  class ImportInvocationContext
+    def _invoke(*args, **kwargs)
+      raise "Not implemented in base class"
+    end
+
+    def _invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs, &block)
+      raise "Not implemented in base class"
+    end
+
+    def method_missing(name, *args, **kwargs, &block)
+      raise "Not implemented in base class"
+    end
+  end
+
+  class RemoteImportInvocationContext < ImportInvocationContext
+    def initialize(runtime_env, host_proxy, namespace_or_ops_file, is_invocation_a_call_to_package_in_bundle_dir = false)
+      @runtime_env = runtime_env
+      @host_proxy = host_proxy
+      @initial_namespace_or_ops_file = @namespace_or_ops_file = namespace_or_ops_file
+      @is_invocation_a_call_to_package_in_bundle_dir = is_invocation_a_call_to_package_in_bundle_dir
+
+      initial_method_name = @namespace_or_ops_file.dirname.basename
+      @method_chain = [initial_method_name]
+    end
+
+    def _invoke(*args, **kwargs)
+      case @namespace_or_ops_file
+      when Namespace
+        _invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs)
+      when OpsFile
+        _invoke_remote(*args, **kwargs)
+      end
+    end
+
+    def _invoke_remote(*args, **kwargs)
+      # 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
+
+      remote_run_command_args = @method_chain.join(" ")
+
+      unless args.empty?
+        remote_run_command_args << " "
+        remote_run_command_args << args.join(" ")
+      end
+
+      unless kwargs.empty?
+        remote_run_command_args << " "
+        remote_run_command_args << kwargs.map do |k, v|
+          case v
+          when Array
+            v.map {|v_element| "#{k}:#{v_element}" }
+          else
+            "#{k}:#{v}"
+          end
+        end.join(" ")
+      end
+
+      @host_proxy.run_ops(:run, "--script", remote_run_command_args)
+    end
+
+    # if this namespace contains an OpsFile of the same name as the namespace, e.g. pkg/install/install.ops, then this
+    # method invokes the OpsFile of that same name and returns the result;
+    # otherwise we return this namespace object
+    def _invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs, &block)
+      method_name = @namespace_or_ops_file.dirname.basename
+      resolved_symbol = @namespace_or_ops_file.resolve_symbol(method_name)
+      if resolved_symbol.is_a? OpsFile
+        _resolve_method_and_invoke(method_name)
+      else
+        self
+      end
+    end
+
+    def _resolve_method_and_invoke(name, *args, **kwargs)
+      @method_chain << name.to_s
+
+      @namespace_or_ops_file = @namespace_or_ops_file.resolve_symbol(name)
+      _invoke(*args, **kwargs)
+    end
+
+    def method_missing(name, *args, **kwargs, &block)
+      _resolve_method_and_invoke(name, *args, **kwargs)
+    end
+  end
+
+  class LocalImportInvocationContext < ImportInvocationContext
+    def initialize(runtime_env, namespace_or_ops_file)
+      @runtime_env = runtime_env
+      @initial_namespace_or_ops_file = @namespace_or_ops_file = namespace_or_ops_file
+    end
+
+    def _invoke(*args, **kwargs)
+      case @namespace_or_ops_file
+      when Namespace
+        _invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs)
+      when OpsFile
+        _invoke_local(*args, **kwargs)
+      end
+    end
+
+    def _invoke_local(*args, **kwargs)
+      params_hash = @namespace_or_ops_file.build_params_hash(*args, **kwargs)
+      @namespace_or_ops_file.invoke(@runtime_env, params_hash)
+    end
+
+    # if this namespace contains an OpsFile of the same name as the namespace, e.g. pkg/install/install.ops, then this
+    # method invokes the OpsFile of that same name and returns the result;
+    # otherwise we return this namespace object
+    def _invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs, &block)
+      method_name = @namespace_or_ops_file.dirname.basename
+      resolved_symbol = @namespace_or_ops_file.resolve_symbol(method_name)
+      if resolved_symbol.is_a? OpsFile
+        params_hash = resolved_symbol.build_params_hash(*args, **kwargs)
+        resolved_symbol.invoke(runtime_env, params_hash)
+      else
+        self
+      end
+    end
+
+    def _resolve_method_and_invoke(name, *args, **kwargs)
+      @namespace_or_ops_file = @namespace_or_ops_file.resolve_symbol(name)
+      _invoke(*args, **kwargs)
+    end
+
+    def method_missing(name, *args, **kwargs, &block)
+      _resolve_method_and_invoke(name, *args, **kwargs)
+    end
+  end
 #   class ArrayOrHashNavigationProxy
 #     def initialize(array_or_hash)
 #       @obj = array_or_hash
@@ -443,4 +572,4 @@
 #     #   end
 #     # end
 #   end
-# end
+end

data/lib/opswalrus/ops_file_script.rb

@@ -1,4 +1,5 @@
 require 'set'
+require_relative 'invocation'
 require_relative 'ops_file_script_dsl'
 
 module OpsWalrus
@@ -8,8 +9,6 @@ module OpsWalrus
     def self.define_for(ops_file, ruby_script)
       klass = Class.new(OpsFileScript)
 
-      # puts "OpsFileScript.define_for(#{ops_file.to_s}, #{ruby_script.to_s})"
-
       methods_defined = Set.new
 
       # define methods for the OpsFile's local_symbol_table: local imports and private lib directory
@@ -21,14 +20,16 @@ module OpsWalrus
             namespace_or_ops_file = @runtime_env.resolve_import_reference(ops_file, import_reference)
             # puts "namespace_or_ops_file=#{namespace_or_ops_file.to_s}"
 
-            case namespace_or_ops_file
-            when Namespace
-              namespace_or_ops_file
-              namespace_or_ops_file._invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs)
-            when OpsFile
-              params_hash = namespace_or_ops_file.build_params_hash(*args, **kwargs)
-              namespace_or_ops_file.invoke(@runtime_env, params_hash)
-            end
+            invocation_context = LocalImportInvocationContext.new(@runtime_env, namespace_or_ops_file)
+            invocation_context._invoke(*args, **kwargs)
+
+            # case namespace_or_ops_file
+            # when Namespace
+            #   namespace_or_ops_file._invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs)
+            # when OpsFile
+            #   params_hash = namespace_or_ops_file.build_params_hash(*args, **kwargs)
+            #   namespace_or_ops_file.invoke(@runtime_env, params_hash)
+            # end
           end
           methods_defined << symbol_name
         end
@@ -48,14 +49,17 @@ module OpsWalrus
             namespace_or_ops_file = @runtime_env.resolve_sibling_symbol(ops_file, symbol_name)
             # puts "namespace_or_ops_file=#{namespace_or_ops_file.to_s}"
 
-            case namespace_or_ops_file
-            when Namespace
-              namespace_or_ops_file
-              namespace_or_ops_file._invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs)
-            when OpsFile
-              params_hash = namespace_or_ops_file.build_params_hash(*args, **kwargs)
-              namespace_or_ops_file.invoke(@runtime_env, params_hash)
-            end
+            invocation_context = LocalImportInvocationContext.new(@runtime_env, namespace_or_ops_file)
+            invocation_context._invoke(*args, **kwargs)
+
+
+            # case namespace_or_ops_file
+            # when Namespace
+            #   namespace_or_ops_file._invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs)
+            # when OpsFile
+            #   params_hash = namespace_or_ops_file.build_params_hash(*args, **kwargs)
+            #   namespace_or_ops_file.invoke(@runtime_env, params_hash)
+            # end
           end
           methods_defined << symbol_name
         end

data/lib/opswalrus/ops_file_script_dsl.rb

@@ -114,10 +114,11 @@ module OpsWalrus
 
   module OpsFileScriptDSL
     def ssh(*args, **kwargs, &block)
-      hosts = inventory(*args, **kwargs).map {|host| host_proxy_class.new(host) }
+      runtime_env = @runtime_env
+
+      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
-      runtime_env = @runtime_env
       local_host = self
       # bootstrap_shell_script = BootstrapLinuxHostShellScript
       # on sshkit_hosts do |sshkit_host|
@@ -157,11 +158,11 @@ module OpsWalrus
           # puts retval.inspect
 
           # cleanup
-          if tmp_bundle_root_dir =~ /tmp/   # sanity check the temp path before we blow away something we don't intend
-            host.execute(:rm, "-rf", "tmpopsbootstrap.sh", "tmpops.zip", tmp_bundle_root_dir)
-          else
-            host.execute(:rm, "-rf", "tmpopsbootstrap.sh", "tmpops.zip")
-          end
+          # if tmp_bundle_root_dir =~ /tmp/   # sanity check the temp path before we blow away something we don't intend
+          #   host.execute(:rm, "-rf", "tmpopsbootstrap.sh", "tmpops.zip", tmp_bundle_root_dir)
+          # else
+          #   host.execute(:rm, "-rf", "tmpopsbootstrap.sh", "tmpops.zip")
+          # end
 
           retval
         rescue SSHKit::Command::Failed => e

data/lib/opswalrus/runtime_environment.rb

@@ -82,32 +82,31 @@ module OpsWalrus
       @symbol_table[symbol_name.to_s]
     end
 
-    # if this namespace contains an OpsFile of the same name as the namespace, e.g. pkg/install/install.ops, then this
-    # method invokes the OpsFile of that same name and returns the result;
-    # otherwise we return this namespace object
-    def _invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs, &block)
-      resolved_symbol = resolve_symbol(@dirname.basename)
-      if resolved_symbol.is_a? OpsFile
-        params_hash = resolved_symbol.build_params_hash(*args, **kwargs)
-        resolved_symbol.invoke(runtime_env, params_hash)
-      else
-        self
-      end
-    end
-
-    def method_missing(name, *args, **kwargs, &block)
-      # puts "method_missing: #{name}"
-      # puts caller
-      resolved_symbol = resolve_symbol(name)
-      case resolved_symbol
-      when Namespace
-        resolved_symbol
-        resolved_symbol._invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs)
-      when OpsFile
-        params_hash = resolved_symbol.build_params_hash(*args, **kwargs)
-        resolved_symbol.invoke(runtime_env, params_hash)
-      end
-    end
+    # # if this namespace contains an OpsFile of the same name as the namespace, e.g. pkg/install/install.ops, then this
+    # # method invokes the OpsFile of that same name and returns the result;
+    # # otherwise we return this namespace object
+    # def _invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs, &block)
+    #   resolved_symbol = resolve_symbol(@dirname.basename)
+    #   if resolved_symbol.is_a? OpsFile
+    #     params_hash = resolved_symbol.build_params_hash(*args, **kwargs)
+    #     resolved_symbol.invoke(runtime_env, params_hash)
+    #   else
+    #     self
+    #   end
+    # end
+
+    # def method_missing(name, *args, **kwargs, &block)
+    #   # puts "method_missing: #{name}"
+    #   # puts caller
+    #   resolved_symbol = resolve_symbol(name)
+    #   case resolved_symbol
+    #   when Namespace
+    #     resolved_symbol._invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs)
+    #   when OpsFile
+    #     params_hash = resolved_symbol.build_params_hash(*args, **kwargs)
+    #     resolved_symbol.invoke(runtime_env, params_hash)
+    #   end
+    # end
   end
 
   # the assumption is that we have a bundle directory with all the packages in it
@@ -316,7 +315,7 @@ module OpsWalrus
       ops_file.invoke(self, params_hash)
     end
 
-    # returns a Namespace or OpsFile
+    # returns a Namespace | OpsFile
     def resolve_sibling_symbol(origin_ops_file, symbol_name)
       @app_load_path.resolve_symbol(origin_ops_file, symbol_name)
     end

data/lib/opswalrus/version.rb

@@ -1,3 +1,3 @@
 module OpsWalrus
-  VERSION = "1.0.11"
+  VERSION = "1.0.13"
 end

metadata

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