dk 0.0.1 → 0.1.0

data/lib/dk/ansi.rb

@@ -0,0 +1,98 @@
+module Dk
+
+  module Ansi
+
+    def self.styled_msg(msg, *styles)
+      code = self.code_for(*styles)
+      return msg if code.empty?
+      code + msg + self.code_for(:reset)
+    end
+
+    def self.code_for(*style_names)
+      style_names.map{ |n| "\e[#{CODES[n]}m" if CODES.key?(n) }.compact.join('')
+    end
+
+    # Table of supported styles/codes (http://en.wikipedia.org/wiki/ANSI_escape_code)
+
+    CODES = {
+      :clear            => 0,
+      :reset            => 0,
+      :bright           => 1,
+      :bold             => 1,
+      :faint            => 2,
+      :dark             => 2,
+      :italic           => 3,
+      :underline        => 4,
+      :underscore       => 4,
+      :blink            => 5,
+      :slow_blink       => 5,
+      :rapid            => 6,
+      :rapid_blink      => 6,
+      :invert           => 7,
+      :inverse          => 7,
+      :reverse          => 7,
+      :negative         => 7,
+      :swap             => 7,
+      :conceal          => 8,
+      :concealed        => 8,
+      :hide             => 9,
+      :strike           => 9,
+
+      :default_font     => 10,
+      :font_default     => 10,
+      :font0            => 10,
+      :font1            => 11,
+      :font2            => 12,
+      :font3            => 13,
+      :font4            => 14,
+      :font5            => 15,
+      :font6            => 16,
+      :font7            => 17,
+      :font8            => 18,
+      :font9            => 19,
+      :fraktur          => 20,
+      :bright_off       => 21,
+      :bold_off         => 21,
+      :double_underline => 21,
+      :clean            => 22,
+      :italic_off       => 23,
+      :fraktur_off      => 23,
+      :underline_off    => 24,
+      :blink_off        => 25,
+      :inverse_off      => 26,
+      :positive         => 26,
+      :conceal_off      => 27,
+      :show             => 27,
+      :reveal           => 27,
+      :crossed_off      => 29,
+      :crossed_out_off  => 29,
+
+      :black            => 30,
+      :red              => 31,
+      :green            => 32,
+      :yellow           => 33,
+      :blue             => 34,
+      :magenta          => 35,
+      :cyan             => 36,
+      :white            => 37,
+
+      :on_black         => 40,
+      :on_red           => 41,
+      :on_green         => 42,
+      :on_yellow        => 43,
+      :on_blue          => 44,
+      :on_magenta       => 45,
+      :on_cyan          => 46,
+      :on_white         => 47,
+
+      :frame            => 51,
+      :encircle         => 52,
+      :overline         => 53,
+      :frame_off        => 54,
+      :encircle_off     => 54,
+      :overline_off     => 55,
+    }
+
+  end
+
+end

data/lib/dk/cli.rb

