riak-client 0.9.8 → 1.0.0.beta

data/.gitignore

@@ -0,0 +1,32 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage/**/*
+rdoc/**/*
+pkg/**/*
+
+## PROJECT::SPECIFIC
+doc
+.yardoc
+.bundle
+spec/support/test_server.yml
+Gemfile.lock
+**/bin
+*.rbc
+.rvmrc
+
+.ripplenode
+.riaktest

data/Gemfile

@@ -1,25 +1,31 @@
 source :rubygems
 
-gem 'i18n'
-gem 'builder'
-gem 'rspec', "~>2.4.0"
-gem 'fakeweb', ">=1.2"
-gem 'rack', '>=1.0'
-gem 'rake'
+gemspec
 gem 'bundler'
-gem 'excon', "~>0.6.1"
-gem 'beefcake', '~>0.3.1'
+gem 'guard-rspec'
+gem 'rb-fsevent'
+gem 'growl'
 
 platforms :mri do
-  gem 'curb', '>=0.6'
   gem 'yajl-ruby'
 end
 
 platforms :jruby do
-  gem 'json'
   gem 'jruby-openssl'
 end
 
 group :integration do
-  gem 'activesupport', '~>3.0'
+  if ENV['RAILS31']
+    gem 'activesupport', '~> 3.1.0'
+  else
+    gem 'activesupport', '~> 3.0.10'
+  end
+end
+
+platforms :mri_18, :jruby do
+  gem 'ruby-debug'
+end
+
+platforms :mri_19 do
+  gem 'ruby-debug19'
 end

data/Guardfile

@@ -0,0 +1,14 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+gemset = ENV['RVM_GEMSET'] || 'ripple'
+gemset = "@#{gemset}" unless gemset.to_s == ''
+
+rvms = %w[ 1.8.7 1.9.2 jruby ].map do |version|
+  "#{version}@#{gemset}"
+end
+
+guard 'rspec', :cli => '--profile --tag "~slow"', :rvm => rvms do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec/riak" }
+end

data/Rakefile

@@ -1,50 +1,22 @@
 require 'rubygems'
-require 'rake/gempackagetask'
-
-gemspec = Gem::Specification.new do |gem|
-  gem.name = "riak-client"
-  gem.summary = %Q{riak-client is a rich client for Riak, the distributed database by Basho.}
-  gem.description = %Q{riak-client is a rich client for Riak, the distributed database by Basho. It supports the full HTTP interface including storage operations, bucket configuration, link-walking and map-reduce.}
-  gem.version = File.read('../VERSION').strip
-  gem.email = "sean@basho.com"
-  gem.homepage = "http://seancribbs.github.com/ripple"
-  gem.authors = ["Sean Cribbs"]
-  gem.add_development_dependency "rspec", "~>2.4.0"
-  gem.add_development_dependency "fakeweb", ">=1.2"
-  gem.add_development_dependency "rack", ">=1.0"
-  gem.add_development_dependency "curb", ">=0.6"
-  gem.add_development_dependency "excon", "~>0.5.7"
-  gem.add_dependency "i18n", ">=0.4.0"
-  gem.add_dependency "builder", "~>2.1.2"
-  gem.add_dependency "beefcake", "=0.3.2"
-
-  files = FileList["**/*"]
-  # Editor and O/S files
-  files.exclude ".DS_Store", "*~", /#/, "*.swp", "*.tmproj", "tmtags"
-  # Generated artifacts
-  files.exclude "coverage/*", "rdoc/*", "pkg/*", "doc/*", ".bundle", "*.rbc", ".rvmrc", ".watchr", ".rspec"
-  # Project-specific
-  files.exclude "Gemfile.lock", %r{spec/support/test_server.yml$}, "bin"
-  # Remove directories
-  files.exclude {|d| File.directory?(d) }
-
-  gem.files = files.to_a
+require 'rubygems/package_task'
+require 'rspec/core'
+require 'rspec/core/rake_task'
 
