fluent-plugin-droonga 0.9.9 → 1.0.0

data/lib/droonga/processor.rb

@@ -13,10 +13,13 @@
 # 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/loggable"
 require "droonga/handler_runner"
 
 module Droonga
   class Processor
+    include Loggable
+
     def initialize(loop, message_pusher, options={})
       @loop = loop
       @message_pusher = message_pusher
@@ -30,26 +33,26 @@ module Droonga
     end
 
     def shutdown
-      $log.trace("#{log_tag}: shutdown: start")
+      logger.trace("shutdown: start")
       @handler_runner.shutdown
-      $log.trace("#{log_tag}: shutdown: done")
+      logger.trace("shutdown: done")
     end
 
     def process(message)
-      $log.trace("#{log_tag}: process: start")
-      command = message["type"]
-      if @handler_runner.processable?(command)
-        $log.trace("#{log_tag}: process: handlable: #{command}")
-        synchronous = @handler_runner.prefer_synchronous?(command)
+      logger.trace("process: start")
+      type = message["type"]
+      if @handler_runner.processable?(type)
+        logger.trace("process: handlable: #{type}")
+        synchronous = @handler_runner.prefer_synchronous?(type)
         if @n_workers.zero? or synchronous
           @handler_runner.process(message)
         else
           @message_pusher.push(message)
         end
       else
-        $log.trace("#{log_tag}: process: ignore #{command}")
+        logger.trace("process: ignore #{type}")
       end
-      $log.trace("#{log_tag}: process: done")
+      logger.trace("process: done")
     end
 
     private

data/lib/droonga/{plugin/collector/basic.rb → reducer.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,82 +13,70 @@
 # 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/collector_plugin"
-
 module Droonga
-  class BasicCollector < Droonga::CollectorPlugin
-    repository.register("basic", self)
-
-    UNLIMITED = -1
+  class Reducer
+    class << self
+      # TODO: This is right location?
+      def apply_range(items, range)
+        if items and items.is_a?(Array)
+          offset = range["offset"] || 0
+          unless offset.zero?
+            items = items[offset..-1] || []
+          end
 
-    command :collector_gather
-    def collector_gather(result)
-      output = body ? body[input_name] : input_name
-      if output.is_a?(Hash)
-        output = output["output"]
+          limit = range["limit"] || 0
+          unless limit == UNLIMITED
+            items = items[0...limit]
+          end
+        end
+        items
       end
-      emit(output, result)
     end
 
-    command :collector_reduce
-    def collector_reduce(request)
-      body[input_name].each do |output, deal|
-        left_value = output_values[output]
-        right_value = request
-        value = reduce(deal, left_value, right_value)
-        emit(output, value)
-      end
+    # XXX: We has ULIMITED defined
+    # lib/droonga/plugins/search/distributed_search_planner.rb. We
+    # should unify it.
+    UNLIMITED = -1
+
+    def initialize(deal)
+      @deal = deal # TODO: deal is good name?
     end
 
-    def reduce(deal, left_value, right_value)
-      if left_value.nil? || right_value.nil?
+    def reduce(left_value, right_value)
+      if left_value.nil? or right_value.nil?
         return right_value || left_value
       end
 
       reduced_value = nil
 
-      case deal["type"]
+      case @deal["type"]
       when "and"
-        reduced_value = left_value && right_value
+        reduced_value = (left_value and right_value)
       when "or"
-        reduced_value = left_value || right_value
+        reduced_value = (left_value or right_value)
       when "sum"
         reduced_value = sum(left_value, right_value)
-        reduced_value = apply_output_range(reduced_value,
-                                           "limit" => deal["limit"])
+        reduced_value = self.class.apply_range(reduced_value,
+                                               "limit" => @deal["limit"])
       when "average"
         reduced_value = (left_value.to_f + right_value.to_f) / 2
       when "sort"
         reduced_value = merge(left_value,
                               right_value,
-                              :operators => deal["operators"],
-                              :key_column => deal["key_column"])
-        reduced_value = apply_output_range(reduced_value,
-                                           "limit" => deal["limit"])
+                              :operators => @deal["operators"],
+                              :key_column => @deal["key_column"])
+        reduced_value = self.class.apply_range(reduced_value,
+                                               "limit" => @deal["limit"])
       end
 
       reduced_value
     end
 
-    def apply_output_range(items, output)
-      if items && items.is_a?(Array)
-        offset = output["offset"] || 0
-        unless offset.zero?
-          items = items[offset..-1] || []
-        end
-
-        limit = output["limit"] || 0
-        unless limit == UNLIMITED
-          items = items[0...limit]
-        end
-      end
-      items
-    end
-
+    private
     def sum(x, y)
       return x || y if x.nil? or y.nil?
 
-      if x.is_a?(Hash) && y.is_a?(Hash)
+      if x.is_a?(Hash) and y.is_a?(Hash)
         x.merge(y)
       else
         x + y

