voldemort-rb 0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Alejandro Crosa
+
+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,46 @@
+Voldemort-client
+================
+
+# Requirements
+
+Since the communication between the client and the server is done using protocol buffers you'll need the ruby_protobuf gem found at http://code.google.com/p/ruby-protobuf/. 
+
+Examples
+=======
+
+# Basic Usage
+## Connecting and bootstrapping
+
+  client = VoldemortClient.new("test", "localhost:6666")
+
+## Storing a value
+
+  client.put("some key", "some value")
+
+## Reading a value
+
+  client.get("some key")
+  
+  you'll get
+  
+  => some value
+
+## deleting a value from a key
+
+  client.delete("some key")
+
+# Conflict resolution
+## Default
+
+Voldemort replies with versions of a value, it's up to the client to resolve the conflicts. By default the library will return the version that's most recent.
+
+## Custom
+
+You can override the default behavior and perform a custom resolution of the conflict, here's how to do so:
+
+  client = VoldemortClient.new("test", "localhost:6666") do |versions|
+     versions.first # just return the first version for example
+   end
+
+
+Copyright (c) 2010 Alejandro Crosa, released under the MIT license

data/Rakefile

@@ -0,0 +1,60 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'date'
+require 'spec/rake/spectask'
+
+GEM = 'Voldemort Client'
+GEM_NAME = 'voldemort_client'
+GEM_VERSION = '0.1'
+AUTHORS = ['Alejandro Crosa']
+EMAIL = "alejandrocrosa@gmail.com"
+HOMEPAGE = "http://github.com/acrosa/Voldemort-Ruby-Client"
+SUMMARY = "A Ruby client for the Voldemort distributed key value store"
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["LICENSE"]
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.authors = AUTHORS
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.add_development_dependency "rspec"
+  s.require_path = 'lib'
+  s.autorequire = GEM
+  s.files = %w(LICENSE README.md Rakefile) + Dir.glob("{lib,tasks,spec}/**/*")
+end
+
+task :default => :spec
+
+desc "Run specs"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = %w(-fs --color)
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the gem locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION}}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{GEM}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new(:rcov) do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.rcov = true
+end

data/lib/connection/connection.rb

@@ -0,0 +1,115 @@
+require 'rexml/document'
+
+class Connection
+  include REXML
+
+  attr_accessor :hosts          # The hosts from where we bootstrapped.
+  attr_accessor :nodes          # The array of VoldemortNodes available.
+  attr_accessor :db_name        # The DB store name.
+  attr_accessor :connected_node # The VoldemortNode we are connected to.
+  attr_accessor :request_count  # Used to track the number of request a node receives.
+  attr_accessor :request_limit_per_node # Limit the number of request per node.
+
+  STATUS_OK = "ok"
+  PROTOCOL  = "pb0"
+  DEFAULT_REQUEST_LIMIT_PER_NODE = 500
+
+  def initialize(db_name, hosts, request_limit_per_node = DEFAULT_REQUEST_LIMIT_PER_NODE)
+    self.db_name = db_name
+    self.hosts   = hosts
+    self.nodes   = hosts.collect{ |h|
+                    n = h.split(":")
+                    node = VoldemortNode.new
+                    node.host = n[0]
+                    node.port = n[1]
+                    node
+                   }
+    self.request_count = 0
+    self.request_limit_per_node = request_limit_per_node
+  end
+
+  def bootstrap
+    response = self.get_from("metadata", "cluster.xml", false)
+    xml = response[1][0][1]
+    self.nodes = self.parse_nodes_from(xml)
+    self.connect_to_random_node
+  rescue StandardError => e
+    raise("There was an error trying to bootstrap from the specified servers: #{e}")
+  end
+
+  def connect_to_random_node
+    nodes = self.nodes.sort_by { rand }
+    for node in nodes do
+      if self.connect_to(node.host, node.port)
+        self.connected_node = node
+        self.request_count = 0
+        return node
+      end
+    end
+  end
+
+  def parse_nodes_from(xml)
+    nodes = []
+    doc = REXML::Document.new(xml)
+    XPath.each(doc, "/cluster/server").each do |n|
+      node = VoldemortNode.new
+      node.id   = n.elements["id"].text
+      node.host = n.elements["host"].text
+      node.port = n.elements["socket-port"].text
+      node.http_port  = n.elements["http-port"].text
+      node.admin_port = n.elements["admin-port"].text
+      node.partitions = n.elements["partitions"].text
+      nodes << node
+    end
+    nodes
+  end
+
+  def protocol_version
+    PROTOCOL
+  end
+
+  def connect
+    self.connect!
+  end
+
+  def reconnect
+    self.reconnect!
+  end
+
+  def disconnect
+    self.disconnect!
+  end
+
+  def reconnect_when_errors_in(response = nil)
+    return unless response
+    self.reconnect! if response.error
+  end
+
+  def rebalance_connection?
+    self.request_count >= self.request_limit_per_node
+  end
+
+  def rebalance_connection_if_needed
+    self.reconnect if self.rebalance_connection?
+    self.request_count += 1
+  end
+
+  def get(key)
+    self.rebalance_connection_if_needed
+    self.get_from(self.db_name, key, true)
+  end
+
+  def get_all(keys)
+    self.rebalance_connection_if_needed
+    self.get_all_from(self.db_name, keys, true)
+  end
+
+  def put(key, value, version = nil, route = true)
+    self.rebalance_connection_if_needed
+    self.put_from(self.db_name, key, value, version, route)
+  end
+  
+  def delete(key)
+    self.delete_from(self.db_name, key)
+  end
+end