-  gem.test_files = gem.files.grep(/spec\/.*_spec\.rb$/)
+def gemspec
+  $riakclient_gemspec ||= Gem::Specification.load("riak-client.gemspec")
 end
 
-# Gem packaging tasks
-Rake::GemPackageTask.new(gemspec) do |pkg|
+Gem::PackageTask.new(gemspec) do |pkg|
   pkg.need_zip = false
   pkg.need_tar = false
 end
 
 task :gem => :gemspec
 
-desc %{Build the gemspec file.}
+desc %{Validate the gemspec file.}
 task :gemspec do
   gemspec.validate
-  File.open("#{gemspec.name}.gemspec", 'w'){|f| f.write gemspec.to_ruby }
 end
 
 desc %{Release the gem to RubyGems.org}
@@ -52,24 +24,26 @@ task :release => :gem do
   system "gem push pkg/#{gemspec.name}-#{gemspec.version}.gem"
 end
 
-require 'rspec/core'
-require 'rspec/core/rake_task'
-
 desc "Run Unit Specs Only"
 RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = "spec/riak/**/*_spec.rb"
+  spec.rspec_opts = %w[--profile --tag ~integration]
 end
 
 namespace :spec do
-  desc "Run Integration Specs Only"
+  desc "Run Integration Specs Only (without explicitly slow specs)"
   RSpec::Core::RakeTask.new(:integration) do |spec|
-    spec.pattern = "spec/integration/**/*_spec.rb"
+    spec.rspec_opts = %w[--profile --tag '~slow' --tag integration]
   end
 
-  desc "Run All Specs"
+  desc "Run All Specs (without explicitly slow specs)"
   RSpec::Core::RakeTask.new(:all) do |spec|
-    spec.pattern = "spec/**/*_spec.rb"
+    spec.rspec_opts = %w[--profile --tag '~slow']
   end
 end
 
-task :default => :spec
+desc "Run All Specs (including slow specs)"
+RSpec::Core::RakeTask.new(:ci) do |spec|
+  spec.rspec_opts = %w[--profile]
+end
+
+task :default => :ci

data/erl_src/riak_kv_test_backend.erl

@@ -1,8 +1,8 @@
 %% -------------------------------------------------------------------
 %%
-%% riak_kv_test_backend: storage engine based on ETS tables
+%% riak_memory_backend: storage engine using ETS tables
 %%
-%% Copyright (c) 2007-2010 Basho Technologies, Inc.  All Rights Reserved.
+%% Copyright (c) 2007-2011 Basho Technologies, Inc.  All Rights Reserved.
 %%
 %% This file is provided to you under the Apache License,
 %% Version 2.0 (the "License"); you may not use this file
@@ -20,170 +20,503 @@
 %%
 %% -------------------------------------------------------------------
 
