ssdb 0.1.0

data/lib/ssdb/batch.rb

@@ -0,0 +1,27 @@
+class SSDB::Batch < Array
+
+  # Constructor
+  def initialize
+    @futures = []
+    super
+  end
+
+  # Call command
+  # @param [Hash] opts the command options
+  def call(opts)
+    push(opts)
+
+    future = SSDB::Future.new(opts[:cmd])
+    @futures.push(future)
+    future
+  end
+
+  # @param [Array] values
+  def values=(values)
+    values.each_with_index do |value, index|
+      future = @futures[index]
+      future.value = value if future
+    end
+  end
+
+end

data/lib/ssdb/client.rb

@@ -0,0 +1,173 @@
+require "socket"
+require "uri"
+
+class SSDB
+  class Client
+    NL = "\n".freeze
+    OK = "ok".freeze
+    NOT_FOUND = "not_found".freeze
+
+    attr_reader :url, :timeout
+    attr_accessor :reconnect
+
+    # @param [Hash] opts
+    # @option opts [String|URI] :url the URL to connect to,required
+    # @option opts [Numeric] :timeout socket timeout, defaults to 10s
+    def initialize(opts = {})
+      @timeout   = opts[:timeout] || 10.0
+      @sock      = nil
+      @url       = parse_url(opts[:url] || ENV["SSDB_URL"] || "ssdb://127.0.0.1:8888/")
+      @reconnect = opts[:reconnect] != false
+    end
+
+    # @return [String] URL string
+    def id
+      url.to_s
+    end
+
+    # @return [Integer] port
+    def port
+      @port ||= url.port || 8888
+    end
+
+    # @return [Boolean] true if connected
+    def connected?
+      !!@sock
+    end
+
+    # Disconnects the client
+    def disconnect
+      @sock.close if connected?
+    rescue
+    ensure
+      @sock = nil
+    end
+
+    # Calls a single command
+    # @param [Hash] opts options
+    # @option opts [Array] :cmd command parts
+    # @option opts [Boolean] :multi true if multi-response is expected
+    # @option opts [Proc] :proc a proc to apply to the result
+    # @option opts [Array] :args arguments to pass to the :proc
+    def call(opts)
+      perform([opts])[0]
+    end
+
+    # Performs multiple commands
+    # @param [Array<Hash>] commands array of command options
+    # @see SSDB::Client#call for command format
+    def perform(commands)
+      message = ""
+
+      commands.each do |hash|
+        hash[:cmd].each do |c|
+          message << c.bytesize.to_s << NL << c << NL
+        end
+        message << NL
+      end
+
+      results = []
+      ensure_connected do
+        io(:write, message)
+
+        commands.each do |hash|
+          part = read_part(hash[:multi])
+          if hash[:proc]
+            args = [part]
+            args.concat(hash[:args]) if hash[:args]
+            part = hash[:proc].call(*args)
+          end
+          results << part
+        end
+      end
+
+      results
+    end
+
+    protected
+
+      # @return [TcpSocket] socket connection
+      def socket
+        @sock ||= connect
+      end
+
+      # Safely perform IO operation
+      def io(op, *args)
+        socket.__send__(op, *args)
+      rescue Errno::EAGAIN
+        raise SSDB::TimeoutError, "Connection timed out"
+      rescue Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, Errno::EBADF, Errno::EINVAL => e
+        raise SSDB::ConnectionError, "Connection lost (%s)" % [e.class.name.split("::").last]
+      end
+
+      def ensure_connected
+        attempts = 0
+        begin
+          yield
+        rescue SSDB::ConnectionError
+          disconnect
+          retry if (attempts += 1) < 2
+          raise
+        rescue Exception
+          disconnect
+          raise
+        end
+      end
+
+    private
+
+      # "Inspired" by http://www.mikeperham.com/2009/03/15/socket-timeouts-in-ruby/
+      def connect
+        addr = Socket.getaddrinfo(url.host, nil)
+        sock = Socket.new(Socket.const_get(addr[0][0]), Socket::SOCK_STREAM, 0)
+        sock.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, sock_timeout
+        sock.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, sock_timeout
+        sock.connect(Socket.pack_sockaddr_in(port, addr[0][3]))
+        sock
+      end
+
+      # Converts numeric `timeout` into a packed socket option value
+      def sock_timeout
+        @sock_timeout ||= begin
+          secs  = Integer(timeout)
+          usecs = Integer((timeout - secs) * 1_000_000)
+          [secs, usecs].pack("l_2")
+        end
+      end
+
+      def read_len
+        len = io(:gets).chomp
+        len unless len.empty?
+      end
+
+      def read_part(multi)
+        read_len || return
+        status = io(:gets).chomp
+
+        case status
+        when OK
+          part = []
+          part << io(:gets).chomp while read_len
+          part.size > 1 || multi ? part : part[0]
+        when NOT_FOUND
+          multi ? [] : nil
+        else
+          raise SSDB::CommandError, "Server responded with '#{status}'"
+        end
+      end
+
+      # Parses `url`
+      def parse_url(url)
+        url = URI(url) if url.is_a?(String)
+
+        # Validate URL
+        unless url.host
+          raise ArgumentError, "Invalid :url option, unable to determine 'host'."
+        end
+
+        url
+      end
+
+  end
+
+end

