fluent-plugin-droonga 0.9.0 → 0.9.9

data/lib/droonga/distributor.rb

@@ -15,35 +15,61 @@
 # 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/distributor_plugin"
-require "droonga/distribution_planner"
+require "tsort"
 
 module Droonga
   class Distributor
-    include Pluggable
+    class UndefinedInputError < StandardError
+      attr_reader :input
+      def initialize(input)
+        @input = input
+        super("undefined input assigned: <#{input}>")
+      end
+    end
+
+    class CyclicStepsError < StandardError
+      attr_reader :steps
+      def initialize(steps)
+        @steps = steps
+        super("cyclic steps found: <#{steps}>")
+      end
+    end
+
+    include TSort
 
-    def initialize(dispatcher, options={})
+    def initialize(dispatcher)
       @dispatcher = dispatcher
-      @plugins = []
-      @options = options
-      # TODO: don't put the default distributions
-      load_plugins(options[:distributors] || ["search", "crud", "groonga", "watch"])
     end
 
-    def distribute(components)
-      planner = DistributionPlanner.new(@dispatcher, components)
-      planned_components = planner.plan
-      @dispatcher.dispatch_components(planned_components)
+    def distribute(plan)
+      @dependency = {}
+      plan.each do |step|
+        @dependency[step] = step["inputs"]
+        next unless step["outputs"]
+        step["outputs"].each do |output|
+          @dependency[output] = [step]
+        end
+      end
+      steps = []
+      each_strongly_connected_component do |cs|
+        raise CyclicStepsError.new(cs) if cs.size > 1
+        steps.concat(cs) unless cs.first.is_a? String
+      end
+      @dispatcher.dispatch_steps(steps)
     end
 
     private
-    def instantiate_plugin(name)
-      DistributorPlugin.repository.instantiate(name, self)
+    def tsort_each_node(&block)
+      @dependency.each_key(&block)
     end
 
-    def log_tag
-      "[#{Process.pid}] distributor"
+    def tsort_each_child(node, &block)
+      if node.is_a? String and @dependency[node].nil?
+        raise UndefinedInputError.new(node)
+      end
+      if @dependency[node]
+        @dependency[node].each(&block)
+      end
     end
   end
 end

data/lib/droonga/handler.rb

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2013 Droonga Project
+# Copyright (C) 2014 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,87 +13,30 @@
 # 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 "groonga"
-
-require "droonga/forwarder"
-require "droonga/handler_message"
-require "droonga/handler_messenger"
 require "droonga/pluggable"
-require "droonga/handler_plugin"
+require "droonga/plugin/metadata/input_message"
+require "droonga/plugin/metadata/handler_action"
 
 module Droonga
   class Handler
-    include Pluggable
-
-    attr_reader :context, :name
-
-    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
-      @forwarder.shutdown
-      if @database
-        @database.close
-        @context.close
-        @database = @context = nil
-      end
-      $log.trace("#{log_tag}: shutdown: done")
-    end
-
-    def prefer_synchronous?(command)
-      find_plugin(command).prefer_synchronous?(command)
-    end
+    extend Pluggable
 
-    def process(message)
-      $log.trace("#{log_tag}: process: start")
-      command = message["type"]
-      plugin = find_plugin(command)
-      if plugin.nil?
-        $log.trace("#{log_tag}: process: done: no plugin: <#{command}>")
-        return
+    class << self
+      def message
+        Plugin::Metadata::InputMessage.new(self)
       end
-      process_command(plugin, command, message)
-      $log.trace("#{log_tag}: process: done: <#{command}>",
-                 :plugin => plugin.class)
-    end
 
-    private
-    def prepare
-      if @database_name && !@database_name.empty?
-        @context = Groonga::Context.new
-        @database = @context.open_database(@database_name)
+      def action
+        Plugin::Metadata::HandlerAction.new(self)
       end
