droonga-client 0.1.5 → 0.1.6

data/bin/droonga-send

@@ -37,6 +37,7 @@ def parse_server(server)
     :host     => host,
     :port     => Integer(port),
     :protocol => protocol.to_sym,
+    :tag      => tag,
   }
 end
 

data/doc/text/news.md

@@ -1,5 +1,9 @@
 # News
 
+## 0.1.6: 2014-04-29 (planned)
+
+ * Supports droonga's protocol.
+
 ## 0.1.5: 2014-03-29
 
 ### Improvements

data/droonga-client.gemspec

@@ -39,6 +39,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "fluent-logger"
   spec.add_runtime_dependency "rack"
   spec.add_runtime_dependency "yajl-ruby"
+  spec.add_runtime_dependency "droonga-message-pack-packer"
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"

data/lib/droonga/client/connection/droonga-protocol.rb

@@ -15,36 +15,18 @@
 # 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 "socket"
-require "thread"
-require "msgpack"
-require "fluent-logger"
+require "droonga/client/connection/error"
 
 module Droonga
   class Client
     module Connection
       class DroongaProtocol
-        class Request
-          def initialize(thread)
-            @thread = thread
-          end
-
-          def wait
-            @thread.join
-          end
-        end
-
         def initialize(options={})
-          default_options = {
-            :tag     => "droonga",
-            :host    => "127.0.0.1",
-            :port    => 24224,
-            :timeout => 1,
-          }
-          @options = default_options.merge(options)
-          @logger = Fluent::Logger::FluentLogger.new(@options.delete(:tag),
-                                                     @options)
-          @timeout = @options[:timeout]
+          @host = options[:host] || "127.0.0.1"
+          @port = options[:port] || 24224
+          @tag = options[:tag] || "droonga"
+          @options = options
+          @backend = create_backend
         end
 
         # Sends a request message and receives one or more response
@@ -72,28 +54,7 @@ module Droonga
         #
         #   @return [Request] The request object.
         def request(message, options={}, &block)
-          receiver = create_receiver
-          message = message.dup
-          message["replyTo"] = "#{receiver.host}:#{receiver.port}/droonga"
-          send(message, options)
-
-          sync = block.nil?
-          if sync
-            responses = []
-            receive(receiver, options) do |response|
-              responses << response
-            end
-            if responses.size > 1
-              responses
-            else
-              responses.first
-            end
-          else
-            thread = Thread.new do
-              receive(receiver, options, &block)
-            end
-            Request.new(thread)
-          end
+          @backend.request(message, options, &block)
         end
 
         # Subscribes something and receives zero or more published
@@ -123,35 +84,7 @@ module Droonga
         #
         #   @return [Request] The request object.
         def subscribe(message, options={}, &block)
-          receiver = create_receiver
-          message = message.dup
-          message["from"] = "#{receiver.host}:#{receiver.port}/droonga"
-          send(message, options)
-
-          receive_options = {
-            :timeout => nil,
-          }
-          sync = block.nil?
-          if sync
-            Enumerator.new do |yielder|
-              loop do
-                receiver.receive(receive_options) do |object|
-                  yielder << object
-                end
-              end
-            end
-          else
-            thread = Thread.new do
-              begin
-                loop do
-                  receiver.receive(receive_options, &block)
-                end
-              ensure
-                receiver.close
-              end
-            end
-            Request.new(thread)
-          end
+          @backend.subscribe(message, options, &block)
         end
 
         # Sends low level request. Normally, you should use other
@@ -162,114 +95,31 @@ module Droonga
         #   TODO: WRITE ME
         # @return [void]
         def send(message, options={}, &block)
-          if message["id"].nil? or message["date"].nil?
-            message = message.merge("id"   => Time.now.to_f.to_s,
-                                    "date" => Time.now)
-          end
-          @logger.post("message", message)
+          @backend.send(message, options, &block)
         end
 
         # Close the connection. This connection can't be used anymore.
         #
         # @return [void]
         def close