data/lib/ssdb/future.rb

@@ -0,0 +1,30 @@
+class SSDB::Future < ::BasicObject
+
+  def initialize(command)
+    @command = command
+  end
+
+  def inspect
+    "<SSDB::Future #{@command.inspect}>"
+  end
+
+  def value=(value)
+    @value = value
+  end
+
+  def value
+    unless defined?(@value)
+      ::Kernel.raise ::SSDB::FutureNotReady, "Value of #{@command.inspect} is not ready"
+    end
+    @value
+  end
+
+  def instance_of?(klass)
+    klass == ::SSDB::Future
+  end
+
+  def class
+    ::SSDB::Future
+  end
+
+end

data/lib/ssdb/version.rb

@@ -0,0 +1,3 @@
+class SSDB
+  VERSION = "0.1.0"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+require 'bundler/setup'
+require 'rspec'
+require 'ssdb'
+
+# Fixture prefix
+FPX = "ssdb:rb:spec"
+
+RSpec.configure do |c|
+
+  c.after do
+    db = SSDB.current
+
+    # Remove keys
+    db.keys(FPX, FPX + "\xFF").each do |key|
+      db.del(key)
+    end
+
+    # Remove zsets
+    db.zlist(FPX, FPX + "\xFF").each do |key|
+      db.multi_zdel key, db.zkeys(key, 0, 1_000_000)
+    end
+  end
+
+end

data/spec/ssdb/batch_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe SSDB::Batch do
+
+  let :futures do
+    subject.instance_variable_get(:@futures)
+  end
+
+  let :calling do
+    -> { subject.call cmd: ["incr", "key", 2] }
+  end
+
+  it { should be_a(Array) }
+
+  describe "#call" do
+
+    it 'should store commands' do
+      calling.should change { subject.count }.by(1)
+      subject.last.should include(:cmd)
+    end
+
+    it 'should remember futures' do
+      calling.should change { futures.count }.by(1)
+      futures.last.should be_instance_of(SSDB::Future)
+    end
+
+  end
+
+  describe "applying values" do
+    before { 3.times { calling.call } }
+
+    it 'should set feature' do
+      subject.values = [2, 4, 6]
+      futures.map(&:value).should == [2, 4, 6]
+    end
+  end
+
+end

