careacademy-runbook 1.2.0

data/lib/runbook/run.rb

@@ -0,0 +1,290 @@
+module Runbook
+  module Run
+    def self.included(base)
+      base.extend(ClassMethods)
+      _register_kill_all_panes_hook(base)
+      _register_additional_step_whitespace_hook(base)
+      ::Runbook::Util::Repo.register_save_repo_hook(base)
+      ::Runbook::Util::Repo.register_delete_stored_repo_hook(base)
+      ::Runbook::Util::StoredPose.register_save_pose_hook(base)
+      ::Runbook::Util::StoredPose.register_delete_stored_pose_hook(base)
+    end
+
+    module ClassMethods
+      include Runbook::Hooks
+      include Runbook::Helpers::FormatHelper
+      include Runbook::Helpers::TmuxHelper
+
+      def execute(object, metadata)
+        return if should_skip?(metadata)
+
+        method = _method_name(object)
+        if respond_to?(method)
+          send(method, object, metadata)
+        else
+          msg = "ERROR! No execution rule for #{object.class} (#{_method_name(object)}) in #{to_s}"
+          metadata[:toolbox].error(msg)
+          return
+        end
+      end
+
+      def runbook__entities__book(object, metadata)
+        metadata[:toolbox].output("Executing #{object.title}...\n\n")
+      end
+
+      def runbook__entities__section(object, metadata)
+        metadata[:toolbox].output("Section #{metadata[:position]}: #{object.title}\n\n")
+      end
+
+      def runbook__entities__setup(object, metadata)
+        metadata[:toolbox].output("Setup:\n\n")
+      end
+
+      def runbook__entities__step(object, metadata)
+        toolbox = metadata[:toolbox]
+        title = " #{object.title}".rstrip
+        toolbox.output("Step #{metadata[:position]}:#{title}\n\n")
+        return if metadata[:auto] || metadata[:noop] ||
+          !metadata[:paranoid] || object.title.nil?
+        step_choices = _step_choices(object, metadata)
+        continue_result = toolbox.expand("Continue?", step_choices)
+        _handle_continue_result(continue_result, object, metadata)
+      end
+
+      def runbook__statements__ask(object, metadata)
+        target = object.parent.dsl
+        existing_val = target.instance_variable_get(:"@#{object.into}")
+        default = existing_val || object.default
+
+        if metadata[:auto]
+          if default
+            target.singleton_class.class_eval { attr_accessor object.into }
+            target.send("#{object.into}=".to_sym, default)
+            return
+          end
+
+          error_msg = "ERROR! Can't execute ask statement without default in automatic mode!"
+          metadata[:toolbox].error(error_msg)
+          raise Runbook::Runner::ExecutionError, error_msg
+        end
+
+        if metadata[:noop]
+          default_msg = default ? " (default: #{default})" : ""
+          echo_msg = object.echo ? "" : " (echo: false)"
+          metadata[:toolbox].output("[NOOP] Ask: #{object.prompt} (store in: #{object.into})#{default_msg}#{echo_msg}")
+          return
+        end
+
+        result = metadata[:toolbox].ask(object.prompt, default: default, echo: object.echo)
+
+        target = object.parent.dsl
+        target.singleton_class.class_eval { attr_accessor object.into }
+        target.send("#{object.into}=".to_sym, result)
+      end
+
+      def runbook__statements__confirm(object, metadata)
+        if metadata[:auto]
+          metadata[:toolbox].output("Skipping confirmation (auto): #{object.prompt}")
+        else
+          if metadata[:noop]
+            metadata[:toolbox].output("[NOOP] Prompt: #{object.prompt}")
+            return
+          end
+
+          result = metadata[:toolbox].yes?(object.prompt)
+          metadata[:toolbox].exit(1) unless result
+        end
+      end
+
+      def runbook__statements__description(object, metadata)
+        metadata[:toolbox].output("Description:")
+        metadata[:toolbox].output("#{object.msg}\n")
+      end
+
+      def runbook__statements__layout(object, metadata)
+        if metadata[:noop]
+          metadata[:toolbox].output(
+            "[NOOP] Layout: #{object.structure.inspect}"
+          )
+          unless ENV["TMUX"]
+            msg = "Warning: layout statement called outside a tmux pane."
+            metadata[:toolbox].warn(msg)
+          end
+          return
+        end
+
+        unless ENV["TMUX"]
+          error_msg = "Error: layout statement called outside a tmux pane. Exiting..."
+          metadata[:toolbox].error(error_msg)
+          metadata[:toolbox].exit(1)
+        end
+
+        structure = object.structure
+        title = object.parent.title
+        layout_panes = setup_layout(structure, runbook_title: title)
+        metadata[:layout_panes].merge!(layout_panes)
+      end
+
+      def runbook__statements__note(object, metadata)
+        metadata[:toolbox].output("Note: #{object.msg}")
+      end
+
+      def runbook__statements__notice(object, metadata)
+        metadata[:toolbox].warn("Notice: #{object.msg}")
+      end
+
+      def runbook__statements__tmux_command(object, metadata)
+        if metadata[:noop]
+          metadata[:toolbox].output("[NOOP] Run: `#{object.cmd}` in pane #{object.pane}")
+          return
+        end
+
+        send_keys(object.cmd, metadata[:layout_panes][object.pane])
+      end
+
+      def runbook__statements__ruby_command(object, metadata)
+        if metadata[:noop]
+          metadata[:toolbox].output("[NOOP] Run the following Ruby block:\n")
+          begin
+            source = deindent(object.block.source)
+            metadata[:toolbox].output("```ruby\n#{source}\n```\n")
+          rescue ::MethodSource::SourceNotFoundError => e
+            metadata[:toolbox].output("Unable to retrieve source code")
+          end
+          return
+        end
+
+        next_index = metadata[:index] + 1
+        parent_items = object.parent.items
+        remaining_items = parent_items.slice!(next_index..-1)
+        object.parent.dsl.instance_exec(object, metadata, self, &object.block)
+        parent_items[next_index..-1].each { |item| item.dynamic! }
+        parent_items.push(*remaining_items)
+      end
+
+      def runbook__statements__wait(object, metadata)
+        if metadata[:noop]
+          metadata[:toolbox].output("[NOOP] Sleep #{object.time} seconds")
+          return
+        end
+
+        time = object.time
+        message = "Sleeping #{time} seconds [:bar] :current/:total"
+        pastel = Pastel.new
+        yellow = pastel.on_yellow(" ")
+        green = pastel.on_green(" ")
+        progress_bar = TTY::ProgressBar.new(
+          message,
+          total: time,
+          width: 60,
+          head: ">",
+          incomplete: yellow,
+          complete: green,
+        )
+        progress_bar.start
+        time.times do
+          sleep(1)
+          progress_bar.advance(1)
+        end
+      end
+
+      def should_skip?(metadata)
+        if metadata[:reversed] && metadata[:position].empty?
+          current_pose = "0"
+        else
+          current_pose = metadata[:position]
+        end
+        return false if current_pose.empty?
+        position = Gem::Version.new(current_pose)
+        start_at = Gem::Version.new(metadata[:start_at])
+        return position < start_at
+      end
+
+      def start_at_is_substep?(object, metadata)
+        return false unless object.is_a?(Entity)
+        return true if metadata[:position].empty?
+        metadata[:start_at].start_with?(metadata[:position])
+      end
+
+      def past_position?(current_position, position)
+        current_pose = Gem::Version.new(current_position)
+        pose = Gem::Version.new(position)
+        return pose <= current_pose
+      end
+
+      def _method_name(object)
+        object.class.to_s.underscore.gsub("/", "__")
+      end
+
+      def _step_choices(object, metadata)
+        [
+          {key: "c", name: "Continue to execute this step", value: :continue},
+          {key: "s", name: "Skip this step", value: :skip},
+          {key: "j", name: "Jump to the specified position", value: :jump},
+          {key: "P", name: "Disable paranoid mode", value: :no_paranoid},
+          {key: "e", name: "Exit the runbook", value: :exit},
+        ]
+      end
+
+      def _handle_continue_result(result, object, metadata)
+        toolbox = metadata[:toolbox]
+        case result
+        when :continue
+          return
+        when :skip
+          position = metadata[:position]
+          split_position = position.split(".")
+          new_step = (split_position.pop.to_i + 1).to_s
+          start_at = (split_position <<  new_step).join(".")
+          metadata[:start_at] = start_at
+        when :jump
+          result = toolbox.ask("What position would you like to jump to?")
+          if past_position?(metadata[:position], result)
+            metadata[:reverse] = true
+            metadata[:reversed] = true
+          end
+          metadata[:start_at] = result
+        when :no_paranoid
+          metadata[:paranoid] = false
+        when :exit
+          toolbox.exit(0)
+        end
+      end
+    end
+
+    def self._register_kill_all_panes_hook(base)
+      base.register_hook(
+        :kill_all_panes_after_book,
+        :after,
+        Runbook::Entities::Book,
+      ) do |object, metadata|
+        next if metadata[:noop] || metadata[:layout_panes].none? || metadata[:keep_panes]
+        if metadata[:auto]
+          metadata[:toolbox].output("Killing all opened tmux panes...")
+          kill_all_panes(metadata[:layout_panes])
+        else
+          prompt = "Kill all opened panes?"
+          result = metadata[:toolbox].yes?(prompt)
+          if result
+            kill_all_panes(metadata[:layout_panes])
+          end
+        end
+      end
+    end
+
+    def self._register_additional_step_whitespace_hook(base)
+      base.register_hook(
+        :add_additional_step_whitespace_hook,
+        :after,
+        Runbook::Statement,
+      ) do |object, metadata|
+        if object.parent.is_a?(Runbook::Entities::Step) ||
+            object.parent.is_a?(Runbook::Entities::Setup)
+          if object.parent.items.last == object
+            metadata[:toolbox].output("\n")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/runbook/runner.rb

