fluentd 1.16.5-x64-mingw32 → 1.17.1-x64-mingw32

data/test/plugin_helper/test_timer.rb

@@ -1,130 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

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

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

@@ -1,8 +0,0 @@
-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

@@ -1,81 +0,0 @@
-#
-# 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

@@ -1,80 +0,0 @@
-#
-# 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

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

data/test/test_capability.rb

@@ -1,74 +0,0 @@
-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

@@ -1,164 +0,0 @@
-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