gqtp 1.0.5 → 1.0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a9646329d91fbafd50713cb36cd0a29805f955fc
+  data.tar.gz: d4a1e5c555ee1463d29a4817d5232e05122b20fb
+SHA512:
+  metadata.gz: 4e97a85e004db92b0d58a9cb624ede027b1ba44d50547526bbec6e0605a96d721b04ad993129ec827959cc050fdad6723ffa0cafedf350cc70c1c1f4fef51646
+  data.tar.gz: 3e6daac1d896ff3ca752bb55a479b6ec1aa7dd4603bc3a28745cd86bdedca95a988da795683e5947edb556326e24d5c5bb8663a4c904d5e0368376b55227549d

data/README.md

@@ -22,7 +22,7 @@ for high concurrency use.
 
 ### Client
 
-    client = GQTP::Client.new(:address => "192.168.0.1", :port => 10041)
+    client = GQTP::Client.new(:host => "192.168.0.1", :port => 10043)
     request = client.send("status") do |header, body|
       p body # => "{\"alloc_count\":163,...}"
     end
@@ -30,7 +30,7 @@ for high concurrency use.
 
 ### Server
 
-    server = GQTP::Server.new(:address => "192.168.0.1", :port => 10041)
+    server = GQTP::Server.new(:host => "192.168.0.1", :port => 10043)
     server.on_request do |request, client|
       body = "{\"alloc_count\":163,...}"
       header = GQTP::Header.new
@@ -45,10 +45,10 @@ for high concurrency use.
 
 ### Proxy
 
-    proxy = GQTP::Proxy.new(:listen_address => "127.0.0.1",
-                            :listen_port => 10041,
-                            :upstream_address => "192.168.0.1",
-                            :upstream_port => 10041)
+    proxy = GQTP::Proxy.new(:listen_host => "127.0.0.1",
+                            :listen_port => 10043,
+                            :upstream_host => "192.168.0.1",
+                            :upstream_port => 10043)
     proxy.run.wait
 
 ## Dependencies

data/bin/gqtp-proxy

@@ -1,6 +1,6 @@
-# -*- coding: utf-8 -*-
+# -*- coding: utf-8; mode: ruby -*-
 #
-# Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2012-2014  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
@@ -22,39 +22,40 @@ require "ostruct"
 require "gqtp"
 
 options = OpenStruct.new
-options.listen_address = "0.0.0.0"
-options.listen_port = 10041
-options.upstream_address = nil
-options.upstream_port = 10041
+options.listen_host = "0.0.0.0"
+options.listen_port = 10043
+options.upstream_host = nil
+options.upstream_port = 10043
 options.backend = :thread
 
 parser = OptionParser.new
-parser.on("--listen-address=ADDRESS",
-          "IP address or host name to listen",
-          "(#{options.listen_address})") do |address|
-  options.listen_address = address
+parser.on("--listen-host=HOST",
+          "IP host or host name to listen",
+          "(#{options.listen_host})") do |host|
+  options.listen_host = host
 end
 parser.on("--listen-port=PORT", Integer,
           "Port number to listen",
           "(#{options.listen_port})") do |port|
   options.listen_port = port
 end
-parser.on("--upstream-address=ADDRESS",
-          "IP address or host name of upstream",
-          "(#{options.upstream_address})") do |address|
-  options.upstream_address = address
+parser.on("--upstream-host=HOST",
+          "IP host or host name of upstream",
+          "(#{options.upstream_host})") do |host|
+  options.upstream_host = host
 end
 parser.on("--upstream-port=PORT", Integer,
           "Port number of upstream",
           "(#{options.upstream_port})") do |port|
   options.upstream_port = port
 end
