flydata 0.3.5 → 0.3.6

data/lib/flydata/fluent-plugins/mysql/alter_table_query_handler.rb

@@ -1,5 +1,5 @@
 require 'flydata/parser_provider'
-require_relative 'ddl_query_handler'
+require 'flydata/fluent-plugins/mysql/ddl_query_handler'
 
 module Mysql
   class AlterTableQueryHandler < DdlQueryHandler

data/lib/flydata/fluent-plugins/mysql/binlog_query_dispatcher.rb

@@ -1,4 +1,4 @@
-require_relative 'alter_table_query_handler'
+require 'flydata/fluent-plugins/mysql/alter_table_query_handler'
 
 module Mysql
   class BinlogQueryDispatcher

data/lib/flydata/fluent-plugins/mysql/binlog_query_handler.rb

@@ -1,4 +1,4 @@
-require_relative 'binlog_record_handler'
+require 'flydata/fluent-plugins/mysql/binlog_record_handler'
 
 module Mysql
   class BinlogQueryHandler < BinlogRecordHandler

data/lib/flydata/fluent-plugins/mysql/binlog_record_dispatcher.rb

@@ -1,7 +1,7 @@
 require 'fluent/plugin/in_mysql_binlog'
 require 'binlog'
-require_relative 'dml_record_handler'
-require_relative 'binlog_query_dispatcher'
+require 'flydata/fluent-plugins/mysql/dml_record_handler'
+require 'flydata/fluent-plugins/mysql/binlog_query_dispatcher'
 
 module Mysql
   class BinlogRecordDispatcher

data/lib/flydata/fluent-plugins/mysql/binlog_record_handler.rb

@@ -1,6 +1,6 @@
 require 'fluent/plugin/in_mysql_binlog'
 require 'binlog'
-require_relative 'binlog_position'
+require 'flydata/fluent-plugins/mysql/binlog_position'
 
 module Mysql
   class BinlogRecordHandler

data/lib/flydata/fluent-plugins/mysql/ddl_query_handler.rb

@@ -1,4 +1,4 @@
-require_relative 'binlog_query_handler'
+require 'flydata/fluent-plugins/mysql/binlog_query_handler'
 
 module Mysql
 

data/lib/flydata/fluent-plugins/mysql/dml_record_handler.rb

@@ -1,4 +1,4 @@
-require_relative 'binlog_record_handler'
+require 'flydata/fluent-plugins/mysql/binlog_record_handler'
 
 module Mysql
   class DmlRecordHandler < BinlogRecordHandler

data/lib/flydata/helpers.rb

@@ -2,16 +2,6 @@ module Flydata
   module Helpers
     @@development_mode = nil
     module_function
-    def parse_command(cmd)
-      klass = Flydata::Command::Base
-      method = cmd
-      if cmd.include?(':')
-        class_name, method = cmd.split(':')
-        klass = to_command_class(class_name)
-      end
-      [klass, method]
-    end
-
     def usage_text
       text = ""
 

data/lib/flydata/heroku.rb

@@ -1,3 +1,6 @@
+require 'flydata/heroku/instance_methods'
+require 'flydata/heroku/configuration_methods'
+
 module Flydata
   module Heroku
     extend ActiveSupport::Concern

data/lib/flydata/output/forwarder.rb

@@ -1,6 +1,6 @@
 require 'socket'
 require 'msgpack'
-require 'flydata/command_logger'
+require 'flydata/command_loggable'
 
 module Flydata
   module Output

data/lib/flydata/parser/mysql/dump_parser.rb

@@ -12,7 +12,7 @@ module Flydata
 
         def mysql_cli(conf = nil)
           mysql_conf(conf) if conf
-          return  Mysql2::Client.new(@mysql_conf) if @mysql_conf
+          return FdMysqlClient.new(@mysql_conf) if @mysql_conf
           nil
         end
       end
@@ -53,32 +53,6 @@ module Flydata
         end
       end
 
