riak-client 2.2.0.pre1 → 2.2.0

data/lib/riak/client/beefcake/socket.rb

@@ -12,7 +12,7 @@ module Riak
         include Client::BeefcakeMessageCodes
         # Only create class methods, don't initialize
         class << self
-          def new(host, port, options={})
+          def new(host, port, options = {})
             return start_tcp_socket(host, port) if options[:authentication].blank?
             return start_tls_socket(host, port, options[:authentication])
           end
@@ -217,7 +217,7 @@ module Riak
 
             # Write a protocol buffers message to whatever the current
             # socket is.
-            def write_message(code, message='')
+            def write_message(code, message = '')
               if code.is_a? Symbol
                 code = BeefcakeMessageCodes.index code
               end

data/lib/riak/client/beefcake_protobuffs_backend.rb

@@ -81,7 +81,7 @@ module Riak
         return true
       end
 
-      def fetch_object(bucket, key, options={})
+      def fetch_object(bucket, key, options = {})
         options = prune_unsupported_options(:GetReq, normalize_quorums(options))
         bucket = Bucket === bucket ? bucket.name : bucket
         req = RpbGetReq.new(options.merge(:bucket => maybe_encode(bucket), :key => maybe_encode(key)))
@@ -99,9 +99,10 @@ module Riak
         load_object(resp, template)
       end
 
-      def reload_object(robject, options={})
+      def reload_object(robject, options = {})
         options = normalize_quorums(options)
         options[:bucket] = maybe_encode(robject.bucket.name)
+        options[:type] = maybe_encode(robject.bucket.type.name) if robject.bucket.needs_type?
         options[:key] = maybe_encode(robject.key)
         options[:if_modified] = maybe_encode Base64.decode64(robject.vclock) if robject.vclock
         req = RpbGetReq.new(prune_unsupported_options(:GetReq, options))
@@ -118,7 +119,7 @@ module Riak
         load_object(resp, robject)
       end
 
-      def store_object(robject, options={})
+      def store_object(robject, options = {})
         options[:return_body] ||= options[:returnbody]
         options = normalize_quorums(options)
         if robject.prevent_stale_writes
@@ -144,8 +145,11 @@ module Riak
         load_object resp, robject
       end
 
-      def delete_object(bucket, key, options={})
-        bucket = Bucket === bucket ? bucket.name : bucket
+      def delete_object(bucket, key, options = {})
+        if bucket.is_a? Bucket
+          options[:type] = bucket.type.name if bucket.needs_type?
+          bucket = bucket.name
+        end
         options = normalize_quorums(options)
         options[:bucket] = maybe_encode(bucket)
         options[:key] = maybe_encode(key)
@@ -156,24 +160,45 @@ module Riak
           p.write :DelReq, req
           p.expect :DelResp
         end
-        
+
         return true
       end
 
-      def get_counter(bucket, key, options={})
-        bucket = bucket.name if bucket.is_a? Bucket 
+      def get_preflist(bucket, key, type = nil, options = {})
+        if type.nil? && bucket.is_a?(Riak::BucketTyped::Bucket)
+          type = bucket.type.name
+        end
+        bucket = bucket.name if bucket.is_a? Bucket
+        type = type.name if type.is_a? BucketType
+
+        message = RpbGetBucketKeyPreflistReq.new(
+          bucket: bucket,
+          key: key,
+          type: type
+        )
+
+        resp = protocol do |p|
+          p.write :GetBucketKeyPreflistReq, message
+          p.expect :GetBucketKeyPreflistResp, RpbGetBucketKeyPreflistResp
+        end
+
+        resp.preflist
+      end
+
+      def get_counter(bucket, key, options = {})
+        bucket = bucket.name if bucket.is_a? Bucket
 
         options = normalize_quorums(options)
         options[:bucket] = bucket
         options[:key] = key
-        
+
         request = RpbCounterGetReq.new options
-        
+
         resp = protocol do |p|
           p.write :CounterGetReq, request
           p.expect :CounterGetResp, RpbCounterGetResp, empty_body_acceptable: true
         end
-        
+
         if :empty == resp
           return 0
         end
@@ -181,7 +206,7 @@ module Riak
         return resp.value || 0
       end
 
-      def post_counter(bucket, key, amount, options={})
+      def post_counter(bucket, key, amount, options = {})
         bucket = bucket.name if bucket.is_a? Bucket
 
         options = normalize_quorums(options)
@@ -190,7 +215,7 @@ module Riak
         # TODO: raise if amount doesn't fit in sint64
         options[:amount] = amount
         options[:returnvalue] = options[:returnvalue] || options[:return_value]
