runbook 0.12.1

data/lib/runbook/extensions/ssh_config.rb

@@ -0,0 +1,76 @@
+module Runbook::Extensions
+  module SSHConfig
+    def self.blank_ssh_config
+      {
+        servers: [],
+        parallelization: {},
+      }
+    end
+
+    def ssh_config
+      @ssh_config ||= Runbook::Extensions::SSHConfig.blank_ssh_config
+    end
+
+    module DSL
+      def ssh_config(&block)
+        config = Class.new do
+          attr_reader :dsl
+          prepend Runbook::Extensions::SSHConfig
+        end.new
+        dsl_class = Runbook::DSL.class(
+          Runbook::Extensions::SSHConfig::DSL,
+        )
+        config.instance_variable_set(:@dsl, dsl_class.new(config))
+        config.dsl.instance_eval(&block)
+        config.ssh_config
+      end
+
+      def parallelization(strategy: , limit: 2, wait: 2)
+        parent.ssh_config[:parallelization] = {
+          strategy: strategy,
+          limit: limit,
+          wait: wait,
+        }
+      end
+
+      def server(server)
+        parent.ssh_config[:servers].clear
+        parent.ssh_config[:servers] << server
+      end
+
+      def servers(*servers)
+        parent.ssh_config[:servers].clear
+        servers.flatten.each do |server|
+          parent.ssh_config[:servers] << server
+        end
+      end
+
+      def path(path)
+        parent.ssh_config[:path] = path
+      end
+
+      def user(user)
+        parent.ssh_config[:user] = user
+      end
+
+      def group(group)
+        parent.ssh_config[:group] = group
+      end
+
+      def env(env)
+        parent.ssh_config[:env] = env
+      end
+
+      def umask(umask)
+        parent.ssh_config[:umask] = umask
+      end
+    end
+  end
+
+  Runbook::Entities::Step.prepend(SSHConfig)
+  Runbook::Entities::Step::DSL.prepend(SSHConfig::DSL)
+  Runbook::Entities::Section.prepend(SSHConfig)
+  Runbook::Entities::Section::DSL.prepend(SSHConfig::DSL)
+  Runbook::Entities::Book.prepend(SSHConfig)
+  Runbook::Entities::Book::DSL.prepend(SSHConfig::DSL)
+end

data/lib/runbook/extensions/statements.rb

@@ -0,0 +1,26 @@
+module Runbook::Extensions
+  module Statements
+    module DSL
+      def method_missing(name, *args, &block)
+        if (klass = Statements::DSL._statement_class(name))
+          klass.new(*args, &block).tap do |statement|
+            parent.add(statement)
+          end
+        else
+          super
+        end
+      end
+
+      def respond_to?(name, include_private = false)
+        !!(Statements::DSL._statement_class(name) || super)
+      end
+
+      def self._statement_class(name)
+        "Runbook::Statements::#{name.to_s.camelize}".constantize
+      rescue NameError
+      end
+    end
+  end
+
+  Runbook::Entities::Step::DSL.prepend(Statements::DSL)
+end

data/lib/runbook/extensions/steps.rb

@@ -0,0 +1,14 @@
+module Runbook::Extensions
+  module Steps
+    module DSL
+      def step(title=nil, &block)
+        Runbook::Entities::Step.new(title).tap do |step|
+          parent.add(step)
+          step.dsl.instance_eval(&block) if block
+        end
+      end
+    end
+  end
+
+  Runbook::Entities::Section::DSL.prepend(Steps::DSL)
+end

data/lib/runbook/extensions/tmux.rb

@@ -0,0 +1,13 @@
+module Runbook::Extensions
+  module Tmux
+    module LayoutDSL
+      def layout(layout)
+        Runbook::Statements::Layout.new(layout).tap do |layout|
+          parent.add(layout)
+        end
+      end
+    end
+  end
+
+  Runbook::Entities::Book::DSL.prepend(Tmux::LayoutDSL)
+end

data/lib/runbook/helpers/format_helper.rb

@@ -0,0 +1,11 @@
+module Runbook::Helpers
+  module FormatHelper
+    def deindent(str, padding: 0)
+      lines = str.split("\n")
+      indentations = lines.map { |l| l.size - l.gsub(/^\s+/, "").size }
+      min_indentation = indentations.min
+      lines.map! { |line| " " * padding + line[min_indentation..-1] }
+      lines.join("\n")
+    end
+  end
+end

data/lib/runbook/helpers/ssh_kit_helper.rb

