tarantool 0.2.5 → 0.3.0.7

data/lib/tarantool.rb

@@ -1,36 +1,86 @@
-# -*- coding: utf-8 -*-
-require 'iproto'
-
-class Tarantool
-  VERSION = '0.2.5'
-  
-  require 'tarantool/space'
-  require 'tarantool/requests'
-  require 'tarantool/response'
-  require 'tarantool/exceptions'
-  require 'tarantool/serializers'
-
-  attr_reader :config
-  def initialize(config = {})
-    @config = config
-  end
+require 'eventmachine'
+require "iproto"
+require "tarantool/version"
+require "tarantool/request"
+require "tarantool/response"
+require "tarantool/space_array.rb"
+require "tarantool/space_hash.rb"
+require "tarantool/query.rb"
+require "tarantool/serializers.rb"
 
-  def configure(config)
-    @config.merge! config
-  end
+module Tarantool
+  #autoload :Record, 'tarantool/record'
+  #autoload :LightRecord, 'tarantool/light_record'
 
-  def connection(c = config)
-    @connection ||= begin
-      raise "Tarantool.configure before connect" unless c
-      IProto.get_connection c[:host], c[:port], c[:type] || :block
+  class << self
+    def new(conf)
+      case conf[:type] || :block
+      when :em, :em_fiber
+        require 'tarantool/fiber_db'
+        FiberDB.new(conf[:host], conf[:port])
+      when :em_cb, :em_callback
+        require 'tarantool/callback_db'
+        CallbackDB.new(conf[:host], conf[:port])
+      when :block
+        require 'tarantool/block_db'
+        BlockDB.new(conf[:host], conf[:port])
+      end
     end
   end
 
-  def space(no, conn = connection)
-    Space.new conn, no
-  end
+  class DB
+    attr_reader :closed, :connection
+    alias closed? closed
+    def initialize(host, port)
+      @host = host
+      @port = port
+      @closed = false
+      establish_connection
+    end
+
+    # returns regular space, where fields are named by position
+    #
+    # 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)
+    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)
+    end
+
+    def query
+      @query ||= self.class::Query.new(self)
+    end
+
+    def method_missing(name, *args)
+      if query.respond_to?(name)
+        query.send(name, *args)
+      else
+        super
+      end
+    end
+
+    def close
+      @closed = true
+      close_connection
+    end
+
+    def establish_connection
+      raise NoMethodError, "#establish_connection should be redefined"
+    end
+
+    def close_connection
+      raise NoMethodError, "#close_connection should be redefined"
+    end
+
+    def _send_request(request_type, body, cb)
+      raise NoMethodError, "#_send_request should be redefined"
+    end
 
-  def self.hexdump(string)
-    string.unpack('C*').map{ |c| "%02x" % c }.join(' ')
   end
-end
+end

data/test/box.pid

@@ -0,0 +1 @@
+2887

data/test/helper.rb

