riak-client 0.8.3 → 0.9.0.beta

data/Rakefile

@@ -26,6 +26,10 @@ gemspec = Gem::Specification.new do |gem|
                   lib/riak/cache_store.rb
                   lib/riak/client/curb_backend.rb
                   lib/riak/client/excon_backend.rb
+                  lib/riak/client/http_backend/configuration.rb
+                  lib/riak/client/http_backend/object_methods.rb
+                  lib/riak/client/http_backend/request_headers.rb
+                  lib/riak/client/http_backend/transport_methods.rb
                   lib/riak/client/http_backend.rb
                   lib/riak/client/net_http_backend.rb
                   lib/riak/client.rb
@@ -42,6 +46,8 @@ gemspec = Gem::Specification.new do |gem|
                   lib/riak/link.rb
                   lib/riak/locale
                   lib/riak/locale/en.yml
+                  lib/riak/map_reduce/filter_builder.rb
+                  lib/riak/map_reduce/phase.rb
                   lib/riak/map_reduce.rb
                   lib/riak/map_reduce_error.rb
                   lib/riak/robject.rb
@@ -68,6 +74,7 @@ gemspec = Gem::Specification.new do |gem|
                   spec/riak/escape_spec.rb
                   spec/riak/excon_backend_spec.rb
                   spec/riak/headers_spec.rb
+                  spec/riak/http_backend/object_methods_spec.rb
                   spec/riak/http_backend_spec.rb
                   spec/riak/link_spec.rb
                   spec/riak/map_reduce_spec.rb
@@ -110,18 +117,18 @@ require 'rspec/core'
 require 'rspec/core/rake_task'
 
 desc "Run Unit Specs Only"
-Rspec::Core::RakeTask.new(:spec) do |spec|
+RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = "spec/riak/**/*_spec.rb"
 end
 
 namespace :spec do
   desc "Run Integration Specs Only"
-  Rspec::Core::RakeTask.new(:integration) do |spec|
+  RSpec::Core::RakeTask.new(:integration) do |spec|
     spec.pattern = "spec/integration/**/*_spec.rb"
   end
 
   desc "Run All Specs"
-  Rspec::Core::RakeTask.new(:all) do |spec|
+  RSpec::Core::RakeTask.new(:all) do |spec|
     spec.pattern = "spec/**/*_spec.rb"
   end
 end

data/lib/riak/bucket.rb

@@ -32,23 +32,7 @@ module Riak
     def initialize(client, name)
       raise ArgumentError, t("client_type", :client => client.inspect) unless Client === client
       raise ArgumentError, t("string_type", :string => name.inspect) unless String === name
-      @client, @name, @props = client, name, {}
-    end
-
-    # Load information for the bucket from a response given by the {Riak::Client::HTTPBackend}.
-    # Used mostly internally - use {Riak::Client#bucket} to get a {Bucket} instance.
-    # @param [Hash] response a response from {Riak::Client::HTTPBackend}
-    # @return [Bucket] self
-    # @see Client#bucket
-    def load(response={})
-      content_type = response[:headers]['content-type'].first rescue ""
-      unless content_type =~ /json$/
-        raise Riak::InvalidResponse.new({"content-type" => ["application/json"]}, response[:headers], t("loading_bucket", :name => name))
-      end
-      payload = JSON.parse(response[:body])
-      @keys = payload['keys'].map {|k| CGI.unescape(k) }  if payload['keys']
-      @props = payload['props'] if payload['props']
-      self
+      @client, @name = client, name
     end
 
     # Accesses or retrieves a list of keys in this bucket.
@@ -59,21 +43,15 @@ module Riak
     # @yield [Array<String>] a list of keys from the current chunk
     # @option options [Boolean] :reload (false) If present, will force reloading of the bucket's keys from Riak
     # @return [Array<String>] Keys in this bucket
-    def keys(options={})
+    def keys(options={}, &block)
       if block_given?
-        @client.http.get(200, @client.prefix, escape(name), {:props => false, :keys => 'stream'}, {}) do |chunk|
-          obj = JSON.parse(chunk) rescue nil
-          next unless obj and obj['keys']
-          yield obj['keys'].map {|k| CGI.unescape(k) } if obj['keys']
-        end
+        @client.backend.list_keys(self, &block)
       elsif @keys.nil? || options[:reload]