@@ -0,0 +1,173 @@
+require 'dk'
+require 'dk/dk_runner'
+require 'dk/dry_runner'
+require 'dk/tree_runner'
+require 'dk/version'
+
+module Dk
+
+  class CLI
+
+    DEFAULT_CONFIG_PATH = 'config/dk.rb'.freeze
+
+    def self.run(args)
+      self.new.run(*args)
+    end
+
+    attr_reader :clirb
+
+    def initialize(kernel = nil)
+      @kernel = kernel || Kernel
+
+      load config_path
+      Dk.init
+      @config = Dk.config
+
+      @clirb = CLIRB.new do
+        option 'list-tasks', 'list all tasks available to run', {
+          :abbrev => 'T'
+        }
+        option 'dry-run', 'run the tasks without executing any local/remote cmds'
+        option 'tree',    'print out the tree of tasks/sub-tasks that would be run'
+        option 'verbose', 'run tasks showing verbose (ie debug log level) details'
+      end
+    end
+
+    def run(*args)
+      begin
+        run!(*args)
+      rescue ShowTaskList
+        @kernel.puts task_list
+      rescue CLIRB::HelpExit
+        @kernel.puts help
+      rescue CLIRB::VersionExit
+        @kernel.puts Dk::VERSION
+      rescue CLIRB::Error, Dk::Config::UnknownTaskError => exception
+        @kernel.puts help
+        @kernel.puts "\n\n#{exception.message}\n"
+        @kernel.exit 1
+      rescue Dk::NoticeError => exception
+        @kernel.puts "\n\n#{exception.message}\n\n"
+        @kernel.puts exception.backtrace.first
+        @kernel.exit 1
+      rescue StandardError => exception
+        @kernel.puts "\n\n#{exception.class}: #{exception.message}"
+        @kernel.puts exception.backtrace.join("\n")
+        @kernel.exit 1
+      end
+      @kernel.exit 0
+    end
+
+    private
+
+    def run!(*args)
+      @clirb.parse!(args)
+      raise ShowTaskList if @clirb.opts['list-tasks']
+
+      @config.stdout_log_level('debug') if @clirb.opts['verbose']
+
+      unknowns = @clirb.args.select{ |name| !@config.tasks.keys.include?(name) }
+      if !unknowns.empty?
+        raise Dk::Config::UnknownTaskError, unknowns.map{ |u| "`#{u}`"}.join(', ')
+      end
+
+      runner = get_runner(@config, @clirb.opts)
+      runner.log_cli_run(args.join(' ')) do
+        @clirb.args.each do |task_name|
+          runner.log_cli_task_run(task_name) do
+            runner.run(@config.task(task_name))
+          end
+        end
+      end
+    end
+
+    def help
+      "Usage: dk [TASKS] [options]\n\n" \
+      "Tasks:\n" \
+      "#{task_list('    ')}\n\n" \
+      "Options: #{@clirb}"
+    end
+
+    def task_list(prefix = '')
+      max_name_width = @config.tasks.keys.map(&:size).max
+      items = @config.tasks.map do |(name, task_class)|
+        "#{prefix}#{name.ljust(max_name_width)} # #{task_class.description}"
+      end
+      items.sort.join("\n")
+    end
+
+    def config_path
+      File.expand_path(ENV['DK_CONFIG'] || DEFAULT_CONFIG_PATH, ENV['PWD'])
+    end
+
+    def get_runner(config, opts)
+      return Dk::DryRunner.new(config) if opts['dry-run']
+
+      if opts['tree']
+        @kernel.puts "building task tree#{'s' if @clirb.args.size > 1}..."
+        return Dk::TreeRunner.new(config, @kernel)
+      end
+
+      Dk::DkRunner.new(config)
+    end
+
+    ShowTaskList = Class.new(RuntimeError)
+
+  end
+
+  class CLIRB  # Version 1.0.0, https://github.com/redding/cli.rb
+    Error    = Class.new(RuntimeError);
+    HelpExit = Class.new(RuntimeError); VersionExit = Class.new(RuntimeError)
+    attr_reader :argv, :args, :opts, :data
+
+    def initialize(&block)
+      @options = []; instance_eval(&block) if block
+      require 'optparse'
+      @data, @args, @opts = [], [], {}; @parser = OptionParser.new do |p|
+        p.banner = ''; @options.each do |o|
+          @opts[o.name] = o.value; p.on(*o.parser_args){ |v| @opts[o.name] = v }
+        end
+        p.on_tail('--version', ''){ |v| raise VersionExit, v.to_s }
+        p.on_tail('--help',    ''){ |v| raise HelpExit,    v.to_s }
+      end
+    end
+
+    def option(*args); @options << Option.new(*args); end
+    def parse!(argv)
+      @args = (argv || []).dup.tap do |args_list|
+        begin; @parser.parse!(args_list)
+        rescue OptionParser::ParseError => err; raise Error, err.message; end
+      end; @data = @args + [@opts]
+    end
+    def to_s; @parser.to_s; end
+    def inspect
+      "#<#{self.class}:#{'0x0%x' % (object_id << 1)} @data=#{@data.inspect}>"
+    end
+
+    class Option
+      attr_reader :name, :opt_name, :desc, :abbrev, :value, :klass, :parser_args
+
+      def initialize(name, *args)
+        settings, @desc = args.last.kind_of?(::Hash) ? args.pop : {}, args.pop || ''
+        @name, @opt_name, @abbrev = parse_name_values(name, settings[:abbrev])
+        @value, @klass = gvalinfo(settings[:value])
+        @parser_args = if [TrueClass, FalseClass, NilClass].include?(@klass)
+          ["-#{@abbrev}", "--[no-]#{@opt_name}", @desc]
+        else
+          ["-#{@abbrev}", "--#{@opt_name} #{@opt_name.upcase}", @klass, @desc]
+        end
+      end
+
+      private
+
+      def parse_name_values(name, custom_abbrev)
+        [ (processed_name = name.to_s.strip.downcase), processed_name.gsub('_', '-'),
+          custom_abbrev || processed_name.gsub(/[^a-z]/, '').chars.first || 'a'
+        ]
+      end
+      def gvalinfo(v); v.kind_of?(Class) ? [nil,gklass(v)] : [v,gklass(v.class)]; end
+      def gklass(k); k == Fixnum ? Integer : k; end
+    end
+  end
+
+end