-      load_plugins(@options[:handlers] || [])
-      @forwarder = Forwarder.new(@loop)
-    end
-
-    def instantiate_plugin(name)
-      HandlerPlugin.repository.instantiate(name, self)
     end
 
-    def process_command(plugin, command, raw_message)
-      handler_message = HandlerMessage.new(raw_message)
-      handler_message.validate
-
-      messenger = HandlerMessenger.new(@forwarder, handler_message, @options)
-      plugin.process(command, handler_message, messenger)
+    def initialize(name, context)
+      @name = name
+      @context = context
     end
 
-    def log_tag
-      "[#{Process.ppid}][#{Process.pid}] handler"
+    def handle(message, messenger)
     end
   end
 end

data/lib/droonga/handler_message.rb

@@ -25,8 +25,8 @@ module Droonga
         raise "<task> value isn't object: <#{@raw.inspect}>"
       end
 
-      unless component.is_a?(Hash)
-        raise "<task/component> value isn't object: <#{@raw.inspect}>"
+      unless step.is_a?(Hash)
+        raise "<task/step> value isn't object: <#{@raw.inspect}>"
       end
     end
 
@@ -42,12 +42,12 @@ module Droonga
       @task ||= body["task"]
     end
 
-    def component
-      @component ||= task["component"]
+    def step
+      @step ||= task["step"]
     end
 
     def request
-      @request ||= component["body"]
+      @request ||= step["body"]
     end
 
     def id

data/lib/droonga/handler_messenger.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2013 Droonga Project
+# Copyright (C) 2013-2014 Droonga Project
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -63,6 +63,9 @@ module Droonga
                                      "body" => body)
         @replier.reply(response)
       else