@@ -0,0 +1,66 @@
+module Runbook
+  class Runner
+    attr_reader :book
+
+    def initialize(book)
+      @book = book
+    end
+
+    def run(
+      run: :ssh_kit,
+      noop: false,
+      auto: false,
+      paranoid: true,
+      keep_panes: false,
+      start_at: "0"
+    )
+      run = "Runbook::Runs::#{run.to_s.camelize}".constantize
+      toolbox = Runbook::Toolbox.new
+      metadata = Util::StickyHash.new.merge({
+        noop: noop,
+        auto: auto,
+        paranoid: Util::Glue.new(paranoid),
+        start_at: Util::Glue.new(start_at || "0"),
+        toolbox: Util::Glue.new(toolbox),
+        keep_panes: keep_panes,
+        book_title: book.title,
+      }).
+      merge(Runbook::Entities::Book.initial_run_metadata).
+      merge(additional_metadata)
+
+      stored_pose = _stored_position(metadata)
+      if metadata[:start_at] == "0" && stored_pose
+        if _resume_previous_pose?(metadata, stored_pose)
+          metadata[:start_at] = stored_pose
+        end
+      end
+
+      if metadata[:start_at] != "0"
+        Util::Repo.load(metadata)
+      end
+
+      book.run(run, metadata)
+    end
+
+    def additional_metadata
+      {
+        layout_panes: {},
+        repo: {},
+        reverse: Util::Glue.new(false),
+        reversed: Util::Glue.new(false),
+      }
+    end
+
+    def _stored_position(metadata)
+      Runbook::Util::StoredPose.load(metadata)
+    end
+
+    def _resume_previous_pose?(metadata, pose)
+      return false if metadata[:auto] || metadata[:noop]
+      pose_msg = "Previous position detected: #{pose}"
+      metadata[:toolbox].output(pose_msg)
+      resume_msg = "Do you want to resume at this position?"
+      metadata[:toolbox].yes?(resume_msg)
+    end
+  end
+end