@@ -0,0 +1,143 @@
+module Runbook::Helpers
+  module SSHKitHelper
+    def ssh_kit_command(cmd, raw: false)
+      return [cmd] if raw
+      cmd, args = cmd.split(" ", 2)
+      [cmd.to_sym, args]
+    end
+
+    def ssh_kit_command_options(ssh_config)
+      {}.tap do |options|
+        if ssh_config[:user] && Runbook.configuration.enable_sudo_prompt
+          options[:interaction_handler] ||= ::SSHKit::Sudo::InteractionHandler.new
+        end
+      end
+    end
+
+    def find_ssh_config(object, ssh_config_method=:ssh_config)
+      blank_config = Runbook::Extensions::SSHConfig.blank_ssh_config
+      nil_or_blank = ->(config) { config.nil? || config == blank_config }
+      ssh_config = object.send(ssh_config_method)
+      return ssh_config unless nil_or_blank.call(ssh_config)
+      object = object.parent
+
+      while object
+        ssh_config = object.ssh_config
+        return ssh_config unless nil_or_blank.call(ssh_config)
+        object = object.parent
+      end
+
+      return blank_config
+    end
+
+    def render_ssh_config_output(ssh_config)
+      "".tap do |output|
+        if (servers = ssh_config[:servers]).any?
+          server_str = servers.join(", ")
+          if server_str.size > 80
+            server_str = "#{server_str[0..38]}...#{server_str[-38..-1]}"
+          end
+          output << "   on: #{server_str}\n"
+        end
+
+        if (strategy = ssh_config[:parallelization][:strategy])
+          limit = ssh_config[:parallelization][:limit]
+          wait = ssh_config[:parallelization][:wait]
+          in_str = "   in: #{strategy}"
+          in_str << ", limit: #{limit}" if strategy == :groups
+          in_str << ", wait: #{wait}" if [:sequence, :groups].include?(strategy)
+          output << "#{in_str}\n"
+        end
+
+        if ssh_config[:user] || ssh_config[:group]
+          user = ssh_config[:user]
+          group = ssh_config[:group]
+          as_str = "   as:"
+          as_str << " user: #{user}" if user
+          as_str << " group: #{group}" if group
+          output << "#{as_str}\n"
+        end
+
+        if (path = ssh_config[:path])
+          output << "   within: #{path}\n"
+        end
+
+        if (env = ssh_config[:env])
+          env_str = env.map do |k, v|
+            "#{k.to_s.upcase}=#{v}"
+          end.join(" ")
+          output << "   with: #{env_str}\n"
+        end
+
+        if (umask = ssh_config[:umask])
+          output << "   umask: #{umask}\n"
+        end
+      end
+    end
+
+    def with_ssh_config(ssh_config, &exec_block)
+      user = ssh_config[:user]
+      group = ssh_config[:group]
+      as_block =  _as_block(user, group, &exec_block)
+      within_block = _within_block(ssh_config[:path], &as_block)
+      with_block = _with_block(ssh_config[:env], &within_block)
+
+      _with_umask(ssh_config[:umask]) do
+        servers = _servers(ssh_config[:servers])
+        parallelization = ssh_config[:parallelization]
+        coordinator_options = _coordinator_options(parallelization)
+        SSHKit::Coordinator.new(servers).each(coordinator_options) do
+          instance_exec(&with_block)
+        end
+      end
+    end
+
+    def _servers(ssh_config_servers)
+      return :local if ssh_config_servers.empty?
+      return :local if ssh_config_servers == [:local]
+      ssh_config_servers
+    end
+
+    def _coordinator_options(ssh_config_parallelization)
+      ssh_config_parallelization.clone.tap do |options|
+        if options[:strategy]
+          options[:in] = options.delete(:strategy)
+        end
+      end
+    end
+
+    def _as_block(user, group, &block)
+      if user || group
+        -> { as({user: user, group: group}) { instance_exec(&block) } }
+      else
+        -> { instance_exec(&block) }
+      end
+    end
+
+    def _with_block(env, &block)
+      if env
+        -> { with(env) { instance_exec(&block) } }
+      else
+        -> { instance_exec(&block) }
+      end
+    end
+
+    def _within_block(path, &block)
+      if path
+        -> { within(path) { instance_exec(&block) } }
+      else
+        -> { instance_exec(&block) }
+      end
+    end
+
+    def _with_umask(umask, &block)
+      old_umask = SSHKit.config.umask
+      begin
+        SSHKit.config.umask = umask if umask
+        instance_exec(&block)
+      ensure
+        SSHKit.config.umask = old_umask
+      end
+    end
+  end
+end