-available_backends = ["thread", "synchronous", "coolio"].join(", ")
-parser.on("--backend=BACKEND",
+available_backends = [:thread, :synchronous, :coolio, :eventmachine]
+available_backends_label = available_backends.join(", ")
+parser.on("--backend=BACKEND", available_backends,
           "Use BACKEND for connection",
-          "[#{available_backends}]",
+          "[#{available_backends_label}]",
           "(#{options.backend})") do |backend|
-  options.backend = backend.to_sym
+  options.backend = backend
 end
 
 begin
@@ -64,14 +65,24 @@ rescue OptionParser::ParseError
   exit(false)
 end
 
-if options.upstream_address.nil?
-  puts("--upstream-address is required.")
+if options.upstream_host.nil?
+  puts("--upstream-host is required.")
   exit(false)
 end
 
-proxy = GQTP::Proxy.new(:listen_address => options.listen_address,
+proxy = GQTP::Proxy.new(:listen_host => options.listen_host,
                         :listen_port => options.listen_port,
-                        :upstream_address => options.upstream_address,
+                        :upstream_host => options.upstream_host,
                         :upstream_port => options.upstream_port,
-                        :connection => options.backend)
-proxy.run.wait
+                        :backend => options.backend)
+begin
+  if options.backend == :eventmachine
+    require "eventmachine"
+    EventMachine.run do
+      proxy.run
+    end
+  else
+    proxy.run.wait
+  end
+rescue Interrupt
+end

data/doc/text/news.md

@@ -1,5 +1,23 @@
 # News
 
+## 1.0.6: 2014-03-25
+
+### Improvements
+
+  * Added EventMachine backend.
+
+### Changes
+
+  * Changed the default port number to 10043 from 10041 because GQTP
+    server packages use 10043.
+  * Changed error class when unknown connection type is specified to
+    `GQTP::Client.new` to `ArgumentError` from `RuntimeError`.
+  * Wrapped internal error to `GQTP::ConnectionError`.
+  * Changed `:address` keyword to `:host` in `GQTP::Client.new`.
+    `:address` is still usable but it is deprecated.
+  * Changed connection backend module/directory name to `backend` from
+    `connection`.
+
 ## 1.0.5: 2013-09-18
 
 ### Improvements

data/lib/gqtp/{connection → backend}/coolio.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2012-2014  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
@@ -19,7 +19,7 @@
 require "cool.io"
 
 module GQTP
-  module Connection
+  module Backend
     module Coolio
       class Request
         def initialize(loop)
@@ -83,13 +83,13 @@ module GQTP
       end
 
       class Client
-        attr_accessor :address, :port
+        attr_accessor :host, :port
         def initialize(options={})
           @options = options
-          @address = options[:address] || "127.0.0.1"
-          @port = options[:port] || 10041
+          @host = options[:host] || "127.0.0.1"
+          @port = options[:port] || 10043
           @loop = options[:loop] || ::Coolio::Loop.default
-          @socket = Socket.connect(@address, @port)
+          @socket = Socket.connect(@host, @port)
           @socket.attach(@loop)
         end
 
@@ -107,16 +107,16 @@ module GQTP
       end
 
       class Server
-        attr_accessor :address, :port
+        attr_accessor :host, :port
         def initialize(options={})
           @options = options
-          @address = options[:address] || "0.0.0.0"
-          @port = options[:port] || 10041
+          @host = options[:host] || "0.0.0.0"
+          @port = options[:port] || 10043
           @loop = options[:loop] || ::Coolio::Loop.default
         end
 
         def run
-          @server = ::Coolio::TCPServer.new(@address, @port, Socket) do |client|
+          @server = ::Coolio::TCPServer.new(@host, @port, Socket) do |client|
             yield(client)
           end
           @server.attach(@loop)

data/lib/gqtp/backend/eventmachine.rb

@@ -0,0 +1,134 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014  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
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "eventmachine"
+
+module GQTP
+  module Backend
+    module Eventmachine
+      class Request
+        def wait
+          # Do nothing
+        end
+      end
+
+      module Handler
+        def post_init
+          @read_callbacks = []
+          @buffer = "".force_encoding("ASCII-8BIT")
+        end
+
+        def write(*chunks, &block)
+          chunks.each do |chunk|
+            send_data(chunk)
+          end
+          if block_given?
+            block.call
+          else
+            Request.new
+          end
+        end
+
+        def read(size, &block)
+          if @buffer.bytesize >= size
+            consume_data(size, block)
+          else
+            @read_callbacks << [size, block]
+          end
+          if block_given?
+            nil
+          else
+            Request.new
+          end
+        end
+
+        def receive_data(data)
+          @buffer << data
+          until @read_callbacks.empty?
+            size, callback = @read_callbacks.first
+            break if @buffer.bytesize < size
+            @read_callbacks.shift
+            consume_data(size, callback)
+          end
+        end
+
+        private
+        def consume_data(size, callback)
+          data = @buffer[0, size]
+          @buffer = @buffer[size..-1]
+          callback.call(data)
+        end
+      end
+
+      class Client
+        attr_accessor :host, :port
+        def initialize(options={})
+          @options = options
+          @host = options[:host] || "127.0.0.1"
+          @port = options[:port] || 10043
+          @connection = EventMachine.connect(@host, @port, Handler)
+        end
+
+        def write(*chunks, &block)
+          @connection.write(*chunks, &block)
+        end
+
+        def read(size, &block)
+          @connection.read(size, &block)
+        end
+
+        def close
+          @connection.close_connection_after_writing
+        end
+      end
+
+      module ServerHandler
+        include Handler
+
+        def initialize(client_handler)
+          super()
+          @client_handler = client_handler
+        end
+
+        def post_init
+          super
+          @client_handler.call(self)
+        end
+      end
+
+      class Server
+        attr_accessor :host, :port
+        def initialize(options={})
+          @options = options
+          @host = options[:host] || "0.0.0.0"
+          @port = options[:port] || 10043
+        end
+
+        def run(&block)
+          @signature =
+            EventMachine.start_server(@host, @port, ServerHandler, block)
+          Request.new
+        end
+
+        def shutdown
+          EventMachine.stop_server(@signature)
+        end
+      end
+    end
+  end
+end

data/lib/gqtp/{connection → backend}/synchronous.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2012-2014  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
@@ -17,7 +17,7 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 module GQTP
-  module Connection
+  module Backend
     module Synchronous
       class Request
         def initialize(data)
@@ -58,12 +58,16 @@ module GQTP
       end
 
       class Client
-        attr_accessor :address, :port
+        attr_accessor :host, :port
         def initialize(options={})
           @options = options
-          @address = options[:address] || "127.0.0.1"
-          @port = options[:port] || 10041
-          @socket = TCPSocket.open(@address, @port)
+          @host = options[:host] || "127.0.0.1"
+          @port = options[:port] || 10043
+          begin
+            @socket = TCPSocket.open(@host, @port)
+          rescue SystemCallError
+            raise ConnectionError.new(@host, @port, $!)
+          end
           @io = IO.new(@socket)
         end
 
@@ -81,16 +85,16 @@ module GQTP
       end
 
       class Server
-        attr_accessor :address, :port
+        attr_accessor :host, :port
         def initialize(options={})
           @options = options
-          @address = options[:address] || "0.0.0.0"
-          @port = options[:port] || 10041
+          @host = options[:host] || "0.0.0.0"
+          @port = options[:port] || 10043
           @backlog = options[:backlog] || 128
         end
 
         def run
-          @server = TCPServer.new(@address, @port)
+          @server = TCPServer.new(@host, @port)
           @server.listen(@backlog)
           loop do
             client = @server.accept

data/lib/gqtp/{connection → backend}/thread.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2012-2014  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
@@ -20,7 +20,7 @@ require "socket"
 require "thread"
 
 module GQTP
-  module Connection
+  module Backend
     module Thread
       class Request
         def initialize(thread)
@@ -69,12 +69,16 @@ module GQTP
       end
 
       class Client
-        attr_accessor :address, :port
+        attr_accessor :host, :port
         def initialize(options={})
           @options = options
-          @address = options[:address] || "127.0.0.1"
-          @port = options[:port] || 10041
-          @socket = TCPSocket.open(@address, @port)
+          @host = options[:host] || "127.0.0.1"
+          @port = options[:port] || 10043
+          begin
+            @socket = TCPSocket.open(@host, @port)
+          rescue SystemCallError
+            raise ConnectionError.new(@host, @port, $!)
+          end
           @io = IO.new(@socket)
         end
 
@@ -92,16 +96,16 @@ module GQTP
       end
 
       class Server
-        attr_accessor :address, :port
+        attr_accessor :host, :port
         def initialize(options={})
           @options = options
-          @address = options[:address] || "0.0.0.0"
-          @port = options[:port] || 10041
+          @host = options[:host] || "0.0.0.0"
+          @port = options[:port] || 10043
           @backlog = options[:backlog] || 128
         end
 
         def run
-          @server = TCPServer.new(@address, @port)
+          @server = TCPServer.new(@host, @port)
           @server.listen(@backlog)
           thread = ::Thread.new do
             loop do

data/lib/gqtp/client.rb

@@ -21,12 +21,12 @@ require "gqtp/sequential-request"
 
 module GQTP
   class Client
-    attr_accessor :address, :port
+    attr_accessor :host, :port
     def initialize(options={})
       @options = options.dup
-      @options[:address] ||= "127.0.0.1"
-      @options[:port] ||= 10041
-      @connection = create_connection
+      @options[:host] ||= @options[:address] || "127.0.0.1"
+      @options[:port] ||= 10043
+      @backend = create_backend
     end
 
     def send(body, options={}, &block)
@@ -35,13 +35,13 @@ module GQTP
 
       if block_given?
         sequential_request = SequentialRequest.new
-        write_request = @connection.write(header.pack, body) do
+        write_request = @backend.write(header.pack, body) do
           sequential_request << read(&block)
         end
         sequential_request << write_request
         sequential_request
       else
-        @connection.write(header.pack, body)
+        @backend.write(header.pack, body)
       end
     end
 
@@ -51,9 +51,9 @@ module GQTP
       response_body = nil
 
       sequential_request = SequentialRequest.new
-      read_header_request = @connection.read(Header.size) do |header|
+      read_header_request = @backend.read(Header.size) do |header|
         parser << header
-        read_body_request = @connection.read(parser.header.size) do |body|
+        read_body_request = @backend.read(parser.header.size) do |body|
           response_body = body
           yield(parser.header, response_body) if block_given?
         end
@@ -88,11 +88,8 @@ module GQTP
       sync = !block_given?
       sequential_request = SequentialRequest.new
       quit_request = send("quit", :header => header_for_close) do
-        ack_request = send("ACK", :header => header_for_close) do
-          @connection.close
-          yield if block_given?
-        end
-        sequential_request << ack_request
+        @backend.close
+        yield if block_given?
       end
       sequential_request << quit_request
 
@@ -105,18 +102,19 @@ module GQTP
     end
 
     private
-    def create_connection
-      connection = @options[:connection] || :thread
+    def create_backend
+      # :connection is just for backward compatibility.
+      backend = @options[:backend] || @options[:connection] || :thread
 
       begin
-        require "gqtp/connection/#{connection}"
+        require "gqtp/backend/#{backend}"
       rescue LoadError
-        raise "unknown connection: <#{connection.inspect}>"
+        raise ArgumentError, "unknown backend: <#{backend.inspect}>: #{$!}"
       end
 
-      module_name = connection.to_s.capitalize
-      connection_module = GQTP::Connection::const_get(module_name)
-      connection_module::Client.new(@options)
+      module_name = backend.to_s.capitalize
+      backend_module = GQTP::Backend.const_get(module_name)
+      backend_module::Client.new(@options)
     end
 
     def header_for_close

data/lib/gqtp/error.rb

@@ -16,9 +16,20 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-require "gqtp/header"
-
 module GQTP
   class Error < StandardError
   end
+
+  class ConnectionError < Error
+    attr_reader :host
+    attr_reader :port
+    attr_reader :detail
+    def initialize(host, port, detail)
+      @host = host
+      @port    = port
+      @detail  = detail
+      super("Failed to connect to <#{@host}:#{@port}>: " +
+              "#{@detail.message} (#{@detail.class})")
+    end
+  end
 end

data/lib/gqtp/proxy.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2012-2013  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2012-2014  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
@@ -20,29 +20,32 @@ require "gqtp/server"
 
 module GQTP
   class Proxy
-    attr_accessor :listen_address, :listen_port
-    attr_accessor :upstream_address, :upstream_port
+    attr_accessor :listen_host, :listen_port
+    attr_accessor :upstream_host, :upstream_port
     def initialize(options={})
       @options = options.dup
-      @listen_address = @options[:listen_address] || "0.0.0.0"
-      @listen_port = @options[:listen_port] || 10041
-      @upstream_address = @options[:upstream_address] || "127.0.0.1"
-      @upstream_port = @options[:upstream_port] || 10041
-      @connection = @options[:connection] || :thread
-      @server = Server.new(:address => @listen_address,
+      @listen_host = @options[:listen_host] || @options[:listen_address]
+      @listen_host ||= "0.0.0.0"
+      @listen_port = @options[:listen_port] || 10043
+      @upstream_host = @options[:upstream_host] || @options[:upstream_address]
+      @upstream_host ||= "127.0.0.1"
+      @upstream_port = @options[:upstream_port] || 10043
+      # :connection is just for backward compatibility.
+      @backend = @options[:backend] || @options[:connection] || :thread
+      @server = Server.new(:host => @listen_host,
                            :port => @listen_port,
-                           :connection => @connection)
+                           :backend => @backend)
     end
 
     def run
       @server.on_connect do |client|
-        create_connection
+        create_backend
       end
-      @server.on_request do |request, client, connection|
-        connection.write(request.header.pack, request.body) do
-          connection.read(Header.size) do |header|
+      @server.on_request do |request, client, backend|
+        backend.write(request.header.pack, request.body) do
+          backend.read(Header.size) do |header|
             response_header = Header.parse(header)
-            connection.read(response_header.size) do |body|
+            backend.read(response_header.size) do |body|
               client.write(header, body) do
               end
             end
@@ -57,18 +60,18 @@ module GQTP
     end
 
     private
-    def create_connection
+    def create_backend
       begin
-        require "gqtp/connection/#{@connection}"
+        require "gqtp/backend/#{@backend}"
       rescue LoadError
-        raise "unknown connection: <#{@connection.inspect}>"
+        raise ArgumentError, "unknown backend: <#{@backend.inspect}>: #{$!}"
       end
 
-      require "gqtp/connection/#{@connection}"
-      module_name = @connection.to_s.capitalize
-      connection_module = GQTP::Connection::const_get(module_name)
-      connection_module::Client.new(:address => @upstream_address,
-                                    :port => @upstream_port)
+      require "gqtp/backend/#{@backend}"
+      module_name = @backend.to_s.capitalize
+      backend_module = GQTP::Backend::const_get(module_name)
+      backend_module::Client.new(:host => @upstream_host,
+                                 :port => @upstream_port)
     end
   end
 end

data/lib/gqtp/server.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2012-2013  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2012-2014  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
@@ -20,24 +20,24 @@ require "gqtp/header"
 
 module GQTP
   class Server
-    attr_accessor :address, :port
+    attr_accessor :host, :port
     def initialize(options={})
       @options = options.dup
-      @options[:address] ||= "0.0.0.0"
-      @options[:port] ||= 10041
+      @options[:host] ||= @options[:address] || "0.0.0.0"
+      @options[:port] ||= 10043
       @on_request = nil
       @on_connect = nil
     end
 
     def run
-      @connection = create_connection
-      @connection.run do |client|
+      @backend = create_backend
+      @backend.run do |client|
         process_request(client, on_connect(client))
       end
     end
 
     def shutdown
-      @connection.shutdown
+      @backend.shutdown
     end
 
     def on_connect(*arguments, &block)
@@ -63,18 +63,19 @@ module GQTP
     end
 
     private
-    def create_connection
-      connection = @options[:connection] || :thread
+    def create_backend
+      # :connection is just for backward compatibility.
+      backend = @options[:backend] || @options[:connection] || :thread
 
       begin
-        require "gqtp/connection/#{connection}"
+        require "gqtp/backend/#{backend}"
       rescue LoadError
-        raise "unknown connection: <#{connection.inspect}>"
+        raise ArgumentError, "unknown backend: <#{backend.inspect}>: #{$!}"
       end
 
-      module_name = connection.to_s.capitalize
-      connection_module = GQTP::Connection::const_get(module_name)
-      connection_module::Server.new(@options)
+      module_name = backend.to_s.capitalize
+      backend_module = GQTP::Backend::const_get(module_name)
+      backend_module::Server.new(@options)
     end
 
     def process_request(client, connect_info)

data/lib/gqtp/version.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2012-2013  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
@@ -17,5 +17,5 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 module GQTP
-  VERSION = "1.0.5"
+  VERSION = "1.0.6"
 end

data/test/test-client.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2012-2013  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2012-2014  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
@@ -21,80 +21,97 @@ require "socket"
 require "gqtp/client"
 
 class ClientTest < Test::Unit::TestCase
-  def setup
-    @address = "127.0.0.1"
-    @server = TCPServer.new(@address, 0)
-    @port = @server.addr[1]
-
-    @request_body = nil
-    @response_body = nil
-    @thread = Thread.new do
-      client = @server.accept
-      @server.close
-
-      process_client(client)
+  class CreateBackendTest < self
+    def test_unknown
+      message = "unknown backend: <\"unknown\">: " +
+        "cannot load such file -- gqtp/backend/unknown"
+      assert_raise(ArgumentError.new(message)) do
+        GQTP::Client.new(:backend => "unknown")
+      end
+    end
 
-      client.close
+    def test_no_server
+      server = TCPServer.new("127.0.0.1", 0)
+      free_port = server.addr[1]
+      server.close
+      assert_raise(GQTP::ConnectionError) do
+        GQTP::Client.new(:port => free_port)
+      end
     end
   end
 
-  def teardown
-    @thread.kill
-  end
+  class RequestTest < self
+    def setup
+      @host = "127.0.0.1"
+      @server = TCPServer.new(@host, 0)
+      @port = @server.addr[1]
 
-  def test_sync
-    @response_body = "[false]"
-    client = GQTP::Client.new(:address => @address, :port => @port)
-    client.send("status")
-    header, body = client.read
-    assert_equal(["status",      @response_body.bytesize, @response_body],
-                 [@request_body, header.size,             body])
-  end
+      @request_body = nil
+      @response_body = nil
+      @thread = Thread.new do
+        client = @server.accept
+        @server.close
+
+        process_client(client)
 
-  def test_async
-    @response_body = "[false]"
-    client = GQTP::Client.new(:address => @address, :port => @port)
-    request = client.send("status") do |header, body|
-      assert_equal(["status",      @response_body.bytesize, @response_body],
-                   [@request_body, header.size,             body])
+        client.close
+      end
     end
-    request.wait
-  end
 
-  private
-  def process_client(client)
-    header = GQTP::Header.parse(client.read(GQTP::Header.size))
-    @request_body = client.read(header.size)
+    def teardown
+      @thread.kill
+    end
 
-    response_header = GQTP::Header.new
-    response_header.size = @response_body.bytesize
-    client.write(response_header.pack)
-    client.write(@response_body)
-  end
+    private
+    def process_client(client)
+      header = GQTP::Header.parse(client.read(GQTP::Header.size))
+      @request_body = client.read(header.size)
 
-  class CloseTest < self
-    def test_sync
-      @response_body = "[]"
-      client = GQTP::Client.new(:address => @address, :port => @port)
-      assert_true(client.close)
+      response_header = GQTP::Header.new
+      response_header.size = @response_body.bytesize
+      client.write(response_header.pack)
+      client.write(@response_body)
     end
 
-    def test_async
-      @response_body = "[]"
-      client = GQTP::Client.new(:address => @address, :port => @port)
-      closed = false
-      close_request = client.close do
-        closed = true
+    class SendTest < self
+      def test_sync
+        @response_body = "[false]"
+        client = GQTP::Client.new(:host => @host, :port => @port)
+        client.send("status")
+        header, body = client.read
+        assert_equal(["status",      @response_body.bytesize, @response_body],
+                     [@request_body, header.size,             body])
+      end
+
+      def test_async
+        @response_body = "[false]"
+        client = GQTP::Client.new(:host => @host, :port => @port)
+        request = client.send("status") do |header, body|
+          assert_equal(["status",      @response_body.bytesize, @response_body],
+                       [@request_body, header.size,             body])
+        end
+        request.wait
       end
-      assert_false(closed)
-      close_request.wait
-      assert_true(closed)
     end
 
-    private
-    def process_client(client)
-      super(client)
-      super(client)
+    class CloseTest < self
+      def test_sync
+        @response_body = "[]"
+        client = GQTP::Client.new(:host => @host, :port => @port)
+        assert_true(client.close)
+      end
+
+      def test_async
+        @response_body = "[]"
+        client = GQTP::Client.new(:host => @host, :port => @port)
+        closed = false
+        close_request = client.close do
+          closed = true
+        end
+        assert_false(closed)
+        close_request.wait
+        assert_true(closed)
+      end
     end
   end
 end

metadata

@@ -1,119 +1,103 @@
 --- !ruby/object:Gem::Specification
 name: gqtp
 version: !ruby/object:Gem::Version
-  version: 1.0.5
-  prerelease: 
+  version: 1.0.6
 platform: ruby
 authors:
 - Kouhei Sutou
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-18 00:00:00.000000000 Z
+date: 2014-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: test-unit-notify
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: packnga
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: redcarpet
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: ! 'Gqtp gem provides both GQTP client, GQTP server and GQTP proxy
-
+description: |
+  Gqtp gem provides both GQTP client, GQTP server and GQTP proxy
   implementations. They provide asynchronous API. You can use gqtp gem
-
   for high concurrency use.
-
-'
 email:
 - kou@clear-code.com
 executables:
@@ -131,11 +115,12 @@ files:
 - lib/gqtp/error.rb
 - lib/gqtp/version.rb
 - lib/gqtp/proxy.rb
+- lib/gqtp/backend/coolio.rb
+- lib/gqtp/backend/thread.rb
+- lib/gqtp/backend/synchronous.rb
+- lib/gqtp/backend/eventmachine.rb
 - lib/gqtp/sequential-request.rb
 - lib/gqtp/server.rb
-- lib/gqtp/connection/coolio.rb
-- lib/gqtp/connection/thread.rb
-- lib/gqtp/connection/synchronous.rb
 - lib/gqtp/client.rb
 - lib/gqtp.rb
 - doc/text/news.md
@@ -149,27 +134,26 @@ files:
 homepage: https://github.com/ranguba/gqtp
 licenses:
 - LGPLv2.1 or later
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.14
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Gqtp gem is a [GQTP (Groonga Query Transfer Protocol)](http://groonga.org/docs/spec/gqtp.html)
   Ruby implementation.
 test_files: