riak-client 2.1.0 → 2.2.0.pre1

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

@@ -10,26 +10,6 @@ module Riak
       end
 
       class RpbBucketProps
-        def clean_hook(newval)
-          if newval.is_a? Array
-            return newval.map{|v| clean_hook v}
-          end
-
-          newval = newval.symbolize_keys if newval.is_a? Hash
-          if newval.is_a?(Hash) && newval[:module] && newval[:function]
-            modfun = RpbModFun.new newval
-            hook = RpbCommitHook.new modfun: modfun
-            newval = hook
-          elsif newval.is_a?(Hash) && newval[:name]
-            hook = RpbCommitHook.new newval
-            newval = hook
-          elsif newval.is_a? String
-            hook = RpbCommitHook.new name: newval
-            newval = hook
-          end
-
-          return newval
-        end
 
         # "repeated" elements with zero items are indistinguishable
         # from a nil, so we have to manage has_precommit/has_postcommit
@@ -55,6 +35,48 @@ module Riak
           @has_postcommit = newval
           @postcommit ||= [] if newval
         end
+
+        def chash_keyfun=(newval)
+          @chash_keyfun = clean_modfun newval
+        end
+
+        def linkfun=(newval)
+          @linkfun = clean_modfun newval
+        end
+
+        private
+
+        def clean_hook(newval)
+          if newval.is_a? Array
+            return newval.map{|v| clean_hook v}
+          end
+
+          newval = newval.symbolize_keys if newval.is_a? Hash
+          if newval.is_a?(Hash) && newval[:module] && newval[:function]
+            modfun = RpbModFun.new newval
+            hook = RpbCommitHook.new modfun: modfun
+            newval = hook
+          elsif newval.is_a?(Hash) && newval[:name]
+            hook = RpbCommitHook.new newval
+            newval = hook
+          elsif newval.is_a? String
+            hook = RpbCommitHook.new name: newval
+            newval = hook
+          end
+
+          return newval
+        end
+
+        def clean_modfun(newval)
+          return newval unless newval.is_a? Hash
+
+          newval = newval.symbolize_keys
+          if newval[:mod] && newval[:fun]
+            modfun = RpbModFun.new :'module' => newval[:mod], function: newval[:fun]
+          end
+
+          return modfun
+        end
       end
     end
   end

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

@@ -88,7 +88,7 @@ module Riak
 
         def encode_index(key, set)
           set.map do |v|
-            RpbPair.new(:key => maybe_encode(key),
+            RpbPair.new(:key => maybe_encode(key.to_s),
                         :value => maybe_encode(v.to_s))
           end
         end

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

@@ -30,7 +30,7 @@ module Riak
             tcp = start_tcp_socket(host, port)
             TlsInitiator.new(tcp, host, authentication).tls_socket
           end
-          
+
           # Wrap up the logic to turn a TCP socket into a TLS socket.
           # Depends on Beefcake, which should be relatively safe.
           class TlsInitiator
@@ -104,7 +104,7 @@ module Riak
                 candidate = @auth[k.to_sym]
                 next if candidate.nil?
                 next if candidate.is_a? OpenSSL::X509::Certificate
-                
+
                 @auth[k.to_sym] = OpenSSL::X509::Certificate.new try_load candidate
               end
             end
@@ -144,7 +144,7 @@ module Riak
                 # couldn't read the file, it might be a string containing
                 # a key
               rescue Errno::ENAMETOOLONG
-                # the filename is too long, it's almost certainly a string 
+                # the filename is too long, it's almost certainly a string
                 # containing a key
               rescue => e
                 raise TlsError::ReadDataError.new e, data_or_path
@@ -192,7 +192,7 @@ module Riak
                 ocsp: !!@auth[:ocsp],
                 crl: !!@auth[:crl]
               }
-              
+
               if @auth[:crl_file]
                 o[:crl_file] = @auth[:crl_file]
                 o[:crl] = true
@@ -232,7 +232,7 @@ module Riak
               len, code = header.unpack 'NC'
               decode = BeefcakeMessageCodes[code]
               return decode, '' if len == 1