data/lib/runbook/helpers/tmux_helper.rb

@@ -0,0 +1,174 @@
+module Runbook::Helpers
+  module TmuxHelper
+    def setup_layout(structure, runbook_title:)
+      _remove_stale_layouts
+      layout_file = _layout_file(_slug(runbook_title))
+      if File.exists?(layout_file)
+        stored_layout = ::YAML::load_file(layout_file)
+        if _all_panes_exist?(stored_layout)
+          return stored_layout
+        end
+      end
+
+      _setup_layout(structure).tap do |layout_panes|
+        File.open(layout_file, 'w') do |f|
+          f.write(layout_panes.to_yaml)
+        end
+      end
+    end
+
+    def send_keys(command, target)
+      `tmux send-keys -t #{target} #{_pager_escape_sequence} '#{command}' C-m`
+    end
+
+    def kill_all_panes(layout_panes)
+      runbook_pane = _runbook_pane
+      layout_panes.values.each do |pane_id|
+        _kill_pane(pane_id) unless pane_id == runbook_pane
+      end
+    end
+
+    def _pager_escape_sequence
+      "q C-u"
+    end
+
+    def _kill_pane(pane_id)
+      `tmux kill-pane -t #{pane_id}`
+    end
+
+    def _layout_file(runbook_title)
+      `tmux display-message -p -t $TMUX_PANE "#{Dir.tmpdir}/runbook_layout_\#{pid}_\#{session_name}_\#{pane_pid}_\#{pane_id}_#{runbook_title}.yml"`.strip
+    end
+
+    def _slug(title)
+      title.titleize.gsub(/\s+/, "").underscore.dasherize
+    end
+
+    def _all_panes_exist?(stored_layout)
+      (stored_layout.values - _session_panes).empty?
+    end
+
+    def _remove_stale_layouts
+      session_panes = _session_panes
+      session_layout_files = _session_layout_files
+      session_layout_files.each do |file|
+        File.delete(file) unless session_panes.any? { |pane| /_#{pane}_/ =~ file }
+      end
+    end
+
+    def _session_panes
+      `tmux list-panes -s -F '#D'`.split("\n")
+    end
+
+    def _session_layout_files
+      session_layout_glob = `tmux display-message -p "#{Dir.tmpdir}/runbook_layout_\#{pid}_\#{session_name}_*.yml"`.strip
+      Dir[session_layout_glob]
+    end
+
+    def _setup_layout(structure)
+      current_pane = _runbook_pane
+      panes_to_init = []
+      {}.tap do |layout_panes|
+        if structure.is_a?(Hash)
+          first_window = true
+          structure.each do |name, window|
+            if first_window
+              _rename_window(name)
+              first_window = false
+            else
+              current_pane = _new_window(name)
+            end
+            _setup_panes(layout_panes, panes_to_init, current_pane, window)
+          end
+        else
+          _setup_panes(layout_panes, panes_to_init, current_pane, structure)
+        end
+        _swap_runbook_pane(panes_to_init, layout_panes)
+        _initialize_panes(panes_to_init, layout_panes)
+      end
+    end
+
+    def _setup_panes(layout_panes, panes_to_init, current_pane, structure, depth=0)
+      return if structure.empty?
+      case structure
+      when Array
+        case structure.size
+        when 1
+          _setup_panes(layout_panes, panes_to_init, current_pane, structure.shift, depth+1)
+        else
+          size = 100 - 100 / structure.size
+          new_pane = _split(current_pane, depth, size)
+          _setup_panes(layout_panes, panes_to_init, current_pane, structure.shift, depth+1)
+          _setup_panes(layout_panes, panes_to_init, new_pane, structure, depth)
+        end
+      when Hash
+        if structure.values.all? { |v| v.is_a?(Numeric) }
+          total_size = structure.values.reduce(:+)
+          case structure.size
+          when 1
+            _setup_panes(layout_panes, panes_to_init, current_pane, structure.keys[0], depth+1)
+          else
+            size = (total_size - structure.values[0]) * 100 / total_size
+            new_pane = _split(current_pane, depth, size)
+            first_struct = structure.keys[0]
+            structure.delete(first_struct)
+            _setup_panes(layout_panes, panes_to_init, current_pane, first_struct, depth+1)
+            _setup_panes(layout_panes, panes_to_init, new_pane, structure, depth)
+          end
+        else
+          layout_panes[structure[:name]] = current_pane
+          panes_to_init << structure
+        end
+      when Symbol
+        layout_panes[structure] = current_pane
+      end
+    end
+
+    def _swap_runbook_pane(panes_to_init, layout_panes)
+      if (runbook_pane = panes_to_init.find { |pane| pane[:runbook_pane] })
+        current_runbook_pane_name = layout_panes.keys.find do |k|
+          layout_panes[k] == _runbook_pane
+        end
+        target_pane_id = layout_panes[runbook_pane[:name]]
+        layout_panes[runbook_pane[:name]] = _runbook_pane
+        layout_panes[current_runbook_pane_name] = target_pane_id
+        _swap_panes(target_pane_id, _runbook_pane)
+      end
+    end
+
+    def _initialize_panes(panes_to_init, layout_panes)
+      panes_to_init.each do |pane|
+        target = layout_panes[pane[:name]]
+        _set_directory(pane[:directory], target) if pane[:directory]
+        send_keys(pane[:command], target) if pane[:command]
+      end
+    end
+
+    def _runbook_pane
+      @runbook_pane ||= `tmux display-message -p '#D'`.strip
+    end
+
+    def _rename_window(name)
+      `tmux rename-window "#{name}"`
+    end
+
+    def _new_window(name)
+      `tmux new-window -n "#{name}" -P -F '#D' -d`.strip
+    end
+
+    def _split(current_pane, depth, size)
+      direction = depth.even? ? "h" : "v"
+      command = "tmux split-window"
+      args = "-#{direction} -t #{current_pane} -p #{size} -P -F '#D' -d"
+      `#{command} #{args}`.strip
+    end
+
+    def _swap_panes(target_pane, source_pane)
+      `tmux swap-pane -d -t #{target_pane} -s #{source_pane}`
+    end
+
+    def _set_directory(directory, target)
+      send_keys("cd #{directory}; clear", target)
+    end
+  end
+end

data/lib/runbook/hooks.rb

@@ -0,0 +1,88 @@
+module Runbook
+  module Hooks
+    def hooks
+      @hooks ||= []
+    end
+
+    def register_hook(name, type, klass, before: nil, &block)
+      hook = {
+        name: name,
+        type: type,
+        klass: klass,
+        block: block,
+      }
+
+      if before
+        hooks.insert(_hook_index(before), hook)
+      else
+        hooks << hook
+      end
+    end
+
+    def hooks_for(type, klass)
+      hooks.select do |hook|
+        hook[:type] == type && klass <= hook[:klass]
+      end
+    end
+
+    def _hook_index(hook_name)
+      hooks.index { |hook| hook[:name] == hook_name } || -1
+    end
+
+    module Invoker
+      def invoke_with_hooks(executor, object, *args, &block)
+        skip_before = skip_around = skip_after = false
+        if executor <= Runbook::Run
+          if executor.should_skip?(args[0])
+            if executor.start_at_is_substep?(object, args[0])
+              skip_before = skip_around = true
+            else
+              skip_before = skip_around = skip_after = true
+            end
+          end
+        end
+
+        unless skip_before
+          _execute_before_hooks(executor, object, *args)
+        end
+
+        if skip_around
+          block.call
+        else
+          _execute_around_hooks(executor, object, *args, &block)
+        end
+
+        unless skip_after
+          _execute_after_hooks(executor, object, *args)
+        end
+      end
+
+      def _execute_before_hooks(executor, object, *args)
+        executor.hooks_for(:before, object.class).each do |hook|
+          executor.instance_exec(object, *args, &hook[:block])
+        end
+      end
+
+      def _execute_around_hooks(executor, object, *args)
+        executor.hooks_for(:around, object.class).reverse.reduce(
+          -> (object, *args) {
+            yield
+          }
+        ) do |inner_method, hook|
+          -> (object, *args) {
+            inner_block = Proc.new do |object, *args|
+              inner_method.call(object, *args)
+            end
+            executor.instance_exec(object, *args, inner_block, &hook[:block])
+          }
+        end.call(object, *args)
+      end
+
+      def _execute_after_hooks(executor, object, *args)
+        executor.hooks_for(:after, object.class).each do |hook|
+          executor.instance_exec(object, *args, &hook[:block])
+        end
+      end
+    end
+  end
+end

data/lib/runbook/node.rb

@@ -0,0 +1,23 @@
+module Runbook
+  class Node
+    def initialize
+      raise "Should not be initialized"
+    end
+
+    def dynamic!
+      @dynamic = true
+    end
+
+    def visited!
+      @visited = true
+    end
+
+    def dynamic?
+      @dynamic
+    end
+
+    def visited?
+      @visited
+    end
+  end
+end