@@ -0,0 +1,164 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'rr'
+
+require 'tarantool'
+
+class ArrayPackSerializer
+  def encode(arr)
+    arr.pack("N*")
+  end
+
+  def decode(str)
+    str.unpack("N*")
+  end
+end
+
+TCONFIG = { host: '127.0.0.1', port: 33013, admin: 33015 }
+
+SPACE0 = {
+  types:  [:str, :str, :str, :int],
+  keys:   [0, [1,2], 3]
+}
+SPACE1 = {
+  types:  [:int, :str, :int, 2],
+  keys:   0
+}
+SPACE2 = {
+  types:  [:str, :str, :int],
+  keys:   [[0,1], 2]
+}
+SPACE3 = {
+  types:  [:int, ArrayPackSerializer.new],
+  keys:   [0, 1]
+}
+
+HSPACE0 = {
+  fields: {name: :str, surname: :str, email: :str, score: :int},
+  keys:   [:name, %w{surname email}, 'score']
+}
+HSPACE1 = {
+  fields: {id: :int, _tail: [:str, :int]},
+  keys:   :id
+}
+HSPACE2 = {
+  fields: {first: :str, second: :str, third: :int},
+  keys:   [%w{first second}, :third]
+}
+HSPACE3 = {
+  fields: {id: :int, scores: ArrayPackSerializer.new},
+  keys:   [:id, :scores]
+}
+
+module Helper
+  def tarantool_pipe
+    $tarantool_pipe ||= begin
+        cnf = TCONFIG
+        tarant = %W{tarantool -p #{cnf[:port]} -m #{cnf[:admin]}}
+        tarant = [{}, *tarant, :err => [:child, :out]]
+        IO.popen(tarant, 'w+').tap{|p| p.sync = true}
+    end
+  end
+
+  def exec_tarantool(cmd, lines_to_read)
+    cmd = cmd.gsub(/^\s+/, '')
+    tarantool_pipe.puts(cmd)
+    tarantool_pipe.flush
+    lines_to_read.times do
+      tarantool_pipe.gets
+    end
+  end
+
+  def truncate
+    exec_tarantool "
+       lua truncate(0)
+       lua truncate(1)
+       lua truncate(2)
+       lua truncate(3)
+    ", 12
+  end
+
+  def seed
+    exec_tarantool "
+      insert into t0 values ('vasya', 'petrov', 'eb@lo.com', 5)
+      insert into t0 values ('ilya', 'zimov', 'il@zi.bot', 13)
+      insert into t0 values ('fedor', 'kuklin', 'ku@kl.in', 13)
+      insert into t1 values (1, 'common', 4)
+      insert into t1 values (2, 'medium', 6, 'common', 7)
+      insert into t2 values ('hi zo', 'ho zo', 1)
+      insert into t2 values ('hi zo', 'pidas', 1, 3, 5)
+      insert into t2 values ('coma', 'peredoma', 2)
+    ", 16
+  end
+
+  def clear_db
+    truncate
+    seed
+  end
+
+  def emrun(semaphore = 1)
+    @semaphore = semaphore
+    EM.run {
+      @timeout_timer = EM.add_timer(1) {
+        EM.stop
+        assert false, "timeout encounted"
+      }
+      yield
+    }
+  end
+
+  def emstop
+    @semaphore -= 1
+    if @semaphore == 0
+      EM.cancel_timer @timeout_timer
+      EM.next_tick{ EM.stop }
+    end
+  end
+
+  def fibrun
+    res = nil
+    EM.run {
+      f = Fiber.new{
+        begin
+          res = yield
+        ensure
+          EM.next_tick{ EM.stop }
+        end
+      }
+      EM.next_tick{ f.resume }
+    }
+    res
+  end
+
+  def blockrun
+    yield
+  end
+
+  def mock(u, meth, &block)
+    u.define_singleton_method(meth, &block)
+  end
+end
+
+class MiniTest::Unit::TestCase
+  include ::Helper
+  include RR::Adapters::MiniTest
+end
+
+class << MiniTest::Spec
+  def shared_examples
+    @shared_examples ||= {}
+  end
+end
+
+module MiniTest::Spec::SharedExamples
+  def shared_examples_for(desc, &block)
+    MiniTest::Spec.shared_examples[desc] = block
+  end
+
+  def it_behaves_like(desc)
+    class_eval &MiniTest::Spec.shared_examples.fetch(desc)
+  end
+end
+
+Object.class_eval { include(MiniTest::Spec::SharedExamples) }
+

data/test/run_all.rb

@@ -0,0 +1,3 @@
+Dir.glob(File.expand_path('../test_*.rb', __FILE__)) do |f|
+  require f
+end

data/test/shared_query.rb

@@ -0,0 +1,73 @@
+require File.expand_path('../helper.rb', __FILE__)
+
+shared_examples_for :blocking_query do
+  before { clear_db }
+
+  let(:vasya){ ['vasya', 'petrov', 'eb@lo.com', 5] }
+  let(:ilya) { ['ilya', 'zimov', 'il@zi.bot', 13] }
+  let(:fedor){ ['fedor', 'kuklin', 'ku@kl.in', 13] }
+  let(:vasya_h) { {name: 'vasya', surname: 'petrov', email: 'eb@lo.com', score: 5} }
+  let(:ilya_h)  { {name: 'ilya', surname: 'zimov', email: 'il@zi.bot', score: 13} }
+  let(:fedor_h) { {name: 'fedor', surname: 'kuklin', email: 'ku@kl.in', score: 13} }
+
+  it "should be able to select" do
+    results = blockrun {[
+      tarantool.select(0, 0, 'vasya', 0, -1),
+      tarantool.all(0, 1, ['zimov', 'il@zi.bot'], returns: [:str, :str, :str, :int]),
+      tarantool.first(0, 2, 13, returns: {name: :str, surname: :str, email: :str, score: :int}),
+      tarantool.all(1, 0, 2, returns: [:int, :str, :int, 2]),
+      tarantool.all(1, 0, 2, returns: {id: :int, _tail: [:str, :int]})
+    ]}
+    vasya_s = vasya.dup
+    vasya_s[3] = "\x05\x00\x00\x00"
+    results[0].must_equal [vasya_s]
+    results[1].must_equal [ilya]
+    [ilya_h, fedor_h].must_include results[2]
+    results[3].must_equal [[2, 'medium', 6, 'common', 7]]
+    results[4].must_equal [{id: 2, _tail: [['medium', 6], ['common', 7]]}]
+  end
+
+  it "should insert" do
+    results = blockrun {[
+      tarantool.insert(0, ['asdf','qwer','zxcv',10], return_tuple: true),
+      tarantool.insert(0, ['wert','sdfg','xcvb',1200], types: [:str, :str, :str, :str], return_tuple: true),
+      tarantool.insert(1, [3, 'a', 5, 'b', 6], types: [:int, :str, :int, 2], return_tuple: true),
+      tarantool.replace(1, [2, 'e', 1]),
+      tarantool.first(1, 0, 2, returns: [:int, :str, :int, 2]),
+    ]}
+    results[0].must_equal ['asdf','qwer','zxcv',10]
+    results[1].must_equal ['wert','sdfg','xcvb',"1200"]
+    results[2].must_equal [3, 'a', 5, 'b', 6]
+    results[3].must_equal 1
+    results[4].must_equal [2, 'e', 1]
+  end
+
+  it "should update" do
+    results = blockrun {[
+      tarantool.update(1, 2, [["+2", 4]], returns: [:int, :str, :int, 2], return_tuple: true)
+    ]}
+    results[0].must_equal [2, 'medium', 10, 'common', 7]
+  end
+
+  it "should delete" do
+    results = blockrun {[
+      tarantool.delete(1, 1, returns: [:int, :str, :int, 2], return_tuple: true),
+      tarantool.delete(1, 2, returns: {id: :int, _tail: [:str, :int]}, return_tuple: true)
+    ]}
+    results[0].must_equal [1, 'common', 4]
+    results[1].must_equal({id: 2, _tail: [['medium', 6], ['common', 7]]})
+  end
+
+  it "should call" do
+    results = blockrun {[
+      tarantool.call('func3', ['hello', '2']),
+      tarantool.call('func3', ['hello', 2]),
+      tarantool.call('func3', [234, 432], returns: [:str, :int]),
+      tarantool.call('func3', [234, 432], returns: {type: :str, val: :int}),
+    ]}
+    results[0].must_equal [['string', 'hello'], ['string', '2']]
+    results[1].must_equal [['string', 'hello'], ['string', "\x02\x00\x00\x00"]]
+    results[2].must_equal [['string', 234], ['string', 432]]
+    results[3].must_equal [{type:'string', val:234}, {type:'string', val:432}]
+  end
+end