-              
+
               message = @sock.read(len - 1)
               return decode, message
             end
@@ -250,7 +250,7 @@ module Riak
                                    actual: candidate_code.inspect,
                                    body: message.inspect
                                    ))
-              
+
             end
           end
         end

data/lib/riak/client/beefcake_protobuffs_backend.rb

@@ -13,12 +13,14 @@ module Riak
           require 'riak/client/beefcake/messages'
           require 'riak/client/beefcake/message_overlay'
           require 'riak/client/beefcake/object_methods'
+          require 'riak/client/beefcake/bucket_properties_operator'
           require 'riak/client/beefcake/crdt_operator'
           require 'riak/client/beefcake/crdt_loader'
           require 'riak/client/beefcake/protocol'
           require 'riak/client/beefcake/socket'
           true
-        rescue LoadError, NameError
+        rescue LoadError, NameError => e
+          # put exception into a variable for debugging
           false
         end
       end
@@ -202,37 +204,17 @@ module Riak
       end
 
       def get_bucket_props(bucket, options = {  })
-        bucket = bucket.name if Bucket === bucket
-
-        req = RpbGetBucketReq.new(:bucket => maybe_encode(bucket))
-        req.type = options[:type] if options[:type]
-
-        resp_message = protocol do |p|
-          p.write :GetBucketReq, req
-          p.expect :GetBucketResp, RpbGetBucketResp
-        end
-
-        resp = normalize_quorums resp_message.props.to_hash.stringify_keys
-        normalized = normalize_hooks resp
-        normalized.stringify_keys
+        bucket_properties_operator.get bucket, options
       end
 
       def set_bucket_props(bucket, props, type=nil)
-        bucket = bucket.name if Bucket === bucket
-        req = RpbSetBucketReq.new(
-                                  bucket: maybe_encode(bucket),
-                                  props: RpbBucketProps.new(props.symbolize_keys),
-                                  type: type)
-
-        protocol do |p|
-          p.write :SetBucketReq, req
-          p.expect :SetBucketResp
-        end
+        bucket_properties_operator.put bucket, props, type: type
       end
 
-      def reset_bucket_props(bucket)
+      def reset_bucket_props(bucket, options)
         bucket = bucket.name if Bucket === bucket
-        req = RpbResetBucketReq.new(:bucket => maybe_encode(bucket))
+        req = RpbResetBucketReq.new(bucket: maybe_encode(bucket),
+                                    type: options[:type])
 
         protocol do |p|
           p.write :ResetBucketReq, req
@@ -240,6 +222,18 @@ module Riak
         end
       end
 
+      def get_bucket_type_props(bucket_type)
+        bucket_type = bucket_type.name if bucket_type.is_a? BucketType
+        req = RpbGetBucketTypeReq.new type: bucket_type
+
+        resp = protocol do |p|
+          p.write :GetBucketTypeReq, req
+          p.expect(:GetBucketResp, RpbGetBucketResp)
+        end
+
+        resp.props.to_hash
+      end
+
       def list_keys(bucket, options={}, &block)
         bucket = bucket.name if Bucket === bucket
         req = RpbListKeysReq.new(options.merge(:bucket => maybe_encode(bucket)))
@@ -322,7 +316,7 @@ module Riak
           }
         end
 
-        options.merge!(:bucket => bucket, :index => index)
+        options.merge!(:bucket => bucket, :index => index.to_s)
         options.merge!(query_options)
         options[:stream] = block_given?
 
@@ -365,20 +359,20 @@ module Riak
 
       def get_search_index(name)
         req = RpbYokozunaIndexGetReq.new(:name => name)
