riak-client 0.9.8 → 1.0.0.beta

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

@@ -1,16 +1,3 @@
-# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
 require 'beefcake'
 
 module Riak
@@ -48,6 +35,7 @@ module Riak
         optional :last_mod,         :uint32, 7
         optional :last_mod_usecs,   :uint32, 8
         repeated :usermeta,         RpbPair, 9
+        repeated :indexes,          RpbPair, 10
       end
 
       # Primary messages
@@ -75,40 +63,57 @@ module Riak
 
       class RpbGetReq
         include Beefcake::Message
-        required :bucket, :bytes,  1
-        required :key,    :bytes,  2
-        optional :r,      :uint32, 3
+        required :bucket,        :bytes,  1
+        required :key,           :bytes,  2
+        optional :r,             :uint32, 3
+        optional :pr,            :uint32, 4
+        optional :basic_quorum,  :bool,   5
+        optional :notfound_ok,   :bool,   6
+        optional :if_modified,   :bytes,  7
+        optional :head,          :bool,   8
+        optional :deletedvclock, :bool,   9
       end
 
       class RpbGetResp
         include Beefcake::Message
-        repeated :content, RpbContent, 1
-        optional :vclock,  :bytes,  2
+        repeated :content,   RpbContent, 1
+        optional :vclock,    :bytes,     2
+        optional :unchanged, :bool,      3
       end
 
       class RpbPutReq
         include Beefcake::Message
-        required :bucket,      :bytes,  1
-        required :key,         :bytes,  2
-        optional :vclock,      :bytes,  3
-        required :content,     RpbContent, 4
-        optional :w,           :uint32, 5
-        optional :dw,          :uint32, 6
-        optional :return_body, :bool,   7
+        required :bucket,          :bytes,     1
+        optional :key,             :bytes,     2
+        optional :vclock,          :bytes,     3
+        required :content,         RpbContent, 4
+        optional :w,               :uint32,    5
+        optional :dw,              :uint32,    6
+        optional :returnbody,     :bool,      7
+        optional :pw,              :uint32,    8
+        optional :if_not_modified, :bool,      9
+        optional :if_none_match,   :bool,      10
+        optional :return_head,     :bool,      11
       end
 
-      # Optional since it has the same structure as GetResp
-      # class RpbPutResp
-      #   include Beefcake::Message
-      #   repeated :content, RpbContent, 1
-      #   optional :vclock,  :bytes,  2
-      # end
+      class RpbPutResp
+        include Beefcake::Message
+        repeated :content, RpbContent, 1
+        optional :vclock,  :bytes,     2
+        optional :key,     :bytes,     3
+      end
 
       class RpbDelReq
         include Beefcake::Message
         required :bucket, :bytes,  1
         required :key,    :bytes,  2
         optional :rw,     :uint32, 3
+        optional :vclock, :bytes,  4
+        optional :r,      :uint32, 5
+        optional :w,      :uint32, 6
+        optional :pr,     :uint32, 7
+        optional :pw,     :uint32, 8
+        optional :dw,     :uint32, 9
       end
 
       class RpbListBucketsResp

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

@@ -1,16 +1,3 @@
-# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
 require 'riak/robject'
 require 'riak/link'
 require 'riak/client/beefcake/messages'
@@ -22,13 +9,14 @@ module Riak
         ENCODING = "Riak".respond_to?(:encoding)
 
         # Returns RpbPutReq
-        def dump_object(robject)
-          pbuf = RpbPutReq.new(:bucket => maybe_encode(robject.bucket.name))
-          pbuf.key = maybe_encode(robject.key ||= generate_key)
-          pbuf.vclock = maybe_encode Base64.decode64(robject.vclock) if robject.vclock
+        def dump_object(robject, options={})
+          pbuf = RpbPutReq.new(options.merge(:bucket => maybe_encode(robject.bucket.name)))
+          pbuf.key = maybe_encode(robject.key) if robject.key # Put w/o key supported!
+          pbuf.vclock = maybe_encode(Base64.decode64(robject.vclock)) if robject.vclock
           pbuf.content = RpbContent.new(:value => maybe_encode(robject.raw_data),
                                         :content_type => maybe_encode(robject.content_type),
-                                        :links => robject.links.map {|l| encode_link(l) }.compact)
+                                        :links => robject.links.map {|l| encode_link(l) }.compact,
+                                        :indexes => robject.indexes.map {|k,s| encode_index(k,s) }.flatten)
 
           pbuf.content.usermeta = robject.meta.map {|k,v| encode_meta(k,v)} if robject.meta.any?
           pbuf.content.vtag = maybe_encode(robject.etag) if robject.etag.present?