-        
+
         request = RpbCounterUpdateReq.new options
 
         resp = protocol do |p|
@@ -199,7 +224,7 @@ module Riak
         end
 
         return nil if :empty == resp
-        
+
         return resp.value
       end
 
@@ -207,7 +232,7 @@ module Riak
         bucket_properties_operator.get bucket, options
       end
 
-      def set_bucket_props(bucket, props, type=nil)
+      def set_bucket_props(bucket, props, type = nil)
         bucket_properties_operator.put bucket, props, type: type
       end
 
@@ -234,7 +259,7 @@ module Riak
         resp.props.to_hash
       end
 
-      def list_keys(bucket, options={}, &block)
+      def list_keys(bucket, options = {}, &block)
         bucket = bucket.name if Bucket === bucket
         req = RpbListKeysReq.new(options.merge(:bucket => maybe_encode(bucket)))
 
@@ -259,13 +284,13 @@ module Riak
       end
 
       # override the simple list_buckets
-      def list_buckets(options={}, &blk)
-        if block_given? 
+      def list_buckets(options = {}, &blk)
+        if block_given?
           return streaming_list_buckets options, &blk
         end
-        
+
         raise t("streaming_bucket_list_without_block") if options[:stream]
-        
+
         request = RpbListBucketsReq.new options
 
         resp = protocol do |p|
@@ -282,9 +307,9 @@ module Riak
       def mapred(mr, &block)
         raise MapReduceError.new(t("empty_map_reduce_query")) if mr.query.empty? && !mapred_phaseless?
         req = RpbMapRedReq.new(:request => mr.to_json, :content_type => "application/json")
-        
+
         results = MapReduce::Results.new(mr)
-        
+
         protocol do |p|
           p.write :MapRedReq, req
           while msg = p.expect(:MapRedResp, RpbMapRedResp)
@@ -296,11 +321,11 @@ module Riak
             end
           end
         end
-        
+
         block_given? || results.report
       end
 
-      def get_index(bucket, index, query, query_options={}, &block)
+      def get_index(bucket, index, query, query_options = {}, &block)
         return super unless pb_indexes?
         bucket = bucket.name if Bucket === bucket
         if Range === query
@@ -328,7 +353,7 @@ module Riak
         end
       end
 
-      def search(index, query, options={})
+      def search(index, query, options = {})
         return super unless pb_search?
         options = options.symbolize_keys
         options[:op] = options.delete(:'q.op') if options[:'q.op']
@@ -347,9 +372,9 @@ module Riak
         return ret
       end
 
-      def create_search_index(name, schema=nil, n_val=nil)
-        index = RpbYokozunaIndex.new(:name => name, :schema => schema, :n_val => n_val)
-        req = RpbYokozunaIndexPutReq.new(:index => index)
+      def create_search_index(name, schema = nil, n_val = nil, timeout = nil)
+        index = RpbYokozunaIndex.new(name: name, schema: schema, n_val: n_val)
+        req = RpbYokozunaIndexPutReq.new(index: index, timeout: timeout)
 
         protocol do |p|
           p.write :YokozunaIndexPutReq, req
@@ -359,7 +384,7 @@ module Riak
 
       def get_search_index(name)
         req = RpbYokozunaIndexGetReq.new(:name => name)
-        begin 
+        begin
           resp = protocol do |p|
             p.write :YokozunaIndexGetReq, req
             p.expect :YokozunaIndexGetResp, RpbYokozunaIndexGetResp, empty_body_acceptable: true
@@ -427,7 +452,7 @@ module Riak
         msglen, msgcode = header.unpack("NC")
         if msglen == 1
           case MESSAGE_CODES[msgcode]
-          when :ListBucketsResp,  
+          when :ListBucketsResp,
                :IndexResp
             []
           when :GetResp,
@@ -483,16 +508,16 @@ module Riak
           if !block_given?
             return IndexCollection.new_from_protobuf(resp)
           end
-          
+
           content = resp.keys || resp.results || []
           yield content
-          
+
           return if resp.done
         end
       rescue ProtobuffsErrorResponse => err
         if match = err.message.match(/indexes_not_supported,(\w+)/)
           old_err = err
