sequel-unicache 0.9.0

data/lib/sequel/unicache/hook.rb

@@ -0,0 +1,56 @@
+require 'sequel/unicache/write'
+
+module Sequel
+  module Unicache
+    class Hook # Provide after_commit & after_destroy_commit to update cache
+      class << self
+        def install_hooks_for_unicache
+          Sequel::Model.include InstanceMethods
+        end
+      end
+
+      module InstanceMethods
+        def after_commit
+          if Unicache.enabled?
+            Write.expire self
+            @_unicache_previous_values = nil
+          end
+          super
+        end
+
+        def after_rollback
+          @_unicache_previous_values = nil if Unicache.enabled?
+          super
+        end
+
+        def after_destroy_commit
+          if Unicache.enabled?
+            Write.expire self
+            @_unicache_previous_values = nil
+          end
+          super
+        end
+
+        def after_destroy_rollback
+          @_unicache_previous_values = nil if Unicache.enabled?
+          super
+        end
+
+        def before_destroy
+          if Unicache.enabled? && !Write.check_completeness?(self) && primary_key
+            @_unicache_previous_values = self.class.with_pk(pk).values
+          end
+          super
+        end
+
+        def before_update
+          if Unicache.enabled?
+            # Store all previous values, to be expired
+            @_unicache_previous_values = initial_values.merge(@_unicache_previous_values || {})
+          end
+          super
+        end
+      end
+    end
+  end
+end

data/lib/sequel/unicache/logger.rb

@@ -0,0 +1,15 @@
+module Sequel
+  module Unicache
+    class Logger
+      class << self
+        %i[debug info warn error fatal unknown].each do |level|
+          define_method level do |config, message = nil, &block|
+            # config can be treated as a model, then fallback to model class configuration and global configuration
+            config = config.class.unicache_class_configuration if config.is_a? Sequel::Model
+            config.logger.send level, message, &block if config.logger
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/unicache/transaction.rb

@@ -0,0 +1,20 @@
+module Sequel
+  module Unicache
+    class Transaction
+      class << self
+        def install_hooks_for_unicache
+          Sequel::Database.prepend InstanceMethods
+        end
+      end
+
+      module InstanceMethods
+        def _transaction conn, opts = Database::OPTS, &block
+          super conn, opts do |conn|
+            Unicache.suspend_unicache { block.call conn }
+          end
+        end
+        private :_transaction
+      end
+    end
+  end
+end

data/lib/sequel/unicache/version.rb

@@ -0,0 +1,5 @@
+module Sequel
+  module Unicache
+    VERSION = '0.9.0'
+  end
+end

data/lib/sequel/unicache/write.rb

