fluentd 1.14.4-x64-mingw-ucrt

data/test/plugin_helper/test_timer.rb

@@ -0,0 +1,130 @@
+require_relative '../helper'
+require 'fluent/plugin_helper/timer'
+require 'fluent/plugin/base'
+
+class TimerTest < Test::Unit::TestCase
+  class Dummy < Fluent::Plugin::TestBase
+    helpers :timer
+  end
+
+  test 'can be instantiated under state that timer is not running' do
+    d1 = Dummy.new
+    assert d1.respond_to?(:timer_running?)
+    assert !d1.timer_running?
+  end
+
+  test 'can be configured' do
+    d1 = Dummy.new
+    assert_nothing_raised do
+      d1.configure(config_element())
+    end
+    assert d1.plugin_id
+    assert d1.log
+  end
+
+  test 'can start timers by start' do
+    d1 = Dummy.new
+    d1.configure(config_element())
+    assert !d1.timer_running?
+    d1.start
+    assert d1.timer_running?
+
+    counter = 0
+    d1.timer_execute(:test, 1) do
+      counter += 1
+    end
+
+    sleep 2
+
+    d1.stop
+    assert !d1.timer_running?
+
+    assert{ counter >= 1 && counter <= 2 }
+
+    d1.shutdown; d1.close; d1.terminate
+  end
+
+  test 'can run many timers' do
+    d1 = Dummy.new
+    d1.configure(config_element())
+    d1.start
+
+    counter1 = 0
+    counter2 = 0
+
+    d1.timer_execute(:t1, 0.2) do
+      counter1 += 1
+    end
+    d1.timer_execute(:t2, 0.2) do
+      counter2 += 1
+    end
+
+    sleep 1
+    d1.stop
+
+    assert{ counter1 >= 4 && counter1 <= 5 }
+    assert{ counter2 >= 4 && counter2 <= 5 }
+
+    d1.shutdown; d1.close; d1.terminate
+  end
+
+  test 'aborts timer which raises exceptions' do
+    d1 = Dummy.new
+    d1.configure(config_element())
+    d1.start
+
+    counter1 = 0
+    counter2 = 0
+
+    d1.timer_execute(:t1, 0.2) do
+      counter1 += 1
+    end
+    d1.timer_execute(:t2, 0.2) do
+      raise "abort!!!!!!" if counter2 > 1
+      counter2 += 1
+    end
+
+    sleep 1
+    d1.stop
+
+    assert{ counter1 >= 4 && counter1 <= 5 }
+    assert{ counter2 == 2 }
+    msg = "Unexpected error raised. Stopping the timer. title=:t2"
+    assert(d1.log.out.logs.any?{|line| line.include?("[error]:") && line.include?(msg) && line.include?("abort!!!!!!") })
+    assert(d1.log.out.logs.any?{|line| line.include?("[error]:") && line.include?("Timer detached. title=:t2") })
+
+    d1.shutdown; d1.close; d1.terminate
+  end
+
+  test 'can run at once' do
+    d1 = Dummy.new
+    d1.configure(config_element())
+    assert !d1.timer_running?
+    d1.start
+    assert d1.timer_running?
+
+    waiting_assertion = true
+    waiting_timer = true
+    counter = 0
+    d1.timer_execute(:test, 1, repeat: false) do
+      sleep(0.1) while waiting_assertion
+      counter += 1
+      waiting_timer = false
+    end
+
+    watchers = d1._event_loop.watchers.reject {|w| w.is_a?(Fluent::PluginHelper::EventLoop::DefaultWatcher) }
+    assert_equal(1, watchers.size)
+    assert(watchers.first.attached?)
+
+    waiting_assertion = false
+    sleep(0.1) while waiting_timer
+
+    assert_equal(1, counter)
+    waiting(4){ sleep 0.1 while watchers.first.attached? }
+    assert_false(watchers.first.attached?)
+    watchers = d1._event_loop.watchers.reject {|w| w.is_a?(Fluent::PluginHelper::EventLoop::DefaultWatcher) }
+    assert_equal(0, watchers.size)
+
+    d1.shutdown; d1.close; d1.terminate
+  end
+end

data/test/scripts/exec_script.rb

@@ -0,0 +1,32 @@
+require 'json'
+require 'msgpack'
+
+def gen_tsv(time)
+  "#{time}\ttag1\tok"
+end
+
+def gen_json(time)
+  {'tag' => 'tag1', 'time' => time, 'k1' => 'ok'}.to_json
+end
+
+def gen_msgpack(time)
+  {'tagger' => 'tag1', 'datetime' => time, 'k1' => 'ok'}.to_msgpack
+end
+
+def gen_raw_string(time)
+  "#{time} hello"
+end
+
+time = ARGV.first
+time = Integer(time) rescue time
+
+case ARGV.last.to_i
+when 0
+  puts gen_tsv(time)
+when 1
+  puts gen_json(time)
+when 2
+  print gen_msgpack(time)
+when 3
+  print gen_raw_string(time)
+end

