opswalrus 1.0.12 → 1.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9c838dbf7a64b90664fa94e0b6579508e0967d20a2fa8d8779616fa36cf9b8f
-  data.tar.gz: 9787c55859ab6ed5f5ceb50803c72df06f9d021e25dcbe7dc917db4f2f30b2ab
+  metadata.gz: 1199faea66fca54073c2446271ef2c31a8e78e6dd55e7e9de5173baae5da7ac4
+  data.tar.gz: 1bbe73114e2cf1449ad296245d4cf53a2c2f8c523a1652f0ce1776bf742e4438
 SHA512:
-  metadata.gz: 644d62c00d36280d5be184f8408c0fc8d5da05d02bae7207b6899d819c98c3f6456be34bb50db1ebfd4012419e6710e193d278c6065bdf2a5b5cc6025b291606
-  data.tar.gz: a0a2f5663a4bc748feba02bf4609de61347a8ef5519420ba578dfade18c5fdb877f9aada5332bc705c3714db3284b0e137844fa43a56718c3a99d23ceda8b613
+  metadata.gz: d4e9a452262cf8a3a82c967bfc5dc9e8b39f87f80b42fb9b641fa764811e2735a78b307cc0c2751c6c185c8223561c0d41b5913b7c62c78d76c020907c8f8286
+  data.tar.gz: 15f772925cb50837543ee0277ca3e4fbee42c0c64e3c0ad28c940617c008d51c4507f3950a3fb28a96086ea8d759368f7b06e04b2f4aaee406a6883cc61956cf

data/Gemfile.lock

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

data/lib/opswalrus/bundler.rb

@@ -173,9 +173,8 @@ module OpsWalrus
         end
       end
 
-      package_uri = package_url
-      if Git.repo?(package_uri)                                                          # git repo
-        download_git_package(package_url, version, destination_package_path)
+      if package_uri = Git.repo?(package_url)                                                          # git repo
+        download_git_package(package_uri, version, destination_package_path)
       end
     end
 

data/lib/opswalrus/host.rb

@@ -2,6 +2,7 @@ require "set"
 require "sshkit"
 
 require_relative "interaction_handlers"
+require_relative "invocation"
 
 module OpsWalrus
 
@@ -48,6 +49,52 @@ module OpsWalrus
 
   # 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)
 
@@ -56,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
@@ -84,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
@@ -97,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

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|

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.12"
+  VERSION = "1.0.13"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opswalrus
 version: !ruby/object:Gem::Version
-  version: 1.0.12
+  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