fluent-plugin-droonga 0.7.0 → 0.8.0

data/lib/droonga/handler.rb

@@ -18,6 +18,8 @@
 require "groonga"
 
 require "droonga/forwarder"
+require "droonga/handler_message"
+require "droonga/handler_messenger"
 require "droonga/pluggable"
 require "droonga/handler_plugin"
 
@@ -25,15 +27,22 @@ module Droonga
   class Handler
     include Pluggable
 
-    attr_reader :context, :envelope, :name
+    attr_reader :context, :name
 
-    def initialize(options={})
+    def initialize(loop, options={})
+      @loop = loop
       @options = options
       @name = options[:name]
       @database_name = options[:database]
       prepare
     end
 
+    def start
+      $log.trace("#{log_tag}: start: start")
+      @forwarder.start
+      $log.trace("#{log_tag}: start: done")
+    end
+
     def shutdown
       $log.trace("#{log_tag}: shutdown: start")
       super
@@ -50,96 +59,39 @@ module Droonga
       find_plugin(command).prefer_synchronous?(command)
     end
 
-    def process(envelope)
+    def process(message)
       $log.trace("#{log_tag}: process: start")
-      body, command, arguments = parse_envelope(envelope)
+      command = message["type"]
       plugin = find_plugin(command)
       if plugin.nil?
         $log.trace("#{log_tag}: process: done: no plugin: <#{command}>")
         return
       end
-      process_command(plugin, command, body, arguments)
+      process_command(plugin, command, message)
       $log.trace("#{log_tag}: process: done: <#{command}>",
                  :plugin => plugin.class)
     end
 
-    def emit(value, name = nil)
-      unless name
-        if @output_names
-          name = @output_names.first
-        else
-          @output_values = @task["values"] = value
-          return
-        end
-      end
-      @output_values[name] = value
-    end
-
-    def post(message, destination)
-      @forwarder.forward(envelope, message, destination)
-    end
-
     private
-    def parse_envelope(envelope)
-      @envelope = envelope
-      envelope["via"] ||= []
-      [envelope["body"], envelope["type"], envelope["arguments"]]
-    end
-
     def prepare
       if @database_name && !@database_name.empty?
         @context = Groonga::Context.new
         @database = @context.open_database(@database_name)
       end
       load_plugins(@options[:handlers] || [])
-      @forwarder = Forwarder.new
+      @forwarder = Forwarder.new(@loop)
     end
 
     def instantiate_plugin(name)
       HandlerPlugin.repository.instantiate(name, self)
     end
 
-    def process_command(plugin, command, request, arguments)
-      return false unless request.is_a? Hash
-
-      @task = request["task"]
-      return false unless @task.is_a? Hash
-
-      @component = @task["component"]
-      return false unless @component.is_a? Hash
-
-      @output_values = @task["values"]
-      @body = @component["body"]
-      @output_names = @component["outputs"]
-      @id = request["id"]
-      @value = request["value"]
-      @input_name = request["name"]
-      @descendants = request["descendants"]
+    def process_command(plugin, command, raw_message)
+      handler_message = HandlerMessage.new(raw_message)
+      handler_message.validate
 
-      plugin.process(command, @body, *arguments)
-      output if @descendants
-      true
-    end
-
-    def output
-      result = @task["values"]
-      if @component["post"]
-        destination = @component["post"]
-        destination = envelope["replyTo"] if destination == true
-        post(result, destination)
-      end
-      @descendants.each do |name, dests|
-        message = {
-          "id" => @id,
-          "input" => name,
-          "value" => result[name]
-        }
-        dests.each do |routes|
-          routes.each do |route|
-            post(message, "to"=>route, "type"=>"dispatcher")
-          end
-        end
-      end
+      messenger = HandlerMessenger.new(@forwarder, handler_message, @options)
+      plugin.process(command, handler_message, messenger)
     end
 
     def log_tag

data/lib/droonga/handler_message.rb

@@ -0,0 +1,61 @@
+# Copyright (C) 2013 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+module Droonga
+  class HandlerMessage
+    attr_reader :raw
+    def initialize(raw)
+      @raw = raw
+    end
+
+    def validate
+      unless task.is_a?(Hash)
+        raise "<task> value isn't object: <#{@raw.inspect}>"
+      end
+
+      unless component.is_a?(Hash)
+        raise "<task/component> value isn't object: <#{@raw.inspect}>"
+      end
+    end
+
+    def [](name)
+      @raw[name]
+    end
+
+    def body
+      @body ||= self["body"]
+    end
+
+    def task
+      @task ||= body["task"]
+    end
+
+    def component
+      @component ||= task["component"]
+    end
+
+    def request
+      @request ||= component["body"]
+    end
+
+    def id
+      @id ||= body["id"]
+    end
+
+    def descendants
+      @descendants ||= body["descendants"]
+    end
+  end
+end

data/lib/droonga/handler_messenger.rb

