fluent-plugin-groonga 1.1.8 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f225a28b0bd052b37c5180b7707ac898f550ca57
-  data.tar.gz: 0c93017fa42a9a2edac9b50d97d0e3d3e5cf0a94
+  metadata.gz: 58980511ad7775baea84617dc9ab6ed0f93e29dc
+  data.tar.gz: 63193a59c766554172b3d34a4d3f40c47465d594
 SHA512:
-  metadata.gz: deb8587173008cf6ddc636aebe1fd7c2eb41ed01b806e91c020af81c1dc38eeccdbac196391ecc2289354458d3172707db85f9d9865a7690bc18f8ff00e917df
-  data.tar.gz: 737f5f9db324b14199f4e2b1734d7bc76e1008b80906eba78febe99f0aae91a428a1db69d809715661473bbc4e4252557be4f75512796f42df6f178195eb89ef
+  metadata.gz: c44c1ad1b43b1144ff703d61092a8ccf76735c5dfdfce75f5f33023b7e1969b78154629205d68b52d0b6ff9889f0b0a2a254a1e225777ded1cfcc23529293a71
+  data.tar.gz: 7a1b9fdef294db2a6ab661ad7d4619486a887e82e5e674f6e0d1243cb301fc7281a6df8c3463cad04bcab63cf359ff8bc9be6edcb773a61234243b551bd0c6a8

data/doc/text/configuration.md

@@ -8,7 +8,25 @@ describes configuration parameters of them.
 
 ## The `groonga` input plugin
 
-Here are available parameters:
+The behavior of `groonga` input plugin is customized in `system`
+directive and `source` directive parameters.
+
+Here is recommended parameter in `system` directive:
+
+  * `workers`: It specifies the number of workers. The point of view
+    in performance, the recommended value is greater than 1 to process
+    requests in parallel.
+
+    * recommended value: greater than `1`.
+
+    * default: `1`
+
+Note that there is one exception about the number of recommended
+workers. Users should use `1` worker when commands contain DDL such as
+`table_create` and `column_create`. Because execution order of these
+commands may be swapped. In such a case, replication will fail.
+
+Here are available parameters in `source` directive:
 
   * `protocol`: It specifies protocol for receiving Groonga commands.
 
@@ -32,28 +50,14 @@ Here are available parameters:
 
     * default: `10041`
 
-  * `command_name_position`: It specifies where Groonga command's
-    name.
-
-    If `tag` is specified, the plugin puts Groonga command's name to
-    tag as `groonga.command.#{COMMAND_NAME}` format and record
-    is the arguments of the command.
-
-    If `record` is specified, the plugin puts both Groonga command's
-    name and arguments to record as `{"name": "#{COMMAND_NAME}",
-    "arguments": {...}}` format. Tag is always `groonga.command`.
-
-    `record` is suitable when you want to implement replication. If
-    you `tag` for replication, Groonga command's order may be changed.
-
-    * Available values: `tag`, `record`
-
-    * default: `tag`
-
   * `emit_commands`: TODO
 
 Here is an example:
 
+    <system>
+      workers 2
+    </system>
+
     <source>
       @type groonga
       protocol http
@@ -61,7 +65,6 @@ Here is an example:
       port 10041
       real_host 192.168.0.1
       real_port 10041
-      command_name_position record
     </source>
 
 ## The `groonga` output plugin

data/doc/text/constitution.md

@@ -66,21 +66,19 @@ Here is an example configuration file:
     # For master Groonga server
     <source>
       @type groonga
-      protocol gqtp                # Or use the below line
+      protocol gqtp          # Or use the below line
       # protocol http
-      bind 127.0.0.1               # For client side Fluentd
-      # bind 192.168.0.1           # For master Groonga server side Fluentd
+      bind 127.0.0.1         # For client side Fluentd
+      # bind 192.168.0.1     # For master Groonga server side Fluentd
       port 10041
