riak-client 0.9.8 → 1.0.0.beta

data/erl_src/riak_search_test_backend.erl

@@ -0,0 +1,175 @@
+%% -------------------------------------------------------------------
+%%
+%% Copyright (c) 2007-2010 Basho Technologies, Inc.  All Rights Reserved.
+%%
+%% -------------------------------------------------------------------
+
+-module(riak_search_test_backend).
+-behavior(riak_search_backend).
+
+-export([
+         reset/0,
+         start/2,
+         stop/1,
+         index/2,
+         delete/2,
+         stream/6,
+         range/8,
+         info/5,
+         fold/3,
+         is_empty/1,
+         drop/1
+        ]).
+-export([
+         stream_results/3
+        ]).
+
+-include_lib("riak_search/include/riak_search.hrl").
+
+-record(state, {partition, table}).
+
+reset() ->
+    {ok, Ring} = riak_core_ring_manager:get_my_ring(),
+    [ ets:delete_all_objects(list_to_atom("rs" ++ integer_to_list(P))) ||
+        P <- riak_core_ring:my_indices(Ring) ],
+    riak_search_config:clear(),
+    ok.
+
+start(Partition, _Config) ->
+    Table = ets:new(list_to_atom("rs" ++ integer_to_list(Partition)),
+                    [named_table, public, ordered_set]),
+    {ok, #state{partition=Partition, table=Table}}.
+
+stop(State) ->
+    maybe_delete(State).
+
+index(IFTVPKList, #state{table=Table}=State) ->
+    lists:foreach(
+      fun({I, F, T, V, P, K}) ->
+              Key = {b(I), b(F), b(T), b(V)},
+              case ets:lookup(Table, Key) of
+                  [{_, _, ExistingKeyClock}] ->
+                      if ExistingKeyClock > K ->
+                              %% stored data is newer
+                              ok;
+                         true ->
+                              %% stored data is older
+                              ets:update_element(Table, Key,
+                                                 [{2, P},{3, K}])
+                      end;
+                  [] ->
+                      ets:insert(Table, {Key, P, K})
+              end
+      end,
+      IFTVPKList),
+    {reply, {indexed, node()}, State}.
+
+delete(IFTVKList, State) ->
+    Table = State#state.table,
+    lists:foreach(fun(IFTVK) -> delete_fun(IFTVK, Table) end, IFTVKList),
+    {reply, {deleted, node()}, State}.
+
+delete_fun({I, F, T, V, K}, Table) ->
+    Key = {b(I), b(F), b(T), b(V)},
+    case ets:lookup(Table, Key) of
+        [{Key, _Props, ExistingKeyClock}] ->
+            if ExistingKeyClock > K ->
+                    %% stored data is newer
+                    ok;
+               true ->
+                    %% stored data is older
+                    ets:delete(Table, Key)
+            end;
+        [] ->
+            ok
+    end;
+delete_fun({I, F, T, V, _P, K}, Table) ->
+    %% copied idea from merge_index_backend
+    %% other operations include Props, though delete shouldn't
+    delete_fun({I, F, T, V, K}, Table).
+
+info(Index, Field, Term, Sender, State) ->
+    Count = ets:select_count(State#state.table,
+                             [{{{b(Index), b(Field), b(Term), '_'},
+                                '_', '_'},
+                               [],[true]}]),
+    riak_search_backend:info_response(Sender, [{Term, node(), Count}]),
+    noreply.
+
+-define(STREAM_SIZE, 100).
+
+range(Index, Field, StartTerm, EndTerm, _Size, FilterFun, Sender, State) ->
+    ST = b(StartTerm),
+    ET = b(EndTerm),
+    spawn(riak_search_ets_backend, stream_results,
+          [Sender,
+           FilterFun,
+           ets:select(State#state.table,
+                      [{{{b(Index), b(Field), '$1', '$2'}, '$3', '_'},
+                        [{'>=', '$1', ST}, {'=<', '$1', ET}],
+                        [{{'$2', '$3'}}]}],
+                      ?STREAM_SIZE)]),
+    noreply.
+
+stream(Index, Field, Term, FilterFun, Sender, State) ->
+    spawn(riak_search_ets_backend, stream_results,
+          [Sender,
+           FilterFun,
+           ets:select(State#state.table,
+                      [{{{b(Index), b(Field), b(Term), '$1'}, '$2', '_'},
+                        [], [{{'$1', '$2'}}]}],
+                      ?STREAM_SIZE)]),
+    noreply.
+
+stream_results(Sender, FilterFun, {Results0, Continuation}) ->
+    case lists:filter(fun({V,P}) -> FilterFun(V, P) end, Results0) of
+        [] ->
+            ok;
+        Results ->
+            riak_search_backend:response_results(Sender, Results)
+    end,
+    stream_results(Sender, FilterFun, ets:select(Continuation));
+stream_results(Sender, _, '$end_of_table') ->
+    riak_search_backend:response_done(Sender).
+
+fold(FoldFun, Acc, State) ->
+    Fun = fun({{I,F,T,V},P,K}, {OuterAcc, {{I,{F,T}},InnerAcc}}) ->
+                  %% same IFT, just accumulate doc/props/clock
+                  {OuterAcc, {{I,{F,T}},[{V,P,K}|InnerAcc]}};
+             ({{I,F,T,V},P,K}, {OuterAcc, {FoldKey, VPKList}}) ->
+                  %% finished a string of IFT, send it off
+                  %% (sorted order is assumed)
+                  NewOuterAcc = FoldFun(FoldKey, VPKList, OuterAcc),
+                  {NewOuterAcc, {{I,{F,T}},[{V,P,K}]}};
+             ({{I,F,T,V},P,K}, {OuterAcc, undefined}) ->
+                  %% first round through the fold - just start building
+                  {OuterAcc, {{I,{F,T}},[{V,P,K}]}}
+          end,
+    {OuterAcc0, Final} = ets:foldl(Fun, {Acc, undefined}, State#state.table),
+    OuterAcc = case Final of
+                   {FoldKey, VPKList} ->
+                       %% one last IFT to send off
+                       FoldFun(FoldKey, VPKList, OuterAcc0);
+                   undefined ->
+                       %% this partition was empty
+                       OuterAcc0
+               end,
+    {reply, OuterAcc, State}.
+
+is_empty(State) ->
+    0 == ets:info(State#state.table, size).
+
+drop(State) ->
+    maybe_delete(State).
+
+maybe_delete(State) ->
+    case lists:member(State#state.table, ets:all()) of
+        true ->
+            ets:delete(State#state.table),
+            ok;
+        false ->
+            ok
+    end.
+
+b(Binary) when is_binary(Binary) -> Binary;
+b(List) when is_list(List) -> iolist_to_binary(List).

data/lib/active_support/cache/riak_store.rb

@@ -1,15 +1,2 @@
-# 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'
 require 'riak/cache_store'

data/lib/riak.rb

@@ -1,26 +1,21 @@
-# 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.
-$KCODE = "UTF8" if RUBY_VERSION < "1.9"
-
+require 'riak/encoding'
 require 'riak/core_ext'
 require 'riak/client'
 require 'riak/map_reduce'
+require 'riak/util/translation'
 
 # The Riak module contains all aspects of the client interface to
 # Riak.
 module Riak
   # Utility classes and mixins
-  module Util
+  module Util; end
+  extend Util::Translation
+
+  class << self
+    # Only change this if you really know what you're doing. Better to
+    # err on the side of caution and assume you don't.
+    # @private
+    attr_accessor :disable_list_keys_warnings
   end
+  self.disable_list_keys_warnings = false
 end

data/lib/riak/bucket.rb

@@ -1,19 +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 'riak/util/translation'
-require 'riak/util/escape'
 require 'riak/client'
 require 'riak/robject'
 require 'riak/failed_request'
@@ -23,7 +8,9 @@ module Riak
   # using {Client#bucket}, or create it manually and retrieve its meta-information later.
   class Bucket
     include Util::Translation
-    include Util::Escape
+
+    # (Riak Search) The precommit specification for kv/search integration
+    SEARCH_PRECOMMIT_HOOK = {"mod" => "riak_search_kv_hook", "fun" => "precommit"}
 
     # @return [Riak::Client] the associated client
     attr_reader :client
@@ -40,22 +27,21 @@ module Riak
       @client, @name = client, name
     end
 
-    # Accesses or retrieves a list of keys in this bucket.
+    # Retrieves a list of keys in this bucket.
     # If a block is given, keys will be streamed through
     # the block (useful for large buckets). When streaming,
-    # results of the operation will not be retained in the local Bucket object.
-    # @param [Hash] options extra options
+    # results of the operation will not be returned to the caller.
     # @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={}, &block)
+    # @note This operation has serious performance implications and
+    #    should not be used in production applications.
+    def keys(&block)
+      warn(t('list_keys', :backtrace => caller.join("\n    "))) unless Riak.disable_list_keys_warnings
       if block_given?
-        @client.backend.list_keys(self, &block)
-        @keys = nil
-      elsif @keys.nil? || options[:reload]
-        @keys = @client.backend.list_keys(self)
+        @client.list_keys(self, &block)
+      else
+        @client.list_keys(self)
       end
-      @keys
     end
 
     # Sets internal properties on the bucket
@@ -80,7 +66,7 @@ module Riak
     def props=(properties)
       raise ArgumentError, t("hash_type", :hash => properties.inspect) unless Hash === properties
       props.merge!(properties)
-      @client.backend.set_bucket_props(self, properties)
+      @client.set_bucket_props(self, properties)
       props
     end
     alias :'properties=' :'props='
@@ -88,7 +74,7 @@ module Riak
     # @return [Hash] Internal Riak bucket properties.
     # @see #props=
     def props
-      @props ||= @client.backend.get_bucket_props(self)
+      @props ||= @client.get_bucket_props(self)
     end
     alias :properties :props
 
@@ -99,7 +85,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={})
-      @client.backend.fetch_object(self, key, options[:r])
+      @client.get_object(self, key, options)
     end
     alias :[] :get
 
@@ -145,9 +131,23 @@ module Riak
     # Deletes a key from the bucket
     # @param [String] key the key to delete
     # @param [Hash] options quorum options
-    # @option options [Fixnum] :rw - the read/write quorum for the delete
+    # @option options [Fixnum] :rw - the read/write quorum for the
+    #   delete
+    # @option options [String] :vclock - the vector clock of the
+    #   object being deleted
     def delete(key, options={})
-      client.backend.delete_object(self, key, options[:rw])
+      client.delete_object(self, key, options)
+    end
+
+    # Queries a secondary index on the bucket.
+    # @note This will only work if your Riak installation supports 2I.
+    # @param [String] index the name of the index
+    # @param [String,Integer,Range] query the value of the index, or a
+    #   Range of values to query
+    # @return [Array<String>] a list of keys that match the index
+    #   query
+    def get_index(index, query)
+      client.get_index(self, index, query)
     end
 
     # @return [true, false] whether the bucket allows divergent siblings
@@ -177,17 +177,35 @@ module Riak
     end
     alias :'n_val=' :'n_value='
 
-    [:r,:w,:dw,:rw].each do |q|
-      class_eval <<-CODE
-        def #{q}
-          props["#{q}"]
-        end
+    %w(r w dw rw).each do |q|
+      define_method(q) { props[q] }
+      define_method("#{q}=") { |value|
+        self.props = { q => value }
+        value
+      }
+    end
 
-        def #{q}=(value)
-          self.props = {"#{q}" => value}
-          value
-        end
-        CODE
+    # (Riak Search) Installs a precommit hook that automatically indexes objects
+    # into riak_search.
+    def enable_index!
+      unless is_indexed?
+        self.props = {"precommit" => (props['precommit'] + [SEARCH_PRECOMMIT_HOOK]), "search" => true}
+      end
+    end
+
+    # (Riak Search) Removes the precommit hook that automatically indexes objects
+    # into riak_search.
+    def disable_index!
+      if is_indexed?
+        self.props = {"precommit" => (props['precommit'] - [SEARCH_PRECOMMIT_HOOK]), "search" => false}
+      end
+    end
+
+    # (Riak Search) Detects whether the bucket is automatically indexed into
+    # riak_search.
+    # @return [true,false] whether the bucket includes the search indexing hook
+    def is_indexed?
+      props['search'] == true || props['precommit'].include?(SEARCH_PRECOMMIT_HOOK)
     end
 
     # @return [String] a representation suitable for IRB and debugging output

data/lib/riak/cache_store.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 'yaml'
 require 'riak/client'
@@ -45,7 +32,7 @@ module Riak
     end
 
     def bucket
-      @bucket ||= @client.bucket(@bucket_name, :keys => false)
+      @bucket ||= @client.bucket(@bucket_name)
     end
 
     def delete_matched(matcher, options={})

data/lib/riak/client.rb

@@ -1,30 +1,17 @@
-# 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 'tempfile'
 require 'delegate'
 require 'riak'
 require 'riak/util/translation'
 require 'riak/util/escape'
 require 'riak/failed_request'
+require 'riak/client/search'
 require 'riak/client/http_backend'
 require 'riak/client/net_http_backend'
-require 'riak/client/curb_backend'
 require 'riak/client/excon_backend'
 require 'riak/client/protobuffs_backend'
 require 'riak/client/beefcake_protobuffs_backend'
 require 'riak/bucket'
+require 'riak/stamp'
 
 module Riak
   # A client connection to Riak.
@@ -41,7 +28,7 @@ module Riak
     # Regexp for validating hostnames, lifted from uri.rb in Ruby 1.8.6
     HOST_REGEX = /^(?:(?:(?:[a-zA-Z\d](?:[-a-zA-Z\d]*[a-zA-Z\d])?)\.)*(?:[a-zA-Z](?:[-a-zA-Z\d]*[a-zA-Z\d])?)\.?|\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|\[(?:(?:[a-fA-F\d]{1,4}:)*(?:[a-fA-F\d]{1,4}|\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})|(?:(?:[a-fA-F\d]{1,4}:)*[a-fA-F\d]{1,4})?::(?:(?:[a-fA-F\d]{1,4}:)*(?:[a-fA-F\d]{1,4}|\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}))?)\])$/n
 
-    VALID_OPTIONS = [:protocol, :host, :port, :http_port, :pb_port, :prefix, :client_id, :mapred, :luwak, :http_backend, :protobuffs_backend, :ssl, :basic_auth]
+    VALID_OPTIONS = [:protocol, :host, :port, :http_port, :pb_port, :prefix, :client_id, :mapred, :luwak, :solr, :http_paths, :http_backend, :protobuffs_backend, :ssl, :basic_auth]
 
     # @return [String] The protocol to use for the Riak endpoint
     attr_reader :protocol
@@ -68,15 +55,9 @@ module Riak
     #     from the provided config
     attr_writer :ssl
 
-    # @return [String] The URL path prefix to the "raw" HTTP endpoint
-    attr_accessor :prefix
-
-    # @return [String] The URL path to the map-reduce HTTP endpoint
-    attr_accessor :mapred
-
-    # @return [String] The URL path to the luwak HTTP endpoint
-    attr_accessor :luwak
-
+    # @return [Hash] HTTP path configuration.
+    attr_accessor :http_paths
+    
     # @return [Symbol] The HTTP backend/client to use
     attr_accessor :http_backend
 
@@ -86,7 +67,8 @@ module Riak
     # Creates a client connection to Riak
     # @param [Hash] options configuration options for the client
     # @option options [String] :host ('127.0.0.1') The host or IP address for the Riak endpoint
-    # @option options [Fixnum] :port (8098) The port of the Riak HTTP endpoint
+    # @option options [Fixnum] :http_port (8098) The port of the Riak HTTP endpoint
+    # @option options [Fixnum] :pb_port (8087) The port of the Riak Protocol Buffers endpoint
     # @option options [String] :prefix ('/riak/') The URL path prefix to the main HTTP endpoint
     # @option options [String] :mapred ('/mapred') The path to the map-reduce HTTP endpoint
     # @option options [Fixnum, String] :client_id (rand(MAX_CLIENT_ID)) The internal client ID used by Riak to route responses
@@ -103,9 +85,12 @@ module Riak
       self.http_port          = options[:http_port]          || 8098
       self.pb_port            = options[:pb_port]            || 8087
       self.port               = options[:port]               if options[:port]
-      self.prefix             = options[:prefix]             || "/riak/"
-      self.mapred             = options[:mapred]             || "/mapred"
-      self.luwak              = options[:luwak]              || "/luwak"
+      self.http_paths         = {
+        prefix: options[:prefix] || "/riak/",
+        mapred: options[:mapred] || "/mapred",
+        luwak:  options[:luwak]  || "/luwak",
+        solr:   options[:solr]   || "/solr" # Unused?
+      }.merge(options[:http_paths] || {})
       self.http_backend       = options[:http_backend]       || :NetHTTP
       self.protobuffs_backend = options[:protobuffs_backend] || :Beefcake
       self.basic_auth         = options[:basic_auth]         if options[:basic_auth]
@@ -279,26 +264,18 @@ module Riak
                    end
     end
 
-    # Pings the Riak server to check for liveness.
-    # @return [true,false] whether the Riak server is alive and reachable
-    def ping
-      backend.ping
-    end
-
     # Retrieves a bucket from Riak.
     # @param [String] bucket the bucket to retrieve
     # @param [Hash] options options for retrieving the bucket
-    # @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?
+      unless (options.keys - [:props]).empty?
         raise ArgumentError, "invalid options"
       end
       @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
@@ -308,30 +285,35 @@ module Riak
     #       in development.
     # @return [Array<Bucket>] a list of buckets
     def buckets
+      warn(t('list_buckets', :backtrace => caller.join("\n    "))) unless Riak.disable_list_keys_warnings
       backend.list_buckets.map {|name| Bucket.new(self, name) }
     end
     alias :list_buckets :buckets
 
-    # Stores a large file/IO-like object in Riak via the "Luwak" interface.
-    # @overload store_file(filename, content_type, data)
-    #   Stores the file at the given key/filename
-    #   @param [String] filename the key/filename for the object
-    #   @param [String] content_type the MIME Content-Type for the data
-    #   @param [IO, String] data the contents of the file
-    # @overload store_file(content_type, data)
-    #   Stores the file with a server-determined key/filename
-    #   @param [String] content_type the MIME Content-Type for the data
-    #   @param [String, #read] data the contents of the file
-    # @return [String] the key/filename where the object was stored
-    def store_file(*args)
-      data, content_type, filename = args.reverse
-      if filename
-        http.put(204, luwak, escape(filename), data, {"Content-Type" => content_type})
-        filename
-      else
-        response = http.post(201, luwak, data, {"Content-Type" => content_type})
-        response[:headers]["location"].first.split("/").last
-      end
+    # Deletes a file stored via the "Luwak" interface
+    # @param [String] filename the key/filename to delete
+    def delete_file(filename)
+      http.delete([204,404], http_paths[:luwak], escape(filename))
+      true
+    end
+    
+    # Delete an object. See Bucket#delete
+    def delete_object(bucket, key, options = {})
+      backend.delete_object(bucket, key, options)
+    end
+
+    # Checks whether a file exists in "Luwak".
+    # @param [String] key the key to check
+    # @return [true, false] whether the key exists in "Luwak"
+    def file_exists?(key)
+      result = http.head([200,404], http_paths[:luwak], escape(key))
+      result[:code] == 200
+    end
+    alias :file_exist? :file_exists?
+
+    # Bucket properties. See Bucket#props
+    def get_bucket_props(bucket)
+      backend.get_bucket_props bucket
     end
 
     # Retrieves a large file/IO object from Riak via the "Luwak"
@@ -347,12 +329,12 @@ module Riak
     # @yieldparam [String] chunk a single chunk of the object's data
     def get_file(filename, &block)
       if block_given?
-        http.get(200, luwak, escape(filename), &block)
+        http.get(200, http_paths[:luwak], escape(filename), &block)
         nil
       else
         tmpfile = LuwakFile.new(escape(filename))
         begin
-          response = http.get(200, luwak, escape(filename)) do |chunk|
+          response = http.get(200, http_paths[:luwak], escape(filename)) do |chunk|
             tmpfile.write chunk
           end
           tmpfile.content_type = response[:headers]['content-type'].first
@@ -363,27 +345,117 @@ module Riak
       end
     end
 
-    # Deletes a file stored via the "Luwak" interface
-    # @param [String] filename the key/filename to delete
-    def delete_file(filename)
-      http.delete([204,404], luwak, escape(filename))
-      true
+    # Queries a secondary index on a bucket. See Bucket#get_index
+    def get_index(bucket, index, query)
+      backend.get_index bucket, index, query
     end
-
-    # Checks whether a file exists in "Luwak".
-    # @param [String] key the key to check
-    # @return [true, false] whether the key exists in "Luwak"
-    def file_exists?(key)
-      result = http.head([200,404], luwak, escape(key))
-      result[:code] == 200
+    
+    # Get an object. See Bucket#get
+    def get_object(bucket, key, options = {})
+      backend.fetch_object(bucket, key, options)
     end
-    alias :file_exist? :file_exists?
 
     # @return [String] A representation suitable for IRB and debugging output.
     def inspect
       "#<Riak::Client #{protocol}://#{host}:#{protocol == 'pbc' ? pb_port : http_port}>"
     end
 
+    # Retrieves a list of keys in the given bucket. See Bucket#keys
+    def list_keys(bucket, &block)
+      if block_given?
+        backend.list_keys bucket, &block
+      else
+        backend.list_keys bucket
+      end
+    end
+    
+    # Deprecated accessor for http_paths[:luwak]
+    def luwak
+      http_paths[:luwak]
+    end
+
+    # Deprecated accessor for http_paths[:luwak]
+    def luwak=(luwak)
+      http_paths[:luwak] = luwak
+    end
+
+    # Executes a mapreduce request. See MapReduce#run
+    def mapred(mr, &block)
+      backend.mapred(mr, &block)
+    end
+
+    # Pings the Riak server to check for liveness.
+    # @return [true,false] whether the Riak server is alive and reachable
+    def ping
+      backend.ping
+    end
+    
+    # Deprecated accessor for http_paths[:prefix]
+    def prefix
+      http_paths[:prefix]
+    end
+
+    # Deprecated accessor http_paths[:prefix]
+    def prefix=(prefix)
+      http_paths[:prefix] = prefix
+    end
+
+    # Reloads the object from Riak.
+    def reload_object(object, options = {})
+      backend.reload_object(object, options)
+    end
+    
+    # Deprecated accessor for http_paths[:solr]
+    def solr
+      http_paths[:solr]
+    end
+
+    # Deprecated accessor for http_paths[:solr]
+    def solr=(solr)
+      http_paths[:solr] = solr
+    end
+
+    # Sets the properties on a bucket. See Bucket#props=
+    def set_bucket_props(bucket, properties)
+      backend.set_bucket_props(bucket, properties)
+    end
+    
+    # Exposes a {Stamp} object for use in generating unique
+    # identifiers.
+    # @return [Stamp] an ID generator
+    # @see Stamp#next
+    def stamp
+      @stamp ||= Riak::Stamp.new(self)
+    end
+
+    # Stores a large file/IO-like object in Riak via the "Luwak" interface.
+    # @overload store_file(filename, content_type, data)
+    #   Stores the file at the given key/filename
+    #   @param [String] filename the key/filename for the object
+    #   @param [String] content_type the MIME Content-Type for the data
+    #   @param [IO, String] data the contents of the file
+    # @overload store_file(content_type, data)
+    #   Stores the file with a server-determined key/filename
+    #   @param [String] content_type the MIME Content-Type for the data
+    #   @param [String, #read] data the contents of the file
+    # @return [String] the key/filename where the object was stored
+    def store_file(*args)
+      data, content_type, filename = args.reverse
+      if filename
+        http.put(204, http_paths[:luwak], escape(filename), data, {"Content-Type" => content_type})
+        filename
+      else
+        response = http.post(201, http_paths[:luwak], data, {"Content-Type" => content_type})
+        response[:headers]["location"].first.split("/").last
+      end
+    end
+
+    # Stores an object in Riak.
+    def store_object(object, options = {})
+      params = {:returnbody => true}.merge(options)
+      backend.store_object(object, params)
+    end
+
     private
     def make_client_id
       rand(MAX_CLIENT_ID)