-        response = @client.http.get(200, @client.prefix, escape(name), {:props => false, :keys => true}, {})
-        load(response)
+        @keys = @client.backend.list_keys(self)
       end
       @keys
     end
 
-
     # Sets internal properties on the bucket
     # Note: this results in a request to the Riak server!
     # @param [Hash] properties new properties for the bucket
@@ -95,18 +73,18 @@ module Riak
     # @see #n_value, #allow_mult, #r, #w, #dw, #rw
     def props=(properties)
       raise ArgumentError, t("hash_type", :hash => properties.inspect) unless Hash === properties
-      body = {'props' => properties}.to_json
-      @client.http.put(204, @client.prefix, escape(name), body, {"Content-Type" => "application/json"})
-      @props.merge!(properties)
+      props.merge!(properties)
+      @client.backend.set_bucket_props(self, properties)
+      props
     end
-    alias properties= props=
+    alias :'properties=' :'props='
 
     # @return [Hash] Internal Riak bucket properties.
     # @see #props=
     def props
-      @props
+      @props ||= @client.backend.get_bucket_props(self)
     end
-    alias properties props
+    alias :properties :props
 
     # Retrieve an object from within the bucket.
     # @param [String] key the key of the object to retrieve
@@ -115,9 +93,7 @@ module Riak
     # @return [Riak::RObject] the object
     # @raise [FailedRequest] if the object is not found or some other error occurs
     def get(key, options={})
-      code = allow_mult ? [200,300] : 200
-      response = @client.http.get(code, @client.prefix, escape(name), escape(key), options, {})
-      RObject.new(self, key).load(response)
+      @client.backend.fetch_object(self, key, options[:r])
     end
     alias :[] :get
 
@@ -151,8 +127,12 @@ module Riak
     # @option options [Fixnum] :r - the read quorum value for the request (R)
     # @return [true, false] whether the key exists in this bucket
     def exists?(key, options={})
-      result = client.http.head([200,404], client.prefix, escape(name), escape(key), options, {})
-      result[:code] == 200
+      begin
+        get(key, options)
+        true
+      rescue Riak::FailedRequest
+        false
+      end
     end
     alias :exist? :exists?
 
@@ -161,7 +141,7 @@ module Riak
     # @param [Hash] options quorum options
     # @option options [Fixnum] :rw - the read/write quorum for the delete
     def delete(key, options={})
-      client.http.delete([204,404], client.prefix, escape(name), escape(key), options, {})
+      client.backend.delete_object(self, key, options[:rw])
     end
 
     # @return [true, false] whether the bucket allows divergent siblings
@@ -181,7 +161,7 @@ module Riak
       props['n_val']
     end
     alias :n_val :n_value
-    
+
     # Set the N value (number of replicas). *NOTE* This will result in a PUT request to Riak.
     # Setting this value after the bucket has objects stored in it may have unpredictable results.
     # @param [Fixnum] value the number of replicas the bucket should keep of each object
@@ -189,8 +169,8 @@ module Riak
       self.props = {'n_val' => value}
       value
     end
-    alias :n_val= :n_value=
-    
+    alias :'n_val=' :'n_value='
+
     [:r,:w,:dw,:rw].each do |q|
       class_eval <<-CODE
         def #{q}
@@ -202,11 +182,16 @@ module Riak
           value
         end
         CODE
-      end
+    end
 
