fluentd 0.14.4-x64-mingw32

data/test/plugin/test_in_monitor_agent.rb

@@ -0,0 +1,329 @@
+require_relative '../helper'
+require 'fluent/test/driver/input'
+require 'fluent/plugin/in_monitor_agent'
+require 'fluent/engine'
+require 'fluent/config'
+require 'fluent/event_router'
+require 'fluent/supervisor'
+require 'net/http'
+require 'json'
+require_relative '../test_plugin_classes'
+
+class MonitorAgentInputTest < Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+  end
+
+  def create_driver(conf = '')
+    Fluent::Test::Driver::Input.new(Fluent::Plugin::MonitorAgentInput).configure(conf)
+  end
+
+  def configure_ra(ra, conf_str)
+    conf = Fluent::Config.parse(conf_str, "(test)", "(test_dir)", true)
+    ra.configure(conf)
+    ra
+  end
+
+  def test_configure
+    d = create_driver
+    assert_equal("0.0.0.0", d.instance.bind)
+    assert_equal(24220, d.instance.port)
+    assert_equal(nil, d.instance.tag)
+    assert_equal(60, d.instance.emit_interval)
+  end
+
+  sub_test_case "collect plugin information" do
+    setup do
+      # check @type and type in one configuration
+      conf = <<-EOC
+<source>
+  @type test_in
+  @id test_in
+</source>
+<filter>
+  @type test_filter
+  @id test_filter
+</filter>
+<match **>
+  @type relabel
+  @id test_relabel
+  @label @test
+</match>
+<label @test>
+  <match **>
+    @type test_out
+    @id test_out
+  </match>
+</label>
+<label @ERROR>
+  <match>
+    @type null
+    @id null
+  </match>
+</label>
+EOC
+      @ra = Fluent::RootAgent.new(log: $log)
+      stub(Fluent::Engine).root_agent { @ra }
+      @ra = configure_ra(@ra, conf)
+    end
+
+    test "plugin_category" do
+      d = create_driver
+      test_label = @ra.labels['@test']
+      error_label = @ra.labels['@ERROR']
+      assert_equal("input", d.instance.plugin_category(@ra.inputs.first))
+      assert_equal("filter", d.instance.plugin_category(@ra.filters.first))
+      assert_equal("output", d.instance.plugin_category(test_label.outputs.first))
+      assert_equal("output", d.instance.plugin_category(error_label.outputs.first))
+    end
+
+    test "get_monitor_info" do
+      d = create_driver
+      test_label = @ra.labels['@test']
+      error_label = @ra.labels['@ERROR']
+      input_info = {
+        "config" => {
+          "@id"   => "test_in",
+          "@type" => "test_in"
+        },
+        "output_plugin"  => false,
+        "plugin_category"=> "input",
+        "plugin_id"      => "test_in",
+        "retry_count"    => nil,
+        "type"           => "test_in"
+      }
+      filter_info = {
+        "config" => {
+          "@id"   => "test_filter",
+          "@type" => "test_filter"
+        },
+        "output_plugin"   => false,
+        "plugin_category" => "filter",
+        "plugin_id"       => "test_filter",
+        "retry_count"     => nil,
+        "type"            => "test_filter"
+      }
+      output_info = {
+        "config" => {
+          "@id"   => "test_out",
+          "@type" => "test_out"
+        },
+        "output_plugin"   => true,
+        "plugin_category" => "output",
+        "plugin_id"       => "test_out",
+        "retry_count"     => 0,
+        "type"            => "test_out"
+      }
+      error_label_info = {
+        "config" => {
+          "@id"=>"null",
+          "@type" => "null"
+        },
+        "output_plugin"   => true,
+        "plugin_category" => "output",
+        "plugin_id"       => "null",
+        "retry_count"     => 0,
+        "type"            => "null"
+      }
+      assert_equal(input_info, d.instance.get_monitor_info(@ra.inputs.first))
+      assert_equal(filter_info, d.instance.get_monitor_info(@ra.filters.first))
+      assert_equal(output_info, d.instance.get_monitor_info(test_label.outputs.first))
+      assert_equal(error_label_info, d.instance.get_monitor_info(error_label.outputs.first))
+    end
+
+    test "fluentd opts" do
+      d = create_driver
+      opts = Fluent::Supervisor.default_options
+      Fluent::Supervisor.new(opts)
+      expected_opts = {
+        "config_path" => "/etc/fluent/fluent.conf",
+        "pid_file"    => nil,
+        "plugin_dirs" => ["/etc/fluent/plugin"],
+        "log_path"    => nil
+      }
+      assert_equal(expected_opts, d.instance.fluentd_opts)
+    end
+
+    test "all_plugins" do
+      d = create_driver
+      plugins = []
+      d.instance.all_plugins.each {|plugin| plugins << plugin.class }
+      assert_equal([FluentTest::FluentTestInput,
+                    Fluent::Plugin::RelabelOutput,
+                    FluentTest::FluentTestFilter,
+                    FluentTest::FluentTestOutput,
+                    Fluent::Plugin::NullOutput], plugins)
+    end
+
+    test "emit" do
+      port = unused_port
+      d = create_driver("
+  @type monitor_agent
+  bind '127.0.0.1'
+  port #{port}
+  tag monitor
+  emit_interval 1
+")
+      d.instance.start
+      d.end_if do
+        d.events.size >= 5
+      end
+      d.run
+      expect_relabel_record = {
+        "plugin_id"       => "test_relabel",
+        "plugin_category" => "output",
+        "type"            => "relabel",
+        "output_plugin"   => true,
+        "retry_count"     => 0}
+      expect_test_out_record = {
+        "plugin_id"       => "test_out",
+        "plugin_category" => "output",
+        "type"            => "test_out",
+        "output_plugin"   => true,
+        "retry_count"     => 0
+      }
+      assert_equal(expect_relabel_record, d.events[1][2])
+      assert_equal(expect_test_out_record, d.events[3][2])
+    end
+  end
+
+  def get(uri, header = {})
+    url = URI.parse(uri)
+    req = Net::HTTP::Get.new(url.path, header)
+    unless header.has_key?('Content-Type')
+      header['Content-Type'] = 'application/octet-stream'
+    end
+    res = Net::HTTP.start(url.host, url.port) {|http|
+      http.request(req)
+    }
+    res.body
+  end
+
+  sub_test_case "servlets" do
+    setup do
+      @port = unused_port
+      # check @type and type in one configuration
+      conf = <<-EOC
+<source>
+  @type test_in
+  @id test_in
+</source>
+<source>
+  @type monitor_agent
+  bind "127.0.0.1"
+  port #{@port}
+  tag monitor
+  @id monitor_agent
+</source>
+<filter>
+  @type test_filter
+  @id test_filter
+</filter>
+<match **>
+  @type relabel
+  @id test_relabel
+  @label @test
+</match>
+<label @test>
+  <match **>
+    @type test_out
+    @id test_out
+  </match>
+</label>
+<label @ERROR>
+  <match>
+    @type null
+    @id null
+  </match>
+</label>
+EOC
+      @ra = Fluent::RootAgent.new(log: $log)
+      stub(Fluent::Engine).root_agent { @ra }
+      @ra = configure_ra(@ra, conf)
+    end
+
+    test "/api/plugins" do
+      d = create_driver("
+  @type monitor_agent
+  bind '127.0.0.1'
+  port #{@port}
+  tag monitor
+")
+      d.instance.start
+      expected_test_in_response = "\
+plugin_id:test_in\tplugin_category:input\ttype:test_in\toutput_plugin:false\tretry_count:"
+      expected_test_filter_response = "\
+plugin_id:test_filter\tplugin_category:filter\ttype:test_filter\toutput_plugin:false\tretry_count:"
+
+      response = get("http://127.0.0.1:#{@port}/api/plugins")
+      test_in = response.split("\n")[0]
+      test_filter = response.split("\n")[3]
+      assert_equal(expected_test_in_response, test_in)
+      assert_equal(expected_test_filter_response, test_filter)
+    end
+
+    test "/api/plugins.json" do
+      d = create_driver("
+  @type monitor_agent
+  bind '127.0.0.1'
+  port #{@port}
+  tag monitor
+")
+      d.instance.start
+      expected_test_in_response =
+        {"config" => {
+          "@id"   => "test_in",
+          "@type" => "test_in"
+        },
+        "output_plugin"   => false,
+        "plugin_category" => "input",
+        "plugin_id"       => "test_in",
+        "retry_count"     => nil,
+        "type"            => "test_in"}
+      expected_null_response =
+        {"config" => {
+          "@id"   => "null",
+          "@type" => "null"
+        },
+        "output_plugin"   => true,
+        "plugin_category" => "output",
+        "plugin_id"       => "null",
+        "retry_count"     => 0,
+        "type"            => "null"}
+      response = JSON.parse(get("http://127.0.0.1:#{@port}/api/plugins.json"))
+      test_in_response = response["plugins"][0]
+      null_response = response["plugins"][5]
+      assert_equal(expected_test_in_response, test_in_response)
+      assert_equal(expected_null_response, null_response)
+    end
+
+    test "/api/config" do
+      d = create_driver("
+  @type monitor_agent
+  bind '127.0.0.1'
+  port #{@port}
+  tag monitor
+")
+      d.instance.start
+      expected_response_regex = /pid:\d+\tppid:\d+\tconfig_path:\/etc\/fluent\/fluent.conf\tpid_file:\tplugin_dirs:\[\"\/etc\/fluent\/plugin\"\]\tlog_path:/
+
+      assert_match(expected_response_regex,
+                   get("http://127.0.0.1:#{@port}/api/config"))
+    end
+
+    test "/api/config.json" do
+      d = create_driver("
+  @type monitor_agent
+  bind '127.0.0.1'
+  port #{@port}
+  tag monitor
+")
+      d.instance.start
+      res = JSON.parse(get("http://127.0.0.1:#{@port}/api/config.json"))
+      assert_equal("/etc/fluent/fluent.conf", res["config_path"])
+      assert_nil(res["pid_file"])
+      assert_equal(["/etc/fluent/plugin"], res["plugin_dirs"])
+      assert_nil(res["log_path"])
+    end
+  end
+end

data/test/plugin/test_in_object_space.rb

@@ -0,0 +1,64 @@
+require_relative '../helper'
+require 'fluent/test/driver/input'
+require 'fluent/plugin/in_object_space'
+
+require 'timeout'
+
+class ObjectSpaceInputTest < Test::Unit::TestCase
+  def waiting(seconds, instance)
+    begin
+      Timeout.timeout(seconds) do
+        yield
+      end
+    rescue Timeout::Error
+      STDERR.print(*instance.log.out.logs)
+      raise
+    end
+  end
+
+  class FailObject
+    def self.class
+      raise "error"
+    end
+  end
+
+  def setup
+    Fluent::Test.setup
+  end
+
+  TESTCONFIG = %[
+    emit_interval 1
+    tag t1
+    top 2
+  ]
+
+  def create_driver(conf=TESTCONFIG)
+    Fluent::Test::Driver::Input.new(Fluent::Plugin::ObjectSpaceInput).configure(conf)
+  end
+
+  def test_configure
+    d = create_driver
+    assert_equal 1, d.instance.emit_interval
+    assert_equal "t1", d.instance.tag
+    assert_equal 2, d.instance.top
+  end
+
+  def test_emit
+    d = create_driver
+
+    d.run do
+      waiting(10, d.instance) do
+        sleep 0.5 until d.events.size > 3
+      end
+    end
+
+    emits = d.events
+    assert{ emits.length > 0 }
+
+    emits.each { |tag, time, record|
+      assert_equal d.instance.tag, tag
+      assert_equal d.instance.top, record.keys.size
+      assert(time.is_a?(Fluent::EventTime))
+    }
+  end
+end

data/test/plugin/test_in_syslog.rb

@@ -0,0 +1,205 @@
+require_relative '../helper'
+require 'fluent/test/driver/input'
+require 'fluent/plugin/in_syslog'
+
+class SyslogInputTest < Test::Unit::TestCase
+  class << self
+    def startup
+      socket_manager_path = ServerEngine::SocketManager::Server.generate_path
+      @server = ServerEngine::SocketManager::Server.open(socket_manager_path)
+      ENV['SERVERENGINE_SOCKETMANAGER_PATH'] = socket_manager_path.to_s
+    end
+
+    def shutdown
+      @server.close
+    end
+  end
+
+  def setup
+    Fluent::Test.setup
+    require 'fluent/plugin/socket_util'
+  end
+
+  PORT = unused_port
+  CONFIG = %[
+    port #{PORT}
+    bind 127.0.0.1
+    tag syslog
+  ]
+
+  IPv6_CONFIG = %[
+    port #{PORT}
+    bind ::1
+    tag syslog
+  ]
+
+  def create_driver(conf=CONFIG)
+    Fluent::Test::Driver::Input.new(Fluent::Plugin::SyslogInput).configure(conf)
+  end
+
+  def test_configure
+    configs = {'127.0.0.1' => CONFIG}
+    configs.merge!('::1' => IPv6_CONFIG) if ipv6_enabled?
+
+    configs.each_pair { |k, v|
+      d = create_driver(v)
+      assert_equal PORT, d.instance.port
+      assert_equal k, d.instance.bind
+    }
+  end
+
+  def test_time_format
+    configs = {'127.0.0.1' => CONFIG}
+    configs.merge!('::1' => IPv6_CONFIG) if ipv6_enabled?
+
+    configs.each_pair { |k, v|
+      d = create_driver(v)
+
+      tests = [
+        {'msg' => '<6>Dec 11 00:00:00 localhost logger: foo', 'expected' => Fluent::EventTime.from_time(Time.strptime('Dec 11 00:00:00', '%b %d %H:%M:%S'))},
+        {'msg' => '<6>Dec  1 00:00:00 localhost logger: foo', 'expected' => Fluent::EventTime.from_time(Time.strptime('Dec  1 00:00:00', '%b  %d %H:%M:%S'))},
+      ]
+      d.run(expect_emits: 2) do
+        u = Fluent::SocketUtil.create_udp_socket(k)
+        u.connect(k, PORT)
+        tests.each {|test|
+          u.send(test['msg'], 0)
+        }
+      end
+
+      events = d.events
+      assert(events.size > 0)
+      events.each_index {|i|
+        assert_equal_event_time(tests[i]['expected'], events[i][1])
+      }
+    }
+  end
+
+  def test_msg_size
+    d = create_driver
+    tests = create_test_case
+
+    d.run(expect_emits: 2) do
+      u = UDPSocket.new
+      u.connect('127.0.0.1', PORT)
+      tests.each {|test|
+        u.send(test['msg'], 0)
+      }
+    end
+
+    assert(d.events.size > 0)
+    compare_test_result(d.events, tests)
+  end
+
+  def test_msg_size_udp_for_large_msg
+    d = create_driver(CONFIG + %[
+      message_length_limit 5k
+    ])
+    tests = create_test_case(large_message: true)
+
+    d.run(expect_emits: 3) do
+      u = UDPSocket.new
+      u.connect('127.0.0.1', PORT)
+      tests.each {|test|
+        u.send(test['msg'], 0)
+      }
+    end
+
+    assert(d.events.size > 0)
+    compare_test_result(d.events, tests)
+  end
+
+  def test_msg_size_with_tcp
+    d = create_driver([CONFIG, 'protocol_type tcp'].join("\n"))
+    tests = create_test_case
+
+    d.run(expect_emits: 2) do
+      tests.each {|test|
+        TCPSocket.open('127.0.0.1', PORT) do |s|
+          s.send(test['msg'], 0)
+        end
+      }
+    end
+
+    assert(d.events.size > 0)
+    compare_test_result(d.events, tests)
+  end
+
+  def test_msg_size_with_same_tcp_connection
+    d = create_driver([CONFIG, 'protocol_type tcp'].join("\n"))
+    tests = create_test_case
+
+    d.run(expect_emits: 2) do
+      TCPSocket.open('127.0.0.1', PORT) do |s|
+        tests.each {|test|
+          s.send(test['msg'], 0)
+        }
+      end
+    end
+
+    assert(d.events.size > 0)
+    compare_test_result(d.events, tests)
+  end
+
+  def test_msg_size_with_json_format
+    d = create_driver([CONFIG, 'format json'].join("\n"))
+    time = Time.parse('2013-09-18 12:00:00 +0900').to_i
+    tests = ['Hello!', 'Syslog!'].map { |msg|
+      event = {'time' => time, 'message' => msg}
+      {'msg' => '<6>' + event.to_json + "\n", 'expected' => msg}
+    }
+
+    d.run(expect_emits: 2) do
+      u = UDPSocket.new
+      u.connect('127.0.0.1', PORT)
+      tests.each {|test|
+        u.send(test['msg'], 0)
+      }
+    end
+
+    assert(d.events.size > 0)
+    compare_test_result(d.events, tests)
+  end
+
+  def test_msg_size_with_include_source_host
+    d = create_driver([CONFIG, 'include_source_host true'].join("\n"))
+    tests = create_test_case
+
+    host = nil
+    d.run(expect_emits: 2) do
+      u = UDPSocket.new
+      u.connect('127.0.0.1', PORT)
+      host = u.peeraddr[2]
+      tests.each {|test|
+        u.send(test['msg'], 0)
+      }
+    end
+
+    assert(d.events.size > 0)
+    compare_test_result(d.events, tests, host)
+  end
+
+  def create_test_case(large_message: false)
+    # actual syslog message has "\n"
+    if large_message
+      [
+        {'msg' => '<6>Sep 10 00:00:00 localhost logger: ' + 'x' * 100 + "\n", 'expected' => 'x' * 100},
+        {'msg' => '<6>Sep 10 00:00:00 localhost logger: ' + 'x' * 1024 + "\n", 'expected' => 'x' * 1024},
+        {'msg' => '<6>Sep 10 00:00:00 localhost logger: ' + 'x' * 4096 + "\n", 'expected' => 'x' * 4096},
+      ]
+    else
+      [
+        {'msg' => '<6>Sep 10 00:00:00 localhost logger: ' + 'x' * 100 + "\n", 'expected' => 'x' * 100},
+        {'msg' => '<6>Sep 10 00:00:00 localhost logger: ' + 'x' * 1024 + "\n", 'expected' => 'x' * 1024},
+      ]
+    end
+  end
+
+  def compare_test_result(events, tests, host = nil)
+    events.each_index { |i|
+      assert_equal('syslog.kern.info', events[i][0]) # <6> means kern.info
+      assert_equal(tests[i]['expected'], events[i][2]['message'])
+      assert_equal(host, events[i][2]['source_host']) if host
+    }
+  end
+end