tarantool 0.3.0.7 → 0.4.2.1

data/lib/tarantool/block_db.rb

@@ -1,15 +1,101 @@
 module Tarantool
   class BlockDB < DB
-    def establish_connection
-      @connection = IProto.get_connection(@host, @port, :block)
+    IPROTO_CONNECTION_TYPE = :block
+
+    include ParseIProto
+    def _send_request(shard_numbers, read_write, response)
+      if @closed
+        response.cb.call ::IProto::Disconnected.new("Tarantool is closed")
+      else
+        response.call_callback begin
+          shard_numbers = shard_numbers[0]  if Array === shard_numbers && shard_numbers.size == 1
+          if Array === shard_numbers
+            _send_to_several_shards(shard_numbers, read_write, response)
+          else
+            _send_to_one_shard(shard_numbers, read_write, response)
+          end
+        end
+      end
+    end
+
+    def _send_to_one_shard(shard_number, read_write, response)
+      response.parse_response(
+        if (replicas = _shard(shard_number)).size == 1
+          _parse_iproto(replicas[0].send_request(response.request_type, response.body))
+        elsif read_write == :read
+          replicas = replicas.shuffle  if @replica_strategy == :round_robin
+          _one_shard_read(replicas, response.request_type, response.body)
+        else
+          _one_shard_write(replicas, response.request_type, response.body)
+        end
+      )
+    end
+
+    def _one_shard_read(replicas, request_type, body)
+      for conn in replicas
+        if conn.could_be_connected?
+          begin
+            res = _parse_iproto(conn.send_request(request_type, body))
+            raise res  if Exception === res
+            return res
+          rescue ::IProto::ConnectionError
+            # pass
+          end
+        end
+      end
+      raise ConnectionError, "no available connections"
+    end
+
+    def _one_shard_write(replicas, request_type, body)
+      i = replicas.size
+      while i > 0
+        conn = replicas[0]
+        if conn.could_be_connected?
+          begin
+            res = _parse_iproto(conn.send_request(request_type, body))
+            raise res  if Exception === res
+            return res
+          rescue ::IProto::ConnectionError, ::Tarantool::NonMaster
+            # pass
+          end
+        end
+        replicas.rotate!
+        i -= 1
+      end
+      raise NoMasterError, "no available master connections"
     end
 
-    def close_connection
-      @connection.close
+    def _send_to_several_shards(shard_numbers, read_write, response)
+      results = []
+      unless read_write == :replace
+        for shard in shard_numbers
+          res = _send_to_one_shard(shard, read_write, response)
+          Array === res ? results.concat(res) : results << res
+        end
+      else
+        for shard in shard_numbers
+          begin
+            res = _send_to_one_shard(shard, read_write, response)
+            Array === res ? results.concat(res) : results << res
+          rescue ::Tarantool::TupleDoesntExists => e
+            results << e
+          end
+        end
+
+        if results.all?{|r| ::Tarantool::TupleDoesntExists === r}
+          raise results.first
+        else
+          results.delete_if{|r| ::Tarantool::TupleDoesntExists === r}
+        end
+      end
+      if Integer === results.first
+        results = results.inject(0){|s, i| s + i}
+      end
+      results
     end
 
-    def _send_request(request_type, body, cb)
-      cb.call @connection.send_request(request_type, body)
+    def primary_interface
+      :synchronous
     end
 
     module CommonSpaceBlockingMethods
@@ -33,6 +119,10 @@ module Tarantool
         replace_cb(tuple, _block_cb, opts)
       end
 
+      def store(tuple, opts={})
+        store_cb(tuple, _block_cb, opts)
+      end
+
       def update(pk, operations, opts={})
         update_cb(pk, operations, _block_cb, opts)
       end
@@ -91,6 +181,10 @@ module Tarantool
     end
 
     class Query < ::Tarantool::Query
+      def _block_cb
+        @_block_cb ||= method(:_raise_or_return)
+      end
+
       def select(space_no, index_no, keys, offset, limit, opts={})
         select_cb(space_no, index_no, keys, offset, limit, _block_cb, opts)
       end
@@ -111,6 +205,10 @@ module Tarantool
         replace_cb(space_no, tuple, _block_cb, opts)
       end
 
+      def store(space_no, tuple, opts={})
+        store_cb(space_no, tuple, _block_cb, opts)
+      end
+
       def update(space_no, pk, operation, opts={})
         update_cb(space_no, pk, operation, _block_cb, opts)
       end

