fluentd 0.12.40 → 1.6.2

data/test/plugin/test_buf_file.rb

@@ -1,604 +1,967 @@
-# -*- coding: utf-8 -*-
 require_relative '../helper'
-require 'fluent/test'
 require 'fluent/plugin/buf_file'
+require 'fluent/plugin/output'
+require 'fluent/unique_id'
+require 'fluent/system_config'
+require 'fluent/env'
 
-require 'fileutils'
-
-require 'stringio'
 require 'msgpack'
 
-module FluentFileBufferTest
-  class FileBufferChunkTest < Test::Unit::TestCase
-    BUF_FILE_TMPDIR = File.expand_path(File.join(File.dirname(__FILE__), '..', 'tmp', 'buf_file_chunk'))
-
-    def setup
-      if Dir.exists? BUF_FILE_TMPDIR
-        FileUtils.remove_entry_secure BUF_FILE_TMPDIR
-      end
-      FileUtils.mkdir_p BUF_FILE_TMPDIR
+module FluentPluginFileBufferTest
+  class DummyOutputPlugin < Fluent::Plugin::Output
+    Fluent::Plugin.register_output('buffer_file_test_output', self)
+    config_section :buffer do
+      config_set_default :@type, 'file'
     end
-
-    def bufpath(unique, link=false)
-      File.join(BUF_FILE_TMPDIR, unique + '.log' + (link ? '.link' : ''))
+    def multi_workers_ready?
+      true
     end
-
-    def filebufferchunk(key, unique, opts={})
-      Fluent::FileBufferChunk.new(key, bufpath(unique), unique, opts[:mode] || "a+", opts[:symlink])
+    def write(chunk)
+      # drop
     end
+  end
+end
 
-    def test_init
-      chunk = filebufferchunk('key', 'init1')
-      assert_equal 'key', chunk.key
-      assert_equal 'init1', chunk.unique_id
-      assert_equal bufpath('init1'), chunk.path
+class FileBufferTest < Test::Unit::TestCase
+  def metadata(timekey: nil, tag: nil, variables: nil)
+    Fluent::Plugin::Buffer::Metadata.new(timekey, tag, variables)
+  end
 
-      chunk.close # size==0, then, unlinked
+  def write_metadata(path, chunk_id, metadata, size, ctime, mtime)
+    metadata = {
+      timekey: metadata.timekey, tag: metadata.tag, variables: metadata.variables,
+      id: chunk_id,
+      s: size,
+      c: ctime,
+      m: mtime,
+    }
+    File.open(path, 'wb') do |f|
+      f.write metadata.to_msgpack
+    end
+  end
 
-      symlink_path = bufpath('init2', true)
+  sub_test_case 'non configured buffer plugin instance' do
+    setup do
+      Fluent::Test.setup
 
-      chunk = filebufferchunk('key2', 'init2', symlink: symlink_path)
-      assert_equal 'key2', chunk.key
-      assert_equal 'init2', chunk.unique_id
-      assert File.exists?(symlink_path) && File.symlink?(symlink_path)
+      @dir = File.expand_path('../../tmp/buffer_file_dir', __FILE__)
+      FileUtils.rm_rf @dir
+      FileUtils.mkdir_p @dir
+    end
 
-      chunk.close # unlink
+    test 'path should include * normally' do
+      d = FluentPluginFileBufferTest::DummyOutputPlugin.new
+      p = Fluent::Plugin::FileBuffer.new
+      p.owner = d
+      p.configure(config_element('buffer', '', {'path' => File.join(@dir, 'buffer.*.file')}))
+      assert_equal File.join(@dir, 'buffer.*.file'), p.path
+    end
 
-      assert File.symlink?(symlink_path)
-      File.unlink(symlink_path)
+    test 'existing directory will be used with additional default file name' do
+      d = FluentPluginFileBufferTest::DummyOutputPlugin.new
+      p = Fluent::Plugin::FileBuffer.new
+      p.owner = d
+      p.configure(config_element('buffer', '', {'path' => @dir}))
+      assert_equal File.join(@dir, 'buffer.*.log'), p.path
     end
 
-    def test_buffer_chunk_interface
-      chunk = filebufferchunk('key', 'interface1')
+    test 'unexisting path without * handled as directory' do
+      d = FluentPluginFileBufferTest::DummyOutputPlugin.new
+      p = Fluent::Plugin::FileBuffer.new
+      p.owner = d
+      p.configure(config_element('buffer', '', {'path' => File.join(@dir, 'buffer')}))
+      assert_equal File.join(@dir, 'buffer', 'buffer.*.log'), p.path
+    end
+  end
 
-      assert chunk.respond_to?(:empty?)
-      assert chunk.respond_to?(:<<)
-      assert chunk.respond_to?(:size)
-      assert chunk.respond_to?(:close)
-      assert chunk.respond_to?(:purge)
-      assert chunk.respond_to?(:read)
-      assert chunk.respond_to?(:open)
-      assert chunk.respond_to?(:write_to)
-      assert chunk.respond_to?(:msgpack_each)
+  sub_test_case 'buffer configurations and workers' do
+    setup do
+      @bufdir = File.expand_path('../../tmp/buffer_file', __FILE__)
+      FileUtils.rm_rf @bufdir
+      Fluent::Test.setup
 
-      chunk.close
+      @d = FluentPluginFileBufferTest::DummyOutputPlugin.new
+      @p = Fluent::Plugin::FileBuffer.new
+      @p.owner = @d
     end
 
-    def test_empty?
-      chunk = filebufferchunk('e1', 'empty1')
-      assert chunk.empty?
-      chunk.close
+    test 'raise error if configured path is of existing file' do
+      @bufpath = File.join(@bufdir, 'buf')
+      FileUtils.mkdir_p @bufdir
+      File.open(@bufpath, 'w'){|f| } # create and close the file
+      assert File.exist?(@bufpath)
+      assert File.file?(@bufpath)
 
-      open(bufpath('empty2'), 'w') do |file|
-        file.write "data1\ndata2\n"
+      buf_conf = config_element('buffer', '', {'path' => @bufpath})
+      assert_raise Fluent::ConfigError.new("Plugin 'file' does not support multi workers configuration (Fluent::Plugin::FileBuffer)") do
+        Fluent::SystemConfig.overwrite_system_config('workers' => 4) do
+          @d.configure(config_element('ROOT', '', {'@id' => 'dummy_output_with_buf'}, [buf_conf]))
+        end
       end
-      chunk = filebufferchunk('e2', 'empty2')
-      assert !(chunk.empty?)
-      chunk.close
     end
 
-    def test_append_close_purge
-      chunk = filebufferchunk('a1', 'append1')
-      assert chunk.empty?
-
-      test_data1 = ("1" * 9 + "\n" + "2" * 9 + "\n").force_encoding('ASCII-8BIT')
-      test_data2 = "日本語Japanese\n".force_encoding('UTF-8')
-      chunk << test_data1
-      chunk << test_data2
-      assert_equal 38, chunk.size
-      chunk.close
-
-      assert File.exists?(bufpath('append1'))
-
-      chunk = filebufferchunk('a1', 'append1', mode: 'r')
-      test_data = test_data1.force_encoding('ASCII-8BIT') + test_data2.force_encoding('ASCII-8BIT')
-
-      #### TODO: This assertion currently fails. Oops.
-      # FileBuffer#read does NOT do force_encoding('ASCII-8BIT'). So encoding of output string instance are 'UTF-8'.
-      # I think it is a kind of bug, but fixing it may break some behavior of buf_file. So I cannot be sure to fix it just now.
-      #
-      # assert_equal test_data, chunk.read
-
-      chunk.purge
-
-      assert !(File.exists?(bufpath('append1')))
+    test 'raise error if fluentd is configured to use file path pattern and multi workers' do
+      @bufpath = File.join(@bufdir, 'testbuf.*.log')
+      buf_conf = config_element('buffer', '', {'path' => @bufpath})
+      assert_raise Fluent::ConfigError.new("Plugin 'file' does not support multi workers configuration (Fluent::Plugin::FileBuffer)") do
+        Fluent::SystemConfig.overwrite_system_config('workers' => 4) do
+          @d.configure(config_element('ROOT', '', {'@id' => 'dummy_output_with_buf'}, [buf_conf]))
+        end
+      end
     end
 
