opswalrus 1.0.13 → 1.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1199faea66fca54073c2446271ef2c31a8e78e6dd55e7e9de5173baae5da7ac4
-  data.tar.gz: 1bbe73114e2cf1449ad296245d4cf53a2c2f8c523a1652f0ce1776bf742e4438
+  metadata.gz: 9ee2d0af10d38f7722a8af82b44af64f3c0d906de21b4425d472d4e27b9495b0
+  data.tar.gz: e42c56ffcdf0c1cf1b08e68771dcf46364439c057393ed325b5325964816d1a8
 SHA512:
-  metadata.gz: d4e9a452262cf8a3a82c967bfc5dc9e8b39f87f80b42fb9b641fa764811e2735a78b307cc0c2751c6c185c8223561c0d41b5913b7c62c78d76c020907c8f8286
-  data.tar.gz: 15f772925cb50837543ee0277ca3e4fbee42c0c64e3c0ad28c940617c008d51c4507f3950a3fb28a96086ea8d759368f7b06e04b2f4aaee406a6883cc61956cf
+  metadata.gz: 39a22eed3d76788bb6d70ad4f4700d512a4e9612614508e407ee9d0187bd2f0aab3593845f5f6a8adb91020d330bd7d955bbe21c869c3aa7e6c1185af4204b6a
+  data.tar.gz: 63e635e997cead804423e1c966e7e429538e625532277b98178c19186345455b469222d5eabd4b7829998690753ba8d95d09788248b167e706d3512d05ece6de

data/Dockerfile

@@ -39,5 +39,5 @@ RUN git config --global --add safe.directory /workdir
 
 # Set the entrypoint to run the installed binary in /workdir
 # Example:  docker run -it -v "$PWD:/workdir" ops
-# ENTRYPOINT ["ops"]
-CMD ["ops"]
+ENTRYPOINT ["ops"]
+# CMD ["ops"]

data/Gemfile.lock

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

data/README.md

@@ -11,17 +11,19 @@ You have two options:
 ## Rubygems install
 
 ```shell
-gem install opswalrus
+❯ gem install opswalrus
 
-ops version
+❯ ops version
+1.0.13
 ```
 
 ## Docker install
 
 ```shell
-alias ops='docker run --rm -it -v $HOME/.ssh:/root/.ssh -v /var/run/docker.sock:/var/run/docker.sock -v ${PWD}/:/workdir ghcr.io/opswalrus/ops'
+❯ alias ops='docker run --rm -it -v $HOME/.ssh:/root/.ssh -v /var/run/docker.sock:/var/run/docker.sock -v ${PWD}/:/workdir ghcr.io/opswalrus/ops'
 
-ops version
+❯ ops version
+1.0.13
 ```
 
 # Examples

data/build.ops

@@ -51,4 +51,5 @@ end
 
 totp = sh("Get Rubygems OTP") { 'bw get totp Rubygems' }
 sh("Push gem", input: {"You have enabled multi-factor authentication. Please enter OTP code." => "#{totp}\n"}) { 'gem push opswalrus-{{ version }}.gem' }
-sh("Build docker image") { 'docker build -t opswalrus/ops:{{ version }} .' }
+sh("Build docker image") { 'docker build -t ghcr.io/opswalrus/ops:latest -t ghcr.io/opswalrus/ops:{{ version }} -t opswalrus/ops:latest -t opswalrus/ops:{{ version }} .' }
+sh("Push docker image to ghcr.io/opswalrus/ops") { 'docker push ghcr.io/opswalrus/ops:latest' }

data/lib/opswalrus/app.rb

@@ -1,12 +1,14 @@
 require "citrus"
 require "io/console"
 require "json"
+require "logger"
 require "random/formatter"
 require "shellwords"
 require "socket"
 require "stringio"
 require "yaml"
 require "pathname"
+require_relative "errors"
 require_relative "patches"
 require_relative "git"
 require_relative "host"
@@ -18,9 +20,6 @@ require_relative "version"
 
 
 module OpsWalrus
-  class Error < StandardError
-  end
-
   class App
     def self.instance(*args)
       @instance ||= new(*args)
@@ -32,6 +31,8 @@ module OpsWalrus
     attr_reader :local_hostname
 
     def initialize(pwd = Dir.pwd)
+      @logger = Logger.new($stdout, level: Logger::INFO)
+
       @verbose = false
       @sudo_user = nil
       @sudo_password = nil
@@ -89,6 +90,7 @@ module OpsWalrus
 
     def set_verbose(verbose)
       @verbose = verbose