data/lib/runbook/runs/ssh_kit.rb

@@ -0,0 +1,193 @@
+module Runbook::Runs
+  module SSHKit
+    include Runbook::Run
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      include Runbook::Helpers::SSHKitHelper
+
+      def runbook__entities__step(object, metadata)
+        airbrussh_context = Runbook.configuration._airbrussh_context
+        airbrussh_context.set_current_task_name(object.title)
+        super
+      end
+
+      def runbook__statements__assert(object, metadata)
+        cmd_ssh_config = find_ssh_config(object, :cmd_ssh_config)
+
+        if metadata[:noop]
+          ssh_config_output = render_ssh_config_output(cmd_ssh_config)
+          metadata[:toolbox].output(ssh_config_output) unless ssh_config_output.empty?
+          interval_msg = "(running every #{object.interval} second(s))"
+          metadata[:toolbox].output("[NOOP] Assert: `#{object.cmd}` returns 0 #{interval_msg}")
+          if object.timeout > 0 || object.attempts > 0
+            timeout_msg = object.timeout > 0 ? "#{object.timeout} second(s)" : nil
+            attempts_msg = object.attempts > 0 ? "#{object.attempts} attempts" : nil
+            abort_msg = "after #{[timeout_msg, attempts_msg].compact.join(" or ")}, abort..."
+            metadata[:toolbox].output(abort_msg)
+            if object.abort_statement
+              object.abort_statement.parent = object.parent
+              object.abort_statement.run(self, metadata.dup)
+            end
+            metadata[:toolbox].output("and exit")
+          end
+          return
+        end
+
+        should_abort = false
+        test_args = ssh_kit_command(object.cmd, raw: object.cmd_raw)
+        test_options = ssh_kit_command_options(cmd_ssh_config)
+
+        with_ssh_config(cmd_ssh_config) do
+          time = Time.now
+          count = object.attempts
+          while !(test(*test_args, test_options))
+            if ((count -= 1) == 0)
+              should_abort = true
+              break
+            end
+
+            if (object.timeout > 0 && Time.now - time > object.timeout)
+              should_abort = true
+              break
+            end
+
+            sleep(object.interval)
+          end
+        end
+
+        if should_abort
+          error_msg = "Error! Assertion `#{object.cmd}` failed"
+          metadata[:toolbox].error(error_msg)
+          if object.abort_statement
+            object.abort_statement.parent = object.parent
+            object.abort_statement.run(self, metadata.dup)
+          end
+          raise Runbook::Runner::ExecutionError, error_msg
+        end
+      end
+
+      def runbook__statements__capture(object, metadata)
+        _handle_capture(object, metadata) do |ssh_config, capture_args, capture_options|
+          if (ssh_config[:servers].size > 1)
+            warn_msg = "Warning: `capture` does not support multiple servers. Use `capture_all` instead.\n"
+            metadata[:toolbox].warn(warn_msg)
+          end
+
+          result = ""
+          with_ssh_config(ssh_config) do
+            result = capture(*capture_args, capture_options)
+          end
+          result
+        end
+      end
+
+      def runbook__statements__capture_all(object, metadata)
+        _handle_capture(object, metadata) do |ssh_config, capture_args, capture_options|
+          result = {}
+          mutex = Mutex.new
+          with_ssh_config(ssh_config) do
+            hostname = self.host.hostname
+            capture_result = capture(*capture_args, capture_options)
+            mutex.synchronize { result[hostname] = capture_result }
+          end
+          result
+        end
+      end
+
+      def _handle_capture(object, metadata, &block)
+        ssh_config = find_ssh_config(object)
+
+        if metadata[:noop]
+          ssh_config_output = render_ssh_config_output(ssh_config)
+          metadata[:toolbox].output(ssh_config_output) unless ssh_config_output.empty?
+          metadata[:toolbox].output("[NOOP] Capture: `#{object.cmd}` into #{object.into}")
+          return
+        end
+
+        metadata[:toolbox].output("\n") # for formatting
+
+        capture_args = ssh_kit_command(object.cmd, raw: object.raw)
+        capture_options = ssh_kit_command_options(ssh_config)
+        capture_options[:strip] = object.strip
+        capture_options[:verbosity] = Logger::INFO
+
+        capture_msg = "Capturing output of `#{object.cmd}`\n\n"
+        metadata[:toolbox].output(capture_msg)
+
+        result = block.call(ssh_config, capture_args, capture_options)
+
+        target = object.parent.dsl
+        target.singleton_class.class_eval { attr_accessor object.into }
+        target.send("#{object.into}=".to_sym, result)
+      end
+
+      def runbook__statements__command(object, metadata)
+        ssh_config = find_ssh_config(object)
+
+        if metadata[:noop]
+          ssh_config_output = render_ssh_config_output(ssh_config)
+          metadata[:toolbox].output(ssh_config_output) unless ssh_config_output.empty?
+          metadata[:toolbox].output("[NOOP] Run: `#{object.cmd}`")
+          return
+        end
+
+        metadata[:toolbox].output("\n") # for formatting
+
+        execute_args = ssh_kit_command(object.cmd, raw: object.raw)
+        exec_options = ssh_kit_command_options(ssh_config)
+
+        with_ssh_config(ssh_config) do
+          execute(*execute_args, exec_options)
+        end
+      end
+
+      def runbook__statements__download(object, metadata)
+        ssh_config = find_ssh_config(object)
+
+        if metadata[:noop]
+          ssh_config_output = render_ssh_config_output(ssh_config)
+          metadata[:toolbox].output(ssh_config_output) unless ssh_config_output.empty?
+          options = object.options
+          to = " to #{object.to}" if object.to
+          opts = " with options #{options}" unless options == {}
+          noop_msg = "[NOOP] Download: #{object.from}#{to}#{opts}"
+          metadata[:toolbox].output(noop_msg)
+          return
+        end
+
+        metadata[:toolbox].output("\n") # for formatting
+
+        with_ssh_config(ssh_config) do
+          download!(object.from, object.to, object.options)
+        end
+      end
+
+      def runbook__statements__upload(object, metadata)
+        ssh_config = find_ssh_config(object)
+
+        if metadata[:noop]
+          ssh_config_output = render_ssh_config_output(ssh_config)
+          metadata[:toolbox].output(ssh_config_output) unless ssh_config_output.empty?
+          options = object.options
+          to = " to #{object.to}" if object.to
+          opts = " with options #{options}" unless options == {}
+          noop_msg = "[NOOP] Upload: #{object.from}#{to}#{opts}"
+          metadata[:toolbox].output(noop_msg)
+          return
+        end
+
+        metadata[:toolbox].output("\n") # for formatting
+
+        with_ssh_config(ssh_config) do
+          upload!(object.from, object.to, object.options)
+        end
+      end
+    end
+
+    extend ClassMethods
+  end
+end

