tarantool 0.3.0.7 → 0.4.2.1

data/Gemfile

@@ -6,11 +6,10 @@ end
 
 group :test do
   gem "rr"
-  gem "activesupport"
   gem "activemodel"
   gem "yajl-ruby"
   gem "bson"
   gem "bson_ext"
 end
-# Specify your gem's dependencies in em-tarantool.gemspec
-gemspec
+# Specify your gem's dependencies in tarantool.gemspec
+gemspec name: 'tarantool'

data/README.md

@@ -14,12 +14,36 @@ gem install tarantool
 require 'tarantool'
 ```
 
-To be able to send requests to the server, you must
-initialize Tarantool and Tarantool space:
+To be able to send requests to the server, you must initialize Tarantool
+and Tarantool space. Space could be initialized with definition of fields
+types (and names) or without (which is not recommended).
+
+Available field types:
+- `:int`, `:integer` - nonnegative 32 bit integer
+- `:int64`, `:integer64` - nonnegative 64 bit integer
+- `:varint` - 32bit or 64bit integer, depending on value
+- `:str`, `:string` - UTF-8 string (attention: empty string is stored as "\x00", which converted back to "" on load)
+- `:bytes`  - ASCII8-bit
+- `:auto` - do not use it (used for space without definition)
+- any object with #encode and #decode methods
+
+Declaration of indexes is optional for array spaces and required for hash spaces.
+When there is no indexes defined for space array, their behaviour is not fixes, so that
+is up to you to specify right amount of values for that indexes.
 
 ```ruby
 DB = Tarantool.new host: 'locahost', port: 33013
-space = DB.space 0
+space_array_without_definition = DB.space 0
+
+space_array = DB.space 1, [:int, :str, :int], keys: [0, [1,2]]
+
+ # last integer specifies tuples tail pattern
+ # note, that two indexes are defined here
+space_array_with_tail = DB.space 2, [:int, :str, :str, :int, 2], keys: [0, 1]
+
+ # space, which returns hashes
+space_hash = DB.space 1, {id: int, name: :str, score: :int}, keys: [:id, [:name, :score]]
+space_hash_with_tail = DB.space 2, {id: int, name: :str, _tail: [:str, :int]}, keys: [:id, :name]
 ```
 
 The driver internals can work in three modes:
@@ -28,39 +52,61 @@ The driver internals can work in three modes:
 - EM::Synchrony like via EventMachine and fibers, so that control flow is visually
   blocked, but eventloop is not (see EM::Synchrony)
 
-By default it uses block mode.
+```ruby
+  DB_SYNC = Tarantool.new host: 'localhost', port: 33013, type: :block
+  DB_CALLBACK = Tarantool.new host: 'localhost', port: 33013, type: :em_callback || :em_cb
+  DB_FIBER = Tarantool.new host: 'localhost', port: 33013, type: :em_fiber || :em
+```
 
+Blocking and Fibered interfaces look similar:
 
 ```ruby
-space.insert 'prepor', 'Andrew', 'ceo@prepor.ru'
-res = space.select 'prepor'
-puts "Name: #{res.tuple[1].to_s}; Email: #{res.tuple[2].to_s}"
-space.delete 'prepor'
+  space = (DB_SYNC || DB_FIBER).space 0, [:str, :str, :str], keys: 0
+  # EM.synchrony do
+    space.insert ['prepor', 'Andrew', 'ceo@prepor.ru']
+    res = space.by_pk 'prepor' # || ['prepor']
+    res = space.first_by_key 0, 'prepor' # || ['prepor']
+    res = space.select 0, ['prepor']
+    puts "Name: #{res[1]}; Email: #{res[2]}"
+    space.delete 'prepor'
+  # EM.stop
+  # end
 ```
 
-**Notice** `Tarantool` instances (connections actually) are not threadsafe. So, you should create `Tarantool` instance per thread.
-
-To use EventMachine pass type: em in options:
+Callback interface is a bit different:
 
 ```ruby
