fluent-plugin-droonga 0.9.0 → 0.9.9

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

@@ -0,0 +1,65 @@
+# 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"
+
+module Droonga
+  module Plugins
+    module Groonga
+      module Status
+        SUCCESS          = 0
+        INVALID_ARGUMENT = -22
+      end
+
+      class GenericCommand
+        class CommandError < StandardError
+          attr_reader :status, :message, :result
+
+          def initialize(params={})
+            @status = params[:status]
+            @message = params[:message]
+            @result = params[:result]
+          end
+        end
+
+        def initialize(context)
+          @context = context
+        end
+
+        def execute(request)
+          @start_time = Time.now.to_f
+          result = process_request(request)
+          format(header(Status::SUCCESS), result)
+        rescue CommandError => error
+          format(header(error.status, error.message), error.result)
+        end
+
+        private
+        def header(return_code, error_message="")
+          elapsed_time = Time.now.to_f - @start_time
+          header = [return_code, @start_time, elapsed_time]
+          header.push(error_message) unless error_message.empty?
+          header
+        end
+
+        def format(header, body)
+          {
+            "result" => [header, body],
+          }
+        end
+      end
+    end
+  end
+end

data/lib/droonga/{plugin/output_adapter/groonga.rb → plugins/groonga/generic_response.rb}

@@ -13,25 +13,26 @@
 # 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/output_adapter_plugin"
+require "droonga/plugin"
 
 module Droonga
-  class GroongaOutputAdapter < Droonga::OutputAdapterPlugin
-    repository.register("groonga", self)
+  module Plugins
+    module Groonga
+      module Generic
+        class Adapter < Droonga::Adapter
+          groonga_commands = [
+            "table_create",
+            "table_remove",
+            "column_create",
+          ]
+          message.input_pattern  = ["type", :in, groonga_commands]
+          message.output_pattern = ["body.result", :exist?]
 
-    command :select_response
-    def select_response(output_message)
-      command = Select.new
-      output_message.body = command.convert(output_message.body)
-    end
-
-    command :groonga_generic_response
-    def groonga_generic_response(output_message)
-      if output_message.body.include?("result")
-        output_message.body = output_message.body["result"]
+          def adapt_output(output_message)
+            output_message.body = output_message.body["result"]
+          end
+        end
       end
     end
   end
 end
-
-require "droonga/plugin/output_adapter/groonga/select"