-          @logger.close
+          @backend.close
         end
 
         private
-        def create_receiver
-          Receiver.new(:host => @options[:receiver_host],
-                       :port => @options[:receiver_port])
-        end
-
-        def receive(receiver, options)
-          timeout = options[:timeout] || @timeout
+        def create_backend
+          backend = @options[:backend] || :thread
 
-          receive_options = {
-            :timeout => timeout,
-          }
           begin
-            receiver.receive(receive_options) do |response|
-              yield(response)
-            end
-          ensure
-            receiver.close
-          end
-        end
-
-        class Receiver
-          def initialize(options={})
-            host = options[:host] || Socket.gethostname
-            port = options[:port] || 0
-            @socket = TCPServer.new(host, port)
-            @read_ios = [@socket]
-            @client_handlers = {}
-          end
-
-          def close
-            @socket.close
-            @client_handlers.each_key do |client|
-              client.close
-            end
-          end
-
-          def host
-            @socket.addr[3]
-          end
-
-          def port
-            @socket.addr[1]
+            require "droonga/client/connection/droonga-protocol/#{backend}"
+          rescue LoadError
+            raise UnknownBackendError.new("Droonga protocol",
+                                          backend,
+                                          $!.message)
           end
 
-          BUFFER_SIZE = 8192
-          def receive(options={}, &block)
-            timeout = options[:timeout]
-            catch do |tag|
-              loop do
-                start = Time.new
-                readable_ios, = IO.select(@read_ios, nil, nil, timeout)
-                break if readable_ios.nil?
-                if timeout
-                  timeout -= (Time.now - start)
-                  timeout = 0 if timeout < 0
-                end
-                readable_ios.each do |readable_io|
-                  on_readable(readable_io) do |object|
-                    begin
-                      yield(object)
-                    rescue LocalJumpError
-                      throw(tag)
-                    end
-                  end
-                end
-              end
-            end
-          end
-
-          private
-          def on_readable(io)
-            case io
-            when @socket
-              client = @socket.accept
-              @read_ios << client
-              @client_handlers[client] = lambda do
-                unpacker = MessagePack::Unpacker.new
-                loop do
-                  readable, = IO.select([client], nil, nil, 0)
-                  break unless readable
-                  data = client.read_nonblock(BUFFER_SIZE)
-                  unpacker.feed_each(data) do |object|
-                    yield(object)
-                  end
-                end
-                client.close
-                @read_ios.delete(client)
-                @client_handlers.delete(client)
-              end
-            else
-              @client_handlers[io].call
-            end
-          end
+          backend_name = backend.to_s.capitalize
+          backend_class = self.class.const_get(backend_name)
+          backend_class.new(@host, @port, @tag, @options)
         end
       end
     end

data/lib/droonga/client/connection/droonga-protocol/coolio.rb