-        resp = protocol do |p|
-          p.write :YokozunaIndexGetReq, req
-          p.expect :YokozunaIndexGetResp, RpbYokozunaIndexGetResp, empty_body_acceptable: true
-        end
-        
-        if :empty == resp
-          raise Riak::ProtobuffsFailedRequest.new(:not_found, t('not_found'))
-        end
+        begin 
+          resp = protocol do |p|
+            p.write :YokozunaIndexGetReq, req
+            p.expect :YokozunaIndexGetResp, RpbYokozunaIndexGetResp, empty_body_acceptable: true
+          end
+        rescue ProtobuffsErrorResponse => e
+          if e.code == 0 && e.original_message =~ /notfound/
+            raise Riak::ProtobuffsFailedRequest.new(:not_found, t('not_found'))
+          end
 
-        if resp.index && Array === resp
-          resp.index.map{|index| {:name => index.name, :schema => index.schema, :n_val => index.n_val} }
-        else
-          resp
+          raise e
         end
+
+        resp
       end
 
       def delete_search_index(name)
@@ -404,9 +398,17 @@ module Riak
       def get_search_schema(name)
         req = RpbYokozunaSchemaGetReq.new(:name => name)
 
-        resp = protocol do |p|
-          p.write :YokozunaSchemaGetReq, req
-          p.expect :YokozunaSchemaGetResp, RpbYokozunaSchemaGetResp
+        begin
+          resp = protocol do |p|
+            p.write :YokozunaSchemaGetReq, req
+            p.expect :YokozunaSchemaGetResp, RpbYokozunaSchemaGetResp
+          end
+        rescue ProtobuffsErrorResponse => e
+          if e.code == 0 && e.original_message =~ /notfound/
+            raise Riak::ProtobuffsFailedRequest.new(:not_found, t('not_found'))
+          end
+
+          raise e
         end
 
         resp.schema ? resp.schema : resp
@@ -506,24 +508,6 @@ module Riak
         # Search returns strings that should always be valid UTF-8
         ObjectMethods::ENCODING ? str.force_encoding('UTF-8') : str
       end
-
-      def normalize_hooks(message)
-        message.dup.tap do |o|
-          %w{chash_keyfun linkfun}.each do |k|
-            o[k] = {'mod' => message[k].module, 'fun' => message[k].function}
-          end
-          %w{precommit postcommit}.each do |k|
-            orig = message[k]
-            o[k] = orig.map do |hook|
-              if hook.modfun
-                {'mod' => hook.modfun.module, 'fun' => hook.modfun.function}
-              else
-                hook.name
-              end
-            end
-          end
-        end
-      end
     end
   end
 end

data/lib/riak/client/protobuffs_backend.rb

@@ -15,6 +15,14 @@ module Riak
 
       MESSAGE_CODES = BeefcakeMessageCodes
 
+      UINTMAX = 0xffffffff
+      QUORUMS = {
+        "one" => UINTMAX - 1,
+        "quorum" => UINTMAX - 2,
+        "all" => UINTMAX - 3,
+        "default" => UINTMAX - 4
+      }.freeze
+
       def self.simple(method, code)
         define_method method do
           socket.write([1, MESSAGE_CODES.index(code)].pack('NC'))
@@ -93,14 +101,6 @@ module Riak
         @socket = nil
       end
 
-      UINTMAX = 0xffffffff
-      QUORUMS = {
-        "one" => UINTMAX - 1,
-        "quorum" => UINTMAX - 2,
-        "all" => UINTMAX - 3,
-        "default" => UINTMAX - 4
-      }.freeze
-
       def prune_unsupported_options(req,options={})
         unless quorum_controls?
           [:notfound_ok, :basic_quorum, :pr, :pw].each {|k| options.delete k }

data/lib/riak/client.rb

@@ -14,6 +14,7 @@ require 'riak/client/yokozuna'
 require 'riak/client/protobuffs_backend'
 require 'riak/client/beefcake_protobuffs_backend'
 require 'riak/bucket'
+require 'riak/bucket_type'
 require 'riak/multiget'
 require 'riak/secondary_index'
 require 'riak/stamp'
@@ -131,6 +132,10 @@ module Riak
     end
     alias :[] :bucket
 
