riak-client 2.4.1 → 2.5.0

data/lib/riak/robject.rb

@@ -1,6 +1,7 @@
 require 'forwardable'
 require 'riak/rcontent'
 require 'riak/conflict'
+require 'riak/tombstone'
 require 'riak/util/translation'
 require 'riak/util/escape'
 require 'riak/bucket'
@@ -141,6 +142,7 @@ module Riak
     # @raise [Conflict] if the object has siblings
     def store(options = {})
       fail Conflict, self if conflict?
+      fail Tombstone, self if tombstone?
       raise ArgumentError, t('content_type_undefined') unless content_type.present?
       raise ArgumentError, t('zero_length_key') if key == ''
       # NB: key can be nil to indicate that Riak should generate one
@@ -188,12 +190,26 @@ module Riak
     # @raise [Conflict] when multiple siblings are present
     def content
       raise Conflict, self if conflict?
+      raise Tombstone, self if tombstone?
       @siblings.first
     end
 
     # @return [true,false] Whether this object has conflicting sibling objects (divergent vclocks)
     def conflict?
-      @siblings.size != 1
+      @siblings.size > 1
+    end
+
+    # @return [true,false] Whether this object is a Riak tombstone (has no RContents, but contains a vclock)
+    def tombstone?
+      @siblings.empty? && !@vclock.nil?
+    end
+
+    # Will "revive" a tombstone object by giving it a new content.
+    # If the object is not a tombstone, will just return self.
+    # @return [Riak::RObject] self
+    def revive
+      @siblings = [ RContent.new(self) ] if tombstone?
+      self
     end
 
     # @return [String] A representation suitable for IRB and debugging output

data/lib/riak/search/result_document.rb

@@ -92,6 +92,15 @@ module Riak::Search
       return crdt if check_type_class Riak::Crdt::Set
     end
 
+    # If the result document describes a set, return it.
+    #
+    # @return [Riak::Crdt::HyperLogLog]
+    # @raise [Riak::CrdtError::NotACrdt] if the result is not a CRDT
+    # @raise [Riak::CrdtError::UnexpectedDataType] if the CRDT is not a hyper_log_log
+    def hyper_log_log
+      return crdt if check_type_class Riak::Crdt::HyperLogLog
+    end
+
     # Provides access to other parts of the result document without
     # materializing them. Useful when querying non-default fields.
     #

data/lib/riak/stamp.rb