-    def test_empty_chunk_key # for BufferedOutput#emit
-      chunk = filebufferchunk('', 'append1')
-      assert chunk.empty?
-
-      test_data1 = ("1" * 9 + "\n" + "2" * 9 + "\n").force_encoding('ASCII-8BIT')
-      test_data2 = "日本語Japanese\n".force_encoding('UTF-8')
-      chunk << test_data1
-      chunk << test_data2
-      assert_equal 38, chunk.size
-      chunk.close
+    test 'enables multi worker configuration with unexisting directory path' do
+      assert_false File.exist?(@bufdir)
+      buf_conf = config_element('buffer', '', {'path' => @bufdir})
+      assert_nothing_raised do
+        Fluent::SystemConfig.overwrite_system_config('root_dir' => @bufdir, 'workers' => 4) do
+          @d.configure(config_element('ROOT', '', {}, [buf_conf]))
+        end
+      end
     end
 
-    def test_read
-      chunk = filebufferchunk('r1', 'read1')
-      assert chunk.empty?
-
-      d1 = "abcde" * 200 + "\n"
-      chunk << d1
-      d2 = "12345" * 200 + "\n"
-      chunk << d2
-      assert_equal (d1.size + d2.size), chunk.size
-
-      read_data = chunk.read
-      assert_equal (d1 + d2), read_data
-
-      chunk.purge
+    test 'enables multi worker configuration with existing directory path' do
+      FileUtils.mkdir_p @bufdir
+      buf_conf = config_element('buffer', '', {'path' => @bufdir})
+      assert_nothing_raised do
+        Fluent::SystemConfig.overwrite_system_config('root_dir' => @bufdir, 'workers' => 4) do
+          @d.configure(config_element('ROOT', '', {}, [buf_conf]))
+        end
+      end
     end
 
-    def test_open
-      chunk = filebufferchunk('o1', 'open1')
-      assert chunk.empty?
-
-      d1 = "abcde" * 200 + "\n"
-      chunk << d1
-      d2 = "12345" * 200 + "\n"
-      chunk << d2
-      assert_equal (d1.size + d2.size), chunk.size
+    test 'enables multi worker configuration with root dir' do
+      buf_conf = config_element('buffer', '')
+      assert_nothing_raised do
+        Fluent::SystemConfig.overwrite_system_config('root_dir' => @bufdir, 'workers' => 4) do
+          @d.configure(config_element('ROOT', '', {'@id' => 'dummy_output_with_buf'}, [buf_conf]))
+        end
+      end
+    end
+  end
 
-      read_data = chunk.open do |io|
-        io.read
+  sub_test_case 'buffer plugin configured only with path' do
+    setup do
+      @bufdir = File.expand_path('../../tmp/buffer_file', __FILE__)
+      @bufpath = File.join(@bufdir, 'testbuf.*.log')
+      FileUtils.rm_r @bufdir if File.exist?(@bufdir)
+
+      Fluent::Test.setup
+      @d = FluentPluginFileBufferTest::DummyOutputPlugin.new
+      @p = Fluent::Plugin::FileBuffer.new
+      @p.owner = @d
+      @p.configure(config_element('buffer', '', {'path' => @bufpath}))
+      @p.start
+    end
+
+    teardown do
+      if @p
+        @p.stop unless @p.stopped?
+        @p.before_shutdown unless @p.before_shutdown?
+        @p.shutdown unless @p.shutdown?
+        @p.after_shutdown unless @p.after_shutdown?
+        @p.close unless @p.closed?
+        @p.terminate unless @p.terminated?
+      end
+      if @bufdir
+        Dir.glob(File.join(@bufdir, '*')).each do |path|
+          next if ['.', '..'].include?(File.basename(path))
+          File.delete(path)
+        end
       end
-      assert_equal (d1 + d2), read_data
+    end
 
-      chunk.purge
+    test 'this is persistent plugin' do
+      assert @p.persistent?
     end
 
-    def test_write_to
-      chunk = filebufferchunk('w1', 'write1')
-      assert chunk.empty?
+    test '#start creates directory for buffer chunks' do
+      plugin = Fluent::Plugin::FileBuffer.new
+      plugin.owner = @d
+      rand_num = rand(0..100)
+      bufpath = File.join(File.expand_path("../../tmp/buffer_file_#{rand_num}", __FILE__), 'testbuf.*.log')
+      bufdir = File.dirname(bufpath)
 
-      d1 = "abcde" * 200 + "\n"
-      chunk << d1
-      d2 = "12345" * 200 + "\n"
-      chunk << d2
-      assert_equal (d1.size + d2.size), chunk.size
+      FileUtils.rm_r bufdir if File.exist?(bufdir)
+      assert !File.exist?(bufdir)
 
-      dummy_dst = StringIO.new
+      plugin.configure(config_element('buffer', '', {'path' => bufpath}))
+      assert !File.exist?(bufdir)
 
-      chunk.write_to(dummy_dst)
-      assert_equal (d1 + d2), dummy_dst.string
+      plugin.start
+      assert File.exist?(bufdir)
+      assert{ File.stat(bufdir).mode.to_s(8).end_with?('755') }
 
-      chunk.purge
+      plugin.stop; plugin.before_shutdown; plugin.shutdown; plugin.after_shutdown; plugin.close; plugin.terminate
+      FileUtils.rm_r bufdir
     end
 
-    def test_msgpack_each
-      chunk = filebufferchunk('m1', 'msgpack1')
-      assert chunk.empty?
+    test '#start creates directory for buffer chunks with specified permission' do
+      omit "NTFS doesn't support UNIX like permissions" if Fluent.windows?
 
-      d0 = MessagePack.pack([[1, "foo"], [2, "bar"], [3, "baz"]])
-      d1 = MessagePack.pack({"key1" => "value1", "key2" => "value2"})
-      d2 = MessagePack.pack("string1")
-      d3 = MessagePack.pack(1)
-      d4 = MessagePack.pack(nil)
-      chunk << d0
-      chunk << d1
-      chunk << d2
-      chunk << d3
-      chunk << d4
+      plugin = Fluent::Plugin::FileBuffer.new
+      plugin.owner = @d
+      rand_num = rand(0..100)
+      bufpath = File.join(File.expand_path("../../tmp/buffer_file_#{rand_num}", __FILE__), 'testbuf.*.log')
+      bufdir = File.dirname(bufpath)
 
-      store = []
-      chunk.msgpack_each do |data|
-        store << data
-      end
+      FileUtils.rm_r bufdir if File.exist?(bufdir)
+      assert !File.exist?(bufdir)
 
-      assert_equal 5, store.size
-      assert_equal [[1, "foo"], [2, "bar"], [3, "baz"]], store[0]
-      assert_equal({"key1" => "value1", "key2" => "value2"}, store[1])
-      assert_equal "string1", store[2]
-      assert_equal 1, store[3]
-      assert_equal nil, store[4]
+      plugin.configure(config_element('buffer', '', {'path' => bufpath, 'dir_permission' => '0700'}))
+      assert !File.exist?(bufdir)
 
-      chunk.purge
-    end
+      plugin.start
+      assert File.exist?(bufdir)
+      assert{ File.stat(bufdir).mode.to_s(8).end_with?('700') }
 
-    def test_mv
-      chunk = filebufferchunk('m1', 'move1')
-      assert chunk.empty?
+      plugin.stop; plugin.before_shutdown; plugin.shutdown; plugin.after_shutdown; plugin.close; plugin.terminate
+      FileUtils.rm_r bufdir
+    end
 
-      d1 = "abcde" * 200 + "\n"
-      chunk << d1
-      d2 = "12345" * 200 + "\n"
-      chunk << d2
-      assert_equal (d1.size + d2.size), chunk.size
+    test '#start creates directory for buffer chunks with specified permission via system config' do
+      omit "NTFS doesn't support UNIX like permissions" if Fluent.windows?
 
-      assert_equal bufpath('move1'), chunk.path
+      sysconf = {'dir_permission' => '700'}
+      Fluent::SystemConfig.overwrite_system_config(sysconf) do
+        plugin = Fluent::Plugin::FileBuffer.new
+        plugin.owner = @d
+        rand_num = rand(0..100)
+        bufpath = File.join(File.expand_path("../../tmp/buffer_file_#{rand_num}", __FILE__), 'testbuf.*.log')
+        bufdir = File.dirname(bufpath)
 
-      assert File.exists?( bufpath( 'move1' ) )
-      assert !(File.exists?( bufpath( 'move2' ) ))
+        FileUtils.rm_r bufdir if File.exist?(bufdir)
+        assert !File.exist?(bufdir)
 
-      chunk.mv(bufpath('move2'))
+        plugin.configure(config_element('buffer', '', {'path' => bufpath}))
+        assert !File.exist?(bufdir)
 