-      class MysqlDumpGeneratorMasterData < MysqlDumpGenerator
-        def dump(file_path)
-          cmd = "#{@dump_cmd} -r #{file_path}"
-          o, e, s = Open3.capture3(cmd)
-          e.to_s.each_line {|l|  puts l unless /^Warning:/ =~ l } unless e.to_s.empty?
-          unless s.exitstatus == 0
-            if File.exists?(file_path)
-              File.open(file_path, 'r') {|f| f.each_line{|l| puts l}}
-              FileUtils.rm(file_path)
-            end
-            raise "Failed to run mysqldump command."
-          end
-          unless File.exists?(file_path)
-            raise "mysqldump file does not exist. Something wrong..."
-          end
-          if File.size(file_path) == 0
-            raise "mysqldump file is empty. Something wrong..."
-          end
-          true
-        end
-
-        def generate_dump_cmd(conf)
-          Util::MysqlUtil.generate_mysqldump_with_master_data_cmd(conf)
-        end
-      end
-
       class MysqlDumpGeneratorNoMasterData < MysqlDumpGenerator
         CHANGE_MASTER_TEMPLATE = <<EOS
 --
@@ -100,7 +74,7 @@ EOS
 
           begin
             # create pipe for callback function
-            rd_io, wr_io = IO.pipe
+            rd_io, wr_io = IO.pipe("utf-8")
             wr_io.sync = true
             wr_io.set_encoding("utf-8")
             rd_io.extend(DumpStreamIO)
@@ -119,7 +93,7 @@ EOS
               threads << Thread.new do
                 begin
                   wr_io.print(first_line) # write a first line
-                  fileter_dump_stream(cmd_out, wr_io, binlog_file, binlog_pos)
+                  filter_dump_stream(cmd_out, wr_io, binlog_file, binlog_pos)
                 ensure
                   wr_io.close rescue nil
                 end
@@ -187,7 +161,7 @@ EOS
 
         def create_table_locker
           Fiber.new do
-            client = Mysql2::Client.new(@db_opts)
+            client = FdMysqlClient.new(@db_opts)
             # Lock tables
             client.query "FLUSH LOCAL TABLES;"
             q = flush_tables_with_read_lock_query(client)
@@ -227,7 +201,7 @@ EOS
           result.first['Value']
         end
 
-        def fileter_dump_stream(cmd_out, w_io, binlog_file, binlog_pos)
+        def filter_dump_stream(cmd_out, w_io, binlog_file, binlog_pos)
           find_insert_pos = :not_started
           cmd_out.each_line do |line|
             if find_insert_pos == :not_started && /^-- Server version/ === line
@@ -248,6 +222,30 @@ EOS
 
       end
 
+      # Custom mysql client that sets config params (eg:-read_timeout) uniformly for all
+      # mysql access. Also, gives access to the last query that was executed using the client
+      # which can be helpful when handling exceptions
+      class FdMysqlClient < Mysql2::Client
+
+        attr_accessor :last_query
+
+        def initialize(db_opts)
+          super(db_opts.merge(read_timeout: 600))
+        end
+
+        def query(sql, options = {})
+          @last_query = sql
+          begin
+            super(sql, options)
+          rescue Mysql2::Error => e
+            if  /^Timeout waiting for a response/ === e.to_s
+              raise "The below query timed out when running. Please check long running processes and locks in your database.\n#{last_query}"
+            end
+            raise e
+          end
+        end
+      end
+
       class MysqlDumpParser
 
         module State

data/lib/flydata/sync_file_manager.rb

@@ -1,290 +1,288 @@
 module Flydata
-  module FileUtil
-    class SyncFileManager
-      DUMP_DIR = ENV['FLYDATA_DUMP'] || File.join(FLYDATA_HOME, 'dump')
-      BACKUP_DIR = ENV['FLYDATA_BACKUP'] || File.join(FLYDATA_HOME, 'backup')
-      TABLE_POSITIONS_DIR = ENV['FLYDATA_TABLE_POSITIONS'] || File.join(FLYDATA_HOME, 'positions')
-      def initialize(data_entry)
-        @data_entry = data_entry
-        @table_position_files = {} # File objects keyed by table name
-      end
+  class SyncFileManager
+    DUMP_DIR = ENV['FLYDATA_DUMP'] || File.join(FLYDATA_HOME, 'dump')
+    BACKUP_DIR = ENV['FLYDATA_BACKUP'] || File.join(FLYDATA_HOME, 'backup')
+    TABLE_POSITIONS_DIR = ENV['FLYDATA_TABLE_POSITIONS'] || File.join(FLYDATA_HOME, 'positions')
+    def initialize(data_entry)
+      @data_entry = data_entry
+      @table_position_files = {} # File objects keyed by table name
+    end
 