data/spec/ssdb/client_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe SSDB::Client do
+
+  its(:url)       { should be_instance_of(URI::Generic) }
+  its(:timeout)   { should == 10.0 }
+  its(:id)        { should == "ssdb://127.0.0.1:8888/" }
+  its(:port)      { should == 8888 }
+  its(:reconnect) { should be(true) }
+
+  it "should not be connected by default" do
+    subject.should_not be_connected
+  end
+
+  it "can connect" do
+    -> { subject.send(:socket) }.should change { subject.connected? }.to(true)
+  end
+
+  it "can disconnect" do
+    -> { subject.disconnect }.should_not change { subject.connected? }
+    subject.send(:socket)
+    -> { subject.disconnect }.should change { subject.connected? }.to(false)
+  end
+
+  it "should perform commands" do
+    res = subject.perform [{ cmd: ["set", "#{FPX}:key", "VAL1"] }]
+    res.should == ["1"]
+  end
+
+  it "should perform commands in bulks" do
+    res = subject.perform [
+      { cmd: ["set", "#{FPX}:key", "VAL2"] },
+      { cmd: ["get", "#{FPX}:key"] }
+    ]
+    res.should == ["1", "VAL2"]
+  end
+
+  it "should perform complex command chains" do
+    res = subject.perform [
+      { cmd: ["zset", "#{FPX}:zset", "VAL1", "1"] },
+      { cmd: ["zset", "#{FPX}:zset", "VAL2", "2"] },
+      { cmd: ["zscan", "#{FPX}:zset", "*", "0", "5", "-1"], multi: true },
+      { cmd: ["zrscan", "#{FPX}:zset", "*", "5", "0", "-1"], multi: true, proc: ->r { r[1] = r[1].to_f; r } }
+    ]
+    res.should == ["1", "1", ["VAL1", "1", "VAL2", "2"], ["VAL2", 2, "VAL1", "1"]]
+  end
+
+end

data/spec/ssdb/future_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe SSDB::Future do
+
+  subject do
+    described_class.new ["set", "key", "val"]
+  end
+
+  it { should be_instance_of(described_class) }
+
+  it "should be introspectable" do
+    subject.inspect.should == %(<SSDB::Future ["set", "key", "val"]>)
+  end
+
+  it "should raise error when not ready" do
+    -> { subject.value }.should raise_error(SSDB::FutureNotReady)
+  end
+
+  it "should return value when ready" do
+    subject.value = "ok"
+    subject.value.should == "ok"
+
+    subject.value = true
+    subject.value.should == true
+
+    subject.value = nil
+    subject.value.should == nil
+  end
+
+end

data/spec/ssdb_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe SSDB do
+
+  describe "class" do
+    subject { described_class }
+
+    its(:current) { should be_instance_of(described_class) }
+    it { should respond_to(:current=) }
+  end
+
+  it 'should execute batches' do
+    res = subject.batch do
+      subject.set  "#{FPX}:key", "100"
+      subject.get  "#{FPX}:key"
+      subject.incr "#{FPX}:key", 10
+      subject.decr "#{FPX}:key", 30
+    end
+    res.should == [true, "100", 110, 80]
+  end
+
+  it 'should execute batches with futures' do
+    s = n = nil
+    subject.batch do
+      subject.set  "#{FPX}:key", "100"
+      s = subject.get  "#{FPX}:key"
+      n = subject.incr "#{FPX}:key", 10
+
+      -> { s.value }.should raise_error(SSDB::FutureNotReady)
+    end
+
+    s.should be_instance_of(SSDB::Future)
+    s.value.should == "100"
+    n.value.should == 110
+  end
+
+end

