opswalrus 1.0.15 → 1.0.17

data/lib/opswalrus/interaction_handlers.rb

@@ -5,6 +5,7 @@ module OpsWalrus
   class ScopedMappingInteractionHandler
     attr_accessor :input_mappings   # Hash[ String | Regex => String ]
 
+    # log_level is one of: :fatal, :error, :warn, :info, :debug, :trace
     def initialize(mapping, log_level = nil)
       @log_level = log_level
       @input_mappings = mapping
@@ -21,11 +22,10 @@ module OpsWalrus
     # end
 
     # sudo_password : String
-    def mapping_for_sudo_password(sudo_password)
+    def self.mapping_for_sudo_password(sudo_password)
       {
         /\[sudo\] password for .*?:\s*/ => "#{sudo_password}\n",
         App::LOCAL_SUDO_PASSWORD_PROMPT => "#{sudo_password}\n",
-        # /\s+/ => nil,     # unnecessary
       }
     end
 
@@ -39,7 +39,7 @@ module OpsWalrus
       raise ArgumentError.new("mapping must be a Hash") unless mapping.is_a?(Hash)
 
       if sudo_password
-        mapping.merge!(mapping_for_sudo_password(sudo_password))
+        mapping.merge!(ScopedMappingInteractionHandler.mapping_for_sudo_password(sudo_password))
       end
 
       if mapping.empty?
@@ -57,17 +57,16 @@ module OpsWalrus
     end
 
     def on_data(_command, stream_name, data, channel)
-      log("Looking up response for #{stream_name} message #{data.inspect}")
-
       response_data = begin
         first_matching_key_value_pair = @input_mappings.find {|k, _v| k === data }
         first_matching_key_value_pair&.last
       end
 
       if response_data.nil?
-        log("Unable to find interaction handler mapping for #{stream_name}: #{data.inspect} so no response was sent")
+        trace(Style.red("No interaction handler mapping for #{stream_name}: #{data} so no response was sent"))
       else
-        log("Sending #{response_data.inspect}")
+        debug(Style.cyan("Handling #{stream_name} message #{data}"))
+        debug(Style.cyan("Sending response #{response_data}"))
         if channel.respond_to?(:send_data)  # Net SSH Channel
           channel.send_data(response_data)
         elsif channel.respond_to?(:write)   # Local IO
@@ -80,16 +79,21 @@ module OpsWalrus
 
     private
 
-    def log(message)
-      # puts message
-      SSHKit.config.output.send(@log_level, message) unless @log_level.nil?
+    def trace(message)
+      App.instance.trace(message)
+    end
+
+    def debug(message)
+      App.instance.debug(message)
+      if [:fatal, :error, :warn, :info, :debug, :trace].include? @log_level
+        SSHKit.config.output.send(@log_level, message)
+      end
     end
 
   end
 
   class PasswdInteractionHandler
     def on_data(command, stream_name, data, channel)
-      # puts data
       case data
       when '(current) UNIX password: '
         channel.send_data("old_pw\n")
@@ -118,8 +122,6 @@ module OpsWalrus
 
   class SudoPromptInteractionHandler
     def on_data(command, stream_name, data, channel)
-      # puts "0" * 80
-      # puts data.inspect
       case data
       when /\[sudo\] password for/
         if channel.respond_to?(:send_data)  # Net::SSH channel
@@ -128,12 +130,11 @@ module OpsWalrus
           channel.write("conquer\n")
         end
       when /\s+/
-        puts 'space, do nothing'
+        nil
       else
         raise "Unexpected prompt: #{data} on stream #{stream_name} and channel #{channel.inspect}"
-    end
+      end
     end
   end
 
-
 end

data/lib/opswalrus/invocation.rb

@@ -13,10 +13,18 @@ module OpsWalrus
     def method_missing(name, *args, **kwargs, &block)
       raise "Not implemented in base class"
     end
+
+    def _bang_method?(name)
+      name.to_s.end_with?("!")
+    end
+
+    def _non_bang_method(name)
+      name.to_s.sub(/!$/, '')
+    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)
+    def initialize(runtime_env, host_proxy, namespace_or_ops_file, is_invocation_a_call_to_package_in_bundle_dir = false, prompt_for_sudo_password: nil)
       @runtime_env = runtime_env
       @host_proxy = host_proxy
       @initial_namespace_or_ops_file = @namespace_or_ops_file = namespace_or_ops_file
@@ -24,12 +32,46 @@ module OpsWalrus
 
       initial_method_name = @namespace_or_ops_file.dirname.basename
       @method_chain = [initial_method_name]
