opswalrus 1.0.12 → 1.0.14

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,27 +9,20 @@ 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
       ops_file.local_symbol_table.each do |symbol_name, import_reference|
         unless methods_defined.include? symbol_name
-          # puts "defining method for local symbol table entry: #{symbol_name}"
+          App.instance.debug "defining method for local symbol table entry: #{symbol_name}"
           klass.define_method(symbol_name) do |*args, **kwargs, &block|
-            # puts "resolving local symbol table entry: #{symbol_name}"
+            App.instance.debug "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}"
-
-            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
+            App.instance.debug "namespace_or_ops_file=#{namespace_or_ops_file.to_s}"
+
+            invocation_context = LocalImportInvocationContext.new(@runtime_env, namespace_or_ops_file)
+            invocation_context._invoke(*args, **kwargs)
+
           end
           methods_defined << symbol_name
         end
@@ -39,23 +33,18 @@ module OpsWalrus
       sibling_symbol_table_names |= ops_file.dirname.glob("*.ops").map {|ops_file_path| ops_file_path.basename(".ops").to_s }   # OpsFiles
       sibling_symbol_table_names |= ops_file.dirname.glob("*").select(&:directory?).map {|dir_path| dir_path.basename.to_s }    # Namespaces
       # puts "sibling_symbol_table_names=#{sibling_symbol_table_names}"
-      # puts "methods_defined=#{methods_defined}"
+      App.instance.debug "methods_defined=#{methods_defined}"
       sibling_symbol_table_names.each do |symbol_name|
         unless methods_defined.include? symbol_name
-          # puts "defining method for implicit imports: #{symbol_name}"
+          App.instance.debug "defining method for implicit imports: #{symbol_name}"
           klass.define_method(symbol_name) do |*args, **kwargs, &block|
-            # puts "resolving implicit import: #{symbol_name}"
+            App.instance.debug "resolving implicit import: #{symbol_name}"
             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
+            App.instance.debug "namespace_or_ops_file=#{namespace_or_ops_file.to_s}"
+
+            invocation_context = LocalImportInvocationContext.new(@runtime_env, namespace_or_ops_file)
+            invocation_context._invoke(*args, **kwargs)
+
           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/package_file.rb

@@ -37,6 +37,17 @@ module OpsWalrus
       local_name
     end
 
+    def to_s
+      "PackageReference(local_name=#{@local_name}, package_uri=#{@package_uri}, version=#{@version})"
+    end
+
+    def summary
+      if version
+        "#{package_uri}:#{version}"
+      else
+        package_uri
+      end
+    end
   end
 
   # these are dynamic package references defined at runtime when an OpsFile's imports are being evaluated.

data/lib/opswalrus/runtime_environment.rb

@@ -23,6 +23,12 @@ module OpsWalrus
       super(local_name)
       @package_reference = package_reference
     end
+    def to_s
+      "PackageDependencyReference(local_name=#{@local_name}, package_reference=#{@package_reference})"
+    end
+    def summary
+      "#{local_name}: #{package_reference.summary}"
+    end
   end
 
   class DirectoryReference < ImportReference
@@ -31,6 +37,12 @@ module OpsWalrus
       super(local_name)
       @dirname = dirname
     end
+    def to_s
+      "DirectoryReference(local_name=#{@local_name}, dirname=#{@dirname})"
+    end
+    def summary
+      "#{local_name}: #{dirname}"
+    end
   end
 
   class DynamicPackageImportReference < ImportReference
@@ -39,6 +51,12 @@ module OpsWalrus
       super(local_name)
       @package_reference = package_reference
     end
+    def to_s
+      "DynamicPackageImportReference(local_name=#{@local_name}, package_reference=#{@package_reference})"
+    end
+    def summary
+      "#{local_name}: #{package_reference.summary}"
+    end
   end
 
   class OpsFileReference < ImportReference
@@ -47,6 +65,12 @@ module OpsWalrus
       super(local_name)
       @ops_file_path = ops_file_path
     end
+    def to_s
+      "DirectoryReference(local_name=#{@local_name}, ops_file_path=#{@ops_file_path})"
+    end
+    def summary
+      "#{local_name}: #{ops_file_path}"
+    end
   end
 
   # Namespace is really just a Map of symbol_name -> (Namespace | OpsFile) pairs
@@ -82,32 +106,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
@@ -179,6 +202,10 @@ module OpsWalrus
       path_map
     end
 
+    def includes_path?(path)
+      !!@path_map[path]
+    end
+
     def dynamically_add_new_package_dir(new_package_dir)
       # patch the symbol resolution (namespace) tree
       dir_basename = new_package_dir.basename
@@ -199,19 +226,22 @@ module OpsWalrus
 
     # returns a Namespace or OpsFile
     def resolve_symbol(origin_ops_file, symbol_name)
