droonga-engine 1.0.9 → 1.1.0

data/lib/droonga/fluent_message_sender.rb

@@ -52,13 +52,19 @@ module Droonga
     def send(tag, data)
       logger.trace("send: start")
       packed_fluent_message = create_packed_fluent_message(tag, data)
-      connect unless connected?
+      unless connected?
+        logger.trace("send: reconnect")
+        connect
+      end
       @socket.write(packed_fluent_message)
       logger.trace("send: done")
     end
 
     def resume
-      connect unless connected?
+      unless connected?
+        logger.trace("resume: reconnect to #{target_node}")
+        connect
+      end
     end
 
     private
@@ -69,22 +75,8 @@ module Droonga
     def connect
       logger.trace("connect: start")
 
-      log_write_complete = lambda do
-        logger.trace("write completed")
-      end
-      log_connect = lambda do
-        logger.trace("connected to #{@host}:#{@port}")
-      end
-      log_failed = lambda do
-        logger.error("failed to connect to #{@host}:#{@port}")
-        @socket = nil
-      end
-      on_close = lambda do
-        @socket = nil
-      end
-
       if @buffering
-        data_directory = Path.buffer + "#{@host}:#{@port}"
+        data_directory = Path.accidental_buffer + "#{target_node}"
         FileUtils.mkdir_p(data_directory.to_s)
         @socket = BufferedTCPSocket.connect(@host, @port, data_directory)
         @socket.resume
@@ -92,25 +84,36 @@ module Droonga
         @socket = Coolio::TCPSocket.connect(@host, @port)
       end
       @socket.on_write_complete do
-        log_write_complete.call
+        logger.trace("write completed")
       end
       @socket.on_connect do
-        log_connect.call
+        logger.trace("connected")
       end
       @socket.on_connect_failed do
-        log_failed.call
+        logger.error("failed to connect")
+        @socket = nil
       end
       @socket.on_close do
-        on_close.call
+        logger.trace("connection is closed by someone")
+        @socket = nil
       end
       @loop.attach(@socket)
+      # logger.trace("connect: new socket watcher attached",
+      #              :watcher => @socket,
+      #              :host => @host,
+      #              :port => @port)
 
       logger.trace("connect: done")
     end
 
     def shutdown_socket
       return unless connected?
-      @socket.close unless @socket.closed?
+      unless @socket.closed?
+        # logger.trace("shutdown_socket: socket watcher detaching",
+        #              :watcher => @socket)
+        @socket.close
+        logger.trace("shutdown_socket: socket watcher detached")
+      end
     end
 
     def create_packed_fluent_message(tag, data)
@@ -121,8 +124,12 @@ module Droonga
       packed_fluent_message
     end
 
+    def target_node
+      "#{@host}:#{@port}"
+    end
+
     def log_tag
-      "[#{Process.ppid}] fluent-message-sender"
+      "[#{Process.ppid}] fluent-message-sender: #{target_node}"
     end
   end
 end

data/lib/droonga/forward_buffer.rb

