fluent-plugin-droonga 0.9.9 → 1.0.0

data/lib/droonga/{plugin/planner/search.rb → error_messages.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
@@ -15,17 +13,21 @@
 # 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/planner_plugin"
-require "droonga/plugin/planner/distributed_search_planner"
+require "droonga/error"
+require "droonga/status_code"
 
 module Droonga
-  class SearchPlanner < Droonga::PlannerPlugin
-    repository.register("search", self)
+  module ErrorMessages
+    class InternalServerError < ErrorMessage
+      STATUS_CODE = StatusCode::INTERNAL_SERVER_ERROR
+    end
+
+    class BadRequest < ErrorMessage
+      STATUS_CODE = StatusCode::BAD_REQUEST
+    end
 
-    command :search
-    def search(message)
-      planner = DistributedSearchPlanner.new(message)
-      planner.plan
+    class NotFound < ErrorMessage
+      STATUS_CODE = StatusCode::NOT_FOUND
     end
   end
 end

data/lib/droonga/farm.rb

@@ -15,37 +15,38 @@
 # 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/partition"
+require "droonga/slice"
 
 module Droonga
   class Farm
-    def initialize(name, loop, options={})
+    def initialize(name, catalog, loop, options={})
       @name = name
+      @catalog = catalog
       @loop = loop
       @options = options
-      @partitions = {}
-      partitions = Droonga.catalog.get_partitions(name)
-      partitions.each do |partition_name, partition_options|
-        partition = Droonga::Partition.new(@loop,
-                                           @options.merge(partition_options))
-        @partitions[partition_name] = partition
+      @slices = {}
+      slices = @catalog.slices(name)
+      slices.each do |slice_name, slice_options|
+        slice = Droonga::Slice.new(@loop,
+                                   @options.merge(slice_options))
+        @slices[slice_name] = slice
       end
     end
 
     def start
-      @partitions.each_value do |partition|
-        partition.start
+      @slices.each_value do |slice|
+        slice.start
       end
     end
 
     def shutdown
-      @partitions.each_value do |partition|
-        partition.shutdown
+      @slices.each_value do |slice|
+        slice.shutdown
       end
     end
 
-    def process(partition_name, message)
-      @partitions[partition_name].process(message)
+    def process(slice_name, message)
+      @slices[slice_name].process(message)
     end
   end
 end

data/lib/droonga/fluent_message_sender.rb

@@ -16,10 +16,14 @@
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 require "cool.io"
+
+require "droonga/loggable"
 require "droonga/message_pack_packer"
 
 module Droonga
   class FluentMessageSender
+    include Loggable
+
     def initialize(loop, host, port)
       @loop = loop
       @host = host
@@ -27,39 +31,39 @@ module Droonga
     end
 
     def start
-      $log.trace("#{log_tag}: start: start")
+      logger.trace("start: start")
       connect
-      $log.trace("#{log_tag}: start: done")
+      logger.trace("start: done")
     end
 
     def shutdown
-      $log.trace("#{log_tag}: shutdown: start")
+      logger.trace("shutdown: start")
       @socket.close unless @socket.closed?
-      $log.trace("#{log_tag}: shutdown: done")
+      logger.trace("shutdown: done")
     end
 
     def send(tag, data)
-      $log.trace("#{log_tag}: send: start")
+      logger.trace("send: start")
       connect if @socket.closed?
       fluent_message = [tag, Time.now.to_i, data]
       packed_fluent_message = MessagePackPacker.pack(fluent_message)
       @socket.write(packed_fluent_message)
       @loop.break_current_loop
-      $log.trace("#{log_tag}: send: done")
+      logger.trace("send: done")
     end
 
     private
     def connect
-      $log.trace("#{log_tag}: connect: start")
+      logger.trace("connect: start")
 
       log_write_complete = lambda do
-        $log.trace("#{log_tag}: write completed")
+        logger.trace("write completed")
       end
       log_connect = lambda do
-        $log.trace("#{log_tag}: connected to #{@host}:#{@port}")
+        logger.trace("connected to #{@host}:#{@port}")
       end
       log_failed = lambda do
-        $log.error("#{log_tag}: failed to connect to #{@host}:#{@port}")
+        logger.error("failed to connect to #{@host}:#{@port}")
       end
 
       @socket = Coolio::TCPSocket.connect(@host, @port)
@@ -74,7 +78,7 @@ module Droonga
       end
       @loop.attach(@socket)
 
-      $log.trace("#{log_tag}: connect: done")
+      logger.trace("connect: done")
     end
 
     def log_tag

data/lib/droonga/forwarder.rb

@@ -15,45 +15,49 @@
 # 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/event_loop"
 require "droonga/fluent_message_sender"
 
 module Droonga
   class Forwarder
+    include Loggable
+
     def initialize(loop)
       @loop = loop
       @senders = {}
     end
 
     def start
-      $log.trace("#{log_tag}: start: start")
-      $log.trace("#{log_tag}: start: done")
+      logger.trace("start: start")
+      logger.trace("start: done")
     end
 
     def shutdown
-      $log.trace("#{log_tag}: shutdown: start")
+      logger.trace("shutdown: start")
       @senders.each_value do |sender|
         sender.shutdown
       end
-      $log.trace("#{log_tag}: shutdown: done")
+      logger.trace("shutdown: done")
     end
 
     def forward(message, destination)
-      $log.trace("#{log_tag}: forward: start")
+      logger.trace("forward: start")
       command = destination["type"]
       receiver = destination["to"]
       arguments = destination["arguments"]
       output(receiver, message, command, arguments)
-      $log.trace("#{log_tag}: forward: done")
+      logger.trace("forward: done")
     end
 
     private
     def output(receiver, message, command, arguments)
-      $log.trace("#{log_tag}: output: start")
-      unless receiver.is_a?(String) && command.is_a?(String)
-        $log.trace("#{log_tag}: output: abort: invalid argument",
-                   :receiver => receiver,
-                   :command  => command)
+      logger.trace("output: start")
+      # TODO: IMPROVE ME: Should not use "unless" and "and". It is confused.
+      unless receiver.is_a?(String) and command.is_a?(String)
+        logger.trace("output: abort: invalid argument",
+                     :receiver => receiver,
+                     :command  => command)
         return
       end
       unless receiver =~ /\A(.*):(\d+)\/(.*?)(\?.+)?\z/
@@ -65,10 +69,10 @@ module Droonga
       params = $4
       sender = find_sender(host, port, params)
       unless sender
-        $log.trace("#{log_tag}: output: abort: no sender",
-                   :host   => host,
-                   :port   => port,
-                   :params => params)
+        logger.trace("output: abort: no sender",
+                     :host   => host,
+                     :port   => port,
+                     :params => params)
         return
       end
       override_message = {
@@ -78,10 +82,10 @@ module Droonga
       message = message.merge(override_message)
       output_tag = "#{tag}.message"
       log_info = "<#{receiver}>:<#{output_tag}>"
-      $log.trace("#{log_tag}: output: post: start: #{log_info}")
+      logger.trace("output: post: start: #{log_info}")
       sender.send(output_tag, message)
-      $log.trace("#{log_tag}: output: post: done: #{log_info}")
-      $log.trace("#{log_tag}: output: done")
+      logger.trace("output: post: done: #{log_info}")
+      logger.trace("output: done")
     end
 
     def find_sender(host, port, params)

data/lib/droonga/handler.rb

@@ -14,12 +14,16 @@
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 require "droonga/pluggable"
+require "droonga/loggable"
 require "droonga/plugin/metadata/input_message"
 require "droonga/plugin/metadata/handler_action"
+require "droonga/error_messages"
 
 module Droonga
   class Handler
     extend Pluggable
+    include Loggable
+    include ErrorMessages
 
     class << self
       def message
@@ -31,12 +35,14 @@ module Droonga
       end
     end
 
-    def initialize(name, context)
+    attr_reader :messenger
+    def initialize(name, context, messenger)
       @name = name
       @context = context
+      @messenger = messenger
     end
 
-    def handle(message, messenger)
+    def handle(message)
     end
   end
 end

data/lib/droonga/handler_runner.rb

@@ -15,85 +15,106 @@
 
 require "groonga"
 
+require "droonga/loggable"
 require "droonga/forwarder"
 require "droonga/handler_message"
 require "droonga/handler_messenger"
-require "droonga/handler"
+require "droonga/step_runner"
 
 module Droonga
   class HandlerRunner
+    include Loggable
+
     def initialize(loop, options={})
       @loop = loop
       @options = options
       @name = options[:name]
+      @dataset_name = options[:dataset]
       @database_name = options[:database]
       prepare
     end
 
     def start
-      $log.trace("#{log_tag}: start: start")
+      logger.trace("start: start")
       @forwarder.start
-      $log.trace("#{log_tag}: start: done")
+      logger.trace("start: done")
     end
 
     def shutdown
-      $log.trace("#{log_tag}: shutdown: start")
+      logger.trace("shutdown: start")
       @forwarder.shutdown
       if @database
         @database.close
         @context.close
         @database = @context = nil
       end
-      $log.trace("#{log_tag}: shutdown: done")
+      logger.trace("shutdown: done")
     end
 
-    def prefer_synchronous?(command)
-      find_handler_class(command).action.synchronous?
+    def prefer_synchronous?(type)
+      find_handler_class(type).action.synchronous?
     end
 
-    def processable?(command)
-      not find_handler_class(command).nil?
+    def processable?(type)
+      not find_handler_class(type).nil?
     end
 
     def process(message)
-      $log.trace("#{log_tag}: process: start")
-      command = message["type"]
-      handler_class = find_handler_class(command)
+      logger.trace("process: start")
+      type = message["type"]
+      handler_class = find_handler_class(type)
       if handler_class.nil?
-        $log.trace("#{log_tag}: process: done: no handler: <#{command}>")
+        logger.trace("process: done: no handler: <#{type}>")
         return
       end
-      process_command(handler_class, command, message)
-      $log.trace("#{log_tag}: process: done: <#{command}>",
-                 :handler => handler_class)
+      process_type(handler_class, type, message)
+      logger.trace("process: done: <#{type}>",
+                   :handler => handler_class)
     end
 
     private
     def prepare
-      if @database_name && !@database_name.empty?
+      if @database_name and !@database_name.empty?
         @context = Groonga::Context.new
         @database = @context.open_database(@database_name)
       end
-      @handler_classes = Handler.find_sub_classes(@options[:plugins] || [])
+      logger.debug("#{self.class.name}: activating plugins for the dataset \"#{@dataset_name}\": " +
+                     "#{@options[:plugins].join(", ")}")
+      @step_runner = StepRunner.new(@options[:plugins] || [])
       @forwarder = Forwarder.new(@loop)
     end
 
-    def find_handler_class(command)
-      @handler_classes.find do |handler_class|
-        handler_class.message.type == command
-      end
+    def find_handler_class(type)
+      step_definition = @step_runner.find(type)
+      return nil if step_definition.nil?
+      step_definition.handler_class
     end
 
-    def process_command(handler_class, command, raw_message)
+    def process_type(handler_class, type, raw_message)
       handler_message = HandlerMessage.new(raw_message)
       handler_message.validate
 
       messenger = HandlerMessenger.new(@forwarder, handler_message, @options)
-      handler = handler_class.new(@name, @context)
+      handler = handler_class.new(@name, @context, messenger)
       begin
-        handler.handle(handler_message, messenger)
-      rescue MessageProcessingError => error
+        result = handler.handle(handler_message)
+        unless result.nil?
+          # XXX: It is just a workaround.
+          # Remove me when super step is introduced.
+          if handler.is_a?(Droonga::Plugins::Search::Handler)
+            messenger.emit(result)
+          else
+            messenger.emit("result" => result)
+          end
+        end
+      rescue ErrorMessage => error
         messenger.error(error.status_code, error.response_body)
+      rescue => error
+        logger.exception("failed to handle message", error)
+        internal_server_error =
+          ErrorMessages::InternalServerError.new("Unknown internal error")
+        messenger.error(internal_server_error.status_code,
+                        internal_server_error.response_body)
       end
     end
 

data/lib/droonga/input_message.rb

@@ -36,16 +36,16 @@ module Droonga
       @raw_message["body"] = body
     end
 
-    def command
+    def type
       @raw_message["type"]
     end
 
-    def command=(command)
-      original_command = @raw_message["type"]
-      return if original_command == command
+    def type=(type)
+      original_type = @raw_message["type"]
+      return if original_type == type
       @raw_message["originalTypes"] ||= []
-      @raw_message["originalTypes"] << original_command
-      @raw_message["type"] = command
+      @raw_message["originalTypes"] << original_type
+      @raw_message["type"] = type
     end
   end
 end

data/lib/droonga/{command.rb → loggable.rb}

@@ -13,24 +13,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/message_matcher"
+require "droonga/logger"
 
 module Droonga
-  class Command
-    attr_reader :method_name
-    # @option options [Array] :pattern The pattern to be matched
-    #    against message. If the pattern is matched to a message,
-    #    the command will be applied.
-    #
-    # @see MessageMatcher
-    def initialize(method_name, options)
-      @method_name = method_name
-      @options = options
-      @matcher = MessageMatcher.new(@options[:pattern])
+  module Loggable
+    private
+    def logger
+      @logger ||= Logger.new(:depth_offset => 1, :tag => log_tag)
     end
 
-    def match?(message)
-      @matcher.match?(message)
+    def log_tag
+      nil
     end
   end
 end