+      @logger.debug! if verbose?
     end
 
     def verbose?
@@ -99,6 +101,22 @@ module OpsWalrus
       @verbose == 2
     end
 
+    def error(msg)
+      @logger.error(msg)
+    end
+
+    def warn(msg)
+      @logger.warn(msg)
+    end
+
+    def log(msg)
+      @logger.info(msg)
+    end
+
+    def debug(msg)
+      @logger.debug(msg)
+    end
+
     def set_pwd(pwd)
       @pwd = pwd.to_pathname
       @bundler = Bundler.new(@pwd)
@@ -147,13 +165,9 @@ module OpsWalrus
     def run(package_operation_and_args)
       return 0 if package_operation_and_args.empty?
 
-      ops_file_path, operation_kv_args, tmp_dir = get_entry_point_ops_file_and_args(package_operation_and_args)
-      ops_file = OpsFile.new(self, ops_file_path)
+      ops_file_path, operation_kv_args, tmp_bundle_root_dir = get_entry_point_ops_file_and_args(package_operation_and_args)
 
-      # if the ops file is part of a package, then set the package directory as the app's pwd
-      if ops_file.package_file && ops_file.package_file.dirname.to_s !~ /#{Bundler::BUNDLE_DIR}/
-        ops_file = set_pwd_to_ops_file_package_directory(ops_file)
-      end
+      ops_file = load_entry_point_ops_file(ops_file_path, tmp_bundle_root_dir)
 
       if @verbose
         puts "Running: #{ops_file.ops_file_path}"
@@ -177,19 +191,52 @@ module OpsWalrus
 
       exit_status
     ensure
-      FileUtils.remove_entry(tmp_dir) if tmp_dir
+      FileUtils.remove_entry(tmp_bundle_root_dir) if tmp_bundle_root_dir
+    end
+
+    def load_entry_point_ops_file(ops_file_path, tmp_bundle_root_dir)
+      ops_file = OpsFile.new(self, ops_file_path)
+
+      # we are running the ops file from within a temporary bundle root directory created by unzipping a zip bundle workspace
+      if tmp_bundle_root_dir
+        return set_pwd_and_rebase_ops_file(tmp_bundle_root_dir, ops_file)
+      end
+
+      # if the ops file is contained within a bundle directory, then that means we're probably running this command invocation
+      # on a remote host, e.g. /home/linuxbrew/.linuxbrew/bin/gem exec -g opswalrus ops run --script /tmp/d20230822-18829-2j5ij2 opswalrus_bundle docker install install
+      # and the corresponding entry point, e.g. /tmp/d20230822-18829-2j5ij2/opswalrus_bundle/docker/install/install.ops
+      # is actually being run from a temporary zip bundle root directory
+      # so we want to set the app's pwd to be the parent directory of the Bundler::BUNDLE_DIR directory, e.g. /tmp/d20230822-18829-2j5ij2
+      if ops_file.ops_file_path.to_s =~ /#{Bundler::BUNDLE_DIR}/
+        return set_pwd_to_parent_of_bundle_dir(ops_file)
+      end
+
+      # if the ops file is part of a package, then set the package directory as the app's pwd
+      if ops_file.package_file && ops_file.package_file.dirname.to_s !~ /#{Bundler::BUNDLE_DIR}/
+        return set_pwd_to_ops_file_package_directory(ops_file)
+      end
+
+      ops_file
+    end
+
+    def set_pwd_to_parent_of_bundle_dir(ops_file)
+      match = /^(.*)#{Bundler::BUNDLE_DIR}.*$/.match(ops_file.ops_file_path.to_s)
+      parent_directory_path = match.captures.first.to_pathname.cleanpath
+      set_pwd_and_rebase_ops_file(parent_directory_path, ops_file)
     end
 
     # sets the App's pwd to the ops file's package directory and
-    # returns a new OpsFile that points at the revised pathname with considered as relative to the package file's directory
+    # returns a new OpsFile that points at the revised pathname when considered as relative to the package file's directory
     def set_pwd_to_ops_file_package_directory(ops_file)
-      # puts "set pwd: #{ops_file.package_file.dirname}"
-      set_pwd(ops_file.package_file.dirname)
-      rebased_ops_file_relative_path = ops_file.ops_file_path.relative_path_from(ops_file.package_file.dirname)
-      # note: rebased_ops_file_relative_path is a relative path that is relative to ops_file.package_file.dirname
-      # puts "rebased path: #{rebased_ops_file_relative_path}"
-      absolute_ops_file_path = ops_file.package_file.dirname.join(rebased_ops_file_relative_path)
-      # puts "absolute path: #{absolute_ops_file_path}"
+      set_pwd_and_rebase_ops_file(ops_file.package_file.dirname, ops_file)
+    end
+
+    # returns a new OpsFile that points at the revised pathname when considered as relative to the new working directory
+    def set_pwd_and_rebase_ops_file(new_working_directory, ops_file)
+      set_pwd(new_working_directory)
+      rebased_ops_file_relative_path = ops_file.ops_file_path.relative_path_from(new_working_directory)
+      # note: rebased_ops_file_relative_path is a relative path that is relative to new_working_directory
+      absolute_ops_file_path = new_working_directory.join(rebased_ops_file_relative_path)
       OpsFile.new(self, absolute_ops_file_path)
     end
 
@@ -203,18 +250,18 @@ module OpsWalrus
     # - ["../../my-package/operation1", "arg1:val1", "arg2:val2", "arg3:val3"]
     # - ["../../my-package/operation1"]
     #
-    # returns 3-tuple of the form: [ ops_file_path, operation_kv_args, optional_tmp_dir ]
-    # such that the third item - optional_tmp_dir - if present, should be deleted after the script has completed running
+    # returns 3-tuple of the form: [ ops_file_path, operation_kv_args, optional_tmp_bundle_root_dir ]
+    # such that the third item - optional_tmp_bundle_root_dir - if present, should be deleted after the script has completed running
     def get_entry_point_ops_file_and_args(package_operation_and_args)
       package_operation_and_args = package_operation_and_args.dup
       package_or_ops_file_reference = package_operation_and_args.slice!(0, 1).first
-      tmp_dir = nil
+      tmp_bundle_root_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]
+        [ops_file_path, operation_kv_args, tmp_bundle_root_dir]
       when File.exist?(package_or_ops_file_reference)
         first_filepath = package_or_ops_file_reference.to_pathname.realpath
 
@@ -222,18 +269,18 @@ module OpsWalrus
         when ".ops"
           [first_filepath, package_operation_and_args]
         when ".zip"
-          tmp_dir = Dir.mktmpdir.to_pathname    # this is the temporary bundle root dir
+          tmp_bundle_root_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)
+          DirZipper.unzip(first_filepath, tmp_bundle_root_dir)
 
-          find_entry_point_ops_file_in_dir(tmp_dir, package_operation_and_args)
+          find_entry_point_ops_file_in_dir(tmp_bundle_root_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]
+        [ops_file_path, operation_kv_args, tmp_bundle_root_dir]
       when repo_url = Git.repo?(package_or_ops_file_reference)
         destination_package_path = bundler.download_git_package(repo_url)
 
@@ -241,7 +288,7 @@ module OpsWalrus
 
         # 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]
+        [ops_file_path, operation_kv_args, tmp_bundle_root_dir]
       else
         raise Error, "Unknown operation reference: #{package_or_ops_file_reference.inspect}"
       end

data/lib/opswalrus/errors.rb

@@ -0,0 +1,7 @@
+module OpsWalrus
+  class Error < StandardError
+  end
+
+  class SymbolResolutionError < Error
+  end
+end

data/lib/opswalrus/host.rb

@@ -173,6 +173,10 @@ module OpsWalrus
 
     # the subclasses of this class will define methods that handle method dispatch via HostProxyOpsFileInvocationBuilder objects
 
+    def to_s
+      @_host.to_s
+    end
+
     def method_missing(name, ...)
       @_host.send(name, ...)
     end

data/lib/opswalrus/invocation.rb

@@ -1,15 +1,3 @@
-# require 'json'
-# require 'set'
-# require 'shellwords'
-# require 'socket'
-# require 'stringio'
-
-# require 'sshkit'
-# require 'sshkit/dsl'
-
-# require_relative 'host'
-# require_relative 'sshkit_ext'
-# require_relative 'walrus_lang'
 
 module OpsWalrus
 
@@ -127,7 +115,7 @@ module OpsWalrus
       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)
+        resolved_symbol.invoke(@runtime_env, params_hash)
       else
         self
       end
@@ -142,434 +130,5 @@ module OpsWalrus
       _resolve_method_and_invoke(name, *args, **kwargs)
     end
   end
