dk-dumpdb 0.0.1 → 0.1.0

data/lib/dk-dumpdb/db.rb

@@ -0,0 +1,69 @@
+module Dk; end
+module Dk::Dumpdb
+
+  class Db
+
+    DEFAULT_VALUE = ''.freeze
+
+    def initialize(dump_file_name = nil, values = nil)
+      dump_file_name = dump_file_name || 'dump.output'
+      @values        = dk_dumpdb_symbolize_keys(values)
+
+      [:host, :port, :user, :pw, :db, :output_root].each do |key|
+        @values[key] ||= DEFAULT_VALUE
+      end
+
+      @values[:output_dir] = dk_dumpdb_build_output_dir(
+        self.output_root,
+        self.host,
+        self.db
+      )
+      @values[:dump_file] = File.join(self.output_dir, dump_file_name)
+    end
+
+    def to_hash; @values; end
+
+    def method_missing(meth, *args, &block)
+      if @values.has_key?(meth.to_sym)
+        @values[meth.to_sym]
+      else
+        super
+      end
+    end
+
+    def respond_to?(meth)
+      @values.has_key?(meth.to_sym) || super
+    end
+
+    def ==(other_db)
+      if other_db.kind_of?(Db)
+        self.to_hash == other_db.to_hash
+      else
+        super
+      end
+    end
+
+    private
+
+    def dk_dumpdb_build_output_dir(output_root, host, database)
+      dir_name = dk_dumpdb_build_output_dir_name(host, database)
+      if output_root && !output_root.to_s.empty?
+        File.join(output_root, dir_name)
+      else
+        dir_name
+      end
+    end
+
+    def dk_dumpdb_build_output_dir_name(host, database)
+      [host, database, Time.now.to_f].map(&:to_s).reject(&:empty?).join("__")
+    end
+
+    def dk_dumpdb_symbolize_keys(values)
+      (values || {}).inject({}) do |h, (k, v)|
+        h.merge(k.to_sym => v)
+      end
+    end
+
+  end
+
+end

data/lib/dk-dumpdb/script.rb

@@ -0,0 +1,83 @@
+require 'much-plugin'
+require 'dk-dumpdb/config'
+require 'dk-dumpdb/task'
+
+module Dk::Dumpdb
+
+  module Script
+    include MuchPlugin
+
+    plugin_included do
+      include InstanceMethods
+      extend ClassMethods
+
+      class self::Task
+        include Dk::Dumpdb::Task
+      end
+      self::Task.script_class self
+
+    end
+
+    module InstanceMethods
+
+      attr_reader :params
+
+      def initialize(task_params = nil)
+        @params = task_params || {}
+      end
+
+      def config
+        @config ||= Config.new.tap do |config|
+          self.class.config_blocks.each do |config_block|
+            config.instance_eval(&config_block)
+          end
+        end
+      end
+
+      def ssh;       @ssh       ||= config.ssh.value(self);       end
+      def dump_file; @dump_file ||= config.dump_file.value(self); end
+      def source;    @source    ||= config.source.value(self);    end
+      def target;    @target    ||= config.target.value(self);    end
+
+      def copy_dump_cmd_args
+        @copy_dump_cmd_args ||= config.copy_dump_cmd_args.value(self)
+      end
+
+      def dump_cmds;    @dump_cmds    ||= config.dump_cmds.value(self);    end
+      def restore_cmds; @restore_cmds ||= config.restore_cmds.value(self); end
+
+      def source_dump_file; self.source.dump_file; end
+      def target_dump_file; self.target.dump_file; end
+
+      def source_hash; self.source.to_hash; end
+      def target_hash; self.target.to_hash; end
+
+      def ssh?
+        self.ssh && !self.ssh.empty?
+      end
+
+      def dump_cmd(&block);   config.dump_cmd(self, &block);    end
+      def restore_cmd(&block) config.restore_cmd(self, &block); end
+
+    end
+
+    module ClassMethods
+
+      def config_blocks
+        @config_blocks ||= []
+      end
+
+      def config(&block)
+        self.config_blocks << block if !block.nil?
+      end
+
+      def task_description(value = nil)
+        self::Task.description(value)
+      end
+      alias_method :task_desc, :task_description
+
+    end
+
+  end
+
+end

data/lib/dk-dumpdb/task.rb