@@ -0,0 +1,232 @@
+# Copyright (C) 2014 Droonga Project
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+require "coolio"
+require "droonga/message-pack-packer"
+
+module Droonga
+  class Client
+    module Connection
+      class DroongaProtocol
+        class Coolio
+          class Request
+            def initialize(receiver, id, loop)
+              @receiver = receiver
+              @id = id
+              @loop = loop
+            end
+
+            def wait
+              return if @receiver.received?(@id)
+              until @receiver.received?(@id)
+                @loop.run_once
+              end
+            end
+          end
+
+          class InfiniteRequest
+            def initialize(loop)
+              @loop = loop
+            end
+
+            def wait
+              @loop.run
+            end
+          end
+
+          class Sender < ::Coolio::TCPSocket
+            def initialize(socket)
+              super(socket)
+            end
+
+            def send(tag, data)
+              fluent_message = [tag, Time.now.to_i, data]
+              packed_fluent_message = MessagePackPacker.pack(fluent_message)
+              write(packed_fluent_message)
+            end
+          end
+
+          class Receiver < ::Coolio::TCPServer
+            def initialize(*args)
+              super(*args) do |engine|
+                @engines << engine
+                handle_engine(engine)
+              end
+              @requests = {}
+              @engines = []
+            end
+
+            def close
+              super
+              @engines.each do |engine|
+                engine.close
+              end
+              @engines.clear
+            end
+
+            def host
+              @listen_socket.addr[3]
+            end
+
+            def port
+              @listen_socket.addr[1]
+            end
+
+            def droonga_name
+              "#{host}:#{port}/droonga"
+            end
+
+            def register(id, &callback)
+              @requests[id] = {
+                :received => false,
+                :callback => callback,
+              }
+            end
+
+            def unregister(id)
+              @requests.delete(id)
+            end
+
+            def received?(id)
+              if @requests.key?(id)
+                @requests[id][:received]
+              else
+                true
+              end
+            end
+
+            private
+            def handle_engine(engine)
+              unpacker = MessagePack::Unpacker.new
+              on_read = lambda do |data|
+                unpacker.feed_each(data) do |fluent_message|
+                  tag, time, droonga_message = fluent_message
+                  id = droonga_message["inReplyTo"]
+                  request = @requests[id]
+                  next if request.nil?
+                  request[:received] = true
+                  request[:callback].call(droonga_message)
+                end
+              end
+              engine.on_read do |data|
+                on_read.call(data)
+              end
+
+              on_close = lambda do
+                @engines.delete(engine)
+              end
+              engine.on_close do
+                on_close.call
+              end
+            end
+          end
+
+          def initialize(host, port, tag, options={})
+            @host = host
+            @port = port
+            @tag = tag
+            default_options = {
+            }
+            @options = default_options.merge(options)
+            @loop = options[:loop] || ::Coolio::Loop.default
+
+            @sender = Sender.connect(@host, @port)
+            @sender.attach(@loop)
+            @receiver_host = @options[:receiver_host] || Socket.gethostname
+            @receiver_port = @options[:receiver_port] || 0
+            @receiver = Receiver.new(@receiver_host, @receiver_port)
+            @receiver.attach(@loop)
+          end
+
+          def request(message, options={}, &block)
+            id = message["id"] || generate_id
+            message = message.merge("id" => id,
+                                    "replyTo" => @receiver.droonga_name)
+            send(message, options)
+
+            sync = block.nil?
+            if sync
+              response = nil
+              block = lambda do |_response|
+                response = _response
+              end
+            end
+            @receiver.register(id) do |response|
+              @receiver.unregister(id)
+              block.call(response)
+            end
+            request = Request.new(@receiver, id, @loop)
+            if sync
+              request.wait
+              response
+            else
+              request
+            end
+          end
+
+          def subscribe(message, options={}, &block)
+            id = message["id"] || generate_id
+            message = message.merge("id" => id,
+                                    "from" => @receiver.droonga_name)
+            send(message, options)
+
+            request = InfiniteRequest.new(@loop)
+            sync = block.nil?
+            if sync
+              yielder = nil
+              buffer = []
+              @receiver.register(id) do |response|
+                if yielder
+                  while (old_response = buffer.shift)
+                    yielder << old_response
+                  end
+                  yielder << response
+                else
+                  buffer << response
+                end
+              end
+              Enumerator.new do |_yielder|
+                yielder = _yielder
+                request.wait
+              end
+            else
+              @receiver.register(id, &block)
+              request
+            end
+          end
+
+          def send(message, options={}, &block)
+            if message["id"].nil? or message["date"].nil?
+              id = message["id"] || generate_id
+              date = message["date"] || Time.now
+              message = message.merge("id" => id, "date" => date)
+            end
+            @sender.send("#{@tag}.message", message)
+          end
+
+          def close
+            @sender.close
+            @receiver.close
+          end
+
+          private
+          def generate_id
+            Time.now.to_f.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/droonga/client/connection/droonga-protocol/thread.rb