-      real_host 192.168.29.1       # IP address of master Groonga server
-      real_port 10041              # Port number of master Groonga server
-      # real_port 20041            # Use different port number
-                                   # for master Groonga server side Fluentd
-
-      command_name_position record # To keep command order
+      real_host 192.168.29.1 # IP address of master Groonga server
+      real_port 10041        # Port number of master Groonga server
+      # real_port 20041      # Use different port number
+                             # for master Groonga server side Fluentd
     </source>
 
     # For slave Groonga server
-    <match groonga.command.**>
+    <match groonga.command.*>
       @type groonga
       protocol gqtp            # Or use the below line
       # protocol http          # You can use different protocol for
@@ -128,7 +126,7 @@ You cannot update data until fluentd is up.
 Here are recover steps when master Groonga server is down:
 
   1. Stop fluentd.
-  2. Run `groonga /PATH/TO/SLAVE/GROONGA/SERVER/DB dump >
+  2. Run `grndump /PATH/TO/SLAVE/GROONGA/SERVER/DB >
      SLAVE_GROONGA_DUMP.grn` on slave Groonga server host.
   3. Run `groonga -n /PATH/TO/MASTER/GROONGA/SERVER/DB <
      SLAVE_GROONGA_DUMP.grn` on master Groonga server.
@@ -141,7 +139,7 @@ You cannot update data until you finish to recover.
 
 Here are recover steps when slave Groonga server is down:
 
-  1. Run `groonga /PATH/TO/MASTER/GROONGA/SERVER/DB dump >
+  1. Run `grndump /PATH/TO/MASTER/GROONGA/SERVER/DB >
      MASTER_GROONGA_DUMP.grn` on master Groonga server host.
   2. Run `groonga -n /PATH/TO/SLAVE/GROONGA/SERVER/DB <
      MASTER_GROONGA_DUMP.grn` on slave Groonga server.
