fluent-plugin-keep-forward 0.0.4 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dbbee68f0007b1260a98d7daa5f5c5cc948dae3c
-  data.tar.gz: 29e55d39b2ac8c062e896a4f52a55c7c98879165
+  metadata.gz: 43773aac13d82ed29b4a225a8c2f943202fe2755
+  data.tar.gz: 49aebeb40d1351ebdb035ef4beefce70d085defd
 SHA512:
-  metadata.gz: e5feef720bd183dff7b0abcb778246d4176700f94aee5520f519a19211c9783161977822943fc76f340f3fc18e9d0ebb1a8d8cefd106f0ab123c7d46b8c99862
-  data.tar.gz: 5d955251c44825f448be0d9fb969b58ed7c2b1611367cc5b01591e8af176b7c22066fa16e6fc072d6345a6413248b11128300441a85dcc405cf5f847d1d022b1
+  metadata.gz: d5dcb984363125e6633332300337d1ec79a74c4725d0491e8952fe53c3333b8bd1c1c2bcbd1923c0edd1d20c8049f5ee777c85914176bf17118cb6a7af686bd5
+  data.tar.gz: 607e402b31507639667ba68035cdd1d30c05e4caa9cc779b29196ba94b68c1a912e2435c1b42458eceee66d2ee787f7fdf6e3d4203ef4eb8d34cd88640ffe43c

data/.gitignore

