flydata 0.6.3 → 0.6.4

data/spec/flydata/source_mysql/sync_generate_table_ddl_spec.rb

@@ -0,0 +1,137 @@
+require 'flydata/source_mysql/sync_generate_table_ddl'
+
+module Flydata
+module SourceMysql
+
+describe SyncGenerateTableDdl do
+  let(:subject_object) { described_class.new(source, dp, options) }
+
+  let(:dp) { double('dp') }
+  let(:de) { {
+    'mysql_data_entry_preference' => {
+      'host' => 'localhost',
+      'port' => 3306,
+      'username' => 'masashi',
+      'password' => 'welcome',
+      'database' => 'sync_test',
+    }
+  } }
+  let(:options) { {} }
+
+  let(:source) { double('source') }
+  before do
+    allow(source).to receive(:de).and_return de
+  end
+
+  describe '#run_compatibility_check' do
+    subject { subject_object.run_compatibility_check }
+
+    let(:checker) { double("checker") }
+    it do
+      expect(MysqlCompatibilityCheck).to receive(:new).and_return checker
+      expect(checker).to receive(:check)
+
+      subject
+    end
+  end
+  describe '#generate_flydata_tabledef' do
+    subject { subject_object.generate_flydata_tabledef(tables, options) }
+
+    let(:tables) { %w| table1 table2 table4 table3 | }
+
+    context 'with full options' do
+      it 'issues mysqldump command with expected parameters' do
+        expect(Open3).to receive(:popen3).with(
+         'mysqldump -h localhost -P 3306 -umasashi -pwelcome --default-character-set=utf8 --protocol=tcp -d sync_test table1 table2 table4 table3')
+
+        subject
+      end
+    end
+    context 'without_host' do
+      before do
+        de['mysql_data_entry_preference'].delete('host')
+      end
+      it { expect { subject }.to raise_error }
+    end
+    context 'with empty host' do
+      before do
+        de['mysql_data_entry_preference']['host'] = ""
+      end
+      it { expect { subject }.to raise_error }
+    end
+    context 'without port' do
+      before do
+        de['mysql_data_entry_preference'].delete('port')
+      end
+      it "uses the default port" do
+        expect(Open3).to receive(:popen3).with(
+         'mysqldump -h localhost -umasashi -pwelcome --default-character-set=utf8 --protocol=tcp -d sync_test table1 table2 table4 table3')
+        subject
+      end
+    end
+    context 'with port override' do
+      before do
+        de['mysql_data_entry_preference']['port'] = 1234
+      end
+      it "uses the specified port" do
+        expect(Open3).to receive(:popen3).with(
+         'mysqldump -h localhost -P 1234 -umasashi -pwelcome --default-character-set=utf8 --protocol=tcp -d sync_test table1 table2 table4 table3')
+        subject
+      end
+    end
+    context 'without username' do
+      before do
+        de['mysql_data_entry_preference'].delete('username')
+      end
+      it { expect { subject }.to raise_error }
+    end
+    context 'with empty username' do
+      before do
+        de['mysql_data_entry_preference']['username'] = ""
+      end
+      it { expect { subject }.to raise_error }
+    end
+    context 'without_password' do
+      before do
+        de['mysql_data_entry_preference'].delete('password')
+      end
+      it "call mysqldump without MYSQL_PW set" do
+        expect(Open3).to receive(:popen3).with(
+         'mysqldump -h localhost -P 3306 -umasashi --default-character-set=utf8 --protocol=tcp -d sync_test table1 table2 table4 table3')
+        subject
+      end
+    end
+    context 'with password containing symbols' do
+      before do
+        de['mysql_data_entry_preference']['password']="welcome&!@^@#^"
+      end
+      it "call mysqldump with MYSQL_PW set with correct symbols" do
+        expect(Open3).to receive(:popen3).with(
+         'mysqldump -h localhost -P 3306 -umasashi -pwelcome\\&\\!@\\^@\\#\\^ --default-character-set=utf8 --protocol=tcp -d sync_test table1 table2 table4 table3')
+        subject
+      end
+    end
+    context 'without_database' do
+      before do
+        de['mysql_data_entry_preference'].delete('database')
+      end
+      it { expect { subject }.to raise_error }
+    end
+    context 'with empty database' do
+      before do
+        de['mysql_data_entry_preference']['database'] = ""
+      end
+      it { expect { subject }.to raise_error }
+    end
+    context 'with empty tables' do
+      before do
+        de['mysql_data_entry_preference']['tables'] = []
+      end
+      it { expect { subject }.to raise_error }
+    end
+  end
+end
+
+
+end
+end