data/lib/connection/tcp_connection.rb

@@ -0,0 +1,171 @@
+require 'socket'
+require 'timeout'
+
+require File.join(File.dirname(__FILE__), "..", "protos", "voldemort-client.pb")
+
+class TCPConnection < Connection
+  include Voldemort
+
+  attr_accessor :socket
+
+  SOCKET_TIMEOUT = 3
+
+  def connect_to(host, port)
+    begin
+      timeout(SOCKET_TIMEOUT) do
+        self.socket = TCPSocket.open(host, port)
+        self.send_protocol_version
+        if(protocol_handshake_ok?)
+          return self.socket
+        else
+          raise "There was an error connecting to the node"
+        end
+      end
+    rescue Timeout::Error
+      raise "Timeout when connecting to node"
+    rescue
+      false
+    end
+  end
+
+  # performs a get using the specified parameters
+  #
+  def get_from(db_name, key, route = true)
+    request = VoldemortRequest.new
+    request.should_route = route
+    request.store = db_name
+    request.type = RequestType::GET
+    request.get = GetRequest.new
+    request.get.key = key
+
+    self.send(request)          # send the request
+    raw_response = self.receive # read the response
+    response = GetResponse.new.parse_from_string(raw_response) # compose the get object based on the raw response
+    reconnect_when_errors_in(response)
+    response
+  end
+
+  # performs a get using multiple keys
+  #
+  def get_all_from(db_name, keys, route = true)
+    request = VoldemortRequest.new
+    request.should_route = route
+    request.store = db_name
+    request.type = RequestType::GET_ALL
+    request.getAll = GetAllRequest.new
+    request.getAll.keys = keys
+
+    self.send(request)          # send the request
+    raw_response = self.receive # read the response
+    response = GetAllResponse.new.parse_from_string(raw_response) # compose the get object based on the raw response
+    reconnect_when_errors_in(response)
+    response
+  end
+
+  def put_from(db_name, key, value, version = nil, route = true)
+    version = get_version(key) unless version
+    request = VoldemortRequest.new
+    request.should_route = route
+    request.store = db_name
+    request.type = RequestType::PUT
+    request.put = PutRequest.new
+    request.put.key = key
+    request.put.versioned = Versioned.new
+    request.put.versioned.value = value
+    request.put.versioned.version = VectorClock.new
+    request.put.versioned.version.merge_from(version)
+
+    self.send(request)          # send the request
+    raw_response = self.receive # read the response
+    response = PutResponse.new.parse_from_string(raw_response)
+    reconnect_when_errors_in(response)
+
+    add_to_versions(version) # add version or increment when needed
+    version
+  end
+
+  def delete_from(db_name, key, version = nil, route = true)
+    version = get_version(key) unless version
+    request = VoldemortRequest.new
+    request.should_route = route
+    request.store  = db_name
+    request.type   = RequestType::DELETE
+    request.delete = DeleteRequest.new
+    request.delete.key = key
+    request.delete.version = VectorClock.new
+    request.delete.version.merge_from(version)
+
+    self.send(request)          # send the request
+    raw_response = self.receive # read the response
+    response = DeleteResponse.new.parse_from_string(raw_response)
+    reconnect_when_errors_in(response)
+    response.success
+  end
+
+  def add_to_versions(version)
+    entry = version.entries.detect { |e| e.node_id == self.connected_node.id.to_i }
+    if(entry)
+      entry.version += 1
+    else
+      entry = ClockEntry.new
+      entry.node_id = self.connected_node.id.to_i
+      entry.version = 1
+      version.entries << entry
+      version.timestamp = Time.new.to_i * 1000
+    end
+    version
+  end
+
+  def get_version(key)
+    other_version = get(key)[1][0]
+    if(other_version)
+      return other_version.version
+    else
+      version = VectorClock.new
+      version.timestamp = Time.new.to_i * 1000
+      return version
+    end
+  end
+
+  # unpack argument is N | Long, network (big-endian) byte order.
+  # from http://ruby-doc.org/doxygen/1.8.4/pack_8c-source.html
+  def receive
+    raw_size = self.socket.recv(4)
+    size = raw_size.unpack('N')
+    self.socket.recv(size[0])
+  rescue
+    self.reconnect!
+  end
+
+  # pack argument is N | Long, network (big-endian) byte order.
+  # from http://ruby-doc.org/doxygen/1.8.4/pack_8c-source.html
+  def send(request)
+    self.reconnect unless self.socket
+    bytes = request.serialize_to_string # helper method thanks to ruby-protobuf
+    self.socket.write([bytes.size].pack("N") + bytes)
+  rescue
+    self.disconnect!
+  end
+
+  def send_protocol_version
+    self.socket.write(self.protocol_version)
+  end
+
+  def protocol_handshake_ok?
+    self.socket.recv(2) == STATUS_OK
+  end
+
+  def connect!
+    self.connect_to_random_node
+  end
+
+  def reconnect!
+    self.disconnect! if self.socket
+    self.connect!
+  end
+
+  def disconnect!
+    self.socket.close if self.socket
+    self.socket = nil
+  end
+end

