fluentd 0.14.4-x64-mingw32

data/lib/fluent/system_config.rb

@@ -0,0 +1,122 @@
+#
+# Fluent
+#
+#    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/configurable'
+require 'fluent/config/element'
+
+module Fluent
+  class SystemConfig
+    include Configurable
+
+    config_param :log_level, default: nil do |level|
+      Log.str_to_level(level)
+    end
+    config_param :suppress_repeated_stacktrace, :bool, default: nil
+    config_param :emit_error_log_interval, :time, default: nil
+    config_param :suppress_config_dump, :bool, default: nil
+    config_param :without_source, :bool, default: nil
+    config_param :rpc_endpoint, :string, default: nil
+    config_param :enable_get_dump, :bool, default: nil
+    config_param :process_name, default: nil
+    config_param :file_permission, default: nil do |v|
+      v.to_i(8)
+    end
+    config_param :dir_permission, default: nil do |v|
+      v.to_i(8)
+    end
+
+    def self.create(conf)
+      systems = conf.elements(name: 'system')
+      return SystemConfig.new if systems.empty?
+      raise Fluent::ConfigError, "<system> is duplicated. <system> should be only one" if systems.size > 1
+
+      SystemConfig.new(systems.first)
+    end
+
+    def self.blank_system_config
+      Fluent::Config::Element.new('<SYSTEM>', '', {}, [])
+    end
+
+    def self.overwrite_system_config(hash)
+      older = defined?($_system_config) ? $_system_config : nil
+      begin
+        $_system_config = SystemConfig.new(Fluent::Config::Element.new('system', '', hash, []))
+        yield
+      ensure
+        $_system_config = older
+      end
+    end
+
+    def initialize(conf=nil)
+      super()
+      conf ||= SystemConfig.blank_system_config
+      configure(conf)
+    end
+
+    def dup
+      s = SystemConfig.new
+      s.log_level = @log_level
+      s.suppress_repeated_stacktrace = @suppress_repeated_stacktrace
+      s.emit_error_log_interval = @emit_error_log_interval
+      s.suppress_config_dump = @suppress_config_dump
+      s.without_source = @without_source
+      s.rpc_endpoint = @rpc_endpoint
+      s.enable_get_dump = @enable_get_dump
+      s.process_name = @process_name
+      s.file_permission = @file_permission
+      s.dir_permission = @dir_permission
+
+      s
+    end
+
+    def apply(supervisor)
+      system = self
+      supervisor.instance_eval {
+        @log.level = @log_level = system.log_level unless system.log_level.nil?
+        @suppress_interval = system.emit_error_log_interval unless system.emit_error_log_interval.nil?
+        @suppress_config_dump = system.suppress_config_dump unless system.suppress_config_dump.nil?
+        @suppress_repeated_stacktrace = system.suppress_repeated_stacktrace unless system.suppress_repeated_stacktrace.nil?
+        @without_source = system.without_source unless system.without_source.nil?
+        @rpc_endpoint = system.rpc_endpoint unless system.rpc_endpoint.nil?
+        @enable_get_dump = system.enable_get_dump unless system.enable_get_dump.nil?
+        @process_name = system.process_name unless system.process_name.nil?
+        @file_permission = system.file_permission unless system.file_permission.nil?
+        @dir_permission = system.dir_permission unless system.dir_permission.nil?
+      }
+    end
+
+    module Mixin
+      def system_config
+        require 'fluent/engine'
+        unless defined?($_system_config)
+          $_system_config = nil
+        end
+        (instance_variable_defined?("@_system_config") && @_system_config) ||
+          $_system_config || Fluent::Engine.system_config
+      end
+
+      def system_config_override(opts={})
+        require 'fluent/engine'
+        if !instance_variable_defined?("@_system_config") || @_system_config.nil?
+          @_system_config = (defined?($_system_config) && $_system_config ? $_system_config : Fluent::Engine.system_config).dup
+        end
+        opts.each_pair do |key, value|
+          @_system_config.send(:"#{key.to_s}=", value)
+        end
+      end
+    end
+  end
+end

data/lib/fluent/test.rb