-% @doc riak_kv_test_backend is a Riak storage backend using ets that
-%      exposes a reset function for efficiently clearing stored data.
+%% @doc riak_kv_memory_backend is a Riak storage backend that uses ets
+%% tables to store all data in memory.
+%%
+%% === Configuration Options ===
+%%
+%% The following configuration options are available for the memory backend.
+%% The options should be specified in the `memory_backend' section of your
+%% app.config file.
+%%
+%% <ul>
+%% <li>`ttl' - The time in seconds that an object should live before being expired.</li>
+%% <li>`max_memory' - The amount of memory in megabytes to limit the backend to.</li>
+%% </ul>
+%%
 
 -module(riak_kv_test_backend).
 -behavior(riak_kv_backend).
--behavior(gen_server).
+
+%% KV Backend API
+-export([api_version/0,
+         start/2,
+         stop/1,
+         get/3,
+         put/5,
+         delete/4,
+         drop/1,
+         fold_buckets/4,
+         fold_keys/4,
+         fold_objects/4,
+         is_empty/1,
+         status/1,
+         callback/3,
+         reset/0]).
+
 -ifdef(TEST).
 -include_lib("eunit/include/eunit.hrl").
 -endif.
--export([start/2,stop/1,get/2,put/3,list/1,list_bucket/2,delete/2,
-         is_empty/1, drop/1, fold/3, callback/3, reset/0]).
 
--export([init/1, handle_call/3, handle_cast/2, handle_info/2,
-         terminate/2, code_change/3]).
+-define(API_VERSION, 1).
+-define(CAPABILITIES, [async_fold]).
+
+-record(state, {data_ref :: integer() | atom(),
+                time_ref :: integer() | atom(),
+                max_memory :: undefined | integer(),
+                used_memory=0 :: integer(),
+                ttl :: integer()}).
 
+-type state() :: #state{}.
+-type config() :: [].
 
-% @type state() = term().
--record(state, {t, p}).
+%% ===================================================================
+%% Public API
+%% ===================================================================
 
-% @spec start(Partition :: integer(), Config :: proplist()) ->
-%                        {ok, state()} | {{error, Reason :: term()}, state()}
-start(Partition, _Config) ->
-    gen_server:start_link(?MODULE, [Partition], []).
+%% TestServer reset
 
-% @spec reset() -> ok | {error, timeout}
+-spec reset() -> ok | {error, timeout}.
 reset() ->
-    Pids = lists:foldl(fun(Item, Acc) ->
-                               case lists:prefix("test_backend", atom_to_list(Item)) of
-                                   true -> [whereis(Item)|Acc];
-                                   _ -> Acc
-                               end
-                       end, [], registered()),
-    [gen_server:cast(Pid,{reset, self()})|| Pid <- Pids],
-    receive_reset(Pids).
-
-receive_reset([]) -> ok;
-receive_reset(Pids) ->
-    receive
-        {reset, Pid} ->
-            receive_reset(lists:delete(Pid, Pids))
-    after 1000 ->
-            {error, timeout}
-    end.
+    {ok, Ring} = riak_core_ring_manager:get_my_ring(),
+    [ ets:delete_all_objects(list_to_atom("kv" ++ integer_to_list(P))) ||
+        P <- riak_core_ring:my_indices(Ring) ],
+    ok.
 
-%% @private
-init([Partition]) ->
-    PName = list_to_atom("test_backend" ++ integer_to_list(Partition)),
-    P = list_to_atom(integer_to_list(Partition)),
-    register(PName, self()),
-    {ok, #state{t=ets:new(P,[]), p=P}}.
+%% KV Backend API
 
-%% @private
-handle_cast({reset,From}, State) ->
-    ets:delete_all_objects(State#state.t),
-    From ! {reset, self()},
-    {noreply, State};
-handle_cast(_, State) -> {noreply, State}.
+%% @doc Return the major version of the
+%% current API and a capabilities list.
+-spec api_version() -> {integer(), [atom()]}.
+api_version() ->
+    {?API_VERSION, ?CAPABILITIES}.
 
-%% @private
-handle_call(stop,_From,State) -> {reply, srv_stop(State), State};
-handle_call({get,BKey},_From,State) -> {reply, srv_get(State,BKey), State};
-handle_call({put,BKey,Val},_From,State) ->
-    {reply, srv_put(State,BKey,Val),State};
-handle_call({delete,BKey},_From,State) -> {reply, srv_delete(State,BKey),State};
-handle_call(list,_From,State) -> {reply, srv_list(State), State};
-handle_call({list_bucket,Bucket},_From,State) ->
-    {reply, srv_list_bucket(State, Bucket), State};
-handle_call(is_empty, _From, State) ->
-    {reply, ets:info(State#state.t, size) =:= 0, State};
-handle_call(drop, _From, State) ->
-    ets:delete(State#state.t),
-    {reply, ok, State};
-handle_call({fold, Fun0, Acc}, _From, State) ->
-    Fun = fun({{B,K}, V}, AccIn) -> Fun0({B,K}, V, AccIn) end,
-    Reply = ets:foldl(Fun, Acc, State#state.t),
-    {reply, Reply, State}.
-
-% @spec stop(state()) -> ok | {error, Reason :: term()}
-stop(SrvRef) -> gen_server:call(SrvRef,stop).
-srv_stop(State) ->
-    true = ets:delete(State#state.t),
+%% @doc Start the memory backend
+-spec start(integer(), config()) -> {ok, state()}.
+start(Partition, Config) ->
+    TTL = config_value(ttl, Config),
+    MemoryMB = config_value(max_memory, Config),
+    case MemoryMB of
+        undefined ->
+            MaxMemory = undefined,
+            TimeRef = undefined;
+        _ ->
+            MaxMemory = MemoryMB * 1024 * 1024,
+            TimeRef = ets:new(list_to_atom(integer_to_list(Partition)), [ordered_set])
+    end,
+    DataRef = ets:new(list_to_atom("kv" ++ integer_to_list(Partition)), [named_table, public]),
+    {ok, #state{data_ref=DataRef,
+                max_memory=MaxMemory,
+                time_ref=TimeRef,
+                ttl=TTL}}.
+
+%% @doc Stop the memory backend
+-spec stop(state()) -> ok.
+stop(#state{data_ref=DataRef,
+            max_memory=MaxMemory,
+            time_ref=TimeRef}) ->
+    catch ets:delete(DataRef),
+    case MaxMemory of
+        undefined ->
+            ok;
+        _ ->
+            catch ets:delete(TimeRef)
+    end,
     ok.
 
-% get(state(), riak_object:bkey()) ->
-%   {ok, Val :: binary()} | {error, Reason :: term()}
-% key must be 160b
-get(SrvRef, BKey) -> gen_server:call(SrvRef,{get,BKey}).
-srv_get(State, BKey) ->
-    case ets:lookup(State#state.t,BKey) of
-        [] -> {error, notfound};
-        [{BKey,Val}] -> {ok, Val};
-        Err -> {error, Err}
+%% @doc Retrieve an object from the memory backend
+-spec get(riak_object:bucket(), riak_object:key(), state()) ->
+                 {ok, any(), state()} |
+                 {ok, not_found, state()} |
+                 {error, term(), state()}.
+get(Bucket, Key, State=#state{data_ref=DataRef,
+                              ttl=TTL}) ->
+    case ets:lookup(DataRef, {Bucket, Key}) of
+        [] -> {error, not_found, State};
+        [{{Bucket, Key}, {{ts, Timestamp}, Val}}] ->
+            case exceeds_ttl(Timestamp, TTL) of
+                true ->
+                    delete(Bucket, Key, undefined, State),
+                    {error, not_found, State};
+                false ->
+                    {ok, Val, State}
+            end;
+        [{{Bucket, Key}, Val}] ->
+            {ok, Val, State};
+        Error ->
+            {error, Error, State}
     end.
 
-% put(state(), riak_object:bkey(), Val :: binary()) ->
-%   ok | {error, Reason :: term()}
-% key must be 160b
-put(SrvRef, BKey, Val) -> gen_server:call(SrvRef,{put,BKey,Val}).
-srv_put(State,BKey,Val) ->
-    true = ets:insert(State#state.t, {BKey,Val}),
-    ok.
+%% @doc Insert an object into the memory backend.
+%% NOTE: The memory backend does not currently
+%% support secondary indexing and the _IndexSpecs
+%% parameter is ignored.
+-type index_spec() :: {add, Index, SecondaryKey} | {remove, Index, SecondaryKey}.
+-spec put(riak_object:bucket(), riak_object:key(), [index_spec()], binary(), state()) ->
+                 {ok, state()} |
+                 {error, term(), state()}.
+put(Bucket, PrimaryKey, _IndexSpecs, Val, State=#state{data_ref=DataRef,
+                                                       max_memory=MaxMemory,
+                                                       time_ref=TimeRef,
+                                                       ttl=TTL,
+                                                       used_memory=UsedMemory}) ->
+    Now = now(),
+    case TTL of
+        undefined ->
+            Val1 = Val;
+        _ ->
+            Val1 = {{ts, Now}, Val}
+    end,
+    case do_put(Bucket, PrimaryKey, Val1, DataRef) of
+        {ok, Size} ->
+            %% If the memory is capped update timestamp table
+            %% and check if the memory usage is over the cap.
+            case MaxMemory of
+                undefined ->
+                    UsedMemory1 = UsedMemory;
+                _ ->
+                    time_entry(Bucket, PrimaryKey, Now, TimeRef),
+                    Freed = trim_data_table(MaxMemory,
+                                            UsedMemory + Size,
+                                            DataRef,
+                                            TimeRef,
+                                            0),
+                    UsedMemory1 = UsedMemory + Size - Freed
+            end,
+            {ok, State#state{used_memory=UsedMemory1}};
+        {error, Reason} ->
+            {error, Reason, State}
+    end.
 
-% delete(state(), riak_object:bkey()) ->
-%   ok | {error, Reason :: term()}
-% key must be 160b
-delete(SrvRef, BKey) -> gen_server:call(SrvRef,{delete,BKey}).
-srv_delete(State, BKey) ->
-    true = ets:delete(State#state.t, BKey),
-    ok.
+%% @doc Delete an object from the memory backend
+%% NOTE: The memory backend does not currently
+%% support secondary indexing and the _IndexSpecs
+%% parameter is ignored.
+-spec delete(riak_object:bucket(), riak_object:key(), [index_spec()], state()) ->
+                    {ok, state()}.
+delete(Bucket, Key, _IndexSpecs, State=#state{data_ref=DataRef,
+                                              time_ref=TimeRef,
+                                              used_memory=UsedMemory}) ->
+    case TimeRef of
+        undefined ->
+            UsedMemory1 = UsedMemory;
+        _ ->
+            %% Lookup the object so we can delete its
+            %% entry from the time table and account
+            %% for the memory used.
+            [Object] = ets:lookup(DataRef, {Bucket, Key}),
+            case Object of
+                {_, {{ts, Timestamp}, _}} ->
+                    ets:delete(TimeRef, Timestamp),
+                    UsedMemory1 = UsedMemory - object_size(Object);
+                _ ->
+                    UsedMemory1 = UsedMemory
+            end
+    end,
+    ets:delete(DataRef, {Bucket, Key}),
+    {ok, State#state{used_memory=UsedMemory1}}.
 
-% list(state()) -> [riak_object:bkey()]
-list(SrvRef) -> gen_server:call(SrvRef,list).
-srv_list(State) ->
-    MList = ets:match(State#state.t,{'$1','_'}),
-    list(MList,[]).
-list([],Acc) -> Acc;
-list([[K]|Rest],Acc) -> list(Rest,[K|Acc]).
-
-% list_bucket(term(), Bucket :: riak_object:bucket()) -> [Key :: binary()]
-list_bucket(SrvRef, Bucket) ->
-    gen_server:call(SrvRef,{list_bucket, Bucket}).
-srv_list_bucket(State, {filter, Bucket, Fun}) ->
-    MList = lists:filter(Fun, ets:match(State#state.t,{{Bucket,'$1'},'_'})),
-    list(MList,[]);
-srv_list_bucket(State, Bucket) ->
-    case Bucket of
-        '_' -> MatchSpec = {{'$1','_'},'_'};
-        _ -> MatchSpec = {{Bucket,'$1'},'_'}
+%% @doc Fold over all the buckets.
+-spec fold_buckets(riak_kv_backend:fold_buckets_fun(),
+                   any(),
+                   [],
+                   state()) -> {ok, any()}.
+fold_buckets(FoldBucketsFun, Acc, Opts, #state{data_ref=DataRef}) ->
+    FoldFun = fold_buckets_fun(FoldBucketsFun),
+    case lists:member(async_fold, Opts) of
+        true ->
+            BucketFolder =
+                fun() ->
+                        {Acc0, _} = ets:foldl(FoldFun, {Acc, sets:new()}, DataRef),
+                        Acc0
+                end,
+            {async, BucketFolder};
+        false ->
+            {Acc0, _} = ets:foldl(FoldFun, {Acc, sets:new()}, DataRef),
+            {ok, Acc0}
+    end.
+
+%% @doc Fold over all the keys for one or all buckets.
+-spec fold_keys(riak_kv_backend:fold_keys_fun(),
+                any(),
+                [{atom(), term()}],
+                state()) -> {ok, term()} | {async, fun()}.
+fold_keys(FoldKeysFun, Acc, Opts, #state{data_ref=DataRef}) ->
+    Bucket =  proplists:get_value(bucket, Opts),
+    FoldFun = fold_keys_fun(FoldKeysFun, Bucket),
+    case lists:member(async_fold, Opts) of
+        true ->
+            {async, get_folder(FoldFun, Acc, DataRef)};
+        false ->
+            Acc0 = ets:foldl(FoldFun, Acc, DataRef),
+            {ok, Acc0}
+    end.
+
+%% @doc Fold over all the objects for one or all buckets.
+-spec fold_objects(riak_kv_backend:fold_objects_fun(),
+                   any(),
+                   [{atom(), term()}],
+                   state()) -> {ok, any()} | {async, fun()}.
+fold_objects(FoldObjectsFun, Acc, Opts, #state{data_ref=DataRef}) ->
+    Bucket =  proplists:get_value(bucket, Opts),
+    FoldFun = fold_objects_fun(FoldObjectsFun, Bucket),
+    case lists:member(async_fold, Opts) of
+        true ->
+            {async, get_folder(FoldFun, Acc, DataRef)};
+        false ->
+            Acc0 = ets:foldl(FoldFun, Acc, DataRef),
+            {ok, Acc0}
+    end.
+
+%% @doc Delete all objects from this memory backend
+-spec drop(state()) -> {ok, state()}.
+drop(State=#state{data_ref=DataRef,
+                  time_ref=TimeRef}) ->
+    ets:delete_all_objects(DataRef),
+    case TimeRef of
+        undefined ->
+            ok;
+        _ ->
+            ets:delete_all_objects(TimeRef)
     end,
-    MList = ets:match(State#state.t,MatchSpec),
-    list(MList,[]).
+    {ok, State}.
+
+%% @doc Returns true if this memory backend contains any
+%% non-tombstone values; otherwise returns false.
+-spec is_empty(state()) -> boolean().
+is_empty(#state{data_ref=DataRef}) ->
+    ets:info(DataRef, size) =:= 0.
 
-is_empty(SrvRef) -> gen_server:call(SrvRef, is_empty).
+%% @doc Get the status information for this memory backend
+-spec status(state()) -> [{atom(), term()}].
+status(#state{data_ref=DataRef,
+              time_ref=TimeRef}) ->
+    DataStatus = ets:info(DataRef),
+    case TimeRef of
+        undefined ->
+            [{data_table_status, DataStatus}];
+        _ ->
+            TimeStatus = ets:info(TimeRef),
+            [{data_table_status, DataStatus},
+             {time_table_status, TimeStatus}]
+    end.
 
-drop(SrvRef) -> gen_server:call(SrvRef, drop).
+%% @doc Register an asynchronous callback
+-spec callback(reference(), any(), state()) -> {ok, state()}.
+callback(_Ref, _Msg, State) ->
+    {ok, State}.
 
-fold(SrvRef, Fun, Acc0) -> gen_server:call(SrvRef, {fold, Fun, Acc0}, infinity).
+%% ===================================================================
+%% Internal functions
+%% ===================================================================
 
-%% Ignore callbacks for other backends so multi backend works
-callback(_State, _Ref, _Msg) ->
-    ok.
+%% @TODO Some of these implementations may be suboptimal.
+%% Need to do some measuring and testing to refine the
+%% implementations.
 
 %% @private
-handle_info(_Msg, State) -> {noreply, State}.
+%% Return a function to fold over the buckets on this backend
+fold_buckets_fun(FoldBucketsFun) ->
+    fun({{Bucket, _}, _}, {Acc, BucketSet}) ->
+            case sets:is_element(Bucket, BucketSet) of
+                true ->
+                    {Acc, BucketSet};
+                false ->
+                    {FoldBucketsFun(Bucket, Acc),
+                     sets:add_element(Bucket, BucketSet)}
+            end
+    end.
 
 %% @private
-terminate(_Reason, _State) -> ok.
+%% Return a function to fold over keys on this backend
+fold_keys_fun(FoldKeysFun, undefined) ->
+    fun({{Bucket, Key}, _}, Acc) ->
+            FoldKeysFun(Bucket, Key, Acc)
+    end;
+fold_keys_fun(FoldKeysFun, Bucket) ->
+    fun({{B, Key}, _}, Acc) ->
+            case B =:= Bucket of
+                true ->
+                    FoldKeysFun(Bucket, Key, Acc);
+                false ->
+                    Acc
+            end
+    end.
 
 %% @private
-code_change(_OldVsn, State, _Extra) -> {ok, State}.
+%% Return a function to fold over keys on this backend
+fold_objects_fun(FoldObjectsFun, undefined) ->
+    fun({{Bucket, Key}, Value}, Acc) ->
+            FoldObjectsFun(Bucket, Key, Value, Acc)
+    end;
+fold_objects_fun(FoldObjectsFun, Bucket) ->
+    fun({{B, Key}, Value}, Acc) ->
+            case B =:= Bucket of
+                true ->
+                    FoldObjectsFun(Bucket, Key, Value, Acc);
+                false ->
+                    Acc
+            end
+    end.
+
+%% @private
+get_folder(FoldFun, Acc, DataRef) ->
+    fun() ->
+            ets:foldl(FoldFun, Acc, DataRef)
+    end.
+
+%% @private
+do_put(Bucket, Key, Val, Ref) ->
+    Object = {{Bucket, Key}, Val},
+    true = ets:insert(Ref, Object),
+    {ok, object_size(Object)}.
+
+%% @private
+config_value(Key, Config) ->
+    config_value(Key, Config, undefined).
+
+%% @private
+config_value(Key, Config, Default) ->
+    case proplists:get_value(Key, Config) of
+        undefined ->
+            app_helper:get_env(memory_backend, Key, Default);
+        Value ->
+            Value
+    end.
+
+%% Check if this timestamp is past the ttl setting.
+exceeds_ttl(Timestamp, TTL) ->
+    Diff = (timer:now_diff(now(), Timestamp) / 1000 / 1000),
+    Diff > TTL.
+
+%% @private
+time_entry(Bucket, Key, Now, TimeRef) ->
+    ets:insert(TimeRef, {Now, {Bucket, Key}}).
+
+%% @private
+%% @doc Dump some entries if the max memory size has
+%% been breached.
+trim_data_table(MaxMemory, UsedMemory, _, _, Freed) when
+      (UsedMemory - Freed) =< MaxMemory ->
+    Freed;
+trim_data_table(MaxMemory, UsedMemory, DataRef, TimeRef, Freed) ->
+    %% Delete the oldest object
+    OldestSize = delete_oldest(DataRef, TimeRef),
+    trim_data_table(MaxMemory,
+                    UsedMemory,
+                    DataRef,
+                    TimeRef,
+                    Freed + OldestSize).
+
+%% @private
+delete_oldest(DataRef, TimeRef) ->
+    OldestTime = ets:first(TimeRef),
+    case OldestTime of
+        '$end_of_table' ->
+            0;
+        _ ->
+            OldestKey = ets:lookup_element(TimeRef, OldestTime, 2),
+            ets:delete(TimeRef, OldestTime),
+            case ets:lookup(DataRef, OldestKey) of
+                [] ->
+                    delete_oldest(DataRef, TimeRef);
+                [Object] ->
+                    ets:delete(DataRef, OldestKey),
+                    object_size(Object)
+            end
+    end.
+
+%% @private
+object_size(Object) ->
+    case Object of
+        {{Bucket, Key}, {{ts, _}, Val}} ->
+            ok;
+        {{Bucket, Key}, Val} ->
+            ok
+    end,
+    size(Bucket) + size(Key) + size(Val).
+
+%% ===================================================================
+%% EUnit tests
+%% ===================================================================
 
-%%
-%% Test
-%%
 -ifdef(TEST).
 
-% @private
-simple_test() ->
+simple_test_() ->
     riak_kv_backend:standard_test(?MODULE, []).
 
--ifdef(EQC).
+ttl_test_() ->
+    Config = [{ttl, 15}],
+    {ok, State} = start(42, Config),
+
+    Bucket = <<"Bucket">>,
+    Key = <<"Key">>,
+    Value = <<"Value">>,
+
+    [
+     %% Put an object
+     ?_assertEqual({ok, State}, put(Bucket, Key, [], Value, State)),
+     %% Wait 1 second to access it
+     ?_assertEqual(ok, timer:sleep(1000)),
+     ?_assertEqual({ok, Value, State}, get(Bucket, Key, State)),
+     %% Wait 3 seconds and access it again
+     ?_assertEqual(ok, timer:sleep(3000)),
+     ?_assertEqual({ok, Value, State}, get(Bucket, Key, State)),
+     %% Wait 15 seconds and it should expire
+     {timeout, 30000, ?_assertEqual(ok, timer:sleep(15000))},
+     %% This time it should be gone
+     ?_assertEqual({error, not_found, State}, get(Bucket, Key, State))
+    ].
+
 %% @private
-eqc_test() ->
-    ?assertEqual(true, backend_eqc:test(?MODULE, true)).
+max_memory_test_() ->
+    %% Set max size to 1.5kb
+    Config = [{max_memory, 1.5 * (1 / 1024)}],
+    {ok, State} = start(42, Config),
+
+    Bucket = <<"Bucket">>,
+    Key1 = <<"Key1">>,
+    Value1 = list_to_binary(string:copies("1", 1024)),
+    Key2 = <<"Key2">>,
+    Value2 = list_to_binary(string:copies("2", 1024)),
+
+    %% Write Key1 to the datastore
+    {ok, State1} = put(Bucket, Key1, [], Value1, State),
+    timer:sleep(timer:seconds(1)),
+    %% Write Key2 to the datastore
+    {ok, State2} = put(Bucket, Key2, [], Value2, State1),
+
+    [
+     %% Key1 should be kicked out
+     ?_assertEqual({error, not_found, State2}, get(Bucket, Key1, State2)),
+     %% Key2 should still be present
+     ?_assertEqual({ok, Value2, State2}, get(Bucket, Key2, State2))
+    ].
+
+-ifdef(EQC).
+
+eqc_test_() ->
+    {spawn,
+     [{inorder,
+       [{setup,
+         fun setup/0,
+         fun cleanup/1,
+         [
+          {timeout, 60000,
+           [?_assertEqual(true,
+                         backend_eqc:test(?MODULE, true))]}
+        ]}]}]}.
+
+setup() ->
+    application:load(sasl),
+    application:set_env(sasl, sasl_error_logger, {file, "riak_kv_memory_backend_eqc_sasl.log"}),
+    error_logger:tty(false),
+    error_logger:logfile({open, "riak_kv_memory_backend_eqc.log"}),
+    ok.
+
+cleanup(_) ->
+    ok.
 
 -endif. % EQC
+
 -endif. % TEST