data/spec/flydata/{mysql → source_mysql}/table_ddl_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
-require 'flydata/mysql/table_ddl'
+require 'flydata/source_mysql/table_ddl'
 
 module Flydata
-module Mysql
+module SourceMysql
 
 describe TableDdl do
   let(:table_name1) { "items" }

data/spec/flydata/source_spec.rb

@@ -0,0 +1,140 @@
+require 'flydata/source'
+
+module Flydata
+
+describe Source do
+  let(:subject_object) { described_class.create(de) }
+
+  let(:target_class) { double('target_class') }
+  let(:type_class) { double('type_class') }
+
+  let(:expected_instance) { double('expected_instance') }
+  let(:de) { double('de') }
+  let(:opts) { double('opts') }
+  let(:class_name) { "replace this" }
+  let(:type_class_name) { "replace this" }
+  let(:data_entry_type) { "RedshiftMysqlDataEntry" }
+
+  before do
+    allow(target_class).to receive(:name).and_return(class_name)
+    allow(type_class).to receive(:name).and_return(type_class_name)
+  end
+  before do
+    allow(de).to receive(:[]).with('type').and_return(data_entry_type)
+  end
+
+  after do
+    if described_class.instance_variable_defined? :@component_classes
+      described_class.remove_instance_variable :@component_classes
+    end
+  end
+
+  describe '#method_missing' do
+    subject { subject_object.send(method_name, opts) }
+
+    before do
+      described_class.register(target_class, type_class)
+    end
+
+    context 'when the target data source exists' do
+      let(:data_entry_type) { "RedshiftMysqlDataEntry" }
+      let(:class_name) { "Flydata::SourceMysql::MySR" }
+
+      context 'when the target component exists' do
+        let(:method_name) { :sync_reset }
+        let(:type_class_name) { "Flydata::Source::SyncReset" }
+
+        it "returns an instance of the target_class" do
+          expect(target_class).to receive(:new).with(subject_object, opts).
+                                  and_return expected_instance
+
+          expect(subject).to eq expected_instance
+        end
+      end
+      context 'when the target component does not exist' do
+        let(:method_name) { :sync_start }
+        let(:type_class_name) { "Flydata::Source::SyncReset" }
+
+        it "raises an error" do
+          expect{ subject }.to raise_error /Component '.*?' is not defined/
+        end
+      end
+    end
+    context 'when the target data source does not exist' do
+      let(:data_entry_type) { "FooBarDataEntry" }
+      let(:class_name) { "Flydata::SourceFooBar::MySR" }
+
+      context 'when the target component exists' do
+        let(:method_name) { :sync_reset }
+        let(:type_class_name) { "Flydata::Source::SyncReset" }
+
+        it "raises an error" do
+          expect{ subject }.to raise_error /No source components are available/
+        end
+      end
+    end
+  end
+
+  describe '.underscored_source_module_sym' do
+    subject { described_class.send(:underscored_source_module_sym, target_class) }
+
+    context 'with a standard name' do
+      let(:class_name) { "Flydata::SourceMysql::SyncReset" }
+      it { is_expected.to eq :source_mysql }
+    end
+    context 'with a nested path' do
+      let(:class_name) { "Flydata::SourceMysql::Command::SyncReset" }
+      it { is_expected.to eq :source_mysql }
+    end
+    context 'with a nested path (not recommended)' do
+      let(:class_name) { "Flydata::Foo::Bar::SourceMysql::SyncReset" }
+      it { is_expected.to eq :source_mysql }
+    end
+    context 'when none of elements starts with "Source"' do
+      let(:class_name) { "Flydata::Foo::Bar::SyncReset" }
+      it { is_expected.to eq nil }
+    end
+    context 'when more than one element start with "Source"' do
+      let(:class_name) { "Flydata::SourceMysql::SourceFiles::SyncReset" }
+      it "uses the first one" do
+        is_expected.to eq :source_mysql
+      end
+    end
+  end
+  describe '.command_dir_paths' do
+    subject { described_class.command_dir_paths }
+
+    before do
+      allow(File).to receive(:exists?).and_return false
+    end
+    shared_examples 'returning the expected result' do
+      before do
+        expect(File).to receive(:exists?).with(/source_mysql\/command/).
+          and_return source_mysql_command_dir_exists
+        expect(File).to receive(:exists?).with(/source_file\/command/).
+          and_return source_file_command_dir_exists
+      end
+      it { is_expected.to eq expected_result }
+    end
+    let(:source_file_command_dir_exists) { false }
+
+    context 'with no source dir' do
+      let(:source_mysql_command_dir_exists) { false }
+      let(:expected_result) { [] }
+      it_behaves_like 'returning the expected result'
+    end
+    context 'with command dir' do
+      let(:source_mysql_command_dir_exists) { true }
+      let(:expected_result) { ["flydata/source_mysql/command"] }
+      it_behaves_like 'returning the expected result'
+    end
+    context 'with two source dirs with command dir' do
+      let(:source_mysql_command_dir_exists) { true }
+      let(:source_file_command_dir_exists) { true }
+      let(:expected_result) { %w(flydata/source_mysql/command flydata/source_file/command) }
+      it_behaves_like 'returning the expected result'
+    end
+  end
+end
+
+end