data/lib/connection/voldemort_node.rb

@@ -0,0 +1,3 @@
+class VoldemortNode
+  attr_accessor :id, :host, :port, :http_port, :admin_port, :partitions
+end

data/lib/protos/voldemort-client.pb.rb

@@ -0,0 +1,190 @@
+### Generated by rprotoc. DO NOT EDIT!
+### <proto file: voldemort-client.proto>
+# package voldemort;
+# 
+# option java_package = "voldemort.client.protocol.pb";
+# option java_outer_classname = "VProto";
+# option optimize_for = SPEED;
+# 
+# message ClockEntry {
+#   required int32 node_id = 1;
+#   required int64 version = 2;
+# }
+# 
+# message VectorClock {
+#   repeated ClockEntry entries = 1;
+#   optional int64 timestamp = 2;
+# }
+# 
+# message Versioned {
+#   required bytes value = 1;
+#   required VectorClock version = 2;
+# }
+# 
+# message Error {
+#   required int32 error_code = 1;
+#   required string error_message = 2;
+# }
+# 
+# message KeyedVersions {
+#   required bytes key = 1;
+#   repeated Versioned versions = 2;
+# }
+# 
+# message GetRequest {
+#   optional bytes key = 1;
+# }
+# 
+# message GetResponse {
+#   repeated Versioned versioned = 1;
+#   optional Error error = 2;
+# }
+# 
+# message GetVersionResponse {
+#   repeated VectorClock versions = 1;
+#   optional Error error = 2;
+# }
+# 
+# message GetAllRequest {
+#   repeated bytes keys = 1;
+# }
+# 
+# message GetAllResponse {
+#   repeated KeyedVersions values = 1;
+#   optional Error error = 2;
+# }
+# 
+# message PutRequest {
+#   required bytes key = 1;
+#   required Versioned versioned = 2;
+# }
+# 
+# message PutResponse {
+#   optional Error error = 1;
+# }
+# 
+# message DeleteRequest {
+#   required bytes key = 1;
+#   required VectorClock version = 2;
+# }
+# 
+# message DeleteResponse {
+#   required bool success = 1;
+#   optional Error error = 2;
+# }
+# 
+# enum RequestType {
+#   GET = 0;
+#   GET_ALL = 1;
+#   PUT = 2;
+#   DELETE = 3;
+#   GET_VERSION = 4;
+# }
+# 
+# 
+# message VoldemortRequest {
+#   required RequestType type = 1;
+#   required bool should_route = 2 [default = false];
+#   required string store = 3;
+#   optional GetRequest get = 4;
+#   optional GetAllRequest getAll = 5;
+#   optional PutRequest put = 6;
+#   optional DeleteRequest delete = 7;
+#   optional int32 requestRouteType = 8;
+# }
+require 'protobuf/message/message'
+require 'protobuf/message/enum'
+require 'protobuf/message/service'
+require 'protobuf/message/extend'
+
+module Voldemort
+  ::Protobuf::OPTIONS[:"java_package"] = "voldemort.client.protocol.pb"
+  ::Protobuf::OPTIONS[:"java_outer_classname"] = "VProto"
+  ::Protobuf::OPTIONS[:"optimize_for"] = :SPEED
+  class ClockEntry < ::Protobuf::Message
+    defined_in __FILE__
+    required :int32, :node_id, 1
+    required :int64, :version, 2
+  end
+  class VectorClock < ::Protobuf::Message
+    defined_in __FILE__
+    repeated :ClockEntry, :entries, 1
+    optional :int64, :timestamp, 2
+  end
+  class Versioned < ::Protobuf::Message
+    defined_in __FILE__
+    required :bytes, :value, 1
+    required :VectorClock, :version, 2
+  end
+  class Error < ::Protobuf::Message
+    defined_in __FILE__
+    required :int32, :error_code, 1
+    required :string, :error_message, 2
+  end
+  class KeyedVersions < ::Protobuf::Message
+    defined_in __FILE__
+    required :bytes, :key, 1
+    repeated :Versioned, :versions, 2
+  end
+  class GetRequest < ::Protobuf::Message
+    defined_in __FILE__
+    optional :bytes, :key, 1
+  end
+  class GetResponse < ::Protobuf::Message
+    defined_in __FILE__
+    repeated :Versioned, :versioned, 1
+    optional :Error, :error, 2
+  end
+  class GetVersionResponse < ::Protobuf::Message
+    defined_in __FILE__
+    repeated :VectorClock, :versions, 1
+    optional :Error, :error, 2
+  end
+  class GetAllRequest < ::Protobuf::Message
+    defined_in __FILE__
+    repeated :bytes, :keys, 1
+  end
+  class GetAllResponse < ::Protobuf::Message
+    defined_in __FILE__
+    repeated :KeyedVersions, :values, 1
+    optional :Error, :error, 2
+  end
+  class PutRequest < ::Protobuf::Message
+    defined_in __FILE__
+    required :bytes, :key, 1
+    required :Versioned, :versioned, 2
+  end
+  class PutResponse < ::Protobuf::Message
+    defined_in __FILE__
+    optional :Error, :error, 1
+  end
+  class DeleteRequest < ::Protobuf::Message
+    defined_in __FILE__
+    required :bytes, :key, 1
+    required :VectorClock, :version, 2
+  end
+  class DeleteResponse < ::Protobuf::Message
+    defined_in __FILE__
+    required :bool, :success, 1
+    optional :Error, :error, 2
+  end
+  class RequestType < ::Protobuf::Enum
+    defined_in __FILE__
+    GET = 0
+    GET_ALL = 1
+    PUT = 2
+    DELETE = 3
+    GET_VERSION = 4
+  end
+  class VoldemortRequest < ::Protobuf::Message
+    defined_in __FILE__
+    required :RequestType, :type, 1
+    required :bool, :should_route, 2, :default => false
+    required :string, :store, 3
+    optional :GetRequest, :get, 4
+    optional :GetAllRequest, :getAll, 5
+    optional :PutRequest, :put, 6
+    optional :DeleteRequest, :delete, 7
+    optional :int32, :requestRouteType, 8
+  end
+end

