fluent-plugin-droonga 0.9.0 → 0.9.9

data/lib/droonga/plugin/{distributor → planner}/watch.rb

@@ -15,30 +15,39 @@
 # 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/distributor_plugin"
+require "droonga/planner_plugin"
 
 module Droonga
-  class WatchDistributor < Droonga::DistributorPlugin
+  class WatchPlanner < Droonga::PlannerPlugin
     repository.register("watch", self)
 
     command "watch.feed" => :feed
     def feed(message)
-      broadcast_all(message)
+      broadcast(message)
     end
 
     command "watch.subscribe" => :subscribe
     def subscribe(message)
-      broadcast_all(message)
+      broadcast(message)
     end
 
     command "watch.unsubscribe" => :unsubscribe
     def unsubscribe(message)
-      broadcast_all(message)
+      broadcast(message)
     end
 
     command "watch.sweep" => :sweep
     def sweep(message)
-      broadcast_all(message)
+      broadcast(message)
+    end
+
+    private
+    def broadcast(message)
+      super(message,
+            :write => true,
+            :reduce => {
+              "success" => "and"
+            })
     end
   end
 end

data/lib/droonga/plugin_loader.rb

@@ -15,6 +15,8 @@
 # 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 "pathname"
+
 module Droonga
   class PluginLoader
     class << self
@@ -29,6 +31,13 @@ module Droonga
               loader.load
             end
           end
+
+          Pathname.glob("#{load_path}/droonga/plugins/*.rb") do |plugin_path|
+            relative_plugin_path =
+              plugin_path.relative_path_from(Pathname(load_path))
+            require_path = relative_plugin_path.to_s.gsub(/\.rb\z/, "")
+            require require_path
+          end
         end
       end
     end
@@ -39,6 +48,7 @@ module Droonga
     end
 
     def load
+      return if @type == "metadata"
       require "droonga/plugin/#{@type}/#{@name}"
     end
   end

data/lib/droonga/plugin_registerable.rb

@@ -15,15 +15,17 @@
 # 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/command_mapper"
-require "droonga/plugin_repository"
+require "droonga/command"
+require "droonga/command_repository"
+require "droonga/legacy_plugin_repository"
 
 module Droonga
   module PluginRegisterable
     class << self
       def extended(plugin_class)
         super
-        plugin_class.class_variable_set(:@@repository, PluginRepository.new)
+        plugin_class.class_variable_set(:@@repository,
+                                        LegacyPluginRepository.new)
       end
     end
 
@@ -33,19 +35,41 @@ module Droonga
 
     def inherited(sub_class)
       super
-      sub_class.instance_variable_set(:@command_mapper, CommandMapper.new)
+      sub_class.instance_variable_set(:@command_repository,
+                                      CommandRepository.new)
     end
 
-    def command(name_or_map)
-      @command_mapper.register(name_or_map)
+    def command(method_name_or_map, options={})
+      if method_name_or_map.is_a?(Hash)
+        type, method_name = method_name_or_map.to_a.first
+        options[:pattern] ||= ["type", :equal, type.to_s]
+      else
+        method_name = method_name_or_map
+        options[:pattern] ||= ["type", :equal, method_name.to_s]
+      end
+      command = Command.new(method_name, options)
+      @command_repository.register(command)
+    end
+
+    def commands
+      @command_repository.commands
+    end
+
+    def find_command(message)
+      @command_repository.find(message)
     end
 
-    def method_name(command)
-      @command_mapper[command]
+    def method_name(message)
+      message = {"type" => message.to_s} unless message.is_a?(Hash)
+      command = find_command(message)
+      return nil if command.nil?
+      command.method_name
     end
 
-    def processable?(command)
-      not method_name(command).nil?
+    def processable?(message)
+      message = {"type" => message.to_s} unless message.is_a?(Hash)
+      command = find_command(message)
+      not command.nil?
     end
   end
 end

data/lib/droonga/plugin_registry.rb

