opswalrus 1.0.7 → 1.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0c1c00f88ff00a4f7eb735a634ea35e1e8818b44fffdccea7a2347bac78e199
-  data.tar.gz: fe54254076c753cfeaf26906fa0f7475bd11807c0ac70d4067da03653b0f774c
+  metadata.gz: 97d8c56ff040eeca8da82c47442a507247e952faec4077ea87293be581234c49
+  data.tar.gz: d9fb2905bcb900acaea9c85ee74af89b01b2200594d05d043da3b1decbb08ff8
 SHA512:
-  metadata.gz: 28244a51a465941731663e9db3901049d36d1fa385a16b4c5ed9254c31fa62ca44012c2d776ef5b6d1d06906c012802b1352e166d72d28b3ec0aa6f9e27073f5
-  data.tar.gz: 39ccb70ca9dc5b2ecf67b1ab29adb7ccc79cb43ad57d256be0deb68b49909bc4c5cd4ddc2871e68aeeb374ed3d0202c365094536e7933f61c3ecf700a2178076
+  metadata.gz: 3268ce43c666de5dd7923286d0c43dce2eac82b0632665b2edd2e77675beab4efb5444b49afccde0e8940f140480750776fe1618cc78c436ff89aa3c864e1820
+  data.tar.gz: bf341b62f93981af7f74c4f9195ac36b30eeaf53b525a64b96ebc9921c0484fb53c9f21304587b7adb3da3e9cb057c6cf23c9f265e89e31d3fe043575c77f103

data/CNAME

@@ -0,0 +1 @@
+opswalrus.com

data/Gemfile.lock

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

data/README.md

@@ -206,7 +206,7 @@ davidinfra
 │   ├── install
 │   │   └── debian.ops
 │   └── install.ops
-├── hosts.yml
+├── hosts.yaml
 ├── main.ops
 ├── prepare_host
 │   ├── all.ops
@@ -225,9 +225,10 @@ davidinfra
 │   └── davidinfra
 │       ├── caddy
 │       │   ├── install
-│       │   │   └── debian.ops
-│       │   └── install.ops
-│       ├── hosts.yml
+│       │   │   ├── debian.ops
+│       │   │   └── install.ops
+│       │   └── restart.ops
+│       ├── hosts.yaml
 │       ├── main.ops
 │       ├── prepare_host
 │       │   ├── all.ops
@@ -238,8 +239,9 @@ davidinfra
 ├── caddy
 │   ├── install
 │   │   └── debian.ops
-│   └── install.ops
-├── hosts.yml
+│   │   └── install.ops
+│   └── restart.ops
+├── hosts.yaml
 ├── main.ops
 ├── prepare_host
 │   ├── all.ops
@@ -255,17 +257,22 @@ The import and symbol resolution rules are as follows:
    Within the lexical scope of an ops file's ruby script, any ops files or subdirectories that are implicitly imported
    may be referenced by their name.
    For example:
-   - main.ops may invoke caddy/install.ops with the expression `caddy.install(...)`
+   - main.ops may invoke caddy/install.ops with the expression `caddy.restart(...)`
    - all.ops may invoke hostname.ops with the expression `hostname(...)`
-2. If there is an ops file and a directory that share the same name (with the exception of the .ops file extension),
-   then only the install.ops file may be referenced and invoked by other ops files, while the directory of the same name,
-   and its contents, may only be referenced from within the ops file of the matching name. This allows the details of
-   an operation to be encapsulated away and a public API be exposed through the ops file, while the details of the
-   implementation are hidden away in the ops files within the directory.
+2. If there is an ops file and a directory that share the same name (with the exception of the .ops file extension), and
+   are both contained by the same parent directory, then only the .ops file may be referenced and invoked by other ops files.
+   The directory of the same name will be treated as a library directory and if there is a Ruby source file in the library
+   directory with the same name, then that ruby file will automatically be loaded. Other ruby files within the library directory
+   will be required/loaded as instructed by the entrypoint .rb file.
+3. If there is an ops file and a directory that share the same name (with the exception of the .ops file extension), and
+   the ops file is contained by the directory of the same name, then the ops file is considered to be the primary API
+   interface for a sub-module that is implemented by the ops files and ruby scripts contained within the directory.
+   Consequently, the directory containing the ops file of the same name (with the exception of the .ops file extension)
+   may be invoked as if it were the primary API interface ops file.
    For example:
-   - main.ops may invoke `caddy.install(...)`, but it may not invoke `caddy.install.debian(...)`
-   - install.ops may invoke `install.debian(...)`, and reference other files or subpackages within the caddy/install directory
-3. Ops files may import packages or relative paths:
+   - main.ops may invoke `caddy.install(...)` as a shorthand syntax for `caddy.install.install(...)`
+   - install.ops may invoke `debian(...)`, and reference other files or subpackages within the caddy/install directory
+4. Ops files may import packages or relative paths:
    1. a package reference that matches one of the local package names in the dependencies captured in packages.yaml
    2. a package reference that resolves to a relative path pointing at a package directory
    3. a relative path that resolves to a directory containing ops files