data/lib/dk/config.rb

@@ -0,0 +1,217 @@
+require 'logsly'
+require 'dk/has_set_param'
+require 'dk/has_ssh_opts'
+require 'dk/task'
+
+module Dk
+
+  class Config
+    include Dk::HasSetParam
+    include Dk::HasSSHOpts
+
+    UnknownTaskError = Class.new(ArgumentError) do
+      def initialize(task_name)
+        super("No task named #{task_name}")
+      end
+    end
+
+    DEFAULT_INIT_PROCS       = [].freeze
+    DEFAULT_PARAMS           = {}.freeze
+    DEFAULT_CALLBACKS        = Hash.new{ |h, k| h[k] = Dk::Task::CallbackSet.new }.freeze
+    DEFAULT_SSH_HOSTS        = {}.freeze
+    DEFAULT_SSH_ARGS         = ''.freeze
+    DEFAULT_HOST_SSH_ARGS    = Hash.new{ |h, k| h[k] = DEFAULT_SSH_ARGS }
+    DEFAULT_TASKS            = Hash.new{ |h, k| raise UnknownTaskError.new("`#{k}`") }.freeze
+    DEFAULT_LOG_PATTERN      = "%m\n".freeze
+    DEFAULT_LOG_FILE_PATTERN = '[%d %-5l] : %m\n'.freeze
+    DEFAULT_STDOUT_LOG_LEVEL = 'info'.freeze
+    DEFAULT_STUBS            = [].freeze
+    FILE_LOG_LEVEL           = 'debug'.freeze
+
+    attr_reader :init_procs, :params
+    attr_reader :before_callbacks, :prepend_before_callbacks
+    attr_reader :after_callbacks, :prepend_after_callbacks
+    attr_reader :tasks, :dry_tree_cmd_stubs, :dry_tree_ssh_stubs
+
+    def initialize
+      @init_procs               = DEFAULT_INIT_PROCS.dup
+      @params                   = DEFAULT_PARAMS.dup
+      @before_callbacks         = DEFAULT_CALLBACKS.dup
+      @prepend_before_callbacks = DEFAULT_CALLBACKS.dup
+      @after_callbacks          = DEFAULT_CALLBACKS.dup
+      @prepend_after_callbacks  = DEFAULT_CALLBACKS.dup
+      @ssh_hosts                = DEFAULT_SSH_HOSTS.dup
+      @ssh_args                 = DEFAULT_SSH_ARGS.dup
+      @host_ssh_args            = DEFAULT_HOST_SSH_ARGS.dup
+      @tasks                    = DEFAULT_TASKS.dup
+      @stdout_log_level         = DEFAULT_STDOUT_LOG_LEVEL
+      @log_pattern              = DEFAULT_LOG_PATTERN
+      @log_file                 = nil
+      @log_file_pattern         = DEFAULT_LOG_FILE_PATTERN
+      @dry_tree_cmd_stubs       = DEFAULT_STUBS.dup
+      @dry_tree_ssh_stubs       = DEFAULT_STUBS.dup
+    end
+
+    def init
+      self.init_procs.each{ |block| self.instance_eval(&block) }
+    end
+
+    def set_param(key, value)
+      self.params.merge!(dk_normalize_params(key => value))
+    end
+
+    def before(subject_task_class, callback_task_class, params = nil)
+      self.before_callbacks[subject_task_class] << Task::Callback.new(
+        callback_task_class,
+        params
+      )
+    end
+
+    def prepend_before(subject_task_class, callback_task_class, params = nil)
+      self.prepend_before_callbacks[subject_task_class].unshift(Task::Callback.new(
+        callback_task_class,
+        params
+      ))
+    end
+
+    def after(subject_task_class, callback_task_class, params = nil)
+      self.after_callbacks[subject_task_class] << Task::Callback.new(
+        callback_task_class,
+        params
+      )
+    end
+
+    def prepend_after(subject_task_class, callback_task_class, params = nil)
+      self.prepend_after_callbacks[subject_task_class].unshift(Task::Callback.new(
+        callback_task_class,
+        params
+      ))
+    end
+
+    def before_callback_task_classes(for_task_class)
+      self.before_callbacks[for_task_class].map(&:task_class)
+    end
+
+    def prepend_before_callback_task_classes(for_task_class)
+      self.prepend_before_callbacks[for_task_class].map(&:task_class)
+    end
+
+    def after_callback_task_classes(for_task_class)
+      self.after_callbacks[for_task_class].map(&:task_class)
+    end
+
+    def prepend_after_callback_task_classes(for_task_class)
+      self.prepend_after_callbacks[for_task_class].map(&:task_class)
+    end
+
+    def task(name, task_class = nil)
+      if !task_class.nil?
+        if !task_class.kind_of?(Class) || !task_class.include?(Dk::Task)
+          raise ArgumentError, "#{task_class.inspect} is not a Dk::Task"
+        end
+        @tasks[name.to_s] = task_class
+      end
+      @tasks[name.to_s]
+    end
+
+    def stdout_log_level(value = nil)
+      @stdout_log_level = value if !value.nil?
+      @stdout_log_level
+    end
+
+    def log_pattern(value = nil)
+      @log_pattern = value if !value.nil?
+      @log_pattern
+    end
+
+    def log_file(value = nil)
+      @log_file = value if !value.nil?
+      @log_file
+    end
+
+    def log_file_pattern(value = nil)
+      @log_file_pattern = value if !value.nil?
+      @log_file_pattern
+    end
+
+    def stub_dry_tree_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])
+
+      @dry_tree_cmd_stubs.unshift(
+        DryTreeStub.new(cmd_str_proc, input_proc, given_opts_proc, block)
+      )
+    end
+
+    def stub_dry_tree_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])
+
+      @dry_tree_ssh_stubs.unshift(
+        DryTreeStub.new(cmd_str_proc, input_proc, given_opts_proc, block)
+      )
+    end
+
+    # private - intended for internal use only
+
+    def dk_logger_stdout_output_name
+      # include the object id to ensure the output is unique to the instance
+      @dk_logger_stdout_output_name ||= "dk-config-#{self.object_id}-stdout"
+    end
+
+    def dk_logger_file_output_name
+      # include the object id to ensure the output is unique to the instance
+      @dk_logger_file_output_name ||= "dk-config-#{self.object_id}-file"
+    end
+
+    def dk_logger
+      @dk_logger ||= LogslyLogger.new(self)
+    end
+
+    private
+
+    def get_cmd_ssh_proc(obj)
+      obj.kind_of?(::Proc) ? obj : proc{ obj }
+    end
+
+    DryTreeStub = Struct.new(:cmd_str_proc, :input_proc, :given_opts_proc, :block)
+
+    class LogslyLogger
+      include Logsly
+
+      LOG_TYPE = 'dk'.freeze
+
+      attr_reader :config
+
+      def initialize(config)
+        @config = config # set the reader first so it can be used when supering
+
+        Logsly.stdout(@config.dk_logger_stdout_output_name) do |logger|
+          level   logger.config.stdout_log_level
+          pattern logger.config.log_pattern
+        end
+        outputs = [@config.dk_logger_stdout_output_name]
+
+        if @config.log_file
+          Logsly.file(@config.dk_logger_file_output_name) do |logger|
+            path    File.expand_path(logger.config.log_file, ENV['PWD'])
+            level   Dk::Config::FILE_LOG_LEVEL
+            pattern logger.config.log_file_pattern
+          end
+          outputs << @config.dk_logger_file_output_name
+        end
+
+        super(LOG_TYPE, :outputs => outputs)
+      end
+
+    end
+
+  end
+
+end