+      @prompt_for_sudo_password = prompt_for_sudo_password
+    end
+
+    def method_missing(name, *args, **kwargs, &block)
+      _resolve_method_and_invoke(name, *args, **kwargs)
+    end
+
+    def _resolve_method_and_invoke(name, *args, **kwargs)
+      if _bang_method?(name)      # foo! is an attempt to invoke the module's default entrypoint
+        method_name = _non_bang_method(name)
+
+        @method_chain << method_name
+
+        @namespace_or_ops_file = @namespace_or_ops_file.resolve_symbol(method_name)
+        _invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs)
+      else
+        @method_chain << name.to_s
+
+        @namespace_or_ops_file = @namespace_or_ops_file.resolve_symbol(name)
+        _invoke(*args, **kwargs)
+      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)
+      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 _invoke(*args, **kwargs)
       case @namespace_or_ops_file
       when Namespace
-        _invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs)
+        self
       when OpsFile
         _invoke_remote(*args, **kwargs)
       end
@@ -59,32 +101,13 @@ module OpsWalrus
         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)
+      # @host_proxy.run_ops(:run, "--script", remote_run_command_args)
+      if @prompt_for_sudo_password
+        @host_proxy.run_ops(:run, "--pass", remote_run_command_args)
       else
-        self
+        @host_proxy.run_ops(:run, remote_run_command_args)
       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
@@ -93,24 +116,25 @@ module OpsWalrus
       @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
+    def method_missing(name, *args, **kwargs, &block)
+      _resolve_method_and_invoke(name, *args, **kwargs)
     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)
+    def _resolve_method_and_invoke(name, *args, **kwargs)
+      if _bang_method?(name)      # foo! is an attempt to invoke the module's default entrypoint
+        method_name = _non_bang_method(name)
+        @namespace_or_ops_file = @namespace_or_ops_file.resolve_symbol(method_name)
+        _invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs)
+      else
+        @namespace_or_ops_file = @namespace_or_ops_file.resolve_symbol(name)
+        _invoke(*args, **kwargs)
+      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)
+    def _invoke_if_namespace_has_ops_file_of_same_name(*args, **kwargs)
       method_name = @namespace_or_ops_file.dirname.basename
       resolved_symbol = @namespace_or_ops_file.resolve_symbol(method_name)
       if resolved_symbol.is_a? OpsFile
@@ -121,14 +145,20 @@ module OpsWalrus
       end
     end
 
-    def _resolve_method_and_invoke(name, *args, **kwargs)
-      @namespace_or_ops_file = @namespace_or_ops_file.resolve_symbol(name)
-      _invoke(*args, **kwargs)
+    def _invoke(*args, **kwargs)
+      case @namespace_or_ops_file
+      when Namespace
+        self
+      when OpsFile
+        _invoke_local(*args, **kwargs)
+      end
     end
 
-    def method_missing(name, *args, **kwargs, &block)
-      _resolve_method_and_invoke(name, *args, **kwargs)
+    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
+
   end
 
 end

data/lib/opswalrus/local_non_blocking_backend.rb

@@ -112,7 +112,6 @@ module SSHKit
         buffer || ""
       end
 
-
       def handle_data_for_stderr(output, cmd, buffer, stdin, is_blocked)
         # we're blocked on reading, so let's process the buffer
         lines, buffer = split_buffer(buffer)

data/lib/opswalrus/operation_runner.rb

@@ -28,24 +28,39 @@ module OpsWalrus
       @app.sudo_password
     end
 
-    # runtime_kv_args is an Array(String) of the form: ["arg1:val1", "arg2:val2", ...]
-    # params_json_hash is a Hash representation of a JSON string
-    def run(runtime_kv_args, params_json_hash: nil)
-      params_hash = runtime_kv_args.reduce(params_json_hash || {}) do |memo, kv_pair_string|
-        str_key, str_value = kv_pair_string.split(":", 2)
-        if pre_existing_value = memo[str_key]
-          array = pre_existing_value.is_a?(Array) ? pre_existing_value : [pre_existing_value]
-          array << str_value
-          memo[str_key] = array
+    # runtime_kv_args is an Array(String) of the form: ["arg1:val1", "arg1:val2", ...]
+    # irb(main):057:0> build_params_hash(["names:foo", "names:bar", "names:baz", "age:5", "profile:name:corge", "profile:language:en", "height:5ft8in"])
+    # => {"names"=>["foo", "bar", "baz"], "age"=>"5", "profile"=>{"name"=>"corge", "language"=>"en"}, "height"=>"5ft8in"}
+    def build_params_hash(runtime_kv_args, params_json_hash: nil)
+      runtime_kv_args.reduce(params_json_hash || {}) do |memo, kv_pair_string|
+        param_name, str_value = kv_pair_string.split(":", 2)
+        key, value = str_value.split(":", 2)
+        if pre_existing_value = memo[param_name]
+          memo[param_name] = if value    # we're dealing with a Hash parameter value
+                               pre_existing_value.merge(key => value)
+                             else        # we're dealing with an Array parameter value or a scalar parameter value
+                               array = pre_existing_value.is_a?(Array) ? pre_existing_value : [pre_existing_value]
+                               array << str_value
+                             end
         else