data/build.ops

@@ -3,8 +3,22 @@ params:
 
 imports:
   core: "https://github.com/opswalrus/core.git"
+
 ...
 
+# when you run this script, it should do something like:
+# ~/sync/projects/ops/opswalrus on  main via 💎 v3.2.2
+# ❯ ../ops.sh run build.ops version:1.0.7
+# Write version.rb for version 1.0.7
+# [localhost] Build gem: gem build opswalrus.gemspec
+# [localhost] Check whether Bitwarden is locked or not: bw status
+# [localhost] Get Rubygems OTP: bw get totp Rubygems
+# [localhost] Push gem: gem push opswalrus-1.0.7.gem
+# [localhost] Build docker image: docker build -t opswalrus/ops:1.0.7 .
+
+# ~/sync/projects/ops/opswalrus on  main via 💎 v3.2.2 took 44s
+
+
 version = params.version
 
 exit 1, "version parameter must be specified" unless version

data/lib/opswalrus/app.rb

@@ -40,6 +40,7 @@ module OpsWalrus
       @pwd = pwd.to_pathname
       @bundler = Bundler.new(@pwd)
       @local_hostname = "localhost"
+      @mode = :report     # :report | :script
     end
 
     def to_s
@@ -50,12 +51,16 @@ module OpsWalrus
       ""  # return empty string because we won't want anyone accidentally printing or inspecting @sudo_password
     end
 
-    def emit_json_output!
-      @emit_json_output = true
+    def script_mode!
+      @mode = :script
     end
 
-    def emit_json_output?
-      @emit_json_output
+    def report_mode?
+      @mode == :report
+    end
+
+    def script_mode?
+      @mode == :script
     end
 
     def set_local_hostname(hostname)
@@ -149,8 +154,12 @@ module OpsWalrus
         ops_file = set_pwd_to_ops_file_package_directory(ops_file)
       end
 
+      if @verbose
+        puts "Running: #{ops_file.ops_file_path}"
+      end
+
       op = OperationRunner.new(self, ops_file)
-      result = op.run(operation_kv_args, params_json_hash: @params, verbose: @verbose)
+      result = op.run(operation_kv_args, params_json_hash: @params)
       exit_status = result.exit_status
 
       if @verbose
@@ -161,7 +170,7 @@ module OpsWalrus
         puts JSON.pretty_generate(result.value)
       end
 
-      if emit_json_output?
+      if script_mode?
         puts JSON.pretty_generate(result.value)
       end
 
@@ -302,7 +311,7 @@ module OpsWalrus
       tags = @inventory_tag_selections + (tag_selection || [])
       tags.uniq!
 
-      host_references = ["hosts.yml"] if (host_references.nil? || host_references.empty?) && File.exist?("hosts.yml")
+      host_references = ["hosts.yaml"] if (host_references.nil? || host_references.empty?) && File.exist?("hosts.yaml")
 
       hosts_files, host_strings = host_references.partition {|ref| File.exist?(ref) }
       hosts_files = hosts_files.map {|file_path| HostsFile.new(file_path) }

data/lib/opswalrus/bootstrap.sh

@@ -7,10 +7,15 @@ if [ -x "$(command -v /home/linuxbrew/.linuxbrew/bin/brew)" ]; then
   # exit early if ruby already exists
   if [ -x "$(command -v ruby)" ]; then
     echo 'Ruby is already installed.' >&2
+
+    # make sure the latest opswalrus gem is installed
+    gem install opswalrus
+
     exit 0
   fi
 fi
 
+# https://github.com/chef/os_release documents the contents of /etc/os-release from a bunch of distros
 OS=$(cat /etc/os-release | grep "^ID=")
 if echo $OS | grep -q 'ubuntu'; then
   # update package list

data/lib/opswalrus/cli.rb

@@ -15,10 +15,11 @@ module OpsWalrus
 
     # this is invoked on an unhandled exception or a call to exit_now!
     on_error do |exception|
-      # puts "*" * 80
-      # puts "catchall exception handler:"
-      # puts exception.message
-      # puts exception.backtrace.join("\n")
+      next(false) if exception.is_a? GLI::CustomExit
+
+      puts "catchall exception handler:"
+      puts exception.message
+      puts exception.backtrace.join("\n")
       false   # disable built-in exception handling
     end
 
@@ -53,7 +54,7 @@ module OpsWalrus
       c.flag [:u, :user], desc: "Specify the user that the operation will run as"
       c.switch :pass, desc: "Prompt for a sudo password"
       c.flag [:p, :params], desc: "JSON string that represents the input parameters for the operation. The JSON string must conform to the params schema for the operation."
-      c.switch :json, desc: "Emit JSON output"
+      c.switch :script, desc: "Script mode"
 
       c.action do |global_options, options, args|
         hosts = global_options[:hosts] || []