@@ -0,0 +1,160 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014-2015 Droonga Project
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "fileutils"
+require "pathname"
+require "msgpack"
+require "time"
+
+require "droonga/loggable"
+require "droonga/path"
+require "droonga/safe_file_writer"
+require "droonga/serf"
+require "droonga/timestamp"
+
+module Droonga
+  class ForwardBuffer
+    include Loggable
+
+    SUFFIX = ".msgpack"
+
+    attr_writer :on_forward
+
+    def initialize(node_name)
+      @on_forward = nil
+
+      @packer = MessagePack::Packer.new
+      @unpacker = MessagePack::Unpacker.new
+
+      @target = node_name
+      @serf = Serf.new(ENV["DROONGA_ENGINE_NAME"])
+
+      dirname = node_name.gsub("/", ":")
+      @data_directory = Path.intentional_buffer + dirname
+      FileUtils.mkdir_p(@data_directory.to_s)
+    end
+
+    def add(message, destination)
+      logger.trace("add: start")
+      @serf.set_have_unprocessed_messages_for(@target)
+      buffered_message = {
+        "message"     => message,
+        "destination" => destination,
+      }
+      @packer.pack(buffered_message)
+      file_path = create_buffered_message_path
+      SafeFileWriter.write(file_path) do |output, file|
+        output.puts(@packer.to_s)
+      end
+      @packer.clear
+      logger.trace("add: done", :path => file_path)
+    end
+
+    def start_forward
+      logger.trace("start_forward: start")
+      n_forwarded_messages = 0
+      buffered_messages.each do |buffered_message_path|
+        forwarded = forward(buffered_message_path)
+        n_forwarded_messages += 1 if forwarded
+      end
+      if n_forwarded_messages > 0 and
+           @process_messages_newer_than_timestamp
+        logger.info("#{n_forwarded_messages} new messages forwarded. " +
+                      "The boundary is now cleared.")
+        # Don't clear the boundary while forwarding.
+        # Because buffered messages are not sorted by their "date",
+        # so older messages can appear after newer one.
+        # (ex. messages generated by Dispatcher)
+        @process_messages_newer_than_timestamp = nil
+      end
+      @serf.reset_have_unprocessed_messages_for(@target)
+      logger.trace("start_forward: done")
+    end
+
+    def buffered_messages
+      Pathname.glob("#{@data_directory}/*#{SUFFIX}").sort_by do |path|
+        path
+      end
+    end
+
+    def empty?
+      @data_directory.children.empty?
+    end
+
+    def process_messages_newer_than(timestamp)
+      @process_messages_newer_than_timestamp = timestamp
+    end
+
+    private
+    def forward(buffered_message_path)
+      logger.trace("forward: start (#{buffered_message_path})")
+
+      unless buffered_message_path.exist?
+        logger.warn("forward: no buffer file (maybe sent by other process)",
+                    :path => buffered_message_path)
+        return false
+      end
+
+      file_contents = buffered_message_path.read
+      @unpacker.feed(file_contents)
+      buffered_message = @unpacker.read
+      @unpacker.reset
+
+      message     = buffered_message["message"]
+      destination = buffered_message["destination"]
+
+      forwarded = false
+
+      if @process_messages_newer_than_timestamp
+        message_timestamp = Time.parse(message["date"])
+        logger.trace("Checking boundary of obsolete message",
+                     :newer_than => @process_messages_newer_than_timestamp,
+                     :message_at => message_timestamp)
+        if @process_messages_newer_than_timestamp >= message_timestamp
+          buffered_message = nil
+        end
+      end
+
+      if buffered_message
+        logger.trace("forward: Forwarding buffered message",
+                     :message     => message,
+                     :destination => destination)
+        message["xSender"] = "forward-buffer"
+        on_forward(message, destination)
+        forwarded = true
+      end
+
+      FileUtils.rm_f(buffered_message_path.to_s)
+      logger.trace("forward: done (#{buffered_message_path})")
+
+      forwarded
+    end
+
+    def create_buffered_message_path(time_stamp=Time.now)
+      basename = Timestamp.stringify(time_stamp)
+      Path.unique_file_path(@data_directory, basename, SUFFIX)
+    end
+
+    def on_forward(message, destination)
+      @on_forward.call(message, destination) if @on_forward
+    end
+
+    def log_tag
+      "[#{Process.ppid}] forward-buffer"
+    end
+  end
+end

data/lib/droonga/forwarder.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2013 Droonga Project
+# Copyright (C) 2013-2015 Droonga Project
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -15,38 +15,45 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
+require "coolio"
+
 require "droonga/loggable"
 require "droonga/path"
-require "droonga/event_loop"
-require "droonga/buffered_tcp_socket"
 require "droonga/fluent_message_sender"
 
 module Droonga
   class Forwarder
     include Loggable
 
+    class AlreadyShutdown < StandardError
+    end
+
+    DEFAULT_AUTO_CLOSE_TIMEOUT_SECONDS = 60
+
     def initialize(loop, options={})
       @loop = loop
-      @buffering = options[:buffering]
       @senders = {}
+      @auto_close_timers = {}
+      @shutting_down = false
+      @auto_close_timeout = options[:auto_close_timeout] ||
+                              DEFAULT_AUTO_CLOSE_TIMEOUT_SECONDS
     end
 
     def start
       logger.trace("start: start")
-      resume
       logger.trace("start: done")
     end
 
     def shutdown
       logger.trace("shutdown: start")
-      @senders.each_value do |sender|
-        sender.shutdown
-      end
+      @shutting_down = true
+      clear_senders
       logger.trace("shutdown: done")
     end
 
     def forward(message, destination)