-#   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
-
-
-#   # BootstrapLinuxHostShellScript = <<~SCRIPT
-#   #   #!/usr/bin/env bash
-#   #   ...
-#   # SCRIPT
-
-#   module InvocationDSL
-#     def ssh(*args, **kwargs, &block)
-#       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
-#       local_host = self
-#       # bootstrap_shell_script = BootstrapLinuxHostShellScript
-#       # on sshkit_hosts do |sshkit_host|
-#       SSHKit::Coordinator.new(sshkit_hosts).each(in: kwargs[:in] || :parallel) do |sshkit_host|
-
-#         # in this context, self is an instance of one of the subclasses of SSHKit::Backend::Abstract, e.g. SSHKit::Backend::Netssh
-
-#         host = sshkit_host_to_ops_host_map[sshkit_host]
-#         # puts "#{host.alias} / #{host}:"
-
-#         begin
-#           host.set_runtime_env(runtime_env)
-#           host.set_ssh_session_connection(self)  # self is an instance of one of the subclasses of SSHKit::Backend::Abstract, e.g. SSHKit::Backend::Netssh
-
-#           # copy over bootstrap shell script
-#           # io = StringIO.new(bootstrap_shell_script)
-#           io = File.open(__FILE__.to_pathname.dirname.join("bootstrap.sh"))
-#           upload_success = host.upload(io, "tmpopsbootstrap.sh")
-#           io.close
-#           raise Error, "Unable to upload bootstrap shell script to remote host" unless upload_success
-#           host.execute(:chmod, "755", "tmpopsbootstrap.sh")
-#           host.execute(:sh, "tmpopsbootstrap.sh")
-
-#           # copy over ops bundle zip file
-#           zip_bundle_path = runtime_env.zip_bundle_path
-#           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(: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_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
-
-#           # 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
-
-#           retval
-#         rescue SSHKit::Command::Failed => e
-#           puts "[!] Command failed:"
-#           puts e.message
-#         rescue Net::SSH::ConnectionTimeout
-#           puts "[!] The host '#{host}' not alive!"
-#         rescue Net::SSH::Timeout
-#           puts "[!] The host '#{host}' disconnected/timeouted unexpectedly!"
-#         rescue Errno::ECONNREFUSED
-#           puts "[!] Incorrect port #{port} for #{host}"
-#         rescue Net::SSH::HostKeyMismatch => e
-#           puts "[!] The host fingerprint does not match the last observed fingerprint for #{host}"
-#           puts e.message
-#           puts "You might try `ssh-keygen -f ~/.ssh/known_hosts -R \"#{host}\"`"
-#         rescue Net::SSH::AuthenticationFailed
-#           puts "Wrong Password: #{host} | #{user}:#{password}"
-#         rescue Net::SSH::Authentication::DisallowedMethod
-#           puts "[!] The host '#{host}' doesn't accept password authentication method."
-#         rescue Errno::EHOSTUNREACH => e
-#           puts "[!] The host '#{host}' is unreachable"
-#         rescue => e
-#           puts e.class
-#           puts e.message
-#           # puts e.backtrace.join("\n")
-#         ensure
-#           host.clear_ssh_session
-#         end
-#       end
-#     end
-
-#     def inventory(*args, **kwargs)
-#       tags = args.map(&:to_s)
-
-#       kwargs = kwargs.transform_keys(&:to_s)
-#       tags.concat(kwargs["tags"]) if kwargs["tags"]
-
-#       @runtime_env.app.inventory(tags)
-#     end
-
-#     def exit(exit_status, message = nil)
-#       if message
-#         puts message
-#       end
-#       result = if exit_status == 0
-#         Invocation::Success.new(nil)
-#       else
-#         Invocation::Error.new(nil, exit_status)
-#       end
-#       throw :exit_now, result
-#     end
-
-#     def env(*keys)
-#       keys = keys.map(&:to_s)
-#       if keys.empty?
-#         @env
-#       else
-#         @env.dig(*keys)
-#       end
-#     end
-
-#     # currently, import may only be used to import a package that is referenced in the script's package file
-#     # I may decide to extend this to work with dynamic package references
-#     #
-#     # local_package_name is the local package name defined for the package dependency that is attempting to be referenced
-#     def import(local_package_name)
-#       local_package_name = local_package_name.to_s
-#       package_reference = @ops_file_script.ops_file.package_file&.dependency(local_package_name)
-#       raise Error, "Unknown package reference: #{local_package_name}" unless package_reference
-#       import_reference = PackageDependencyReference.new(local_package_name, package_reference)
-#       # puts "import: #{import_reference.inspect}"
-#       @runtime_env.resolve_import_reference(@ops_file_script.ops_file, import_reference)
-#     end
-
-#     def params(*keys, default: nil)
-#       keys = keys.map(&:to_s)
-#       if keys.empty?
-#         @params
-#       else
-#         @params.dig(*keys) || default
-#       end
-#     end
-
-#     # returns the stdout from the command
-#     def sh(desc_or_cmd = nil, cmd = nil, input: nil, &block)
-#       out, err, status = *shell!(desc_or_cmd, cmd, block, input: input)
-#       out
-#     end
-
-#     # returns the tuple: [stdout, stderr, exit_status]
-#     def shell(desc_or_cmd = nil, cmd = nil, input: nil, &block)
-#       shell!(desc_or_cmd, cmd, block, input: input)
-#     end
-
-#     # returns the tuple: [stdout, stderr, exit_status]
-#     def shell!(desc_or_cmd = nil, cmd = nil, block = nil, input: nil)
-#       # description = nil
-
-#       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
-#       cmd = block.call if block
-#       cmd ||= desc_or_cmd
-
-#       cmd = WalrusLang.render(cmd, block.binding) if block && cmd =~ /{{.*}}/
-
-#       #cmd = Shellwords.escape(cmd)
-
-#       # puts "shell! self: #{self.inspect}"
-
-#       if App.instance.report_mode?
-#         print "[#{@runtime_env.local_hostname}] "
-#         print "#{description}: " if description
-#         puts 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)
-#       end
-
-#       [sshkit_cmd.full_stdout, sshkit_cmd.full_stderr, sshkit_cmd.exit_status]
-#     end
-
-#     # def init_brew
-#     #   execute('eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"')
-#     # end
-
-#   end
-
-#   # An Invocation object represents a stack frame, and the params_hash represents the
-#   # arguments that the caller has supplied for that stack frame to reference
-#   class Invocation
-#     class Result
-#       attr_accessor :value
-#       attr_accessor :exit_status
-#       def initialize(value, exit_status = 0)
-#         @value = value
-#         @exit_status = exit_status
-#       end
-#       def success?
-#         !failure?
-#       end
-#       def failure?
-#         !success?
-#       end
-#     end
-#     class Success < Result
-#       def initialize(value)
-#         super(value, 0)
-#       end
-#       def success?
-#         true
-#       end
-#     end
-#     class Error < Result
-#       def initialize(value, exit_status = 1)
-#         super(value, exit_status == 0 ? 1 : exit_status)
-#       end
-#       def failure?
-#         true
-#       end
-#     end
-
-
-#     def self.define_invocation_class(ops_file)
-#       klass = Class.new(Invocation)
-
-#       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
-#           klass.define_method(symbol_name) do |*args, **kwargs, &block|
-#             # puts "0" * 80
-#             # puts "@runtime_env.resolve_import_reference(@ops_file_script.ops_file, #{import_reference.inspect})"
-#             # puts @ops_file_script.ops_file.ops_file_path
-#             # puts symbol_name
-#             namespace_or_ops_file = @runtime_env.resolve_import_reference(@ops_file_script.ops_file, import_reference)
-#             # puts namespace_or_ops_file.inspect
-#             # puts "0" * 80
-#             case namespace_or_ops_file
-#             when Namespace
-#               namespace_or_ops_file
-#             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
-#       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
-#           klass.define_method(symbol_name) do |*args, **kwargs, &block|
-#             # puts "0" * 80
-#             # puts "@runtime_env.resolve_symbol(@ops_file_script.ops_file, #{symbol_name})"
-#             # puts @ops_file_script.ops_file.ops_file_path
-#             # puts symbol_name
-#             namespace_or_ops_file = @runtime_env.resolve_sibling_symbol(@ops_file_script.ops_file, symbol_name)
-#             # puts namespace_or_ops_file.inspect
-#             # puts "0" * 80
-#             case namespace_or_ops_file
-#             when Namespace
-#               namespace_or_ops_file
-#             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
-#       end
-
-#       klass
-#     end
-
-#     include InvocationDSL
-
-#     def initialize(ops_file_script, runtime_env, params_hash)
-#       @ops_file_script = ops_file_script
-#       @runtime_env = runtime_env
-#       @params = InvocationParams.new(params_hash)
-#     end
-
-#     def backend
-#       @runtime_env.pty
-#     end
-
-#     def debug?
-#       @runtime_env.debug?
-#     end
-
-#     def verbose?
-#       @runtime_env.verbose?
-#     end
-
-#     # def evaluate
-#     #   # the evaluation context needs to be a module with all of the following:
-#     #   # - InvocationDSL methods
-#     #   # - @ops_file_script
-#     #   # - @runtime_env
-#     #   # - @params
-#     #   # - #backend
-#     #   # - #debug?
-#     #   # - #verbose?
-#     #   # - all the dynamically defined methods in the subclass of Invocation
-#     # end
-
-#     def evaluate
-#       eval(@ops_file_script.script, nil, @ops_file_script.ops_file.ops_file_path.to_s, @ops_file_script.ops_file.script_line_offset)
-#     end
-
-#     # def evaluate
-#     #   ops_file_script = @ops_file_script
-#     #   runtime_env = @runtime_env
-#     #   invocation_params = @params
-
-#     #   # we use a Module as the evaluation context instead of this #evaluate method so that classes and other structures may be defined in an .ops file
-#     #   evaluation_context = Module.new
-#     #   evaluation_context.module_exec {
-#     #     include InvocationDSL
-
-#     #     @ops_file_script = ops_file_script
-#     #     @runtime_env = runtime_env
-#     #     @params = invocation_params
-
-#     #     def backend
-#     #       @runtime_env.pty
-#     #     end
-
-#     #     def debug?
-#     #       @runtime_env.debug?
-#     #     end
-
-#     #     def verbose?
-#     #       @runtime_env.verbose?
-#     #     end
-#     #   }
-
-#     #   evaluation_context.module_eval(@ops_file_script.script, @ops_file_script.ops_file.ops_file_path.to_s, @ops_file_script.ops_file.script_line_offset)
-#     # end
-
-#     # def method_missing(name, *args, **kwargs, &block)
-#     #   puts "1" * 80
-#     #   import_reference = @ops_file_script.ops_file.resolve_import(name)
-#     #   if import_reference
-#     #     puts "2" * 80
-#     #     resolved_value = @runtime_env.resolve_import_reference(@ops_file_script.ops_file, import_reference)
-#     #     return resolved_value if resolved_value
-#     #   end
 