+    def bucket_type(name)
+      BucketType.new self, name
+    end
+
     # Lists buckets which have keys stored in them.
     # @note This is an expensive operation and should be used only
     #       in development.
@@ -369,9 +374,9 @@ module Riak
     end
 
     # Clears the properties on a bucket. See Bucket#clear_props
-    def clear_bucket_props(bucket)
+    def clear_bucket_props(bucket, options={  })
       backend do |b|
-        b.reset_bucket_props(bucket)
+        b.reset_bucket_props(bucket, options)
       end
     end
 

data/lib/riak/crdt/base.rb

@@ -16,6 +16,22 @@ module Riak
       # Riak-assigned key.
       attr_reader :key
 
+
+      # Base CRDT initialization The bucket type is determined by the first of
+      # these sources:
+      #
+      # 1. The `bucket_type` String argument
+      # 2. A {BucketTyped::Bucket} as the `bucket` argument
+      # 3. A `bucket_type` Symbol argument is looked up in the
+      #    `Crdt::Base::DEFAULT_BUCKET_TYPES` hash
+      # @api private
+      #
+      # @param [Bucket] bucket the {Riak::Bucket} for this counter
+      # @param [String, nil] key The name of the counter. A nil key makes
+      #        Riak assign a key.
+      # @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
 
@@ -25,7 +41,7 @@ module Riak
 
         @bucket = bucket
         @key = key
-        @bucket_type = bucket_type
+        set_bucket_type bucket_type
         @options = options
 
         @dirty = true
@@ -132,6 +148,18 @@ module Riak
           @dirty = false
         end
       end
+
+      def set_bucket_type(constructor_type)
+        @bucket_type = if constructor_type.is_a? String
+                         constructor_type
+                       elsif constructor_type.is_a? BucketType
+                         constructor_type.name
+                       elsif @bucket.is_a? BucketTyped::Bucket
+                         @bucket.type.name
+                       elsif constructor_type.is_a? Symbol
+                         DEFAULT_BUCKET_TYPES[constructor_type]
+                       end
+      end
     end
   end
 end

data/lib/riak/crdt/counter.rb

@@ -6,8 +6,12 @@ module Riak
     # Riak 1.4 Counters, see {Riak::Counter}.
     class Counter < Base
 
-      # Create a counter instance. If not provided, the default bucket type
-      # from {Riak::Crdt} will be used.
+      # Create a counter instance. The bucket type is determined by the first of
+      # these sources:
+      #
+      # 1. The `bucket_type` String argument
+      # 2. A {BucketTyped::Bucket} as the `bucket` argument
+      # 3. The `Crdt::Base::DEFAULT_BUCKET_TYPES[:counter]` entry
       #
       # @param [Bucket] bucket the {Riak::Bucket} for this counter
       # @param [String, nil] key The name of the counter. A nil key makes
@@ -16,7 +20,7 @@ module Riak
       #        The default is in `Crdt::Base::DEFAULT_BUCKET_TYPES[:counter]`.
       # @param [Hash] options
       def initialize(bucket, key, bucket_type=nil, options={})
-        super(bucket, key, bucket_type || DEFAULT_BUCKET_TYPES[:counter], options)
+        super(bucket, key, bucket_type || :counter, options)
       end
       
       # The current value of the counter; hits the server if the value has

data/lib/riak/crdt/inner_flag.rb

@@ -6,7 +6,7 @@ module Riak
     #
     # @api private
     class InnerFlag
-      def self.new(parent, value)
+      def self.new(parent, value=false)
         ensure_boolean value
         
         return value

data/lib/riak/crdt/map.rb

@@ -20,8 +20,12 @@ module Riak
     class Map < Base
       attr_reader :counters, :flags, :maps, :registers, :sets
       
-      # Create a map instance. If not provided, the default bucket type
-      # from {Riak::Crdt} will be used.
+      # Create a map instance. The bucket type is determined by the first of
+      # these sources:
+      #
+      # 1. The `bucket_type` String argument
+      # 2. A {BucketTyped::Bucket} as the `bucket` argument
+      # 3. The `Crdt::Base::DEFAULT_BUCKET_TYPES[:map]` entry
       #
       # @param bucket [Bucket] the {Riak::Bucket} for this map
       # @param [String, nil] key The name of the map. A nil key makes