-      def close
-        @table_position_files.values.each {|f| f.close }
-        @table_position_files = {}
-      end
+    def close
+      @table_position_files.values.each {|f| f.close }
+      @table_position_files = {}
+    end
 
-      def dump_file_path
-        File.join(dump_dir, @data_entry['name']) + ".dump"
-      end
+    def dump_file_path
+      File.join(dump_dir, @data_entry['name']) + ".dump"
+    end
 
-      # dump pos file for resume
-      def dump_pos_path
-        dump_file_path + ".pos"
-      end
+    # dump pos file for resume
+    def dump_pos_path
+      dump_file_path + ".pos"
+    end
 
-      def save_dump_pos(status, table_name, last_pos, binlog_pos, state = nil, substate = nil)
-        File.open(dump_pos_path, 'w') do |f|
-          f.write(dump_pos_content(status, table_name, last_pos, binlog_pos, state, substate))
-        end
+    def save_dump_pos(status, table_name, last_pos, binlog_pos, state = nil, substate = nil)
+      File.open(dump_pos_path, 'w') do |f|
+        f.write(dump_pos_content(status, table_name, last_pos, binlog_pos, state, substate))
       end
+    end
 
-      def load_dump_pos
-        path = dump_pos_path
-        return {} unless File.exists?(path)
-        items = File.open(path, 'r').readline.split("\t")
-        raise "Invalid dump.pos file: #{path}" unless items.length >= 5 && items.length <= 7
-        mysql_table = load_mysql_table_marshal_dump
-        { status: items[0], table_name: items[1], last_pos: items[2].to_i,
-          binlog_pos: {binfile: items[3], pos: items[4].to_i},
-          state: items[5], substate: items[6], mysql_table: mysql_table}
-      end
+    def load_dump_pos
+      path = dump_pos_path
+      return {} unless File.exists?(path)
+      items = File.open(path, 'r').readline.split("\t")
+      raise "Invalid dump.pos file: #{path}" unless items.length >= 5 && items.length <= 7
+      mysql_table = load_mysql_table_marshal_dump
+      { status: items[0], table_name: items[1], last_pos: items[2].to_i,
+        binlog_pos: {binfile: items[3], pos: items[4].to_i},
+        state: items[5], substate: items[6], mysql_table: mysql_table}
+    end
 
-      def mark_generated_tables(tables)
-        table_positions_dir_path = ENV['FLYDATA_TABLE_POSITIONS'] || File.join(FLYDATA_HOME, 'positions')
-        #Create positions if dir does not exist
-        unless File.directory?(table_positions_dir_path)
-          FileUtils.mkdir_p(table_positions_dir_path)
-        end
-        tables.each do |tab|
-          File.open(File.join(table_positions_dir_path, "#{tab}.generated_ddl"), 'w') {|f| f.write("1") }
-        end
+    def mark_generated_tables(tables)
+      table_positions_dir_path = ENV['FLYDATA_TABLE_POSITIONS'] || File.join(FLYDATA_HOME, 'positions')
+      #Create positions if dir does not exist
+      unless File.directory?(table_positions_dir_path)
+        FileUtils.mkdir_p(table_positions_dir_path)
       end
-
-      def get_new_table_list(tables, file_type)
-        table_positions_dir_path = ENV['FLYDATA_TABLE_POSITIONS'] || File.join(FLYDATA_HOME, 'positions')
-        new_tables = []
-        tables.each do |table|
-          new_tables << table unless  File.exists?(File.join(table_positions_dir_path, "#{table}.#{file_type}"))
-        end
-        new_tables
+      tables.each do |tab|
+        File.open(File.join(table_positions_dir_path, "#{tab}.generated_ddl"), 'w') {|f| f.write("1") }
       end
