dk 0.0.1 → 0.1.0

data/lib/dk/has_the_stubs.rb

@@ -0,0 +1,116 @@
+require 'much-plugin'
+require 'dk/local'
+require 'dk/remote'
+
+module Dk
+
+  module HasTheStubs
+    include MuchPlugin
+
+    plugin_included do
+      include InstanceMethods
+
+    end
+
+    module InstanceMethods
+
+      # cmd stub api
+
+      def local_cmd_stubs
+        @local_cmd_stubs ||= []
+      end
+
+      def stub_cmd(cmd_str, args = nil, &block)
+        args ||= {}
+
+        cmd_str_proc    = get_cmd_ssh_proc(cmd_str)
+        input_proc      = get_cmd_ssh_proc(args[:input])
+        given_opts_proc = get_cmd_ssh_proc(args[:opts])
+
+        local_cmd_stubs.unshift(
+          Stub.new(cmd_str_proc, input_proc, given_opts_proc, block)
+        )
+      end
+
+      def unstub_all_cmds
+        local_cmd_stubs.clear
+      end
+
+      # ssh stub API
+
+      def remote_cmd_stubs
+        @remote_cmd_stubs ||= []
+      end
+
+      def stub_ssh(cmd_str, args = nil, &block)
+        args ||= {}
+
+        cmd_str_proc    = get_cmd_ssh_proc(cmd_str)
+        input_proc      = get_cmd_ssh_proc(args[:input])
+        given_opts_proc = get_cmd_ssh_proc(args[:opts])
+
+        remote_cmd_stubs.unshift(
+          Stub.new(cmd_str_proc, input_proc, given_opts_proc, block)
+        )
+      end
+
+      def unstub_all_ssh
+        remote_cmd_stubs.clear
+      end
+
+      private
+
+      def get_cmd_ssh_proc(obj)
+        obj.kind_of?(::Proc) ? obj : proc{ obj }
+      end
+
+      def find_cmd_ssh_stub_block(stubs, task, cmd_str, input, given_opts)
+        stub = stubs.find do |stub|
+          task.instance_eval(&stub.cmd_str_proc)    == cmd_str    &&
+          task.instance_eval(&stub.input_proc)      == input      &&
+          task.instance_eval(&stub.given_opts_proc) == given_opts
+        end
+        stub ? stub.block : nil
+      end
+
+      # if the cmd is stubbed, build a spy and apply the stub (or return the
+      # cached spy), otherwise let the runner decide how to handle the local
+      # cmd
+      def build_local_cmd(task, cmd_str, input, given_opts)
+        b = find_cmd_ssh_stub_block(local_cmd_stubs, task, cmd_str, input, given_opts)
+        if b
+          Local::CmdSpy.new(cmd_str, given_opts).tap(&b)
+        else
+          has_the_stubs_build_local_cmd(cmd_str, given_opts)
+        end
+      end
+
+      def has_the_stubs_build_local_cmd(cmd_str, given_opts)
+        raise NotImplementedError
+      end
+
+      # if the cmd is stubbed, build a spy and apply the stub (or return the
+      # cached spy), otherwise let the runner decide how to handle the remote
+      # cmd; when building the spy use the ssh opts, this allows stubbing and
+      # calling ssh cmds with the same opts but also allows building a valid
+      # remote cmd that has an ssh host
+      def build_remote_cmd(task, cmd_str, input, given_opts, ssh_opts)
+        b = find_cmd_ssh_stub_block(remote_cmd_stubs, task, cmd_str, input, given_opts)
+        if b
+          Remote::CmdSpy.new(cmd_str, ssh_opts).tap(&b)
+        else
+          has_the_stubs_build_remote_cmd(cmd_str, ssh_opts)
+        end
+      end
+
+      def has_the_stubs_build_remote_cmd(cmd_str, ssh_opts)
+        raise NotImplementedError
+      end
+
+    end
+
+    Stub = Struct.new(:cmd_str_proc, :input_proc, :given_opts_proc, :block)
+
+  end
+
+end