-          memo[str_key] = str_value
+          memo[param_name] = if value    # we're dealing with a Hash parameter value
+                               {key => value}
+                             else        # we're dealing with an Array parameter value or a scalar parameter value
+                               str_value
+                             end
         end
         memo
       end
+    end
+
+    # runtime_kv_args is an Array(String) of the form: ["arg1:val1", "arg1:val2", ...]
+    # params_json_hash is a Hash representation of a JSON string
+    def run(runtime_kv_args, params_json_hash: nil)
+      params_hash = build_params_hash(runtime_kv_args, params_json_hash: params_json_hash)
 
       if app.debug?
-        puts "Script:"
-        puts @entry_point_ops_file.script
+        App.instance.trace "Script:"
+        App.instance.trace @entry_point_ops_file.script
       end
 
       result = begin
@@ -61,14 +76,14 @@ module OpsWalrus
         App.instance.error "[!] Command failed: #{e.message}"
       rescue Error => e
         App.instance.error "Error: Ops script crashed."
-        App.instance.error e.message
-        App.instance.error e.backtrace.take(5).join("\n")
+        App.instance.error e
+        # App.instance.error e.backtrace.take(5).join("\n")
         Invocation::Error.new(e)
       rescue => e
         App.instance.error "Unhandled Error: Ops script crashed."
         App.instance.error e.class
-        App.instance.error e.message
-        App.instance.error e.backtrace.take(10).join("\n")
+        App.instance.error e
+        # App.instance.error e.backtrace.take(10).join("\n")
         Invocation::Error.new(e)
       end
 
@@ -76,7 +91,7 @@ module OpsWalrus
         App.instance.debug "Ops script error details:"
         App.instance.debug "Error: #{result.value}"
         App.instance.debug "Status code: #{result.exit_status}"
-        App.instance.debug @entry_point_ops_file.script
+        App.instance.debug @entry_point_ops_file.script.to_s
       end
 
       result

data/lib/opswalrus/ops_file.rb

@@ -173,8 +173,9 @@ module OpsWalrus
       raise Error, "Unknown import reference: #{local_name}: #{import_str.inspect}"
     end
 
-    def invoke(runtime_env, params_hash)
-      script._invoke(runtime_env, params_hash)
+    def invoke(runtime_env, hashlike_params)
+      # this invokes the dynamically generated _invoke method that is defined at runtime within OpsFileScript.define_for(...)
+      script._invoke(runtime_env, hashlike_params)
     end
 
     def build_params_hash(*args, **kwargs)

data/lib/opswalrus/ops_file_script.rb

@@ -1,9 +1,80 @@
+require 'forwardable'
 require 'set'
 require_relative 'invocation'
 require_relative 'ops_file_script_dsl'
 
 module OpsWalrus
 
+  class ArrayOrHashNavigationProxy
+    extend Forwardable
+
+    def initialize(array_or_hash)
+      @obj = array_or_hash
+    end
+
+    def_delegators :@obj, :to_s, :inspect, :hash, :===, :eql?, :kind_of?, :is_a?, :instance_of?, :respond_to?, :<=>
+
+    def [](index, *args, **kwargs, &block)
+      @obj.method(:[]).call(index, *args, **kwargs, &block)
+    end
+    def respond_to_missing?(method, *)
+      @obj.is_a?(Hash) && @obj.respond_to?(method)
+    end
+    def method_missing(name, *args, **kwargs, &block)
+      case @obj
+      when Array
+        @obj.method(name).call(*args, **kwargs, &block)
+      when Hash
+        if @obj.respond_to?(name)
+          @obj.method(name).call(*args, **kwargs, &block)
+        else
+          value = self[name.to_s]
+          case value
+          when Array, Hash
+            ArrayOrHashNavigationProxy.new(value)
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+
+  class InvocationParams
+    # @params : Hash
+
+    # params : Hash | ArrayOrHashNavigationProxy
+    def initialize(hashlike_params)
+      # this doesn't seem to make any difference
+      @params = hashlike_params.to_h
+      # @params = hashlike_params
+    end
+
+    def [](key)
+      key = key.to_s if key.is_a? Symbol
+      @params[key]
+    end
+
+    def dig(*keys)
+      # keys = keys.map {|key| key.is_a?(Integer) ? key : key.to_s }
+      @params.dig(*keys)
+    end
+
+    def method_missing(name, *args, **kwargs, &block)
+      if @params.respond_to?(name)
+        @params.method(name).call(*args, **kwargs, &block)
+      else
+        value = self[name]
+        case value
+        when Array, Hash
+          ArrayOrHashNavigationProxy.new(value)
+        else
+          value
+        end
+      end
+    end
+  end
+
   class OpsFileScript
 
     def self.define_for(ops_file, ruby_script)