@@ -0,0 +1,56 @@
+#
+# 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 'test/unit'
+require 'fluent/env' # for Fluent.windows?
+require 'fluent/test/log'
+require 'fluent/test/base'
+require 'fluent/test/input_test'
+require 'fluent/test/output_test'
+require 'fluent/test/filter_test'
+require 'fluent/test/parser_test'
+require 'fluent/test/formatter_test'
+require 'serverengine'
+
+
+module Fluent
+  module Test
+    def self.dummy_logger
+      dl_opts = {log_level: ServerEngine::DaemonLogger::INFO}
+      logdev = Fluent::Test::DummyLogDevice.new
+      logger = ServerEngine::DaemonLogger.new(logdev, dl_opts)
+      Fluent::Log.new(logger)
+    end
+
+    def self.setup
+      $log = dummy_logger
+
+      Fluent.__send__(:remove_const, :Engine)
+      engine = Fluent.const_set(:Engine, EngineClass.new).init(SystemConfig.new)
+
+      engine.define_singleton_method(:now=) {|n|
+        @now = n
+      }
+      engine.define_singleton_method(:now) {
+        @now ||= super()
+      }
+
+      nil
+    end
+  end
+end
+
+$log ||= Fluent::Test.dummy_logger

data/lib/fluent/test/base.rb

@@ -0,0 +1,85 @@
+#
+# 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/config'
+require 'fluent/engine'
+require 'fluent/system_config'
+require 'fluent/test/log'
+require 'serverengine'
+
+module Fluent
+  module Test
+    class TestDriver
+      include ::Test::Unit::Assertions
+
+      def initialize(klass, &block)
+        if klass.is_a?(Class)
+          if block
+            # Create new class for test w/ overwritten methods
+            #   klass.dup is worse because its ancestors does NOT include original class name
+            klass_name = klass.name
+            klass = Class.new(klass)
+            klass.define_singleton_method("name") { klass_name }
+            klass.module_eval(&block)
+          end
+          @instance = klass.new
+        else
+          @instance = klass
+        end
+        @instance.router = Engine.root_agent.event_router
+        @instance.log = TestLogger.new
+        Engine.root_agent.instance_variable_set(:@log, @instance.log)
+
+        @config = Config.new
+      end
+
+      attr_reader :instance, :config
+
+      def configure(str, use_v1 = false)
+        if str.is_a?(Fluent::Config::Element)
+          @config = str
+        else
+          @config = Config.parse(str, "(test)", "(test_dir)", use_v1)
+        end
+        if label_name = @config['@label']
+          Engine.root_agent.add_label(label_name)
+        end
+        @instance.configure(@config)
+        self
+      end
+
+      # num_waits is for checking thread status. This will be removed after improved plugin API
+      def run(num_waits = 10, &block)
+        @instance.start
+        @instance.after_start
+        begin
+          # wait until thread starts
+          num_waits.times { sleep 0.05 }
+          return yield
+        ensure
+          @instance.shutdown
+        end
+      end
+    end
+  end
+end
+
+Test::Unit::Assertions.module_eval do
+  def assert_equal_event_time(a, b)
+    assert_equal(a.sec, b.sec)
+    assert_equal(a.nsec, b.nsec)
+  end
+end

data/lib/fluent/test/driver/base.rb