data/lib/dk/local.rb

@@ -0,0 +1,84 @@
+require 'scmd'
+
+module Dk; end
+module Dk::Local
+
+  class BaseCmd
+
+    attr_reader :scmd, :cmd_str
+
+    def initialize(scmd_or_spy_klass, cmd_str, opts)
+      opts ||= {}
+
+      @cmd_str = cmd_str
+      @scmd    = scmd_or_spy_klass.new(@cmd_str, :env => opts[:env])
+    end
+
+    def to_s; self.cmd_str; end
+
+    def run(input = nil)
+      @scmd.run(input)
+      self
+    end
+
+    def stdout;   @scmd.stdout;   end
+    def stderr;   @scmd.stderr;   end
+    def success?; @scmd.success?; end
+
+    def output_lines
+      build_stdout_lines(self.stdout) + build_stderr_lines(self.stderr)
+    end
+
+    private
+
+    def build_stdout_lines(stdout)
+      build_output_lines('stdout', stdout)
+    end
+
+    def build_stderr_lines(stderr)
+      build_output_lines('stderr', stderr)
+    end
+
+    def build_output_lines(name, output)
+      output.to_s.strip.split("\n").map{ |line| OutputLine.new(name, line) }
+    end
+
+    OutputLine = Struct.new(:name, :line)
+
+  end
+
+  class Cmd < BaseCmd
+
+    def initialize(cmd_str, opts = nil)
+      super(Scmd, cmd_str, opts)
+    end
+
+  end
+
+  class CmdSpy < BaseCmd
+
+    attr_reader :cmd_opts
+
+    def initialize(cmd_str, opts = nil)
+      require 'scmd/command_spy'
+      super(Scmd::CommandSpy, cmd_str, opts)
+      @cmd_opts = opts
+    end
+
+    def run_input
+      return nil unless self.run_called?
+      self.run_calls.first.input
+    end
+
+    def stdout=(value);     @scmd.stdout     = value; end
+    def stderr=(value);     @scmd.stderr     = value; end
+    def exitstatus=(value); @scmd.exitstatus = value; end
+
+    def run_calls;   @scmd.run_calls;   end
+    def run_called?; @scmd.run_called?; end
+
+    def ssh?; false; end
+
+  end
+
+end

data/lib/dk/null_logger.rb

@@ -0,0 +1,13 @@
+require 'logger'
+
+module Dk
+
+  class NullLogger
+
+    ::Logger::Severity.constants.each do |name|
+      define_method(name.downcase){ |*args| } # no-op
+    end
+
+  end
+
+end

data/lib/dk/remote.rb