-require 'em-synchrony'
-DB = Tarantool.new host: 'locahost', port: 33013, type: :em
-EM.synchrony do
-  space = DB.space 0
-  space.insert 'prepor', 'Andrew', 'ceo@prepor.ru'
-  res = space.select 'prepor'
-  puts "Name: #{res.tuple[1].to_s}; Email: #{res.tuple[2].to_s}"
-  space.delete 'prepor'
-  EM.stop
+space = DB_CALLBACK.space 0, [:str, :str, :str], keys: 0
+EM.schedule do
+  space.insert ['prepor', 'Andrew', 'ceo@prepor.ru'] do |res|
+    if Exception === res
+      catch_error
+    else
+      space.by_pk 'prepor' do |res|
+        if Exception === res
+          catch_error
+        else
+          puts "Name: #{res[1]}; Email: #{res[2]}"
+          space.delete 'prepor' do |res|
+            catch_error  if Exception === res
+            EM.stop
+          end
+        end
+      end
+    end
+  end
 end
 ```
 
-The driver itself provides ActiveModel API: Callbacks, Validations, Serialization, Dirty.
-Type casting is automatic, based on the index type chosen to process the query.
-For example:
+**Notice** Blocking `Tarantool` connections are not threadsafe. So, you should create `Tarantool` instance per thread.
+
+## LightRecord
+
+`LightRecord` is a light model with callbacks ala Sequel. It is not aware about ActiveModel goodness.
+For ActiveModel avare record look for `tarantool-record` gem
 
 ```ruby
-require 'tarantool/record'
+require 'tarantool/light_record'
 require 'tarantool/serializers/bson'
 class User < Tarantool::Record
   field :login, :string
@@ -70,10 +116,14 @@ class User < Tarantool::Record
   field :info, :bson
   index :name, :email
 
-  validates_length_of(:login, minimum: 3)
+  def after_init
+    super
+    # some work
+  end
 
-  after_create do
-    # after work!
+  def before_create
+    # validation could occure here
+    super # call super if all is allright, return false otherwise
   end
 end
 
@@ -82,11 +132,19 @@ User.create login: 'prepor', email: 'ceo@prepor.ru', name: 'Andrew'
 User.create login: 'ruden', name: 'Andrew', email: 'rudenkoco@gmail.com'
 
 # find by primary key login
+User.by_pk 'prepor'
+User.first 'prepor'
+User.first login: 'prepor'
 User.find 'prepor'
 # first 2 users with name Andrew
+User.all({name: 'Andrew'}, limit: 2)
+User.select({name: 'Andrew'}, limit: 2)
 User.where(name: 'Andrew').limit(2).all
 # second user with name Andrew
-User.where(name: 'Andrew').offset(1).limit(1).all
+User.all({name: 'Andrew'}, offset: 1, limit: 1)[0]
+User.select({name: 'Andrew'}, offset: 1, limit: 1)[0]
+User.where(name: 'Andrew').offset(1).limit(1).all[0]
+User.where(name: 'Andrew').offset(1).first
 # user with name Andrew and email ceo@prepor.ru
 User.where(name: 'Andrew', email: 'ceo@prepor.ru').first
 # raise exception, becouse we can't select query started from not first part of index
@@ -97,10 +155,12 @@ end
 # increment field apples_count by one. Its atomic operation via native Tarantool interface
 User.find('prepor').increment :apples_count
 
-# update only dirty attributes
+# update all attributes (see tarantool-record gem for record, which updates only dirty attributes)
 user = User.find('prepor')
 user.name = "Petr"
 user.save
+user.update_attributes email: "petr@inter.com"  # calls callbacks as well as `save`
+user.update email: "petr@inter.com" # do not calls callbacks, and reloads all fields
 
 # field serialization to bson
 user.info = { 'bio' => "hi!", 'age' => 23, 'hobbies' => ['mufa', 'tuka'] }
@@ -123,4 +183,4 @@ in the tuple stored by Tarantool. By default, the primary key is field 0.
 * admin-socket protocol
 * safe to add fields to exist model
 * Hash, Array and lambdas as default values
-* timers to response, reconnect strategies
+* timers to response

data/Rakefile

@@ -1,5 +1,10 @@
 #!/usr/bin/env rake
-require "bundler/gem_tasks"
+require "bundler/gem_helper"
+Bundler::GemHelper.install_tasks name: 'tarantool'
+namespace :record do
+  Bundler::GemHelper.install_tasks name: 'tarantool-record'
+end
+
 require 'rake/testtask'
 Rake::TestTask.new do |i|
   i.options = '-v'

data/lib/tarantool.rb

@@ -1,6 +1,7 @@
 require 'eventmachine'
 require "iproto"
 require "tarantool/version"
+require "tarantool/exceptions"
 require "tarantool/request"
 require "tarantool/response"
 require "tarantool/space_array.rb"
@@ -11,31 +12,74 @@ require "tarantool/serializers.rb"
 module Tarantool
   #autoload :Record, 'tarantool/record'
   #autoload :LightRecord, 'tarantool/light_record'
+  DEFAULT_PORT = 33013
 
   class << self
     def new(conf)