data/spec/flydata/source_zendesk/sync_generate_table_ddl_spec.rb

@@ -0,0 +1,33 @@
+require 'flydata/source_zendesk/sync_generate_table_ddl'
+
+module Flydata
+module SourceZendesk
+
+describe SyncGenerateTableDdl do
+  let(:subject_object) { described_class.new(source, dp, options) }
+
+  let(:source) { double('source') }
+  let(:dp) { double('dp') }
+  let(:options) { {} }
+
+  describe '#run_compatibility_check' do
+    subject { subject_object.run_compatibility_check }
+    it { subject }
+  end
+
+  describe '#generate_flydata_tabledef' do
+    subject { subject_object.generate_flydata_tabledef(tables, options) }
+
+    let(:supported_tables) { %w(tickets ticket_comments ticket_audits users organizations) }
+    let(:options) { double('options') }
+
+    context 'with all supported tables' do
+      let(:tables) { supported_tables }
+      it { subject }
+    end
+  end
+end
+
+
+end
+end

data/spec/flydata/sync_file_manager_spec.rb

@@ -1,15 +1,19 @@
 # coding: utf-8
 require 'spec_helper'
 require 'flydata/sync_file_manager'
-require 'flydata/parser/mysql/dump_parser'
+require 'flydata/parser/source_table'
+require 'flydata/command/base'
 
 module Flydata
   describe SyncFileManager do
-    let(:subject_object) { described_class.new(default_data_entry) }
+    let(:subject_object) { described_class.new(default_data_entry, source) }
 
-    let(:default_mysqldump_dir) do
+    let(:default_dump_dir) do
       File.join('/tmp', "sync_dump_#{Time.now.to_i}")
     end
+    let(:default_dump_dir2) do
+      File.join('/tmp', "sync_dump2_#{Time.now.to_i}")
+    end
     let(:default_data_entry) do
       {"id"=>93,
       "name"=>"flydata_sync_mysql",
@@ -33,7 +37,7 @@ module Flydata
       "mysql_data_entry_preference" =>
         { "host"=>"localhost", "port"=>3306, "username"=>"masashi",
           "password"=>"welcome", "database"=>"sync_test", "tables"=>nil,
-          "mysqldump_dir"=>default_mysqldump_dir, "forwarder" => "tcpforwarder",
+          "dump_dir"=>default_dump_dir, "forwarder" => "tcpforwarder",
           "data_servers"=>"localhost:9905" }
        }
     end
@@ -42,156 +46,188 @@ module Flydata
     let (:table_name) { 'test_table' }
     let (:table_name2) { 'test_table2' }
     let (:last_pos) { 9999 }
-    let (:binlog_pos) { {binfile: 'mysqlbin.00001', pos: 111}  }
     let (:state) { 'CREATE_TABLE' }
     let (:substate) { nil }
 