@@ -14,11 +85,11 @@ module OpsWalrus
       # 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
-          App.instance.debug "defining method for local symbol table entry: #{symbol_name}"
+          App.instance.trace "defining method for local symbol table entry: #{symbol_name}"
           klass.define_method(symbol_name) do |*args, **kwargs, &block|
-            App.instance.debug "resolving local symbol table entry: #{symbol_name}"
+            App.instance.trace "resolving local symbol table entry: #{symbol_name}"
             namespace_or_ops_file = @runtime_env.resolve_import_reference(ops_file, import_reference)
-            App.instance.debug "namespace_or_ops_file=#{namespace_or_ops_file.to_s}"
+            App.instance.trace "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)
@@ -33,14 +104,14 @@ 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}"
-      App.instance.debug "methods_defined=#{methods_defined}"
+      App.instance.trace "methods_defined=#{methods_defined}"
       sibling_symbol_table_names.each do |symbol_name|
         unless methods_defined.include? symbol_name
-          App.instance.debug "defining method for implicit imports: #{symbol_name}"
+          App.instance.trace "defining method for implicit imports: #{symbol_name}"
           klass.define_method(symbol_name) do |*args, **kwargs, &block|
-            App.instance.debug "resolving implicit import: #{symbol_name}"
+            App.instance.trace "resolving implicit import: #{symbol_name}"
             namespace_or_ops_file = @runtime_env.resolve_sibling_symbol(ops_file, symbol_name)
-            App.instance.debug "namespace_or_ops_file=#{namespace_or_ops_file.to_s}"
+            App.instance.trace "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)
@@ -60,9 +131,9 @@ module OpsWalrus
       # - #verbose?
       # - all the dynamically defined methods in the subclass of Invocation
       invoke_method_definition = <<~INVOKE_METHOD
-        def _invoke(runtime_env, params_hash)
+        def _invoke(runtime_env, hashlike_params)
           @runtime_env = runtime_env
-          @params = InvocationParams.new(params_hash)
+          @params = InvocationParams.new(hashlike_params)
           #{ruby_script}
         end
       INVOKE_METHOD
@@ -101,7 +172,7 @@ module OpsWalrus
     end
 
     # The _invoke method is dynamically defined as part of OpsFileScript.define_for
-    def _invoke(runtime_env, params_hash)
+    def _invoke(runtime_env, hashlike_params)
       raise "Not implemented in base class."
     end
 

data/lib/opswalrus/ops_file_script_dsl.rb

@@ -12,67 +12,6 @@ require_relative 'walrus_lang'
 
 module OpsWalrus
 
-  class ArrayOrHashNavigationProxy
-    def initialize(array_or_hash)
-      @obj = array_or_hash
-    end
-    def [](index, *args, **kwargs, &block)
-      @obj.method(:[]).call(index, *args, **kwargs, &block)
-    end
-    def respond_to_missing?(method, *)
-      @obj.is_a?(Hash) && @obj.respond_to?(method)
-    end
-    def method_missing(name, *args, **kwargs, &block)
-      case @obj
-      when Array
-        @obj.method(name).call(*args, **kwargs, &block)
-      when Hash
-        if @obj.respond_to?(name)
-          @obj.method(name).call(*args, **kwargs, &block)
-        else
-          value = self[name.to_s]
-          case value
-          when Array, Hash
-            ArrayOrHashNavigationProxy.new(value)
-          else
-            value
-          end
-        end
-      end
-    end
-  end
-
-  class InvocationParams
-    # params : Hash
-    def initialize(params)
-      @params = params
-    end
-
-    def [](key)
-      key = key.to_s if key.is_a? Symbol
-      @params[key]
-    end
-
-    def dig(*keys)
-      # keys = keys.map {|key| key.is_a?(Integer) ? key : key.to_s }
-      @params.dig(*keys)
-    end
-
-    def method_missing(name, *args, **kwargs, &block)
-      if @params.respond_to?(name)
-        @params.method(name).call(*args, **kwargs, &block)
-      else
-        value = self[name]
-        case value
-        when Array, Hash
-          ArrayOrHashNavigationProxy.new(value)
-        else
-          value
-        end
-      end
-    end
-  end
-
   module Invocation
     class Result
       attr_accessor :value