data/lib/droonga/plugins/groonga/select.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 "droonga/plugin"
+
+module Droonga
+  module Plugins
+    module Groonga
+      module Select
+        class RequestConverter
+          def convert(select_request)
+            table = select_request["table"]
+            result_name = table + "_result"
+            match_columns = select_request["match_columns"]
+            match_to = match_columns ? match_columns.split(/ *\|\| */) : []
+            query = select_request["query"]
+            output_columns = select_request["output_columns"] || ""
+            attributes = output_columns.split(/, */)
+            offset = (select_request["offset"] || "0").to_i
+            limit = (select_request["limit"] || "10").to_i
+
+            search_request = {
+              "queries" => {
+                result_name => {
+                  "source" => table,
+                  "output" => {
+                    "elements"   => [
+                      "startTime",
+                      "elapsedTime",
+                      "count",
+                      "attributes",
+                      "records",
+                    ],
+                    "attributes" => attributes,
+                    "offset" => offset,
+                    "limit" => limit,
+                  },
+                }
+              }
+            }
+            if query
+              condition = {
+                "query"  => query,
+                "matchTo"=> match_to,
+                "defaultOperator"=> "&&",
+                "allowPragma"=> false,
+                "allowColumn"=> true,
+              }
+              search_request["queries"][result_name]["condition"] = condition
+            end
+            search_request
+          end
+        end
+
+        class ResponseConverter
+          def convert(search_response)
+            select_responses = search_response.collect do |key, value|
+              status_code = 0
+
+              start_time = value["startTime"]
+              start_time_in_unix_time = if start_time
+                                          Time.parse(start_time).to_f
+                                        else
+                                          Time.now.to_f
+                                        end
+              elapsed_time = value["elapsedTime"] || 0
+              count = value["count"]
+
+              attributes = value["attributes"] || []
+              converted_attributes = attributes.collect do |attribute|
+                name = attribute["name"]
+                type = attribute["type"]
+                [name, type]
+              end
+
+              header = [status_code, start_time_in_unix_time, elapsed_time]
+              records = value["records"]
+              if records.empty?
+                results = [[count], converted_attributes]
+              else
+                results = [[count], converted_attributes, records]
+              end
+              body = [results]
+
+              [header, body]
+            end
+            select_responses.first
+          end
+        end
+
+        class Adapter < Droonga::Adapter
+          message.input_pattern = ["type", :equal, "select"]
+
+          def adapt_input(input_message)
+            converter = RequestConverter.new
+            select_request = input_message.body
+            search_request = converter.convert(select_request)
+            input_message.command = "search"
+            input_message.body = search_request
+          end
+
+          def adapt_output(output_message)
+            converter = ResponseConverter.new
+            search_response = output_message.body
+            select_response = converter.convert(search_response)
+            output_message.body = select_response
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# 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/table-create"
+
+require "droonga/plugin"
+require "droonga/plugins/groonga/generic_command"
+
+module Droonga
+  module Plugins
+    module Groonga
+      module TableCreate
+        class Command < GenericCommand
+          def process_request(request)
+            command_class = ::Groonga::Command.find("table_create")
+            @command = command_class.new("table_create", request)
+
+            name = @command["name"]
+            unless name
+              message = "Should not create anonymous table"
+              raise CommandError.new(:status => Status::INVALID_ARGUMENT,
+                                     :message => message,
+                                     :result => false)
+            end
+
+            options = parse_command
+            ::Groonga::Schema.define(:context => @context) do |schema|
+              schema.create_table(name, options)
+            end
+            true
+          end
+
+          private
+          def parse_command
+            options = {}
+            parse_flags(options)
+            parse_key_type(options)
+            parse_value_type(options)
+            parse_default_tokenizer(options)
+            parse_normalizer(options)
+            options
+          end
+
+          def parse_flags(options)
+            options[:type] = :hash
+            if @command.table_no_key?
+              options[:type] = :array
+            elsif @command.table_hash_key?
+              options[:type] = :hash
+            elsif @command.table_pat_key?
+              options[:type] = :patricia_trie
+            elsif @command.table_dat_key?
+              options[:type] = :double_array_trie
+            end
+            if @command.key_with_sis? and @command.table_pat_key?
+              options[:key_with_sis] = true
+            end
+          end
+
+          def parse_key_type(options)
+            return unless @command["key_type"]
+            options[:key_type] = @command["key_type"]
+          end
+
+          def parse_value_type(options)
+            return unless @command["value_type"]
+            options[:value_type] = @command["value_type"]
+          end
+
+          def parse_default_tokenizer(options)
+            return unless @command["default_tokenizer"]
+            options[:default_tokenizer] = @command["default_tokenizer"]
+          end
+
+          def parse_normalizer(options)
+            return unless @command["normalizer"]
+            options[:normalizer] = @command["normalizer"]
+          end
+        end
+
+        class Handler < Droonga::Handler
+          message.type = "table_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

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

@@ -0,0 +1,57 @@
+# 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 "groonga/command/table-remove"
+
+require "droonga/plugin"
+require "droonga/plugins/groonga/generic_command"
+
+module Droonga
+  module Plugins
+    module Groonga
+      module TableRemove
+        class Command < GenericCommand
+          def process_request(request)
+            command_class = ::Groonga::Command.find("table_remove")
+            @command = command_class.new("table_remove", request)
+
+            name = @command["name"]
+            if name.nil? || @context[name].nil?
+              raise CommandError.new(:status => Status::INVALID_ARGUMENT,
+                                     :message => "table not found",
+                                     :result => false)
+            end
+
+            ::Groonga::Schema.define(:context => @context) do |schema|
+              schema.remove_table(name)
+            end
+            true
+          end
+        end
+
+        class Handler < Droonga::Handler
+          message.type = "table_remove"
+          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

data/lib/droonga/plugins/search.rb

