fluent-plugin-droonga 0.9.0 → 0.9.9

data/lib/droonga/{plugin_repository.rb → legacy_plugin_repository.rb}

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-#
-# 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
@@ -16,7 +14,7 @@
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 module Droonga
-  class PluginRepository
+  class LegacyPluginRepository
     include Enumerable
 
     def initialize

data/lib/droonga/message_matcher.rb

@@ -0,0 +1,101 @@
+# 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
+# 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
+  # It checks whether the pattern matches against a message.
+  #
+  # It provides the small language. Here is the pattern syntax.
+  #
+  #   * PATTERN = [TARGET_PATH, OPERATOR, ARGUMENTS*]
+  #   * PATTERN = [PATTERN, LOGICAL_OPERATOR, PATTERN]
+  #   * TARGET_PATH = "COMPONENT(.COMPONENT)*"
+  #   * OPERATOR = :equal, :in, :include?, :exist?
+  #                (More operators may be added in the future.
+  #                 For example, :start_with and so on.)
+  #   * ARGUMENTS = OBJECT_DEFINED_IN_JSON*
+  #   * LOGICAL_OPERATOR = :or (:add will be added.)
+  #
+  # For example:
+  #
+  # ```
+  # ["type", :equal, "search"]
+  # ```
+  #
+  # matches to the following message:
+  #
+  # ```
+  # {"type" => "search"}
+  # ```
+  #
+  # Another example:
+  #
+  # ```
+  # ["body.output.limit", :equal, 10]
+  # ```
+  #
+  # matches to the following message:
+  #
+  # ```
+  # {
+  #   "body" => {
+  #     "output" => {
+  #       "limit" => 10,
+  #     },
+  #   },
+  # }
+  # ```
+  class MessageMatcher
+    # @param [Array] pattern The pattern to be matched against a message.
+    def initialize(pattern)
+      @pattern = pattern
+    end
+
+    def match?(message)
+      return false if @pattern.nil?
+      path, operator, *arguments = @pattern
+      target = resolve_path(path, message)
+      apply_operator(operator, target, arguments)
+    end
+
+    private
+    NONEXISTENT_PATH = Object.new
+    def resolve_path(path, message)
+      path.split(".").inject(message) do |result, component|
+        return NONEXISTENT_PATH unless result.is_a?(Hash)
+        result[component]
+      end
+    end
+
+    def apply_operator(operator, target, arguments)
+      case operator
+      when :equal
+        [target] == arguments
+      when :in
+        arguments.any? do |argument|
+          argument.include?(target)
+        end
+      when :include?
+        return false unless target.respond_to?(:include?)
+        arguments.any? do |argument|
+          target.include?(argument)
+        end
+      when :exist?
+        target != NONEXISTENT_PATH
+      else
+        raise ArgumentError, "Unknown operator"
+      end
+    end
+  end
+end

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

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-#
-# 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
@@ -15,19 +13,25 @@
 # 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_pluggable"
+require "droonga/planner_plugin"
 
 module Droonga
-  class InputAdapterPlugin < Plugin
-    extend PluginRegisterable
+  class Planner
+    include LegacyPluggable
 
-    def initialize(dispatcher)
-      super()
+    def initialize(dispatcher, plugins)
       @dispatcher = dispatcher
+      load_plugins(plugins)
+    end
+
+    private
+    def instantiate_plugin(name)
+      PlannerPlugin.repository.instantiate(name, self)
     end
 
-    def forward(message, destination)
-      @dispatcher.forward(message, destination)
+    def log_tag
+      "[#{Process.pid}] planner"
     end
   end
 end

data/lib/droonga/planner_plugin.rb

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+#
+# 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 "droonga/legacy_plugin"
+require "droonga/distributed_command_planner"
+
+module Droonga
+  class PlannerPlugin < LegacyPlugin
+    extend PluginRegisterable
+
+    def initialize(planner)
+      super()
+      @planner = planner
+    end
+
+    def scatter(message, options={})
+      planner = DistributedCommandPlanner.new(message)
+      planner.scatter
+      planner.key = options[:key]
+      planner.reduce(options[:reduce])
+      planner.plan
+    end
+
+    def broadcast(message, options={})
+      planner = DistributedCommandPlanner.new(message)
+      planner.broadcast(:write => options[:write])
+      planner.reduce(options[:reduce])
+      planner.plan
+    end
+
+    private
+    def process_error(command, error, arguments)
+      if error.is_a?(MessageProcessingError)
+        raise error
+      else
+        super
+      end
+    end
+  end
+end

data/lib/droonga/pluggable.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
@@ -17,51 +15,17 @@
 
 module Droonga
   module Pluggable
-    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?
-      plugin.process(command, *arguments)
-      $log.trace("#{log_tag}: process: done: <#{command}>",
-                 :plugin => plugin.class)
-    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
+    def options
+      @options ||= {}
     end
 
-    def find_plugin(command)
-      @plugins.find do |plugin|
-        plugin.processable?(command)
+    def find_sub_classes(names)
+      target_sub_classes = []
+      names.each do |name|
+        sub_classes = Plugin.registry.find_sub_classes(name, self)
+        target_sub_classes.concat(sub_classes)
       end
