fluentd 1.16.6-x64-mingw-ucrt → 1.16.8-x64-mingw-ucrt

data/test/plugin/test_in_syslog.rb

@@ -5,24 +5,24 @@ require 'fluent/plugin/in_syslog'
 class SyslogInputTest < Test::Unit::TestCase
   def setup
     Fluent::Test.setup
-    @port = unused_port
+    @port = unused_port(protocol: :udp)
   end
 
   def teardown
     @port = nil
   end
 
-  def ipv4_config
+  def ipv4_config(port = @port)
     %[
-      port #{@port}
+      port #{port}
       bind 127.0.0.1
       tag syslog
     ]
   end
 
-  def ipv6_config
+  def ipv6_config(port = @port)
     %[
-      port #{@port}
+      port #{port}
       bind ::1
       tag syslog
     ]
@@ -69,7 +69,8 @@ EOS
        'Use transport and protocol' => ["protocol_type udp\n<transport tcp>\n </transport>", :udp, :tcp])
   def test_configure_protocol(param)
     conf, proto_type, transport_proto_type = *param
-    d = create_driver([ipv4_config, conf].join("\n"))
+    port = unused_port(protocol: proto_type ? proto_type : transport_proto_type)
+    d = create_driver([ipv4_config(port), conf].join("\n"))
 
     assert_equal(d.instance.protocol_type, proto_type)
     assert_equal(d.instance.transport_config.protocol, transport_proto_type)
@@ -158,12 +159,13 @@ EOS
   end
 
   def test_msg_size_with_tcp
-    d = create_driver([ipv4_config, "<transport tcp> \n</transport>"].join("\n"))
+    port = unused_port(protocol: :tcp)
+    d = create_driver([ipv4_config(port), "<transport tcp> \n</transport>"].join("\n"))
     tests = create_test_case
 
     d.run(expect_emits: 2) do
       tests.each {|test|
-        TCPSocket.open('127.0.0.1', @port) do |s|
+        TCPSocket.open('127.0.0.1', port) do |s|
           s.send(test['msg'], 0)
         end
       }
@@ -189,11 +191,12 @@ EOS
   end
 
   def test_msg_size_with_same_tcp_connection
-    d = create_driver([ipv4_config, "<transport tcp> \n</transport>"].join("\n"))
+    port = unused_port(protocol: :tcp)
+    d = create_driver([ipv4_config(port), "<transport tcp> \n</transport>"].join("\n"))
     tests = create_test_case
 
     d.run(expect_emits: 2) do
-      TCPSocket.open('127.0.0.1', @port) do |s|
+      TCPSocket.open('127.0.0.1', port) do |s|
         tests.each {|test|
           s.send(test['msg'], 0)
         }
@@ -347,12 +350,13 @@ EOS
 
   sub_test_case 'octet counting frame' do
     def test_msg_size_with_tcp
-      d = create_driver([ipv4_config, "<transport tcp> \n</transport>", 'frame_type octet_count'].join("\n"))
+      port = unused_port(protocol: :tcp)
+      d = create_driver([ipv4_config(port), "<transport tcp> \n</transport>", 'frame_type octet_count'].join("\n"))
       tests = create_test_case
 
       d.run(expect_emits: 2) do
         tests.each {|test|
-          TCPSocket.open('127.0.0.1', @port) do |s|
+          TCPSocket.open('127.0.0.1', port) do |s|
             s.send(test['msg'], 0)
           end
         }
@@ -363,11 +367,12 @@ EOS
     end
 
     def test_msg_size_with_same_tcp_connection
-      d = create_driver([ipv4_config, "<transport tcp> \n</transport>", 'frame_type octet_count'].join("\n"))
+      port = unused_port(protocol: :tcp)
+      d = create_driver([ipv4_config(port), "<transport tcp> \n</transport>", 'frame_type octet_count'].join("\n"))
       tests = create_test_case
 
       d.run(expect_emits: 2) do
-        TCPSocket.open('127.0.0.1', @port) do |s|
+        TCPSocket.open('127.0.0.1', port) do |s|
           tests.each {|test|
             s.send(test['msg'], 0)
           }
@@ -469,7 +474,8 @@ EOS
   end
 
   def test_send_keepalive_packet_is_disabled_by_default