@@ -157,7 +155,7 @@ is full (see `buffer_queue_limit`) or fluentd gives up retrying (see
 Groonga server before those situations:
 
   1. Stop fluentd.
-  2. Run `groonga /PATH/TO/MASTER/GROONGA/SERVER/DB dump >
+  2. Run `grndump /PATH/TO/MASTER/GROONGA/SERVER/DB >
      MASTER_GROONGA_DUMP.grn` on master Groonga server host.
   3. Run `groonga -n /PATH/TO/SLAVE/GROONGA/SERVER/DB <
      MASTER_GROONGA_DUMP.grn` on slave Groonga server host.
@@ -196,21 +194,19 @@ Here is an example configuration file:
     # For master Groonga server
     <source>
       @type groonga
-      protocol gqtp                # Or use the below line
+      protocol gqtp          # Or use the below line
       # protocol http
-      bind 127.0.0.1               # For client side Fluentd
-      # bind 192.168.0.1           # For master Groonga server side Fluentd
+      bind 127.0.0.1         # For client side Fluentd
+      # bind 192.168.0.1     # For master Groonga server side Fluentd
       port 10041
-      real_host 192.168.29.1       # IP address of master Groonga server
-      real_port 10041              # Port number of master Groonga server
-      # real_port 20041            # Use different port number
-                                   # for master Groonga server side fluentd
-
-      command_name_position record # To keep command order
+      real_host 192.168.29.1 # IP address of master Groonga server
+      real_port 10041        # Port number of master Groonga server
+      # real_port 20041      # Use different port number
+                             # for master Groonga server side fluentd
     </source>
 
     # For slave Groonga servers
-    <match groonga.command.**>
+    <match groonga.command.*>
       @type copy
 
       # The first slave Groonga server

data/doc/text/news.md

@@ -2,12 +2,18 @@
 
 # News
 
-## 1.1.8: 2018-01-16
+## 1.2.0: 2017-04-26
 
 ### Improvements
 
-* in: `command_name_position`: Added a new parameter to control
-  command format. The default behavior isn't changed.
+* Supported recent fluentd v0.14 API.
+  Since fluentd 0.14.12, compatibility layer is unexpectedly broken,
+  fluent-plugin-groonga had been also affected because
+  fluent-plugin-groonga relied on it. Note that fluent-plugin-groonga
+  does not work with fluentd v0.12 because it does not use
+  compatibility layer anymore. We recommends to use latest release,
+  but if you still stay with fluentd v0.12, you need to use
+  fluent-plugin-groonga 1.1.7.
 
 ## 1.1.7: 2017-04-04
 

data/fluent-plugin-groonga.gemspec

@@ -1,7 +1,6 @@
 # -*- mode: ruby; coding: utf-8 -*-
 #
-# Copyright (C) 2018  Yasuhiro Horimoto <horimoto@clear-code.com>
-# Copyright (C) 2012-2017  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2012-2016  Kouhei Sutou <kou@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -18,7 +17,7 @@
 
 Gem::Specification.new do |spec|
   spec.name = "fluent-plugin-groonga"
-  spec.version = "1.1.8"
+  spec.version = "1.2.0"
   spec.authors = ["Kouhei Sutou"]
   spec.email = ["kou@clear-code.com"]
   spec.summary = "Fluentd plugin to store data into Groonga and implement Groonga replication system."
@@ -35,7 +34,7 @@ Gem::Specification.new do |spec|
   spec.test_files += Dir.glob("test/**/*")
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency("fluentd", ">= 0.12.20", "< 0.14.0")
+  spec.add_runtime_dependency("fluentd", ">= 0.14.0")
   spec.add_runtime_dependency("groonga-client", ">= 0.1.0")
   spec.add_runtime_dependency("groonga-command-parser")
 

data/lib/fluent/plugin/in_groonga.rb

@@ -1,4 +1,3 @@
-# Copyright (C) 2018  Yasuhiro Horimoto <horimoto@clear-code.com>
 # Copyright (C) 2012-2017  Kouhei Sutou <kou@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
@@ -23,460 +22,448 @@ require "http_parser"
 require "gqtp"
 require "groonga/command/parser"
 
-require "fluent/input"
-require "fluent/process"
+require "fluent/plugin/input"
 
 module Fluent
-  class GroongaInput < Input
-    Plugin.register_input("groonga", self)
+  module Plugin
+    class GroongaInput < Input
+      Plugin.register_input("groonga", self)
 
-    def initialize
-      super
-    end
-
-    config_param :protocol, :enum, :list => [:http, :gqtp], :default => :http
-    config_param :command_name_position, :enum, :list => [:tag, :record], :default => :tag
-
-    def configure(conf)
-      super
-      case @protocol
-      when :http
-        @input = HTTPInput.new(self)
-      when :gqtp
-        @input = GQTPInput.new(self)
-      end
-      @input.configure(conf)
-    end
-
-    def start
-      super
-      @input.start
-    end
-
-    def shutdown
-      super
-      @input.shutdown
-    end
-
-    class Repeater < Coolio::TCPSocket
-      def initialize(socket, handler)
-        super(socket)
-        @handler = handler
-      end
-
-      def on_read(data)
-        @handler.write_back(data)
-      end
-
-      def on_close
-        @handler.close
-      end
-    end
+      helpers :server
 
-    class BaseInput
-      include Configurable
-      include DetachMultiProcessMixin
-
-      config_param :bind, :string, :default => "0.0.0.0"
-      config_param :port, :integer, :default => nil
-      config_param :real_host, :string
-      config_param :real_port, :integer, :default => nil
-      DEFAULT_EMIT_COMMANDS = [
-        "clearlock",
-        "column_copy",
-        "column_create",
-        "column_remove",
-        "column_rename",
-        "config_delete",
-        "config_set",
-        "delete",
-        "load",
-        "lock_acquire",
-        "lock_clear",
-        "lock_release",
-        "logical_table_remove",
-        "object_remove",
-        "plugin_register",
-        "plugin_unregister",
-        "register",
-        "reindex",
-        "table_copy",
-        "table_create",
-        "table_remove",
-        "table_rename",
-        "truncate",
-      ]
-      config_param :emit_commands, :default => DEFAULT_EMIT_COMMANDS do |value|
-        commands = value.split(/\s*,\s*/)
-        commands.collect do |command|
-          if /\A\/(.*)\/(i)?\z/ =~ command
-            pattern = $1
-            flag_mark = $2
-            flag = 0
-            flag |= Regexp::IGNORECASE if flag_mark == "i"
-            Regexp.new(pattern, flag)
-          else
-            command
-          end
-        end
+      def initialize
+        super
       end
 
-      def initialize(input_plugin)
-        @input_plugin = input_plugin
-      end
+      config_param :protocol, :enum, :list => [:http, :gqtp], :default => :http
 
       def configure(conf)
         super
-
-        @port ||= default_port
-        @real_port ||= default_port
+        case @protocol
+        when :http
+          @input = HTTPInput.new(self)
+        when :gqtp
+          @input = GQTPInput.new(self)
+        end
+        @input.configure(conf)
       end
 
       def start
-        listen_socket = TCPServer.new(@bind, @port)
-        detach_multi_process do
-          @loop = Coolio::Loop.new
-
-          @socket = Coolio::TCPServer.new(listen_socket, nil,
-                                          handler_class, self)
-          @loop.attach(@socket)
+        super
 
-          @shutdown_notifier = Coolio::AsyncWatcher.new
-          @loop.attach(@shutdown_notifier)
+        port = @input.port
+        bind = @input.bind
+        log.info("[input][groonga][connect] listening port",
+                 :port => port, :bind => bind)
+        server_create_connection(:groonga_input,
+                                 port,
+                                 :proto => :tcp,
+                                 :shared => system_config.workers > 1,
+                                 :bind => bind) do |connection|
+          handler = nil
+          real_host = @input.real_host
+          real_port = @input.real_port
+          repeater = Coolio::TCPSocket.connect(real_host, real_port)
+          repeater.on_connect_failed do
+            log.error("[input][groonga][connect][error] " +
+                      "failed to connect to Groonga:",
+                      :real_host => real_host,
+                      :real_port => real_port)
+            connection.close
+          end
+          repeater.on_read do |data|
+            handler.write_back(data)
+          end
+          repeater.on_close do
+            handler.close
+          end
+          event_loop_attach(repeater)
 
-          @thread = Thread.new do
-            run
+          handler = @input.create_handler(connection, repeater)
+          connection.data do |data|
+            handler.on_read(data)
           end
         end
       end
 
       def shutdown
-        @loop.stop
-        @socket.close
-        @shutdown_notifier.signal
-        @thread.join
+        super
       end
 
-      def create_repeater(client)
-        repeater = Repeater.connect(@real_host, @real_port, client)
-        repeater.attach(@loop)
-        repeater
+      def multi_workers_ready?
+        true
       end
 
-      def emit(command, params)
-        normalized_command = command.split(".")[0]
-        return unless emit_command?(normalized_command)
-        case @input_plugin.command_name_position
-        when :tag
-          tag = "groonga.command.#{normalized_command}"
-          record = params
-        else
-          tag = "groonga.command"
-          record = {
-            "name" => normalized_command,
-            "arguments" => params
-          }
+      class Repeater < Coolio::TCPSocket
+        def initialize(socket, handler)
+          super(socket)
+          @handler = handler
         end
-        @input_plugin.router.emit(tag,
-                                  Engine.now,
-                                  record)
-      end
 
-      private
-      def run
-        @loop.run
-      rescue
-        $log.error("[input][groonga][error] unexpected error",
-                   :error => "#{$!.class}: #{$!}")
-        $log.error_backtrace
-      end
-
-      def emit_command?(command)
-        return true if @emit_commands.empty?
-        @emit_commands.any? do |pattern|
-          pattern === command
+        def on_read(data)
+          @handler.write_back(data)
         end
-      end
-    end
 
-    class HTTPInput < BaseInput
-      private
-      def default_port
-        10041
-      end
-
-      def handler_class
-        Handler
+        def on_close
+          @handler.close
+        end
       end
 
-      class Handler < Coolio::Socket
-        def initialize(socket, input)
-          super(socket)
-          @input = input
+      class BaseInput
+        include Configurable
+
+        config_param :bind, :string, :default => "0.0.0.0"
+        config_param :port, :integer, :default => nil
+        config_param :real_host, :string
+        config_param :real_port, :integer, :default => nil
+        DEFAULT_EMIT_COMMANDS = [
+          "clearlock",
+          "column_copy",
+          "column_create",
+          "column_remove",
+          "column_rename",
+          "config_delete",
+          "config_set",
+          "delete",
+          "load",
+          "lock_acquire",
+          "lock_clear",
+          "lock_release",
+          "logical_table_remove",
+          "object_remove",
+          "plugin_register",
+          "plugin_unregister",
+          "register",
+          "reindex",
+          "table_copy",
+          "table_create",
+          "table_remove",
+          "table_rename",
+          "truncate",
+        ]
+        config_param :emit_commands, :default => DEFAULT_EMIT_COMMANDS do |value|
+          commands = value.split(/\s*,\s*/)
+          commands.collect do |command|
+            if /\A\/(.*)\/(i)?\z/ =~ command
+              pattern = $1
+              flag_mark = $2
+              flag = 0
+              flag |= Regexp::IGNORECASE if flag_mark == "i"
+              Regexp.new(pattern, flag)
+            else
+              command
+            end
+          end
         end
 
-        def on_connect
-          @repeater = @input.create_repeater(self)
-          @repeater.on_connect_failed do
-            $log.error("[input][groonga][connect][error] " +
-                       "failed to connect to Groonga:",
-                       :real_host => @input.real_host,
-                       :real_port => @input.real_port)
-            close
-          end
-          @request_handler = RequestHandler.new(@input, @repeater)
-          @response_handler = ResponseHandler.new(self)
+        def initialize(input_plugin)
+          @input_plugin = input_plugin
         end
 
-        def on_read(data)
-          begin
-            @request_handler << data
-          rescue HTTP::Parser::Error, URI::InvalidURIError
-            $log.error("[input][groonga][request][error] " +
-                       "failed to parse HTTP request:",
-                       :error => "#{$!.class}: #{$!}")
-            $log.error_backtrace
-            reply_error_response("400 Bad Request")
-          rescue
-            $log.error("[input][groonga][request][error] " +
-                       "failed to handle HTTP request:",
-                       :error => "#{$!.class}: #{$!}")
-            $log.error_backtrace
-            reply_error_response("500 Internal Server Error")
-          end
-        end
+        def configure(conf)
+          super
 
-        def write_back(data)
-          begin
-            @response_handler << data
-          rescue
-            $log.error("[input][groonga][response][error] " +
-                       "failed to handle HTTP response from Groonga:",
-                       :error => "#{$!.class}: #{$!}")
-            $log.error_backtrace
-            reply_error_response("500 Internal Server Error")
-            return
-          end
-          write(data)
+          @port ||= default_port
+          @real_port ||= default_port
         end
 
-        def on_response_complete(response)
-          if need_emit?(response)
-            @input.emit(@request_handler.command,
-                        @request_handler.params)
-          end
-          on_write_complete do
-            @repeater.close
-          end
+        def emit(command, params)
+          normalized_command = command.split(".")[0]
+          return unless emit_command?(normalized_command)
+          @input_plugin.router.emit("groonga.command.#{normalized_command}",
+                                    Engine.now,
+                                    params)
         end
 
-        private
-        def need_emit?(response)
-          case @request_handler.command
-          when "load", "object_remove"
-            return true
-          end
-
-          case response
-          when Array
-            return_code = response[0][0]
-            return_code.zero?
-          else
-            false
-          end
+        def log
+          @input_plugin.log
         end
 
-        def reply_error_response(status)
-          write("HTTP1.1 #{status}\r\n")
-          write("Server: fluent-plugin-groonga\r\n")
-          write("Connection: close\r\n")
-          write("Content-Length: 0\r\n")
-          write("\r\n")
-          disable
-          on_write_complete do
-            @repeater.close
+        private
+        def emit_command?(command)
+          return true if @emit_commands.empty?
+          @emit_commands.any? do |pattern|
+            pattern === command
           end
         end
       end
 
-      class RequestHandler
-        attr_reader :command
-        attr_reader :params
-        def initialize(input, repeater)
-          @input = input
-          @repeater = repeater
-          @parser = Http::Parser.new(self)
+      class HTTPInput < BaseInput
+        def create_handler(connection, repeater)
+          Handler.new(self, connection, repeater)
         end
 
-        def <<(chunk)
-          @parser << chunk
+        private
+        def default_port
+          10041
         end
 
-        def on_message_begin
-          @body = ""
-          @command = nil
-          @params = nil
-        end
+        class Handler
+          def initialize(input, connection, repeater)
+            @input = input
+            @connection = connection
+            @repeater = repeater
+            @request_handler = RequestHandler.new(@input, @repeater)
+            @response_handler = ResponseHandler.new(self, @input)
+          end
 
-        def on_headers_complete(headers)
-          method = @parser.http_method
-          url = @parser.request_url
-          http_version = @parser.http_version.join(".")
-          @repeater.write("#{method} #{url} HTTP/#{http_version}\r\n")
-          headers.each do |name, value|
-            case name
-            when /\AHost\z/i
-              real_host = @input.real_host
-              real_port = @input.real_port
-              @repeater.write("#{name}: #{real_host}:#{real_port}\r\n")
-            else
-              @repeater.write("#{name}: #{value}\r\n")
+          def on_read(data)
+            begin
+              @request_handler << data
+            rescue HTTP::Parser::Error, URI::InvalidURIError
+              @input.log.error("[input][groonga][request][error] " +
+                               "failed to parse HTTP request:",
+                               :error => "#{$!.class}: #{$!}")
+              @input.log.error_backtrace
+              reply_error_response("400 Bad Request")
+            rescue
+              @input.log.error("[input][groonga][request][error] " +
+                               "failed to handle HTTP request:",
+                               :error => "#{$!.class}: #{$!}")
+              @input.log.error_backtrace
+              reply_error_response("500 Internal Server Error")
             end
           end
-          @repeater.write("\r\n")
-        end
 
-        def on_body(chunk)
-          @body << chunk
-          @repeater.write(chunk)
-        end
+          def write_back(data)
+            begin
+              @response_handler << data
+            rescue
+              @input.log.error("[input][groonga][response][error] " +
+                               "failed to handle HTTP response from Groonga:",
+                               :error => "#{$!.class}: #{$!}")
+              @input.log.error_backtrace
+              reply_error_response("500 Internal Server Error")
+              return
+            end
+            @connection.write(data)
+          end
 
-        def on_message_complete
-          uri = URI.parse(@parser.request_url)
-          params = WEBrick::HTTPUtils.parse_query(uri.query)
-          path_info = uri.path
-          case path_info
-          when /\A\/d\//
-            command = $POSTMATCH
-            if command == "load"
-              params["values"] = @body unless @body.empty?
+          def on_response_complete(response)
+            if need_emit?(response)
+              @input.emit(@request_handler.command,
+                          @request_handler.params)
+            end
+            @connection.on(:write_complete) do
+              @repeater.close
             end
-            @command = command
-            @params = params
           end
-        end
-      end
 
-      class ResponseHandler
-        def initialize(handler)
-          @handler = handler
-          @parser = Http::Parser.new(self)
-        end
+          def close
+            @connection.close
+          end
 
-        def <<(chunk)
-          @parser << chunk
-        end
+          private
+          def need_emit?(response)
+            case @request_handler.command
+            when "load", "object_remove"
+              return true
+            end
 
-        def on_message_begin
-          @body = ""
-          @content_type = nil
-        end
+            case response
+            when Array
+              return_code = response[0][0]
+              return_code.zero?
+            else
+              false
+            end
+          end
 
-        def on_headers_complete(headers)
-          headers.each do |name, value|
-            case name
-            when /\AContent-Type\z/i
-              @content_type = value
+          def reply_error_response(status)
+            @connection.write("HTTP1.1 #{status}\r\n")
+            @connection.write("Server: fluent-plugin-groonga\r\n")
+            @connection.write("Connection: close\r\n")
+            @connection.write("Content-Length: 0\r\n")
+            @connection.write("\r\n")
+            @connection.on(:write_complete) do
+              @repeater.close
             end
           end
         end
 
-        def on_body(chunk)
-          @body << chunk
-        end
+        class RequestHandler
+          attr_reader :command
+          attr_reader :params
+          def initialize(input, repeater)
+            @input = input
+            @repeater = repeater
+            @parser = Http::Parser.new(self)
+          end
 
-        def on_message_complete
-          return if @parser.status_code == 100
+          def <<(chunk)
+            @parser << chunk
+          end
 
-          response = nil
-          case @content_type
-          when /\Aapplication\/json\z/i
-            begin
-              response = JSON.parse(@body)
-            rescue JSON::ParserError
-              $log.warn("[input][groonga][response][warn] " +
-                        "failed to parse response JSON:",
-                        :error => "#{$!.class}: #{$!}",
-                        :json => @body)
+          def on_message_begin
+            @body = ""
+            @command = nil
+            @params = nil
+          end
+
+          def on_headers_complete(headers)
+            method = @parser.http_method
+            url = @parser.request_url
+            http_version = @parser.http_version.join(".")
+            @repeater.write("#{method} #{url} HTTP/#{http_version}\r\n")
+            headers.each do |name, value|
+              case name
+              when /\AHost\z/i
+                real_host = @input.real_host
+                real_port = @input.real_port
+                @repeater.write("#{name}: #{real_host}:#{real_port}\r\n")
+              else
+                @repeater.write("#{name}: #{value}\r\n")
+              end
             end
-          when /\Aapplication\/x-msgpack\z/i
-            begin
-              response = MessagePack.unpack(@body)
-            rescue MessagePack::UnpackError, EOFError
-              $log.warn("[input][groonga][response][warn] " +
-                        "failed to parse response MessagePack",
-                        :error => "#{$!.class}: #{$!}",
-                        :msgpack => @body)
+            @repeater.write("\r\n")
+          end
+
+          def on_body(chunk)
+            @body << chunk
+            @repeater.write(chunk)
+          end
+
+          def on_message_complete
+            uri = URI.parse(@parser.request_url)
+            params = WEBrick::HTTPUtils.parse_query(uri.query)
+            path_info = uri.path
+            case path_info
+            when /\A\/d\//
+              command = $POSTMATCH
+              if command == "load"
+                params["values"] = @body unless @body.empty?
+              end
+              @command = command
+              @params = params
             end
-          when /\Atext\/x-groonga-command-list\z/i
-            response = @body
           end
-          @handler.on_response_complete(response)
         end
-      end
-    end
 
-    class GQTPInput < BaseInput
-      private
-      def default_port
-        10043
-      end
+        class ResponseHandler
+          def initialize(handler, input)
+            @handler = handler
+            @input = input
+            @parser = Http::Parser.new(self)
+          end
 
-      def handler_class
-        Handler
-      end
+          def <<(chunk)
+            @parser << chunk
+          end
 
-      class Handler < Coolio::Socket
-        def initialize(socket, input)
-          super(socket)
-          @input = input
-        end
+          def on_message_begin
+            @body = ""
+            @content_type = nil
+          end
 
-        def on_connect
-          @parser = Parser.new(@input)
-          @repeater = @input.create_repeater(self)
-        end
+          def on_headers_complete(headers)
+            headers.each do |name, value|
+              case name
+              when /\AContent-Type\z/i
+                @content_type = value
+              end
+            end
+          end
 
-        def on_read(data)
-          @parser << data
-          @repeater.write(data)
-        end
+          def on_body(chunk)
+            @body << chunk
+          end
 
-        def on_close
-          @parser.close
+          def on_message_complete
+            return if @parser.status_code == 100
+
+            response = nil
+            case @content_type
+            when /\Aapplication\/json\z/i
+              begin
+                response = JSON.parse(@body)
+              rescue JSON::ParserError
+                @input.log.warn("[input][groonga][response][warn] " +
+                                "failed to parse response JSON:",
+                                :error => "#{$!.class}: #{$!}",
+                                :json => @body)
+              end
+            when /\Aapplication\/x-msgpack\z/i
+              begin
+                response = MessagePack.unpack(@body)
+              rescue MessagePack::UnpackError, EOFError
+                @input.log.warn("[input][groonga][response][warn] " +
+                                "failed to parse response MessagePack",
+                                :error => "#{$!.class}: #{$!}",
+                                :msgpack => @body)
+              end
+            when /\Atext\/x-groonga-command-list\z/i
+              response = @body
+            end
+            @handler.on_response_complete(response)
+          end
         end
       end
 
-      class Parser < GQTP::Parser
-        def initialize(input)
-          super()
-          @input = input
-          initialize_command_parser
+      class GQTPInput < BaseInput
+        def create_handler(connection, repeater)
+          Handler.new(self, connection, repeater)
         end
 
-        def on_body(chunk)
-          @command_parser << chunk
+        private
+        def default_port
+          10043
         end
 
-        def on_complete
-          @command_parser << "\n"
-        end
+        class Handler
+          def initialize(input, connection, repeater)
+            @input = input
+            @connection = connection
+            @repeater = repeater
+
+            @request_parser = RequestParser.new(@input)
+          end
 
-        def close
-          @command_parser.finish
+          def on_read(data)
+            @request_parser << data
+            @repeater.write(data)
+          end
+
+          def write_back(data)
+            @connection.write(data)
+          end
+
+          def close
+            @request_parser.close
+            @connection.close
+          end
         end
 
-        private
-        def initialize_command_parser
-          @command_parser = Groonga::Command::Parser.new
-          @command_parser.on_command do |command|
-            @input.emit(command.name, command.arguments)
-          end
-          @command_parser.on_load_value do |command, value|
-            arguments = command.arguments.dup
-            arguments[:columns] = command.columns.join(", ")
-            arguments[:values] = Yajl::Encoder.encode([value])
-            @input.emit(command.name, arguments)
+        class RequestParser < GQTP::Parser
+          def initialize(input)
+            super()
+            @input = input
+            initialize_command_parser
+          end
+
+          def on_body(chunk)
+            @command_parser << chunk
+          end
+
+          def on_complete
+            @command_parser << "\n"
+          end
+
+          def close
+            @command_parser.finish
+          end
+
+          private
+          def initialize_command_parser
+            @command_parser = Groonga::Command::Parser.new
+            @command_parser.on_command do |command|
+              @input.emit(command.command_name, command.arguments)
+            end
+            @command_parser.on_load_value do |command, value|
+              arguments = command.arguments.dup
+              arguments[:columns] = command.columns.join(", ")
+              arguments[:values] = Yajl::Encoder.encode([value])
+              @input.emit(command.command_name, arguments)
+            end
           end
         end
       end