-      assert !(File.exists?( bufpath( 'move1' ) ))
-      assert File.exists?( bufpath( 'move2' ) )
+        plugin.start
+        assert File.exist?(bufdir)
+        assert{ File.stat(bufdir).mode.to_s(8).end_with?('700') }
 
-      assert_equal bufpath('move2'), chunk.path
+        plugin.stop; plugin.before_shutdown; plugin.shutdown; plugin.after_shutdown; plugin.close; plugin.terminate
+        FileUtils.rm_r bufdir
+      end
+    end
 
-      chunk.purge
+    test '#generate_chunk generates blank file chunk on path from unique_id of metadata' do
+      m1 = metadata()
+      c1 = @p.generate_chunk(m1)
+      assert c1.is_a? Fluent::Plugin::Buffer::FileChunk
+      assert_equal m1, c1.metadata
+      assert c1.empty?
+      assert_equal :unstaged, c1.state
+      assert_equal Fluent::Plugin::Buffer::FileChunk::FILE_PERMISSION, c1.permission
+      assert_equal @bufpath.gsub('.*.', ".b#{Fluent::UniqueId.hex(c1.unique_id)}."), c1.path
+      assert{ File.stat(c1.path).mode.to_s(8).end_with?('644') }
+
+      m2 = metadata(timekey: event_time('2016-04-17 11:15:00 -0700').to_i)
+      c2 = @p.generate_chunk(m2)
+      assert c2.is_a? Fluent::Plugin::Buffer::FileChunk
+      assert_equal m2, c2.metadata
+      assert c2.empty?
+      assert_equal :unstaged, c2.state
+      assert_equal Fluent::Plugin::Buffer::FileChunk::FILE_PERMISSION, c2.permission
+      assert_equal @bufpath.gsub('.*.', ".b#{Fluent::UniqueId.hex(c2.unique_id)}."), c2.path
+      assert{ File.stat(c2.path).mode.to_s(8).end_with?('644') }
+
+      c1.purge
+      c2.purge
+    end
+
+    test '#generate_chunk generates blank file chunk with specified permission' do
+      omit "NTFS doesn't support UNIX like permissions" if Fluent.windows?
+
+      plugin = Fluent::Plugin::FileBuffer.new
+      plugin.owner = @d
+      rand_num = rand(0..100)
+      bufpath = File.join(File.expand_path("../../tmp/buffer_file_#{rand_num}", __FILE__), 'testbuf.*.log')
+      bufdir = File.dirname(bufpath)
+
+      FileUtils.rm_r bufdir if File.exist?(bufdir)
+      assert !File.exist?(bufdir)
+
+      plugin.configure(config_element('buffer', '', {'path' => bufpath, 'file_permission' => '0600'}))
+      assert !File.exist?(bufdir)
+      plugin.start
+
+      m = metadata()
+      c = plugin.generate_chunk(m)
+      assert c.is_a? Fluent::Plugin::Buffer::FileChunk
+      assert_equal m, c.metadata
+      assert c.empty?
+      assert_equal :unstaged, c.state
+      assert_equal 0600, c.permission
+      assert_equal bufpath.gsub('.*.', ".b#{Fluent::UniqueId.hex(c.unique_id)}."), c.path
+      assert{ File.stat(c.path).mode.to_s(8).end_with?('600') }
+
+      c.purge
+
+      plugin.stop; plugin.before_shutdown; plugin.shutdown; plugin.after_shutdown; plugin.close; plugin.terminate
+      FileUtils.rm_r bufdir
     end
   end
 
-  class FileBufferTest < Test::Unit::TestCase
-    BUF_FILE_TMPDIR = File.expand_path(File.join(File.dirname(__FILE__), '..', 'tmp', 'buf_file'))
-
-    def setup
-      if Dir.exists? BUF_FILE_TMPDIR
-        FileUtils.remove_entry_secure BUF_FILE_TMPDIR
+  sub_test_case 'configured with system root directory and plugin @id' do
+    setup do
+      @root_dir = File.expand_path('../../tmp/buffer_file_root', __FILE__)
+      FileUtils.rm_rf @root_dir
+
+      Fluent::Test.setup
+      @d = FluentPluginFileBufferTest::DummyOutputPlugin.new
+      @p = Fluent::Plugin::FileBuffer.new
+      @p.owner = @d
+      Fluent::SystemConfig.overwrite_system_config('root_dir' => @root_dir) do
+        @d.configure(config_element('ROOT', '', {'@id' => 'dummy_output_with_buf'}))
+        @p.configure(config_element('buffer', ''))
       end
-      FileUtils.mkdir_p BUF_FILE_TMPDIR
-    end
-
-    def bufpath(basename)
-      File.join(BUF_FILE_TMPDIR, basename)
     end
 
-    def filebuffer(key, unique, opts={})
-      Fluent::FileBufferChunk.new(key, bufpath(unique), unique, opts[:mode] || "a+", opts[:symlink])
+    teardown do
+      if @p
+        @p.stop unless @p.stopped?
+        @p.before_shutdown unless @p.before_shutdown?
+        @p.shutdown unless @p.shutdown?
+        @p.after_shutdown unless @p.after_shutdown?
+        @p.close unless @p.closed?
+        @p.terminate unless @p.terminated?
+      end
     end
 
-    def test_init_configure
-      buf = Fluent::FileBuffer.new
-
-      assert_raise(Fluent::ConfigError){ buf.configure({}) }
-
-      buf.configure({'buffer_path' => bufpath('configure1.*.log')})
-      assert_equal bufpath('configure1.*.log'), buf.buffer_path
-      assert_equal nil, buf.symlink_path
-      assert_equal false, buf.instance_eval{ @flush_at_shutdown }
-
-      buf2 = Fluent::FileBuffer.new
+    test '#start creates directory for buffer chunks' do
+      expected_buffer_path = File.join(@root_dir, 'worker0', 'dummy_output_with_buf', 'buffer', 'buffer.*.log')
+      expected_buffer_dir = File.dirname(expected_buffer_path)
+      assert_equal expected_buffer_path, @p.path
+      assert_false Dir.exist?(expected_buffer_dir)
 
-      # Same buffer_path value is rejected, not to overwrite exisitng buffer file.
-      assert_raise(Fluent::ConfigError){ buf2.configure({'buffer_path' => bufpath('configure1.*.log')}) }
+      @p.start
 
-      buf2.configure({'buffer_path' => bufpath('configure2.*.log'), 'flush_at_shutdown' => ''})
-      assert_equal bufpath('configure2.*.log'), buf2.buffer_path
-      assert_equal true, buf2.instance_eval{ @flush_at_shutdown }
+      assert Dir.exist?(expected_buffer_dir)
     end
+  end
 
-    def test_configure_path_prefix_suffix
-      # With '*' in path, prefix is the part before '*', suffix is the part after '*'
-      buf = Fluent::FileBuffer.new
-
-      path1 = bufpath('suffpref1.*.log')
-      prefix1, suffix1 = path1.split('*', 2)
-      buf.configure({'buffer_path' => path1})
-      assert_equal prefix1, buf.instance_eval{ @buffer_path_prefix }
-      assert_equal suffix1, buf.instance_eval{ @buffer_path_suffix }
-
-      # Without '*', prefix is the string of whole path + '.', suffix is '.log'
-      path2 = bufpath('suffpref2')
-      buf.configure({'buffer_path' => path2})
-      assert_equal path2 + '.', buf.instance_eval{ @buffer_path_prefix }
-      assert_equal '.log', buf.instance_eval{ @buffer_path_suffix }
+  sub_test_case 'there are no existing file chunks' do
+    setup do
+      @bufdir = File.expand_path('../../tmp/buffer_file', __FILE__)
+      @bufpath = File.join(@bufdir, 'testbuf.*.log')
+      FileUtils.rm_r @bufdir if File.exist?(@bufdir)
+
+      Fluent::Test.setup
+      @d = FluentPluginFileBufferTest::DummyOutputPlugin.new
+      @p = Fluent::Plugin::FileBuffer.new
+      @p.owner = @d
+      @p.configure(config_element('buffer', '', {'path' => @bufpath}))
+      @p.start
+    end
+    teardown do
+      if @p
+        @p.stop unless @p.stopped?
+        @p.before_shutdown unless @p.before_shutdown?
+        @p.shutdown unless @p.shutdown?
+        @p.after_shutdown unless @p.after_shutdown?
+        @p.close unless @p.closed?
+        @p.terminate unless @p.terminated?
+      end
+      if @bufdir
+        Dir.glob(File.join(@bufdir, '*')).each do |path|
+          next if ['.', '..'].include?(File.basename(path))
+          File.delete(path)
+        end
+      end
     end
 