@@ -40,7 +28,9 @@ module Riak
 
         # Returns RObject
         def load_object(pbuf, robject)
+          return robject if pbuf.respond_to?(:unchanged) && pbuf.unchanged # Reloading
           robject.vclock = Base64.encode64(pbuf.vclock).chomp if pbuf.vclock
+          robject.key = maybe_unescape(pbuf.key) if pbuf.respond_to?(:key) && pbuf.key # Put w/o key
           if pbuf.content.size > 1
             robject.conflict = true
             robject.siblings = pbuf.content.map do |c|
@@ -48,6 +38,8 @@ module Riak
               sibling.vclock = robject.vclock
               load_content(c, sibling)
             end
+
+            return robject.attempt_conflict_resolution
           else
             load_content(pbuf.content.first, robject)
           end
@@ -64,6 +56,10 @@ module Riak
           robject.content_type = pbuf.content_type if pbuf.content_type.present?
           robject.links = pbuf.links.map(&method(:decode_link)) if pbuf.links.present?
           pbuf.usermeta.each {|pair| decode_meta(pair, robject.meta) } if pbuf.usermeta.present?
+          if pbuf.indexes.present?
+            robject.indexes.clear
+            pbuf.indexes.each {|pair| decode_index(pair, robject.indexes) }
+          end
           if pbuf.last_mod.present?
             robject.last_modified = Time.at(pbuf.last_mod)
             robject.last_modified += pbuf.last_mod_usecs / 1000000 if pbuf.last_mod_usecs.present?
@@ -92,8 +88,20 @@ module Riak
                       :value => maybe_encode(value.to_s))
         end
 
+        def decode_index(pbuf, hash)
+          value = pbuf.key =~ /int$/ ? pbuf.value.to_i : pbuf.value
+          hash[pbuf.key] << value
+        end
+
+        def encode_index(key, set)
+          set.map do |v|
+            RpbPair.new(:key => maybe_encode(key),
+                        :value => maybe_encode(v.to_s))
+          end
+        end
+
         def maybe_encode(string)
-          ENCODING ? string.encode('BINARY') : string
+          ENCODING ? string.dup.force_encoding('BINARY') : string
         end
       end
 

data/lib/riak/client/beefcake_protobuffs_backend.rb

@@ -1,17 +1,4 @@
-# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-
+require 'base64'
 require 'riak/json'
 require 'riak/client'
 require 'riak/failed_request'
@@ -44,45 +31,49 @@ module Riak
         decode_response
       end
 
-      def fetch_object(bucket, key, r=nil)
+      def fetch_object(bucket, key, options={})
+        options = normalize_quorums(options)
         bucket = Bucket === bucket ? bucket.name : bucket
-        req = RpbGetReq.new(:bucket => bucket, :key => key)
-        req.r = normalize_quorum_value(r) if r
+        req = RpbGetReq.new(options.merge(:bucket => maybe_encode(bucket), :key => maybe_encode(key)))
         write_protobuff(:GetReq, req)
         decode_response(RObject.new(client.bucket(bucket), key))
       end
 
-      def reload_object(robject, r=nil)
-        req = RpbGetReq.new(:bucket => robject.bucket.name, :key => robject.key)
-        req.r = normalize_quorum_value(r) if r
+      def reload_object(robject, options={})
+        options = normalize_quorums(options)
+        options[:bucket] = maybe_encode(robject.bucket.name)
+        options[:key] = maybe_encode(robject.key)
+        options[:if_modified] = maybe_encode Base64.decode64(robject.vclock) if robject.vclock
+        req = RpbGetReq.new(options)
         write_protobuff(:GetReq, req)
         decode_response(robject)
       end
 
-      def store_object(robject, returnbody=false, w=nil, dw=nil)
+      def store_object(robject, options={})
         if robject.prevent_stale_writes
           other = fetch_object(robject.bucket, robject.key)
           raise Riak::ProtobuffsFailedRequest(:stale_object, t("stale_write_prevented")) unless other.vclock == robject.vclock
         end
-        req = dump_object(robject)
-        req.w = normalize_quorum_value(w) if w
-        req.dw = normalize_quorum_value(dw) if dw
-        req.return_body = returnbody
+        options = normalize_quorums(options)
+        req = dump_object(robject, options)
         write_protobuff(:PutReq, req)
         decode_response(robject)
       end
 