-      logger.trace("forward: start")
+      logger.trace("forward: start", :message => message)
+      raise AlreadyShutdown.new if @shutting_down
       command = destination["type"]
       receiver = destination["to"]
       arguments = destination["arguments"]
@@ -54,33 +61,25 @@ module Droonga
       logger.trace("forward: done")
     end
 
-    def resume
-      return unless Path.buffer.exist?
-      Pathname.glob("#{Path.buffer}/*") do |path|
-        next unless path.directory?
-
-        destination = path.basename.to_s
-        sender = @senders[destination]
-        if sender
-          sender.resume
-          next
-        end
-
-        chunk_loader = BufferedTCPSocket::ChunkLoader.new(path)
-        unless chunk_loader.have_any_chunk?
-          #FileUtils.rm_rf(path.to_s) # TODO re-enable this
-          next
-        end
-
-        components = destination.split(":")
-        port = components.pop.to_i
-        next if port.zero?
-        host = components.join(":")
-
-        sender = create_sender(host, port)
-        sender.resume
-        @senders[destination] = sender
+    def refresh_connection_for(name)
+      logger.trace("refresh_connection_for(#{name}): start")
+      sender = @senders[name]
+      if sender
+        sender.shutdown
+        @senders.delete(name)
+      end
+      timer = @auto_close_timers[name]
+      if timer
+        timer.detach
+        @auto_close_timers.delete(name)
       end
+      logger.trace("refresh_connection_for(#{name}): done")
+    end
+
+    def refresh_all_connections
+      logger.trace("refresh_all_connections: start")
+      clear_senders
+      logger.trace("refresh_all_connections: done")
     end
 
     private
@@ -107,6 +106,7 @@ module Droonga
                      :params => params)
         return
       end
+      set_auto_close_timer(host, port, params)
       override_message = {
         "type" => command,
       }
@@ -120,11 +120,15 @@ module Droonga
       logger.trace("output: done")
     end
 
-    def find_sender(host, port, params)
+    def resolve_destination(host, port, params)
       connection_id = extract_connection_id(params)
       destination = "#{host}:#{port}"
       destination << "?#{connection_id}" if connection_id
+      destination
+    end
 
+    def find_sender(host, port, params)
+      destination = resolve_destination(host, port, params)
       @senders[destination] ||= create_sender(host, port)
     end
 
@@ -139,14 +143,43 @@ module Droonga
     end
 
     def create_sender(host, port)
-      options = {
-        :buffering => @buffering,
-      }
-      sender = FluentMessageSender.new(@loop, host, port, options)
+      sender = FluentMessageSender.new(@loop, host, port)
       sender.start
       sender
     end
 
+    def set_auto_close_timer(host, port, params)
+      destination = resolve_destination(host, port, params)
+
+      previous_timer = @auto_close_timers[destination]
+      previous_timer.detach if previous_timer
+
+      timer = Coolio::TimerWatcher.new(@auto_close_timeout)
+      timer.on_timer do
+        timer.detach
+        @auto_close_timers.delete(destination)
+        sender = @senders[destination]
+        if sender
+          logger.info("sender for #{destination} is automatically closed by timeout.")
+          sender.shutdown
+          @senders.delete(destination)
+        end
+      end
+      @loop.attach(timer)
+      @auto_close_timers[destination] = timer
+    end
+
+    def clear_senders
+      @senders.each_value do |sender|
+        sender.shutdown
+      end
+      @senders = {}
+      @auto_close_timers.each_value do |timer|
+        timer.detach
+      end
+      @auto_close_timers = {}
+    end
+
     def log_tag
       "[#{Process.ppid}] forwarder"
     end

data/lib/droonga/handler.rb

@@ -35,12 +35,13 @@ module Droonga
       end
     end
 
-    attr_reader :messenger, :loop
-    def initialize(name, context, messenger, loop)
-      @name = name
-      @context = context
-      @messenger = messenger
-      @loop = loop
+    attr_reader :label, :messenger, :loop
+    def initialize(params)
+      @name      = params[:name]
+      @label     = params[:label]
+      @context   = params[:context]
+      @messenger = params[:messenger]
+      @loop      = params[:loop]
     end
 
     def handle(message)