@@ -30,7 +34,7 @@ module Riak
       #        The default is in `Crdt::Base::DEFAULT_BUCKET_TYPES[:map]`.
       # @param options [Hash]
       def initialize(bucket, key, bucket_type=nil, options={})
-        super(bucket, key, bucket_type || DEFAULT_BUCKET_TYPES[:map], options)
+        super(bucket, key, bucket_type || :map, options)
 
         if key
           initialize_collections 

data/lib/riak/crdt/set.rb

@@ -7,17 +7,20 @@ module Riak
     # be used frequently.
     class Set < Base
       
-      # Create a set instance. If not provided, the default bucket type from
-      # {Riak::Crdt} will be used.
+      # Create a set instance. The bucket type is determined by the first of
+      # these sources:
+      #
+      # 1. The `bucket_type` String argument
+      # 2. A {BucketTyped::Bucket} as the `bucket` argument
+      # 3. The `Crdt::Base::DEFAULT_BUCKET_TYPES[:set]` entry
       #
       # @param bucket [Bucket] the {Riak::Bucket} for this set
       # @param [String, nil] key The name of the set. A nil key makes
       #        Riak assign a key.
       # @param [String] bucket_type The optional bucket type for this set.
-      #        The default is in `Crdt::Base::DEFAULT_BUCKET_TYPES[:set]`.
       # @param options [Hash]
       def initialize(bucket, key, bucket_type=nil, options={})
-        super(bucket, key, bucket_type || DEFAULT_BUCKET_TYPES[:set], options)
+        super(bucket, key, bucket_type || :set, options)
       end
 
       # Yields a `BatchSet` to proxy multiple set operations into a single

data/lib/riak/errors/failed_request.rb

@@ -9,9 +9,11 @@ module Riak
 
   # Exception raised when receiving an unexpected Protocol Buffers response from Riak
   class ProtobuffsFailedRequest < FailedRequest
+    attr_reader :code, :original_message
     def initialize(code, message)
       super t('protobuffs_failed_request', :code => code, :body => message)
       @original_message = message
+      @code = code
       @not_found = code == :not_found
       @server_error = code == :server_error
     end

data/lib/riak/errors/search_error.rb

@@ -0,0 +1,29 @@
+require 'riak/errors/base'
+
+module Riak
+  class SearchError < Error
+    class IndexExistsError < SearchError
+      def initialize(name)
+        super t('search.index_exists', name: name)
+      end
+    end
+
+    class SchemaExistsError < SearchError
+      def initialize(name)
+        super t('search.schema_exists', name: name)
+      end
+    end
+
+    class IndexArgumentError < SearchError
+      def initialize(index)
+        super t('search.index_argument_error', index: index)
+      end
+    end
+
+    class IndexNonExistError < SearchError
+      def initialize(index)
+        super t('search.index_non_exist', index: index)
+      end
+    end
+  end
+end

data/lib/riak/locale/en.yml

@@ -1,5 +1,7 @@
 en:
   riak:
+    argument_error:
+      bucket_type: "invalid argument %{bucket_type} is not a Riak::BucketType or a String"
     backwards_clock: "System clock moved backwards, ID generation will fail for %{delay} more milliseconds."
     bucket_link_conversion: "Can't convert a bucket link to a walk spec"
     bucket_type: "invalid argument %{bucket} is not a Riak::Bucket"
@@ -68,6 +70,11 @@ en:
     protobuffs_failed_request: "Expected success from Riak but received %{code}. %{body}"
     protobuffs_configuration: "The %{backend} Protobuffs backend cannot be used. Please check its requirements."
     request_body_type: "Request body must be a String or respond to :read."