data/lib/runbook/statement.rb

@@ -0,0 +1,20 @@
+module Runbook
+  class Statement < Node
+    include Runbook::Hooks::Invoker
+
+    def render(view, output, metadata)
+      invoke_with_hooks(view, self, output, metadata) do
+        view.render(self, output, metadata)
+      end
+    end
+
+    def run(run, metadata)
+      return if dynamic? && visited?
+
+      invoke_with_hooks(run, self, metadata) do
+        run.execute(self, metadata)
+      end
+      self.visited!
+    end
+  end
+end

data/lib/runbook/statements/ask.rb

@@ -0,0 +1,12 @@
+module Runbook::Statements
+  class Ask < Runbook::Statement
+    attr_reader :prompt, :into, :default, :echo
+
+    def initialize(prompt, into:, default: nil, echo: true)
+      @prompt = prompt
+      @into = into
+      @default = default
+      @echo = echo
+    end
+  end
+end

data/lib/runbook/statements/assert.rb

@@ -0,0 +1,34 @@
+module Runbook::Statements
+  class Assert < Runbook::Statement
+    attr_reader :cmd, :cmd_ssh_config, :cmd_raw
+    attr_reader :interval, :timeout, :attempts
+    attr_reader :abort_statement
+
+    def timeout_statement
+      Runbook.deprecator.deprecation_warning(:timeout_statement, :abort_statement)
+      @abort_statement
+    end
+
+    def initialize(
+      cmd,
+      cmd_ssh_config: nil,
+      cmd_raw: false,
+      interval: 1,
+      timeout: 0,
+      attempts: 0,
+      abort_statement: nil,
+      timeout_statement: nil
+    )
+      @cmd = cmd
+      @cmd_ssh_config = cmd_ssh_config
+      @cmd_raw = cmd_raw
+      @interval = interval
+      @timeout = timeout
+      @attempts = attempts
+      if timeout_statement
+        Runbook.deprecator.deprecation_warning(:timeout_statement, :abort_statement)
+      end
+      @abort_statement = abort_statement || timeout_statement
+    end
+  end
+end