@@ -0,0 +1,58 @@
+# 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
+  class PluginRegistry
+    include Enumerable
+
+    def initialize
+      @plugins = {}
+    end
+
+    def each(&block)
+      @plugins.each(&block)
+    end
+
+    def register(name, plugin_module)
+      @plugins[name] = plugin_module
+    end
+
+    def [](name)
+      @plugins[name]
+    end
+
+    def clear
+      @plugins.clear
+    end
+
+    def find_sub_classes(name, klass)
+      plugin_module = self[name]
+      return [] if plugin_module.nil?
+      sub_classes = []
+      collect_sub_classes_recursive(plugin_module, klass, sub_classes)
+      sub_classes
+    end
+
+    private
+    def collect_sub_classes_recursive(base, klass, sub_classes)
+      base.constants.each do |constant_name|
+        constant = base.const_get(constant_name)
+        next unless constant.is_a?(Module)
+        sub_classes << constant if constant < klass
+        collect_sub_classes_recursive(constant, klass, sub_classes)
+      end
+    end
+  end
+end

data/lib/droonga/plugins/crud.rb

@@ -0,0 +1,124 @@
+# 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/plugin"
+require "droonga/message_processing_error"
+
+module Droonga
+  module Plugins
+    module CRUD
+      Plugin.registry.register("crud", self)
+
+      class Adapter < Droonga::Adapter
+        message.input_pattern  = ["type", :equal, "add"]
+        message.output_pattern = ["body.success", :exist?]
+
+        def adapt_output(output_message)
+          success = output_message.body["success"]
+          unless success.nil?
+            output_message.body = output_message.body["success"]
+          end
+        end
+      end
+
+      class Handler < Droonga::Handler
+        message.type = "add"
+
+        class MissingTableParameter < BadRequest
+          def initialize
+            super("\"table\" must be specified.")
+          end
+        end
+
+        class MissingPrimaryKeyParameter < BadRequest
+          def initialize(table_name)
+            super("\"key\" must be specified. " +
+                    "The table #{table_name.inspect} requires a primary key for a new record.")
+          end
+        end
+
+        class UnknownTable < NotFound
+          def initialize(table_name)
+            super("The table #{table_name.inspect} does not exist in the dataset.")
+          end
+        end
+
+        class InvalidValue < BadRequest
+          def initialize(column, value, request)
+            super("The column #{column.inspect} cannot store the value #{value.inspect}.",
+                  request)
+          end
+        end
+
+        class UnknownColumn < NotFound
+          def initialize(column, table, request)
+            super("The column #{column.inspect} does not exist in the table #{table.inspect}.",
+                  request)
+          end
+        end
+
+        def handle(message, messenger)
+          succeeded = process_add(message.request)
+          outputs = {
+            "success" => succeeded,
+          }
+          messenger.emit(outputs)
+        end
+
+        private
+        def process_add(request)
+          raise MissingTableParameter.new unless request.include?("table")
+
+          table = @context[request["table"]]
+          raise UnknownTable.new(request["table"]) unless table
+
+          if table.support_key?
+            unless request.include?("key")
+              raise MissingPrimaryKeyParameter.new(request["table"])
+            end
+          end
+
+          add_record(table, request)
+          true
+        end
+
+        def add_record(table, request)
+          record = nil
+          if table.support_key?
+            record = table.add(request["key"])
+          else
+            record = table.add
+          end
+          (request["values"] || []).each do |column, value|
+            begin
+              record[column] = value
+            rescue ::Groonga::InvalidArgument => error
+              record.delete if record.added?
+              raise InvalidValue.new(column, value, request)
+            rescue ArgumentError => error
+              record.delete if record.added?
+              raise InvalidValue.new(column, value, request)
+            rescue ::Groonga::NoSuchColumn => error
+              record.delete if record.added?
+              raise UnknownColumn.new(column, request["table"], request)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/droonga/plugins/error.rb