+        #XXX This is just a temporary solution. We should rewrite this,
+        #    to put errors outside of the message body. Otherwise
+        #    plugins cannot use the name "errors" for their message body.
         body = {
           "id"    => @message.id,
           "input" => "errors",

data/lib/droonga/handler_plugin.rb

@@ -15,11 +15,11 @@
 # 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/plugin"
+require "droonga/legacy_plugin"
 require "droonga/message_processing_error"
 
 module Droonga
-  class HandlerPlugin < Plugin
+  class HandlerPlugin < LegacyPlugin
     extend PluginRegisterable
 
     def initialize(handler)

data/lib/droonga/handler_runner.rb

@@ -0,0 +1,104 @@
+# Copyright (C) 2013-2014 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 "groonga"
+
+require "droonga/forwarder"
+require "droonga/handler_message"
+require "droonga/handler_messenger"
+require "droonga/handler"
+
+module Droonga
+  class HandlerRunner
+    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")
+      @forwarder.shutdown
+      if @database
+        @database.close
+        @context.close
+        @database = @context = nil
+      end
+      $log.trace("#{log_tag}: shutdown: done")
+    end
+
+    def prefer_synchronous?(command)
+      find_handler_class(command).action.synchronous?
+    end
+
+    def processable?(command)
+      not find_handler_class(command).nil?
+    end
+
+    def process(message)
+      $log.trace("#{log_tag}: process: start")
+      command = message["type"]
+      handler_class = find_handler_class(command)
+      if handler_class.nil?
+        $log.trace("#{log_tag}: process: done: no handler: <#{command}>")
+        return
+      end
+      process_command(handler_class, command, message)
+      $log.trace("#{log_tag}: process: done: <#{command}>",
+                 :handler => handler_class)
+    end
+
+    private
+    def prepare
+      if @database_name && !@database_name.empty?
+        @context = Groonga::Context.new
+        @database = @context.open_database(@database_name)
+      end
+      @handler_classes = Handler.find_sub_classes(@options[:plugins] || [])
+      @forwarder = Forwarder.new(@loop)
+    end
+
+    def find_handler_class(command)
+      @handler_classes.find do |handler_class|
+        handler_class.message.type == command
+      end
+    end
+
+    def process_command(handler_class, command, raw_message)
+      handler_message = HandlerMessage.new(raw_message)
+      handler_message.validate
+
+      messenger = HandlerMessenger.new(@forwarder, handler_message, @options)
+      handler = handler_class.new(@name, @context)
+      begin
+        handler.handle(handler_message, messenger)
+      rescue MessageProcessingError => error
+        messenger.error(error.status_code, error.response_body)
+      end
+    end
+
+    def log_tag
+      "[#{Process.ppid}][#{Process.pid}] handler"
+    end
+  end
+end

data/lib/droonga/input_message.rb

@@ -28,10 +28,6 @@ module Droonga
       @raw_message
     end
 
-    def add_route(route)
-      @raw_message["via"].push(route)
-    end
-
     def body
       @raw_message["body"]
     end
@@ -45,6 +41,10 @@ module Droonga
     end
 
     def command=(command)
+      original_command = @raw_message["type"]
+      return if original_command == command
+      @raw_message["originalTypes"] ||= []
+      @raw_message["originalTypes"] << original_command
       @raw_message["type"] = command
     end
   end

data/lib/droonga/legacy_pluggable.rb

@@ -0,0 +1,66 @@
+# Copyright (C) 2013-2014 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
+  module LegacyPluggable
+    class UnknownPlugin < StandardError
+      attr_reader :command
+
+      def initialize(command)
+        @command = command
+      end
+    end
+
+    def shutdown
+      $log.trace("#{log_tag}: shutdown: plugin: start")
+      @plugins.each do |plugin|
+        plugin.shutdown
+      end
+      $log.trace("#{log_tag}: shutdown: plugin: done")
+    end
+
+    def processable?(command)
+      not find_plugin(command).nil?
+    end
+
+    def process(command, *arguments)
+      plugin = find_plugin(command)
+      $log.trace("#{log_tag}: process: start: <#{command}>",
+                 :plugin => plugin.class)
+      raise UnknownPlugin.new(command) if plugin.nil?
+      result = plugin.process(command, *arguments)
+      $log.trace("#{log_tag}: process: done: <#{command}>",
+                 :plugin => plugin.class)
+      result
+    end
+
+    private
+    def load_plugins(names)
+      @plugins = names.collect do |name|
+        plugin = instantiate_plugin(name)
+        if plugin.nil?
+          raise "unknown plugin: <#{name}>: TODO: improve error handling"
+        end
+        plugin
+      end
+    end
+
+    def find_plugin(command)
+      @plugins.find do |plugin|
+        plugin.processable?(command)
+      end
+    end
+  end
+end

data/lib/droonga/{input_adapter.rb → legacy_plugin.rb}

@@ -15,38 +15,43 @@
 # 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"
+require "droonga/plugin_registerable"
 
 module Droonga
-  class InputAdapter
-    include Pluggable
+  class LegacyPlugin
+    def initialize
+    end
 
-    def initialize(dispatcher, options={})
-      @dispatcher = dispatcher
-      load_plugins(options[:plugins] || [])
+    def start
     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
+    def shutdown
+    end
+
+    def processable?(command)
+      self.class.processable?(command)
+    end
+
+    def process(command, *arguments)
+      run_command(command, *arguments)
+    rescue => exception
+      process_error(command, exception, arguments)
     end
 
     private
-    def instantiate_plugin(name)
-      InputAdapterPlugin.repository.instantiate(name, @dispatcher)
+    def run_command(command, *arguments)
+      if command.is_a?(Command)
+        method_name = command.method_name
+      else
+        method_name = self.class.method_name(command)
+      end
+      __send__(method_name, *arguments)
     end
 
-    def log_tag
-      "input-adapter"
+    def process_error(command, error, arguments)
+      Logger.error("error while processing: <#{command}>",
+                   error,
+                   :arguments => arguments)
     end
   end
 end