@@ -1,77 +1,77 @@
-require 'riak/client'
-require 'riak/util/translation'
-require 'thread'
-
-module Riak
-  # Implements a client-side form of monotonically-increasing k-sorted
-  # unique identifiers.  These are useful for key generation if your
-  # data is time-sequential and needs to be sorted by key, perhaps in
-  # Riak Search. Inspired by Twitter's Snowflake project.
-  class Stamp
-    attr_reader :client
-
-    CLIENT_ID_MASK = (1 << 10) - 1
-    SEQUENCE_MASK = (1 << 12) - 1
-    TIMESTAMP_MASK = (1 << 41) - 1
-    SEQUENCE_SHIFT = 10
-    TIMESTAMP_SHIFT = 22
-
-    # @param [Client] client a {Riak::Client} which will be used for
-    #   the "worker ID" component of the stamp.
-    # @see Client#stamp
-    def initialize(client)
-      @client = client
-      @mutex = Mutex.new
-      @timestamp = time_gen
-      @sequence = 0
-    end
-
-    # Generates a k-sorted unique ID for use as a key or other
-    # disambiguation purposes.
-    def next
-      @mutex.synchronize do
-        now = time_gen
-        if @timestamp == now
-          @sequence = (@sequence + 1) & SEQUENCE_MASK
-          now = wait_for_next_ms(@timestamp) if @sequence == 0
-        else
-          @sequence = 0
-        end
-
-        raise BackwardsClockError.new(@timestamp - now) if now < @timestamp
-
-        @timestamp = now
-        @timestamp << TIMESTAMP_SHIFT | @sequence << SEQUENCE_SHIFT | client_id
-      end
-    end
-
-    private
-    def client_id
-      case id = @client.client_id
-      when Integer
-        id & CLIENT_ID_MASK
-      else
-        id.hash & CLIENT_ID_MASK
-      end
-    end
-
-    def time_gen
-      (Time.now.to_f * 1000).floor & TIMESTAMP_MASK
-    end
-
-    def wait_for_next_ms(start)
-      now = time_gen
-      now = time_gen while now <= start
-      now
-    end
-  end
-
-  # Raised when calling {Stamp#next} and NTP or some other external
-  # event has moved the system clock backwards.
-  class BackwardsClockError < StandardError
-    include Util::Translation
-    def initialize(delay)
-      super t('backwards_clock', :delay => delay)
-    end
-  end
-end
+require 'riak/client'
+require 'riak/util/translation'
+require 'thread'
+
+module Riak
+  # Implements a client-side form of monotonically-increasing k-sorted
+  # unique identifiers.  These are useful for key generation if your
+  # data is time-sequential and needs to be sorted by key, perhaps in
+  # Riak Search. Inspired by Twitter's Snowflake project.
+  class Stamp
+    attr_reader :client
+
+    CLIENT_ID_MASK = (1 << 10) - 1
+    SEQUENCE_MASK = (1 << 12) - 1
+    TIMESTAMP_MASK = (1 << 41) - 1
+    SEQUENCE_SHIFT = 10
+    TIMESTAMP_SHIFT = 22
+
+    # @param [Client] client a {Riak::Client} which will be used for
+    #   the "worker ID" component of the stamp.
+    # @see Client#stamp
+    def initialize(client)
+      @client = client
+      @mutex = Mutex.new
+      @timestamp = time_gen
+      @sequence = 0
+    end
+
+    # Generates a k-sorted unique ID for use as a key or other
+    # disambiguation purposes.
+    def next
+      @mutex.synchronize do
+        now = time_gen
+        if @timestamp == now
+          @sequence = (@sequence + 1) & SEQUENCE_MASK
+          now = wait_for_next_ms(@timestamp) if @sequence == 0
+        else
+          @sequence = 0
+        end
+
+        raise BackwardsClockError.new(@timestamp - now) if now < @timestamp
+
+        @timestamp = now
+        @timestamp << TIMESTAMP_SHIFT | @sequence << SEQUENCE_SHIFT | client_id
+      end
+    end
+
+    private
+    def client_id
+      case id = @client.client_id
+      when Integer
+        id & CLIENT_ID_MASK
+      else
+        id.hash & CLIENT_ID_MASK
+      end
+    end
+
+    def time_gen
+      (Time.now.to_f * 1000).floor & TIMESTAMP_MASK
+    end
+
+    def wait_for_next_ms(start)
+      now = time_gen
+      now = time_gen while now <= start
+      now
+    end
+  end
+
+  # Raised when calling {Stamp#next} and NTP or some other external
+  # event has moved the system clock backwards.
+  class BackwardsClockError < StandardError
+    include Util::Translation
+    def initialize(delay)
+      super t('backwards_clock', :delay => delay)
+    end
+  end
+end

data/lib/riak/tombstone.rb

@@ -0,0 +1,13 @@
+require 'riak/util/translation'
+
+module Riak
+  # Raised when a tombstone object (i.e. has vclock, but no rcontent values) is
+  # stored or manipulated as if it had a single value.
+  class Tombstone < StandardError
+    include Util::Translation
+
+    def initialize(robject)
+      super t('tombstone_object', :robject => robject.inspect)
+    end
+  end
+end

data/lib/riak/util/tcp_socket_extensions.rb

@@ -1,58 +1,58 @@
-require 'time'
-require 'timeout'
-require 'socket'
-
-# Borrowed from Webrat and Selenium client, watches for TCP port
-# liveness of the spawned server.
-# @private
-class TCPSocket
-  def self.wait_for_service(options)
-    verbose_wait until listening_service?(options)
-  end
-
-  def self.wait_for_service_termination(options)
-    verbose_wait while listening_service?(options)
-  end
-
-  def self.listening_service?(options)
-    Timeout::timeout(options[:timeout] || 20) do
-      begin
-        socket = TCPSocket.new(options[:host], options[:port])
-        socket.close unless socket.nil?
-        true
-      rescue Errno::ECONNREFUSED,
-        Errno::EBADF           # Windows
-        false
-      end
-    end
-  end
-
-  def self.verbose_wait
-    # Removed the puts call so as not to clutter up test output.
-    sleep 2
-  end
-
-  def self.wait_for_service_with_timeout(options)
-    start_time = Time.now
-
-    until listening_service?(options)
-      verbose_wait
-
-      if options[:timeout] && (Time.now > start_time + options[:timeout])
-        raise SocketError.new("Socket did not open within #{options[:timeout]} seconds")
-      end
-    end
-  end
-
-  def self.wait_for_service_termination_with_timeout(options)
-    start_time = Time.now
-
-    while listening_service?(options)
-      verbose_wait
-
-      if options[:timeout] && (Time.now > start_time + options[:timeout])
-        raise SocketError.new("Socket did not terminate within #{options[:timeout]} seconds")
-      end
-    end
-  end
-end
+require 'time'
+require 'timeout'
+require 'socket'
+
+# Borrowed from Webrat and Selenium client, watches for TCP port
+# liveness of the spawned server.
+# @private
+class TCPSocket
+  def self.wait_for_service(options)
+    verbose_wait until listening_service?(options)
+  end
+
+  def self.wait_for_service_termination(options)
+    verbose_wait while listening_service?(options)
+  end
+
+  def self.listening_service?(options)
+    Timeout::timeout(options[:timeout] || 20) do
+      begin
+        socket = TCPSocket.new(options[:host], options[:port])
+        socket.close unless socket.nil?
+        true
+      rescue Errno::ECONNREFUSED,
+        Errno::EBADF           # Windows
+        false
+      end
+    end
+  end
+
+  def self.verbose_wait
+    # Removed the puts call so as not to clutter up test output.
+    sleep 2
+  end
+
+  def self.wait_for_service_with_timeout(options)
+    start_time = Time.now
+
+    until listening_service?(options)
+      verbose_wait
+
+      if options[:timeout] && (Time.now > start_time + options[:timeout])
+        raise SocketError.new("Socket did not open within #{options[:timeout]} seconds")
+      end
+    end
+  end
+
+  def self.wait_for_service_termination_with_timeout(options)
+    start_time = Time.now
+
+    while listening_service?(options)
+      verbose_wait
+
+      if options[:timeout] && (Time.now > start_time + options[:timeout])
+        raise SocketError.new("Socket did not terminate within #{options[:timeout]} seconds")
+      end
+    end
+  end
+end