+    search:
+      index_exists: "The index %{name} already exists."
+      index_non_exist: "The index %{index} doesn't exist."
+      index_argument_error: "invalid argument %{index} is not a Riak::Search::Index or a String"
+      schema_exists: "The schema %{name} already exists."
     search_unsupported: "Riak server does not support search."
     search_docs_require_id: "Search index documents must include the 'id' field."
     search_remove_requires_id_or_query: "Search index documents to be removed must have 'id' or 'query' keys."

data/lib/riak/map_reduce.rb

@@ -4,6 +4,7 @@ require 'riak/json'
 require 'riak/client'
 require 'riak/bucket'
 require 'riak/robject'
+require 'riak/bucket_typed/bucket'
 require 'riak/walk_spec'
 require 'riak/errors/failed_request'
 require 'riak/map_reduce_error'
@@ -68,23 +69,29 @@ module Riak
         p = params.first
         case p
         when Bucket
-          warn(t('full_bucket_mapred', :backtrace => caller.join("\n    "))) unless Riak.disable_list_keys_warnings
-          @inputs = maybe_escape(p.name)
+          @inputs = bucket_input(p)
         when RObject
-          @inputs << [maybe_escape(p.bucket.name), maybe_escape(p.key)]
+          @inputs << robject_input(p)
         when String
           warn(t('full_bucket_mapred', :backtrace => caller.join("\n    "))) unless Riak.disable_list_keys_warnings
           @inputs = maybe_escape(p)
         end
       when 2..3
         bucket = params.shift
-        bucket = bucket.name if Bucket === bucket
+
         if Array === params.first
+          if bucket.is_a? Bucket
+            bucket = bucket_input(bucket)
+          else
+            bucket = maybe_escape(bucket)
+          end
+          
           warn(t('full_bucket_mapred', :backtrace => caller.join("\n    "))) unless Riak.disable_list_keys_warnings
-          @inputs = {:bucket => maybe_escape(bucket), :key_filters => params.first }
+          @inputs = {:bucket => bucket, :key_filters => params.first }
         else
           key = params.shift
-          @inputs << params.unshift(maybe_escape(key)).unshift(maybe_escape(bucket))
+          key_data = params.shift || ''
+          @inputs << key_input(key, bucket, key_data)
         end
       end
       self
@@ -222,5 +229,62 @@ module Riak
         raise fr
       end
     end
+
+    private
+
+    # Processes a {Bucket} or {BucketTyped::Bucket} into a whole-bucket
+    # {MapReduce} input.
+    def bucket_input(bucket)
+      warn(t('full_bucket_mapred', :backtrace => caller.join("\n    "))) unless Riak.disable_list_keys_warnings
+
+      if bucket.needs_type?
+        return [maybe_escape(bucket.type.name), maybe_escape(bucket.name)]
+      end
+
+      maybe_escape(bucket.name)
+    end
+
+    # Processes a {RObject} into a single-object {MapReduce} input, whether it
+    # has a bucket type or not.
+    def robject_input(obj, key_data='')
+      bucket = obj.bucket
+      if bucket.needs_type?
+        return [
+                maybe_escape(bucket.name), 
+                maybe_escape(obj.key), 
+                key_data, 
+                maybe_escape(bucket.type.name)
+               ]
+      end
+
+      [maybe_escape(obj.bucket.name), maybe_escape(obj.key)]
+    end
+
+    # Processes a key into a single-object {MapReduce} input, doing the correct
+    # thing if the bucket argument is a {String}, {Bucket}, or a
+    # {BucketTyped::Bucket}.
+    def key_input(key, bucket, key_data='')     
+      kd = []
+      kd << key_data unless key_data.blank?
+
+      if bucket.is_a? String
+        return [
+                maybe_escape(bucket), 
+                maybe_escape(key)
+               ] + kd
+      elsif bucket.needs_type?
+        return [
+                maybe_escape(bucket.name),
+                maybe_escape(key),
+                key_data,
+                maybe_escape(bucket.type.name)
+               ]
+      else
+        return [
+                maybe_escape(bucket.name),
+                maybe_escape(key)
+               ] + kd
+      end
+    end
   end
 end