data/lib/protos/voldemort-client.proto

@@ -0,0 +1,92 @@
+package voldemort;
+
+option java_package = "voldemort.client.protocol.pb";
+option java_outer_classname = "VProto";
+option optimize_for = SPEED;
+
+message ClockEntry {
+  required int32 node_id = 1;
+  required int64 version = 2;
+}
+
+message VectorClock {
+  repeated ClockEntry entries = 1;
+  optional int64 timestamp = 2;
+}
+
+message Versioned {
+  required bytes value = 1;
+  required VectorClock version = 2;
+}
+
+message Error {
+  required int32 error_code = 1;
+  required string error_message = 2;
+}
+
+message KeyedVersions {
+  required bytes key = 1;
+  repeated Versioned versions = 2;
+}
+
+message GetRequest {
+  optional bytes key = 1;
+}
+
+message GetResponse {
+  repeated Versioned versioned = 1;
+  optional Error error = 2;
+}
+
+message GetVersionResponse {
+  repeated VectorClock versions = 1;
+  optional Error error = 2;
+}
+
+message GetAllRequest {
+  repeated bytes keys = 1;
+}
+
+message GetAllResponse {
+  repeated KeyedVersions values = 1;
+  optional Error error = 2;
+}
+
+message PutRequest {
+  required bytes key = 1;
+  required Versioned versioned = 2;
+}
+
+message PutResponse {
+  optional Error error = 1;
+}
+
+message DeleteRequest {
+  required bytes key = 1;
+  required VectorClock version = 2;
+}
+
+message DeleteResponse {
+  required bool success = 1;
+  optional Error error = 2;
+}
+
+enum RequestType {
+  GET = 0;
+  GET_ALL = 1;
+  PUT = 2;
+  DELETE = 3;
+  GET_VERSION = 4;
+}
+
+
+message VoldemortRequest {
+  required RequestType type = 1;
+  required bool should_route = 2 [default = false];
+  required string store = 3;
+  optional GetRequest get = 4;
+  optional GetAllRequest getAll = 5;
+  optional PutRequest put = 6;
+  optional DeleteRequest delete = 7;
+  optional int32 requestRouteType = 8;
+}