@@ -0,0 +1,58 @@
+require 'dk/task'
+require 'much-plugin'
+require 'dk-dumpdb/task/copy_dump'
+require 'dk-dumpdb/task/dump'
+require 'dk-dumpdb/task/restore'
+require 'dk-dumpdb/task/setup'
+require 'dk-dumpdb/task/teardown'
+
+module Dk::Dumpdb
+
+  module Task
+    include MuchPlugin
+
+    plugin_included do
+      include Dk::Task
+      include InstanceMethods
+      extend ClassMethods
+
+    end
+
+    module InstanceMethods
+
+      def run!
+        script = self.class.script_class.new(params)
+
+        run_task Setup,      'script' => script
+        begin
+          run_task Dump,     'script' => script
+          run_task CopyDump, 'script' => script
+          run_task Restore,  'script' => script
+        ensure
+          run_task Teardown, 'script' => script
+        end
+      end
+
+    end
+
+    module ClassMethods
+
+      def script_class(value = nil)
+        @script_class = value if !value.nil?
+        @script_class
+      end
+
+    end
+
+    module TestHelpers
+      include MuchPlugin
+
+      plugin_included do
+        include Dk::Task::TestHelpers
+      end
+
+    end
+
+  end
+
+end

data/lib/dk-dumpdb/task/copy_dump.rb

@@ -0,0 +1,16 @@
+require 'dk-dumpdb/task/internal_task'
+
+module Dk::Dumpdb::Task
+
+  class CopyDump
+    include Dk::Dumpdb::Task::InternalTask
+
+    desc "(dk-dumpdb) copy the given script's dump file from source to target"
+
+    def run!
+      copy_cmd! params['script'].copy_dump_cmd_args
+    end
+
+  end
+
+end

data/lib/dk-dumpdb/task/dump.rb

@@ -0,0 +1,16 @@
+require 'dk-dumpdb/task/internal_task'
+
+module Dk::Dumpdb::Task
+
+  class Dump
+    include Dk::Dumpdb::Task::InternalTask
+
+    desc "(dk-dumpdb) run the given script's dump cmds"
+
+    def run!
+      params['script'].dump_cmds.each{ |cmd_str| source_cmd!(cmd_str) }
+    end
+
+  end
+
+end

data/lib/dk-dumpdb/task/internal_task.rb

@@ -0,0 +1,44 @@
+require 'dk/task'
+require 'much-plugin'
+require 'dk-dumpdb'
+
+module Dk::Dumpdb::Task
+
+  module InternalTask
+    include MuchPlugin
+
+    plugin_included do
+      include Dk::Task
+      include InstanceMethods
+
+    end
+
+    module InstanceMethods
+
+      private
+
+      def source_cmd!(cmd_str)
+        if params['script'].ssh?
+          ssh!(cmd_str, :hosts => params['script'].ssh)
+        else
+          cmd!(cmd_str)
+        end
+      end
+
+      def copy_cmd!(args)
+        if (s = params['script']).ssh?
+          cmd! "scp #{try_param(Dk::Dumpdb::SCP_ARGS_PARAM_NAME)} #{s.ssh}:#{args}"
+        else
+          cmd! "cp #{args}"
+        end
+      end
+
+      def target_cmd!(cmd_str)
+        cmd!(cmd_str)
+      end
+
+    end
+
+  end
+
+end

data/lib/dk-dumpdb/task/restore.rb

@@ -0,0 +1,16 @@
+require 'dk-dumpdb/task/internal_task'
+
+module Dk::Dumpdb::Task
+
+  class Restore
+    include Dk::Dumpdb::Task::InternalTask
+
+    desc "(dk-dumpdb) run the given script's restore cmds"
+
+    def run!
+      params['script'].restore_cmds.each{ |cmd_str| target_cmd!(cmd_str) }
+    end
+
+  end
+
+end

data/lib/dk-dumpdb/task/setup.rb

@@ -0,0 +1,17 @@
+require 'dk-dumpdb/task/internal_task'
+
+module Dk::Dumpdb::Task
+
+  class Setup
+    include Dk::Dumpdb::Task::InternalTask
+
+    desc "(dk-dumpdb) setup a script run"
+
+    def run!
+      source_cmd!(params['script'].dump_cmd{ "mkdir -p #{source.output_dir}" })
+      target_cmd!(params['script'].restore_cmd{ "mkdir -p #{target.output_dir}" })
+    end
+
+  end
+
+end

data/lib/dk-dumpdb/task/teardown.rb

@@ -0,0 +1,17 @@
+require 'dk-dumpdb/task/internal_task'
+
+module Dk::Dumpdb::Task
+
+  class Teardown
+    include Dk::Dumpdb::Task::InternalTask
+
+    desc "(dk-dumpdb) teardown a script run"
+
+    def run!
+      source_cmd!(params['script'].dump_cmd{ "rm -rf #{source.output_dir}" })
+      target_cmd!(params['script'].restore_cmd{ "rm -rf #{target.output_dir}" })
+    end
+
+  end
+
+end

data/lib/dk-dumpdb/version.rb

@@ -1,4 +1,4 @@
 module Dk; end
 module Dk::Dumpdb
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/test/support/factory.rb