@@ -0,0 +1,92 @@
+# Copyright (C) 2013 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+require "droonga/replier"
+require "droonga/forwarder"
+
+module Droonga
+  class HandlerMessenger
+    def initialize(forwarder, message, options={})
+      @forwarder = forwarder
+      @message = message
+      @options = options
+      @replier = Replier.new(@forwarder)
+      @dispatcher = @options[:dispatcher]
+    end
+
+    def emit(value)
+      descendants = @message.descendants
+      raw_message = @message.raw
+      if descendants.empty?
+        return if raw_message["replyTo"].nil?
+        @replier.reply(raw_message.merge("body" => value))
+      else
+        descendants.each do |name, dests|
+          body = {
+            "id"    => @message.id,
+            "input" => name,
+            "value" => value[name],
+          }
+          dests.each do |dest|
+            if @dispatcher
+              @dispatcher.dispatch(body, dest)
+            else
+              message = raw_message.merge("body" => body)
+              forward(message, "to" => dest, "type" => "dispatcher")
+            end
+          end
+        end
+      end
+    end
+
+    def error(status_code, body)
+      descendants = @message.descendants
+      raw_message = @message.raw
+      if descendants.empty?
+        return if raw_message["replyTo"].nil?
+        response = raw_message.merge("statusCode" => status_code,
+                                     "body" => body)
+        @replier.reply(response)
+      else
+        #XXX IMPLEMENT ME!!
+        raise error
+      end
+    end
+
+    # Forwards a Droonga message to other Droonga Engine.
+    #
+    # @param [Hash] droonga_message
+    #   The Droonga message to be forwarded.
+    # @param [Hash] destination
+    #   The destination of the Droonga message. See {Forwarder#forward} to
+    #   know about how to specify destination.
+    #
+    # @return [void]
+    #
+    # @see Forwarder#forward
+    def forward(droonga_message, destination)
+      @forwarder.forward(droonga_message, destination)
+    end
+
+    def inspect
+      "\#<#{self.class} id=#{object_id}>"
+    end
+
+    private
+    def log_tag
+      "[#{Process.ppid}][#{Process.pid}] handler_messenger"
+    end
+  end
+end

data/lib/droonga/handler_plugin.rb

@@ -16,6 +16,7 @@
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 require "droonga/plugin"
+require "droonga/message_processing_error"
 
 module Droonga
   class HandlerPlugin < Plugin
@@ -27,20 +28,17 @@ module Droonga
       @context = @handler.context
     end
 
-    def envelope
-      @handler.envelope
-    end
-
-    def emit(value, name=nil)
-      @handler.emit(value, name)
-    end
-
-    def post(body, destination=nil)
-      @handler.post(body, destination)
-    end
-
     def prefer_synchronous?(command)
       false
     end
+
+    private
+    def run_command(command, message, messenger)
+      begin
+        super
+      rescue MessageProcessingError => error
+        messenger.error(error.status_code, error.response_body)
+      end
+    end
   end
 end

data/lib/droonga/input_adapter.rb

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+require "droonga/pluggable"
+require "droonga/input_adapter_plugin"
+require "droonga/input_message"
+
+module Droonga
+  class InputAdapter
+    include Pluggable
+
+    def initialize(dispatcher, options={})
+      @dispatcher = dispatcher
+      load_plugins(options[:plugins] || [])
+    end
+
+    def adapt(message)
+      adapted_message = message
+      @plugins.each do |plugin|
+        input_message = InputMessage.new(adapted_message)
+        command = input_message.command
+        next unless plugin.processable?(command)
+        process(command, input_message)
+        adapted_message = input_message.adapted_message
+      end
+      adapted_message
+    end
+
+    private
+    def instantiate_plugin(name)
+      InputAdapterPlugin.repository.instantiate(name, @dispatcher)
+    end
+
+    def log_tag
+      "input-adapter"
+    end
+  end
+end

data/lib/droonga/{adapter.rb → input_adapter_plugin.rb}

@@ -15,25 +15,19 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
-require "droonga/pluggable"
-require "droonga/adapter_plugin"
+require "droonga/plugin"
 
 module Droonga
-  class Adapter
-    include Pluggable
+  class InputAdapterPlugin < Plugin
+    extend PluginRegisterable
 
-    def initialize(dispatcher, options={})
+    def initialize(dispatcher)
+      super()
       @dispatcher = dispatcher
-      load_plugins(options[:adapters] || [])
     end
 
-    private
-    def instantiate_plugin(name)
-      AdapterPlugin.repository.instantiate(name, @dispatcher)
-    end
-
-    def log_tag
-      "adapter"
+    def forward(message, destination)
+      @dispatcher.forward(message, destination)
     end
   end
 end

data/lib/droonga/input_message.rb

@@ -17,35 +17,35 @@
 
 module Droonga
   class InputMessage
-    def initialize(envelope)
-      @envelope = envelope
+    def initialize(raw_message)
+      @raw_message = raw_message
     end
 
-    def adapted_envelope
-      # TODO: We can create adapted envelope non-destructively.
+    def adapted_message
+      # TODO: We can create adapted message non-destructively.
       # If it is not performance issue, it is better that we don't
-      # change envelope destructively. Consider about it later.
-      @envelope
+      # change message destructively. Consider about it later.
+      @raw_message
     end
 
     def add_route(route)
-      @envelope["via"].push(route)
+      @raw_message["via"].push(route)
     end
 
     def body
-      @envelope["body"]
+      @raw_message["body"]
     end
 
     def body=(body)
-      @envelope["body"] = body
+      @raw_message["body"] = body
     end
 
     def command
-      @envelope["type"]
+      @raw_message["type"]
     end
 
     def command=(command)
-      @envelope["type"] = command
+      @raw_message["type"] = command
     end
   end
 end