@@ -0,0 +1,132 @@
+require 'dk/config'
+require 'dk/local'
+
+module Dk; end
+module Dk::Remote
+
+  def self.ssh_cmd_str(cmd_str, host, args, host_args)
+    host_args = host_args[host.to_s] if !host.nil?
+    val = "\"#{cmd_str.gsub(/\s+/, ' ')}\"".gsub("\\", "\\\\\\").gsub('"', '\"')
+    "ssh #{args} #{host_args} #{host} -- \"sh -c #{val}\""
+  end
+
+  class BaseCmd
+
+    attr_reader :hosts, :ssh_args, :host_ssh_args, :cmd_str, :local_cmds
+
+    def initialize(local_cmd_or_spy_klass, cmd_str, opts)
+      opts ||= {}
+      if nil_or_empty_or_missing_hosts(opts[:hosts])
+        raise NoHostsError, "no hosts to run cmd on (#{opts[:hosts].inspect})"
+      end
+
+      @hosts         = opts[:hosts].sort
+      @ssh_args      = opts[:ssh_args]      || Dk::Config::DEFAULT_SSH_ARGS.dup
+      @host_ssh_args = opts[:host_ssh_args] || Dk::Config::DEFAULT_HOST_SSH_ARGS.dup
+      @cmd_str       = cmd_str
+
+      @local_cmds = @hosts.inject({}) do |cmds, host|
+        cmds[host] = local_cmd_or_spy_klass.new(self.ssh_cmd_str(host), {
+          :env          => opts[:env],
+          :dry_tree_run => opts[:dry_tree_run]
+        })
+        cmds
+      end
+    end
+
+    def to_s; self.cmd_str; end
+
+    def ssh_cmd_str(host)
+      build_ssh_cmd_str(@cmd_str, host, @ssh_args, @host_ssh_args)
+    end
+
+    def run(input = nil)
+      self.hosts.each{ |host| @local_cmds[host].scmd.start(input) }
+      self.hosts.each{ |host| @local_cmds[host].scmd.wait }
+      self
+    end
+
+    def stdout
+      self.hosts.inject('') do |out, host|
+        out.empty? ? @local_cmds[host].stdout.to_s : out
+      end
+    end
+
+    def stderr
+      self.hosts.inject('') do |err, host|
+        err.empty? ? @local_cmds[host].stderr.to_s : err
+      end
+    end
+
+    def success?
+      self.hosts.inject(true) do |success, host|
+        success && @local_cmds[host].success?
+      end
+    end
+
+    def output_lines
+      self.hosts.inject([]) do |lines, host|
+        lines + build_output_lines(host, @local_cmds[host].output_lines)
+      end
+    end
+
+    private
+
+    def nil_or_empty_or_missing_hosts(h)
+      h.nil? ||
+      !h.respond_to?(:empty?) || h.empty? ||
+      !h.respond_to?(:select) || h.select(&:nil?).size > 0
+    end
+
+    # escape everything properly; run in sh to ensure full profile is loaded
+    def build_ssh_cmd_str(cmd_str, host, args, host_args)
+      Dk::Remote.ssh_cmd_str(cmd_str, host, args, host_args)
+    end
+
+    def build_output_lines(host, local_cmd_output_lines)
+      local_cmd_output_lines.map{ |ol| OutputLine.new(host, ol.name, ol.line) }
+    end
+
+    OutputLine = Struct.new(:host, :name, :line)
+
+  end
+
+  NoHostsError = Class.new(ArgumentError)
+
+  class Cmd < BaseCmd
+
+    def initialize(cmd_str, opts = nil)
+      super(Dk::Local::Cmd, cmd_str, opts)
+    end
+
+  end
+
+  class CmdSpy < BaseCmd
+
+    attr_reader :cmd_opts
+
+    def initialize(cmd_str, opts = nil)
+      super(Dk::Local::CmdSpy, cmd_str, opts)
+      @cmd_opts = opts
+      @first_local_cmd_spy = @local_cmds[@hosts.first]
+    end
+
+    def run_input
+      return nil unless self.run_called?
+      self.run_calls.first.input
+    end
+
+    # just set the first local cmd, this will have an overall effect
+    def stdout=(value);     @first_local_cmd_spy.stdout     = value; end
+    def stderr=(value);     @first_local_cmd_spy.stderr     = value; end
+    def exitstatus=(value); @first_local_cmd_spy.exitstatus = value; end
+
+    # just query the firs tlocal cmd - if run for one it was run for all
+    def run_calls;   @first_local_cmd_spy.scmd.start_calls;   end
+    def run_called?; @first_local_cmd_spy.scmd.start_called?; end
+
+    def ssh?; true; end
+
+  end
+
+end

data/lib/dk/runner.rb