@@ -157,7 +96,7 @@ module OpsWalrus
 
           # puts retval.inspect
 
-          # cleanup
+          # todo: 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
@@ -264,6 +203,7 @@ module OpsWalrus
       return ["", "", 0] if !desc_or_cmd && !cmd && !block    # we were told to do nothing; like hitting enter at the bash prompt; we can do nothing successfully
 
       description = desc_or_cmd if cmd || block
+      description = WalrusLang.render(description, block.binding) if description && block
       cmd = block.call if block
       cmd ||= desc_or_cmd
 
@@ -274,19 +214,23 @@ module OpsWalrus
       # puts "shell! self: #{self.inspect}"
 
       if App.instance.report_mode?
-        print "[#{@runtime_env.local_hostname}] "
+        puts Style.green("*" * 80)
+        print "[#{Style.blue(@runtime_env.local_hostname)}] "
         print "#{description}: " if description
-        puts cmd
+        puts Style.yellow(cmd)
       end
 
       return unless cmd && !cmd.strip.empty?
 
-      sshkit_cmd = @runtime_env.handle_input(input) do |interaction_handler|
-        # self is a Module instance that is serving as the evaluation context in an instance of a subclass of an Invocation; see Invocation#evaluate
-        backend.execute_cmd(cmd, interaction_handler: interaction_handler, verbosity: :info)
+      if App.instance.dry_run?
+        ["", "", 0]
+      else
+        sshkit_cmd = @runtime_env.handle_input(input) do |interaction_handler|
+          # self is a Module instance that is serving as the evaluation context in an instance of a subclass of an Invocation; see Invocation#evaluate
+          backend.execute_cmd(cmd, interaction_handler: interaction_handler, verbosity: :info)
+        end
+        [sshkit_cmd.full_stdout, sshkit_cmd.full_stderr, sshkit_cmd.exit_status]
       end
-
-      [sshkit_cmd.full_stdout, sshkit_cmd.full_stderr, sshkit_cmd.exit_status]
     end
 
     # def init_brew

data/lib/opswalrus/package_file.rb

@@ -15,15 +15,6 @@ module OpsWalrus
       @local_name, @package_uri, @version = local_name, package_uri, version
     end
 
-    def sanitized_package_uri
-      sanitize_path(@package_uri)
-    end
-
-    def sanitize_path(path)
-      # found this at https://apidock.com/rails/v5.2.3/ActiveStorage/Filename/sanitized
-      path.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "�").strip.tr("\u{202E}%$|:;/\t\r\n\\", "-")
-    end
-
     # important: the import_resolution_dirname implemented as the local_name is critical because Bundler#download_package downloads
     # package dependencies to the name that this method returns, which must match the package reference's local name
     # so that later, when the package is being looked up on the load path (in LoadPath#resolve_import_reference),
@@ -34,7 +25,7 @@ module OpsWalrus
     # change in order for the three things to reconcile with respect to one another, since all three bits of logic are
     # what make bundling package dependencies and loading them function properly.
     def import_resolution_dirname
-      local_name
+      "pkg_#{local_name}_version_#{version}"
     end
 
     def to_s
@@ -53,8 +44,17 @@ module OpsWalrus
   # these are dynamic package references defined at runtime when an OpsFile's imports are being evaluated.
   # this will usually be the case when an ops file does not belong to a package
   class DynamicPackageReference < PackageReference
+    def self.import_resolution_dirname(package_uri, version)
+      sanitized_package_uri = sanitize_path(package_uri || raise(Error, "Unspecified package reference"))
+      sanitized_version = sanitize_path(version || "")
+      "pkg_#{sanitized_package_uri}_version_#{sanitized_version}"
+    end
+    def self.sanitize_path(path)
+      # found this at https://apidock.com/rails/v5.2.3/ActiveStorage/Filename/sanitized
+      path.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "�").strip.tr("\u{202E}%$|:;/\t\r\n\\", "-")
+    end
     def import_resolution_dirname
-      sanitized_package_uri
+      DynamicPackageReference.import_resolution_dirname(@package_uri, @version)
     end
   end