data/test/scripts/fluent/plugin/formatter1/formatter_test1.rb

@@ -0,0 +1,7 @@
+module Fluent
+  Plugin.register_formatter(
+    'test1',
+    Proc.new { |tag, time, record|
+      "#{tag}:#{time}:#{record.size}"
+    })
+end

data/test/scripts/fluent/plugin/formatter2/formatter_test2.rb

@@ -0,0 +1,7 @@
+module Fluent
+  Plugin.register_formatter(
+    'test2',
+    Proc.new { |tag, time, record|
+      "#{tag}:#{time}:#{record.size}"
+    })
+end

data/test/scripts/fluent/plugin/formatter_known.rb

@@ -0,0 +1,8 @@
+module Fluent
+  TextFormatter.register_template('known_old', Proc.new { |tag, time, record|
+      "#{tag}:#{time}:#{record.size}"
+    })
+  Plugin.register_formatter('known', Proc.new { |tag, time, record|
+      "#{tag}:#{time}:#{record.size}"
+    })
+end

data/test/scripts/fluent/plugin/out_test.rb

@@ -0,0 +1,81 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/plugin/output'
+require 'fluent/event'
+
+module Fluent::Plugin
+  class TestOutput < Output
+    Fluent::Plugin.register_output('test', self)
+
+    config_param :name, :string
+
+    config_section :buffer do
+      config_set_default :chunk_keys, ['tag']
+    end
+
+    def initialize
+      super
+      @emit_streams = []
+    end
+
+    attr_reader :emit_streams
+
+    def emits
+      all = []
+      @emit_streams.each {|tag,events|
+        events.each {|time,record|
+          all << [tag, time, record]
+        }
+      }
+      all
+    end
+
+    def events
+      all = []
+      @emit_streams.each {|tag,events|
+        all.concat events
+      }
+      all
+    end
+
+    def records
+      all = []
+      @emit_streams.each {|tag,events|
+        events.each {|time,record|
+          all << record
+        }
+      }
+      all
+    end
+
+    def prefer_buffered_processing
+      false
+    end
+
+    def process(tag, es)
+      @emit_streams << [tag, es.to_a]
+    end
+
+    def write(chunk)
+      es = Fluent::ArrayEventStream.new
+      chunk.each do |time, record|
+        es.add(time, record)
+      end
+      @emit_streams << [tag, es]
+    end
+  end
+end

data/test/scripts/fluent/plugin/out_test2.rb

@@ -0,0 +1,80 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+module Fluent::Plugin
+  class Test2Output < Output
+    Fluent::Plugin.register_output('test2', self)
+
+    helpers :event_emitter
+
+    config_param :name, :string
+
+    config_section :buffer do
+      config_set_default :chunk_keys, ['tag']
+    end
+
+    def initialize
+      super
+      @emit_streams = []
+    end
+
+    attr_reader :emit_streams
+
+    def emits
+      all = []
+      @emit_streams.each {|tag,events|
+        events.each {|time,record|
+          all << [tag, time, record]
+        }
+      }
+      all
+    end
+
+    def events
+      all = []
+      @emit_streams.each {|tag,events|
+        all.concat events
+      }
+      all
+    end
+
+    def records
+      all = []
+      @emit_streams.each {|tag,events|
+        events.each {|time,record|
+          all << record
+        }
+      }
+      all
+    end
+
+    def prefer_buffered_processing
+      false
+    end
+
+    def process(tag, es)
+      @emit_streams << [tag, es.to_a]
+    end
+
+    def write(chunk)
+      es = Fluent::ArrayEventStream.new
+      chunk.each do |time, record|
+        es.add(time, record)
+      end
+      @emit_streams << [tag, es]
+    end
+  end
+end

data/test/scripts/fluent/plugin/parser_known.rb

@@ -0,0 +1,4 @@
+module Fluent
+  TextParser.register_template('known_old', /^(?<message>.*)$/)
+  Plugin.register_parser('known', /^(?<message>.*)$/)
+end

data/test/test_capability.rb