@@ -0,0 +1,202 @@
+require 'benchmark'
+require 'set'
+require 'dk'
+require 'dk/ansi'
+require 'dk/config'
+require 'dk/has_set_param'
+require 'dk/has_ssh_opts'
+require 'dk/local'
+require 'dk/null_logger'
+require 'dk/remote'
+
+module Dk
+
+  class Runner
+    include Dk::HasSetParam
+    include Dk::HasSSHOpts
+
+    TASK_START_LOG_PREFIX  = ' >>>  '.freeze
+    TASK_END_LOG_PREFIX    = ' <<<  '.freeze
+    INDENT_LOG_PREFIX      = '      '.freeze
+    CMD_LOG_PREFIX         = '[CMD] '.freeze
+    SSH_LOG_PREFIX         = '[SSH] '.freeze
+    CMD_SSH_OUT_LOG_PREFIX = "> ".freeze
+
+    attr_reader :params, :logger
+
+    def initialize(opts = nil)
+      opts ||= {}
+      @params = Hash.new{ |h, k| raise Dk::NoParamError, "no param named `#{k}`" }
+      @params.merge!(dk_normalize_params(opts[:params]))
+
+      d = Config::DEFAULT_CALLBACKS
+      @task_callbacks = {
+        'before'         => opts[:before_callbacks]         || d.dup,
+        'prepend_before' => opts[:prepend_before_callbacks] || d.dup,
+        'after'          => opts[:after_callbacks]          || d.dup,
+        'prepend_after'  => opts[:prepend_after_callbacks]  || d.dup
+      }
+
+      @ssh_hosts     = opts[:ssh_hosts]     || Config::DEFAULT_SSH_HOSTS.dup
+      @ssh_args      = opts[:ssh_args]      || Config::DEFAULT_SSH_ARGS.dup
+      @host_ssh_args = opts[:host_ssh_args] || Config::DEFAULT_HOST_SSH_ARGS.dup
+
+      @logger = opts[:logger] || NullLogger.new
+
+      @has_run_task_classes = Set.new
+    end
+
+    def task_callbacks(named, task_class)
+      @task_callbacks[named][task_class] || []
+    end
+
+    def task_callback_task_classes(named, task_class)
+      task_callbacks(named, task_class).map(&:task_class)
+    end
+
+    def add_task_callback(named, subject_task_class, callback_task_class, params)
+      @task_callbacks[named][subject_task_class] << Task::Callback.new(
+        callback_task_class,
+        params
+      )
+    end
+
+    # called by CLI on top-level tasks
+    def run(task_class, params = nil)
+      check_run_once_and_build_and_run_task(task_class, params)
+    end
+
+    # called by other tasks on sub-tasks
+    def run_task(task_class, params = nil)
+      check_run_once_and_build_and_run_task(task_class, params)
+    end
+
+    def log_info(msg, *ansi_styles)
+      self.logger.info("#{INDENT_LOG_PREFIX}#{Ansi.styled_msg(msg, *ansi_styles)}")
+    end
+
+    def log_debug(msg, *ansi_styles)
+      self.logger.debug("#{INDENT_LOG_PREFIX}#{Ansi.styled_msg(msg, *ansi_styles)}")
+    end
+
+    def log_error(msg, *ansi_styles)
+      self.logger.error("#{INDENT_LOG_PREFIX}#{Ansi.styled_msg(msg, *ansi_styles)}")
+    end
+
+    def log_task_run(task_class, &run_block)
+      self.logger.debug "#{TASK_START_LOG_PREFIX}#{task_class}"
+      time = Benchmark.realtime(&run_block)
+      self.logger.debug "#{TASK_END_LOG_PREFIX}#{task_class} (#{self.pretty_run_time(time)})"
+    end
+
+    def log_cli_task_run(task_name, &run_block)
+      self.logger.info "Starting `#{task_name}`."
+      time = Benchmark.realtime(&run_block)
+      self.logger.info "`#{task_name}` finished in #{self.pretty_run_time(time)}."
+      self.logger.info ""
+      self.logger.info ""
+    end
+
+    def log_cli_run(cli_argv, &run_block)
+      15.times{ self.logger.debug "" }
+      self.logger.debug "===================================="
+      self.logger.debug ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> `#{cli_argv}`"
+      self.logger.debug "===================================="
+      time = Benchmark.realtime(&run_block)
+      self.logger.info "(#{self.pretty_run_time(time)})"
+      self.logger.debug "===================================="
+      self.logger.debug "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< `#{cli_argv}`"
+      self.logger.debug "===================================="
+    end
+
+    def cmd(task, cmd_str, input, given_opts)
+      build_and_run_local_cmd(task, cmd_str, input, given_opts)
+    end
+
+    def ssh(task, cmd_str, input, given_opts, ssh_opts)
+      build_and_run_remote_cmd(task, cmd_str, input, given_opts, ssh_opts)
+    end
+
+    def has_run_task?(task_class)
+      @has_run_task_classes.include?(task_class)
+    end
+
+    def pretty_run_time(raw_run_time)
+      if raw_run_time > 1.5 # seconds
+        "#{raw_run_time.to_i / 60}:#{(raw_run_time.round % 60).to_i.to_s.rjust(2, '0')}s"
+      else
+        "#{(raw_run_time * 1000 * 10.0).round / 10.0}ms"
+      end
+    end
+
+    private
+
+    def check_run_once_and_build_and_run_task(task_class, params = nil)
+      if task_class.run_only_once && self.has_run_task?(task_class)
+        build_task(task_class, params)
+      else
+        build_and_run_task(task_class, params)
+      end
+    end
+
+    def build_and_run_task(task_class, params = nil)
+      build_task(task_class, params).tap do |task|
+        task.dk_run
+        @has_run_task_classes << task_class
+      end
+    end
+
+    def build_task(task_class, params = nil)
+      task_class.new(self, params)
+    end
+
+    def build_and_run_local_cmd(task, cmd_str, input, given_opts)
+      local_cmd = build_local_cmd(task, cmd_str, input, given_opts)
+      log_local_cmd(local_cmd){ |cmd| cmd.run(input) }
+    end
+
+    # input is needed for the `TestRunner` so it can use it with stubbing
+    # otherwise it is ignored when building a local cmd
+    def build_local_cmd(task, cmd_str, input, given_opts)
+      Local::Cmd.new(cmd_str, given_opts)
+    end
+
+    def log_local_cmd(cmd, &block)
+      self.logger.info("#{CMD_LOG_PREFIX}#{cmd.cmd_str}")
+      time = Benchmark.realtime{ block.call(cmd) }
+      self.logger.info("#{INDENT_LOG_PREFIX}(#{self.pretty_run_time(time)})")
+      cmd.output_lines.each do |output_line|
+        self.logger.debug("#{INDENT_LOG_PREFIX}#{CMD_SSH_OUT_LOG_PREFIX}#{output_line.line}")
+      end
+      cmd
+    end
+
+    def build_and_run_remote_cmd(task, cmd_str, input, given_opts, ssh_opts)
+      remote_cmd = build_remote_cmd(task, cmd_str, input, given_opts, ssh_opts)
+      log_remote_cmd(remote_cmd){ |cmd| cmd.run(input) }
+    end
+
+    # input and given opts are needed for the `TestRunner` so it can use it with
+    # stubbing otherwise they are ignored when building a remote cmd
+    def build_remote_cmd(task, cmd_str, input, given_opts, ssh_opts)
+      Remote::Cmd.new(cmd_str, ssh_opts)
+    end
+
+    def log_remote_cmd(cmd, &block)
+      self.logger.info("#{SSH_LOG_PREFIX}#{cmd.cmd_str}")
+      self.logger.debug("#{INDENT_LOG_PREFIX}#{cmd.ssh_cmd_str('<host>')}")
+      cmd.hosts.each do |host|
+        self.logger.info("#{INDENT_LOG_PREFIX}[#{host}]")
+      end
+      time = Benchmark.realtime{ block.call(cmd) }
+      self.logger.info("#{INDENT_LOG_PREFIX}(#{self.pretty_run_time(time)})")
+      cmd.output_lines.each do |ol|
+        self.logger.debug "#{INDENT_LOG_PREFIX}[#{ol.host}] " \
+                          "#{CMD_SSH_OUT_LOG_PREFIX}#{ol.line}"
+      end
+      cmd
+    end
+
+  end
+
+end