Max size option

lib/active_support/cache/database_store.rb

@@ -20,8 +20,15 @@ def self.supports_cache_versioning?
 
       # param [Hash] options options
       # option options [Class] :model model class. Default: ActiveSupport::Cache::DatabaseStore::Model
+      # option options [Boolean] :auto_cleanup When true, runs {#cleanup} after every {#write_entry} and {#delete_entry}. Default: false
+      # option options [Integer, nil] :max_size When set (to a positive integer),
+      #    this is the maximum amount of entries that is allowed in the cache.
+      #    Going over will first run {#cleanup} to delete any expired entries.
+      #    If this is not enough, the oldest entry in the cache (based on `created_at` time) will also be deleted. Default: nil
       def initialize(options = nil)
         @model = (options || {}).delete(:model) || Model
+        @auto_cleanup = (options || {}).delete(:auto_cleanup) || false
+        @max_size = (options || {}).delete(:max_size) || nil
         super(options)
       end
 
@@ -74,10 +81,23 @@ def write_entry(key, entry, _options = nil)
         record = @model.where(key: key).first_or_initialize
         expires_at = Time.zone.at(entry.expires_at) if entry.expires_at
         record.update! value: Marshal.dump(entry.value), version: entry.version.presence, expires_at: expires_at
+      ensure
+        cleanup if @auto_cleanup || max_size_exceeded?
+        delete_oldest_entry if max_size_exceeded? # <- Only happens when running cleanup was not enough
+      end
+
+      def max_size_exceeded?
+        @max_size && @model.count > @max_size
+      end
+
+      def delete_oldest_entry
+        @model.order(created_at: :asc).limit(1).destroy_all
       end
 
       def delete_entry(key, _options = nil)
         @model.where(key: key).destroy_all
+      ensure
+        cleanup if @auto_cleanup
       end
 
       def read_multi_entries(names, options)

spec/active_support/cache/database_store_spec.rb

@@ -326,4 +326,132 @@ def obj.cache_key_with_version
       expect(subject.read('foo', version: '1')).to eq('bar')
     end
   end
+
+  describe "auto_cleanup option" do
+    describe "when true" do
+      subject do
+        described_class.new auto_cleanup: true
+      end
+
+      it "cleans up expired entries automatically on write" do
+        time = Time.now
+        expect(subject.count(all: true)).to eq(0)
+
+        subject.write('one', 'foo', expires_in: 1)
+        subject.write('two', 'bar', expires_in: 1)
+        subject.write('three', 'baz', expires_in: 1)
+
+        expect(subject.count(all: true)).to eq(3)
+
+        allow(Time).to receive(:now).and_return(time + 11)
+
+        expect(subject.count(all: true)).to eq(3)
+
+        subject.write('four', 'qux', expires_in: 1)
+
+        expect(subject.count(all: true)).to eq(1)
+        expect(subject.read('four')).to eq('qux')
+      end
+
+      it "cleans up expired entries automatically on delete" do
+        time = Time.now
+        expect(subject.count(all: true)).to eq(0)
+
+        subject.write('one', 'foo', expires_in: 1)
+        subject.write('two', 'bar', expires_in: 1)
+        subject.write('three', 'baz', expires_in: 1)
+
+        expect(subject.count(all: true)).to eq(3)
+
+        allow(Time).to receive(:now).and_return(time + 11)
+
+        expect(subject.count(all: true)).to eq(3)
+
+        subject.delete('three')
+
+        expect(subject.count(all: true)).to eq(0)
+      end
+    end
+
+    describe "when false or not set" do
+      subject do
+        described_class.new auto_cleanup: false
+      end
+
+      it "no cleanup happens on write" do
+        time = Time.now
+        expect(subject.count(all: true)).to eq(0)
+
+        subject.write('one', 'foo', expires_in: 1)
+        subject.write('two', 'bar', expires_in: 1)
+        subject.write('three', 'baz', expires_in: 1)
+
+        expect(subject.count(all: true)).to eq(3)
+
+        allow(Time).to receive(:now).and_return(time + 11)
+
+        expect(subject.count(all: true)).to eq(3)
+
+        subject.write('four', 'qux', expires_in: 1)
+
+        expect(subject.count(all: true)).to eq(4)
+        expect(subject.read('four')).to eq('qux')
+      end
+    end
+
+    it "no cleanup happens on delete" do
+      time = Time.now
+      expect(subject.count(all: true)).to eq(0)
+
+      subject.write('one', 'foo', expires_in: 1)
+      subject.write('two', 'bar', expires_in: 1)
+      subject.write('three', 'baz', expires_in: 1)
+
+      expect(subject.count(all: true)).to eq(3)
+
+      allow(Time).to receive(:now).and_return(time + 11)
+
+      expect(subject.count(all: true)).to eq(3)
+
+      subject.delete('three')
+
+      expect(subject.count(all: true)).to eq(2)
+    end
+  end
+
+  describe "max_size option" do
+    subject do
+      described_class.new max_size: 3
+    end
+
+    it "when set, deletes oldest entry when exceeding" do
+      subject.write('one', 'foo')
+      subject.write('two', 'bar')
+      subject.write('three', 'baz')
+      subject.write('four', 'qux')
+
+      expect(subject.count(all: true)).to eq(3)
+      expect(subject.read('four')).to eq('qux')
+      expect(subject.read('three')).to eq('baz')
+      expect(subject.read('two')).to eq('bar')
+      expect(subject.read('one')).to eq(nil)
+    end
+
+    it "when set, first calls cleanup when exceeding" do
+      time = Time.now
+      expect(subject.count(all: true)).to eq(0)
+
+      subject.write('one', 'foo', expires_in: 1)
+      subject.write('two', 'bar', expires_in: 1)
+      subject.write('three', 'baz', expires_in: 100)
+
+      expect(subject.count(all: true)).to eq(3)
+
+      allow(Time).to receive(:now).and_return(time + 2)
+
+      subject.write('four', 'baz', expires_in: 1)
+
+      expect(subject.count(all: true)).to eq(2)
+    end
+  end
 end