data/lib/dk/config_runner.rb

@@ -0,0 +1,24 @@
+require 'dk/runner'
+
+module Dk
+
+  class ConfigRunner < Runner
+
+    def initialize(config, opts = nil)
+      opts ||= {}
+      super({
+        :params                   => config.params,
+        :before_callbacks         => config.before_callbacks,
+        :prepend_before_callbacks => config.prepend_before_callbacks,
+        :after_callbacks          => config.after_callbacks,
+        :prepend_after_callbacks  => config.prepend_after_callbacks,
+        :ssh_hosts                => config.ssh_hosts,
+        :ssh_args                 => config.ssh_args,
+        :host_ssh_args            => config.host_ssh_args,
+        :logger                   => opts[:logger] || config.dk_logger
+      })
+    end
+
+  end
+
+end

data/lib/dk/dk_runner.rb

@@ -0,0 +1,13 @@
+require 'dk/config_runner'
+
+module Dk
+
+  class DkRunner < ConfigRunner
+
+    def initialize(config)
+      super(config)
+    end
+
+  end
+
+end

data/lib/dk/dry_runner.rb

@@ -0,0 +1,43 @@
+require 'dk/config_runner'
+require 'dk/has_the_stubs'
+
+module Dk
+
+  class DryRunner < ConfigRunner
+    include HasTheStubs
+
+    # run with disabled cmds, just log actions, but run all sub-tasks
+
+    def initialize(config, *args)
+      super(config, *args)
+      config.dry_tree_cmd_stubs.each do |s|
+        self.stub_cmd(s.cmd_str_proc, {
+          :input => s.input_proc,
+          :opts  => s.given_opts_proc
+        }, &s.block)
+      end
+      config.dry_tree_ssh_stubs.each do |s|
+        self.stub_ssh(s.cmd_str_proc, {
+          :input => s.input_proc,
+          :opts  => s.given_opts_proc
+        }, &s.block)
+      end
+    end
+
+    private
+
+    def has_the_stubs_build_local_cmd(cmd_str, given_opts)
+      given_opts ||= {}
+      cmd_klass = given_opts[:dry_tree_run] ? Local::Cmd : Local::CmdSpy
+      cmd_klass.new(cmd_str, given_opts)
+    end
+
+    def has_the_stubs_build_remote_cmd(cmd_str, ssh_opts)
+      ssh_opts ||= {}
+      cmd_klass = ssh_opts[:dry_tree_run] ? Remote::Cmd : Remote::CmdSpy
+      cmd_klass.new(cmd_str, ssh_opts)
+    end
+
+  end
+
+end