data/lib/tarantool/callback_db.rb

@@ -2,6 +2,10 @@ require 'tarantool/em_db'
 
 module Tarantool
   class CallbackDB < EMDB
+    def primary_interface
+      :callback
+    end
+
     class SpaceArray < ::Tarantool::SpaceArray
       alias by_pk        by_pk_blk
       alias all_by_key   all_by_key_blk
@@ -10,6 +14,7 @@ module Tarantool
       alias select       select_blk
       alias insert       insert_blk
       alias replace      replace_blk
+      alias store        store_blk
       alias update       update_blk
       alias delete       delete_blk
       alias invoke       invoke_blk
@@ -24,6 +29,7 @@ module Tarantool
       alias select  select_blk
       alias insert  insert_blk
       alias replace replace_blk
+      alias store   store_blk
       alias update  update_blk
       alias delete  delete_blk
       alias invoke  invoke_blk
@@ -37,6 +43,7 @@ module Tarantool
       alias first   first_blk
       alias insert  insert_blk
       alias replace replace_blk
+      alias store   store_blk
       alias update  update_blk
       alias delete  delete_blk
       alias invoke  invoke_blk

data/lib/tarantool/core-ext.rb

@@ -1,12 +1,28 @@
-require 'fiber'
+require 'iproto/core-ext'
 
-class Fiber
-  alias call resume
-end
+module Tarantool
+  module ClassAttribute
+    # spinoff from ActiveSupport class attribute
+    def t_class_attribute(*attrs)
+      attrs.each do |name|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def self.#{name}() nil end
+          def self.#{name}?() !!#{name} end
 
