opswalrus 1.0.12 → 1.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9c838dbf7a64b90664fa94e0b6579508e0967d20a2fa8d8779616fa36cf9b8f
-  data.tar.gz: 9787c55859ab6ed5f5ceb50803c72df06f9d021e25dcbe7dc917db4f2f30b2ab
+  metadata.gz: 9ee2d0af10d38f7722a8af82b44af64f3c0d906de21b4425d472d4e27b9495b0
+  data.tar.gz: e42c56ffcdf0c1cf1b08e68771dcf46364439c057393ed325b5325964816d1a8
 SHA512:
-  metadata.gz: 644d62c00d36280d5be184f8408c0fc8d5da05d02bae7207b6899d819c98c3f6456be34bb50db1ebfd4012419e6710e193d278c6065bdf2a5b5cc6025b291606
-  data.tar.gz: a0a2f5663a4bc748feba02bf4609de61347a8ef5519420ba578dfade18c5fdb877f9aada5332bc705c3714db3284b0e137844fa43a56718c3a99d23ceda8b613
+  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.12)
+    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/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/errors.rb

@@ -0,0 +1,7 @@
+module OpsWalrus
+  class Error < StandardError
+  end
+
+  class SymbolResolutionError < Error
+  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,12 +166,17 @@ 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
 
+    def to_s
+      @_host.to_s
+    end
+
     def method_missing(name, ...)
       @_host.send(name, ...)
     end