-    class DummyOutput
-      attr_accessor :written
+    test '#resume returns empty buffer state' do
+      ary = @p.resume
+      assert_equal({}, ary[0])
+      assert_equal([], ary[1])
+    end
+  end
 
-      def write(chunk)
-        @written ||= []
-        @written.push chunk
-        "return value"
+  sub_test_case 'there are some existing file chunks' do
+    setup do
+      @bufdir = File.expand_path('../../tmp/buffer_file', __FILE__)
+      FileUtils.mkdir_p @bufdir unless File.exist?(@bufdir)
+
+      @c1id = Fluent::UniqueId.generate
+      p1 = File.join(@bufdir, "etest.q#{Fluent::UniqueId.hex(@c1id)}.log")
+      File.open(p1, 'wb') do |f|
+        f.write ["t1.test", event_time('2016-04-17 13:58:15 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t2.test", event_time('2016-04-17 13:58:17 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t3.test", event_time('2016-04-17 13:58:21 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t4.test", event_time('2016-04-17 13:58:22 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+      end
+      write_metadata(
+        p1 + '.meta', @c1id, metadata(timekey: event_time('2016-04-17 13:58:00 -0700').to_i),
+        4, event_time('2016-04-17 13:58:00 -0700').to_i, event_time('2016-04-17 13:58:22 -0700').to_i
+      )
+
+      @c2id = Fluent::UniqueId.generate
+      p2 = File.join(@bufdir, "etest.q#{Fluent::UniqueId.hex(@c2id)}.log")
+      File.open(p2, 'wb') do |f|
+        f.write ["t1.test", event_time('2016-04-17 13:59:15 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t2.test", event_time('2016-04-17 13:59:17 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t3.test", event_time('2016-04-17 13:59:21 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+      end
+      write_metadata(
+        p2 + '.meta', @c2id, metadata(timekey: event_time('2016-04-17 13:59:00 -0700').to_i),
+        3, event_time('2016-04-17 13:59:00 -0700').to_i, event_time('2016-04-17 13:59:23 -0700').to_i
+      )
+
+      @c3id = Fluent::UniqueId.generate
+      p3 = File.join(@bufdir, "etest.b#{Fluent::UniqueId.hex(@c3id)}.log")
+      File.open(p3, 'wb') do |f|
+        f.write ["t1.test", event_time('2016-04-17 14:00:15 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t2.test", event_time('2016-04-17 14:00:17 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t3.test", event_time('2016-04-17 14:00:21 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t4.test", event_time('2016-04-17 14:00:28 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+      end
+      write_metadata(
+        p3 + '.meta', @c3id, metadata(timekey: event_time('2016-04-17 14:00:00 -0700').to_i),
+        4, event_time('2016-04-17 14:00:00 -0700').to_i, event_time('2016-04-17 14:00:28 -0700').to_i
+      )
+
+      @c4id = Fluent::UniqueId.generate
+      p4 = File.join(@bufdir, "etest.b#{Fluent::UniqueId.hex(@c4id)}.log")
+      File.open(p4, 'wb') do |f|
+        f.write ["t1.test", event_time('2016-04-17 14:01:15 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t2.test", event_time('2016-04-17 14:01:17 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t3.test", event_time('2016-04-17 14:01:21 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+      end
+      write_metadata(
+        p4 + '.meta', @c4id, metadata(timekey: event_time('2016-04-17 14:01:00 -0700').to_i),
+        3, event_time('2016-04-17 14:01:00 -0700').to_i, event_time('2016-04-17 14:01:25 -0700').to_i
+      )
+
+      @bufpath = File.join(@bufdir, 'etest.*.log')
+
+      Fluent::Test.setup
+      @d = FluentPluginFileBufferTest::DummyOutputPlugin.new
+      @p = Fluent::Plugin::FileBuffer.new
+      @p.owner = @d
+      @p.configure(config_element('buffer', '', {'path' => @bufpath}))
+      @p.start
+    end
+
+    teardown do
+      if @p
+        @p.stop unless @p.stopped?
+        @p.before_shutdown unless @p.before_shutdown?
+        @p.shutdown unless @p.shutdown?
+        @p.after_shutdown unless @p.after_shutdown?
+        @p.close unless @p.closed?
+        @p.terminate unless @p.terminated?
+      end
+      if @bufdir
+        Dir.glob(File.join(@bufdir, '*')).each do |path|
+          next if ['.', '..'].include?(File.basename(path))
+          File.delete(path)
+        end
       end
     end
 
-    def test_encode_key
-      buf = Fluent::FileBuffer.new
-      safe_chars = '-_.abcdefgxyzABCDEFGXYZ0123456789'
-      assert_equal safe_chars, buf.send(:encode_key, safe_chars)
-      unsafe_chars = '-_.abcdefgxyzABCDEFGXYZ0123456789 ~/*()'
-      assert_equal safe_chars + '%20%7E%2F%2A%28%29', buf.send(:encode_key, unsafe_chars)
-    end
+    test '#resume returns staged/queued chunks with metadata' do
+      assert_equal 2, @p.stage.size
+      assert_equal 2, @p.queue.size
 
-    def test_decode_key
-      buf = Fluent::FileBuffer.new
-      safe_chars = '-_.abcdefgxyzABCDEFGXYZ0123456789'
-      assert_equal safe_chars, buf.send(:decode_key, safe_chars)
-      unsafe_chars = '-_.abcdefgxyzABCDEFGXYZ0123456789 ~/*()'
-      assert_equal unsafe_chars, buf.send(:decode_key, safe_chars + '%20%7E%2F%2A%28%29')
+      stage = @p.stage
 
-      assert_equal safe_chars, buf.send(:decode_key, buf.send(:encode_key, safe_chars))
-      assert_equal unsafe_chars, buf.send(:decode_key, buf.send(:encode_key, unsafe_chars))
+      m3 = metadata(timekey: event_time('2016-04-17 14:00:00 -0700').to_i)
+      assert_equal @c3id, stage[m3].unique_id
+      assert_equal 4, stage[m3].size
+      assert_equal :staged, stage[m3].state
+
+      m4 = metadata(timekey: event_time('2016-04-17 14:01:00 -0700').to_i)
+      assert_equal @c4id, stage[m4].unique_id
+      assert_equal 3, stage[m4].size
+      assert_equal :staged, stage[m4].state
     end
 
-    def test_make_path
-      buf = Fluent::FileBuffer.new
-      buf.configure({'buffer_path' => bufpath('makepath.*.log')})
-      prefix = buf.instance_eval{ @buffer_path_prefix }
-      suffix = buf.instance_eval{ @buffer_path_suffix }
+    test '#resume returns queued chunks ordered by last modified time (FIFO)' do
+      assert_equal 2, @p.stage.size
+      assert_equal 2, @p.queue.size
 
-      path,tsuffix = buf.send(:make_path, buf.send(:encode_key, 'foo bar'), 'b')
-      assert path =~ /\A#{prefix}[-_.a-zA-Z0-9\%]+\.[bq][0-9a-f]+#{suffix}\Z/, "invalid format:#{path}"
-      assert tsuffix =~ /\A[0-9a-f]+\Z/, "invalid hexadecimal:#{tsuffix}"
+      queue = @p.queue
 
-      path,tsuffix = buf.send(:make_path, buf.send(:encode_key, 'baz 123'), 'q')
-      assert path =~ /\A#{prefix}[-_.a-zA-Z0-9\%]+\.[bq][0-9a-f]+#{suffix}\Z/, "invalid format:#{path}"
-      assert tsuffix =~ /\A[0-9a-f]+\Z/, "invalid hexadecimal:#{tsuffix}"
-    end
+      assert{ queue[0].modified_at < queue[1].modified_at }
 
-    def test_tsuffix_to_unique_id
-      buf = Fluent::FileBuffer.new
-      # why *2 ? frsyuki said "I forgot why completely."
-      assert_equal "\xFF\xFF\xFF\xFF".force_encoding('ASCII-8BIT'), buf.send(:tsuffix_to_unique_id, 'ffff')
-      assert_equal "\x88\x00\xFF\x00\x11\xEE\x88\x00\xFF\x00\x11\xEE".force_encoding('ASCII-8BIT'), buf.send(:tsuffix_to_unique_id, '8800ff0011ee')
-    end
+      assert_equal @c1id, queue[0].unique_id
+      assert_equal :queued, queue[0].state
+      assert_equal event_time('2016-04-17 13:58:00 -0700').to_i, queue[0].metadata.timekey
+      assert_nil queue[0].metadata.tag
+      assert_nil queue[0].metadata.variables
+      assert_equal Time.parse('2016-04-17 13:58:00 -0700').localtime, queue[0].created_at
+      assert_equal Time.parse('2016-04-17 13:58:22 -0700').localtime, queue[0].modified_at
+      assert_equal 4, queue[0].size
 
-    def test_start_makes_parent_directories
-      buf = Fluent::FileBuffer.new
-      buf.configure({'buffer_path' => bufpath('start/base.*.log')})
-      parent_dirname = File.dirname(buf.instance_eval{ @buffer_path_prefix })
-      assert !(Dir.exists?(parent_dirname))
-      buf.start
-      assert Dir.exists?(parent_dirname)
+      assert_equal @c2id, queue[1].unique_id
+      assert_equal :queued, queue[1].state
+      assert_equal event_time('2016-04-17 13:59:00 -0700').to_i, queue[1].metadata.timekey
+      assert_nil queue[1].metadata.tag
+      assert_nil queue[1].metadata.variables
+      assert_equal Time.parse('2016-04-17 13:59:00 -0700').localtime, queue[1].created_at
+      assert_equal Time.parse('2016-04-17 13:59:23 -0700').localtime, queue[1].modified_at
+      assert_equal 3, queue[1].size
     end
+  end
 
-    def test_new_chunk
-      buf = Fluent::FileBuffer.new
-      buf.configure({'buffer_path' => bufpath('new_chunk_1')})
-      prefix = buf.instance_eval{ @buffer_path_prefix }
-      suffix = buf.instance_eval{ @buffer_path_suffix }
+  sub_test_case 'there are some existing file chunks, both in specified path and per-worker directory under specified path, configured as multi workers' do
+    setup do
+      @bufdir = File.expand_path('../../tmp/buffer_file/path', __FILE__)
+      @worker0_dir = File.join(@bufdir, "worker0")
+      @worker1_dir = File.join(@bufdir, "worker1")
+      FileUtils.rm_rf @bufdir
+      FileUtils.mkdir_p @worker0_dir
+      FileUtils.mkdir_p @worker1_dir
+
+      @bufdir_chunk_1 = Fluent::UniqueId.generate
+      bc1 = File.join(@bufdir, "buffer.q#{Fluent::UniqueId.hex(@bufdir_chunk_1)}.log")
+      File.open(bc1, 'wb') do |f|
+        f.write ["t1.test", event_time('2016-04-17 13:58:15 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t2.test", event_time('2016-04-17 13:58:17 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t3.test", event_time('2016-04-17 13:58:21 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t4.test", event_time('2016-04-17 13:58:22 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+      end
+      write_metadata(
+        bc1 + '.meta', @bufdir_chunk_1, metadata(timekey: event_time('2016-04-17 13:58:00 -0700').to_i),
+        4, event_time('2016-04-17 13:58:00 -0700').to_i, event_time('2016-04-17 13:58:22 -0700').to_i
+      )
+
+      @bufdir_chunk_2 = Fluent::UniqueId.generate
+      bc2 = File.join(@bufdir, "buffer.q#{Fluent::UniqueId.hex(@bufdir_chunk_2)}.log")
+      File.open(bc2, 'wb') do |f|
+        f.write ["t1.test", event_time('2016-04-17 13:58:15 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t2.test", event_time('2016-04-17 13:58:17 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t3.test", event_time('2016-04-17 13:58:21 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t4.test", event_time('2016-04-17 13:58:22 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+      end
+      write_metadata(
+        bc2 + '.meta', @bufdir_chunk_2, metadata(timekey: event_time('2016-04-17 13:58:00 -0700').to_i),
+        4, event_time('2016-04-17 13:58:00 -0700').to_i, event_time('2016-04-17 13:58:22 -0700').to_i
+      )
+
+      @worker_dir_chunk_1 = Fluent::UniqueId.generate
+      wc0_1 = File.join(@worker0_dir, "buffer.q#{Fluent::UniqueId.hex(@worker_dir_chunk_1)}.log")
+      wc1_1 = File.join(@worker1_dir, "buffer.q#{Fluent::UniqueId.hex(@worker_dir_chunk_1)}.log")
+      [wc0_1, wc1_1].each do |chunk_path|
+        File.open(chunk_path, 'wb') do |f|
+          f.write ["t1.test", event_time('2016-04-17 13:59:15 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+          f.write ["t2.test", event_time('2016-04-17 13:59:17 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+          f.write ["t3.test", event_time('2016-04-17 13:59:21 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        end
+        write_metadata(
+          chunk_path + '.meta', @worker_dir_chunk_1, metadata(timekey: event_time('2016-04-17 13:59:00 -0700').to_i),
+          3, event_time('2016-04-17 13:59:00 -0700').to_i, event_time('2016-04-17 13:59:23 -0700').to_i
+        )
+      end
 
-      chunk = buf.new_chunk('key1')
-      assert chunk
-      assert File.exists?(chunk.path)
-      assert chunk.path =~ /\A#{prefix}[-_.a-zA-Z0-9\%]+\.b[0-9a-f]+#{suffix}\Z/, "path from new_chunk must be a 'b' buffer chunk"
-      chunk.close
+      @worker_dir_chunk_2 = Fluent::UniqueId.generate
+      wc0_2 = File.join(@worker0_dir, "buffer.b#{Fluent::UniqueId.hex(@worker_dir_chunk_2)}.log")
+      wc1_2 = File.join(@worker1_dir, "buffer.b#{Fluent::UniqueId.hex(@worker_dir_chunk_2)}.log")
+      [wc0_2, wc1_2].each do |chunk_path|
+        File.open(chunk_path, 'wb') do |f|
+          f.write ["t1.test", event_time('2016-04-17 14:00:15 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+          f.write ["t2.test", event_time('2016-04-17 14:00:17 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+          f.write ["t3.test", event_time('2016-04-17 14:00:21 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+          f.write ["t4.test", event_time('2016-04-17 14:00:28 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        end
+        write_metadata(
+          chunk_path + '.meta', @worker_dir_chunk_2, metadata(timekey: event_time('2016-04-17 14:00:00 -0700').to_i),
+          4, event_time('2016-04-17 14:00:00 -0700').to_i, event_time('2016-04-17 14:00:28 -0700').to_i
+        )
+      end
+
+      @worker_dir_chunk_3 = Fluent::UniqueId.generate
+      wc0_3 = File.join(@worker0_dir, "buffer.b#{Fluent::UniqueId.hex(@worker_dir_chunk_3)}.log")
+      wc1_3 = File.join(@worker1_dir, "buffer.b#{Fluent::UniqueId.hex(@worker_dir_chunk_3)}.log")
+      [wc0_3, wc1_3].each do |chunk_path|
+        File.open(chunk_path, 'wb') do |f|
+          f.write ["t1.test", event_time('2016-04-17 14:01:15 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+          f.write ["t2.test", event_time('2016-04-17 14:01:17 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+          f.write ["t3.test", event_time('2016-04-17 14:01:21 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        end
+        write_metadata(
+          chunk_path + '.meta', @worker_dir_chunk_3, metadata(timekey: event_time('2016-04-17 14:01:00 -0700').to_i),
+          3, event_time('2016-04-17 14:01:00 -0700').to_i, event_time('2016-04-17 14:01:25 -0700').to_i
+        )
+      end
+
+      Fluent::Test.setup
     end
 
-    def test_chunk_identifier_in_path
-      buf1 = Fluent::FileBuffer.new
-      buf1.configure({'buffer_path' => bufpath('chunkid1')})
-      prefix1 = buf1.instance_eval{ @buffer_path_prefix }
-      suffix1 = buf1.instance_eval{ @buffer_path_suffix }
+    teardown do
+      if @p
+        @p.stop unless @p.stopped?
+        @p.before_shutdown unless @p.before_shutdown?
+        @p.shutdown unless @p.shutdown?
+        @p.after_shutdown unless @p.after_shutdown?
+        @p.close unless @p.closed?
+        @p.terminate unless @p.terminated?
+      end
+    end
 
-      chunk1 = buf1.new_chunk('key1')
-      assert_equal chunk1.path, prefix1 + buf1.chunk_identifier_in_path(chunk1.path) + suffix1
+    test 'worker(id=0) #resume returns staged/queued chunks with metadata, not only in worker dir, including the directory specified by path' do
+      ENV['SERVERENGINE_WORKER_ID'] = '0'
 
-      buf2 = Fluent::FileBuffer.new
-      buf2.configure({'buffer_path' => bufpath('chunkid2')})
-      prefix2 = buf2.instance_eval{ @buffer_path_prefix }
-      suffix2 = buf2.instance_eval{ @buffer_path_suffix }
+      buf_conf = config_element('buffer', '', {'path' => @bufdir})
+      @d = FluentPluginFileBufferTest::DummyOutputPlugin.new
+      with_worker_config(workers: 2, worker_id: 0) do
+        @d.configure(config_element('output', '', {}, [buf_conf]))
+      end
 
-      chunk2 = buf2.new_chunk('key2')
-      assert_equal chunk2.path, prefix2 + buf2.chunk_identifier_in_path(chunk2.path) + suffix2
-    end
+      @d.start
+      @p = @d.buffer
 
-    def test_enqueue_moves_chunk_from_b_to_q
-      buf = Fluent::FileBuffer.new
-      buf.configure({'buffer_path' => bufpath('enqueue1')})
-      prefix = buf.instance_eval{ @buffer_path_prefix }
-      suffix = buf.instance_eval{ @buffer_path_suffix }
+      assert_equal 2, @p.stage.size
+      assert_equal 3, @p.queue.size
 
-      chunk = buf.new_chunk('key1')
-      chunk << "data1\ndata2\n"
+      stage = @p.stage
 
-      assert chunk
-      old_path = chunk.path.dup
-      assert File.exists?(chunk.path)
-      assert chunk.path =~ /\A#{prefix}[-_.a-zA-Z0-9\%]+\.b[0-9a-f]+#{suffix}\Z/, "path from new_chunk must be a 'b' buffer chunk"
+      m1 = metadata(timekey: event_time('2016-04-17 14:00:00 -0700').to_i)
+      assert_equal @worker_dir_chunk_2, stage[m1].unique_id
+      assert_equal 4, stage[m1].size
+      assert_equal :staged, stage[m1].state
 
-      buf.enqueue(chunk)
+      m2 = metadata(timekey: event_time('2016-04-17 14:01:00 -0700').to_i)
+      assert_equal @worker_dir_chunk_3, stage[m2].unique_id
+      assert_equal 3, stage[m2].size
+      assert_equal :staged, stage[m2].state
 
-      assert chunk
-      assert File.exists?(chunk.path)
-      assert !(File.exists?(old_path))
-      assert chunk.path =~ /\A#{prefix}[-_.a-zA-Z0-9\%]+\.q[0-9a-f]+#{suffix}\Z/, "enqueued chunk's path must be a 'q' buffer chunk"
+      queue = @p.queue
 
-      data = chunk.read
-      assert "data1\ndata2\n", data
+      assert_equal [@bufdir_chunk_1, @bufdir_chunk_2, @worker_dir_chunk_1].sort, queue.map(&:unique_id).sort
+      assert_equal [3, 4, 4], queue.map(&:size).sort
+      assert_equal [:queued, :queued, :queued], queue.map(&:state)
     end
 
-    # empty chunk keys are used w/ BufferedOutput
-    #  * ObjectBufferedOutput's keys are tag
-    #  * TimeSlicedOutput's keys are time_key
-    def test_enqueue_chunk_with_empty_key
-      buf = Fluent::FileBuffer.new
-      buf.configure({'buffer_path' => bufpath('enqueue2')})
-      prefix = buf.instance_eval{ @buffer_path_prefix }
-      suffix = buf.instance_eval{ @buffer_path_suffix }
+    test 'worker(id=1) #resume returns staged/queued chunks with metadata, only in worker dir' do
+      buf_conf = config_element('buffer', '', {'path' => @bufdir})
+      @d = FluentPluginFileBufferTest::DummyOutputPlugin.new
+      with_worker_config(workers: 2, worker_id: 1) do
+        @d.configure(config_element('output', '', {}, [buf_conf]))
+      end
 
-      chunk = buf.new_chunk('')
-      chunk << "data1\ndata2\n"
+      @d.start
+      @p = @d.buffer
 
-      assert chunk
-      old_path = chunk.path.dup
-      assert File.exists?(chunk.path)
-      # chunk key is empty
-      assert chunk.path =~ /\A#{prefix}\.b[0-9a-f]+#{suffix}\Z/, "path from new_chunk must be a 'b' buffer chunk"
+      assert_equal 2, @p.stage.size
+      assert_equal 1, @p.queue.size
 
-      buf.enqueue(chunk)
+      stage = @p.stage
 
-      assert chunk
-      assert File.exists?(chunk.path)
-      assert !(File.exists?(old_path))
-      # chunk key is empty
-      assert chunk.path =~ /\A#{prefix}\.q[0-9a-f]+#{suffix}\Z/, "enqueued chunk's path must be a 'q' buffer chunk"
+      m1 = metadata(timekey: event_time('2016-04-17 14:00:00 -0700').to_i)
+      assert_equal @worker_dir_chunk_2, stage[m1].unique_id
+      assert_equal 4, stage[m1].size
+      assert_equal :staged, stage[m1].state
 
-      data = chunk.read
-      assert "data1\ndata2\n", data
-    end
+      m2 = metadata(timekey: event_time('2016-04-17 14:01:00 -0700').to_i)
+      assert_equal @worker_dir_chunk_3, stage[m2].unique_id
+      assert_equal 3, stage[m2].size
+      assert_equal :staged, stage[m2].state
 
-    def test_before_shutdown_without_flush_at_shutdown
-      buf = Fluent::FileBuffer.new
-      buf.configure({'buffer_path' => bufpath('before_shutdown1')})
-      buf.start
+      queue = @p.queue
 
-      # before_shutdown does nothing
-
-      c1 = [ buf.new_chunk('k0'), buf.new_chunk('k1'), buf.new_chunk('k2'), buf.new_chunk('k3') ]
-      c2 = [ buf.new_chunk('q0'), buf.new_chunk('q1') ]
+      assert_equal @worker_dir_chunk_1, queue[0].unique_id
+      assert_equal 3, queue[0].size
+      assert_equal :queued, queue[0].state
+    end
+  end
 
-      buf.instance_eval do
-        @map = {
-          'k0' => c1[0], 'k1' => c1[1], 'k2' => c1[2], 'k3' => c1[3],
-          'q0' => c2[0], 'q1' => c2[1]
-        }
+  sub_test_case 'there are some existing file chunks without metadata file' do
+    setup do
+      @bufdir = File.expand_path('../../tmp/buffer_file', __FILE__)
+
+      @c1id = Fluent::UniqueId.generate
+      p1 = File.join(@bufdir, "etest.201604171358.q#{Fluent::UniqueId.hex(@c1id)}.log")
+      File.open(p1, 'wb') do |f|
+        f.write ["t1.test", event_time('2016-04-17 13:58:15 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t2.test", event_time('2016-04-17 13:58:17 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t3.test", event_time('2016-04-17 13:58:21 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t4.test", event_time('2016-04-17 13:58:22 -0700').to_i, {"message" => "yay"}].to_json + "\n"
       end
-      c1[0] << "data1\ndata2\n"
-      c1[1] << "data1\ndata2\n"
-      c1[2] << "data1\ndata2\n"
-      # k3 chunk is empty!
-
-      c2[0] << "data1\ndata2\n"
-      c2[1] << "data1\ndata2\n"
-      buf.push('q0')
-      buf.push('q1')
-
-      buf.instance_eval do
-        @enqueue_hook_times = 0
-        def enqueue(chunk)
-          @enqueue_hook_times += 1
+      FileUtils.touch(p1, mtime: Time.parse('2016-04-17 13:58:28 -0700'))
+
+      @c2id = Fluent::UniqueId.generate
+      p2 = File.join(@bufdir, "etest.201604171359.q#{Fluent::UniqueId.hex(@c2id)}.log")
+      File.open(p2, 'wb') do |f|
+        f.write ["t1.test", event_time('2016-04-17 13:59:15 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t2.test", event_time('2016-04-17 13:59:17 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t3.test", event_time('2016-04-17 13:59:21 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+      end
+      FileUtils.touch(p2, mtime: Time.parse('2016-04-17 13:59:30 -0700'))
+
+      @c3id = Fluent::UniqueId.generate
+      p3 = File.join(@bufdir, "etest.201604171400.b#{Fluent::UniqueId.hex(@c3id)}.log")
+      File.open(p3, 'wb') do |f|
+        f.write ["t1.test", event_time('2016-04-17 14:00:15 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t2.test", event_time('2016-04-17 14:00:17 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t3.test", event_time('2016-04-17 14:00:21 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t4.test", event_time('2016-04-17 14:00:28 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+      end
+      FileUtils.touch(p3, mtime: Time.parse('2016-04-17 14:00:29 -0700'))
+
+      @c4id = Fluent::UniqueId.generate
+      p4 = File.join(@bufdir, "etest.201604171401.b#{Fluent::UniqueId.hex(@c4id)}.log")
+      File.open(p4, 'wb') do |f|
+        f.write ["t1.test", event_time('2016-04-17 14:01:15 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t2.test", event_time('2016-04-17 14:01:17 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t3.test", event_time('2016-04-17 14:01:21 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+      end
+      FileUtils.touch(p4, mtime: Time.parse('2016-04-17 14:01:22 -0700'))
+
+      @bufpath = File.join(@bufdir, 'etest.*.log')
+
+      Fluent::Test.setup
+      @d = FluentPluginFileBufferTest::DummyOutputPlugin.new
+      @p = Fluent::Plugin::FileBuffer.new
+      @p.owner = @d
+      @p.configure(config_element('buffer', '', {'path' => @bufpath}))
+      @p.start
+    end
+
+    teardown do
+      if @p
+        @p.stop unless @p.stopped?
+        @p.before_shutdown unless @p.before_shutdown?
+        @p.shutdown unless @p.shutdown?
+        @p.after_shutdown unless @p.after_shutdown?
+        @p.close unless @p.closed?
+        @p.terminate unless @p.terminated?
+      end
+      if @bufdir
+        Dir.glob(File.join(@bufdir, '*')).each do |path|
+          next if ['.', '..'].include?(File.basename(path))
+          File.delete(path)
         end
       end
-      assert_equal 0, buf.instance_eval{ @enqueue_hook_times }
-
-      out = DummyOutput.new
-      assert_equal nil, out.written
-
-      buf.before_shutdown(out)
-
-      assert_equal 0, buf.instance_eval{ @enqueue_hook_times } # k0, k1, k2
-      assert_nil out.written
     end
 
-    def test_before_shutdown_with_flush_at_shutdown
-      buf = Fluent::FileBuffer.new
-      buf.configure({'buffer_path' => bufpath('before_shutdown2'), 'flush_at_shutdown' => 'true'})
-      buf.start
-
-      # before_shutdown flushes all chunks in @map and @queue
+    test '#resume returns queued chunks for files without metadata' do
+      assert_equal 0, @p.stage.size
+      assert_equal 4, @p.queue.size
 
-      c1 = [ buf.new_chunk('k0'), buf.new_chunk('k1'), buf.new_chunk('k2'), buf.new_chunk('k3') ]
-      c2 = [ buf.new_chunk('q0'), buf.new_chunk('q1') ]
+      queue = @p.queue
 
-      buf.instance_eval do
-        @map = {
-          'k0' => c1[0], 'k1' => c1[1], 'k2' => c1[2], 'k3' => c1[3],
-          'q0' => c2[0], 'q1' => c2[1]
-        }
-      end
-      c1[0] << "data1\ndata2\n"
-      c1[1] << "data1\ndata2\n"
-      c1[2] << "data1\ndata2\n"
-      # k3 chunk is empty!
-
-      c2[0] << "data1\ndata2\n"
-      c2[1] << "data1\ndata2\n"
-      buf.push('q0')
-      buf.push('q1')
+      m = metadata()
 
-      buf.instance_eval do
-        @enqueue_hook_times = 0
-        def enqueue(chunk)
-          @enqueue_hook_times += 1
-        end
-      end
-      assert_equal 0, buf.instance_eval{ @enqueue_hook_times }
+      assert_equal @c1id, queue[0].unique_id
+      assert_equal m, queue[0].metadata
+      assert_equal 0, queue[0].size
+      assert_equal :queued, queue[0].state
+      assert_equal Time.parse('2016-04-17 13:58:28 -0700'), queue[0].modified_at
 
-      out = DummyOutput.new
-      assert_equal nil, out.written
+      assert_equal @c2id, queue[1].unique_id
+      assert_equal m, queue[1].metadata
+      assert_equal 0, queue[1].size
+      assert_equal :queued, queue[1].state
+      assert_equal Time.parse('2016-04-17 13:59:30 -0700'), queue[1].modified_at
 
-      buf.before_shutdown(out)
+      assert_equal @c3id, queue[2].unique_id
+      assert_equal m, queue[2].metadata
+      assert_equal 0, queue[2].size
+      assert_equal :queued, queue[2].state
+      assert_equal Time.parse('2016-04-17 14:00:29 -0700'), queue[2].modified_at
 
-      assert_equal 3, buf.instance_eval{ @enqueue_hook_times } # k0, k1, k2
-      assert_equal 5, out.written.size
-      assert_equal [c2[0], c2[1], c1[0], c1[1], c1[2]], out.written
+      assert_equal @c4id, queue[3].unique_id
+      assert_equal m, queue[3].metadata
+      assert_equal 0, queue[3].size
+      assert_equal :queued, queue[3].state
+      assert_equal Time.parse('2016-04-17 14:01:22 -0700'), queue[3].modified_at
     end
+  end
 
-    def test_resume
-      buffer_path_for_resume_test = bufpath('resume')
-
-      buf1 = Fluent::FileBuffer.new
-      buf1.configure({'buffer_path' => buffer_path_for_resume_test})
-      prefix = buf1.instance_eval{ @buffer_path_prefix }
-      suffix = buf1.instance_eval{ @buffer_path_suffix }
+  sub_test_case 'there are some non-buffer chunk files, with a path without buffer chunk ids' do
+    setup do
+      @bufdir = File.expand_path('../../tmp/buffer_file', __FILE__)
 
-      buf1.start
+      FileUtils.rm_rf @bufdir
+      FileUtils.mkdir_p @bufdir
 
-      chunk1 = buf1.new_chunk('key1')
-      chunk1 << "data1\ndata2\n"
+      @c1id = Fluent::UniqueId.generate
+      p1 = File.join(@bufdir, "etest.201604171358.q#{Fluent::UniqueId.hex(@c1id)}.log")
+      File.open(p1, 'wb') do |f|
+        f.write ["t1.test", event_time('2016-04-17 13:58:15 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t2.test", event_time('2016-04-17 13:58:17 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t3.test", event_time('2016-04-17 13:58:21 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t4.test", event_time('2016-04-17 13:58:22 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+      end
+      FileUtils.touch(p1, mtime: Time.parse('2016-04-17 13:58:28 -0700'))
+
+      @not_chunk = File.join(@bufdir, 'etest.20160416.log')
+      File.open(@not_chunk, 'wb') do |f|
+        f.write ["t1.test", event_time('2016-04-16 23:58:15 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t2.test", event_time('2016-04-16 23:58:17 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t3.test", event_time('2016-04-16 23:58:21 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t4.test", event_time('2016-04-16 23:58:22 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+      end
+      FileUtils.touch(@not_chunk, mtime: Time.parse('2016-04-17 00:00:00 -0700'))
+
+      @bufpath = File.join(@bufdir, 'etest.*.log')
+
+      Fluent::Test.setup
+      @d = FluentPluginFileBufferTest::DummyOutputPlugin.new
+      @p = Fluent::Plugin::FileBuffer.new
+      @p.owner = @d
+      @p.configure(config_element('buffer', '', {'path' => @bufpath}))
+      @p.start
+    end
+
+    teardown do
+      if @p
+        @p.stop unless @p.stopped?
+        @p.before_shutdown unless @p.before_shutdown?
+        @p.shutdown unless @p.shutdown?
+        @p.after_shutdown unless @p.after_shutdown?
+        @p.close unless @p.closed?
+        @p.terminate unless @p.terminated?
+      end
+      if @bufdir
+        Dir.glob(File.join(@bufdir, '*')).each do |path|
+          next if ['.', '..'].include?(File.basename(path))
+          File.delete(path)
+        end
+      end
+    end
 
-      chunk2 = buf1.new_chunk('key2')
-      chunk2 << "data3\ndata4\n"
+    test '#resume returns queued chunks for files without metadata, while ignoring non-chunk looking files' do
+      assert_equal 0, @p.stage.size
+      assert_equal 1, @p.queue.size
 
-      assert chunk1
-      assert chunk1.path =~ /\A#{prefix}[-_.a-zA-Z0-9\%]+\.b[0-9a-f]+#{suffix}\Z/, "path from new_chunk must be a 'b' buffer chunk"
+      queue = @p.queue
 
-      buf1.enqueue(chunk1)
+      m = metadata()
 
-      assert chunk1
-      assert chunk1.path =~ /\A#{prefix}[-_.a-zA-Z0-9\%]+\.q[0-9a-f]+#{suffix}\Z/, "chunk1 must be enqueued"
-      assert chunk2
-      assert chunk2.path =~ /\A#{prefix}[-_.a-zA-Z0-9\%]+\.b[0-9a-f]+#{suffix}\Z/, "chunk2 is not enqueued yet"
+      assert_equal @c1id, queue[0].unique_id
+      assert_equal m, queue[0].metadata
+      assert_equal 0, queue[0].size
+      assert_equal :queued, queue[0].state
+      assert_equal Time.parse('2016-04-17 13:58:28 -0700'), queue[0].modified_at
 
-      buf1.shutdown
+      assert File.exist?(@not_chunk)
+    end
+  end
 
-      buf2 = Fluent::FileBuffer.new
-      Fluent::FileBuffer.send(:class_variable_set, :'@@buffer_paths', {})
-      buf2.configure({'buffer_path' => buffer_path_for_resume_test})
-      prefix = buf2.instance_eval{ @buffer_path_prefix }
-      suffix = buf2.instance_eval{ @buffer_path_suffix }
+  sub_test_case 'there are existing broken file chunks' do
+    setup do
+      @bufdir = File.expand_path('../../tmp/broken_buffer_file', __FILE__)
+      FileUtils.mkdir_p @bufdir unless File.exist?(@bufdir)
+      @bufpath = File.join(@bufdir, 'broken_test.*.log')
+
+      Fluent::Test.setup
+      @d = FluentPluginFileBufferTest::DummyOutputPlugin.new
+      @p = Fluent::Plugin::FileBuffer.new
+      @p.owner = @d
+      @p.configure(config_element('buffer', '', {'path' => @bufpath}))
+    end
+
+    teardown do
+      if @p
+        @p.stop unless @p.stopped?
+        @p.before_shutdown unless @p.before_shutdown?
+        @p.shutdown unless @p.shutdown?
+        @p.after_shutdown unless @p.after_shutdown?
+        @p.close unless @p.closed?
+        @p.terminate unless @p.terminated?
+      end
+      if @bufdir
+        Dir.glob(File.join(@bufdir, '*')).each do |path|
+          next if ['.', '..'].include?(File.basename(path))
+          File.delete(path)
+        end
+      end
+    end
 
-      # buf1.start -> resume is normal operation, but now, we cannot it.
-      queue, map = buf2.resume
+    def create_first_chunk(mode)
+      cid = Fluent::UniqueId.generate
+      path = File.join(@bufdir, "broken_test.#{mode}#{Fluent::UniqueId.hex(cid)}.log")
+      File.open(path, 'wb') do |f|
+        f.write ["t1.test", event_time('2016-04-17 14:00:15 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t2.test", event_time('2016-04-17 14:00:17 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t3.test", event_time('2016-04-17 14:00:21 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t4.test", event_time('2016-04-17 14:00:28 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+      end
+      write_metadata(
+        path + '.meta', cid, metadata(timekey: event_time('2016-04-17 14:00:00 -0700').to_i),
+        4, event_time('2016-04-17 14:00:00 -0700').to_i, event_time('2016-04-17 14:00:28 -0700').to_i
+      )
 
-      assert_equal 1, queue.size
-      assert_equal 1, map.size
+      return cid, path
+    end
 
-      resumed_chunk1 = queue.first
-      assert_equal chunk1.path, resumed_chunk1.path
-      resumed_chunk2 = map['key2']
-      assert_equal chunk2.path, resumed_chunk2.path
+    def create_second_chunk(mode)
+      cid = Fluent::UniqueId.generate
+      path = File.join(@bufdir, "broken_test.#{mode}#{Fluent::UniqueId.hex(cid)}.log")
+      File.open(path, 'wb') do |f|
+        f.write ["t1.test", event_time('2016-04-17 14:01:15 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t2.test", event_time('2016-04-17 14:01:17 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+        f.write ["t3.test", event_time('2016-04-17 14:01:21 -0700').to_i, {"message" => "yay"}].to_json + "\n"
+      end
+      write_metadata(
+        path + '.meta', cid, metadata(timekey: event_time('2016-04-17 14:01:00 -0700').to_i),
+        3, event_time('2016-04-17 14:01:00 -0700').to_i, event_time('2016-04-17 14:01:25 -0700').to_i
+      )
 
-      assert_equal "data1\ndata2\n", resumed_chunk1.read
-      assert_equal "data3\ndata4\n", resumed_chunk2.read
+      return cid, path
     end
 
-    class DummyChain
-      def next
-        true
-      end
+    def compare_staged_chunk(staged, id, time, num, mode)
+      assert_equal 1, staged.size
+      m = metadata(timekey: event_time(time).to_i)
+      assert_equal id, staged[m].unique_id
+      assert_equal num, staged[m].size
+      assert_equal mode, staged[m].state
     end
 
-    def test_resume_only_for_my_buffer_path
-      chain = DummyChain.new
+    def compare_queued_chunk(queued, id, num, mode)
+      assert_equal 1, queued.size
+      assert_equal id, queued[0].unique_id
+      assert_equal num, queued[0].size
+      assert_equal mode, queued[0].state
+    end
 
-      buffer_path_for_resume_test_1 = bufpath('resume_fix.1.*.log')
-      buffer_path_for_resume_test_2 = bufpath('resume_fix.*.log')
+    def compare_log(plugin, msg)
+      logs = plugin.log.out.logs
+      assert { logs.any? { |log| log.include?(msg) } }
+    end
 
-      buf1 = Fluent::FileBuffer.new
-      buf1.configure({'buffer_path' => buffer_path_for_resume_test_1})
-      buf1.start
+    test '#resume ignores staged empty chunk' do
+      _, p1 = create_first_chunk('b')
+      File.open(p1, 'wb') { |f| } # create staged empty chunk file
+      c2id, _ = create_second_chunk('b')
 
-      buf1.emit('key1', "x1\ty1\tz1\n", chain)
-      buf1.emit('key1', "x2\ty2\tz2\n", chain)
+      @p.start
+      compare_staged_chunk(@p.stage, c2id, '2016-04-17 14:01:00 -0700', 3, :staged)
+      compare_log(@p, 'staged file chunk is empty')
+    end
 
-      assert buf1.instance_eval{ @map['key1'] }
+    test '#resume ignores staged broken metadata' do
+      c1id, _ = create_first_chunk('b')
+      _, p2 = create_second_chunk('b')
+      File.open(p2 + '.meta', 'wb') { |f| f.write("\0" * 70) } # create staged broken meta file
 
-      buf1.shutdown
+      @p.start
+      compare_staged_chunk(@p.stage, c1id, '2016-04-17 14:00:00 -0700', 4, :staged)
+      compare_log(@p, 'staged meta file is broken')
+    end
 
-      buf2 = Fluent::FileBuffer.new
-      buf2.configure({'buffer_path' => buffer_path_for_resume_test_2}) # other buffer_path
+    test '#resume ignores enqueued empty chunk' do
+      _, p1 = create_first_chunk('q')
+      File.open(p1, 'wb') { |f| } # create enqueued empty chunk file
+      c2id, _ = create_second_chunk('q')
 
-      queue, map = buf2.resume
+      @p.start
+      compare_queued_chunk(@p.queue, c2id, 3, :queued)
+      compare_log(@p, 'enqueued file chunk is empty')
+    end
 
-      assert_equal 0, queue.size
+    test '#resume ignores enqueued broken metadata' do
+      c1id, _ = create_first_chunk('q')
+      _, p2 = create_second_chunk('q')
+      File.open(p2 + '.meta', 'wb') { |f| f.write("\0" * 70) } # create enqueued broken meta file
 
-      ### TODO: This map size MUST be 0, but actually, 1
-      # This is because 1.XXXXX is misunderstood like chunk key of resume_fix.*.log.
-      # This may be a kind of bug, but we cannot decide whether 1. is a part of chunk key or not,
-      # because current version of buffer plugin uses '.'(dot) as a one of chars for chunk encoding.
-      # I think that this is a mistake of design, but we cannot fix it because updated plugin become
-      # not to be able to resume existing file buffer chunk.
-      # We will fix it in next API version of buffer plugin.
-      assert_equal 1, map.size
+      @p.start
+      compare_queued_chunk(@p.queue, c1id, 4, :queued)
+      compare_log(@p, 'enqueued meta file is broken')
     end
   end
 end