@@ -1,6 +1,18 @@
 require 'assert/factory'
+require 'dk-dumpdb/script'
 
 module Factory
   extend Assert::Factory
 
+  def self.script_class(&config_proc)
+    Class.new do
+      include Dk::Dumpdb::Script
+      config &config_proc
+    end
+  end
+
+  def self.script(script_class = nil, &config_proc)
+    (script_class || self.script_class(&config_proc)).new
+  end
+
 end

data/test/support/task/internal_task.rb

@@ -0,0 +1,27 @@
+require 'dk/task'
+require 'much-plugin'
+require 'dk-dumpdb/task/internal_task'
+
+module Dk::Dumpdb::Task::InternalTask
+
+  module TestHelpers
+    include MuchPlugin
+
+    plugin_included do
+      include Dk::Task::TestHelpers
+      include InstanceMethods
+
+    end
+
+    module InstanceMethods
+
+      def set_dk_dumpdb_script_param(*args, &block)
+        @params ||= {}
+        @params['script'] = Factory.script(*args, &block)
+      end
+
+    end
+
+  end
+
+end

data/test/unit/config_tests.rb

@@ -0,0 +1,259 @@
+require 'assert'
+require 'dk-dumpdb/config'
+
+require 'dk-dumpdb/db'
+# require 'test/support/test_scripts'
+
+class Dk::Dumpdb::Config
+
+  class UnitTests < Assert::Context
+    desc "Dk::Dumpdb::Config"
+    setup do
+      @script = FakeScript.new
+      @config_class = Dk::Dumpdb::Config
+    end
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      now = Factory.time
+      Assert.stub(Time, :now){ now }
+
+      @config = @config_class.new
+    end
+    subject{ @config }
+
+    should have_readers :copy_dump_cmd_args, :dump_cmds, :restore_cmds
+    should have_imeths :ssh, :dump_file, :source, :target, :dump, :restore
+    should have_imeths :dump_cmd, :restore_cmd
+
+    should "default its values" do
+      assert_instance_of Ssh, subject.ssh
+      assert_equal '', subject.ssh.value(@script)
+
+      assert_instance_of DumpFile, subject.dump_file
+      assert_equal '', subject.dump_file.value(@script)
+
+      assert_instance_of SourceTargetDb, subject.source
+      val = subject.source.value(@script)
+      assert_instance_of Dk::Dumpdb::Db, val
+      exp = Dk::Dumpdb::Db.new(@script.dump_file, {})
+      assert_equal exp, val
+
+      assert_instance_of SourceTargetDb, subject.target
+      val = subject.target.value(@script)
+      assert_instance_of Dk::Dumpdb::Db, val
+      exp = Dk::Dumpdb::Db.new(@script.dump_file, {})
+      assert_equal exp, val
+
+      assert_instance_of CopyDumpCmdArgs, subject.copy_dump_cmd_args
+
+      assert_instance_of CmdList, subject.dump_cmds
+      assert_equal [], subject.dump_cmds.value(@script)
+
+      assert_instance_of CmdList, subject.restore_cmds
+      assert_equal [], subject.restore_cmds.value(@script)
+    end
+
+    should "allow setting new values" do
+      value = Factory.string
+      subject.ssh{ value }
+      assert_equal value, subject.ssh.value(@script)
+
+      subject.dump_file{ value }
+      assert_equal value, subject.dump_file.value(@script)
+
+      subject.source do
+        { 'pw' => value }
+      end
+      val = subject.source.value(@script)
+      exp = Dk::Dumpdb::Db.new(@script.dump_file, { 'pw' => value })
+      assert_equal exp, val
+
+      subject.target do
+        { 'pw' => value }
+      end
+      val = subject.target.value(@script)
+      exp = Dk::Dumpdb::Db.new(@script.dump_file, { 'pw' => value })
+      assert_equal exp, val
+    end
+
+    should "append dump/restore cmds" do
+      subject.dump{ Factory.string }
+      assert_equal 1, subject.dump_cmds.value(@script).size
+      assert_instance_of DumpCmd, subject.dump_cmds.first
+
+      subject.restore{ Factory.string }
+      assert_equal 1, subject.restore_cmds.value(@script).size
+      assert_instance_of RestoreCmd, subject.restore_cmds.first
+    end
+
+    should "build dump/restore cmd strs" do
+      cmd_str = "#{Factory.string}; pw: `:pw`"
+
+      exp = DumpCmd.new(proc{ cmd_str }).value(@script)
+      assert_equal exp, subject.dump_cmd(@script){ cmd_str }
+
+      exp = RestoreCmd.new(proc{ cmd_str }).value(@script)
+      assert_equal exp, subject.restore_cmd(@script){ cmd_str }
+    end
+
+  end
+
+  class ValueTests < UnitTests
+    desc "Value"
+    setup do
+      @setting = Value.new
+    end
+    subject{ @setting }
+
+    should have_readers :proc
+    should have_imeths :value
+
+    should "know its proc" do
+      assert_kind_of ::Proc, subject.proc
+      assert_nil subject.proc.call
+    end
+
+    should "instance eval its proc in the scope of a script to return a value" do
+      setting = Value.new(Proc.new{ "something: #{dump_file}" })
+      assert_equal "something: #{@script.dump_file}", setting.value(@script)
+    end
+
+  end
+
+  class SshTests < UnitTests
+    desc "Ssh"
+
+    should "be a Value" do
+      assert_true Ssh < Value
+    end
+
+  end
+
+  class DumpFileTests < UnitTests
+    desc "DumpFile"
+
+    should "be a Value" do
+      assert_true DumpFile < Value
+    end
+
+  end
+
+  class SourceTargetDbTests < UnitTests
+    desc "SourceTargetDb"
+
+    should "be a Value" do
+      assert_true SourceTargetDb < Value
+    end
+
+    should "have a Db value built from a hash" do
+      db_hash = { 'host' => Factory.string }
+      db = SourceTargetDb.new(db_hash).value(@script)
+      assert_instance_of Dk::Dumpdb::Db, db
+
+      assert_equal db_hash['host'], db.host
+      assert_includes @script.dump_file, db.to_hash[:dump_file]
+    end
+
+  end
+
+  class CopyDumpCmdArgsTests < UnitTests
+    desc "CopyDumpCmdArgs"
+
+    should "be a Value" do
+      assert_true CopyDumpCmdArgs < Value
+    end
+
+    should "know its value" do
+      exp = "#{@script.source_dump_file} #{@script.target_dump_file}"
+      assert_equal exp, CopyDumpCmdArgs.new.value(@script)
+    end
+
+  end
+
+  class CmdTests < UnitTests
+    desc "Cmd"
+
+    should "be a Value" do
+      assert_true Cmd < Value
+    end
+
+    should "eval and apply any placeholders to the cmd string" do
+      cmd_str = Proc.new{ "dump file: `#{dump_file}`; pw: `:pw`" }
+
+      exp = "dump file: `#{@script.dump_file}`; pw: `#{@script.source_hash['pw']}`"
+      assert_equal exp, Cmd.new(cmd_str).value(@script, @script.source_hash)
+    end
+
+  end
+
+  class DumpCmdTests < UnitTests
+    desc "DumpCmd"
+
+    should "be a Cmd" do
+      assert_true DumpCmd < Cmd
+    end
+
+    should "eval and apply any source placeholders to the cmd string" do
+      cmd_str = Proc.new{ "dump file: `#{dump_file}`; pw: `:pw`" }
+
+      exp = "dump file: `#{@script.dump_file}`; pw: `#{@script.source_hash['pw']}`"
+      assert_equal exp, DumpCmd.new(cmd_str).value(@script)
+    end
+
+  end
+
+  class RestoreCmdTests < UnitTests
+    desc "RestoreCmd"
+
+    should "be a Cmd" do
+      assert_true RestoreCmd < Cmd
+    end
+
+    should "eval and apply any target placeholders to the cmd string" do
+      cmd_str = Proc.new{ "dump file: `#{dump_file}`; pw: `:pw`" }
+
+      exp = "dump file: `#{@script.dump_file}`; pw: `#{@script.target_hash['pw']}`"
+      assert_equal exp, RestoreCmd.new(cmd_str).value(@script)
+    end
+
+  end
+
+  class CmdListTests < UnitTests
+    desc "CmdList"
+    setup do
+      other_cmd = Factory.string
+      @cmds = [
+        Cmd.new(Proc.new{ "dump file: `#{dump_file}`; pw: `:pw`" }),
+        Cmd.new(Proc.new{ other_cmd })
+      ]
+    end
+
+    should "be an Array" do
+      assert_kind_of ::Array, CmdList.new
+    end
+
+    should "return the commands, eval'd and placeholders applied" do
+      exp = @cmds.map{ |c| c.value(@script, @script.source_hash) }
+      assert_equal exp, CmdList.new(@cmds).value(@script, @script.source_hash)
+    end
+
+  end
+
+  class FakeScript
+    attr_reader :dump_file, :source_dump_file, :target_dump_file
+    attr_reader :source_hash, :target_hash
+
+    def initialize
+      @dump_file        = Factory.string
+      @source_dump_file = File.join(Factory.path, @dump_file)
+      @target_dump_file = File.join(Factory.path, @dump_file)
+      @source_hash      = { 'pw' => Factory.string }
+      @target_hash      = { 'pw' => Factory.string }
+    end
+  end
+
+end