-      def delete_object(bucket, key, rw=nil)
+      def delete_object(bucket, key, options={})
         bucket = Bucket === bucket ? bucket.name : bucket
-        req = RpbDelReq.new(:bucket => bucket, :key => key)
-        req.rw = normalize_quorum_value(rw) if rw
+        options = normalize_quorums(options)
+        options[:bucket] = maybe_encode(bucket)
+        options[:key] = maybe_encode(key)
+        options[:vclock] = Base64.decode64(options[:vclock]) if options[:vclock]
+        req = RpbDelReq.new(options)
         write_protobuff(:DelReq, req)
         decode_response
       end
 
       def get_bucket_props(bucket)
         bucket = bucket.name if Bucket === bucket
-        req = RpbGetBucketReq.new(:bucket => bucket)
+        req = RpbGetBucketReq.new(:bucket => maybe_encode(bucket))
         write_protobuff(:GetBucketReq, req)
         decode_response
       end
@@ -90,14 +81,14 @@ module Riak
       def set_bucket_props(bucket, props)
         bucket = bucket.name if Bucket === bucket
         props = props.slice('n_val', 'allow_mult')
-        req = RpbSetBucketReq.new(:bucket => bucket, :props => RpbBucketProps.new(props))
+        req = RpbSetBucketReq.new(:bucket => maybe_encode(bucket), :props => RpbBucketProps.new(props))
         write_protobuff(:SetBucketReq, req)
         decode_response
       end
 
       def list_keys(bucket, &block)
         bucket = bucket.name if Bucket === bucket
-        req = RpbListKeysReq.new(:bucket => bucket)
+        req = RpbListKeysReq.new(:bucket => maybe_encode(bucket))
         write_protobuff(:ListKeysReq, req)
         keys = []
         pump = Pump.new(block) if block_given?
@@ -165,9 +156,12 @@ module Riak
           when :GetServerInfoResp
             res = RpbGetServerInfoResp.decode(message)
             {:node => res.node, :server_version => res.server_version}
-          when :GetResp, :PutResp
+          when :GetResp
             res = RpbGetResp.decode(message)
             load_object(res, args.first)
+          when :PutResp
+            res = RpbPutResp.decode(message)
+            load_object(res, args.first)
           when :ListBucketsResp
             res = RpbListBucketsResp.decode(message)
             res.buckets
@@ -180,7 +174,7 @@ module Riak
             RpbMapRedResp.decode(message)
           end
         end
-      rescue SocketError => e
+      rescue SystemCallError, SocketError => e
         reset_socket
         raise Riak::ProtobuffsFailedRequest.new(:server_error, e.message)
       end

data/lib/riak/client/excon_backend.rb

@@ -1,16 +1,3 @@
-# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
 
 require 'riak/failed_request'
 require 'riak/client/http_backend'

data/lib/riak/client/http_backend.rb

@@ -1,17 +1,3 @@
-# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-
 require 'riak/util/escape'
 require 'riak/util/translation'
 require 'riak/util/multipart'
@@ -35,7 +21,7 @@ module Riak
     class HTTPBackend
       include Util::Escape
       include Util::Translation
-      
+
       include TransportMethods
       include ObjectMethods
       include Configuration
@@ -53,7 +39,7 @@ module Riak
       # Pings the server
       # @return [true,false] whether the server is available
       def ping
-        get(200, riak_kv_wm_ping, {}, {})
+        get(200, ping_path)
         true
       rescue
         false
@@ -63,20 +49,22 @@ module Riak
       # @param [Bucket, String] bucket the bucket where the object is
       #        stored
       # @param [String] key the key of the object
-      # @param [Fixnum, String, Symbol] r the read quorum for the
-      #         request - how many nodes should concur on the read
+      # @param [Hash] options request quorums
+      # @option options [Fixnum, String, Symbol] :r the read quorum for the
+      #   request - how many nodes should concur on the read
+      # @option options [Fixnum, String, Symbol] :pr the "primary"
+      #   read quorum for the request - how many primary partitions
+      #   must be available
       # @return [RObject] the fetched object
-      def fetch_object(bucket, key, r=nil)
+      def fetch_object(bucket, key, options={})
         bucket = Bucket.new(client, bucket) if String === bucket
-        options = r ? {:r => r} : {}
-        response = get([200,300],riak_kv_wm_raw, escape(bucket.name), escape(key), options, {})
+        response = get([200,300], object_path(bucket.name, key, options))
         load_object(RObject.new(bucket, key), response)
       end
 
       # Reloads the data for a given RObject, a special case of {#fetch_object}.