+      if conf[:host]
+        shards = [ [ _fix_connection(conf) ] ]
+      else
+        shards = conf[:servers]
+        unless shards.is_a? Array
+          shards = [ shards ]
+        end
+        unless shards.first.is_a? Array
+          shards = [ shards ]
+        end
+        shards = shards.map{|shard| shard.map{|server| _fix_connection(server)}}
+      end
+
+      replica_strategy = conf[:replica_strategy] || :round_robin
+      if %w{round_robin master_first}.include?(replica_strategy)
+        replica_strategy = replica_strategy.to_sym
+      end
+      unless [:round_robin, :master_first].include?(replica_strategy)
+        raise ArgumentError, "Shard strategy could be :round_robin or :master_first, got #{replica_strategy.inspect}"
+      end
+
+      previous_shards_count = conf[:previous_shards_count]
+      insert_to_previous_shard = conf[:insert_to_previous_shard]
+
       case conf[:type] || :block
       when :em, :em_fiber
         require 'tarantool/fiber_db'
-        FiberDB.new(conf[:host], conf[:port])
+        FiberDB.new(shards, replica_strategy, previous_shards_count, insert_to_previous_shard)
       when :em_cb, :em_callback
         require 'tarantool/callback_db'
-        CallbackDB.new(conf[:host], conf[:port])
+        CallbackDB.new(shards, replica_strategy, previous_shards_count, insert_to_previous_shard)
       when :block
         require 'tarantool/block_db'
-        BlockDB.new(conf[:host], conf[:port])
+        BlockDB.new(shards, replica_strategy, previous_shards_count, insert_to_previous_shard)
+      else
+        raise "Unknown Tarantool connection type #{conf[:type]}"
+      end
+    end
+
+    private
+    def _fix_connection(conn)
+      if conn.is_a? Hash
+        conn = [conn[:host], conn[:port]].compact.join(':')
+      end
+      if conn.is_a? String
+        host, port = conn.split(':')
+        port ||= DEFAULT_PORT
+        conn = [host, port.to_i]
       end
+      raise ArgumentError, "Wrong connection declaration #{conn}" unless conn.is_a? Array
+      conn
     end
   end
 
   class DB
-    attr_reader :closed, :connection
+    attr_reader :closed, :connections
     alias closed? closed
-    def initialize(host, port)
-      @host = host
-      @port = port
+    def initialize(shards, replica_strategy, previous_shards_count, insert_to_previous_shard)
+      @shards = shards
+      @replica_strategy = replica_strategy
+      @previous_shards_count = previous_shards_count
+      @insert_to_previous_shard = insert_to_previous_shard
+      @connections = {}
       @closed = false
-      establish_connection
     end
 
     # returns regular space, where fields are named by position
@@ -43,14 +87,29 @@ module Tarantool
     # tarantool.space_block(0, [:int, :str, :int, :str], keys: [[0], [1,2]])
     def space_array(space_no, field_types = [], opts = {})
       indexes = opts[:keys] || opts[:indexes]
-      self.class::SpaceArray.new(self, space_no, field_types, indexes)
+      shard_fields = opts[:shard_fields]
+      shard_proc = opts[:shard_proc]
+      self.class::SpaceArray.new(self, space_no, field_types, indexes,
+                                 shard_fields, shard_proc)
+    end
+
+    def space(space_no, fields = [], opts = {})
+      case fields
+      when Array
+        space_array(space_no, fields, opts)
+      when Hash
+        space_hash(space_no, fields, opts)
+      else
+        raise "You should specify fields as an array or hash (got #{fields.inspect})"
+      end
     end
-    # alias space_array to space for backward compatibility
-    alias space space_array
 
     def space_hash(space_no, fields, opts = {})
       indexes = opts[:keys] || opts[:indexes]
-      self.class::SpaceHash.new(self, space_no, fields, indexes)
+      shard_fields = opts[:shard_fields]
+      shard_proc = opts[:shard_proc]
+      self.class::SpaceHash.new(self, space_no, fields, indexes,
+                                shard_fields, shard_proc)
     end
 
     def query
@@ -70,17 +129,33 @@ module Tarantool
       close_connection
     end
 
-    def establish_connection
-      raise NoMethodError, "#establish_connection should be redefined"
+    def shards_count
+      @shards.count
     end
 
-    def close_connection
-      raise NoMethodError, "#close_connection should be redefined"
+    attr_reader :previous_shards_count
+
+    def insert_with_shards_count
+      @insert_to_previous_shard && @previous_shards_count || @shards.count
     end
 
-    def _send_request(request_type, body, cb)
-      raise NoMethodError, "#_send_request should be redefined"
+    def _shard(number)
+      @connections[number] ||= begin
+        @shards[number].map do |host, port|
+          IProto.get_connection(host, port, self.class::IPROTO_CONNECTION_TYPE)
+        end
+      end
+    end
+
+    def close_connection
+      @connections.each do |number, replicas|
+        replicas.each(&:close)
+      end
+      @connections.clear
     end
 