data/lib/voldemort-rb.rb

@@ -0,0 +1,47 @@
+require File.join(File.dirname(__FILE__), "connection", "voldemort_node")
+require File.join(File.dirname(__FILE__), "connection", "connection")
+require File.join(File.dirname(__FILE__), "connection", "tcp_connection")
+
+class VoldemortClient
+  attr_accessor :connection
+  attr_accessor :conflict_resolver
+
+  def initialize(db_name, *hosts, &block)
+    self.conflict_resolver = block unless !block
+    self.connection = TCPConnection.new(db_name, hosts) # implement and modifiy if you don't want to use TCP protobuf.
+    self.connection.bootstrap
+  end
+
+  def get(key)
+    versions = self.connection.get(key)
+    version  = self.resolve_conflicts(versions.versioned)
+    if version
+      version.value
+    else
+      nil
+    end
+  end
+
+  def get_all(keys)
+    all_version = self.connection.get_all(keys)
+    values = {}
+    all_version.values.collect do |v|
+      values[v.key] = self.resolve_conflicts(v.versions).value
+    end
+    values
+  end
+
+  def put(key, value, version = nil)
+    self.connection.put(key, value)
+  end
+
+  def delete(key)
+    self.connection.delete(key)
+  end
+
+  def resolve_conflicts(versions)
+    return self.conflict_resolver.call(versions) if self.conflict_resolver
+    # by default just return the version that has the most recent timestamp.
+    versions.max { |a, b| a.version.timestamp <=> b.version.timestamp }
+  end
+end

data/spec/connection_spec.rb