@@ -0,0 +1,40 @@
+# 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/plugin"
+require "droonga/searcher"
+
+module Droonga
+  module Plugins
+    module Search
+      Plugin.registry.register("search", self)
+
+      class Handler < Droonga::Handler
+        message.type = "search"
+
+        def handle(message, messenger)
+          searcher = Droonga::Searcher.new(@context)
+          values = {}
+          request = message.request
+          raise Droonga::Searcher::NoQuery.new unless request
+          searcher.search(request["queries"]).each do |output, value|
+            values[output] = value
+          end
+          messenger.emit(values)
+        end
+      end
+    end
+  end
+end

data/lib/droonga/plugins/watch.rb

@@ -0,0 +1,156 @@
+# 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/plugin"
+require "droonga/watcher"
+require "droonga/sweeper"
+require "droonga/watch_schema"
+
+module Droonga
+  module Plugins
+    module Watch
+      Plugin.registry.register("watch", self)
+
+      module SchemaCreatable
+        private
+        def ensure_schema_created
+          # XXX just workaround. This must be re-written.
+          # When secondary and later processes opens the database,
+          # creation processes of tables by the first process is
+          # not finished yet. Then secondary and others tries to
+          # create tables and raises errors. To avoid such a problem,
+          # the creation processes of tables is disabled on workers.
+          if $0 !~ /\AServer/
+            schema = WatchSchema.new(@context)
+            schema.ensure_created
+          else
+            until @context["Keyword"]
+              sleep 0.1
+            end
+            sleep 1
+          end
+        end
+      end
+
+      module MessageParsable
+        private
+        def parse_message(message)
+          request = message.request
+          subscriber = request["subscriber"]
+          condition = request["condition"]
+          route = request["route"] || message["from"]
+          query = condition && condition.to_json
+          [subscriber, condition, query, route]
+        end
+      end
+
+      class SubscribeHandler < Droonga::Handler
+        include SchemaCreatable
+        include MessageParsable
+
+        message.type = "watch.subscribe"
+
+        def initialize(*args)
+          super
+          ensure_schema_created # TODO: REMOVE ME
+        end
+
+        def handle(message, messenger)
+          subscriber, condition, query, route = parse_message(message)
+          normalized_request = {
+            :subscriber => subscriber,
+            :condition  => condition,
+            :query      => query,
+            :route      => route,
+          }
+          watcher = Watcher.new(@context)
+          watcher.subscribe(normalized_request)
+          outputs = {
+            "success" => true,
+          }
+          messenger.emit(outputs)
+        end
+      end
+
+      class UnsubscribeHandler < Droonga::Handler
+        include SchemaCreatable
+        include MessageParsable
+
+        message.type = "watch.unsubscribe"
+
+        def initialize(*args)
+          super
+          ensure_schema_created # TODO: REMOVE ME
+        end
+
+        def handle(message, messenger)
+          subscriber, condition, query, route = parse_message(message)
+          normalized_request = {
+            :subscriber => subscriber,
+            :condition  => condition,
+            :query      => query,
+          }
+          watcher = Watcher.new(@context)
+          watcher.unsubscribe(normalized_request)
+          outputs = {
+            "success" => true,
+          }
+          messenger.emit(outputs)
+        end
+      end
+
+      class FeedHandler < Droonga::Handler
+        include SchemaCreatable
+
+        message.type = "watch.feed"
+
+        def initialize(*args)
+          super
+          ensure_schema_created # TODO: REMOVE ME
+        end
+
+        def handle(message, messenger)
+          request = message.request
+          watcher = Watcher.new(@context)
+          watcher.feed(:targets => request["targets"]) do |route, subscribers|
+            published_message = {
+              "to"   => subscribers,
+              "body" => request,
+            }
+            published_message = message.raw.merge(published_message)
+            messenger.forward(published_message,
+                              "to" => route, "type" => "watch.publish")
+          end
+        end
+      end
+
+      class SweepHandler < Droonga::Handler
+        include SchemaCreatable
+
+        message.type = "watch.sweep"
+
+        def initialize(*args)
+          super
+          ensure_schema_created # TODO: REMOVE ME
+        end
+
+        def sweep(message, messenger)
+          sweeper = Sweeper.new(@context)
+          sweeper.sweep_expired_subscribers
+        end
+      end
+    end
+  end
+end