+    end
 
-      # MysqlTable marshal file
-      def mysql_table_marshal_dump_path
-        dump_file_path + ".mysql_table"
+    def get_new_table_list(tables, file_type)
+      table_positions_dir_path = ENV['FLYDATA_TABLE_POSITIONS'] || File.join(FLYDATA_HOME, 'positions')
+      new_tables = []
+      tables.each do |table|
+        new_tables << table unless  File.exists?(File.join(table_positions_dir_path, "#{table}.#{file_type}"))
       end
+      new_tables
+    end
 
-      def save_mysql_table_marshal_dump(mysql_table)
-        File.open(mysql_table_marshal_dump_path, 'w') do |f|
-          f.write Marshal.dump(mysql_table)
-        end
-      end
+    # MysqlTable marshal file
+    def mysql_table_marshal_dump_path
+      dump_file_path + ".mysql_table"
+    end
 
-      # binlog.pos file
-      def save_binlog(binlog_pos)
-        path = binlog_path
-        File.open(path, 'w') do |f|
-          f.write(binlog_content(binlog_pos))
-        end
+    def save_mysql_table_marshal_dump(mysql_table)
+      File.open(mysql_table_marshal_dump_path, 'w') do |f|
+        f.write Marshal.dump(mysql_table)
       end
+    end
 
-      def binlog_path
-        File.join(FLYDATA_HOME, @data_entry['name'] + ".binlog.pos")
+    # binlog.pos file
+    def save_binlog(binlog_pos)
+      path = binlog_path
+      File.open(path, 'w') do |f|
+        f.write(binlog_content(binlog_pos))
       end
+    end
 
-      def reset_table_position_files(tables)
-        tables.each do |table_name|
-          file = File.join(table_positions_dir_path, table_name + ".pos")
-          File.open(file, "w") {|f| f.write('0') }
-        end
-      end
+    def binlog_path
+      File.join(FLYDATA_HOME, @data_entry['name'] + ".binlog.pos")
+    end
 
-      def table_positions_dir_path
-        TABLE_POSITIONS_DIR
+    def reset_table_position_files(tables)
+      tables.each do |table_name|
+        file = File.join(table_positions_dir_path, table_name + ".pos")
+        File.open(file, "w") {|f| f.write('0') }
       end
+    end
 
-      def table_position_file_paths(*tables)
-        tables.empty? ? Dir.glob(File.join(table_positions_dir_path, '*.pos')) :
-          tables.map{|table| File.join(table_positions_dir_path, table + '.pos')}
-      end
+    def table_positions_dir_path
+      TABLE_POSITIONS_DIR
+    end
 
-      def table_ddl_file_paths(*tables)
-        tables.empty? ? Dir.glob(File.join(table_positions_dir_path, '*.generated_ddl')) :
-          tables.map{|table| File.join(table_positions_dir_path, table + '.generated_ddl')}
-      end
+    def table_position_file_paths(*tables)
+      tables.empty? ? Dir.glob(File.join(table_positions_dir_path, '*.pos')) :
+        tables.map{|table| File.join(table_positions_dir_path, table + '.pos')}
+    end
 
-      def table_binlog_pos_paths(*tables)
-        tables.empty? ? Dir.glob(File.join(table_positions_dir_path, '*.binlog.pos')) :
-          tables.map{|table| File.join(table_positions_dir_path, table + '.binlog.pos')}
-      end
+    def table_ddl_file_paths(*tables)
+      tables.empty? ? Dir.glob(File.join(table_positions_dir_path, '*.generated_ddl')) :
+        tables.map{|table| File.join(table_positions_dir_path, table + '.generated_ddl')}
+    end
 
-      def table_binlog_pos_init_paths(*tables)
-        tables.empty? ? Dir.glob(File.join(table_positions_dir_path, '*.binlog.pos.init')) :
-          tables.map{|table| File.join(table_positions_dir_path, table + '.binlog.pos.init')}
-      end
+    def table_binlog_pos_paths(*tables)
+      tables.empty? ? Dir.glob(File.join(table_positions_dir_path, '*.binlog.pos')) :
+        tables.map{|table| File.join(table_positions_dir_path, table + '.binlog.pos')}
+    end
 