@@ -0,0 +1,179 @@
+#
+# 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/config'
+require 'fluent/config/element'
+require 'fluent/log'
+
+require 'timeout'
+
+module Fluent
+  module Test
+    module Driver
+      class Base
+        attr_reader :instance, :logs
+
+        def initialize(klass, opts: {}, &block)
+          if klass.is_a?(Class)
+            if block
+              # Create new class for test w/ overwritten methods
+              #   klass.dup is worse because its ancestors does NOT include original class name
+              klass_name = klass.name
+              klass = Class.new(klass)
+              klass.define_singleton_method("name") { klass_name }
+              klass.module_eval(&block)
+            end
+            @instance = klass.new
+          else
+            @instance = klass
+          end
+
+          @logs = []
+
+          @run_post_conditions = []
+          @run_breaking_conditions = []
+          @broken = false
+        end
+
+        def configure(conf, syntax: :v1)
+          raise NotImplementedError
+        end
+
+        def end_if(&block)
+          raise ArgumentError, "block is not given" unless block_given?
+          @run_post_conditions << block
+        end
+
+        def break_if(&block)
+          raise ArgumentError, "block is not given" unless block_given?
+          @run_breaking_conditions << block
+        end
+
+        def broken?
+          @broken
+        end
+
+        def run(timeout: nil, start: true, shutdown: true, &block)
+          instance_start if start
+
+          if @instance.respond_to?(:thread_wait_until_start)
+            @instance.thread_wait_until_start
+          end
+          if @instance.respond_to?(:event_loop_wait_until_start)
+            @instance.event_loop_wait_until_start
+          end
+
+          begin
+            run_actual(timeout: timeout, &block)
+          ensure
+            instance_shutdown if shutdown
+          end
+        end
+
+        def instance_start
+          unless @instance.started?
+            @instance.start
+            instance_hook_after_started
+          end
+          unless @instance.after_started?
+            @instance.after_start
+          end
+        end
+
+        def instance_hook_after_started
+          # insert hooks for tests available after instance.start
+        end
+
+        def instance_shutdown
+          @instance.stop            unless @instance.stopped?
+          @instance.before_shutdown unless @instance.before_shutdown?
+          @instance.shutdown        unless @instance.shutdown?
+
+          if @instance.respond_to?(:event_loop_wait_until_stop)
+            @instance.event_loop_wait_until_stop
+          end
+
+          @instance.after_shutdown  unless @instance.after_shutdown?
+          @instance.close     unless @instance.closed?
+
+          if @instance.respond_to?(:thread_wait_until_stop)
+            @instance.thread_wait_until_stop
+          end
+
+          @instance.terminate unless @instance.terminated?
+        end
+
+        def run_actual(timeout: nil, &block)
+          if @instance.respond_to?(:_threads)
+            until @instance._threads.values.all?(&:alive?)
+              sleep 0.01
+            end
+          end
+
+          if @instance.respond_to?(:event_loop_running?)
+            until @instance.event_loop_running?
+              sleep 0.01
+            end
+          end
+
+          if timeout
+            stop_at = Time.now + timeout
+            @run_breaking_conditions << ->(){ Time.now >= stop_at }
+          end
+
+          if !block_given? && @run_post_conditions.empty? && @run_breaking_conditions.empty?
+            raise ArgumentError, "no stop conditions nor block specified"
+          end
+
+          proc = if block_given?
+                   ->(){ block.call; sleep(0.1) until stop? }
+                 else
+                   ->(){ sleep(0.1) until stop? }
+                 end
+
+          if timeout
+            begin
+              Timeout.timeout(timeout * 1.1) do |sec|
+                proc.call
+              end
+            rescue Timeout::Error
+              @broken = true
+            end
+          else
+            proc.call
+          end
+        end
+
+        def stop?
+          # Should stop running if post conditions are not registered.
+          return true unless @run_post_conditions
+
+          # Should stop running if all of the post conditions are true.
+          return true if @run_post_conditions.all? {|proc| proc.call }
+
+          # Should stop running if some of the breaking conditions is true.
+          # In this case, some post conditions may be not true.
+          if @run_breaking_conditions.any? {|proc| proc.call }
+            @broken = true
+            return true
+          end
+
+          false
+        end
+      end
+    end
+  end
+end

data/lib/fluent/test/driver/base_owned.rb

@@ -0,0 +1,70 @@
+#
+# 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/test/driver/base'
+
+require 'fluent/plugin/base'
+require 'fluent/plugin_id'
+require 'fluent/log'
+require 'fluent/plugin_helper'
+
+module Fluent
+  module Test
+    module Driver
+      class OwnerDummy < Fluent::Plugin::Base
+        include PluginId
+        include PluginLoggerMixin
+        include PluginHelper::Mixin
+      end
+
+      class BaseOwned < Base
+        attr_accessor :section_name
+
+        def initialize(klass, opts: {}, &block)
+          super
+
+          owner = OwnerDummy.new
+          if opts
+            owner.system_config_override(opts)
+          end
+          owner.log = TestLogger.new
+
+          if @instance.respond_to?(:owner=)
+            @instance.owner = owner
+            if opts
+              @instance.system_config_override(opts)
+            end
+          end
+
+          @logs = owner.log.out.logs
+          @section_name = ''
+        end
+
+        def configure(conf, syntax: :v1)
+          if conf.is_a?(Fluent::Config::Element)
+            @config = conf
+          elsif conf.is_a?(Hash)
+            @config = Fluent::Config::Element.new(@section_name, "", Hash[conf.map{|k,v| [k.to_s, v]}], [])
+          else
+            @config = Fluent::Config.parse(conf, @section_name, "", syntax: syntax)
+          end
+          @instance.configure(@config)
+          self
+        end
+      end
+    end
+  end
+end