+    let(:source_pos_str) { "a position\t\tcould include many tabs\t456" }
+    let(:source_pos_org) { double ('source_pos_org') }
+    let(:source_pos_obj) { double('source_pos_obj') }
+    let(:source) { double('source') }
+    let(:context) { double('context') }
+    let(:columns_hash)  do
+      { 'id' => { column_name: 'id', format_type: 'int' },
+        'value' => { column_name: 'value', format_type: 'text' } }
+    end
+    let(:dump_contents_hash) do
+      { status: status, table_name: table_name, last_pos: last_pos,
+        source_pos: source_pos_obj, state: state, substate: substate }
+    end
+
     after :each do
-      if Dir.exists?(default_mysqldump_dir)
-        Dir.delete(default_mysqldump_dir) rescue nil
+      if Dir.exists?(default_dump_dir)
+        Dir.delete(default_dump_dir) rescue nil
       end
-      if File.exists?(default_mysqldump_dir)
-        File.delete(default_mysqldump_dir) rescue nil
+      if File.exists?(default_dump_dir)
+        File.delete(default_dump_dir) rescue nil
       end
     end
 
     describe '#dump_file_path' do
-      context 'when mysqldump_dir param is nil' do
+      subject { subject_object.dump_file_path }
+      context 'when dump_dir param is nil' do
         before do
-          default_data_entry['mysql_data_entry_preference'].delete('mysqldump_dir')
+          default_data_entry['mysql_data_entry_preference'].delete('dump_dir')
         end
         it do
           stub_const('Flydata::FileUtil::SyncFileManager::DUMP_DIR', File.join(Flydata::FLYDATA_HOME, 'dump'))
-          expect(subject_object.dump_file_path).to eq(
-            File.join(Flydata::FLYDATA_HOME, 'dump', 'flydata_sync_mysql.dump'))
+          is_expected.to eq(File.join(Flydata::FLYDATA_HOME, 'dump', 'flydata_sync_mysql.dump'))
         end
       end
       context 'when file exists' do
-        before { `touch #{default_mysqldump_dir}`}
+        before { `touch #{default_dump_dir}`}
         it do
-          expect{subject_object.dump_file_path}.to raise_error
+          expect{ subject }.to raise_error
         end
       end
       context 'when directory exists' do
-        before { `mkdir -p #{default_mysqldump_dir}`}
+        before { `mkdir -p #{default_dump_dir}`}
         it do
-          expect(FileUtils).to receive(:mkdir_p).with(default_mysqldump_dir).never
-          expect(subject_object.dump_file_path).to eq(
-            File.join(default_mysqldump_dir, 'flydata_sync_mysql.dump'))
+          expect(FileUtils).to receive(:mkdir_p).with(default_dump_dir).never
+          is_expected.to eq(File.join(default_dump_dir, 'flydata_sync_mysql.dump'))
         end
       end
       context 'when directory or file does not exist' do
         it do
-          expect(FileUtils).to receive(:mkdir_p).with(default_mysqldump_dir).once
-          expect(subject_object.dump_file_path).to eq(
-            File.join(default_mysqldump_dir, 'flydata_sync_mysql.dump'))
+          expect(FileUtils).to receive(:mkdir_p).with(default_dump_dir).once
+          is_expected.to eq(File.join(default_dump_dir, 'flydata_sync_mysql.dump'))
         end
       end
       context 'when file name includes "~"' do
-        let(:default_mysqldump_dir) { "~/tmp/dump/sync_spec_#{Time.now.to_i}" }
+        let(:default_dump_dir) { "~/tmp/dump/sync_spec_#{Time.now.to_i}" }
         it do
-          expected_dir = File.join(ENV['HOME'], default_mysqldump_dir[1..-1])
+          expected_dir = File.join(ENV['HOME'], default_dump_dir[1..-1])
           expect(FileUtils).to receive(:mkdir_p).with(expected_dir).once
-          expect(subject_object.dump_file_path).to eq(
-            File.join(expected_dir, 'flydata_sync_mysql.dump'))
+          is_expected.to eq(File.join(expected_dir, 'flydata_sync_mysql.dump'))
         end
       end
     end
 
     describe '#dump_pos_path' do
-      it { expect(subject_object.dump_pos_path).to eq(
-        File.join(default_mysqldump_dir, 'flydata_sync_mysql.dump.pos')) }
+      subject { subject_object.dump_pos_path }
+      it { is_expected.to eq(File.join(default_dump_dir, 'flydata_sync_mysql.dump.pos')) }
     end
 
     describe '#save_dump_pos' do