@@ -9,3 +9,5 @@ vendor
 doc/*
 tmp/*
 .yardoc
+.ruby-version
+pkg/*

data/CHANGELOG.md

@@ -0,0 +1,21 @@
+## 0.1.1
+
+Changes:
+
+* Change default of `keepalive` option to `false`
+
+## 0.1.0
+
+Enhancements:
+
+* Add `keepalive` and `keepalive_time` option
+
+## 0.0.4
+
+Enhancements:
+
+* Add `prefer_recover` option
+
+## 0.0.1
+
+First version

data/README.md

@@ -4,17 +4,25 @@ testing ruby: 1.9.2, 1.9.3, 2.0.0;  fluentd: 0.10.x
 
 ## About
 
-This is an extension of fluentd out\_forward plugin to keep fowarding log data to the same node (as much as possible).
+This is an extension of fluentd out\_forward plugin to keep fowarding log data to the same node (as long as possible).
 
-## Configuration
+## Parameters
 
 Basically same with out\_forward plugin. See http://docs.fluentd.org/articles/out_forward
 
-## Additional Parameters
+Following parameters are additionally available: 
 
-* prefer_recover
+- keepalive (bool)
 
-    Switch to a recovered node from standby nodes or less weighted nodes. Default is `true`.
+    Keepalive connection. Default is `false`.
+
+- keepalive_time (time)
+
+    Keepalive expired time. Default is nil (which means as long as possible).
+
+- prefer_recover (bool)
+
+    Switch connection to a recovered node from standby nodes or less weighted nodes. Default is `true`.
 
 ## Contributing
 
@@ -24,6 +32,10 @@ Basically same with out\_forward plugin. See http://docs.fluentd.org/articles/ou
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new [Pull Request](../../pull/new/master)
 
+## ChangeLog
+
+See [CHANGELOG.md](CHANGELOG.md) for details.
+
 ## Copyright
 
-Copyright (c) 2013 Naotoshi SEO. See [LICENSE](LICENSE) for details.
+Copyright (c) 2013 Naotoshi Seo. See [LICENSE](LICENSE) for details.

data/fluent-plugin-keep-forward.gemspec

@@ -3,11 +3,11 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "fluent-plugin-keep-forward"
-  s.version     = "0.0.4"
-  s.authors     = ["Naotoshi SEO"]
+  s.version     = "0.1.1"
+  s.authors     = ["Naotoshi Seo"]
   s.email       = ["sonots@gmail.com"]
   s.homepage    = "https://github.com/sonots/fluent-plugin-keep-forward"
-  s.summary     = "out_foward extension to keep forwarding to a node"
+  s.summary     = "Fluentd plugin to keep forwarding to a node"
   s.description = s.summary
 
   s.rubyforge_project = "fluent-plugin-keep-forward"
@@ -21,4 +21,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rake"
   s.add_development_dependency "rspec"
   s.add_development_dependency "pry"
+  s.add_development_dependency "pry-nav"
+  s.add_development_dependency "delorean"
 end

data/lib/fluent/plugin/out_keep_forward.rb

@@ -4,22 +4,64 @@ class Fluent::KeepForwardOutput < Fluent::ForwardOutput
   Fluent::Plugin.register_output('keep_forward', self)
 
   config_param :prefer_recover, :bool, :default => true
+  config_param :keepalive, :bool, :default => false
+  config_param :keepalive_time, :time, :default => nil # infinite
 
-  def write_objects(tag, es)
-    @node ||= {}
-    if @node[tag] and @node[tag].available? and (!@prefer_recover or @weight_array.include?(@node[tag]))
+  # for test
+  attr_accessor :watcher_interval
+
+  def configure(conf)
+    super
+
+    @node = {}
+    @sock = {}
+    @sock_expired_at = {}
+    @mutex = {}
+    @watcher_interval = 1
+  end
+
+  def start
+    super
+    start_watcher
+  end
+
+  def shutdown
+    super
+    stop_watcher
+  end
+
+  def start_watcher
+    if @keepalive and @keepalive_time
+      @watcher = Thread.new(&method(:watch_keepalive_time))
+    end
+  end
+
+  def stop_watcher
+    if @watcher
+      @watcher.terminate
+      @watcher.join
+    end
+  end
+
+  # Override
+  def write_objects(tag, chunk)
+    return if chunk.empty?
+    error = nil
+    node = @node[tag]
+
+    if node and node.available? and (!@prefer_recover or @weight_array.include?(node))
       begin
-        send_data(@node[tag], tag, es)
+        send_data(node, tag, chunk)
         return
       rescue
-        weight_send_data(tag, es)
+        weight_send_data(tag, chunk)
       end
     else
-      weight_send_data(tag, es)
+      weight_send_data(tag, chunk)
     end
   end
 
-  def weight_send_data(tag, es)
+  def weight_send_data(tag, chunk)
     error = nil
 
     wlen = @weight_array.length
@@ -29,9 +71,8 @@ class Fluent::KeepForwardOutput < Fluent::ForwardOutput
 
       if node.available?
         begin
-          send_data(node, tag, es)
+          send_data(node, tag, chunk)
           @node[tag] = node
-          # $log.info "keep forwarding tag '#{tag}' to node '#{node.name}'", :host=>node.host, :port=>node.port, :weight=>node.weight
           return
         rescue
           # for load balancing during detecting crashed servers
@@ -41,11 +82,102 @@ class Fluent::KeepForwardOutput < Fluent::ForwardOutput
     end
 
     @node[tag] = nil
-    # $log.info "keep forwarding tag '#{tag}' is lost"
     if error
       raise error
     else
       raise "no nodes are available"  # TODO message
     end
   end
+
+  # Override for keepalive
+  def send_data(node, tag, chunk)
+    get_mutex(node).synchronize do
+      sock = get_sock[node]
+      unless sock
+        sock = reconnect(node)
+      end
+
+      begin
+        sock_write(sock, tag, chunk)
+        node.heartbeat(false)
+      rescue Errno::EPIPE, Errno::ECONNRESET, Errno::ECONNABORTED, Errno::ETIMEDOUT => e
+        $log.warn "out_keep_forward: #{e.class} #{e.message}"
+        sock = reconnect(node)
+        retry
+      end
+    end
+  end
+
+  def reconnect(node)
+    sock = connect(node)
+    opt = [1, @send_timeout.to_i].pack('I!I!')  # { int l_onoff; int l_linger; }
+    sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_LINGER, opt)
+
+    opt = [@send_timeout.to_i, 0].pack('L!L!')  # struct timeval
+    sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, opt)
+
+    if @keepalive
+      get_sock[node] = sock
+      get_sock_expired_at[node] = Time.now + @keepalive_time if @keepalive_time
+    end
+
+    sock
+  end
+
+  def sock_write(sock, tag, chunk)
+    # beginArray(2)
+    sock.write FORWARD_HEADER
+
+    # writeRaw(tag)
+    sock.write tag.to_msgpack  # tag
+
+    # beginRaw(size)
+    sz = chunk.size
+    #if sz < 32
+    #  # FixRaw
+    #  sock.write [0xa0 | sz].pack('C')
+    #elsif sz < 65536
+    #  # raw 16
+    #  sock.write [0xda, sz].pack('Cn')
+    #else
+    # raw 32
+    sock.write [0xdb, sz].pack('CN')
+    #end
+
+    # writeRawBody(packed_es)
+    chunk.write_to(sock)
+  end
+
+  # watcher thread callback
+  def watch_keepalive_time
+    while true
+      sleep @watcher_interval
+      thread_ids = @sock.keys
+      thread_ids.each do |thread_id|
+        @sock[thread_id].each do |node, sock|
+          @mutex[thread_id][node].synchronize do
+            next unless sock_expired_at = @sock_expired_at[thread_id][node]
+            next unless Time.now >= sock_expired_at
+            sock.close rescue IOError if sock
+            @sock[thread_id][node] = nil
+            @sock_expired_at[thread_id][node] = nil
+          end
+        end
+      end
+    end
+  end
+
+  def get_mutex(node)
+    thread_id = Thread.current.object_id
+    @mutex[thread_id] ||= {}
+    @mutex[thread_id][node] ||= Mutex.new
+  end
+
+  def get_sock
+    @sock[Thread.current.object_id] ||= {}
+  end
+
+  def get_sock_expired_at
+    @sock_expired_at[Thread.current.object_id] ||= {}
+  end
 end

data/spec/out_keep_forward_spec.rb

@@ -14,72 +14,134 @@ shared_context 'keep_forward_init' do
     </server>
   ]
   let(:tag) { 'syslog.host1' }
-  let(:es)  { Object.new }
+  let(:chunk)  { [1] }
   let(:config) { CONFIG }
   let(:driver) { Fluent::Test::OutputTestDriver.new(Fluent::KeepForwardOutput, tag).configure(config).instance }
 end
 
 shared_context 'keep_forward_try_once' do
   before do
+    # stub connection
+    stub_sock = StringIO.new
+    driver.stub(:connect).and_return { stub_sock }
+    stub_sock.stub(:setsockopt)
+    driver.stub(:sock_write).and_return { nil }
+    Fluent::ForwardOutput::Node.any_instance.stub(:heartbeat).and_return { nil }
     # simpler version of Fluent::ForwardOutput#start method
+    driver.watcher_interval = 0
+    driver.start_watcher
     driver.instance_variable_set(:@rand_seed, Random.new.seed)
     driver.send(:rebuild_weight_array)
     driver.instance_variable_set(:@rr, 0)
-    # try send once to cache keep_node
-    driver.stub(:send_data) # stub
-    driver.write_objects(tag, es)
+    driver.write_objects(tag, chunk)
+  end
+  after do
+    driver.stop_watcher
   end
   let!(:keep_node) { driver.instance_variable_get(:@node)[tag] }
-  let!(:unkeep_node) { (driver.instance_variable_get(:@nodes) - [keep_node]).first }
+  let!(:another_node) { (driver.instance_variable_get(:@nodes) - [keep_node]).first }
+end
+
+shared_examples "keep_node_available" do
+  it { driver.write_objects(tag, chunk) }
+end
+
+shared_examples "keep_node_not_available" do
+  before { keep_node.available = false }
+  it { driver.write_objects(tag, chunk) }
+end
+
+shared_examples "prefer_recover false" do
+  let(:config) { CONFIG + %[prefer_recover false] }
+  before { driver.instance_variable_set(:@weight_array, [another_node]) }
+  it { driver.write_objects(tag, chunk) }
+end
+
+shared_context "prefer_recover true" do
+  let(:config) { CONFIG + %[prefer_recover true] }
+  before { driver.instance_variable_set(:@weight_array, [another_node]) }
+  it { driver.write_objects(tag, chunk) }
+end
+
+shared_examples "error_occurs" do
+  before { driver.stub(:send_data).with(keep_node, tag, chunk).and_raise(StandardError) }
+  it { driver.write_objects(tag, chunk) }
 end
 
 describe Fluent::KeepForwardOutput do
   include_context 'keep_forward_init'
   include_context 'keep_forward_try_once'
-  before { driver.should_receive(:send_data).with(target, tag, es) } # mock
 
-  describe 'keep forwarding if no problem?' do
-    let(:target) { keep_node }
-    it { driver.write_objects(tag, es) }
+  describe "keep_node" do
+    it_should_behave_like 'keep_node_available' do
+      before { driver.should_receive(:send_data).with(keep_node, tag, chunk) }
+    end
+    it_should_behave_like 'keep_node_not_available' do
+      before { driver.should_receive(:send_data).with(another_node, tag, chunk) }
+    end
+    it_should_behave_like 'prefer_recover true' do
+      before { driver.should_receive(:send_data).with(another_node, tag, chunk) }
+    end
+    it_should_behave_like 'prefer_recover false' do
+      before { driver.should_receive(:send_data).with(keep_node, tag, chunk) }
+    end
+    it_should_behave_like 'error_occurs' do
+      before { driver.stub(:weight_send_data).with(tag, chunk) } # re-call weight_send_data
+    end
   end
 
-  describe 'switch if not available?' do
-    before { keep_node.available = false }
-
-    let(:target) { unkeep_node }
-    it { driver.write_objects(tag, es) }
+  describe "keepalive false" do
+    let(:config) { CONFIG + %[keepalive false] }
+    it_should_behave_like 'keep_node_available' do
+      before { driver.should_receive(:reconnect) }
+    end
+    it_should_behave_like 'keep_node_not_available' do
+      before { driver.should_receive(:reconnect) }
+    end
+    it_should_behave_like 'prefer_recover true' do
+      let(:config) { CONFIG + %[prefer_recover true\nkeepalive false] }
+      before { driver.should_receive(:reconnect) }
+    end
+    it_should_behave_like 'prefer_recover false' do
+      let(:config) { CONFIG + %[prefer_recover false\nkeepalive false] }
+      before { driver.should_receive(:reconnect) }
+    end
   end
 
-  describe 'not included in weight_array?' do
-    context "switch if recover true" do
-      let(:config) {
-        CONFIG + %[
-          prefer_recover true
-        ]
-      }
-      before { driver.instance_variable_set(:@weight_array, [unkeep_node]) }
-
-      let(:target) { unkeep_node }
-      it { driver.write_objects(tag, es) }
+  describe "keepalive true" do
+    let(:config) { CONFIG + %[keepalive true] }
+    it_should_behave_like 'keep_node_available' do
+      before { driver.should_not_receive(:reconnect) }
     end
-
-    context "not switch if recorver false" do
-      let(:config) {
-        CONFIG + %[
-          prefer_recover false
-        ]
-      }
-      before { driver.instance_variable_set(:@weight_array, [unkeep_node]) }
-
-      let(:target) { keep_node }
-      it { driver.write_objects(tag, es) }
+    it_should_behave_like 'keep_node_not_available' do
+      before { driver.should_receive(:reconnect) }
+    end
+    it_should_behave_like 'prefer_recover true' do
+      let(:config) { CONFIG + %[prefer_recover true\nkeepalive true] }
+      before { driver.should_receive(:reconnect) }
+    end
+    it_should_behave_like 'prefer_recover false' do
+      let(:config) { CONFIG + %[prefer_recover false\nkeepalive true] }
+      before { driver.should_not_receive(:reconnect) }
     end
   end
 
-  describe 'switch if send_data to keep_node raises?' do
-    before { driver.stub(:send_data).with(keep_node, tag, es).and_raise(StandardError) }
-
-    let(:target) { unkeep_node }
-    it { driver.write_objects(tag, es) }
+  describe "keepalive_time expired" do
+    let(:config) { CONFIG + %[keepalive true\nkeepalive_time 30] }
+    before { Delorean.jump 30 }
+    it_should_behave_like 'keep_node_available' do
+      before { sleep 1; driver.should_receive(:reconnect) }
+    end
+    it_should_behave_like 'keep_node_not_available' do
+      before { sleep 1; driver.should_receive(:reconnect) }
+    end
+    it_should_behave_like 'prefer_recover true' do
+      let(:config) { CONFIG + %[prefer_recover true\nkeepalive true\nkeepalive_time 30] }
+      before { sleep 1; driver.should_receive(:reconnect) }
+    end
+    it_should_behave_like 'prefer_recover false' do
+      let(:config) { CONFIG + %[prefer_recover false\nkeepalive true\nkeepalive_time 30] }
+      before { sleep 1; driver.should_receive(:reconnect) }
+    end
   end
 end

data/spec/spec_helper.rb

@@ -7,6 +7,7 @@ Bundler.require(:default, :test)
 require 'fluent/test'
 require 'rspec'
 require 'pry'
+require 'delorean'
 
 $TESTING=true
 $:.unshift File.join(File.dirname(__FILE__), '..', 'lib')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-keep-forward
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.1
 platform: ruby
 authors:
-- Naotoshi SEO
+- Naotoshi Seo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-08 00:00:00.000000000 Z
+date: 2013-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fluentd
@@ -66,7 +66,35 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: out_foward extension to keep forwarding to a node
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: delorean
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Fluentd plugin to keep forwarding to a node
 email:
 - sonots@gmail.com
 executables: []
@@ -76,8 +104,8 @@ files:
 - .gitignore
 - .rdebugrc
 - .rspec
-- .ruby-version
 - .travis.yml
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
@@ -105,10 +133,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: fluent-plugin-keep-forward
-rubygems_version: 2.0.0
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
-summary: out_foward extension to keep forwarding to a node
+summary: Fluentd plugin to keep forwarding to a node
 test_files:
 - spec/out_keep_forward_spec.rb
 - spec/spec_helper.rb

data/.ruby-version

@@ -1 +0,0 @@
-2.0.0-p0