-      # @return [String] a representation suitable for IRB and debugging output
-      def inspect
-        "#<Riak::Bucket #{client.http.path(client.prefix, escape(name)).to_s}#{" keys=[#{keys.join(',')}]" if defined?(@keys)}>"
-      end
+    # @return [String] a representation suitable for IRB and debugging output
+    def inspect
+      "#<Riak::Bucket {#{name}}#{" keys=[#{keys.join(',')}]" if defined?(@keys)}>"
+    end
+
+    # @return [true,false] whether the other is equivalent
+    def ==(other)
+      Bucket === other && other.client == client && other.name == name
     end
   end
+end

data/lib/riak/client.rb

@@ -130,21 +130,35 @@ module Riak
                 end
     end
 
+    alias :backend :http
+
     # Retrieves a bucket from Riak.
     # @param [String] bucket the bucket to retrieve
     # @param [Hash] options options for retrieving the bucket
-    # @option options [Boolean] :keys (true) whether to retrieve the bucket keys
-    # @option options [Boolean] :props (true) whether to retreive the bucket properties
+    # @option options [Boolean] :keys (false whether to retrieve the bucket keys
+    # @option options [Boolean] :props (false) whether to retreive the bucket properties
     # @return [Bucket] the requested bucket
     def bucket(name, options={})
       unless (options.keys - [:keys, :props]).empty?
         raise ArgumentError, "invalid options"
       end
-      response = http.get(200, prefix, escape(name), {:keys => false}.merge(options), {})
-      Bucket.new(self, name).load(response)
+      @bucket_cache ||= {}
+      (@bucket_cache[name] ||= Bucket.new(self, name)).tap do |b|
+        b.props if options[:props]
+        b.keys  if options[:keys]
+      end
     end
     alias :[] :bucket
 
+    # Lists buckets which have keys stored in them.
+    # @note This is an expensive operation and should be used only
+    #       in development.
+    # @return [Array<Bucket>] a list of buckets
+    def buckets
+      backend.list_buckets.map {|name| Bucket.new(self, name) }
+    end
+    alias :list_buckets :buckets
+
     # Stores a large file/IO object in Riak via the "Luwak" interface.
     # @overload store_file(filename, content_type, data)
     #   Stores the file at the given key/filename

data/lib/riak/client/excon_backend.rb

@@ -21,6 +21,11 @@ module Riak
     class ExconBackend < HTTPBackend
       def self.configured?
         begin
+          begin
+            require 'fiber'
+          rescue LoadError
+            require 'riak/util/fiber1.8'
+          end
           require 'excon'
           Excon::VERSION >= "0.3.4"
         rescue LoadError
@@ -38,7 +43,16 @@ module Riak
         params[:query] = uri.query if uri.query
         params[:body] = data if [:put,:post].include?(method)
         params[:idempotent] = (method != :post)
-
+        if block_given?
+          passed_block = block
+          Fiber.new {
+            f = Fiber.current
+            block = lambda {|chunk| f.resume(chunk) }
+            loop do
+              passed_block.call Fiber.yield
+            end
+          }.resume
+        end
         response = connection.request(params, &block)
         if valid_response?(expect, response.status)
           response_headers.initialize_http_header(response.headers)

data/lib/riak/client/http_backend.rb

@@ -13,11 +13,27 @@
 #    limitations under the License.
 require 'riak'
 
+
 module Riak
   class Client
-    # The parent class for all backends that connect to Riak via HTTP.
+    # The parent class for all backends that connect to Riak via
+    # HTTP. This class implements all of the universal backend API
+    # methods on behalf of subclasses, which need only implement the
+    # {TransportMethods#perform} method for library-specific
+    # semantics.
     class HTTPBackend
+      autoload :RequestHeaders,   "riak/client/http_backend/request_headers"
+      autoload :TransportMethods, "riak/client/http_backend/transport_methods"
+      autoload :ObjectMethods,    "riak/client/http_backend/object_methods"
+      autoload :Configuration,    "riak/client/http_backend/configuration"
+
+      include TransportMethods
+      include ObjectMethods
+      include Configuration
+
+      include Util::Escape
       include Util::Translation
+
       # The Riak::Client that uses this backend
       attr_reader :client
 
@@ -28,212 +44,169 @@ module Riak
         @client = client
       end
 
-      # Default header hash sent with every request, based on settings in the client
-      # @return [Hash] headers that will be merged with user-specified headers on every request
-      def default_headers
-        {
-          "Accept" => "multipart/mixed, application/json;q=0.7, */*;q=0.5",
-          "X-Riak-ClientId" => @client.client_id
-        }
-      end
-
-      # Performs a HEAD request to the specified resource on the Riak server.
-      # @param [Fixnum, Array] expect the expected HTTP response code(s) from Riak
-      # @param [String, Array<String,Hash>] resource a relative path or array of path segments and optional query params Hash that will be joined to the root URI
-      # @overload head(expect, *resource)
-      # @overload head(expect, *resource, headers)
-      #   Send the request with custom headers
-      #   @param [Hash] headers custom headers to send with the request
-      # @return [Hash] response data, containing only the :headers and :code keys
-      # @raise [FailedRequest] if the response code doesn't match the expected response
-      def head(expect, *resource)
-        headers = default_headers.merge(resource.extract_options!)
-        verify_path!(resource)
-        perform(:head, path(*resource), headers, expect)
-      end
-
-      # Performs a GET request to the specified resource on the Riak server.
-      # @param [Fixnum, Array] expect the expected HTTP response code(s) from Riak
-      # @param [String, Array<String,Hash>] resource a relative path or array of path segments and optional query params Hash that will be joined to the root URI
-      # @overload get(expect, *resource)
-      # @overload get(expect, *resource, headers)
-      #   Send the request with custom headers
-      #   @param [Hash] headers custom headers to send with the request
-      # @overload get(expect, *resource, headers={})
-      #   Stream the response body through the supplied block
-      #   @param [Hash] headers custom headers to send with the request
-      #   @yield [chunk] yields successive chunks of the response body as strings
-      #   @return [Hash] response data, containing only the :headers and :code keys
-      # @return [Hash] response data, containing :headers, :body, and :code keys
-      # @raise [FailedRequest] if the response code doesn't match the expected response
-      def get(expect, *resource, &block)
-        headers = default_headers.merge(resource.extract_options!)
-        verify_path!(resource)
-        perform(:get, path(*resource), headers, expect, &block)
-      end
-
-      # Performs a PUT request to the specified resource on the Riak server.
-      # @param [Fixnum, Array] expect the expected HTTP response code(s) from Riak
-      # @param [String, Array<String,Hash>] resource a relative path or array of path segments and optional query params Hash that will be joined to the root URI
-      # @param [String] body the request body to send to the server
-      # @overload put(expect, *resource, body)
-      # @overload put(expect, *resource, body, headers)
-      #   Send the request with custom headers
-      #   @param [Hash] headers custom headers to send with the request
-      # @overload put(expect, *resource, body, headers={})
-      #   Stream the response body through the supplied block
-      #   @param [Hash] headers custom headers to send with the request
-      #   @yield [chunk] yields successive chunks of the response body as strings
-      #   @return [Hash] response data, containing only the :headers and :code keys
-      # @return [Hash] response data, containing :headers, :code, and :body keys
-      # @raise [FailedRequest] if the response code doesn't match the expected response
-      def put(expect, *resource, &block)
-        headers = default_headers.merge(resource.extract_options!)
-        uri, data = verify_path_and_body!(resource)
-        perform(:put, path(*uri), headers, expect, data, &block)
-      end
-
-      # Performs a POST request to the specified resource on the Riak server.
-      # @param [Fixnum, Array] expect the expected HTTP response code(s) from Riak
-      # @param [String, Array<String>] resource a relative path or array of path segments that will be joined to the root URI
-      # @param [String] body the request body to send to the server
-      # @overload post(expect, *resource, body)
-      # @overload post(expect, *resource, body, headers)
-      #   Send the request with custom headers
-      #   @param [Hash] headers custom headers to send with the request
-      # @overload post(expect, *resource, body, headers={})
-      #   Stream the response body through the supplied block
-      #   @param [Hash] headers custom headers to send with the request
-      #   @yield [chunk] yields successive chunks of the response body as strings
-      #   @return [Hash] response data, containing only the :headers and :code keys
-      # @return [Hash] response data, containing :headers, :code and :body keys
-      # @raise [FailedRequest] if the response code doesn't match the expected response
-      def post(expect, *resource, &block)
-        headers = default_headers.merge(resource.extract_options!)
-        uri, data = verify_path_and_body!(resource)
-        perform(:post, path(*uri), headers, expect, data, &block)
-      end
-
-      # Performs a DELETE request to the specified resource on the Riak server.
-      # @param [Fixnum, Array] expect the expected HTTP response code(s) from Riak
-      # @param [String, Array<String,Hash>] resource a relative path or array of path segments and optional query params Hash that will be joined to the root URI
-      # @overload delete(expect, *resource)
-      # @overload delete(expect, *resource, headers)
-      #   Send the request with custom headers
-      #   @param [Hash] headers custom headers to send with the request
-      # @overload delete(expect, *resource, headers={})
-      #   Stream the response body through the supplied block
-      #   @param [Hash] headers custom headers to send with the request
-      #   @yield [chunk] yields successive chunks of the response body as strings
-      #   @return [Hash] response data, containing only the :headers and :code keys
-      # @return [Hash] response data, containing :headers, :code and :body keys
-      # @raise [FailedRequest] if the response code doesn't match the expected response
-      def delete(expect, *resource, &block)
-        headers = default_headers.merge(resource.extract_options!)
-        verify_path!(resource)
-        perform(:delete, path(*resource), headers, expect, &block)
-      end
-
-      # @return [URI] The calculated root URI for the Riak HTTP endpoint
-      def root_uri
-        URI.parse("http://#{@client.host}:#{@client.port}")
-      end
-
-      # Calculates an absolute URI from a relative path specification
-      # @param [Array<String,Hash>] segments a relative path or sequence of path segments and optional query params Hash that will be joined to the root URI
-      # @return [URI] an absolute URI for the resource
-      def path(*segments)
-        query = segments.extract_options!.to_param
-        root_uri.merge(segments.join("/").gsub(/\/+/, "/").sub(/^\//, '')).tap do |uri|
-          uri.query = query if query.present?
+      # Pings the server
+      # @return [true,false] whether the server is available
+      def ping
+        get(200, riak_kv_wm_ping, {}, {})
+        true
+      rescue
+        false
+      end
+
+      # Fetches an object by bucket/key
+      # @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
+      # @return [RObject] the fetched object
+      def fetch_object(bucket, key, r=nil)
+        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, {})
+        load_object(RObject.new(bucket, key), response)
+      end
+
+      # Reloads the data for a given RObject, a special case of {#fetch}.
+      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))
+        if response[:code].to_i == 304
+          robject
+        else
+          load_object(robject, response)
         end
       end
 
-      # Verifies that both a resource path and body are present in the arguments
-      # @param [Array] args the arguments to verify
-      # @raise [ArgumentError] if the body or resource is missing, or if the body is not a String
-      def verify_path_and_body!(args)
-        body = args.pop
-        begin
-          verify_path!(args)
-        rescue ArgumentError
-          raise ArgumentError, t("path_and_body_required")
+      # Stores an object
+      # @param [RObject] robject the object to store
+      # @param [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
-
-        raise ArgumentError, t("request_body_type") unless String === body || IO === body
-        [args, body]
-      end
-
-      # Verifies that the specified resource is valid
-      # @param [String, Array] resource the resource specification
-      # @raise [ArgumentError] if the resource path is too short
-      def verify_path!(resource)
-        resource = Array(resource).flatten
-        raise ArgumentError, t("resource_path_short") unless resource.length > 1 || resource.include?(@client.mapred)
-      end
-
-      # Checks the expected response codes against the actual response code. Use internally when
-      # implementing {#perform}.
-      # @param [String, Fixnum, Array<String,Fixnum>] expected the expected response code(s)
-      # @param [String, Fixnum] actual the received response code
-      # @return [Boolean] whether the actual response code is acceptable given the expectations
-      def valid_response?(expected, actual)
-        Array(expected).map(&:to_i).include?(actual.to_i)
-      end
-
-      # Checks whether a combination of the HTTP method, response code, and block should
-      # result in returning the :body in the response hash. Use internally when implementing {#perform}.
-      # @param [Symbol] method the HTTP method
-      # @param [String, Fixnum] code the received response code
-      # @param [Boolean] has_block whether a streaming block was passed to {#perform}. Pass block_given? to this parameter.
-      # @return [Boolean] whether to return the body in the response hash
-      def return_body?(method, code, has_block)
-        method != :head && !valid_response?([204,205,304], code) && !has_block
-      end
-
-      # Executes requests according to the underlying HTTP client library semantics.
-      # @abstract Subclasses must implement this internal method to perform HTTP requests
-      #           according to the API of their HTTP libraries.
-      # @param [Symbol] method one of :head, :get, :post, :put, :delete
-      # @param [URI] uri the HTTP URI to request
-      # @param [Hash] headers headers to send along with the request
-      # @param [Fixnum, Array] expect the expected response code(s)
-      # @param [String, IO] body the PUT or POST request body
-      # @return [Hash] response data, containing :headers, :code and :body keys. Only :headers and :code should be present when the body is streamed or the method is :head.
-      # @yield [chunk] if the method is not :head, successive chunks of the response body will be yielded as strings
-      # @raise [NotImplementedError] if a subclass does not implement this method
-      def perform(method, uri, headers, expect, body=nil)
-        raise NotImplementedError
-      end
-
-      private
-      def response_headers
-        Thread.current[:response_headers] ||= Riak::Util::Headers.new
-      end
-
-      # @private
-      class RequestHeaders < Riak::Util::Headers
-        alias each each_capitalized
-
-        def initialize(hash)
-          initialize_http_header(hash)
+        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
+      end
+
+      # Deletes an object
+      # @param [Bucket, String] bucket the bucket where the object
+      #        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)
+        bucket = bucket.name if Bucket === bucket
+        options = rw ? {:rw => rw} : {}
+        delete([204, 404], riak_kv_wm_raw, escape(bucket), escape(key), options, {})
+      end
+
+      # Fetches bucket properties
+      # @param [Bucket, String] bucket the bucket properties to fetch
+      # @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}, {})
+        JSON.parse(response[:body])['props']
+      end
+
+      # Sets bucket properties
+      # @param [Bucket, String] bucket the bucket to set properties on
+      # @param [Hash] properties the properties to set
+      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"})
+      end
+
+      # List keys in a bucket
+      # @param [Bucket, String] bucket the bucket to fetch the keys
+      #        for
+      # @yield [Array<String>] a list of keys from the current
+      #        streamed chunk
+      # @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'}, {}) do |chunk|
+            obj = JSON.parse(chunk) rescue nil
+            next unless obj && obj['keys']
+            yield obj['keys'].map {|k| unescape(k) }
+          end
+        else
+          response = get(200, riak_kv_wm_raw, escape(bucket), {:props => false, :keys => true}, {})
+          obj = JSON.parse(response[:body])
+          obj && obj['keys'].map {|k| unescape(k) }
         end
+      end
 
-        def to_a
-          [].tap do |arr|
-            each_capitalized do |k,v|
-              arr << "#{k}: #{v}"
-            end
+      # Lists known buckets
+      # @return [Array<String>] the list of buckets
+      def list_buckets
+        response = get(200, riak_kv_wm_raw, {:buckets => true}, {})
+        JSON.parse(response[:body])['buckets']
+      end
+
+      # Performs a MapReduce query.
+      # @param [MapReduce] mr the query to perform
+      # @yield [Fixnum, Object] the phase number and single result
+      #        from the phase
+      # @return [Array<Object>] the list of results, if no block was
+      #        given
+      def mapred(mr)
+        response = post(200, riak_kv_wm_mapred, mr.to_json, {"Content-Type" => "application/json", "Accept" => "application/json"})
+        data = begin
+                 JSON.parse(response[:body])
+               rescue
+                 response
+               end
+        # This fakes streaming until the streaming MIME parser works.
+        if block_given?
+          data = [data] if mr.query.count {|p| p.keep } == 1
+          data.each_with_index do |phase, idx|
+            phase.each {|obj| yield idx, obj }
           end
+        else
+          data
         end
+      end
 
-        def to_hash
-          {}.tap do |hash|
-            each_capitalized do |k,v|
-              hash[k] ||= []
-              hash[k] << v
+      # Gets health statistics
+      # @return [Hash] information about the server, including stats
+      def stats
+        response = get(200, riak_kv_wm_stats, {}, {})
+        JSON.parse(response[:body])
+      end
+
+      # Performs a link-walking query
+      # @param [RObject] robject the object to start at
+      # @param [Array<WalkSpec>] walk_specs a list of walk
+      #        specifications to process
+      # @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("/"))
+        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, key = $1, $2 if obj[:headers]['location'].first =~ %r{/.*/(.*)/(.*)$}
+                load_object(RObject.new(client.bucket(bucket), key), obj)
+              end
             end
           end
+        else
+          []
         end
       end
     end