-#     #   puts "3" * 80
-#     #   case namespace_or_ops_file = @runtime_env.resolve_symbol(@ops_file_script.ops_file, name.to_s)
-#     #   when Namespace
-#     #     puts "4" * 80
-#     #     namespace_or_ops_file
-#     #   when OpsFile
-#     #     puts "5" * 80
-#     #     namespace_or_ops_file.invoke(@runtime_env, *args, **kwargs, &block)
-#     #   else
-#     #     raise NoMethodError, "No method named '#{name}'"
-#     #   end
-#     # end
-#   end
 end

data/lib/opswalrus/operation_runner.rb

@@ -58,25 +58,25 @@ module OpsWalrus
           Invocation::Success.new(ruby_script_return)
         end
       rescue SSHKit::Command::Failed => e
-        puts "[!] Command failed: #{e.message}"
+        App.instance.error "[!] Command failed: #{e.message}"
       rescue Error => e
-        $stderr.puts "Error: Ops script crashed."
-        $stderr.puts e.message
-        $stderr.puts e.backtrace.join("\n")
+        App.instance.error "Error: Ops script crashed."
+        App.instance.error e.message
+        App.instance.error e.backtrace.take(5).join("\n")
         Invocation::Error.new(e)
       rescue => e
-        $stderr.puts "Unhandled Error: Ops script crashed."
-        $stderr.puts e.class
-        $stderr.puts e.message
-        $stderr.puts e.backtrace.join("\n")
+        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")
         Invocation::Error.new(e)
       end
 
       if app.debug? && result.failure?
-        puts "Ops script error details:"
-        puts "Error: #{result.value}"
-        puts "Status code: #{result.exit_status}"
-        puts @entry_point_ops_file.script
+        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
       end
 
       result

data/lib/opswalrus/ops_file_script.rb

@@ -14,22 +14,15 @@ 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
-          # 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}"
+            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)
 
-            # 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
@@ -40,26 +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}"
+            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)
 
-
-            # 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/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
@@ -178,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
@@ -198,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
@@ -221,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
 
@@ -315,23 +348,41 @@ module OpsWalrus
       ops_file.invoke(self, params_hash)
     end
 
+    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.13"
+  VERSION = "1.0.14"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: opswalrus
 version: !ruby/object:Gem::Version
-  version: 1.0.13
+  version: 1.0.14
 platform: ruby
 authors:
 - David Ellis
@@ -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