-      def reload_object(robject, r = nil)
-        options = r ? {:r => r} : {}
-        response = get([200,300,304], riak_kv_wm_raw, escape(robject.bucket.name), escape(robject.key), options, reload_headers(robject))
+      def reload_object(robject, options={})
+        response = get([200,300,304], object_path(robject.bucket.name, robject.key, options), reload_headers(robject))
         if response[:code].to_i == 304
           robject
         else
@@ -86,35 +74,37 @@ module Riak
 
       # Stores an object
       # @param [RObject] robject the object to store
-      # @param [true,false] returnbody (false) whether to update the object
+      # @param [Hash] options quorum and storage options
+      # @option options [true,false] :returnbody (false) whether to update the object
       #        after write with the new value
-      # @param [Fixnum, String, Symbol] w the write quorum
-      # @param [Fixnum, String, Symbol] dw the durable write quorum
-      def store_object(robject, returnbody=false, w=nil, dw=nil)
-        query = {}.tap do |q|
-          q[:returnbody] = returnbody unless returnbody.nil?
-          q[:w] = w unless w.nil?
-          q[:dw] = dw unless dw.nil?
-        end
-        method, codes, path = if robject.key.present?
-                                [:put, [200,204,300], "#{escape(robject.bucket.name)}/#{escape(robject.key)}"]
-                              else
-                                [:post, 201, escape(robject.bucket.name)]
-                              end
-        response = send(method, codes, riak_kv_wm_raw, path, query, robject.raw_data, store_headers(robject))
-        load_object(robject, response) if returnbody
+      # @option options [Fixnum, String, Symbol] :w the write quorum
+      # @option options [Fixnum, String, Symbol] :pw the "primary"
+      #   write quorum - how many primary partitions must be available
+      # @option options [Fixnum, String, Symbol] :dw the durable write quorum
+      def store_object(robject, options={})
+        method, codes = if robject.key.present?
+                          [:put, [200,204,300]]
+                        else
+                          [:post, 201]
+                        end
+        response = send(method, codes, object_path(robject.bucket.name, robject.key, options), robject.raw_data, store_headers(robject))
+        load_object(robject, response) if options[:returnbody]
       end
 
       # Deletes an object
       # @param [Bucket, String] bucket the bucket where the object
-      #        lives
+      #    lives
       # @param [String] key the key where the object lives
-      # @param [Fixnum, String, Symbol] rw the read/write quorum for
-      #        the request
-      def delete_object(bucket, key, rw=nil)
+      # @param [Hash] options quorum and delete options
+      # @options options [Fixnum, String, Symbol] :rw the read/write quorum for
+      #   the request
+      # @options options [String] :vclock the vector clock of the
+      #   object to be deleted
+      def delete_object(bucket, key, options={})
         bucket = bucket.name if Bucket === bucket
-        options = rw ? {:rw => rw} : {}
-        delete([204, 404], riak_kv_wm_raw, escape(bucket), escape(key), options, {})
+        vclock = options.delete(:vclock)
+        headers = vclock ? {"X-Riak-VClock" => vclock} : {}
+        delete([204, 404], object_path(bucket, key, options), headers)
       end
 
       # Fetches bucket properties
@@ -122,7 +112,7 @@ module Riak
       # @return [Hash] bucket properties
       def get_bucket_props(bucket)
         bucket = bucket.name if Bucket === bucket
-        response = get(200, riak_kv_wm_raw, escape(bucket), {:keys => false, :props => true}, {})
+        response = get(200, bucket_properties_path(bucket))
         JSON.parse(response[:body])['props']
       end
 
@@ -132,7 +122,7 @@ module Riak
       def set_bucket_props(bucket, props)
         bucket = bucket.name if Bucket === bucket
         body = {'props' => props}.to_json
-        put(204, riak_kv_wm_raw, escape(bucket), body, {"Content-Type" => "application/json"})
+        put(204, bucket_properties_path(bucket), body, {"Content-Type" => "application/json"})
       end
 
       # List keys in a bucket
@@ -143,10 +133,10 @@ module Riak
       # @return [Array<String>] the list of keys, if no block was given
       def list_keys(bucket, &block)
         bucket = bucket.name if Bucket === bucket
-        if block_given?          
-          get(200, riak_kv_wm_raw, escape(bucket), {:props => false, :keys => 'stream'}, {}, &KeyStreamer.new(block))
+        if block_given?
+          get(200, key_list_path(bucket, :keys => 'stream'), {}, &KeyStreamer.new(block))
         else