@@ -0,0 +1,217 @@
+# Copyright (C) 2013-2014 Droonga Project
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+require "socket"
+require "thread"
+require "msgpack"
+require "fluent-logger"
+
+module Droonga
+  class Client
+    module Connection
+      class DroongaProtocol
+        class Thread
+          class Request
+            def initialize(thread)
+              @thread = thread
+            end
+
+            def wait
+              @thread.join
+            end
+          end
+
+          def initialize(host, port, tag, options={})
+            @host = host
+            @port = port
+            @tag = tag
+            default_options = {
+              :timeout => 1,
+            }
+            @options = default_options.merge(options)
+            @logger = Fluent::Logger::FluentLogger.new(@tag, @options)
+            @timeout = @options[:timeout]
+          end
+
+          def request(message, options={}, &block)
+            receiver = create_receiver
+            message = message.dup
+            message["replyTo"] = "#{receiver.host}:#{receiver.port}/droonga"
+            send(message, options)
+
+            sync = block.nil?
+            if sync
+              responses = []
+              receive(receiver, options) do |response|
+                responses << response
+              end
+              if responses.size > 1
+                responses
+              else
+                responses.first
+              end
+            else
+              thread = ::Thread.new do
+                receive(receiver, options, &block)
+              end
+              Request.new(thread)
+            end
+          end
+
+          def subscribe(message, options={}, &block)
+            receiver = create_receiver
+            message = message.dup
+            message["from"] = "#{receiver.host}:#{receiver.port}/droonga"
+            send(message, options)
+
+            receive_options = {
+              :timeout => nil,
+            }
+            sync = block.nil?
+            if sync
+              Enumerator.new do |yielder|
+                loop do
+                  receiver.receive(receive_options) do |object|
+                    yielder << object
+                  end
+                end
+              end
+            else
+              thread = ::Thread.new do
+                begin
+                  loop do
+                    receiver.receive(receive_options, &block)
+                  end
+                ensure
+                  receiver.close
+                end
+              end
+              Request.new(thread)
+            end
+          end
+
+          def send(message, options={}, &block)
+            if message["id"].nil? or message["date"].nil?
+              message = message.merge("id"   => Time.now.to_f.to_s,
+                                      "date" => Time.now)
+            end
+            @logger.post("message", message)
+          end
+
+          def close
+            @logger.close
+          end
+
+          private
+          def create_receiver
+            Receiver.new(:host => @options[:receiver_host],
+                         :port => @options[:receiver_port])
+          end
+
+          def receive(receiver, options)
+            timeout = options[:timeout] || @timeout
+
+            receive_options = {
+              :timeout => timeout,
+            }
+            begin
+              receiver.receive(receive_options) do |response|
+                yield(response)
+              end
+            ensure
+              receiver.close
+            end
+          end
+
+          class Receiver
+            def initialize(options={})
+              host = options[:host] || Socket.gethostname
+              port = options[:port] || 0
+              @socket = TCPServer.new(host, port)
+              @read_ios = [@socket]
+              @client_handlers = {}
+            end
+
+            def close
+              @socket.close
+              @client_handlers.each_key do |client|
+                client.close
+              end
+            end
+
+            def host
+              @socket.addr[3]
+            end
+
+            def port
+              @socket.addr[1]
+            end
+
+            BUFFER_SIZE = 8192
+            def receive(options={}, &block)
+              timeout = options[:timeout]
+              catch do |tag|
+                loop do
+                  start = Time.new
+                  readable_ios, = IO.select(@read_ios, nil, nil, timeout)
+                  break if readable_ios.nil?
+                  if timeout
+                    timeout -= (Time.now - start)
+                    timeout = 0 if timeout < 0
+                  end
+                  readable_ios.each do |readable_io|
+                    on_readable(readable_io) do |object|
+                      begin
+                        yield(object)
+                      rescue LocalJumpError
+                        throw(tag)
+                      end
+                    end
+                  end
+                end
+              end
+            end
+
+            private
+            def on_readable(io)
+              case io
+              when @socket
+                client = @socket.accept
+                @read_ios << client
+                @client_handlers[client] = lambda do
+                  unpacker = MessagePack::Unpacker.new
+                  loop do
+                    readable, = IO.select([client], nil, nil, 0)
+                    break unless readable
+                    data = client.read_nonblock(BUFFER_SIZE)
+                    unpacker.feed_each(data) do |fluent_message|
+                      tag, time, droonga_message = fluent_message
+                      yield(droonga_message)
+                    end
+                  end
+                  client.close
+                  @read_ios.delete(client)
+                  @client_handlers.delete(client)
+                end
+              else
+                @client_handlers[io].call
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/droonga/client/connection/empty-request.rb

