dk 0.0.1 → 0.1.0

data/lib/dk/task.rb

@@ -0,0 +1,266 @@
+require 'much-plugin'
+require 'dk'
+require 'dk/remote'
+require 'dk/runner'
+
+module Dk
+
+  module Task
+    include MuchPlugin
+
+    class ParamsHash < Hash
+      def try_param(key)
+        begin; self.[](key); rescue Dk::NoParamError; nil; end
+      end
+    end
+
+    plugin_included do
+      include InstanceMethods
+      extend ClassMethods
+
+    end
+
+    module InstanceMethods
+
+      def initialize(runner, params = nil)
+        params ||= {}
+        @dk_runner = runner
+        @dk_params = ParamsHash.new{ |h, k| @dk_runner.params[k] }
+        @dk_params.merge!(params)
+      end
+
+      def dk_run
+        self.dk_run_callbacks 'before'
+        @dk_runner.log_task_run(self.class) do
+          catch(:halt){ self.run! }
+        end
+        self.dk_run_callbacks 'after'
+      end
+
+      def run!
+        raise NotImplementedError
+      end
+
+      def dk_run_callbacks(named)
+        callbacks = CallbackSet.new
+        callbacks.add_callbacks(@dk_runner.task_callbacks("prepend_#{named}", self.class))
+        callbacks.add_callbacks(self.class.send("#{named}_callbacks") || [])
+        callbacks.add_callbacks(@dk_runner.task_callbacks(named, self.class))
+        callbacks.each{ |c| run_task(c.task_class, c.params) }
+      end
+
+      def dk_dsl_ssh_hosts
+        @dk_dsl_ssh_hosts ||= self.instance_eval(&self.class.ssh_hosts)
+      end
+
+      def ==(other_task)
+        self.class == other_task.class
+      end
+
+      private
+
+      # Helpers
+
+      def run_task(task_class, params = nil)
+        @dk_runner.run_task(task_class, params)
+      end
+
+      def cmd(cmd_str, *args)
+        given_opts = args.last.kind_of?(::Hash) ? args.pop : nil
+        input      = args.last
+        @dk_runner.cmd(self, cmd_str, input, given_opts)
+      end
+
+      def cmd!(cmd_str, *args)
+        cmd = cmd(cmd_str, *args)
+        if !cmd.success?
+          raise CmdRunError, "error running `#{cmd.cmd_str}`", caller
+        end
+        cmd
+      end
+
+      def ssh(cmd_str, *args)
+        given_opts = args.last.kind_of?(::Hash) ? args.pop : nil
+        input      = args.last
+        @dk_runner.ssh(self, cmd_str, input, given_opts, dk_build_ssh_opts(given_opts))
+      end
+
+      def ssh!(cmd_str, *args)
+        cmd = ssh(cmd_str, *args)
+        if !cmd.success?
+          raise SSHRunError, "error running `#{cmd.cmd_str}` over ssh", caller
+        end
+        cmd
+      end
+
+      def params
+        @dk_params
+      end
+
+      def set_param(key, value)
+        @dk_runner.set_param(key, value)
+      end
+
+      def param?(key)
+        @dk_params.key?(key) || @dk_runner.params.key?(key)
+      end
+
+      def try_param(key)
+        @dk_params.try_param(key)
+      end
+
+      def before(subject, callback, params = nil)
+        @dk_runner.add_task_callback('before', subject, callback, params)
+      end
+
+      def prepend_before(subject, callback, params = nil)
+        @dk_runner.add_task_callback('prepend_before', subject, callback, params)
+      end
+
+      def after(subject, callback, params = nil)
+        @dk_runner.add_task_callback('after', subject, callback, params)
+      end
+
+      def prepend_after(subject, callback, params = nil)
+        @dk_runner.add_task_callback('prepend_after', subject, callback, params)
+      end
+
+      def ssh_hosts(group_name = nil, *values)
+        @dk_runner.ssh_hosts(group_name, *values)
+      end
+
+      def ssh_cmd_str(cmd_str, opts = nil)
+        opts ||= {}
+        Remote.ssh_cmd_str(
+          cmd_str,
+          opts[:host].to_s,
+          dk_lookup_ssh_args(opts[:ssh_args]),
+          dk_lookup_host_ssh_args(opts[:host_ssh_args])
+        )
+      end
+
+      def halt
+        throw :halt
+      end
+
+      def log_info(msg, *styles);  @dk_runner.log_info(msg, *styles);  end
+      def log_debug(msg, *styles); @dk_runner.log_debug(msg, *styles); end
+      def log_error(msg, *styles); @dk_runner.log_error(msg, *styles); end
+
+      def dk_build_ssh_opts(opts)
+        opts ||= {}
+        opts.merge({
+          :hosts         => dk_lookup_ssh_hosts(opts[:hosts]),
+          :ssh_args      => dk_lookup_ssh_args(opts[:ssh_args]),
+          :host_ssh_args => dk_lookup_host_ssh_args(opts[:host_ssh_args])
+        })
+      end
+
+      def dk_lookup_ssh_hosts(opts_hosts)
+        [*(
+          ssh_hosts[opts_hosts] ||
+          opts_hosts ||
+          ssh_hosts[self.dk_dsl_ssh_hosts] ||
+          self.dk_dsl_ssh_hosts
+        )]
+      end
+
+      def dk_lookup_ssh_args(opts_args)
+        opts_args || @dk_runner.ssh_args
+      end
+
+      def dk_lookup_host_ssh_args(opts_args)
+        opts_args || @dk_runner.host_ssh_args
+      end
+
+    end
+
+    CmdRunError = Class.new(RuntimeError)
+    SSHRunError = Class.new(RuntimeError)
+
+    module ClassMethods
+
+      def description(value = nil)
+        @description = value.to_s if !value.nil?
+        @description
+      end
+      alias_method :desc, :description
+
+      def before_callbacks; @before_callbacks ||= CallbackSet.new; end
+      def after_callbacks;  @after_callbacks  ||= CallbackSet.new; end
+
+      def before_callback_task_classes; self.before_callbacks.map(&:task_class); end
+      def after_callback_task_classes;  self.after_callbacks.map(&:task_class);  end
+
+      def before(task_class, params = nil)
+        self.before_callbacks << Callback.new(task_class, params)
+      end
+
+      def after(task_class, params = nil)
+        self.after_callbacks << Callback.new(task_class, params)
+      end
+
+      def prepend_before(task_class, params = nil)
+        self.before_callbacks.unshift(Callback.new(task_class, params))
+      end
+
+      def prepend_after(task_class, params = nil)
+        self.after_callbacks.unshift(Callback.new(task_class, params))
+      end
+
+      def ssh_hosts(value = nil, &block)
+        @ssh_hosts = block || proc{ value } if !block.nil? || !value.nil?
+        @ssh_hosts || proc{}
+      end
+
+      def run_only_once(value = nil)
+        @run_only_once = !!value if !value.nil?
+        @run_only_once
+      end
+
+    end
+
+    Callback = Struct.new(:task_class, :params)
+
+    class CallbackSet < ::Array
+
+      def <<(callback);      super unless self.include?(callback); end
+      def unshift(callback); super unless self.include?(callback); end
+
+      def add_callbacks(callbacks)
+        callbacks.each{ |cb| self.<<(cb) }
+      end
+
+    end
+
+    module TestHelpers
+      include MuchPlugin
+
+      plugin_included do
+        require 'dk/test_runner'
+        include InstanceMethods
+      end
+
+      module InstanceMethods
+
+        def test_runner(task_class, args = nil)
+          Dk::TestRunner.new(args).tap do |runner|
+            runner.task_class = task_class
+          end
+        end
+
+        def test_task(task_class, args = nil)
+          test_runner(task_class, args).task
+        end
+
+        def ssh_cmd_str(task, *args)
+          task.instance_eval{ ssh_cmd_str(*args) }
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/dk/task_run.rb

