tarantool16 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7438bad2e35b3f56d1949664f4e51a1c866550ed
+  data.tar.gz: 802d8dd75d560a73b7b30bf8815908d49a484262
+SHA512:
+  metadata.gz: 8cae0fe3c55291a6f2c503f7a4611f950e28d2679e8950b149697090ec185d6f0bfd875ccaf002899aa9b6020cda218c12578ad10a547ea00b3264d67e409d46
+  data.tar.gz: 7281531d361f6bd6032c36d37c40527aacf0e9607efbc14cd1da6615d952f4e37994b35f1f7930cf62d8c67f7cafab895b72679dce367f8a678d84a7e51cb15c

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tarantool16.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Sokolov Yura aka funny_falcon
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,80 @@
+# Tarantool16
+
+This is adapter for (tarantool)[http://tarantool.org] version 1.6.
+
+(adapter for version <=1.5 is called (tarantool)[https://github.org/tarantoool/tarantool-ruby])
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'tarantool16'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tarantool16
+
+## Usage
+
+Currently only simple single threaded one-request-at-time connection implemented.
+
+```ruby
+require 'tarantool16'
+
+db = Tarantool16.new host:'localhost:33013'
+#db = Tarantool16.new host:'localhost:33013', user:'tester', password:'testpass'
+
+# select from '_space' space info about 'test' table
+# returns array of tuples as an array
+tar.get(272, ['test'], index: 2)
+
+# same, but return tuples as a hashes
+tar.get(272, ['test'], index: 2, hash: true)
+
+# same with names
+# Names and index descriptions are fetched from tarantool.
+# Index is autodetected by key names
+tar.get(:_space, {name: 'test'})
+
+# get all spaces
+tar.select(:_space, nil, iterator: :all)
+tar.select(:_space, nil, iterator: :all, hash: true)
+
+tar.select(:_space, [512], index: 0, iterator: :>=, hash: true)
+
+# override tuple field definition
+tar.define_fields(:test, [:id, :name, :value])
+
+tar.insert(:test, [1, 'buddy', [1,2,3]])
+tar.replace(:test, [1, 'buddy!', [2,3,4]])
+tar.update(:test, [1], [[':', 1, 6, 6, '?']])
+#tar.update(:test, [1], [[':', 1, 6, 6, '?']], index: 0)
+tar.delete(:test, [1])
+#tar.delete(:test, [1], index: 0)
+
+tar.insert(:test, {id: 1, name: 'buddy', value: [1,2,3]})
+tar.replace(:test, {id: 1, name: 'buddy!', value: [2,3,4]})
+tar.update(:test, {id: 1}, {name: [':', 6,6,'?']})
+tar.delete(:test, {id: 1})
+
+# note: currenlty there is no documented way to store field definition in an tarantool
+# but actually you can do it with this
+tar.update(:_space, {name: 'test'}, {format: [:=, [{name: :id, type: :num}, {name: :name, type: :str}, {name: :value, type: '*'}]]})
+
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/funny-falcon/tarantool16/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+Or simply fill an issue

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/tarantool16/connection/common.rb

@@ -0,0 +1,196 @@
+require 'msgpack'
+require 'openssl'
+require 'openssl/digest'
+require 'tarantool16/consts'
+require_relative 'response'
+
+module Tarantool16
+  module Connection
+    class Error < ::StandardError; end
+    class ConnectionError < Error; end
+    class CouldNotConnect < ConnectionError; end
+    class Disconnected < ConnectionError; end
+    class Retry < ConnectionError; end
+    class UnexpectedResponse < Error; end
+
+    module Common
+      DEFAULT_RECONNECT = 0.2
+      attr :host, :user
+      def _init_common(host, opts)
+        @host = host
+        @user = opts[:user]
+        if opts[:password]
+          @passwd = ::OpenSSL::Digest::SHA1.digest(opts[:password])
+        end
+        if opts[:reconnect].nil?
+          @reconnect_timeout = DEFAULT_RECONNECT
+          @reconnect = true
+        elsif Numeric === opts[:reconnect]
+          @reconnect_timeout = opts[:reconnect]
+          @reconnect = true
+        else
+          @reconnect = false
+        end
+        @p = MessagePack::Packer.new
+        @u = MessagePack::Unpacker.new
+        @s = 0
+      end
+
+      if ::Process.respond_to?(:clock_gettime)
+        if defined?(::Process::CLOCK_MONOTONIC_COARSE)
+          CLOCK_KIND = ::Process::CLOCK_MONOTONIC_COARSE
+        elsif defined?(::Process::CLOCK_MONOTONIC_FAST)
+          CLOCK_KIND = ::Process::CLOCK_MONOTONIC_FAST
+        elsif defined?(::Process::CLOCK_MONOTONIC)
+          CLOCK_KIND = ::Process::CLOCK_MONOTONIC
+        else
+          CLOCK_KIND = ::Process::CLOCK_REALTIME
+        end
+        def now_f
+          ::Process.clock_gettime(CLOCK_KIND)
+        end
+      else
+        def now_f
+          Time.now.to_f
+        end
+      end
+
+      def next_sync
+        @s = @s % 0x3fffffff + 1
+      end
+
+      def format_request(code, sync, body)
+        @p.write(0x01020304).
+          write_map_header(2).
+          write(IPROTO_CODE).write(code).
+          write(IPROTO_SYNC).write(sync).
+          write(body)
+        sz = @p.size - 5
+        str = @p.to_s
+        @p.clear
+        # fix bigendian size
+        str.setbyte(4, sz)
+        str.setbyte(3, sz>>8)
+        str.setbyte(2, sz>>16)
+        str.setbyte(1, sz>>24)
+        str
+      end
+
+      def format_authenticate(user, pass1, salt)
+        pass2 = ::OpenSSL::Digest::SHA1.digest(pass1)
+        scramble = ::OpenSSL::Digest::SHA1.new(salt).update(pass2).digest
+        pints = pass1.unpack('L*')
+        sints = scramble.unpack('L*')
+        pints.size.times{|i| sints[i] ^= pints[i] }
+        format_request(REQUEST_TYPE_AUTHENTICATE, next_sync, {
+          IPROTO_USER_NAME => user,
+          IPROTO_TUPLE => [ 'chap-sha1', sints.pack('L*') ]
+        })
+      end
+
+      def parse_greeting(greeting)
+        @greeting = greeting[0, 64]
+        @salt = greeting[64..-1].unpack('m')[0][0,20]
+      end
+
+      def parse_size(str)
+        @u.feed(str)
+        n = @u.read
+        unless Integer === n
+          return UnexpectedResponse.new("wanted response size, got #{n.inspect}")
+        end
+        n
+      rescue ::MessagePack::UnpackError, ::MessagePack::TypeError => e
+        e
+      end
+
+      def parse_response(str)
+        sync = nil
+        @u.feed(str)
+        n = @u.read_map_header
+        while n > 0
+          cd = @u.read
+          vl = @u.read
+          case cd
+          when IPROTO_SYNC
+            sync = vl
+          when IPROTO_CODE
+            code = vl
+          end
+          n -= 1
+        end
+        if sync == nil
+          return Option.error(nil, UnexpectedResponse, "Mailformed response: no sync")
+        elsif code == nil
+          return Option.error(nil, UnexpectedResponse, "Mailformed response: no code for sync=#{sync}")
+        end
+        unless @u.buffer.empty?
+          bmap = @u.read
+          body = bmap[IPROTO_DATA] || bmap[IPROTO_ERROR]
+        else
+          body = nil
+        end
+        Option.ok(sync, code, body)
+      rescue ::MessagePack::UnpackError, ::MessagePack::TypeError => e
+        Option.error(sync, e, nil)
+      end
+
+      def host_port
+        h, p = @host.split(':')
+        [h, p.to_i]
+      end
+
+      def _insert(space_no, tuple, cb)
+        req = {IPROTO_SPACE_ID => space_no,
+               IPROTO_TUPLE => tuple}
+        send_request(REQUEST_TYPE_INSERT, req, cb)
+      end
+
+      def _replace(space_no, tuple, cb)
+        req = {IPROTO_SPACE_ID => space_no,
+               IPROTO_TUPLE => tuple}
+        send_request(REQUEST_TYPE_REPLACE, req, cb)
+      end
+
+      def _delete(space_no, index_no, key, cb)
+        req = {IPROTO_SPACE_ID => space_no,
+               IPROTO_INDEX_ID => index_no,
+               IPROTO_KEY => key}
+        send_request(REQUEST_TYPE_DELETE, req, cb)
+      end
+
+      def _select(space_no, index_no, key, offset, limit, iterator, cb)
+        iterator ||= ::Tarantool16::ITERATOR_EQ
+        unless Integer === iterator
+          iterator = ::Tarantool16.iter(iterator)
+        end
+        req = {IPROTO_SPACE_ID => space_no,
+               IPROTO_INDEX_ID => index_no,
+               IPROTO_KEY => key || [],
+               IPROTO_OFFSET => offset,
+               IPROTO_LIMIT => limit,
+               IPROTO_ITERATOR => iterator}
+        send_request(REQUEST_TYPE_SELECT, req, cb)
+      end
+
+      def _update(space_no, index_no, key, ops, cb)
+        req = {IPROTO_SPACE_ID => space_no,
+               IPROTO_INDEX_ID => index_no,
+               IPROTO_KEY => key,
+               IPROTO_TUPLE => ops}
+        send_request(REQUEST_TYPE_UPDATE, req, cb)
+      end
+
+      def _call(name, args, cb)
+        req = {IPROTO_FUNCTION_NAME => name,
+               IPROTO_TUPLE => args}
+        send_request(REQUEST_TYPE_CALL, req, cb)
+      end
+
+      REQ_EMPTY = {}.freeze
+      def _ping(cb)
+        send_request(REQUEST_TYPE_PING, REQ_EMPTY, cb)
+      end
+    end
+  end
+end

data/lib/tarantool16/connection/dumb.rb

@@ -0,0 +1,122 @@
+require 'socket'
+require_relative 'common'
+module Tarantool16
+  module Connection
+    class Dumb
+      include Common
+
+      def initialize(host, opts = {})
+        _init_common(host, opts)
+        @nbuf = "\x00".b * 5
+        @reconnect_time = now_f - 1
+        @socket = nil
+        _connect
+      end
+
+      def send_request(code, body, cb)
+        _connect
+        syswrite format_request(code, next_sync, body)
+        written = true
+        response = _read_response
+      rescue ::Errno::EPIPE, Retry => e
+        @socket = nil
+        if !written && @retry && @reconnect
+          @retry = false
+          retry
+        end
+        cb.call Option.error(nil, Disconnected, e.message)
+      rescue StandardError => e
+        cb.call Option.error(nil, e, nil)
+      else
+        cb.call response
+      end
+
+      def disconnect
+        if @socket
+          @socket.close rescue nil
+          @socket = nil
+          @s = 0
+        end
+      end
+
+      def close
+        @reconnect = false
+        if @socket
+          @socket.close rescue nil
+          @socket = false
+          @s = 0
+        end
+      end
+
+      def connected?
+        @socket
+      end
+
+      def could_be_connected?
+        @socket || (@socket.nil? && (@reconnect || @reconnect_time < now_f))
+      end
+
+    private
+      def _connect
+        return if @socket
+        unless could_be_connected?
+          raise Disconnected, "connection is closed"
+        end
+        @socket = TCPSocket.new(*host_port)
+        @socket.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+        @retry = @reconnect
+        greeting = @socket.read(IPROTO_GREETING_SIZE)
+        unless greeting && greeting.bytesize == IPROTO_GREETING_SIZE
+          raise Disconnected, "mailformed greeting #{greeting.inspect}"
+        end
+        parse_greeting greeting
+        authenticate if @user
+      rescue ::Errno::ECONNREFUSED, ::Errno::EPIPE, Disconnected => e
+        @socket = nil
+        if !@reconnect
+          @socket = false
+          @s = 0
+        else
+          @reconnect_time = now_f + @reconnect_timeout
+        end
+        raise CouldNotConnect, e.message
+      end
+
+      def syswrite(req)
+        if @socket.syswrite(req) != req.bytesize
+          raise Retry, "Could not write message"
+        end
+      end
+
+      def authenticate
+        syswrite format_authenticate(@user, @passwd, @salt)
+        _read_response.raise_if_error!
+      end
+
+      def _read_response
+        str = @socket.read(5, @nbuf)
+        unless str && str.bytesize == 5
+          # check if we sent request or not
+          begin
+            @socket.send("\x00", 0)
+          rescue ::Errno::EPIPE
+            # if OS knows that socket is closed, then request were not sent
+            raise Retry
+          else
+            # otherwise request were sent
+            raise Disconnected, "disconnected while read length"
+          end
+        end
+        n = parse_size(str)
+        raise n unless ::Integer === n
+        resp = @socket.read(n)
+        raise Disconnected, "disconnected while read response" unless resp && resp.bytesize == n
+        r = parse_response(resp)
+        if r.ok? && r.sync != @s
+          raise UnexpectedResponse, "sync mismatch: #{@s} != #{r.sync}"
+        end
+        r
+      end
+    end
+  end
+end