-          response = get(200, riak_kv_wm_raw, escape(bucket), {:props => false, :keys => true}, {})
+          response = get(200, key_list_path(bucket))
           obj = JSON.parse(response[:body])
           obj && obj['keys'].map {|k| unescape(k) }
         end
@@ -155,7 +145,7 @@ module Riak
       # Lists known buckets
       # @return [Array<String>] the list of buckets
       def list_buckets
-        response = get(200, riak_kv_wm_raw, {:buckets => true}, {})
+        response = get(200, bucket_list_path)
         JSON.parse(response[:body])['buckets']
       end
 
@@ -171,10 +161,10 @@ module Riak
             result = JSON.parse(response[:body])
             yield result['phase'], result['data']
           end
-          post(200, riak_kv_wm_mapred, {:chunked => true}, mr.to_json, {"Content-Type" => "application/json", "Accept" => "application/json"}, &parser)
+          post(200, mapred_path({:chunked => true}), mr.to_json, {"Content-Type" => "application/json", "Accept" => "application/json"}, &parser)
           nil
         else
-          response = post(200, riak_kv_wm_mapred, mr.to_json, {"Content-Type" => "application/json", "Accept" => "application/json"})
+          response = post(200, mapred_path, mr.to_json, {"Content-Type" => "application/json", "Accept" => "application/json"})
           begin
             JSON.parse(response[:body])
           rescue
@@ -186,7 +176,7 @@ module Riak
       # Gets health statistics
       # @return [Hash] information about the server, including stats
       def stats
-        response = get(200, riak_kv_wm_stats, {}, {})
+        response = get(200, stats_path)
         JSON.parse(response[:body])
       end
 
@@ -197,20 +187,65 @@ module Riak
       # @return [Array<Array<RObject>>] a list of the matched objects,
       #         grouped by phase
       def link_walk(robject, walk_specs)
-        response = get(200, riak_kv_wm_link_walker, escape(robject.bucket.name), escape(robject.key), walk_specs.join("/"))
+        response = get(200, link_walk_path(robject.bucket.name, robject.key, walk_specs))
         if boundary = Util::Multipart.extract_boundary(response[:headers]['content-type'].first)
           Util::Multipart.parse(response[:body], boundary).map do |group|
             group.map do |obj|
-              if obj[:headers] && obj[:body] && obj[:headers]['location']
-                bucket = $1 if obj[:headers]['location'].first =~ %r{/.*/(.*)/.*$}
-                load_object(RObject.new(client.bucket(bucket), nil), obj)
+              if obj[:headers] && !obj[:headers]['x-riak-deleted'] && !obj[:body].blank? && obj[:headers]['location']
+                link = Riak::Link.new(obj[:headers]['location'].first, "")
+                load_object(RObject.new(client.bucket(link.bucket), link.key), obj)
               end
-            end
+            end.compact
           end
         else
           []
         end
       end
+
+      # Performs a secondary-index query.
+      # @param [String, Bucket] bucket the bucket to query
+      # @param [String] index the index to query
+      # @param [String, Integer, Range] query the equality query or
+      #   range query to perform
+      # @return [Array<String>] a list of keys matching the query
+      def get_index(bucket, index, query)
+        bucket = bucket.name if Bucket === bucket
+        path = case query
+               when Range
+                 raise ArgumentError, t('invalid_index_query', :value => query.inspect) unless String === query.begin || Integer === query.end
+                 index_range_path(bucket, index, query.begin, query.end)
+               when String, Integer
+                 index_eq_path(bucket, index, query)
+               else
+                 raise ArgumentError, t('invalid_index_query', :value => query.inspect)
+               end
+        response = get(200, path)
+        JSON.parse(response[:body])['keys']
+      end
+
+      # (Riak Search) Performs a search query
+      # @param [String,nil] index the index to query, or nil for the
+      #   default
+      # @param [String] query the Lucene query to perform
+      # @param [Hash] options query options
+      # @see Client#search
+      def search(index, query, options={})
+        response = get(200, solr_select_path(index, query, options.stringify_keys))
+        if response[:headers]['content-type'].include?("application/json")
+          JSON.parse(response[:body])
+        else
+          response[:body]
+        end
+      end
+
+      # (Riak Search) Updates a search index (includes deletes).
+      # @param [String, nil] index the index to update, or nil for the
+      #   default index.
+      # @param [String] updates an XML update string in Solr's required format
+      # @see Client#index
+      def update_search_index(index, updates)
+        post(200, solr_update_path(index), updates, {'Content-Type' => 'text/xml'})
+      end
     end
   end
 end