data/lib/dk/has_set_param.rb

@@ -0,0 +1,42 @@
+require 'much-plugin'
+
+module Dk
+
+  module HasSetParam
+    include MuchPlugin
+
+    plugin_included do
+      include InstanceMethods
+
+    end
+
+    module InstanceMethods
+
+      def set_param(key, value)
+        self.params.merge!(dk_normalize_params(key => value))
+      end
+
+      private
+
+      def dk_normalize_params(params)
+        StringifyParams.new(params || {})
+      end
+
+    end
+
+    module StringifyParams
+      def self.new(object)
+        case(object)
+        when ::Hash
+          object.inject({}){ |h, (k, v)| h.merge(k.to_s => self.new(v)) }
+        when ::Array
+          object.map{ |item| self.new(item) }
+        else
+          object
+        end
+      end
+    end
+
+  end
+
+end

data/lib/dk/has_ssh_opts.rb

@@ -0,0 +1,36 @@
+require 'much-plugin'
+
+module Dk
+
+  module HasSSHOpts
+    include MuchPlugin
+
+    plugin_included do
+      include InstanceMethods
+
+    end
+
+    module InstanceMethods
+
+      def ssh_hosts(group_name = nil, *values)
+        return @ssh_hosts if group_name.nil?
+        @ssh_hosts[group_name.to_s] = values.flatten if !values.empty?
+        @ssh_hosts[group_name.to_s]
+      end
+
+      def ssh_args(value = nil)
+        @ssh_args = value if !value.nil?
+        @ssh_args
+      end
+
+      def host_ssh_args(host_name = nil, value = nil)
+        return @host_ssh_args if host_name.nil?
+        @host_ssh_args[host_name.to_s] = value if !value.nil?
+        @host_ssh_args[host_name.to_s]
+      end
+
+    end
+
+  end
+
+end

data/lib/dk/has_the_runs.rb

@@ -0,0 +1,23 @@
+require 'much-plugin'
+
+module Dk
+
+  module HasTheRuns
+    include MuchPlugin
+
+    plugin_included do
+      include InstanceMethods
+
+    end
+
+    module InstanceMethods
+
+      def runs
+        @runs ||= []
+      end
+
+    end
+
+  end
+
+end