data/lib/droonga/replier.rb

@@ -13,20 +13,23 @@
 # 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/loggable"
+require "droonga/status_code"
+
 module Droonga
   class Replier
-    STATUS_OK = 200
+    include Loggable
 
     def initialize(forwarder)
       @forwarder = forwarder
     end
 
     def reply(message)
-      $log.trace("#{log_tag}: reply: start")
+      logger.trace("reply: start")
       destination = message["replyTo"]
       reply_message = {
         "inReplyTo"  => message["id"],
-        "statusCode" => message["statusCode"] || STATUS_OK,
+        "statusCode" => message["statusCode"] || StatusCode::OK,
         "type"       => destination["type"],
         "body"       => message["body"],
       }
@@ -35,7 +38,7 @@ module Droonga
         reply_message["errors"] = errors unless errors.empty?
       end
       @forwarder.forward(reply_message, destination)
-      $log.trace("#{log_tag}: reply: done")
+      logger.trace("reply: done")
     end
 
     private

data/lib/droonga/searcher.rb

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-#
 # Copyright (C) 2013-2014 Droonga Project
 #
 # This library is free software; you can redistribute it and/or
@@ -19,34 +17,37 @@ require "English"
 require "tsort"
 require "groonga"
 
+require "droonga/loggable"
 require "droonga/time_formatter"
-require "droonga/message_processing_error"
+require "droonga/error_messages"
 
 module Droonga
   class Searcher
-    class NoQuery < BadRequest
+    include Loggable
+
+    class NoQuery < ErrorMessages::BadRequest
       def initialize
         super("You must specify one or more query.")
       end
     end
 
-    class MissingSourceParameter < BadRequest
+    class MissingSourceParameter < ErrorMessages::BadRequest
       def initialize(query, queries)