data/lib/runbook/statements/capture.rb

@@ -0,0 +1,14 @@
+module Runbook::Statements
+  class Capture < Runbook::Statement
+    attr_reader :cmd, :into, :ssh_config, :raw, :strip
+
+    def initialize(cmd, into:, ssh_config: nil, raw: false, strip: true)
+      @cmd = cmd
+      @into = into
+      @ssh_config = ssh_config
+      @raw = raw
+      @strip = strip
+    end
+  end
+end
+

data/lib/runbook/statements/capture_all.rb

@@ -0,0 +1,14 @@
+module Runbook::Statements
+  class CaptureAll < Runbook::Statement
+    attr_reader :cmd, :into, :ssh_config, :raw, :strip
+
+    def initialize(cmd, into:, ssh_config: nil, raw: false, strip: true)
+      @cmd = cmd
+      @into = into
+      @ssh_config = ssh_config
+      @raw = raw
+      @strip = strip
+    end
+  end
+end
+

data/lib/runbook/statements/command.rb

@@ -0,0 +1,11 @@
+module Runbook::Statements
+  class Command < Runbook::Statement
+    attr_reader :cmd, :ssh_config, :raw
+
+    def initialize(cmd, ssh_config: nil, raw: false)
+      @cmd = cmd
+      @ssh_config = ssh_config
+      @raw = raw
+    end
+  end
+end

data/lib/runbook/statements/confirm.rb

@@ -0,0 +1,10 @@
+module Runbook::Statements
+  class Confirm < Runbook::Statement
+    attr_reader :prompt
+
+    def initialize(prompt)
+      @prompt = prompt
+    end
+  end
+end
+

data/lib/runbook/statements/description.rb

@@ -0,0 +1,9 @@
+module Runbook::Statements
+  class Description < Runbook::Statement
+    attr_reader :msg
+
+    def initialize(msg)
+      @msg = msg
+    end
+  end
+end

data/lib/runbook/statements/download.rb

@@ -0,0 +1,12 @@
+module Runbook::Statements
+  class Download < Runbook::Statement
+    attr_reader :from, :to, :options, :ssh_config
+
+    def initialize(from, to: nil, ssh_config: nil, options: {})
+      @from = from
+      @to = to
+      @ssh_config = ssh_config
+      @options = options
+    end
+  end
+end