flydata 0.6.3 → 0.6.4

data/spec/flydata/fluent-plugins/mysql/alter_table_query_handler_spec.rb

@@ -17,7 +17,7 @@ module Mysql
         r
       end
       before do
-        parser_class = ParserProvider.parser(:mysql, :mysql_alter_table)
+        parser_class = Flydata::Parser::ParserProvider.parser(:mysql, :mysql_alter_table)
         allow(parser_class).to receive(:new).and_return(parser)
         allow_any_instance_of(described_class).to receive(:check_empty_binlog)
         record.delete('table_name')
@@ -56,8 +56,8 @@ module Mysql
       end
       context "when event binlog is older than table binlog.pos" do
         it 'skip sending event' do
-          expect(sync_fm).to receive(:get_table_binlog_pos).and_return("mysql-bin.000067\t120").once
-          expect(ParserProvider).not_to receive(:parser)
+          expect(sync_fm).to receive(:get_table_source_raw_pos).and_return("mysql-bin.000067\t120").once
+          expect(Flydata::Parser::ParserProvider).not_to receive(:parser)
           expect(subject.process(record)).to eq(nil)
         end
       end

data/spec/flydata/fluent-plugins/mysql/dml_record_handler_spec.rb

@@ -12,7 +12,7 @@ describe DmlRecordHandler do
   let(:tables) { ['items', 'orders'] }
   let(:sync_fm) {
     sfm = double('sync_fm')
-    allow(sfm).to receive(:get_table_binlog_pos).and_return nil
+    allow(sfm).to receive(:get_table_source_raw_pos).and_return nil
     sfm
   }
   let(:context) {

data/spec/flydata/fluent-plugins/mysql/shared_query_handler_context.rb

@@ -4,11 +4,13 @@ module Mysql
     let(:database) { target_database }
     let(:table) { "foo" }
     let(:seq) { 200 }
+    let(:binlog_pos_string) { "mysql-bin.000065\t120" }
+    let(:binlog_pos_object) { FlydataCore::Mysql::BinlogPos.new(binlog_pos_string) }
     let(:sync_fm) do
       r = double('sync_fm')
-      allow(r).to receive(:get_table_binlog_pos).and_return("mysql-bin.000065\t120")
+      allow(r).to receive(:get_table_source_raw_pos).and_return(binlog_pos_string)
       allow(r).to receive(:increment_and_save_table_position).with(table).and_yield(seq).and_return(nil)
-      allow(r).to receive(:delete_table_binlog_pos).with(table)
+      allow(r).to receive(:delete_table_source_pos).with(table)
       r
     end
     let(:table_meta) { double'table_meta' }

data/spec/flydata/fluent-plugins/mysql/truncate_query_handler_spec.rb

@@ -79,7 +79,7 @@ module Mysql
       context 'when per-table binlog pos exists' do
         let(:truncate_query) { "TRUNCATE #{table}" }
         before do
-          allow(sync_fm).to receive(:get_table_binlog_pos).and_return("mysql-bin.000067\t120")
+          allow(sync_fm).to receive(:get_table_source_raw_pos).and_return("mysql-bin.000067\t120")
         end
         include_examples "skip processing queries"
       end

data/spec/flydata/source_mysql/generate_source_dump_spec.rb

@@ -0,0 +1,69 @@
+require 'flydata/source_mysql/generate_source_dump'
+
+module Flydata
+module SourceMysql
+
+describe GenerateSourceDump do
+  let(:subject_object) { described_class.new(source, dp, options) }
+
+  let(:source) { double('source') }
+  before do
+    allow(source).to receive(:de).and_return(de)
+  end
+  let(:dp) { double('dp') }
+  let(:options) { double('options') }
+
+  let(:de) { {
+    "mysql_data_entry_preference" => {
+      "host" => "foo",
+      "port" => 1234,
+      "tables" => all_tables,
+    }
+  } }
+
+  let(:all_tables) { %w|a b c d| + partial_tables }
+  let(:partial_tables) { %w|e f| }
+  let(:file_path) { double('file_path') }
+  let(:src_pos_callback) { Proc.new{} }
+  let(:db_size_check) { double('db_size_check') }
+  let(:size) { double('size') }
+
+  let(:options_with_partial_tables) {
+    prefs = de['mysql_data_entry_preference'].clone
+    prefs["tables"] = partial_tables
+    prefs
+  }
+
+  describe '#dump_size' do
+    subject { subject_object.dump_size(partial_tables) }
+
+    it 'creates DatabaseSizeCheck object with correct parameter' do
+      expect(Parser::DatabaseSizeCheck).to receive(:new).
+        with(options_with_partial_tables).and_return(db_size_check)
+      expect(db_size_check).to receive(:get_db_bytesize).and_return(size)
+
+      expect(subject).to eq size
+    end
+  end
+
+  describe '#dump' do
+    subject { subject_object.dump(partial_tables, file_path, &src_pos_callback) }
+
+    let(:dump_generator) { double('dump_generator') }
+    before do
+      allow(dump_generator).to receive(:dump)
+    end
+
+    it 'creates dump_generator with correct parameters' do
+      expect(Parser::MysqlDumpGeneratorNoMasterData).to receive(:new).
+        with(options_with_partial_tables).and_return(dump_generator)
+      expect(dump_generator).to receive(:dump).
+        with(file_path, &src_pos_callback)
+
+      subject
+    end
+  end
+end
+
+end
+end

data/spec/flydata/source_mysql/mysql_compatibility_check_spec.rb

@@ -0,0 +1,280 @@
+require 'spec_helper'
+require 'flydata/source_mysql/mysql_compatibility_check'
+
+module Flydata
+module SourceMysql
+
+  describe MysqlCompatibilityCheck do
+    let(:subject_object) { described_class.new(dp_hash, de_hash, options) }
+
+    let(:dp_hash) { default_data_port }
+    let(:de_hash) { default_mysql_cred }
+    let(:options) { default_options }
+
+    let(:default_data_port) do
+      {
+        "servers"=>["sample-test-site.com"]
+      }
+     end
+
+    let(:default_mysql_cred) do
+      {
+        "host" => "test",
+        "port" => 1234,
+        "username" => "test",
+        "password" => "password",
+        "database" => "test_db"
+      }
+    end
+
+    let(:default_options) { {} }
+
+    let(:client) { double('client') }
+    before do
+      allow(Mysql2::Client).to receive(:new).and_return(client)
+      allow(client).to receive(:close)
+    end
+
+    describe "#check" do
+      subject { subject_object.check }
+
+      it "calls all check methods" do
+        %w(compatibility56_variable mysql_user_compat mysql_protocol_tcp_compat
+           mysql_parameters_compat rds_master_status mysql_binlog_retention
+           mysql_table_types writing_permissions).each do |method_name|
+          expect(subject_object).to receive("check_#{method_name}".to_sym)
+        end
+
+        subject
+      end
+    end
+
+    describe "#check_mysql_user_compat" do
+      subject { subject_object.check_mysql_user_compat }
+
+      context "with all privileges in all databases" do
+        before do
+          allow(client).to receive(:query).and_return([{"Grants for test"=>"GRANT ALL PRIVILEGES ON *.* TO 'test'@'host"}])
+        end
+        it do
+          expect{subject}.to_not raise_error
+        end
+      end
+      context "with missing privileges in one database" do
+        before do
+          allow(client).to receive(:query).and_return([{"Grants for test"=>"GRANT ALL PRIVILEGES ON 'mysql'.* TO 'test'@'host"},
+                                                       {"Grants for test"=>"GRANT SELECT, RELOAD, REPLICATION CLIENT ON `test_db`.* TO 'test'@'host"}])
+        end
+        it do
+          expect{subject}.to raise_error(FlydataCore::MysqlCompatibilityError, /test_db': LOCK TABLES, REPLICATION SLAVE/)
+        end
+      end
+      context "with all required privileges in between all and specific databases" do
+        before do
+          allow(client).to receive(:query).and_return([{"Grants for test"=>"GRANT RELOAD, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'test'@'host"},
+                                                       {"Grants for test"=>"GRANT SELECT, LOCK TABLES ON `test_db`.* TO 'test'@'host"},
+                                                       {"Grants for test"=>"GRANT SELECT, LOCK TABLES ON `mysql`.* TO 'test'@'host"}])
+        end
+        it do
+          expect{subject}.to_not raise_error
+        end
+      end
+      context "with missing privileges in each database" do
+        before do
+          allow(client).to receive(:query).and_return([{"Grants for test"=>"GRANT REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'test'@'host"},
+                                                       {"Grants for test"=>"GRANT SELECT, LOCK TABLES ON `test_db`.* TO 'test'@'host"},
+                                                       {"Grants for test"=>"GRANT SELECT, LOCK TABLES ON `mysql`.* TO 'test'@'host"}])
+        end
+        it do
+          expect{subject}.to raise_error(FlydataCore::MysqlCompatibilityError, /mysql': RELOAD\n.*test_db': RELOAD/)
+        end
+      end
+      context "with all required privileges in all databases" do
+        before do
+          allow(client).to receive(:query).and_return([{"Grants for test"=>"GRANT SELECT, LOCK TABLES, RELOAD, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'test'@'host"}])
+        end
+        it do
+          expect{subject}.to_not raise_error
+        end
+      end
+      context "with missing privileges in all databases" do
+        before do
+          allow(client).to receive(:query).and_return([{"Grants for test"=>"GRANT RELOAD, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'test'@'host"}])
+        end
+        it do
+          expect{subject}.to raise_error(FlydataCore::MysqlCompatibilityError, /mysql': SELECT, LOCK TABLES\n.*test_db': SELECT, LOCK TABLES/)
+        end
+      end
+      context "with privileges for other databases only" do
+        before do
+          allow(client).to receive(:query).and_return([{"Grants for test"=>"GRANT REPLICATION CLIENT ON `test_db_01`.* TO 'test'@'host"},
+                                                       {"Grants for test"=>"GRANT LOCK TABLES ON `test_db_02`.* TO 'test'@'host"},
+                                                       {"Grants for test"=>"GRANT SELECT ON `text_db_03`.* TO 'test'@'host"}])
+        end
+        it do
+          expect{subject}.to raise_error(FlydataCore::MysqlCompatibilityError, /mysql': SELECT, RELOAD, LOCK TABLES, REPLICATION SLAVE, REPLICATION CLIENT\n.*test_db': SELECT, RELOAD, LOCK TABLES, REPLICATION SLAVE, REPLICATION CLIENT/)
+        end
+      end
+
+    end
+
+    describe "#check_mysql_binlog_retention" do
+      subject { subject_object.check_mysql_binlog_retention }
+      context "on on-premise mysql server" do
+        before do
+          allow(subject_object).to receive(:is_rds?).and_return(false)
+        end
+        context "where retention is below limit" do
+          before do
+            allow(client).to receive(:query).and_return([{"Variable_name" => "expire_logs_days", "Value" => 1}])
+          end
+          it do
+            expect{subject}.to raise_error(FlydataCore::MysqlCompatibilityError, /expire_logs_days/)
+          end
+        end
+        context "where retention is 0" do
+          before do
+            allow(client).to receive(:query).and_return([{"Variable_name" => "expire_logs_days", "Value" => 0}])
+          end
+          it do
+            expect{subject}.to_not raise_error
+          end
+        end
+        context "where retention is above limit" do
+          before do
+            allow(client).to receive(:query).and_return([{"expire_logs_days"=>11}])
+            allow(client).to receive(:query).and_return([{"Variable_name" => "expire_logs_days", "Value" => 11}])
+          end
+          it do
+            expect{subject}.to_not raise_error
+          end
+        end
+      end
+      context "on RDS" do
+        before do
+          allow(subject_object).to receive(:is_rds?).and_return(true)
+        end
+        before do
+          allow(client).to receive(:query).with("SELECT @@expire_logs_days").and_return([{"@@expire_logs_days"=>0}])
+        end
+
+
+        context "where retention period is nil" do
+          before do
+            allow(client).to receive(:query).with("call mysql.rds_show_configuration;").and_return([{"name"=>"binlog retention hours", "value"=>nil}])
+          end
+          it do
+            expect{subject}.to raise_error(FlydataCore::MysqlCompatibilityError, /rds_set_config/)
+          end
+        end
+        context "where retention period is too low" do
+          before do
+            allow(client).to receive(:query).with("call mysql.rds_show_configuration;").and_return([{"name"=>"binlog retention hours", "value"=>4}])
+          end
+          it do
+            expect{subject}.to raise_error(FlydataCore::MysqlCompatibilityError, /rds_set_config/)
+          end
+        end
+        context "where retention period is over recommended limit" do
+          before do
+            allow(client).to receive(:query).with("call mysql.rds_show_configuration;").and_return([{"name"=>"binlog retention hours", "value"=>120}])
+          end
+          it do
+            expect{subject}.to_not raise_error
+          end
+        end
+        context "where user has no access to rds configuration" do
+          before do
+            allow(client).to receive(:query).with("call mysql.rds_show_configuration;").and_raise(Mysql2::Error, "execute command denied to user")
+          end
+          it do
+            expect{subject}.to_not raise_error
+          end
+        end
+      end
+    end
+
+    describe "#check_mysql_table_types" do
+      subject { subject_object.check_mysql_table_types }
+
+      let(:de_hash) do
+        { "host" => "test",
+          "port" => 1234,
+          "username" => "test",
+          "password" => "password",
+          "database" => "test_db",
+          "tables"=>["normal_table", "engine_table", "view_table"] }
+      end
+      let(:normal_table) { {"table_name"=>"normal_table", "table_type"=>"BASE TABLE", "engine"=>"InnoDB"} }
+      let(:engine_table) { {"table_name"=>"engine_table", "table_type"=>"BASE TABLE", "engine"=>"MEMORY"} }
+      let(:blackhole_table) { {"table_name"=>"blackhole_table", "table_type"=>"BASE TABLE", "engine"=>"BLACKHOLE"} }
+      let(:view) { {"table_name"=>"view_table", "table_type"=>"VIEW", "engine"=>nil} }
+      let(:error) { FlydataCore::MysqlCompatibilityError }
+      let(:base_error_msg) { "FlyData does not support VIEW and MEMORY,BLACKHOLE STORAGE ENGINE table. Remove following tables from data entry: %s" }
+      before do
+        allow(client).to receive(:query).and_return(table_list)
+        allow(client).to receive(:escape).and_return("aaa")
+      end
+      context "where data entry has VIEW and MEMORY engine table" do
+        let(:error_msg) { base_error_msg %  engine_table['table_name'] + ', ' + view['table_name'] }
+        let(:table_list) { [ engine_table, view ] }
+        it { expect{subject}.to raise_error(error, /#{error_msg}/) }
+      end
+      context "where data entry has MEMORY engine table" do
+        let(:error_msg) { base_error_msg %  engine_table['table_name'] }
+        let(:table_list) { [ engine_table ] }
+        it { expect{subject}.to raise_error(error, /#{error_msg}/) }
+      end
+      context "where data entry has BLACKHOLE engine table" do
+        let(:error_msg) { base_error_msg %  blackhole_table['table_name'] }
+        let(:table_list) { [ blackhole_table ] }
+        it { expect{subject}.to raise_error(error, /#{error_msg}/) }
+      end
+      context "where data entry has the VIEW" do
+        let(:error_msg) { base_error_msg % view['table_name'] }
+        let(:table_list) { [ view ] }
+        it { expect{subject}.to raise_error(error, /#{error_msg}/) }
+      end
+      context "where data entry does not have either VIEW and ENGINE table" do
+        let(:table_list) { [ normal_table ] }
+        it { expect{subject}.to_not raise_error }
+      end
+    end
+
+    describe "#check_rds_master_status" do
+      subject { subject_object.check_rds_master_status }
+
+      let(:master_status) { [] }
+
+      before do
+        allow(client).to receive(:query).and_return(master_status)
+      end
+
+      context 'when host is rds' do
+        before do
+          de_hash['host'] = 'rdrss.xxyyzz.rds.amazonaws.com'
+        end
+
+        context "where backup retention period is not set" do
+          let(:master_status) { [] }
+          it { expect{subject}.to raise_error(FlydataCore::MysqlCompatibilityError, /Backup Retention Period/) }
+        end
+
+        context "where backup retention period is set" do
+          let(:master_status) do
+            [{
+              'File' => 'mysql-bin-changelog.026292',
+              'Position' => '31300',
+              'Binlog_Do_DB' => '',
+              'Binlog_Ignore_DB' => '',
+              'Executed_Gtid_Set' => '',
+            }]
+          end
+          it { expect{subject}.not_to raise_error }
+        end
+      end
+    end
+  end
+
+end
+end

data/spec/flydata/{parser/mysql → source_mysql/parser}/alter_table_parser_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
-require 'flydata/parser_provider'
+require 'flydata/parser/parser_provider'
 
 describe 'MysqlAlterTableParser' do
   before do
     #load parser
-    @parser_class = Mysql::ParserProvider.parser(:mysql, :mysql_alter_table)
+    @parser_class = Flydata::Parser::ParserProvider.parser(:mysql, :mysql_alter_table)
   end
 
   let(:query) { "" }

data/spec/flydata/{parser/mysql → source_mysql/parser}/dump_parser_spec.rb

@@ -3,11 +3,12 @@ require 'spec_helper'
 require 'open3'
 require 'mysql2'
 require 'flydata/command/sync'
-require 'flydata/parser/mysql/dump_parser'
+require 'flydata/source_mysql/parser/dump_parser'
+require 'flydata-core/mysql/binlog_pos'
 
 module Flydata
-  module Parser
-    module Mysql
+  module SourceMysql
+    module Parser
       context "Test Dump Generators" do
         let(:stdin) do
           s = double(:stdin)
@@ -153,8 +154,9 @@ EOT
             content[0...content.index(string)].bytesize + string.bytesize + 1
           end
 
-          let(:default_parser) { MysqlDumpParser.new(binlog_pos: default_binlog_pos) }
+          let(:default_parser) { MysqlDumpParser.new(source_pos: default_binlog_pos_object) }
           let(:default_binlog_pos) { {binfile: 'mysql-bin.000267', pos: 120 } }
+          let(:default_binlog_pos_object) { FlydataCore::Mysql::BinlogPos.new(default_binlog_pos) }
           let(:dump_pos_after_binlog_pos) { index_after(DUMP_HEADER, '5.6.13-log') }
 
           let(:create_table_block) { double('create_table_block') }
@@ -210,30 +212,30 @@ EOT
             }
             before { generate_dump_file(dump_content) }
             it do
-              expect(create_table_block).to receive(:call) { |mysql_table|
-                expect(mysql_table.table_name).to eq('users_login')
+              expect(create_table_block).to receive(:call) { |source_table|
+                expect(source_table.table_name).to eq('users_login')
               }.once
               expect(insert_record_block).to receive(:call).never
-              expect(check_point_block).to receive(:call) { |mysql_table, last_pos, bytesize, binlog_pos, state, substate|
-                expect(mysql_table).to be_nil
+              expect(check_point_block).to receive(:call) { |source_table, last_pos, bytesize, binlog_pos, state, substate|
+                expect(source_table).to be_nil
                 expect(last_pos).to eq(dump_pos_after_binlog_pos)
                 expect(binlog_pos).to eq(default_binlog_pos)
-                expect(state).to eq(MysqlDumpParser::State::CREATE_TABLE)
+                expect(state).to eq(Flydata::Parser::State::CREATE_TABLE)
                 expect(substate).to be_nil
               }
-              expect(check_point_block).to receive(:call) { |mysql_table, last_pos, bytesize, binlog_pos, state, substate|
-                expect(mysql_table.table_name).to eq('users_login')
-                expect(mysql_table.columns.keys).to eq([col_name, 'login_count', 'create_time', 'update_time'])
+              expect(check_point_block).to receive(:call) { |source_table, last_pos, bytesize, binlog_pos, state, substate|
+                expect(source_table.table_name).to eq('users_login')
+                expect(source_table.columns.keys).to eq([col_name, 'login_count', 'create_time', 'update_time'])
                 expect(last_pos).to eq(index_after(dump_content, 'ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT=\'\';'))
                 expect(binlog_pos).to eq(default_binlog_pos)
-                expect(state).to eq(MysqlDumpParser::State::INSERT_RECORD)
+                expect(state).to eq(Flydata::Parser::State::INSERT_RECORD)
                 expect(substate).to be_nil
               }
-              expect(check_point_block).to receive(:call) { |mysql_table, last_pos, bytesize, binlog_pos, state, substate|
-                expect(mysql_table.table_name).to eq('users_login')
+              expect(check_point_block).to receive(:call) { |source_table, last_pos, bytesize, binlog_pos, state, substate|
+                expect(source_table.table_name).to eq('users_login')
                 expect(last_pos).to eq(index_after(dump_content, 'UNLOCK TABLES;'))
                 expect(binlog_pos).to eq(default_binlog_pos)
-                expect(state).to eq(MysqlDumpParser::State::CREATE_TABLE)
+                expect(state).to eq(Flydata::Parser::State::CREATE_TABLE)
                 expect(substate).to be_nil
               }
               expect(check_point_block).to receive(:call).never
@@ -302,9 +304,9 @@ EOT
             before { generate_dump_file(dump_content) }
             it do
               # create_table_block
-              expect(create_table_block).to receive(:call) { |mysql_table|
-                expect(mysql_table.table_name).to eq('users_login')
-                expect(mysql_table.columns.keys).to eq(['user_id', 'login_count', 'comment', 'create_time', 'update_time'])
+              expect(create_table_block).to receive(:call) { |source_table|
+                expect(source_table.table_name).to eq('users_login')
+                expect(source_table.columns.keys).to eq(['user_id', 'login_count', 'comment', 'create_time', 'update_time'])
               }.once
               expect(create_table_block).to receive(:call).never
 
@@ -316,8 +318,8 @@ EOT
                 [ %w(373 31 out'swearing 1979-10-07\ 08:10:08 2006-02-22\ 16:26:04),
                   %w(493 8 schizophrenic 1979-07-06\ 07:34:07 1970-08-09\ 01:21:01),]
               ].each do |expected_values|
-                expect(insert_record_block).to receive(:call) { |mysql_table, values_set|
-                  expect(mysql_table.table_name).to eq('users_login')
+                expect(insert_record_block).to receive(:call) { |source_table, values_set|
+                  expect(source_table.table_name).to eq('users_login')
                   expect(values_set).to eq(expected_values)
                   nil
                 }.once
@@ -326,13 +328,13 @@ EOT
 
               # insert_record_block
               [
-                {state: MysqlDumpParser::State::CREATE_TABLE},
-                {state: MysqlDumpParser::State::INSERT_RECORD},
-                {state: MysqlDumpParser::State::CREATE_TABLE,
+                {state: Flydata::Parser::State::CREATE_TABLE},
+                {state: Flydata::Parser::State::INSERT_RECORD},
+                {state: Flydata::Parser::State::CREATE_TABLE,
                  last_pos: index_after(dump_content, 'UNLOCK TABLES;')}
               ].each do |expected_params|
-                expect(check_point_block).to receive(:call) { |mysql_table, last_pos, bytesize, binlog_pos, state, substate|
-                  expect(mysql_table.table_name).to eq('users_login') if mysql_table
+                expect(check_point_block).to receive(:call) { |source_table, last_pos, bytesize, binlog_pos, state, substate|
+                  expect(source_table.table_name).to eq('users_login') if source_table
                   expect(state).to eq(expected_params[:state])
                   if expected_params[:last_pos]
                     expect(last_pos).to eq(expected_params[:last_pos])
@@ -384,9 +386,9 @@ EOT
             before { generate_dump_file(dump_content) }
             it do
               # create_table_block
-              expect(create_table_block).to receive(:call) { |mysql_table|
-                expect(mysql_table.table_name).to eq('users_login')
-                expect(mysql_table.columns.keys).to eq(['user_id', 'login_count', 'comment', 'create_time', 'update_time'])
+              expect(create_table_block).to receive(:call) { |source_table|
+                expect(source_table.table_name).to eq('users_login')
+                expect(source_table.columns.keys).to eq(['user_id', 'login_count', 'comment', 'create_time', 'update_time'])
               }.once
               expect(create_table_block).to receive(:call).never
 
@@ -396,8 +398,8 @@ EOT
                   ['35', '6', nil, '1991-10-15 19:38:07', '1970-10-01 22:03:10'],
                   %w(52 33 subfield 1972-08-23\ 20:16:08 1974-10-10\ 23:28:11),],
               ].each do |expected_values|
-                expect(insert_record_block).to receive(:call) { |mysql_table, values_set|
-                  expect(mysql_table.table_name).to eq('users_login')
+                expect(insert_record_block).to receive(:call) { |source_table, values_set|
+                  expect(source_table.table_name).to eq('users_login')
                   expect(values_set).to eq(expected_values)
                   nil
                 }.once
@@ -406,13 +408,13 @@ EOT
 
               # insert_record_block
               [
-                {state: MysqlDumpParser::State::CREATE_TABLE},
-                {state: MysqlDumpParser::State::INSERT_RECORD},
-                {state: MysqlDumpParser::State::CREATE_TABLE,
+                {state: Flydata::Parser::State::CREATE_TABLE},
+                {state: Flydata::Parser::State::INSERT_RECORD},
+                {state: Flydata::Parser::State::CREATE_TABLE,
                  last_pos: index_after(dump_content, 'UNLOCK TABLES;')}
               ].each do |expected_params|
-                expect(check_point_block).to receive(:call) { |mysql_table, last_pos, bytesize, binlog_pos, state, substate|
-                  expect(mysql_table.table_name).to eq('users_login') if mysql_table
+                expect(check_point_block).to receive(:call) { |source_table, last_pos, bytesize, binlog_pos, state, substate|
+                  expect(source_table.table_name).to eq('users_login') if source_table
                   expect(state).to eq(expected_params[:state])
                   if expected_params[:last_pos]
                     expect(last_pos).to eq(expected_params[:last_pos])
@@ -472,16 +474,16 @@ EOT
                 Proc.new{
                   raise "Should not be called"
                 },
-                Proc.new{ |mysql_table, last_pos, bytesize, binlog_pos, state, substate|
-                  if mysql_table
-                    @mysql_table = mysql_table
+                Proc.new{ |source_table, last_pos, bytesize, binlog_pos, state, substate|
+                  if source_table
+                    @source_table = source_table
                     @option = { status: Flydata::Command::Sync::STATUS_PARSING,
-                                table_name: mysql_table.table_name,
+                                table_name: source_table.table_name,
                                 last_pos: last_pos,
                                 binlog_pos: binlog_pos,
                                 state: state,
                                 substate: substate,
-                                mysql_table: mysql_table }
+                                source_table: source_table }
                   end
                 }
               )
@@ -490,15 +492,16 @@ EOT
                 table_name: 'users_login',
                 last_pos: index_after(dump_content_head, 'ENGINE=InnoDB DEFAULT CHARSET=utf8;'),
                 binlog_pos: default_binlog_pos,
-                state: MysqlDumpParser::State::INSERT_RECORD,
+                state: Flydata::Parser::State::INSERT_RECORD,
                 substate: nil,
-                mysql_table: @mysql_table
+                source_table: @source_table
               })
             end
             it do
               generate_dump_file(dump_content_all)
+              @option.delete(:binlog_pos)
+              @option.merge!( {source_pos: default_binlog_pos_object} )
               parser_for_resume = MysqlDumpParser.new(@option)
-
               # create_table_block
               expect(create_table_block).to receive(:call).never
 
@@ -508,8 +511,8 @@ EOT
                   %w(35 6 missteer  1991-10-15\ 19:38:07 1970-10-01\ 22:03:10),
                   %w(52 33 subfield 1972-08-23\ 20:16:08 1974-10-10\ 23:28:11),],
               ].each do |expected_values|
-                expect(insert_record_block).to receive(:call) { |mysql_table, values|
-                  expect(mysql_table.table_name).to eq('users_login')
+                expect(insert_record_block).to receive(:call) { |source_table, values|
+                  expect(source_table.table_name).to eq('users_login')
                   expect(values).to eq(expected_values)
                   nil
                 }.once
@@ -518,11 +521,11 @@ EOT
 
               # check_point_block
               [
-                {state: MysqlDumpParser::State::CREATE_TABLE,
+                {state: Flydata::Parser::State::CREATE_TABLE,
                  last_pos: index_after(dump_content_all, 'UNLOCK TABLES;')}
               ].each do |expected_params|
-                expect(check_point_block).to receive(:call) { |mysql_table, last_pos, bytesize, binlog_pos, state, substate|
-                  expect(mysql_table.table_name).to eq('users_login') if mysql_table
+                expect(check_point_block).to receive(:call) { |source_table, last_pos, bytesize, binlog_pos, state, substate|
+                  expect(source_table.table_name).to eq('users_login') if source_table
                   expect(state).to eq(expected_params[:state])
                   if expected_params[:last_pos]
                     expect(last_pos).to eq(expected_params[:last_pos])
@@ -582,16 +585,16 @@ EOT
                 dump_io,
                 Proc.new{},
                 insert_record_block_for_resume,
-                Proc.new{ |mysql_table, last_pos, bytesize, binlog_pos, state, substate|
+                Proc.new{ |source_table, last_pos, bytesize, binlog_pos, state, substate|
                   if last_pos == index_after(dump_content, "'1972-08-23 20:16:08','1974-10-10 23:28:11');")
-                    @mysql_table = mysql_table
+                    @source_table = source_table
                     @option = { status: Flydata::Command::Sync::STATUS_PARSING,
-                                table_name: mysql_table.table_name,
+                                table_name: source_table.table_name,
                                 last_pos: last_pos,
                                 binlog_pos: binlog_pos,
                                 state: state,
                                 substate: substate,
-                                mysql_table: mysql_table }
+                                source_table: source_table }
                   end
                 }
               )
@@ -600,13 +603,15 @@ EOT
                 table_name: 'users_login',
                 last_pos: index_after(dump_content, "'1972-08-23 20:16:08','1974-10-10 23:28:11');"),
                 binlog_pos: default_binlog_pos,
-                state: MysqlDumpParser::State::INSERT_RECORD,
+                state: Flydata::Parser::State::INSERT_RECORD,
                 substate: nil,
-                mysql_table: @mysql_table
+                source_table: @source_table
               })
             end
             it do
               generate_dump_file(dump_content)
+              @option.delete(:binlog_pos)
+              @option.merge!({source_pos: default_binlog_pos_object})
               parser_for_resume = MysqlDumpParser.new(@option)
 
               # create_table_block
@@ -617,8 +622,8 @@ EOT
                 [ %w(194 11 pandemonium 2008-01-22\ 22:15:10 1991-04-04\ 17:30:05),
                   %w(230 7 cloudburst 2010-12-28\ 11:46:11 1971-06-22\ 13:08:01),],
               ].each do |expected_values|
-                expect(insert_record_block).to receive(:call) { |mysql_table, values_set|
-                  expect(mysql_table.table_name).to eq('users_login')
+                expect(insert_record_block).to receive(:call) { |source_table, values_set|
+                  expect(source_table.table_name).to eq('users_login')
                   expect(values_set).to eq(expected_values)
                   nil
                 }.once
@@ -627,11 +632,11 @@ EOT
 
               # check_point_block
               [
-                {state: MysqlDumpParser::State::CREATE_TABLE,
+                {state: Flydata::Parser::State::CREATE_TABLE,
                  last_pos: index_after(dump_content, 'UNLOCK TABLES;')}
               ].each do |expected_params|
-                expect(check_point_block).to receive(:call) { |mysql_table, last_pos, bytesize, binlog_pos, state, substate|
-                  expect(mysql_table.table_name).to eq('users_login') if mysql_table
+                expect(check_point_block).to receive(:call) { |source_table, last_pos, bytesize, binlog_pos, state, substate|
+                  expect(source_table.table_name).to eq('users_login') if source_table
                   expect(state).to eq(expected_params[:state])
                   if expected_params[:last_pos]
                     expect(last_pos).to eq(expected_params[:last_pos])
@@ -684,9 +689,9 @@ EOT
             before { generate_dump_file(dump_content) }
             it do
               # create_table_block
-              expect(create_table_block).to receive(:call) { |mysql_table|
-                expect(mysql_table.table_name).to eq('users_login')
-                expect(mysql_table.columns.keys).to eq(['user_id', 'login_count', 'comment', 'create_time', 'update_time'])
+              expect(create_table_block).to receive(:call) { |source_table|
+                expect(source_table.table_name).to eq('users_login')
+                expect(source_table.columns.keys).to eq(['user_id', 'login_count', 'comment', 'create_time', 'update_time'])
               }.once
               expect(create_table_block).to receive(:call).never
 
@@ -698,8 +703,8 @@ EOT
                 [ ['373','31',"outs\nwearing",'1979-10-07 08:10:08','2006-02-22 16:26:04'],
                   ['493','8',"schiz\tophrenic",'1979-07-06 07:34:07\'),','1970-08-09,01:21:01,\')'] ]
               ].each do |expected_values|
-                expect(insert_record_block).to receive(:call) { |mysql_table, values_set|
-                  expect(mysql_table.table_name).to eq('users_login')
+                expect(insert_record_block).to receive(:call) { |source_table, values_set|
+                  expect(source_table.table_name).to eq('users_login')
                   expect(values_set).to eq(expected_values)
                   nil
                 }.once
@@ -708,13 +713,13 @@ EOT
 
               # insert_record_block
               [
-                {state: MysqlDumpParser::State::CREATE_TABLE},
-                {state: MysqlDumpParser::State::INSERT_RECORD},
-                {state: MysqlDumpParser::State::CREATE_TABLE,
+                {state: Flydata::Parser::State::CREATE_TABLE},
+                {state: Flydata::Parser::State::INSERT_RECORD},
+                {state: Flydata::Parser::State::CREATE_TABLE,
                  last_pos: index_after(dump_content, 'UNLOCK TABLES;')}
               ].each do |expected_params|
-                expect(check_point_block).to receive(:call) { |mysql_table, last_pos, bytesize, binlog_pos, state, substate|
-                  expect(mysql_table.table_name).to eq('users_login') if mysql_table
+                expect(check_point_block).to receive(:call) { |source_table, last_pos, bytesize, binlog_pos, state, substate|
+                  expect(source_table.table_name).to eq('users_login') if source_table
                   expect(state).to eq(expected_params[:state])
                   if expected_params[:last_pos]
                     expect(last_pos).to eq(expected_params[:last_pos])