data/lib/riak/version.rb

@@ -1,3 +1,3 @@
 module Riak
-  VERSION = "2.4.1"
+  VERSION = "2.5.0"
 end

data/spec/failover/failover.rb

@@ -1,59 +1,59 @@
-$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../../lib')
-require 'riak'
-
-# This is not a formal spec yet. It's designed to be run agains a local dev
-# cluster while you bring nodes up and down.
-[
-  {:protocol => 'pbc', :protobuffs_backend => :Beefcake},
-  {:protocol => 'http', :http_backend => :NetHTTP},
-  {:protocol => 'http', :http_backend => :Excon}
-].each do |opts|
-  @client = Riak::Client.new(
-    {
-      :nodes => (1..3).map { |i|
-        {
-          :http_port => 8090 + i,
-          :pb_port => 8080 + i
-        }
-      }
-    }.merge(opts)
-  )
-
-  errors = []
-  p opts
-
-  n = 10
-  c = 1000
-
-  (0...n).map do |t|
-    Thread.new do
-      # Generate a stream of put reqs. Put a . for each success, an X for
-      # each failure.
-      c.times do |i|
-        begin
-          o = @client['test'].new("#{t}:#{i}")
-          o.content_type = 'text/plain'
-          o.data = i.to_s
-          o.store
-          o2 = @client['test'].get("#{t}:#{i}")
-          o2.data == i.to_s or raise "wrong data"
-          print '.'
-        rescue => e
-          print 'X'
-          errors << e
-        end
-      end
-    end
-  end.each do |thread|
-    thread.join
-  end
-
-  # Put errors
-  puts
-  errors.each do |e|
-    puts e.inspect
-    puts e.backtrace.map { |x| "  #{x}" }.join("\n")
-  end
-
-  puts "\n\n"
-end
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../../lib')
+require 'riak'
+
+# This is not a formal spec yet. It's designed to be run agains a local dev
+# cluster while you bring nodes up and down.
+[
+  {:protocol => 'pbc', :protobuffs_backend => :Beefcake},
+  {:protocol => 'http', :http_backend => :NetHTTP},
+  {:protocol => 'http', :http_backend => :Excon}
+].each do |opts|
+  @client = Riak::Client.new(
+    {
+      :nodes => (1..3).map { |i|
+        {
+          :http_port => 8090 + i,
+          :pb_port => 8080 + i
+        }
+      }
+    }.merge(opts)
+  )
+
+  errors = []
+  p opts
+
+  n = 10
+  c = 1000
+
+  (0...n).map do |t|
+    Thread.new do
+      # Generate a stream of put reqs. Put a . for each success, an X for
+      # each failure.
+      c.times do |i|
+        begin
+          o = @client['test'].new("#{t}:#{i}")
+          o.content_type = 'text/plain'
+          o.data = i.to_s
+          o.store
+          o2 = @client['test'].get("#{t}:#{i}")
+          o2.data == i.to_s or raise "wrong data"
+          print '.'
+        rescue => e
+          print 'X'
+          errors << e
+        end
+      end
+    end
+  end.each do |thread|
+    thread.join
+  end
+
+  # Put errors
+  puts
+  errors.each do |e|
+    puts e.inspect
+    puts e.backtrace.map { |x| "  #{x}" }.join("\n")
+  end
+
+  puts "\n\n"
+end