-      lookup_namespace(origin_ops_file)&.resolve_symbol(symbol_name)
+      resolved_namespace_or_ops_file = lookup_namespace(origin_ops_file)&.resolve_symbol(symbol_name)
+      App.instance.debug("LoadPath#resolve_symbol(#{origin_ops_file}, #{symbol_name}) -> #{resolved_namespace_or_ops_file}")
+      resolved_namespace_or_ops_file
     end
 
     # returns a Namespace | OpsFile
     def resolve_import_reference(origin_ops_file, import_reference)
-      case import_reference
+      resolved_namespace_or_ops_file = case import_reference
       when PackageDependencyReference
         # puts "root namespace: #{@root_namespace.symbol_table}"
-        @root_namespace.resolve_symbol(import_reference.package_reference.import_resolution_dirname)   # returns the Namespace associated with the bundled package dirname (i.e. the local name)
+        @root_namespace.resolve_symbol(import_reference.package_reference.import_resolution_dirname)   # returns the Namespace associated with the bundled package import_resolution_dirname (i.e. the local name)
       when DynamicPackageImportReference
         dynamic_package_reference = import_reference.package_reference
         @dynamic_package_additions_memo[dynamic_package_reference] ||= begin
           # puts "Downloading dynamic package: #{dynamic_package_reference.inspect}"
+          App.instance.debug("Downloading dynamic package: #{dynamic_package_reference}")
           dynamically_added_package_dir = @runtime_env.app.bundler.download_git_package(dynamic_package_reference.package_uri, dynamic_package_reference.version)
           dynamically_add_new_package_dir(dynamically_added_package_dir)
           dynamically_added_package_dir
@@ -222,6 +252,8 @@ module OpsWalrus
       when OpsFileReference
         @path_map[import_reference.ops_file_path]
       end
+      App.instance.debug("LoadPath#resolve_import_reference(#{origin_ops_file}, #{import_reference}) -> #{resolved_namespace_or_ops_file}")
+      resolved_namespace_or_ops_file
     end
   end
 
@@ -316,23 +348,41 @@ module OpsWalrus
       ops_file.invoke(self, params_hash)
     end
 
-    # returns a Namespace or OpsFile
+    def find_load_path_that_includes_path(path)
+      load_path = [@bundle_load_path, @app_load_path].find {|load_path| load_path.includes_path?(path) }
+      raise SymbolResolutionError, "No load path includes the path: #{path}" unless load_path
+      load_path
+    end
+
+    # returns a Namespace | OpsFile
     def resolve_sibling_symbol(origin_ops_file, symbol_name)
-      @app_load_path.resolve_symbol(origin_ops_file, symbol_name)
+      # if the origin_ops_file's file path is contained within a Bundler::BUNDLE_DIR directory, then we want to consult the @bundle_load_path
+      # otherwise, we want to consult the @app_load_path
+      load_path = find_load_path_that_includes_path(origin_ops_file.ops_file_path)
+      namespace_or_ops_file = load_path.resolve_symbol(origin_ops_file, symbol_name)
+      raise SymbolResolutionError, "Symbol '#{symbol_name}' not in load path for #{origin_ops_file.ops_file_path}" unless namespace_or_ops_file
+      namespace_or_ops_file
     end
 
     # returns a Namespace | OpsFile
     def resolve_import_reference(origin_ops_file, import_reference)
-      case import_reference
+      load_path = case import_reference
 
-      # we know we're dealing with a package dependency reference, so we want to do the lookup in the bundle load path, where package dependencies live
+      # We know we're dealing with a package dependency reference, so we want to do the lookup in the bundle load path, where package dependencies live.
+      # Package references are guaranteed to live in the bundle dir
       when PackageDependencyReference, DynamicPackageImportReference
-        @bundle_load_path.resolve_import_reference(origin_ops_file, import_reference)
-
-      # we know we're dealing with a directory reference or OpsFile reference outside of the bundle dir, so we want to do the lookup in the app load path
-      when DirectoryReference, OpsFileReference
-        @app_load_path.resolve_import_reference(origin_ops_file, import_reference)
+        @bundle_load_path
+      when DirectoryReference
+        find_load_path_that_includes_path(import_reference.dirname)
+      when OpsFileReference
+        find_load_path_that_includes_path(import_reference.ops_file_path)
       end
+
+      namespace_or_ops_file = load_path.resolve_import_reference(origin_ops_file, import_reference)
+
+      raise SymbolResolutionError, "Import reference '#{import_reference.summary}' not in load path for #{origin_ops_file.ops_file_path}" unless namespace_or_ops_file
+
+      namespace_or_ops_file
     end
 
   end

data/lib/opswalrus/version.rb

@@ -1,3 +1,3 @@
 module OpsWalrus
-  VERSION = "1.0.12"
+  VERSION = "1.0.14"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opswalrus
 version: !ruby/object:Gem::Version
-  version: 1.0.12
+  version: 1.0.14
 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
@@ -132,6 +132,7 @@ files:
 - lib/opswalrus/bootstrap.sh
 - lib/opswalrus/bundler.rb
 - lib/opswalrus/cli.rb
+- lib/opswalrus/errors.rb
 - lib/opswalrus/git.rb
 - lib/opswalrus/host.rb
 - lib/opswalrus/hosts_file.rb