@@ -0,0 +1,17 @@
+require 'dk/has_the_runs'
+
+module Dk
+
+  class TaskRun
+    include HasTheRuns
+
+    attr_reader :task_class, :params
+
+    def initialize(task_class, params)
+      @task_class = task_class
+      @params     = params
+    end
+
+  end
+
+end

data/lib/dk/test_runner.rb

@@ -0,0 +1,54 @@
+require 'dk/has_the_runs'
+require 'dk/has_the_stubs'
+require 'dk/local'
+require 'dk/remote'
+require 'dk/runner'
+require 'dk/task_run'
+
+module Dk
+
+  class TestRunner < Runner
+    include HasTheRuns
+    include HasTheStubs
+
+    attr_accessor :task_class
+
+    # test runners are designed to only run their task
+    def run(params = nil)
+      self.task(params).tap(&:dk_run)
+    end
+
+    # don't run any sub-tasks, just track that a sub-task was run
+    def run_task(task_class, params = nil)
+      TaskRun.new(task_class, params).tap{ |tr| self.runs << tr }
+    end
+
+    # track that a local cmd was run
+    def cmd(task, cmd_str, input, given_opts)
+      super(task, cmd_str, input, given_opts).tap{ |c| self.runs << c }
+    end
+
+    # track that a remote cmd was run
+    def ssh(task, cmd_str, input, given_opts, ssh_opts)
+      super(task, cmd_str, input, given_opts, ssh_opts).tap{ |c| self.runs << c }
+    end
+
+    # test task API
+
+    def task(params = nil)
+      @task ||= build_task(self.task_class, params)
+    end
+
+    private
+
+    def has_the_stubs_build_local_cmd(cmd_str, given_opts)
+      Local::CmdSpy.new(cmd_str, given_opts)
+    end
+
+    def has_the_stubs_build_remote_cmd(cmd_str, ssh_opts)
+      Remote::CmdSpy.new(cmd_str, ssh_opts)
+    end
+
+  end
+
+end