@@ -0,0 +1,28 @@
+# Copyright (C) 2014 Droonga Project
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+module Droonga
+  class Client
+    module Connection
+      class EmptyRequest
+        def initialize
+        end
+
+        def wait
+        end
+      end
+    end
+  end
+end

data/lib/droonga/client/connection/error.rb

@@ -23,6 +23,16 @@ module Droonga
       # The top error class of connection module.
       class Error < Client::Error
       end
+
+      class UnknownBackendError < Error
+        attr_reader :protocol
+        attr_reader :backend
+        def initialize(protocol, backend, detail)
+          @protocol = protocol
+          @backend = backend
+          super("Unknown #{@protocol} backend: <#{backend}>: #{detail}")
+        end
+      end
     end
   end
 end

data/lib/droonga/client/version.rb

@@ -17,6 +17,6 @@
 
 module Droonga
   class Client
-    VERSION = "0.1.5"
+    VERSION = "0.1.6"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: droonga-client
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-28 00:00:00.000000000 Z
+date: 2014-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
-  requirement: &76032510 !ruby/object:Gem::Requirement
+  requirement: &76464960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *76032510
+  version_requirements: *76464960
 - !ruby/object:Gem::Dependency
   name: fluent-logger
-  requirement: &76032280 !ruby/object:Gem::Requirement
+  requirement: &76464730 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *76032280
+  version_requirements: *76464730
 - !ruby/object:Gem::Dependency
   name: rack
-  requirement: &76032070 !ruby/object:Gem::Requirement
+  requirement: &76464520 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *76032070
+  version_requirements: *76464520
 - !ruby/object:Gem::Dependency
   name: yajl-ruby
-  requirement: &76031860 !ruby/object:Gem::Requirement
+  requirement: &76464310 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,21 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *76031860
+  version_requirements: *76464310
+- !ruby/object:Gem::Dependency
+  name: droonga-message-pack-packer
+  requirement: &76464100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *76464100
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &76031610 !ruby/object:Gem::Requirement
+  requirement: &76463850 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,10 +76,10 @@ dependencies:
         version: '1.3'
   type: :development
   prerelease: false
-  version_requirements: *76031610
+  version_requirements: *76463850
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &76031400 !ruby/object:Gem::Requirement
+  requirement: &76463640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +87,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *76031400
+  version_requirements: *76463640
 - !ruby/object:Gem::Dependency
   name: packnga
-  requirement: &76031170 !ruby/object:Gem::Requirement
+  requirement: &76463410 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,7 +98,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *76031170
+  version_requirements: *76463410
 description: Droonga client for Ruby
 email:
 - droonga@groonga.org
@@ -109,6 +120,9 @@ files:
 - droonga-client.gemspec
 - lib/droonga/client.rb
 - lib/droonga/client/connection/droonga-protocol.rb
+- lib/droonga/client/connection/droonga-protocol/coolio.rb
+- lib/droonga/client/connection/droonga-protocol/thread.rb
+- lib/droonga/client/connection/empty-request.rb
 - lib/droonga/client/connection/error.rb
 - lib/droonga/client/connection/http.rb
 - lib/droonga/client/error.rb