@@ -81,17 +82,10 @@ module OpsWalrus
           $app.prompt_sudo_password
         end
 
-        if options[:json]
-          $app.emit_json_output!
+        if options[:script]
+          $app.script_mode!
         end
 
-        # puts "verbose"
-        # puts verbose.inspect
-        # puts "user"
-        # puts user.inspect
-        # puts "args"
-        # puts args.inspect
-
         exit_status = $app.run(args)
 
         exit_now!("error", exit_status) unless exit_status == 0

data/lib/opswalrus/host.rb

@@ -5,71 +5,6 @@ require_relative "interaction_handlers"
 
 module OpsWalrus
 
-  module HostDSL
-    # 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)
-
-      if self.alias
-        print "[#{self.alias} | #{host}] "
-      else
-        print "[#{host}] "
-      end
-      print "#{description}: " if description
-      puts cmd
-
-      return unless cmd && !cmd.strip.empty?
-
-      # puts "shell: #{cmd}"
-      # puts "shell: #{cmd.inspect}"
-      # puts "sudo_password: #{sudo_password}"
-
-      sshkit_cmd = execute_cmd(cmd, input: input)
-
-      [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
-
-    # runs the specified ops command with the specified command arguments
-    def run_ops(command, command_arguments, in_bundle_root_dir: true, verbose: false)
-      # e.g. /home/linuxbrew/.linuxbrew/bin/gem exec -g opswalrus ops bundle unzip tmpops.zip
-      # e.g. /home/linuxbrew/.linuxbrew/bin/gem exec -g opswalrus ops run echo.ops args:foo args:bar
-
-      cmd = "/home/linuxbrew/.linuxbrew/bin/gem exec -g opswalrus ops"
-      cmd << " -v" if verbose
-      cmd << " #{command.to_s}"
-      cmd << " #{@tmp_bundle_root_dir}" if in_bundle_root_dir
-      cmd << " #{command_arguments}" unless command_arguments.empty?
-
-      shell!(cmd)
-    end
-
-  end
-
   class HostProxyOpsFileInvocationBuilder
     def initialize(host_proxy, is_invocation_a_call_to_package_in_bundle_dir = false)
       @host_proxy = host_proxy
@@ -116,6 +51,53 @@ 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
+
+
     attr_accessor :_host
 
     def initialize(host)
@@ -129,6 +111,74 @@ module OpsWalrus
     end
   end
 
+
+  module HostDSL
+    # 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)
+
+      if App.instance.report_mode?
+        if self.alias
+          print "[#{self.alias} | #{host}] "
+        else
+          print "[#{host}] "
+        end
+        print "#{description}: " if description
+        puts cmd
+      end
+
+      return unless cmd && !cmd.strip.empty?
+
+      # puts "shell: #{cmd}"
+      # puts "shell: #{cmd.inspect}"
+      # puts "sudo_password: #{sudo_password}"
+
+      sshkit_cmd = execute_cmd(cmd, input: input)
+
+      [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
+
+    # runs the specified ops command with the specified command arguments
+    def run_ops(command, command_arguments, in_bundle_root_dir: true, verbose: false)
+      # e.g. /home/linuxbrew/.linuxbrew/bin/gem exec -g opswalrus ops bundle unzip tmpops.zip
+      # e.g. /home/linuxbrew/.linuxbrew/bin/gem exec -g opswalrus ops run echo.ops args:foo args:bar
+
+      cmd = "/home/linuxbrew/.linuxbrew/bin/gem exec -g opswalrus ops"
+      cmd << " -v" if verbose
+      cmd << " #{command.to_s}"
+      cmd << " #{@tmp_bundle_root_dir}" if in_bundle_root_dir
+      cmd << " #{command_arguments}" unless command_arguments.empty?
+
+      shell!(cmd)
+    end
+
+  end
+
   class Host
     include HostDSL
 
@@ -222,18 +272,12 @@ module OpsWalrus
     end
 
     def execute(*args, input: nil)
-      # puts "interaction handler responds with: #{ssh_password}"
-      # @sshkit_backend.capture(*args, interaction_handler: SudoPasswordMapper.new(ssh_password).interaction_handler, verbosity: :info)
-      # @sshkit_backend.capture(*args, interaction_handler: SudoPromptInteractionHandler.new, verbosity: :info)
-
       @runtime_env.handle_input(input, ssh_password) do |interaction_handler|
         @sshkit_backend.capture(*args, interaction_handler: interaction_handler, verbosity: :info)
       end
-
     end
 
     def execute_cmd(*args, input: nil)
-      # @sshkit_backend.execute_cmd(*args, interaction_handler: SudoPasswordMapper.new(ssh_password).interaction_handler, verbosity: :info)
       @runtime_env.handle_input(input, ssh_password) do |interaction_handler|
         @sshkit_backend.execute_cmd(*args, interaction_handler: interaction_handler, verbosity: :info)
       end