+    def primary_interface
+      raise NoMethodError, "#primary_interface should by overriden"
+    end
   end
 end

data/lib/tarantool/base_record.rb

@@ -1,30 +1,66 @@
 require 'tarantool'
 require 'tarantool/record/select'
-require 'active_support/core_ext/class/attribute'
+require 'tarantool/core-ext'
 
 module Tarantool
   class RecordError < StandardError; end
   class UpdateNewRecord < RecordError; end
 
   class BaseRecord
-    class_attribute :fields, instance_reader: false, instance_writer: false
+    extend ::Tarantool::ClassAttribute
+    t_class_attribute :fields
     self.fields = {}.freeze
 
-    class_attribute :default_values, instance_reader: false, instance_writer: false
+    t_class_attribute :default_values
     self.default_values = {}.freeze
 
-    class_attribute :indexes, instance_reader: false, instance_writer: false
+    t_class_attribute :indexes
     self.indexes = [].freeze
 
-    class_attribute :space_no, instance_reader: false, instance_writer: false
-    class_attribute :tarantool, instance_reader: false, instance_writer: false
+    t_class_attribute :_space_no
+    t_class_attribute :_tarantool
+
+    t_class_attribute :_shard_proc
+    t_class_attribute :_shard_fields
+    self._shard_proc = nil
+    self._shard_fields = nil
 
     class << self
-      alias set_space_no space_no=
-      alias set_tarantool tarantool=
+      alias set_shard_proc _shard_proc=
     end
 
     module ClassMethods
+      def tarantool(v=nil)
+        unless v
+          _tarantool
+        else
+          self.tarantool = v
+        end
+      end
+
+      def tarantool=(v)
+        reset_space!
+        unless ::Tarantool::DB === v && v.primary_interface == :synchronous
+          raise ArgumentError, "you may assing to record's tarantool only instances of Tarantool::BlockDB or Tarantool::FiberDB"
+        end
+        self._tarantool= v
+      end
+      alias set_tarantool tarantool=
+
+      def space_no(v=nil)
+        unless v
+          _space_no
+        else
+          self.space_no = v
+        end
+      end
+
+      def space_no=(v)
+        reset_space!
+        self._space_no = v
+      end
+      alias set_space_no  space_no=
+
       def field(name, type, params = {})
         type = Serializers.check_type(type)
 
@@ -57,13 +93,50 @@ module Tarantool
         end
       end
 
+      def shard_proc(cb = nil, &block)
+        if cb ||= block
+          self._shard_proc = cb
+        else
+          _shard_proc
+        end
+      end
+
+      def shard_fields(*args)
+        if args.empty?
+          _shard_fields
+        else
+          self._shard_fields = args
+        end
+      end
+      alias set_shard_fields shard_fields
+
       def primary_index
         indexes[0]
       end
 
       def space
         @space ||= begin
-            tarantool.space_hash(space_no, fields.dup, keys: indexes)
+            shard_fields = _shard_fields || primary_index
+            shard_proc = _shard_proc ||
+              if shard_fields.size == 1
+                case fields[shard_fields[0]]
+                when :int, :int16, :int8
+                  :sumbur_murmur_fmix
+                when :int64
+                  :sumbur_murmur_int64
+                when :string
+                  :sumbur_murmur_str
+                else
+                  :default
+                end
+              else
+                :default
+              end
+            _tarantool.space_hash(_space_no, fields.dup,
+                                 keys: indexes,
+                                 shard_fields: shard_fields,
+                                 shard_proc: shard_proc
+                                )
           end
       end
 
@@ -75,6 +148,11 @@ module Tarantool
           end
       end
 
+      def reset_space!
+        @space = nil
+        @auto_space = nil
+      end
+
       def by_pk(pk)
         if Hash === (res = space.by_pk(pk))
           from_fetched(res)
@@ -171,6 +249,15 @@ module Tarantool
         end
       end
 
+      def store(hash, ret_tuple = false)
+        hash = default_values.merge(hash)
+        if ret_tuple
+          from_fetched space.store(hash, return_tuple: true)
+        else
+          space.store(hash)
+        end
+      end
+
       def update(pk, ops, ret_tuple=false)
         if ret_tuple
           from_fetched space.update(pk, ops, return_tuple: true)
@@ -187,7 +274,7 @@ module Tarantool
         end
       end
 
-      %w{where limit offset}.each do |meth|
+      %w{where limit offset shard}.each do |meth|
         class_eval <<-"EOF", __FILE__, __LINE__
           def #{meth}(arg)
             select.#{meth}(arg)