data/spec/types/values_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe SSDB do
+  describe "plain values" do
+
+    before do
+      subject.set "#{FPX}:key1", 1
+      subject.set "#{FPX}:key2", "2"
+      subject.set "#{FPX}:key3", "C"
+      subject.set "#{FPX}:key4", "d"
+    end
+
+    it "should check existence" do
+      subject.exists("#{FPX}:key1").should be(true)
+      subject.exists?("#{FPX}:key2").should be(true)
+      subject.exists?("#{FPX}:keyX").should be(false)
+    end
+
+    it "should delete" do
+      -> {
+        subject.del("#{FPX}:key1").should be_nil
+      }.should change { subject.exists?("#{FPX}:key1") }.to(false)
+
+      subject.del("#{FPX}:keyX").should be_nil
+    end
+
+    it "should list" do
+      subject.keys("#{FPX}:key1", "#{FPX}:key3").should == ["#{FPX}:key2", "#{FPX}:key3"]
+      subject.keys("#{FPX}:key0", "#{FPX}:keyz", limit: 2).should == ["#{FPX}:key1", "#{FPX}:key2"]
+      subject.keys("#{FPX}:keyy", "#{FPX}:keyz").should == []
+      subject.keys("#{FPX}:keyz", "#{FPX}:key0").should == []
+    end
+
+    it "should scan" do
+      subject.scan("#{FPX}:key1", "#{FPX}:key3").should == [["#{FPX}:key2", "2"], ["#{FPX}:key3", "C"]]
+      subject.scan("#{FPX}:key0", "#{FPX}:keyz", limit: 2).should == [["#{FPX}:key1", "1"], ["#{FPX}:key2", "2"]]
+      subject.scan("#{FPX}:keyy", "#{FPX}:keyz").should == []
+      subject.scan("#{FPX}:keyz", "#{FPX}:key0").should == []
+    end
+
+    it "should rscan" do
+      subject.rscan("#{FPX}:key3", "#{FPX}:key1").should == [["#{FPX}:key2", "2"], ["#{FPX}:key1", "1"]]
+      subject.rscan("#{FPX}:keyz", "#{FPX}:key0", limit: 2).should == [["#{FPX}:key4", "d"], ["#{FPX}:key3", "C"]]
+      subject.rscan("#{FPX}:keyz", "#{FPX}:keyy").should == []
+      subject.rscan("#{FPX}:key0", "#{FPX}:keyz").should == []
+    end
+
+    it "should set/get values" do
+      subject.set("#{FPX}:key", "a").should be(true)
+      subject.set("#{FPX}:key", "a").should be(true)
+      subject.set("#{FPX}:key", "b").should be(true)
+
+      subject.get("#{FPX}:key").should == "b"
+      subject.get("#{FPX}:keyX").should be_nil
+    end
+
+    it "should increment/decrement values" do
+      subject.incr("#{FPX}:key", 7).should == 7
+      subject.decr("#{FPX}:key", 2).should == 5
+      subject.incr("#{FPX}:key", 4).should == 9
+      subject.incr("#{FPX}:key", 3.9).should == 12
+      subject.decr("#{FPX}:key", 2.8).should == 10
+
+      subject.set "#{FPX}:keyN", "100"
+      subject.incr("#{FPX}:keyN", 2).should == 102
+
+      subject.set "#{FPX}:keyN", "100"
+      subject.decr("#{FPX}:keyN", 2).should == 98
+
+      subject.set "#{FPX}:keyN", "5.9"
+      subject.incr("#{FPX}:keyN", 3.1).should == 8
+
+      subject.set "#{FPX}:keyS", "a"
+      subject.incr("#{FPX}:keyS", 4).should == 4
+      subject.get("#{FPX}:keyS").should == "4"
+
+      subject.set "#{FPX}:keyS", "a"
+      subject.decr("#{FPX}:keyS", 4).should == -4
+      subject.get("#{FPX}:keyS").should == "-4"
+    end
+
+    it 'should multi-get/set' do
+      subject.multi_set("#{FPX}:key4" => "x", "#{FPX}:key8" => "y", "#{FPX}:key9" => "z").should == 6
+      subject.multi_get(["#{FPX}:key4", "#{FPX}:key6", "#{FPX}:key9", "#{FPX}:key8"]).
+        should == ["x", nil, "z", "y"]
+    end
+
+    it 'should check existence of multiple keys' do
+      subject.multi_exists(["#{FPX}:key2", "#{FPX}:key3"]).should == [true, true]
+      subject.multi_exists(["#{FPX}:key2", "#{FPX}:key9", "#{FPX}:key3"]).should == [true, false, true]
+    end
+
+    it 'should multi-delete' do
+      keys = ["#{FPX}:key2", "#{FPX}:key3", "#{FPX}:key9"]
+      -> {
+        subject.multi_del(keys).should == 0
+      }.should change {
+        subject.multi_exists(keys)
+      }.from([true, true, false]).to([false, false, false])
+    end
+
+  end
+end