@@ -0,0 +1,74 @@
+require_relative 'helper'
+require 'fluent/test'
+require 'fluent/capability'
+
+class FluentCapabilityTest < ::Test::Unit::TestCase
+  setup do
+    @capability = Fluent::Capability.new(:current_process)
+    omit "Fluent::Capability class is not usable on this environment" unless @capability.usable?
+  end
+
+  sub_test_case "check capability" do
+    test "effective" do
+      @capability.clear(:both)
+      assert_true @capability.update(:add, :effective, :dac_read_search)
+      assert_equal CapNG::Result::PARTIAL, @capability.have_capabilities?(:caps)
+      assert_nothing_raised do
+        @capability.apply(:caps)
+      end
+      assert_equal CapNG::Result::NONE, @capability.have_capabilities?(:bounds)
+      assert_true @capability.have_capability?(:effective, :dac_read_search)
+      assert_false @capability.have_capability?(:inheritable, :dac_read_search)
+      assert_false @capability.have_capability?(:permitted, :dac_read_search)
+    end
+
+    test "inheritable" do
+      @capability.clear(:both)
+      capabilities = [:chown, :dac_override]
+      assert_equal [true, true], @capability.update(:add, :inheritable, capabilities)
+      assert_equal CapNG::Result::NONE, @capability.have_capabilities?(:caps)
+      assert_nothing_raised do
+        @capability.apply(:caps)
+      end
+      assert_equal CapNG::Result::NONE, @capability.have_capabilities?(:bounds)
+      capabilities.each do |capability|
+        assert_false @capability.have_capability?(:effective, capability)
+        assert_true @capability.have_capability?(:inheritable, capability)
+        assert_false @capability.have_capability?(:permitted, capability)
+      end
+    end
+
+    test "permitted" do
+      @capability.clear(:both)
+      capabilities = [:fowner, :fsetid, :kill]
+      assert_equal [true, true, true], @capability.update(:add, :permitted, capabilities)
+      assert_equal CapNG::Result::NONE, @capability.have_capabilities?(:caps)
+      assert_nothing_raised do
+        @capability.apply(:caps)
+      end
+      assert_equal CapNG::Result::NONE, @capability.have_capabilities?(:bounds)
+      capabilities.each do |capability|
+        assert_false @capability.have_capability?(:effective, capability)
+        assert_false @capability.have_capability?(:inheritable, capability)
+        assert_true @capability.have_capability?(:permitted, capability)
+      end
+    end
+
+    test "effective/inheritable/permitted" do
+      @capability.clear(:both)
+      capabilities = [:setpcap, :net_admin, :net_raw, :sys_boot, :sys_time]
+      update_type = CapNG::Type::EFFECTIVE | CapNG::Type::INHERITABLE | CapNG::Type::PERMITTED
+      assert_equal [true, true, true, true, true], @capability.update(:add, update_type, capabilities)
+      assert_equal CapNG::Result::PARTIAL, @capability.have_capabilities?(:caps)
+      assert_nothing_raised do
+        @capability.apply(:caps)
+      end
+      assert_equal CapNG::Result::NONE, @capability.have_capabilities?(:bounds)
+      capabilities.each do |capability|
+        assert_true @capability.have_capability?(:effective, capability)
+        assert_true @capability.have_capability?(:inheritable, capability)
+        assert_true @capability.have_capability?(:permitted, capability)
+      end
+    end
+  end
+end

data/test/test_clock.rb