@@ -0,0 +1,50 @@
+# 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
+
+require "droonga/plugin"
+
+module Droonga
+  module Plugins
+    module Error
+      Plugin.registry.register("error", self)
+
+      class Adapter < Droonga::Adapter
+        message.output_pattern = ["body.errors", :exist?]
+
+        def adapt_output(output_message)
+          errors = output_message.body["errors"]
+          if errors && !errors.empty?
+            output_message.errors = errors
+
+            status_codes = []
+            errors.values.each do |error|
+              status_codes << error["statusCode"]
+            end
+            status_codes = status_codes.uniq
+            if status_codes.size == 1
+              output_message.status_code = status_codes.first
+            else
+              output_message.status_code = MessageProcessingError::STATUS_CODE
+            end
+
+            output_message.body = errors.values.first["body"]
+          else
+            output_message.body.delete("errors")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/droonga/{output_adapter_plugin.rb → plugins/groonga.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,18 +14,16 @@
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 require "droonga/plugin"
+require "droonga/plugins/groonga/generic_response"
+require "droonga/plugins/groonga/select"
+require "droonga/plugins/groonga/table_create"
+require "droonga/plugins/groonga/table_remove"
+require "droonga/plugins/groonga/column_create"
 
 module Droonga
-  class OutputAdapterPlugin < Plugin
-    extend PluginRegisterable
-
-    def initialize(dispatcher)
-      super()
-      @dispatcher = dispatcher
-    end
-
-    def forward(message, destination)
-      @dispatcher.forward(message, destination)
+  module Plugins
+    module Groonga
+      Plugin.registry.register("groonga", self)
     end
   end
 end

data/lib/droonga/plugins/groonga/column_create.rb

@@ -0,0 +1,123 @@
+# 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/command/column-create"
+
+require "droonga/plugin"
+require "droonga/plugins/groonga/generic_command"
+
+module Droonga
+  module Plugins
+    module Groonga
+      module ColumnCreate
+        class Command < GenericCommand
+          def process_request(request)
+            command_class = ::Groonga::Command.find("column_create")
+            @command = command_class.new("column_create", request)
+
+            table_name = @command["table"]
+            if table_name.nil? || @context[table_name].nil?
+              message = "table doesn't exist: <#{table_name.to_s}>"
+              raise CommandError.new(:status => Status::INVALID_ARGUMENT,
+                                     :message => message,
+                                     :result => false)
+            end
+
+            if @command.column_index?
+              define_index
+            else
+              define_column
+            end
+          end
+
+          private
+          def define_column
+            table_name = @command["table"]
+            column_name = @command["name"]
+            column_type = @command["type"]
+
+            options = create_column_options
+            ::Groonga::Schema.define(:context => @context) do |schema|
+              schema.change_table(table_name) do |table|
+                table.column(column_name, column_type, options)
+              end
+            end
+            true
+          end
+
+          def create_column_options
+            options = {}
+            create_column_options_flags(options)
+            options
+          end
+
+          def create_column_options_flags(options)
+            options[:type] = :scalar
+            if @command.column_scalar?
+              options[:type] = :scalar
+            elsif @command.column_vector?
+              options[:type] = :vector
+            end
+            options
+          end
+
+          def define_index
+            table_name = @command["table"]
+            target_table = @command["type"]
+            target_columns = (@command["source"] || "").split(/\s*,\s*/)
+
+            options = create_index_options
+            ::Groonga::Schema.define(:context => @context) do |schema|
+              schema.change_table(table_name) do |table|
+                arguments = [target_table, *target_columns]
+                arguments << options
+                table.index(*arguments)
+              end
+            end
+            true
+          end
+
+          def create_index_options
+            options = {}
+            create_index_options_name(options)
+            create_index_options_flags(options)
+            options
+          end
+
+          def create_index_options_name(options)
+            options[:name] = @command["name"]
+          end
+
+          def create_index_options_flags(options)
+            options[:with_section] = true if @command.with_section?
+            options[:with_weight] = true if @command.with_weight?
+            options[:with_position] = true if @command.with_position?
+          end
+        end
+
+        class Handler < Droonga::Handler
+          message.type = "column_create"
+          action.synchronous = true
+
+          def handle(message, messenger)
+            command = Command.new(@context)
+            outputs = command.execute(message.request)
+            messenger.emit(outputs)
+          end
+        end
+      end
+    end
+  end
+end