opswalrus 1.0.8 → 1.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5cc78e2afa6b27ff1d9c88d43b8ddf5e805768c020b22a31d8c51b592fedbb9c
-  data.tar.gz: 3f66378e5cfeb379aaed583ec180c14ecd5845bce81cf3e210fcac9bbe90b665
+  metadata.gz: 472ae5aafb306653a32149c08a481288237c6c524a3f72761e09ac9887a4c0f4
+  data.tar.gz: 449e723590784e10faf30bbbebb122d0ae00c6652e02559decc0cbbac0ba670f
 SHA512:
-  metadata.gz: a0f2aed13949ccafd89f6ae5ab274db40e0c9904c7f1eee1a15e19c22eefc5f24a5d47a62df04bd58628eca6c4a003a0063de57d796f48ee28e14156be794a70
-  data.tar.gz: ca70e69f2bba12706f983ec6ff78a1ab5a32e65c495bcb8e07b3f4cdccfac50ec3073b60085f7c42c885ec71e5d8bc8f369b0d51f6e86242c3efd4c9b68d1309
+  metadata.gz: 319c28870d5b1e91680e9aed29834df12c25dae3bbc6abeb0d54566f7d6a7662064dc8d54f7851d9d9ce7dc82d48c73a019abe58b384281e8b7c98ec5d252d99
+  data.tar.gz: 3e4a3d90ef1f30f29f4acb0acc8a34422e4f6f687f42fef3cba890e052b1d07848f38276b88d5c95f91be3d3e966c5b4a1e3f5c8e1faa8d31b1342dd8364c64e

data/CNAME

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

data/Gemfile.lock

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

data/README.md

@@ -10,12 +10,18 @@ You have two options:
 
 ## Rubygems install
 
+```shell
+gem install opswalrus
+
+ops version
+```
+
 ## 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'
 
-ops --version
+ops version
 ```
 
 # Examples
@@ -206,7 +212,7 @@ davidinfra
 │   ├── install
 │   │   └── debian.ops
 │   └── install.ops
-├── hosts.yml
+├── hosts.yaml
 ├── main.ops
 ├── prepare_host
 │   ├── all.ops
@@ -225,9 +231,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 +245,9 @@ davidinfra
 ├── caddy
 │   ├── install
 │   │   └── debian.ops
-│   └── install.ops
-├── hosts.yml
+│   │   └── install.ops
+│   └── restart.ops
+├── hosts.yaml
 ├── main.ops
 ├── prepare_host
 │   ├── all.ops
@@ -255,17 +263,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/lib/opswalrus/app.rb

@@ -14,6 +14,7 @@ require_relative "hosts_file"
 require_relative "operation_runner"
 require_relative "bundler"
 require_relative "package_file"
+require_relative "version"
 
 
 module OpsWalrus
@@ -40,6 +41,7 @@ module OpsWalrus
       @pwd = pwd.to_pathname
       @bundler = Bundler.new(@pwd)
       @local_hostname = "localhost"
+      @mode = :report     # :report | :script
     end
 
     def to_s
@@ -50,12 +52,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 +155,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 +171,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 +312,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) }
@@ -327,6 +337,10 @@ module OpsWalrus
       selected_hosts.sort_by(&:to_s)
     end
 
+    def print_version
+      puts VERSION
+    end
+
     def unzip(zip_bundle_file = nil, output_dir = nil)
       bundler.unzip(zip_bundle_file, output_dir)
     end

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
 
@@ -27,12 +28,19 @@ module OpsWalrus
     desc 'Be verbose'
     switch [:v, :verbose]
 
-    desc 'Debug'
+    desc 'Turn on debug mode'
     switch [:d, :debug]
 
     flag [:h, :hosts], multiple: true, desc: "Specify the hosts.yaml file"
     flag [:t, :tags], multiple: true, desc: "Specify a set of tags to filter the hosts by"
 
+    desc 'Print version'
+    command :version do |c|
+      c.action do |global_options, options, args|
+        $app.print_version
+      end
+    end
+
     desc 'Report on the host inventory'
     long_desc 'Report on the host inventory'
     command :inventory do |c|
@@ -53,7 +61,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 +89,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