@@ -0,0 +1,164 @@
+require_relative 'helper'
+require 'fluent/clock'
+
+require 'timecop'
+
+class ClockTest < ::Test::Unit::TestCase
+  teardown do
+    Fluent::Clock.return # call it always not to affect other tests
+  end
+
+  sub_test_case 'without any pre-operation' do
+    test 'clock can provides incremental floating point number based on second' do
+      c1 = Fluent::Clock.now
+      assert_kind_of Float, c1
+      sleep 1.1
+      c2 = Fluent::Clock.now
+      assert{ c2 >= c1 + 1.0 && c2 < c1 + 9.0 } # if clock returns deci-second (fantastic!), c2 should be larger than c1 + 10
+    end
+
+    test 'clock value will proceed even if timecop freezes Time' do
+      Timecop.freeze(Time.now) do
+        c1 = Fluent::Clock.now
+        assert_kind_of Float, c1
+        sleep 1.1
+        c2 = Fluent::Clock.now
+        assert{ c2 >= c1 + 1.0 && c2 < c1 + 9.0 }
+      end
+    end
+  end
+
+  sub_test_case 'using #freeze without any arguments' do
+    test 'Clock.freeze without arguments freezes clock with current clock value' do
+      c0 = Fluent::Clock.now
+      Fluent::Clock.freeze
+      c1 = Fluent::Clock.now
+      Fluent::Clock.return
+      c2 = Fluent::Clock.now
+      assert{ c0 <= c1 && c1 <= c2 }
+    end
+
+    test 'Clock.return raises an error if it is called in block' do
+      assert_raise RuntimeError.new("invalid return while running code in blocks") do
+        Fluent::Clock.freeze do
+          Fluent::Clock.return
+        end
+      end
+    end
+  end
+
+  sub_test_case 'using #freeze with clock value' do
+    test 'Clock.now always returns frozen time until #return called' do
+      c0 = Fluent::Clock.now
+      Fluent::Clock.freeze(c0)
+      assert_equal c0, Fluent::Clock.now
+      sleep 0.5
+      assert_equal c0, Fluent::Clock.now
+      sleep 0.6
+      assert_equal c0, Fluent::Clock.now
+
+      Fluent::Clock.return
+      c1 = Fluent::Clock.now
+      assert{ c1 >= c0 + 1.0 }
+    end
+
+    test 'Clock.now returns frozen time in the block argument of #freeze' do
+      c0 = Fluent::Clock.now
+      Fluent::Clock.freeze(c0) do
+        assert_equal c0, Fluent::Clock.now
+        sleep 0.5
+        assert_equal c0, Fluent::Clock.now
+        sleep 0.6
+        assert_equal c0, Fluent::Clock.now
+      end
+      c1 = Fluent::Clock.now
+      assert{ c1 >= c0 + 1.0 }
+    end
+
+    test 'Clock.now returns unfrozen value after jumping out from block by raising errors' do
+      c0 = Fluent::Clock.now
+      rescued_error = nil
+      begin
+        Fluent::Clock.freeze(c0) do
+          assert_equal c0, Fluent::Clock.now
+          sleep 0.5
+          assert_equal c0, Fluent::Clock.now
+          sleep 0.6
+          assert_equal c0, Fluent::Clock.now
+          raise "bye!"
+        end
+      rescue => e
+        rescued_error = e
+      end
+      assert rescued_error # ensure to rescue an error
+      c1 = Fluent::Clock.now
+      assert{ c1 >= c0 + 1.0 }
+    end
+
+    test 'Clock.return cancels all Clock.freeze effects by just once' do
+      c0 = Fluent::Clock.now
+      sleep 0.1
+      c1 = Fluent::Clock.now
+      sleep 0.1
+      c2 = Fluent::Clock.now
+      Fluent::Clock.freeze(c0)
+      sleep 0.1
+      assert_equal c0, Fluent::Clock.now
+      Fluent::Clock.freeze(c1)
+      sleep 0.1
+      assert_equal c1, Fluent::Clock.now
+      Fluent::Clock.freeze(c2)
+      sleep 0.1
+      assert_equal c2, Fluent::Clock.now
+
+      Fluent::Clock.return
+      assert{ Fluent::Clock.now > c2 }
+    end
+
+    test 'Clock.freeze allows nested blocks by itself' do
+      c0 = Fluent::Clock.now
+      sleep 0.1
+      c1 = Fluent::Clock.now
+      sleep 0.1
+      c2 = Fluent::Clock.now
+      Fluent::Clock.freeze(c0) do
+        sleep 0.1
+        assert_equal c0, Fluent::Clock.now
+        Fluent::Clock.freeze(c1) do
+          sleep 0.1
+          assert_equal c1, Fluent::Clock.now
+          Fluent::Clock.freeze(c2) do
+            sleep 0.1
+            assert_equal c2, Fluent::Clock.now
+          end
+          assert_equal c1, Fluent::Clock.now
+        end
+        assert_equal c0, Fluent::Clock.now
+      end
+      assert{ Fluent::Clock.now > c0 }
+    end
+  end
+
+  sub_test_case 'using #freeze with Time argument' do
+    test 'Clock.freeze returns the clock value which should be produced when the time is at the specified time' do
+      c0 = Fluent::Clock.now
+      t0 = Time.now
+      t1 = t0 - 30
+      assert_kind_of Time, t1
+      t2 = t0 + 30
+      assert_kind_of Time, t2
+
+      # 31 is for error of floating point value
+      Fluent::Clock.freeze(t1) do
+        c1 = Fluent::Clock.now
+        assert{ c1 >= c0 - 31 && c1 <= c0 - 31 + 10 } # +10 is for threading schedule error
+      end
+
+      # 29 is for error of floating point value
+      Fluent::Clock.freeze(t2) do
+        c2 = Fluent::Clock.now
+        assert{ c2 >= c0 + 29 && c2 <= c0 + 29 + 10 } # +10 is for threading schedule error
+      end
+    end
+  end
+end