+      target_sub_classes
     end
   end
 end

data/lib/droonga/plugin.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,38 +13,16 @@
 # 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_registerable"
+require "droonga/plugin_registry"
+require "droonga/adapter"
+require "droonga/handler"
 
 module Droonga
-  class Plugin
-    def initialize
-    end
-
-    def start
-    end
-
-    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 run_command(command, *arguments)
-      __send__(self.class.method_name(command), *arguments)
-    end
-
-    def process_error(command, error, arguments)
-      Logger.error("error while processing #{command}",
-                   error,
-                   :arguments => arguments)
+  module Plugin
+    class << self
+      def registry
+        @@registry ||= PluginRegistry.new
+      end
     end
   end
 end

data/lib/droonga/plugin/collector/basic.rb

@@ -52,6 +52,8 @@ module Droonga
       case deal["type"]
       when "and"
         reduced_value = left_value && right_value
+      when "or"
+        reduced_value = left_value || right_value
       when "sum"
         reduced_value = sum(left_value, right_value)
         reduced_value = apply_output_range(reduced_value,

data/lib/droonga/plugin/collector/search.rb

@@ -27,32 +27,24 @@ module Droonga
       if output.is_a?(Hash)
         elements = output["elements"]
         if elements && elements.is_a?(Hash)
-          # phase 1: pre-process
-          elements.each do |element, mapper|
-            case mapper["type"]
-            when "count"
-              result[element] = result[mapper["target"]].size
-            when "sort"
-              # do nothing on this phase!
+          # because "count" mapper requires all records,
+          # I have to apply it at first, before "limit" and "offset" are applied.
+          count_mapper = elements["count"]
+          if count_mapper
+            if count_mapper["no_output"]
+              result.delete("count")
+            else
+              result["count"] = result[count_mapper["target"]].size
             end
           end
-          # phase 2: post-process
-          elements.each do |element, mapper|
-            if mapper["no_output"]
-              result.delete(element)
-              next
-            end
 
-            case mapper["type"]
-            when "count"
-              # do nothing on this phase!
-            when "sort"
-              # because "count" type mapper requires all items of the array,
-              # I have to apply "sort" type mapper later.
-              if result[element]
-                result[element] = apply_output_range(result[element], mapper)
-                result[element] = apply_output_attributes_and_format(result[element], mapper)
-              end
+          records_mapper = elements["records"]
+          if records_mapper && result["records"]
+            if records_mapper["no_output"]
+              result.delete("records")
+            else
+              result["records"] = apply_output_range(result["records"], records_mapper)
+              result["records"] = apply_output_attributes_and_format(result["records"], records_mapper)
             end
           end
         end
@@ -62,21 +54,18 @@ module Droonga
     end
 
     def apply_output_attributes_and_format(items, output)
-      attributes = output["attributes"]
-      if attributes
-        format = output["format"]
-        if format == "complex"
-          items.collect! do |item|
-            complex_item = {}
-            attributes.each_with_index do |label, index|
-              complex_item[label] = item[index]
-            end
-            complex_item
-          end
-        else
-          items.collect! do |item|
-            item[0...attributes.size]
+      attributes = output["attributes"] || []
+      if output["format"] == "complex"
+        items.collect! do |item|
+          complex_item = {}
+          attributes.each_with_index do |label, index|
+            complex_item[label] = item[index]
           end
+          complex_item
+        end
+      else
+        items.collect! do |item|
+          item[0...attributes.size]
         end
       end
       items
@@ -84,6 +73,11 @@ module Droonga
 
     command :collector_search_reduce
     def collector_search_reduce(request)
+      #XXX This is just a workaround. Errors should be handled by the framework itself.
+      if input_name == "errors"
+        return collector_reduce(request)
+      end
+
       return unless request
       body[input_name].each do |output, elements|
         value = request

data/lib/droonga/plugin/{handler/groonga/table_remove.rb → metadata/adapter_message.rb}

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-#
 # Copyright (C) 2014 Droonga Project
 #
 # This library is free software; you can redistribute it and/or
@@ -15,27 +13,34 @@
 # 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 "groonga/command/table-remove"
-
 module Droonga
-  class GroongaHandler
-    class TableRemove < Command
-      def process_request(request)
-        command_class = Groonga::Command.find("table_remove")
-        @command = command_class.new("table_remove", request)
+  module Plugin
+    module Metadata
+      class AdapterMessage
+        def initialize(adapter_class)
+          @adapter_class = adapter_class
+        end
+
+        def input_pattern
+          configuration[:input_pattern]
+        end
+
+        def input_pattern=(pattern)
+          configuration[:input_pattern] = pattern
+        end
+
+        def output_pattern
+          configuration[:output_pattern]
+        end
 
-        name = @command["name"]
-        if name.nil? || @context[name].nil?
-          raise CommandError.new(:status => Status::INVALID_ARGUMENT,
-                                 :message => "table not found",
-                                 :result => false)
+        def output_pattern=(pattern)
+          configuration[:output_pattern] = pattern
         end
 
-        Groonga::Schema.define(:context => @context) do |schema|
-          schema.remove_table(name)
+        private
+        def configuration
+          @adapter_class.options[:message] ||= {}
         end
-        true
       end
     end
   end