-      # Read a sequence number from the table's position file,
-      # increment the number and pass the number to a block.
-      # After executing the block, saves the value to the position
-      # file.
-      def increment_and_save_table_position(table_name)
-        file = File.join(table_positions_dir_path, table_name + ".pos")
-        retry_count = 0
-        begin
-          @table_position_files[table_name] ||= File.open(file, "r+")
-        rescue Errno::ENOENT
-          raise if retry_count > 0 # Already retried.  Must be a differentfile causing the error
-          # File not exist.  Create one with initial value of '0'
-          File.open(file, "w") {|f| f.write('0') }
-          retry_count += 1
-          retry
-        end
-        f = @table_position_files[table_name]
-        seq = f.read
-        seq = seq.to_i + 1
-        begin
-          yield(seq)
-        ensure
-          # when an error happened in yield, the sequence number should remain
-          # as is.  For the next call to read the value correctly, the position
-          # must be rewound.
-          f.rewind
-        end
-        f.truncate(0)
-        f.write(seq)
-        f.flush
+    def table_binlog_pos_init_paths(*tables)
+      tables.empty? ? Dir.glob(File.join(table_positions_dir_path, '*.binlog.pos.init')) :
+        tables.map{|table| File.join(table_positions_dir_path, table + '.binlog.pos.init')}
+    end
+
+    # Read a sequence number from the table's position file,
+    # increment the number and pass the number to a block.
+    # After executing the block, saves the value to the position
+    # file.
+    def increment_and_save_table_position(table_name)
+      file = File.join(table_positions_dir_path, table_name + ".pos")
+      retry_count = 0
+      begin
+        @table_position_files[table_name] ||= File.open(file, "r+")
+      rescue Errno::ENOENT
+        raise if retry_count > 0 # Already retried.  Must be a differentfile causing the error
+        # File not exist.  Create one with initial value of '0'
+        File.open(file, "w") {|f| f.write('0') }
+        retry_count += 1
+        retry
+      end
+      f = @table_position_files[table_name]
+      seq = f.read
+      seq = seq.to_i + 1
+      begin
+        yield(seq)
+      ensure
+        # when an error happened in yield, the sequence number should remain
+        # as is.  For the next call to read the value correctly, the position
+        # must be rewound.
         f.rewind
       end
+      f.truncate(0)
+      f.write(seq)
+      f.flush
+      f.rewind
+    end
 
-      def sync_info_file
-        File.join(dump_dir, "sync.info")
-      end
+    def sync_info_file
+      File.join(dump_dir, "sync.info")
+    end
 
-      def save_sync_info(initial_sync, tables)
-        File.open(sync_info_file, "w") do |f|
-          f.write([initial_sync, tables.join(" ")].join("\t"))
-        end
+    def save_sync_info(initial_sync, tables)
+      File.open(sync_info_file, "w") do |f|
+        f.write([initial_sync, tables.join(" ")].join("\t"))
       end
+    end
 
-      def load_sync_info
-        return nil unless File.exists?(sync_info_file)
-        items = File.open(sync_info_file, 'r').readline.split("\t")
-        { initial_sync: (items[0] == 'true'),
-          tables: items[1].split(" ") }
-      end
+    def load_sync_info
+      return nil unless File.exists?(sync_info_file)
+      items = File.open(sync_info_file, 'r').readline.split("\t")
+      { initial_sync: (items[0] == 'true'),
+        tables: items[1].split(" ") }
+    end
 
-      def get_table_binlog_pos(table_name)
-        file = File.join(table_positions_dir_path, table_name + ".binlog.pos")
-        return nil unless File.exists?(file)
-        File.open(file, 'r').readline
-      end
+    def get_table_binlog_pos(table_name)
+      file = File.join(table_positions_dir_path, table_name + ".binlog.pos")
+      return nil unless File.exists?(file)
+      File.open(file, 'r').readline
+    end
 