@@ -0,0 +1,97 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Connection do
+
+  before(:each) do
+    @connection = Connection.new("test", "localhost:6666")
+  end
+
+  describe "default methods" do
+
+    it "should support connect" do
+      @connection.should respond_to(:connect)
+    end
+
+    it "should support reconnect" do
+      @connection.should respond_to(:reconnect)
+    end
+
+    it "should support disconnect" do
+      @connection.should respond_to(:disconnect)
+    end
+
+    it "should parse nodes from xml" do
+      @connection.should respond_to(:parse_nodes_from)
+      xml = "<cluster>\r\n  <name>mycluster</name>\r\n  <server>\r\n    <id>0</id>\r\n    <host>localhost</host>\r\n    <http-port>8081</http-port>\r\n    <socket-port>6666</socket-port>\r\n    <admin-port>6667</admin-port>\r\n    <partitions>0, 1</partitions>\r\n  </server>\r\n</cluster>"
+      nodes = @connection.parse_nodes_from(xml)
+      nodes.first.host.should eql("localhost")
+      nodes.first.port.should eql("6666")
+      nodes.length.should eql(1)
+    end
+
+    it "should tell to wich node is connected to" do
+      @connection.should respond_to(:connected_node)
+      node = mock(VoldemortNode)
+      node.stub!(:host).and_return("localhost")
+      node.stub!(:port).and_return(6666)
+      @connection.nodes.stub!(:sort_by).and_return([node])
+      @connection.stub!(:connect_to).and_return(true)
+      @connection.connect_to_random_node
+      @connection.connected_node.should eql(node)
+    end
+
+    it "should use protobuf by default" do
+      @connection.protocol_version.should eql("pb0")
+    end
+
+    it "should use the hosts specified" do
+      connection = Connection.new("test", "localhost:6666")
+      connection.hosts.should eql("localhost:6666")
+      connection.nodes.length.should eql(1)
+      connection2 = Connection.new("test", ["localhost:6666", "localhost:7777"])
+      connection2.hosts.should eql(["localhost:6666", "localhost:7777"])
+      connection2.nodes.length.should eql(2)
+    end
+  end
+
+  describe "rebalance nodes by evaluating number of requests" do
+    
+    it "should have a request_count and request_limit_per_node per node connection" do
+      @connection.should respond_to(:request_count)
+      @connection.should respond_to(:request_limit_per_node)
+    end
+    
+    it "should tell if the request limit per node was reached" do
+      @connection.request_count = 0
+      @connection.request_limit_per_node = 10
+      @connection.rebalance_connection?.should eql(false)
+      @connection.request_count = 11
+      @connection.request_limit_per_node = 10
+      @connection.rebalance_connection?.should eql(true)
+    end
+    
+    it "should reconnect every N number of requests" do
+      @connection.should_receive(:rebalance_connection?).and_return(true)
+      @connection.should_receive(:reconnect).and_return(true)
+      @connection.rebalance_connection_if_needed
+    end
+    
+    it "should not reconnect if it haven't reached the limit of requests" do
+      @connection.should_receive(:rebalance_connection?).and_return(false)
+      @connection.should_not_receive(:reconnect).and_return(false)
+      @connection.rebalance_connection_if_needed
+    end
+    
+    it "should rebalance if needed when calling get, get_all or put" do
+      @connection.should_receive(:rebalance_connection_if_needed).exactly(3).times.and_return(true)
+      @connection.stub!(:get_from).and_return(true)
+      @connection.stub!(:get_all_from).and_return(true)
+      @connection.stub!(:put_from).and_return(true)
+      @connection.stub!(:delete_from).and_return(true)
+      @connection.get("value")
+      @connection.put("value", "value")
+      @connection.get_all(["key1", "key2"])
+      @connection.delete("key")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'rubygems'
+require 'voldemort_client'

data/spec/tcp_connection_spec.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe TCPConnection do
+
+  before(:each) do
+    @connection = TCPConnection.new("test", "localhost:6666")
+  end
+
+  describe "connection mechanism" do
+
+    it "should connect to a specified host" do
+      @connection.should respond_to(:connect_to)
+      mock_socket = mock(TCPSocket)
+      TCPSocket.should_receive(:open).and_return(mock_socket)
+      @connection.should_receive(:send_protocol_version).and_return(true)
+      @connection.should_receive(:protocol_handshake_ok?).and_return(true)
+      @connection.connect_to("localhost", 6666).should eql(mock_socket)
+    end
+
+    it "should send the protocol" do
+      @connection.should respond_to(:send_protocol_version)
+      mock_socket = mock(TCPSocket)
+      @connection.stub!(:socket).and_return(mock_socket)
+      mock_socket.should_receive(:write).with(Connection::PROTOCOL).and_return(true)
+      @connection.send_protocol_version.should eql(true)
+    end
+
+    it "should receive the protocol handshake response" do
+      @connection.should respond_to(:protocol_handshake_ok?)
+      mock_socket = mock(TCPSocket)
+      @connection.stub!(:socket).and_return(mock_socket)
+      mock_socket.should_receive(:recv).with(2).and_return(Connection::STATUS_OK)
+      @connection.protocol_handshake_ok?.should eql(true)
+    end
+
+    it "should have a socket" do
+      @connection.should respond_to(:socket)
+    end
+  end
+end