-module Kernel
-  def fiber_yield
-    Fiber.yield
+          def self.#{name}=(val)
+            singleton_class.class_eval do
+              begin
+                if method_defined?(:"#{name}") || private_method_defined?(:"#{name}")
+                  remove_method(:#{name})
+                end
+              rescue NameError
+              end
+              define_method(:#{name}) { val }
+            end
+            val
+          end
+        RUBY
+      end
+    end
   end
-  alias fyield fiber_yield
 end

data/lib/tarantool/em_db.rb

@@ -1,36 +1,205 @@
 module Tarantool
   class EMDB < DB
-    def establish_connection
-      @connection_waiters = []
-      EM.schedule do
-        unless @closed
-          @connection = IProto.get_connection(@host, @port, :em_callback)
-          while waiter = @connection_waiters.shift
-            _send_request(*waiter)
+    IPROTO_CONNECTION_TYPE = :em_callback
+    INITIAL = Object.new.freeze
+
+    class Curry1 < Struct.new(:obj, :arg)
+      def call
+        obj.call arg
+      end
+    end
+
+    class FeedResponse < Struct.new(:response)
+      def call(result)
+        if Exception === result
+          response.cb.call result
+        else
+          response.call_callback(result)
+        end
+      end
+    end
+
+    def _send_request(shard_numbers, read_write, response)
+      if @closed
+        exc =  ::IProto::Disconnected.new("Tarantool is closed")
+        if EM.reactor_running?
+          EM.next_tick Curry1.new(response.cb, exc)
+        else
+          response.cb.call exc
+        end
+      else
+        feed = FeedResponse.new(response)
+        shard_numbers = shard_numbers[0]  if Array === shard_numbers && shard_numbers.size == 1
+        if Array === shard_numbers
+          _send_to_several_shards(shard_numbers, read_write, response, feed)
+        else
+          _send_to_one_shard(shard_numbers, read_write, response, feed)
+        end
+      end
+    end
+
+    def _send_to_one_shard(shard_number, read_write, response, feed)
+      if (replicas = _shard(shard_number)).size == 1
+        replicas[0].send_request(response.request_type, response.body, OneReplica.new(response, feed))
+      elsif read_write == :read
+        replicas = replicas.shuffle  if @replica_strategy == :round_robin
+        EM.next_tick OneShardRead.new(replicas, response, feed)
+      else
+        EM.next_tick OneShardWrite.new(replicas, response, feed)
+      end
+    end
+
+    class OneReplica
+      include ParseIProto
+      def initialize(response, feed)
+        @response = response
+        @feed = feed
+      end
+
+      def call(result)
+        if Exception === (result = _parse_iproto(result))
+          @feed.call result
+        else
+          @feed.call @response.parse_response(result)
+        end
+      end
+    end
+
+    class OneShardRead
+      include ParseIProto
+      def initialize(replicas, response, feed)
+        @replicas = replicas
+        @i = -1
+        @response = response
+        @feed = feed
+      end
+
+      def call(result=INITIAL)
+        result = _parse_iproto(result)  unless result == INITIAL
+        case result
+        when INITIAL, ::IProto::ConnectionError
+          begin
+            if (@i += 1) >= @replicas.size
+              EM.next_tick Curry1.new(@feed, ConnectionError.new("no available connections"))
+              return
+            end
+          end until (repl = @replicas[@i]).could_be_connected?
+          repl.send_request(@response.request_type, @response.body, self)
+        when Exception
+          @feed.call result
+        else
+          @feed.call @response.parse_response(result)
+        end
+      end
+    end
+
+    class OneShardWrite
+      include ParseIProto
+      def initialize(replicas, response, feed)
+        @replicas_origin = replicas
+        @replicas = replicas.dup
+        @i = replicas.size
+        @response = response
+        @feed = feed
+      end
+
+      def rotate!
+        if @i > 0
+          @i -= 1
+          @replicas.rotate!
+        end
+      end
+
+      def call(result=INITIAL)
+        result = _parse_iproto(result)  unless result == INITIAL
+        case result
+        when INITIAL, ::IProto::ConnectionError, ::Tarantool::NonMaster
+          rotate!  if Exception === result
+          rotate!  until @i <= 0 || (repl = @replicas[0]).could_be_connected?
+          if @i <= 0
+            EM.next_tick Curry1.new(@feed, NoMasterError.new("no available master connections"))
+            return
           end
+          repl.send_request(@response.request_type, @response.body, self)
+        when Exception
+          @feed.call result
+        else
+          @replicas_origin.replace @replicas
+          @feed.call @response.parse_response(result)
         end
       end
     end
 
-    def close_connection
-      EM.schedule do
-        if @connection
-          @connection.close
-          @connection = nil
+    class Concatter
+      def initialize(count, feed)
+        @result = []
+        @count = count
+        @feed = feed
+      end
+      def call(array)
+        if @count > 0
+          case array
+          when Array
+            @result.concat array
+          when Exception
+            @result = array
+            @count = 1
+          else
+            @result << array
+          end
+          if (@count -= 1) == 0
+            if Array === @result && Integer === @result.first
+              @feed.call @result.inject(0){|s, i| s + i}
+            else
+              @feed.call @result
+            end
+          end
         end
-        unless @connection_waiters.empty?
-          while waiter = @connection_waiters.shift
-            waiter.last.call(::IProto::Disconnected)
+      end
+    end
+
+    class ConcatterReplace
+      def initialize(count, feed)
+        @result = []
+        @count = count
+        @feed = feed
+      end
+      def call(array)
+        if @count > 0
+          case array
+          when Array
+            @result.concat array
+          when ::Tarantool::TupleDoesntExists
+            @result << array
+          when Exception
+            @result = array
+            @count = 1
+          else
+            @result << array
+          end
+          if (@count -= 1) == 0
+            if Exception === @result
+              @feed.call @result
+            elsif @result.all?{|r| ::Tarantool::TupleDoesntExists === r}
+              @feed.call @result.first
+            else
+              @result.delete_if{|r| ::Tarantool::TupleDoesntExists === r}
+              if Integer === @result.first
+                @feed.call @result.inject(0){|s, i| s + i}
+              else
+                @feed.call @result
+              end
+            end
           end
         end
       end
     end
 
-    def _send_request(request_type, body, cb)
-      if @connection
-        @connection.send_request(request_type, body, cb)
-      else
-        @connection_waiters << [request_type, body, cb]
+    def _send_to_several_shards(shard_numbers, read_write, response, feed)
+      concat = read_write != :replace ? Concatter.new(shard_numbers.size, feed) :
+                                        ConcatterReplace.new(shard_numbers.size, feed)
+      for shard in shard_numbers
+        _send_to_one_shard(shard, read_write, response, concat)
       end
     end
   end

data/lib/tarantool/exceptions.rb

@@ -1,6 +1,10 @@
 module Tarantool
+  class ConnectionError < ::IProto::Disconnected; end
+  class NoMasterError < ConnectionError; end
+
   class ArgumentError < ::ArgumentError; end
   class StringTooLong < ArgumentError; end
+  class IntegerFieldOverflow < ArgumentError; end
 
   class TarantoolError < StandardError; end
   class ValueError < TarantoolError; end