-    d = create_driver(ipv4_config + %[
+    port = unused_port(protocol: :tcp)
+    d = create_driver(ipv4_config(port) + %[
       <transport tcp>
       </transport>
       protocol tcp
@@ -479,19 +485,20 @@ EOS
 
   def test_send_keepalive_packet_can_be_enabled
     addr = "127.0.0.1"
-    d = create_driver(ipv4_config + %[
+    port = unused_port(protocol: :tcp)
+    d = create_driver(ipv4_config(port) + %[
       <transport tcp>
       </transport>
       send_keepalive_packet true
     ])
     assert_true d.instance.send_keepalive_packet
     mock.proxy(d.instance).server_create_connection(
-      :in_syslog_tcp_server, @port,
+      :in_syslog_tcp_server, port,
       bind: addr,
       resolve_name: nil,
       send_keepalive_packet: true)
     d.run do
-      TCPSocket.open(addr, @port)
+      TCPSocket.open(addr, port)
     end
   end
 

data/test/plugin/test_in_tail.rb

@@ -1611,6 +1611,7 @@ class TailInputTest < Test::Unit::TestCase
 
       cleanup_file("#{@tmp_dir}/tail.txt")
       waiting(20) { sleep 0.1 until Dir.glob("#{@tmp_dir}/*.txt").size == 0 } # Ensure file is deleted on Windows
+      waiting(5) { sleep 0.1 until d.logs.last.include?("detected rotation") }
       waiting(5) { sleep 0.1 until d.instance.instance_variable_get(:@tails).keys.size <= 0 }
 
       assert_equal(
@@ -3172,9 +3173,7 @@ class TailInputTest < Test::Unit::TestCase
         Fluent::FileWrapper.open("#{@tmp_dir}/tail.txt0", "ab") {|f| f.puts "file3 log2"}
       end
 
-      inode_0 = tail_watchers[0]&.ino
-      inode_1 = tail_watchers[1]&.ino
-      inode_2 = tail_watchers[2]&.ino
+      pos_file_inode = tail_watchers[2].pe.read_inode
       record_values = d.events.collect { |event| event[2]["message"] }.sort
       position_entries = []
       Fluent::FileWrapper.open("#{@tmp_dir}/tail.pos", "r") do |f|
@@ -3188,17 +3187,15 @@ class TailInputTest < Test::Unit::TestCase
         {
           record_values: ["file1 log1", "file1 log2", "file2 log1", "file2 log2", "file3 log1", "file3 log2"],
           tail_watcher_paths: ["#{@tmp_dir}/tail.txt0", "#{@tmp_dir}/tail.txt0", "#{@tmp_dir}/tail.txt0"],
-          tail_watcher_inodes: [inode_0, inode_1, inode_2],
           tail_watcher_io_handler_opened_statuses: [false, false, false],
           position_entries: [
             # The recorded path is old, but it is no problem. The path is not used when using follow_inodes.
-            ["#{@tmp_dir}/tail.txt0", "0000000000000016", inode_2],
+            ["#{@tmp_dir}/tail.txt0", "0000000000000016", pos_file_inode],
           ],
         },
         {
           record_values: record_values,
           tail_watcher_paths: tail_watchers.collect { |tw| tw.path },
-          tail_watcher_inodes: tail_watchers.collect { |tw| tw.ino },
           tail_watcher_io_handler_opened_statuses: tail_watchers.collect { |tw| tw.instance_variable_get(:@io_handler)&.opened? || false },
           position_entries: position_entries
         },
@@ -3253,9 +3250,7 @@ class TailInputTest < Test::Unit::TestCase
         sleep 4
       end
 
-      inode_0 = tail_watchers[0]&.ino
-      inode_1 = tail_watchers[1]&.ino
-      inode_2 = tail_watchers[2]&.ino
+      pos_file_inode = tail_watchers[2].pe.read_inode
       record_values = d.events.collect { |event| event[2]["message"] }.sort
       position_entries = []
       Fluent::FileWrapper.open("#{@tmp_dir}/tail.pos", "r") do |f|
@@ -3269,16 +3264,14 @@ class TailInputTest < Test::Unit::TestCase
         {
           record_values: ["file1 log1", "file1 log2", "file2 log1", "file2 log2", "file3 log1", "file3 log2"],
           tail_watcher_paths: ["#{@tmp_dir}/tail.txt0", "#{@tmp_dir}/tail.txt0", "#{@tmp_dir}/tail.txt0"],
-          tail_watcher_inodes: [inode_0, inode_1, inode_2],
           tail_watcher_io_handler_opened_statuses: [false, false, false],
           position_entries: [
-            ["#{@tmp_dir}/tail.txt0", "0000000000000016", inode_2],
+            ["#{@tmp_dir}/tail.txt0", "0000000000000016", pos_file_inode],
           ],
         },
         {
           record_values: record_values,
           tail_watcher_paths: tail_watchers.collect { |tw| tw.path },
-          tail_watcher_inodes: tail_watchers.collect { |tw| tw.ino },
           tail_watcher_io_handler_opened_statuses: tail_watchers.collect { |tw| tw.instance_variable_get(:@io_handler)&.opened? || false },
           position_entries: position_entries
         },

data/test/plugin/test_in_tcp.rb

@@ -5,7 +5,7 @@ require 'fluent/plugin/in_tcp'
 class TcpInputTest < Test::Unit::TestCase
   def setup
     Fluent::Test.setup
-    @port = unused_port
+    @port = unused_port(protocol: :tcp)
   end
 
   def teardown

data/test/plugin/test_in_udp.rb

@@ -5,7 +5,7 @@ require 'fluent/plugin/in_udp'
 class UdpInputTest < Test::Unit::TestCase
   def setup
     Fluent::Test.setup
-    @port = unused_port
+    @port = unused_port(protocol: :udp)
   end
 
   def teardown
@@ -268,25 +268,31 @@ class UdpInputTest < Test::Unit::TestCase
 
   test 'message_length_limit' do
     message_length_limit = 32
+
+    if Fluent.windows?
+      expected_records = ["0" * 30, "4" * 30]
+    else
+      expected_records = 1.upto(3).collect do |i|
+        "#{i}" * message_length_limit
+      end
+      expected_records.prepend("0" * 30)
+      expected_records.append("4" * 30)
+    end
+
     d = create_driver(base_config + %!
       format none
       message_length_limit #{message_length_limit}
     !)
-    d.run(expect_records: 3) do
+    d.run(expect_records: expected_records.size, timeout: 5) do
       create_udp_socket('127.0.0.1', @port) do |u|
-        3.times do |i|
+        u.send("0" * 30 + "\n", 0)
+        1.upto(3) do |i|
           u.send("#{i}" * 40 + "\n", 0)
         end
+        u.send("4" * 30 + "\n", 0)
       end
     end
 
-    if Fluent.windows?
-      expected_records = []
-    else
-      expected_records = 3.times.collect do |i|
-        "#{i}" * message_length_limit
-      end
-    end
     actual_records = d.events.collect do |event|
       event[2]["message"]
     end

data/test/plugin/test_out_exec_filter.rb

@@ -500,10 +500,18 @@ class ExecFilterOutputTest < Test::Unit::TestCase
     d = create_driver(conf)
     time = event_time('2011-01-02 13:14:15')
 
-    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: true,  shutdown: false){ d.feed(time, {"k1" => 0}) }
-    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: false){ d.feed(time, {"k1" => 1}) }
-    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: false){ d.feed(time, {"k1" => 2}) }
-    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: false){ d.feed(time, {"k1" => 3}) }
+    d.run(default_tag: 'test', expect_emits: 4) do
+      d.feed(time, {"k1" => 0})
+      d.flush
+      sleep 0.5
+      d.feed(time, {"k1" => 1})
+      d.flush
+      sleep 0.5
+      d.feed(time, {"k1" => 2})
+      d.flush
+      sleep 0.5
+      d.feed(time, {"k1" => 3})
+    end
 
     assert_equal "2011-01-02 13:14:15\ttest\t0\n", d.formatted[0]
     assert_equal "2011-01-02 13:14:15\ttest\t1\n", d.formatted[1]
@@ -524,9 +532,6 @@ class ExecFilterOutputTest < Test::Unit::TestCase
     assert_equal pid_list[1], events[1][2]['child_pid']
     assert_equal pid_list[0], events[2][2]['child_pid']
     assert_equal pid_list[1], events[3][2]['child_pid']
-
-  ensure
-    d.run(start: false, shutdown: true)
   end
 
   # child process exits per 3 lines

data/test/plugin/test_out_file.rb

@@ -334,7 +334,7 @@ class FileOutputTest < Test::Unit::TestCase
       assert_equal r5, d.formatted[4]
 
       read_gunzip = ->(path){
-        File.open(path){ |fio|
+        File.open(path, 'rb'){ |fio|
           Zlib::GzipReader.new(StringIO.new(fio.read)).read
         }
       }

data/test/plugin/test_out_forward.rb

@@ -12,7 +12,8 @@ class ForwardOutputTest < Test::Unit::TestCase
     FileUtils.rm_rf(TMP_DIR)
     FileUtils.mkdir_p(TMP_DIR)
     @d = nil
-    @target_port = unused_port
+    # forward plugin uses TCP and UDP sockets on the same port number
+    @target_port = unused_port(protocol: :all)
   end
 
   def teardown
@@ -610,7 +611,6 @@ EOL
 
     @d = d = create_driver(config + %[
       require_ack_response true
-      ack_response_timeout 1s
       <buffer tag>
         flush_mode immediate
         retry_type periodic
@@ -658,7 +658,6 @@ EOL
 
     @d = d = create_driver(config + %[
       require_ack_response true
-      ack_response_timeout 10s
       <buffer tag>
         flush_mode immediate
         retry_type periodic

data/test/plugin/test_out_stream.rb

@@ -54,7 +54,7 @@ class TcpOutputTest < Test::Unit::TestCase
 
   def setup
     super
-    @port = unused_port
+    @port = unused_port(protocol: :tcp)
   end
 
   def teardown

data/test/plugin/test_output.rb

@@ -1111,7 +1111,7 @@ class OutputTest < Test::Unit::TestCase
         config: config_element(
           "ROOT", "", {},
           [
-            config_element("buffer", "", {}), 
+            config_element("buffer", "", {}),
             config_element("secondary", "", {"@type" => "test", "name" => "test"}),
           ]
         ),

data/test/plugin/test_output_as_buffered.rb

@@ -1343,6 +1343,7 @@ class BufferedOutputTest < Test::Unit::TestCase
       hash = {
         'flush_interval' => 10,
         'flush_thread_count' => 1,
+        'flush_thread_interval' => 0.1,
         'flush_thread_burst_interval' => 0.1,
         'chunk_limit_size' => 1024,
       }
@@ -1445,7 +1446,7 @@ class BufferedOutputTest < Test::Unit::TestCase
 
       assert{ @i.buffer.stage.size == 3 }
 
-      # to trigger try_flush with flush_thread_burst_interval
+      # to trigger try_flush with flush_thread_interval
       Timecop.freeze( Time.parse('2016-04-13 14:04:11 +0900') )
       @i.enqueue_thread_wait
       Timecop.freeze( Time.parse('2016-04-13 14:04:12 +0900') )
@@ -1454,7 +1455,6 @@ class BufferedOutputTest < Test::Unit::TestCase
       @i.enqueue_thread_wait
       Timecop.freeze( Time.parse('2016-04-13 14:04:14 +0900') )
       @i.enqueue_thread_wait
-      @i.flush_thread_wakeup
 
       assert{ @i.buffer.stage.size == 0 }
 

data/test/plugin/test_output_as_buffered_retries.rb

@@ -941,7 +941,7 @@ class BufferedOutputRetryTest < Test::Unit::TestCase
       @i.enqueue_thread_wait
 
       @i.flush_thread_wakeup
-      waiting(4){ Thread.pass until @i.write_count > 0 }
+      waiting(4){ Thread.pass until @i.write_count > 0 && @i.num_errors > 0 }
       waiting(4) do
         state = @i.instance_variable_get(:@output_flush_threads).first
         state.thread.status == 'sleep'
@@ -953,7 +953,7 @@ class BufferedOutputRetryTest < Test::Unit::TestCase
       now = @i.next_flush_time
       Timecop.freeze( now )
       @i.flush_thread_wakeup
-      waiting(4){ Thread.pass until @i.write_count > 1 }
+      waiting(4){ Thread.pass until @i.write_count > 1 && @i.num_errors > 1 }
       waiting(4) do
         state = @i.instance_variable_get(:@output_flush_threads).first
         state.thread.status == 'sleep'

data/test/plugin/test_parser_csv.rb

@@ -164,7 +164,7 @@ class CSVParserTest < ::Test::Unit::TestCase
       text = 'a"b,"a"""c"'
       assert_raise(CSV::MalformedCSVError) {
         normal.instance.parse(text) { |t, r| }
-      } 
+      }
       assert_nothing_raised {
         # generate broken record
         fast.instance.parse(text) { |t, r| }

data/test/plugin_helper/test_http_server_helper.rb

@@ -14,7 +14,7 @@ class HttpHelperTest < Test::Unit::TestCase
   CERT_CA_DIR = File.expand_path(File.dirname(__FILE__) + '/data/cert/with_ca')
 
   def setup
-    @port = unused_port
+    @port = unused_port(protocol: :tcp)
   end
 
   def teardown