data/spec/voldemort_client_spec.rb

@@ -0,0 +1,97 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'lib/protos/voldemort-client.pb'
+
+include Voldemort
+
+describe VoldemortClient do
+
+  before(:each) do
+    connection = mock(TCPConnection)
+    node = mock(VoldemortNode)
+    connection.stub!(:bootstrap).and_return(node)
+    TCPConnection.stub!(:new).and_return(connection)
+    @client = VoldemortClient.new("test", "localhost:6666")
+    @client.stub!(:connection).and_return(connection)
+  end
+
+  describe "connection abstraction" do
+   it "should have a connection" do
+     @client.should respond_to(:connection)
+   end
+
+   it "should initialize the connection" do
+     @client.connection.should_not be(nil)
+   end
+ end
+
+ describe "default methods" do
+
+   it "should support get" do
+     @client.should respond_to(:get)
+     version = mock(Versioned)
+     v = mock(VectorClock)
+     v.stub!(:value).and_return("some value")
+     version.stub!(:versioned).and_return([v])
+     @client.connection.should_receive(:get).with("key").and_return(version)
+     @client.get("key").should eql("some value")
+   end
+   
+   it "should support get all" do
+     @client.should respond_to(:get_all)
+     version = mock(Versioned)
+     v = mock(VectorClock)
+     v.stub!(:value).and_return("some value")
+     v.stub!(:key).and_return("key")
+     v.stub!(:versions).and_return([v])
+     version.stub!(:values).and_return([v])
+     @client.connection.should_receive(:get_all).with(["key", "key2"]).and_return(version)
+     @client.get_all(["key", "key2"]).should eql({ "key" => "some value" }) # we pretend key2 doesn't exist
+   end
+
+   it "should support put" do
+     @client.should respond_to(:put)
+     @client.connection.should_receive(:put).with("key", "value").and_return("version")
+     @client.put("key", "value").should eql("version")
+   end
+
+   it "should support delete" do
+     @client.should respond_to(:delete)
+     @client.connection.should_receive(:delete).with("key").and_return(true)
+     @client.delete("key").should eql(true)
+   end
+ end
+
+ describe "default resolver" do
+
+   before(:each) do
+     @old_versioned = Versioned.new
+     @old_versioned.value = "old value"
+     @old_versioned.version = VectorClock.new
+     @old_versioned.version.timestamp = (Time.now-86400).to_i * 1000
+
+     @new_versioned = Versioned.new
+     @new_versioned.value = "new value"
+     @new_versioned.version = VectorClock.new
+     @new_versioned.version.timestamp = (Time.now).to_i * 1000
+
+     @versions = []
+     @versions << @old_versioned
+     @versions << @new_versioned
+   end
+
+   it "should have a default resolver" do
+     @client.should respond_to(:conflict_resolver)
+   end
+
+   it "should pick a default version form a list of versions, and should be the most recent value" do
+     @client.resolve_conflicts(@versions).should eql(@new_versioned)
+   end
+
+   it "should allow a custom conflict resolver" do
+     @client = VoldemortClient.new("test", "localhost:6666") do |versions|
+       versions.first # just return the first version
+     end
+     @client.resolve_conflicts(@versions).should eql(@old_versioned)
+   end
+ end
+end

data/spec/voldemort_node_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe VoldemortNode do
+
+  before(:each) do
+    @voldemort_node = VoldemortNode.new
+  end
+
+  describe "default methods" do
+
+    it "should have id, host, port, http_port, admin_port and partitions" do
+      [:id, :host, :port, :http_port, :admin_port, :partitions].each do |m|
+        @voldemort_node.should respond_to(m)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: voldemort-rb
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Alejandro Crosa
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-05 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: voldemort-rb allows you to connect to the Voldemort descentralized key value store.
+email: 
+- alejandrocrosa@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- CHANGELOG
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/voldemort-rb.rb
+- lib/connection/connection.rb
+- lib/connection/tcp_connection.rb
+- lib/connection/voldemort_node.rb
+- lib/protos/voldemort-client.pb.rb
+- lib/protos/voldemort-client.proto
+- spec/connection_spec.rb
+- spec/tcp_connection_spec.rb
+- spec/voldemort_node_spec.rb
+- spec/voldemort_client_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/acrosa/voldemort-rb
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A Ruby client for the Voldemort distributed key value store
+test_files: []
+