@@ -0,0 +1,122 @@
+require 'sequel/unicache/logger'
+
+module Sequel
+  module Unicache
+    class Write
+      class << self
+        def write model
+          # If model is not completed, don't cache it
+          if (model.columns - model.keys).empty?
+            cache = {}
+            unicache_configurations(model).each_value do |config|
+              continue unless enabled? model, config # if unicached is disabled, do nothing
+              # write cache requires if-condition returns true
+              # otherwise will fallback to expire
+              if permitted? model, config
+                write_for model, config, cache unless suspended? # must be allowed to write cache
+              else
+                expire_for model, config
+              end
+            end
+          end
+        rescue => error
+          Unicache::Logger.fatal model, "[Unicache] Exception happen when write cache for a model, fallback to expire. Reason: #{error.message}. Model: #{model.inspect}"
+          error.backtrace.each do |trace|
+            Unicache::Logger.fatal model, "[Unicache] #{trace}"
+          end
+          expire model
+        end
+
+        def expire model, force: false
+          configs = unicache_configurations model
+          reload model unless check_completeness? model, configs
+          restore_previous model do # restore to previous values temporarily
+            # Unicache must be enabled then do expiration
+            configs.each_value { |config| expire_for model, config if force || enabled?(model, config) }
+          end
+        rescue => error
+          Unicache::Logger.fatal model, "[Unicache] Exception happen when expire cache for a model. Reason: #{error.message}. Model: #{model.inspect}"
+          error.backtrace.each do |trace|
+            Unicache::Logger.fatal model, "[Unicache] #{trace}"
+          end
+        end
+
+        def check_completeness? model, configs = unicache_configurations(model)
+          all_unicache_keys = configs.keys.flatten.uniq
+          model_keys = model.keys
+          all_unicache_keys.all? {|key| model_keys.include? key }
+        end
+
+      private
+
+        def reload model
+          model.reload
+        rescue Sequel::Error => err
+          raise unless err.message == 'Record not found'
+        end
+
+        def write_for model, config, results
+          key = cache_key model, config
+          cache = results[config.serialize]
+          unless cache # if serialize was run before, use the cache
+            cache = config.serialize.(model.values, config)
+            results[config.serialize] = cache
+          end
+          config.cache.set key, cache, config.ttl
+        rescue => error
+          Unicache::Logger.error config, "[Unicache] Exception happen when write cache for unicache_key, fallback to expire. Reason: #{error.message}. Model: #{model.inspect}. Config: #{config.inspect}"
+          error.backtrace.each do |trace|
+            Unicache::Logger.error config, "[Unicache] #{trace}"
+          end
+          expire_for model, config
+        end
+
+        def expire_for model, config
+          key = cache_key model, config
+          config.cache.delete key
+        rescue => error
+          Unicache::Logger.fatal config, "[Unicache] Exception happen when expire cache for unicache_key. Reason: #{error.message}. Model: #{model.inspect}. Config: #{config.inspect}"
+          error.backtrace.each do |trace|
+            Unicache::Logger.fatal config, "[Unicache] #{trace}"
+          end
+        end
+
+        def unicache_configurations model
+          model.class.unicache_configurations
+        end
+
+        def cache_key model, config
+          values = select_keys model, config.unicache_keys
+          config.key.(values, config)
+        end
+
+        def restore_previous model
+          previous_changes = model.instance_variable_get :@_unicache_previous_values
+          unless previous_changes.nil? || previous_changes.empty?
+            origin = select_keys model, previous_changes.keys
+            model.set_all previous_changes
+          end
+          yield
+        ensure
+          model.set_all origin if origin
+        end
+
+        def select_keys model, keys
+          Array(keys).inject({}) { |hash, attr| hash.merge attr => model[attr] }
+        end
+
+        def enabled? model, config
+          model.class.unicache_enabled_for? config
+        end
+
+        def suspended?
+          Unicache.unicache_suspended?
+        end
+
+        def permitted? model, config
+          !config.if || config.if.(model, config)
+        end
+      end
+    end
+  end
+end