-          err = ProtobuffsFailedRequest.new(:indexes_not_supported, 
+          err = ProtobuffsFailedRequest.new(:indexes_not_supported,
                                             t('index.wrong_backend', backend: match[1])
                                             )
         end

data/lib/riak/client/protobuffs_backend.rb

@@ -59,7 +59,7 @@ module Riak
       # @param [String] query the Lucene-style search query
       # @param [Hash] options ignored in MapReduce emulation
       # @return [Hash] the search results
-      def search(index, query, options={})
+      def search(index, query, options = {})
         mr = Riak::MapReduce.new(client).search(index || 'search', query)
         unless mapred_phaseless?
           mr.reduce(%w[riak_kv_mapreduce reduce_identity], :arg => {:reduce_phase_only_1 => true}, :keep => true)
@@ -76,7 +76,7 @@ module Riak
       def teardown
         reset_socket
       end
-      
+
       def socket
         @socket ||= new_socket
       end
@@ -90,7 +90,7 @@ module Riak
       def decode_response
         raise NotImplementedError
       end
-      
+
       def new_socket
         raise NotImplementedError
       end
@@ -101,7 +101,7 @@ module Riak
         @socket = nil
       end
 
-      def prune_unsupported_options(req,options={})
+      def prune_unsupported_options(req, options = {})
         unless quorum_controls?
           [:notfound_ok, :basic_quorum, :pr, :pw].each {|k| options.delete k }
         end
@@ -121,7 +121,7 @@ module Riak
         options
       end
 
-      def normalize_quorums(options={})
+      def normalize_quorums(options = {})
         options.dup.tap do |o|
           [:r, :pr, :w, :pw, :dw, :rw].each do |k|
             next o[k] = normalize_quorum_value(o[k]) if o[k]

data/lib/riak/client/yokozuna.rb

@@ -1,9 +1,9 @@
 module Riak
   class Client
-    def create_search_index(name, schema=nil, n_val=nil)
+    def create_search_index(name, schema = nil, n_val = nil, timeout = nil)
       raise ArgumentError, t("zero_length_index") if name.nil? || name.empty?
       backend do |b|
-        b.create_search_index(name, schema, n_val)
+        b.create_search_index(name, schema, n_val, timeout)
       end
       true
     end
@@ -49,4 +49,4 @@ module Riak
       end
     end
   end
-end
+end

data/lib/riak/core_ext/deep_dup.rb

@@ -3,7 +3,7 @@ unless {}.respond_to?(:deep_dup)
     # Returns a deep copy of hash.
     def deep_dup
       duplicate = self.dup
-      duplicate.each_pair do |k,v|
+      duplicate.each_pair do |k, v|
         tv = duplicate[k]
         duplicate[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? tv.deep_dup : v
       end

data/lib/riak/counter.rb

@@ -23,10 +23,10 @@ module Riak
     end
 
     # Retrieve the current value of the counter.
-    # @param [Hash] options 
+    # @param [Hash] options
     # @option options [Fixnum,String] :r ("quorum") read quorum (numeric or
     # symbolic)
-    def value(options={})
+    def value(options = {})
       backend do |backend|
         backend.get_counter bucket, key, options
       end
@@ -35,27 +35,27 @@ module Riak
 
     # Increment the counter and return its new value.
     # @param amount [Integer] the amount to increment the counter by.
-    def increment_and_return(amount=1)
+    def increment_and_return(amount = 1)
       increment amount, return_value: true
     end
 
     # Decrement the counter and return its new value.
-    # @param amount [Integer] the amount to decrement the counter by. Negative 
+    # @param amount [Integer] the amount to decrement the counter by. Negative
     # values increment the counter.
-    def decrement_and_return(amount=1)
+    def decrement_and_return(amount = 1)
       increment_and_return -amount
     end
 
     # Increment the counter.
     # @param amount [Integer] the amount to increment the counter by
-    # @param [Hash] options 
+    # @param [Hash] options
     # @option options [Boolean] :return_value whether to return the new counter
     # value. Default false.
     # @option options [Fixnum,String] :r ("quorum") read quorum (numeric or
     # symbolic)
     # @option options [Fixnum] :w the "w" parameter (Write quorum)
     # @option options [Fixnum] :dw the "dw" parameter (Durable-write quorum)
-    def increment(amount=1, options={})
+    def increment(amount = 1, options = {})
       validate_amount amount
 
       backend do |backend|
@@ -64,16 +64,16 @@ module Riak
     end
 
     # Decrement the counter.
-    # @param amount [Integer] the amount to decrement the counter by. Negative 
+    # @param amount [Integer] the amount to decrement the counter by. Negative
     # values increment the counter.
-    # @param [Hash] options 
+    # @param [Hash] options
     # @option options [Boolean] :return_value whether to return the new counter
     # value. Default false.
     # @option options [Fixnum,String] :r ("quorum") read quorum (numeric or
     # symbolic)
     # @option options [Fixnum] :w the "w" parameter (Write quorum)
     # @option options [Fixnum] :dw the "dw" parameter (Durable-write quorum)
-    def decrement(amount=1, options={})
+    def decrement(amount = 1, options = {})
       increment(-amount, options)
     end
 

data/lib/riak/crdt/base.rb

@@ -1,6 +1,5 @@
 module Riak
   module Crdt
-
     # Basic and shared code used by the top-level CRDTs. In particular, dirty-
     # tracking, loading, and operating is implemented by this class, and
     # the {Riak::Crdt::Set}, {Riak::Crdt::Counter}, and {Riak::Crdt::Map}
@@ -12,11 +11,10 @@ module Riak
       attr_reader :bucket
       attr_reader :bucket_type
 
-      # Returns the key of this CRDT. Extremely useful when using a 
+      # Returns the key of this CRDT. Extremely useful when using a
       # Riak-assigned key.
       attr_reader :key
 
-
       # Base CRDT initialization The bucket type is determined by the first of
       # these sources:
       #
@@ -32,16 +30,10 @@ module Riak
       # @param [String] bucket_type The optional bucket type for this counter.
       #        The default is in `Crdt::Base::DEFAULT_BUCKET_TYPES[:counter]`.
       # @param [Hash] options
-      def initialize(bucket, key, bucket_type, options={})
-        raise ArgumentError, t("bucket_type", bucket: bucket.inspect) unless bucket.is_a? Bucket
-
-        unless key.is_a? String or key.nil?
-          raise ArgumentError, t("string_type", string: key.inspect)
-        end
-
-        @bucket = bucket
-        @key = key
-        set_bucket_type bucket_type
+      def initialize(bucket, key, bucket_type, options = {})
+        configure_bucket bucket
+        configure_key key
+        configure_bucket_type bucket_type
         @options = options
 
         @dirty = true
@@ -50,7 +42,7 @@ module Riak
       def dirty?
         @dirty
       end
-      
+
       # Force a reload of this structure from Riak.
       def reload
         loader do |l|
@@ -69,6 +61,14 @@ module Riak
         !!@context
       end
 
+      def ==(other)
+        return false unless self.class == other.class
+        return false unless self.bucket_type == other.bucket_type
+        return false unless self.bucket == other.bucket
+        return false unless self.key == other.key
+        return true
+      end
+
       def pretty_print(pp)
         pp.object_group self do
           pp.breakable
@@ -90,16 +90,18 @@ module Riak
       end
 
       def inspect_name
-        "#<#{self.class.name} bucket=#{@bucket.name} key=#{@key} type=#{@bucket_type}>"
+        "#<#{self.class.name} bucket=#{@bucket.name} " \
+        "key=#{@key} type=#{@bucket_type}>"
       end
-      
+
       private
+
       def client
         @bucket.client
       end
 
       def backend(&blk)
-        client.backend &blk
+        client.backend(&blk)
       end
 
       def loader
@@ -107,7 +109,7 @@ module Riak
           yield be.crdt_loader
         end
       end
-      
+
       def operator
         backend do |be|
           yield be.crdt_operator
@@ -115,7 +117,7 @@ module Riak
       end
 
       def operate(*args)
-        options = Hash.new
+        options = {}
         options = args.pop if args.last.is_a? Hash
         options[:context] ||= @context
         result = operator do |op|
@@ -134,7 +136,7 @@ module Riak
         @dirty = true
         vivify_returnbody(result)
 
-        return true
+        true
       end
 
       def vivify_returnbody(result)
@@ -149,7 +151,7 @@ module Riak
         end
       end
 
-      def set_bucket_type(constructor_type)
+      def configure_bucket_type(constructor_type)
         @bucket_type = if constructor_type.is_a? String
                          constructor_type
                        elsif constructor_type.is_a? BucketType
@@ -160,6 +162,22 @@ module Riak
                          DEFAULT_BUCKET_TYPES[constructor_type]
                        end
       end
+
+      def configure_bucket(bucket)
+        unless bucket.is_a? Bucket
+          fail ArgumentError, t('bucket_type', bucket: bucket.inspect)
+        end
+
+        @bucket = bucket
+      end
+
+      def configure_key(key)
+        unless key.is_a?(String) || key.nil?
+          fail ArgumentError, t('string_type', string: key.inspect)
+        end
+
+        @key = key
+      end
     end
   end
 end