data/lib/dk/tree_runner.rb

@@ -0,0 +1,64 @@
+require 'dk/dry_runner'
+require 'dk/has_the_runs'
+require 'dk/null_logger'
+require 'dk/task_run'
+
+module Dk
+
+  class TreeRunner < DryRunner
+    include HasTheRuns
+
+    LEVEL_PREFIX = '    '.freeze
+    LEVEL_BULLET = '|-- '.freeze
+
+    def initialize(config, kernel)
+      super(config, :logger => NullLogger.new) # disable any logging
+
+      @task_run_stack = [self]
+      @run_num        = 0
+      @kernel         = kernel
+    end
+
+    def run(*args)
+      # wipe the task runs before every run; that way `output_task_runs` outputs
+      # just this run's task runs
+      self.runs.clear
+
+      # increment the run num and run the task
+      @run_num += 1
+      task = super
+
+      # recursively output the task runs in a tree format
+      output_task_runs(self.runs, 0, "#{@run_num}) ".rjust(LEVEL_PREFIX.size, ' '))
+
+      # return the top-level task that was run
+      task
+    end
+
+    private
+
+    # track all task runs
+    def build_and_run_task(task_class, params = nil)
+      task_run = TaskRun.new(task_class, params)
+      @task_run_stack.last.runs << task_run
+
+      @task_run_stack.push(task_run)
+      task = super(task_class, params)
+      @task_run_stack.pop
+      task
+    end
+
+    def output_task_runs(runs, level, prefix = nil)
+      runs.each do |task_run|
+        # recursively output the prefix and task class on indented, bulleted lines
+        @kernel.puts "#{LEVEL_PREFIX*level}" \
+                     "#{LEVEL_BULLET if level > 0}" \
+                     "#{prefix}#{task_run.task_class}"
+        output_task_runs(task_run.runs, level+1)
+      end
+
+    end
+
+  end
+
+end

data/lib/dk/version.rb

@@ -1,3 +1,3 @@
 module Dk
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/dk.rb

@@ -1,4 +1,26 @@
-require "dk/version"
+require 'dk/version'
+require 'dk/config'
+require 'dk/task'
 
 module Dk
+
+  def self.config
+    @config ||= Config.new
+  end
+
+  def self.configure(&block)
+    self.config.init_procs << block
+  end
+
+  def self.init
+    self.config.init
+  end
+
+  def self.reset
+    @config = Config.new
+  end
+
+  NoticeError  = Class.new(RuntimeError)
+  NoParamError = Class.new(ArgumentError)
+
 end

data/test/helper.rb

@@ -2,13 +2,18 @@
 # put any test helpers here
 
 # add the root dir to the load path
-$LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
+require 'pathname'
+ROOT_PATH = Pathname.new(File.expand_path("../..", __FILE__))
+$LOAD_PATH.unshift(ROOT_PATH)
 
 # require pry for debugging (`binding.pry`)
 require 'pry'
 
 require 'test/support/factory'
 
+# put scmd in test mode
+ENV['SCMD_TEST_MODE'] = '1'
+
 # 1.8.7 backfills
 
 # Array#sample

data/test/support/config/dk.rb

@@ -0,0 +1,7 @@
+require 'dk'
+require 'test/support/config/task_defs'
+
+Dk.configure do
+  task 'cli-test-task',  CLITestTask
+  task 'cli-other-task', CLIOtherTask
+end

data/test/support/config/task_defs.rb

@@ -0,0 +1,10 @@
+class CLITestTask
+  include Dk::Task
+
+end
+
+class CLIOtherTask
+  include Dk::Task
+
+end
+

data/test/support/factory.rb

@@ -3,4 +3,42 @@ require 'assert/factory'
 module Factory
   extend Assert::Factory
 
+  def self.ssh_cmd_opts
+    cmd_opts = { Factory.string => Factory.string }
+    # optionally have these options, this will ensure the default ssh cmd opts
+    # are used if these aren't provided
+    if Factory.boolean
+      cmd_opts.merge!({
+        :hosts         => Factory.hosts,
+        :ssh_args      => Factory.string,
+        :host_ssh_args => { Factory.string => Factory.string }
+      })
+    end
+    cmd_opts
+  end
+
+  def self.stdout
+    Factory.integer(3).times.map{ Factory.string }.join("\n")
+  end
+
+  def self.stderr
+    Factory.integer(3).times.map{ Factory.string }.join("\n")
+  end
+
+  def self.exitstatus
+    [0, 1].sample
+  end
+
+  def self.hosts
+    Factory.integer(3).times.map{ "#{Factory.string}.example.com" }
+  end
+
+  def self.log_file
+    ROOT_PATH.join("test/support/log/#{Factory.string}.txt")
+  end
+
+  def self.task_callback(task_class, params = nil)
+    Dk::Task::Callback.new(task_class, params || {})
+  end
+
 end