-      def table_rev_file_path(table_name)
-        File.join(table_positions_dir_path, table_name + ".rev")
-      end
+    def table_rev_file_path(table_name)
+      File.join(table_positions_dir_path, table_name + ".rev")
+    end
 
-      def table_rev_file_paths(*tables)
-        tables.empty? ? Dir.glob(File.join(table_positions_dir_path, "*.rev")) :
-          tables.map{|table| table_rev_file_path(table)}
-      end
+    def table_rev_file_paths(*tables)
+      tables.empty? ? Dir.glob(File.join(table_positions_dir_path, "*.rev")) :
+        tables.map{|table| table_rev_file_path(table)}
+    end
 
-      def table_rev(table_name)
-        file = table_rev_file_path(table_name)
-        return 1 unless File.exists?(file) #default revision is 1
-        File.open(file, "r+") do |f|
-          seq = f.read
-          if seq.empty?
-            return 1
-          else
-            return seq.to_i
-          end
+    def table_rev(table_name)
+      file = table_rev_file_path(table_name)
+      return 1 unless File.exists?(file) #default revision is 1
+      File.open(file, "r+") do |f|
+        seq = f.read
+        if seq.empty?
+          return 1
+        else
+          return seq.to_i
         end
       end
+    end
 
-      def increment_table_rev(table_name, base_rev)
-        file = table_rev_file_path(table_name)
-        new_rev = base_rev + 1
-        File.open(file, "w") do |f|
-          f.write(new_rev)
-        end
-        new_rev
+    def increment_table_rev(table_name, base_rev)
+      file = table_rev_file_path(table_name)
+      new_rev = base_rev + 1
+      File.open(file, "w") do |f|
+        f.write(new_rev)
       end
+      new_rev
+    end
 
-      def delete_table_binlog_pos(table_name)
-        file = File.join(table_positions_dir_path, table_name + ".binlog.pos")
-        if File.exists?(file)
-          FileUtils.rm(file, :force => true)
-        else
-          puts "#{file} does not exist. Something is wrong. Did you delete the file manually when flydata was running?"
-        end
+    def delete_table_binlog_pos(table_name)
+      file = File.join(table_positions_dir_path, table_name + ".binlog.pos")
+      if File.exists?(file)
+        FileUtils.rm(file, :force => true)
+      else
+        puts "#{file} does not exist. Something is wrong. Did you delete the file manually when flydata was running?"
       end
+    end
 
-      def save_table_binlog_pos(tables, binlog_pos)
-        tables.each do |table_name|
-          file = File.join(dump_dir, table_name + ".binlog.pos")
-          File.open(file, "w") do |f|
-            f.write(binlog_content(binlog_pos))
-          end
+    def save_table_binlog_pos(tables, binlog_pos)
+      tables.each do |table_name|
+        file = File.join(dump_dir, table_name + ".binlog.pos")
+        File.open(file, "w") do |f|
+          f.write(binlog_content(binlog_pos))
         end
       end
+    end
 
-      def install_table_binlog_files(tables)
-        FileUtils.mkdir_p(table_positions_dir_path) unless Dir.exists?(table_positions_dir_path)
-        tables.each do |table_name|
-          file_name = table_name + ".binlog.pos"
-          src_file = File.join(dump_dir, file_name)
-          if ! File.exists?(src_file)
-            raise "#{src_file} does not exist. Error!!"
-          end
-          FileUtils.mv(src_file, table_positions_dir_path)
-          # save the position at initial sync.  this is used for repair if
-          # necessary.
-          FileUtils.cp(File.join(table_positions_dir_path, file_name), File.join(table_positions_dir_path, file_name + ".init"))
+    def install_table_binlog_files(tables)
+      FileUtils.mkdir_p(table_positions_dir_path) unless Dir.exists?(table_positions_dir_path)
+      tables.each do |table_name|
+        file_name = table_name + ".binlog.pos"
+        src_file = File.join(dump_dir, file_name)
+        if ! File.exists?(src_file)
+          raise "#{src_file} does not exist. Error!!"
         end