-        super("The query #{query.inspect} has no source. " +
+        super("[#{query}] No source is specified. " +
                 "Query must have a valid source.",
               queries)
       end
     end
 
-    class UnknownSource < NotFound
+    class UnknownSource < ErrorMessages::NotFound
       def initialize(source, queries)
-        super("The source #{source.inspect} does not exist. " +
+        super("Source not found: <#{source}> " +
                 "It must be a name of an existing table or another query.",
               queries)
       end
     end
 
-    class CyclicSource < BadRequest
+    class CyclicSource < ErrorMessages::BadRequest
       def initialize(queries)
         super("There is cyclic reference of sources.",
               queries)
@@ -59,40 +60,40 @@ module Droonga
 
     def search(queries)
       outputs = nil
-      $log.trace("#{log_tag}: search: start", :queries => queries)
+      logger.trace("search: start", :queries => queries)
       @context.push_memory_pool do
         outputs = process_queries(queries)
       end
-      $log.trace("#{log_tag}: search: done")
+      logger.trace("search: done")
       return outputs
     end
 
     private
     def process_queries(queries)
-      $log.trace("#{log_tag}: process_queries: start")
-      if queries.nil? || queries.empty?
+      logger.trace("process_queries: start")
+      if queries.nil? or queries.empty?
         raise NoQuery.new
       end
-      $log.trace("#{log_tag}: process_queries: sort: start")
+      logger.trace("process_queries: sort: start")
       sorted_queries = QuerySorter.sort(queries)
-      $log.trace("#{log_tag}: process_queries: sort: done")
+      logger.trace("process_queries: sort: done")
       outputs = {}
       results = {}
       sorted_queries.each do |name|
         if queries[name]
-          $log.trace("#{log_tag}: process_queries: search: start",
-                     :name => name)
+          logger.trace("process_queries: search: start",
+                       :name => name)
           search_request = SearchRequest.new(@context, queries[name], results)
           search_result = QuerySearcher.search(search_request)
           results[name] = search_result.records
-          $log.trace("#{log_tag}: process_queries: search: done",
-                     :name => name)
-          if search_request.need_output?
-            $log.trace("#{log_tag}: process_queries: format: start",
+          logger.trace("process_queries: search: done",
                        :name => name)
+          if search_request.need_output?
+            logger.trace("process_queries: format: start",
+                         :name => name)
             outputs[name] = ResultFormatter.format(search_request, search_result)
-            $log.trace("#{log_tag}: process_queries: format: done",
-                       :name => name)
+            logger.trace("process_queries: format: done",
+                         :name => name)
           end
         elsif @context[name]
           results[name] = @context[name]
@@ -100,7 +101,7 @@ module Droonga
           raise UnknownSource.new(name, queries)
         end
       end
-      $log.trace("#{log_tag}: process_queries: done")
+      logger.trace("process_queries: done")
       return outputs
     end
 
@@ -192,6 +193,8 @@ module Droonga
     end
 
     class QuerySearcher
+      include Loggable
+
       OPERATOR_CONVERSION_TABLE = {
         "||" => Groonga::Operator::OR,
         "&&" => Groonga::Operator::AND,
@@ -292,7 +295,7 @@ module Droonga
       end
 
       def search_query!
-        $log.trace("#{log_tag}: search_query: start")
+        logger.trace("search_query: start")
 
         @result.start_time = Time.now
 
@@ -309,7 +312,7 @@ module Droonga
         sort_by = @request.query["sortBy"]
         apply_sort_by!(sort_by) if sort_by
 
-        $log.trace("#{log_tag}: search_query: done")
+        logger.trace("search_query: done")
         @result.records = @records
         @result.end_time = Time.now
       end
@@ -318,16 +321,16 @@ module Droonga
         expression = Groonga::Expression.new(context: @request.context)
         expression.define_variable(:domain => @records)
         parse_condition(@records, expression, condition)
-        $log.trace("#{log_tag}: search_query: select: start",
-                   :condition => condition)
+        logger.trace("search_query: select: start",
+                     :condition => condition)
         @records = @records.select(expression)
-        $log.trace("#{log_tag}: search_query: select: done")
+        logger.trace("search_query: select: done")
         @result.condition = expression
       end
 
       def apply_group_by!(group_by)
-        $log.trace("#{log_tag}: search_query: group: start",
-                   :by => group_by)
+        logger.trace("search_query: group: start",
+                     :by => group_by)
         case group_by
         when String
           @records = @records.group(group_by)
@@ -338,13 +341,13 @@ module Droonga
         else
           raise '"groupBy" parameter must be a Hash or a String'
         end
-        $log.trace("#{log_tag}: search_query: group: done",
-                   :by => group_by)
+        logger.trace("search_query: group: done",
+                     :by => group_by)
       end
 
       def apply_sort_by!(sort_by)
-        $log.trace("#{log_tag}: search_query: sort: start",
-                   :by => sort_by)
+        logger.trace("search_query: sort: start",
+                     :by => sort_by)
         case sort_by
         when Array
           keys = parse_order_keys(sort_by)
@@ -358,8 +361,8 @@ module Droonga
           raise '"sortBy" parameter must be a Hash or an Array'
         end
         @records = @records.sort(keys, :offset => offset, :limit => limit)
-        $log.trace("#{log_tag}: search_query: sort: done",
-                   :by => sort_by)
+        logger.trace("search_query: sort: done",
+                     :by => sort_by)
       end
 
       def log_tag

data/lib/droonga/server.rb

@@ -15,22 +15,24 @@
 # 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/logger"
+
 module Droonga
   module Server
     def before_run
-      $log.trace("#{log_tag}: before_run: start")
-      $log.trace("#{log_tag}: before_run: done")
+      Droonga.logger.trace("#{log_tag}: before_run: start")
+      Droonga.logger.trace("#{log_tag}: before_run: done")
     end
 
     def after_run
-      $log.trace("#{log_tag}: after_run: start")
-      $log.trace("#{log_tag}: after_run: done")
+      Droonga.logger.trace("#{log_tag}: after_run: start")
+      Droonga.logger.trace("#{log_tag}: after_run: done")
     end
 
     def stop(stop_graceful)
-      $log.trace("#{log_tag}: stop: start")
+      Droonga.logger.trace("#{log_tag}: stop: start")
       super(stop_graceful)
-      $log.trace("#{log_tag}: stop: done")
+      Droonga.logger.trace("#{log_tag}: stop: done")
     end
 
     private

data/lib/droonga/session.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
@@ -15,10 +15,10 @@
 
 module Droonga
   class Session
-    def initialize(id, dispatcher, collector, tasks, inputs)
+    def initialize(id, dispatcher, collector_runner, tasks, inputs)
       @id = id
       @dispatcher = dispatcher
-      @collector = collector
+      @collector_runner = collector_runner
       @tasks = tasks
       @n_dones = 0
       @inputs = inputs
@@ -49,20 +49,30 @@ module Droonga
       tasks.each do |task|
         task["n_of_inputs"] += 1
         step = task["step"]
-        type = step["type"]
-        command = "collector_" + type
+        command = step["type"]
         n_of_expects = step["n_of_expects"]
         message = {
           "task"=>task,
           "name"=>name,
           "value"=>value
         }
-        @collector.process(command, message)
+        @collector_runner.collect(message)
         return if task["n_of_inputs"] < n_of_expects
         #the task is done
         result = task["values"]
         post = step["post"]
-        @dispatcher.reply("body" => result) if post
+        if post
+          # XXX: It is just a workaround.
+          # Remove me when super step is introduced.
+          if result["errors"]
+            reply_body = result
+          elsif command == "search_gather"
+            reply_body = result
+          else
+            reply_body = result["result"]
+          end
+          @dispatcher.reply("body" => reply_body)
+        end
         step["descendants"].each do |name, routes|
           message = {
             "id" => @id,