data/sequel-unicache.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sequel/unicache/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sequel-unicache"
+  spec.version       = Sequel::Unicache::VERSION
+  spec.authors       = ['Bachue Zhou']
+  spec.email         = ['bachue.shu@gmail.com']
+  spec.summary       = 'Write through and Read through caching library inspired by Cache Money, support Sequel 4'
+  spec.description   = <<-SUMMARY
+Read through caching library inspired by Cache Money, support Sequel 4
+
+Read-Through: Queries by ID or any specified unique key, like `User[params[:id]]` or `User[username: 'bachue@gmail.com']`, will first look in memcache store and then look in the database for the results of that query. If there is a cache miss, it will populate the cache. As objects are created, updated, and deleted, all of the caches are automatically expired.
+  SUMMARY
+  spec.homepage      = 'https://github.com/bachue/sequel-unicache'
+  spec.license       = 'GPLv2'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = spec.files.grep(%r{^spec/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '~> 2.1'
+  spec.add_runtime_dependency 'sequel', '~> 4.0'
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'dalli'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'pry-doc'
+  spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'activesupport'
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,121 @@
+describe Sequel::Unicache::Configuration do
+  before :each do
+    Sequel::Unicache.configure cache: memcache, enabled: true, ttl: 120
+  end
+
+  it 'should configure primary key as unicache' do
+    expect(User.unicache_for(:id)).to be_kind_of Sequel::Unicache::Configuration
+    expect(User.unicache_for(:id).cache).to be memcache
+    expect(User.unicache_for(:id).enabled).to be true
+    expect(User.unicache_for(:id).ttl).to be 120
+    expect(User.unicache_for(:id).model_class).to be User
+    expect(User.unicache_for(:id).unicache_keys).to be :id
+  end
+
+  it 'should let class-level configuration override global-level configuration' do
+    User.instance_exec { unicache :id, ttl: 150 }
+    expect(User.unicache_for(:id).cache).to be memcache
+    expect(User.unicache_for(:id).enabled).to be true
+    expect(User.unicache_for(:id).ttl).to be 150
+    expect(User.unicache_for(:id).model_class).to be User
+    expect(User.unicache_for(:id).unicache_keys).to be :id
+  end
+
+  it 'should configure primary key as unicache even primary key is changed' do
+    User.set_primary_key [:company_name, :department, :employee_id]
+    expect(User.unicache_for(:company_name, :department, :employee_id)).to be_kind_of Sequel::Unicache::Configuration
+    expect(User.unicache_for(:department, :company_name, :employee_id).cache).to be memcache
+    expect(User.unicache_for(:employee_id, :department, :company_name).enabled).to be true
+    expect(User.unicache_for(:department, :employee_id, :company_name).ttl).to be 120
+    expect(User.unicache_for(:company_name, :employee_id, :department).model_class).to be User
+    expect(User.unicache_for(:employee_id, :company_name, :department).unicache_keys).to eq [:company_name, :department, :employee_id]
+  end
+
+  it 'can configure for primary key manually' do
+    condition_proc = ->(model, opts) { model.deleted? }
+    User.instance_exec { unicache :id, enabled: false, if: condition_proc }
+    expect(User.unicache_for(:id)).to be_kind_of Sequel::Unicache::Configuration
+    expect(User.unicache_for(:id).cache).to be memcache
+    expect(User.unicache_for(:id).enabled).to be false
+    expect(User.unicache_for(:id).ttl).to be 120
+    expect(User.unicache_for(:id).if).to be condition_proc
+    expect(User.unicache_for(:id).model_class).to be User
+    expect(User.unicache_for(:id).unicache_keys).to be :id
+  end
+
+  it 'can configure for another unicache' do
+    serialize_proc = ->(values, opts) { JSON.dump values }
+    deserialize_proc = ->(cache, opts) { JSON.load cache }
+    User.instance_exec {
+      unicache :department, :employee_id, :company_name, ttl: 60,
+               serialize: serialize_proc, deserialize: deserialize_proc
+    }
+    expect(User.unicache_for(:company_name, :department, :employee_id)).to be_kind_of Sequel::Unicache::Configuration
+    expect(User.unicache_for(:department, :company_name, :employee_id).cache).to be memcache
+    expect(User.unicache_for(:employee_id, :department, :company_name).enabled).to be true
+    expect(User.unicache_for(:department, :employee_id, :company_name).serialize).to be serialize_proc
+    expect(User.unicache_for(:company_name, :employee_id, :department).deserialize).to be deserialize_proc
+    expect(User.unicache_for(:employee_id, :company_name, :department).model_class).to be User
+    expect(User.unicache_for(:company_name, :department, :employee_id).unicache_keys).to eq [:company_name, :department, :employee_id]
+  end
+
+  it 'can configure key-level, class-level and global level' do
+    condition_proc = ->(model, opts) { model.deleted? }
+    serialize_proc = ->(values, opts) { JSON.dump values }
+    deserialize_proc = ->(cache, opts) { JSON.load cache }
+    User.instance_exec {
+      unicache if: condition_proc, enabled: false
+      unicache :department, :employee_id, :company_name, ttl: 60, enabled: true,
+               serialize: serialize_proc, deserialize: deserialize_proc
+    }
+    expect(User.unicache_for(:id)).to be_kind_of Sequel::Unicache::Configuration
+    expect(User.unicache_for(:id).cache).to be memcache
+    expect(User.unicache_for(:id).enabled).to be false
+    expect(User.unicache_for(:id).if).to be condition_proc
+    expect(User.unicache_for(:id).ttl).to be 120
+    expect(User.unicache_for(:id).model_class).to be User
+    expect(User.unicache_for(:id).unicache_keys).to be :id
+    expect(User.unicache_for(:company_name, :department, :employee_id)).to be_kind_of Sequel::Unicache::Configuration
+    expect(User.unicache_for(:department, :company_name, :employee_id).cache).to be memcache
+    expect(User.unicache_for(:employee_id, :department, :company_name).enabled).to be true
+    expect(User.unicache_for(:employee_id, :department, :company_name).ttl).to be 60
+    expect(User.unicache_for(:department, :employee_id, :company_name).serialize).to be serialize_proc
+    expect(User.unicache_for(:company_name, :employee_id, :department).deserialize).to be deserialize_proc
+    expect(User.unicache_for(:employee_id, :company_name, :department).model_class).to be User
+    expect(User.unicache_for(:company_name, :department, :employee_id).unicache_keys).to eq [:company_name, :department, :employee_id]
+  end
+
+  it 'can enable & disable any unicache key' do
+    User.instance_exec { unicache enabled: false }
+    expect(User.unicache_for(:id).enabled).to be false
+    expect(User.unicache_enabled_for?(:id)).to be false
+    User.unicache_for(:id).enabled = true
+    expect(User.unicache_for(:id).enabled).to be true
+    expect(User.unicache_enabled_for?(:id)).to be true
+  end
+
+  it 'can fuzzy search for unicache keys' do
+    User.instance_exec { unicache :department, :employee_id, :company_name }
+    expect(User.unicache_for(:id, :department)).to be_nil
+    expect(User.unicache_for(:id, :department, fuzzy: true)).to be User.unicache_for(:id)
+    expect(User.unicache_for(:id, :department, :employee_id, :company_name, fuzzy: true)).to be User.unicache_for(:id)
+    User.unicache_for(:id).enabled = false
+    expect(User.unicache_for(:id, :department, fuzzy: true)).to be_nil
+    expect(User.unicache_for(:id, :department, :employee_id, :company_name, fuzzy: true)).to be User.unicache_for(:department, :employee_id, :company_name)
+  end
+
+  it 'should disable unicache key if cache store is not specified' do
+    reset_global_configuration
+    Sequel::Unicache.configure enabled: true, ttl: 120
+    expect(User.unicache_enabled_for?(:id)).to be nil
+    cache = memcache
+    User.instance_exec { unicache :id, cache: cache }
+    expect(User.unicache_enabled_for?(:id)).to be true
+  end
+
+  it 'should always give default value for serialize, deserialize & key' do
+    expect(User.unicache_for(:id).serialize).not_to be_nil
+    expect(User.unicache_for(:id).deserialize).not_to be_nil
+    expect(User.unicache_for(:id).key).not_to be_nil
+  end
+end

data/spec/finder_spec.rb

@@ -0,0 +1,173 @@
+describe Sequel::Unicache::Finder do
+  let!(:user_id) { User.first.id }
+
+  before :each do
+    Sequel::Unicache.configure cache: memcache
+  end
+
+  context '.[]' do
+    context 'simple pk' do
+      it 'should cache' do
+        user = User[user_id]
+        cache = memcache.get "User:id:#{user.id}"
+        expect(cache).not_to be_nil
+        expect(Marshal.load(cache)).to eq user.values
+      end
+
+      it 'should get model from cache' do
+        User.instance_exec { unicache :id, serialize: ->(values, _) { values.to_yaml }, deserialize: ->(values, _) { YAML.load values } }
+        expect(User[10]).to be_nil
+        values = { id: 10, username: 'bachue@emc.com', password: '123456', company_name: 'EMC', department: 'DPC', employee_id: 1000 }
+        memcache.set 'User:id:10', values.to_yaml
+        user = User[10]
+        expect(user).not_to be_nil
+        expect(user.values).to eq values
+      end
+    end
+
+    context 'single unicache key' do
+      before :each do
+        User.instance_exec { unicache :username }
+      end
+
+      it 'should cache' do
+        user = User[username: 'bachue@gmail.com']
+        cache = memcache.get 'User:username:bachue@gmail.com'
+        expect(cache).not_to be_nil
+        expect(Marshal.load(cache)).to eq user.values
+      end
+
+      it 'should get model from cache' do
+        expect(User[username: 'bachue@emc.com']).to be_nil
+        values = { id: 10, username: 'bachue@emc.com', password: '123456', company_name: 'EMC', department: 'DPC', employee_id: 1000 }
+        memcache.set 'User:username:bachue@emc.com', Marshal.dump(values)
+        user = User[username: 'bachue@emc.com']
+        expect(user).not_to be_nil
+        expect(user.values).to eq values
+      end
+    end
+
+    context 'complexed unicache key' do
+      before :each do
+        User.instance_exec { unicache :company_name, :department, :employee_id }
+      end
+
+      it 'should cache' do
+        user = User[company_name: 'EMC', department: 'Mozy', employee_id: 12345]
+        cache = memcache.get 'User:company_name:EMC:department:Mozy:employee_id:12345'
+        expect(cache).not_to be_nil
+        expect(Marshal.load(cache)).to eq user.values
+      end
+
+      it 'should get model from cache' do
+        expect(User[company_name: 'EMC', department: 'DPC:Mozy', employee_id: 1000]).to be_nil
+        values = { id: 10, username: 'bachue@emc.com', password: '123456', company_name: 'EMC', department: 'DPC:Mozy', employee_id: 1000 }
+        memcache.set 'User:company_name:EMC:department:DPC\:Mozy:employee_id:1000', Marshal.dump(values)
+        user = User[company_name: 'EMC', department: 'DPC:Mozy', employee_id: 1000]
+        expect(user).not_to be_nil
+        expect(user.values).to eq values
+      end
+    end
+
+    context 'negative cases' do
+      it 'should only read-through from simple dataset' do
+        User[user_id] # cache primary key
+        expect(User.where(department: 'DPC')[user_id]).to be_nil
+        expect(User.offset(1)[user_id]).to be_nil
+      end
+
+      it 'should not read-through from joined dataset' do
+        user = User[1] # cache primary key
+        ds = User.inner_join :users, {id: :manager_id}, table_alias: 'managers'
+        expect(ds[1].values).not_to eq user.values
+      end
+    end
+  end
+
+  context '.find' do
+    context 'simple pk' do
+      it 'should cache' do
+        user = User.find user_id
+        cache = memcache.get "User:id:#{user.id}"
+        expect(cache).not_to be_nil
+        expect(Marshal.load(cache)).to eq user.values
+      end
+
+      it 'should get model from cache' do
+        User.instance_exec { unicache :id, serialize: ->(values, _) { values.to_yaml }, deserialize: ->(values, _) { YAML.load values } }
+        expect(User.find 10).to be_nil
+        values = { id: 10, username: 'bachue@emc.com', password: '123456', company_name: 'EMC', department: 'DPC', employee_id: 1000 }
+        memcache.set 'User:id:10', values.to_yaml
+        user = User.find 10
+        expect(user).not_to be_nil
+        expect(user.values).to eq values
+      end
+    end
+
+    context 'single unicache key' do
+      before :each do
+        User.instance_exec { unicache :username }
+      end
+
+      it 'should cache' do
+        user = User.find username: 'bachue@gmail.com'
+        cache = memcache.get "User:username:bachue@gmail.com"
+        expect(cache).not_to be_nil
+        expect(Marshal.load(cache)).to eq user.values
+      end
+
+      it 'should get model from cache' do
+        User.instance_exec { unicache :username, serialize: ->(values, _) { values.to_yaml }, deserialize: ->(values, _) { YAML.load values } }
+        expect(User.find(username: 'bachue@emc.com')).to be_nil
+        values = { id: 10, username: 'bachue@emc.com', password: '123456', company_name: 'EMC', department: 'DPC', employee_id: 1000 }
+        memcache.set 'User:username:bachue@emc.com', values.to_yaml
+        user = User.find username: 'bachue@emc.com'
+        expect(user).not_to be_nil
+        expect(user.values).to eq values
+      end
+    end
+
+    context 'complexed unicache key' do
+      before :each do
+        User.instance_exec { unicache :company_name, :department, :employee_id }
+      end
+
+      it 'should cache' do
+        user = User.find company_name: 'EMC', department: 'Mozy', employee_id: 12345
+        cache = memcache.get 'User:company_name:EMC:department:Mozy:employee_id:12345'
+        expect(cache).not_to be_nil
+        expect(Marshal.load(cache)).to eq user.values
+      end
+
+      it 'should get model from cache' do
+        expect(User.find company_name: 'EMC', department: 'DPC:Mozy', employee_id: 1000).to be_nil
+        values = { id: 10, username: 'bachue@emc.com', password: '123456', company_name: 'EMC', department: 'DPC:Mozy', employee_id: 1000 }
+        memcache.set 'User:company_name:EMC:department:DPC\:Mozy:employee_id:1000', Marshal.dump(values)
+        user = User.find company_name: 'EMC', department: 'DPC:Mozy', employee_id: 1000
+        expect(user).not_to be_nil
+        expect(user.values).to eq values
+      end
+    end
+  end
+
+  context 'association' do
+    let!(:user) { User.first }
+
+    it 'should cache associated object' do
+      manager = user.manager
+      cache = memcache.get "User:id:#{manager.id}"
+      expect(cache).not_to be_nil
+      expect(Marshal.load(cache)).to eq manager.values
+    end
+
+    it 'should get model from cache' do
+      expect(user.manager.manager).to be_nil
+      values = { id: 10, username: 'tim@emc.com', password: 'abcdef', company_name: 'EMC', department: 'DPC:Mozy', employee_id: 100 }
+      memcache.set "User:id:10", Marshal.dump(values)
+      user.manager.set manager_id: 10
+      manager = user.manager.manager
+      expect(manager).not_to be_nil
+      expect(manager.values).to eq values
+    end
+  end
+end