+        FileUtils.mv(src_file, table_positions_dir_path)
+        # save the position at initial sync.  this is used for repair if
+        # necessary.
+        FileUtils.cp(File.join(table_positions_dir_path, file_name), File.join(table_positions_dir_path, file_name + ".init"))
       end
+    end
 
-      def delete_dump_file
-        FileUtils.rm(dump_file_path) if File.exists?(dump_file_path)
-      end
+    def delete_dump_file
+      FileUtils.rm(dump_file_path) if File.exists?(dump_file_path)
+    end
 
-      def backup_dump_dir
-        backup_dir = BACKUP_DIR.dup
-        FileUtils.mkdir_p(backup_dir) unless Dir.exists?(backup_dir)
-        dest_dir = File.join(backup_dir, Time.now.strftime("%Y%m%d%H%M%S"))
-        FileUtils.mkdir(dest_dir)
-        FileUtils.mv(Dir.glob("#{dump_dir}/*"), dest_dir)
-      end
+    def backup_dump_dir
+      backup_dir = BACKUP_DIR.dup
+      FileUtils.mkdir_p(backup_dir) unless Dir.exists?(backup_dir)
+      dest_dir = File.join(backup_dir, Time.now.strftime("%Y%m%d%H%M%S"))
+      FileUtils.mkdir(dest_dir)
+      FileUtils.mv(Dir.glob("#{dump_dir}/*"), dest_dir)
+    end
 
-      def backup_dir
-        BACKUP_DIR
-      end
+    def backup_dir
+      BACKUP_DIR
+    end
 
-      private
+    private
 
-      def dump_pos_content(status, table_name, last_pos, binlog_pos, state = nil, substate = nil)
-        [status, table_name, last_pos, binlog_content(binlog_pos), state, substate].join("\t")
-      end
+    def dump_pos_content(status, table_name, last_pos, binlog_pos, state = nil, substate = nil)
+      [status, table_name, last_pos, binlog_content(binlog_pos), state, substate].join("\t")
+    end
 
-      def binlog_content(binlog_pos)
-        [binlog_pos[:binfile], binlog_pos[:pos]].join("\t")
-      end
+    def binlog_content(binlog_pos)
+      [binlog_pos[:binfile], binlog_pos[:pos]].join("\t")
+    end
 
-      def load_mysql_table_marshal_dump
-        path = mysql_table_marshal_dump_path
-        return nil unless File.exists?(path)
-        Marshal.load(File.open(path, 'r'))
-      end
+    def load_mysql_table_marshal_dump
+      path = mysql_table_marshal_dump_path
+      return nil unless File.exists?(path)
+      Marshal.load(File.open(path, 'r'))
+    end
 
-      def dump_dir
-        pref = @data_entry['mysql_data_entry_preference']
-        dump_dir = if pref and pref['mysqldump_dir']
-                     pref['mysqldump_dir']
-                   else
-                     nil
-                   end
-        if dump_dir
-          dump_dir = dump_dir.dup
-          dump_dir[0] = ENV['HOME'] if dump_dir.match(/^~$|^~\//)
-        else
-          dump_dir = DUMP_DIR.dup
-        end
-        if File.exists?(dump_dir) and not Dir.exists?(dump_dir)
-          raise "'mysqldump_dir'(#{dump_dir}) must be a directory."
-        end
-        FileUtils.mkdir_p(dump_dir) unless Dir.exists?(dump_dir)
-        dump_dir
-      end
+    def dump_dir
+      pref = @data_entry['mysql_data_entry_preference']
+      dump_dir = if pref and pref['mysqldump_dir']
+                   pref['mysqldump_dir']
+                 else
+                   nil
+                 end
+      if dump_dir
+        dump_dir = dump_dir.dup
+        dump_dir[0] = ENV['HOME'] if dump_dir.match(/^~$|^~\//)
+      else
+        dump_dir = DUMP_DIR.dup
+      end
+      if File.exists?(dump_dir) and not Dir.exists?(dump_dir)
+        raise "'mysqldump_dir'(#{dump_dir}) must be a directory."
+      end
+      FileUtils.mkdir_p(dump_dir) unless Dir.exists?(dump_dir)
+      dump_dir
     end
   end
 end