-      context 'without mysql marshal data' do
+      subject { subject_object.save_dump_pos(status, table_name, last_pos, source_pos_org,
+                  state, substate) }
+      context 'without source marshal data' do
         it do
-          expect{subject_object.save_dump_pos(
-            status, table_name, last_pos, binlog_pos, state, substate)}.not_to raise_error
-            expect(subject_object.load_dump_pos).to eq({
-              status: status, table_name: table_name, last_pos: last_pos,
-              binlog_pos: binlog_pos, state: state, substate: substate,
-              mysql_table: nil
-            })
+          expect(source_pos_org).to receive(:to_s).and_return(source_pos_str)
+          expect{ subject }.not_to raise_error
+
+          expect(source).to receive(:source_pos).and_return(context)
+          expect(context).to receive(:create_source_pos).with(source_pos_str).
+           and_return(source_pos_obj)
+
+          expect(subject_object.load_dump_pos).to eq( dump_contents_hash.merge( { source_table: nil } ) )
         end
       end
     end
 
     describe '#load_dump_pos' do
-      let (:mysql_table) do
-        Flydata::Parser::Mysql::MysqlTable.new(
-          table_name, { 'id' => { column_name: 'id', format_type: 'int' }, 'value' => { column_name: 'value', format_type: 'text' } }
-        )
-      end
+      subject { subject_object.load_dump_pos }
+
+      context 'with source marshal data' do
+        let(:source_table_obj) { double('source_table_obj') }
 
-      context 'with mysql marshal data' do
+        let(:source_table) { Flydata::Parser::SourceTable.new( table_name, columns_hash) }
         before do
-          subject_object.save_mysql_table_marshal_dump(mysql_table)
-          subject_object.save_dump_pos(status, table_name, last_pos, binlog_pos, state, substate)
+          allow(source_pos_org).to receive(:to_s).and_return(source_pos_str)
+          subject_object.save_source_table_marshal_dump(source_table)
+          subject_object.save_dump_pos(status, table_name, last_pos, source_pos_org, state, substate)
         end
         it do
-          ret = subject_object.load_dump_pos
-          mt = ret.delete(:mysql_table)
-          expect(ret).to eq({
-            status: status, table_name: table_name, last_pos: last_pos,
-            binlog_pos: binlog_pos, state: state, substate: substate,
-          })
-          expect(mt.table_name).to eq(table_name)
-          expect(mt.columns).to eq({
-            'id' => { column_name: 'id', format_type: 'int' },
-            'value' => { column_name: 'value', format_type: 'text' },
-          })
+          expect(source).to receive(:source_pos).and_return(context)
+          expect(context).to receive(:create_source_pos).with(source_pos_str).and_return(source_pos_obj)
+          expect(subject_object).to receive(:load_source_table_marshal_dump).and_return(source_table_obj)
+
+          is_expected.to eq( dump_contents_hash.merge({source_table: source_table_obj}) )
         end
       end
     end
 
-    describe '#save_binlog' do
-      let(:binfile) { 'mysqlbinlog.000001' }
-      let(:pos) { 107 }
-      let(:binlog_pos) { {binfile: binfile, pos: pos} }
+    describe '#load_source_table_marshal_dump' do
+      subject { subject_object.send(:load_source_table_marshal_dump) }
+
+      let(:source_table) { Flydata::Parser::SourceTable.new( table_name, columns_hash) }
+      before do
+        subject_object.save_source_table_marshal_dump(source_table)
+      end
       it do
-        subject_object.save_binlog(binlog_pos)
-        expect(`cat #{subject_object.binlog_path}`).to eq("#{binfile}\t#{pos}")
+        expect(subject.table_name).to eq(table_name)
+        expect(subject.columns).to eq(columns_hash)
       end
     end
 
-    describe '#load_binlog' do
-      let(:binfile) { 'mysqlbinlog.000001' }
-      let(:pos) { 107 }
-      let(:binlog_pos) { {binfile: binfile, pos: pos} }
+    describe '#save_source_pos' do
+      subject { subject_object.save_source_pos(source_pos) }
 
-      subject { subject_object.load_binlog }
+      let(:source_pos) { double('source_pos') }
+      let(:source_pos_str) { "a position" }
+      it do
+        expect(source_pos).to receive(:to_s).and_return(source_pos_str)
+        subject
+        expect(`cat #{subject_object.source_pos_path}`).to eq(source_pos_str)
+      end
+    end
+
+    describe '#load_source_pos' do
+      subject { subject_object.load_source_pos }
 
-      context 'when binlog pos does not exist' do
+      before do
+        allow(subject_object).to receive(:source).and_return(source)
+      end
+
+      context 'when source_pos file does not exist' do
         before do
-          File.delete(subject_object.binlog_path) if File.exist?(subject_object.binlog_path)
+          File.delete(subject_object.source_pos_path) if File.exist?(subject_object.source_pos_path)
         end
         it { is_expected.to be_nil }
       end
 
-      context 'when binlog pos exists' do
+      context 'when source_pos file exists' do
         before do
-          subject_object.save_binlog(binlog_pos)
+          File.open(subject_object.source_pos_path, "w"){|f| f.write(source_pos_str)}
+        end
+        after do
+          File.delete(subject_object.source_pos_path)
+        end
+        it do
+          expect(source).to receive(:source_pos).and_return(context)
+          expect(context).to receive(:create_source_pos).with(source_pos_str).
+           and_return(source_pos_obj)
+
+          is_expected.to eq source_pos_obj
         end
-        it { is_expected.to eq(binlog_pos) }
       end
     end
 
-    describe '#binlog_path' do
-      it { expect(subject_object.binlog_path).to eq("#{FLYDATA_HOME}/flydata_sync_mysql.binlog.pos") }
+    describe '#source_pos_path' do
+      subject { subject_object.source_pos_path }
+      it { is_expected.to eq("#{FLYDATA_HOME}/flydata_sync_mysql.binlog.pos") }
     end
 
-    describe '#sent_binlog_path' do
+    describe '#sent_source_pos_path' do
       context 'with no args' do
-        subject { subject_object.sent_binlog_path }
+        subject { subject_object.sent_source_pos_path }
         it { is_expected.to eq("#{FLYDATA_HOME}/flydata_sync_mysql.binlog.sent.pos") }
       end
       context 'with invalid args' do
-        subject { subject_object.sent_binlog_path('/home/ec2-user/.flydata/flydata_sync.pos') }
+        subject { subject_object.sent_source_pos_path('/home/ec2-user/.flydata/flydata_sync.pos') }
         it { expect{subject}.to raise_error(ArgumentError) }
       end
       context 'with valid args' do
-        subject { subject_object.sent_binlog_path('/home/ec2-user/.flydata/flydata_sync.binlog.pos') }
+        subject { subject_object.sent_source_pos_path('/home/ec2-user/.flydata/flydata_sync.binlog.pos') }
         it { is_expected.to eq('/home/ec2-user/.flydata/flydata_sync.binlog.sent.pos') }
       end
     end
@@ -329,5 +365,49 @@ module Flydata
         end
       end
     end
+    describe '#dump_dir' do
+      subject { subject_object.send(:dump_dir) }
+
+      before do
+        default_data_entry["mysql_data_entry_preference"].delete("dump_dir")
+      end
+
+      context 'when the new property is defined' do
+        before do
+          default_data_entry["mysql_data_entry_preference"]["dump_dir"] =
+                                                                     default_dump_dir
+        end
+        context 'when the old property is defined' do
+          before do
+            default_data_entry["mysql_data_entry_preference"]["mysqldump_dir"] =
+                                                                     default_dump_dir2
+          end
+          it 'uses the dir specified by the new property' do
+            is_expected.to eq default_dump_dir
+          end
+        end
+        context 'when the old property is not defined' do
+          it 'uses the dir specified by the new property' do
+            is_expected.to eq default_dump_dir
+          end
+        end
+      end
+      context 'when the new property is not defined' do
+        context 'when the old property is defined' do
+          before do
+            default_data_entry["mysql_data_entry_preference"]["mysqldump_dir"] =
+                                                                     default_dump_dir2
+          end
+          it 'uses the dir specified by the old property' do
+            is_expected.to eq default_dump_dir2
+          end
+        end
+        context 'when the old property is not defined' do
+          it 'uses the default dir' do
+            is_expected.to eq File.join(FLYDATA_HOME, "dump")
+          end
+        end
+      end
+    end
   end
 end