legion-cache 1.1.1 → 1.3.0

data/legion-cache.gemspec

@@ -3,38 +3,32 @@
 require_relative 'lib/legion/cache/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = 'legion-cache'
+  spec.name = 'legion-cache'
   spec.version       = Legion::Cache::VERSION
   spec.authors       = ['Esity']
   spec.email         = ['matthewdiverson@gmail.com']
 
-  spec.summary       = 'Legion::Cache integration'
-  spec.description   = 'Used to connect Legion with a cache service like memcached'
-  spec.homepage      = 'https://bitbucket.org/legion-io/legion-cache'
-  spec.license       = 'MIT'
-  spec.required_ruby_version = Gem::Requirement.new('>= 2.5.0')
-
-  spec.metadata['homepage_uri'] = spec.homepage
-  spec.metadata['source_code_uri'] = 'https://bitbucket.org/legion-io/legion-cache/src'
-  spec.metadata['changelog_uri'] = 'https://bitbucket.org/legion-io/legion-cache/src/master/CHANGELOG.md'
-  spec.metadata['wiki_uri'] = 'https://bitbucket.org/legion-io/legion-cache/wiki'
-  spec.metadata['bug_tracker_uri'] = 'https://bitbucket.org/legion-io/legion-cache/issues'
-
-  spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  end
+  spec.summary       = 'Wraps both the redis and dalli gems to make a consistent interface for accessing cached objects'
+  spec.description   = 'A Wrapper class for the LegionIO framework to interface with both Memcached and Redis for caching purposes'
+  spec.homepage      = 'https://github.com/LegionIO/legion-cache'
+  spec.license       = 'Apache-2.0'
   spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 3.4'
+  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.extra_rdoc_files = %w[README.md LICENSE CHANGELOG.md]
+  spec.metadata = {
+    'bug_tracker_uri'       => 'https://github.com/LegionIO/legion-cache/issues',
+    'changelog_uri'         => 'https://github.com/LegionIO/legion-cache/blob/main/CHANGELOG.md',
+    'documentation_uri'     => 'https://github.com/LegionIO/legion-cache',
+    'homepage_uri'          => 'https://github.com/LegionIO/LegionIO',
+    'source_code_uri'       => 'https://github.com/LegionIO/legion-cache',
+    'wiki_uri'              => 'https://github.com/LegionIO/legion-cache/wiki',
+    'rubygems_mfa_required' => 'true'
+  }
 
-  spec.add_development_dependency 'bundler', '>= 2'
-  spec.add_development_dependency 'legion-logging'
-  spec.add_development_dependency 'legion-settings'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec'
-  spec.add_development_dependency 'rspec_junit_formatter'
-  spec.add_development_dependency 'rubocop'
-  spec.add_development_dependency 'simplecov', '< 0.18.0'
-
-  spec.add_dependency 'connection_pool', '>= 2.2.3'
-  spec.add_dependency 'dalli', '>= 2.7'
-  spec.add_dependency 'redis', '>= 4.2'
+  spec.add_dependency 'connection_pool', '>= 2.4'
+  spec.add_dependency 'dalli', '>= 3.0'
+  spec.add_dependency 'legion-logging'
+  spec.add_dependency 'legion-settings'
+  spec.add_dependency 'redis', '>= 5.0'
 end

data/lib/legion/cache/local.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'legion/cache/settings'
+
+module Legion
+  module Cache
+    module Local
+      class << self
+        def setup(**)
+          return if @connected
+
+          settings = local_settings
+          return unless settings[:enabled]
+
+          driver_name = settings[:driver] || Legion::Cache::Settings.driver
+          @driver = build_driver(driver_name)
+          @driver.client(**settings, **)
+          @connected = true
+          Legion::Logging.info "Legion::Cache::Local connected (#{driver_name})" if defined?(Legion::Logging)
+        rescue StandardError => e
+          Legion::Logging.warn "Legion::Cache::Local setup failed: #{e.message}" if defined?(Legion::Logging)
+          @connected = false
+        end
+
+        def shutdown
+          return unless @connected
+
+          Legion::Logging.info 'Shutting down Legion::Cache::Local' if defined?(Legion::Logging)
+          @driver&.close
+          @driver = nil
+          @connected = false
+        end
+
+        def connected?
+          @connected == true
+        end
+
+        def get(key)
+          @driver.get(key)
+        end
+
+        def set(key, value, ttl = 180)
+          @driver.set(key, value, ttl)
+        end
+
+        def fetch(key, ttl = nil)
+          @driver.fetch(key, ttl)
+        end
+
+        def delete(key)
+          @driver.delete(key)
+        end
+
+        def flush(delay = 0)
+          @driver.flush(delay)
+        end
+
+        def client
+          @driver&.client
+        end
+
+        def close
+          @driver&.close
+          @connected = false
+        end
+
+        def restart(**opts)
+          settings = local_settings
+          @driver&.restart(**settings.merge(opts))
+          @connected = true
+        end
+
+        def size
+          @driver.size
+        end
+
+        def available
+          @driver.available
+        end
+
+        def pool_size
+          @driver.pool_size
+        end
+
+        def timeout
+          @driver.timeout
+        end
+
+        def reset!
+          @driver = nil
+          @connected = false
+        end
+
+        private
+
+        def build_driver(driver_name)
+          case driver_name
+          when 'redis'
+            require 'legion/cache/redis'
+            Legion::Cache::Redis.dup
+          else
+            require 'legion/cache/memcached'
+            Legion::Cache::Memcached.dup
+          end
+        end
+
+        def local_settings
+          return Legion::Cache::Settings.local unless defined?(Legion::Settings)
+
+          Legion::Settings[:cache_local] || Legion::Cache::Settings.local
+        end
+      end
+    end
+  end
+end

data/lib/legion/cache/memcached.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dalli'
 require 'legion/cache/pool'
 
@@ -5,7 +7,7 @@ module Legion
   module Cache
     module Memcached
       include Legion::Cache::Pool
-      extend self
+      extend self # rubocop:disable Style/ModuleFunction
 
       def client(servers: Legion::Settings[:cache][:servers], **opts)
         return @client unless @client.nil?
@@ -14,8 +16,11 @@ module Legion
         @timeout = opts.key?(:timeout) ? opts[:timeout] : Legion::Settings[:cache][:timeout] || 5
 
         Dalli.logger = Legion::Logging
+        cache_opts = Legion::Settings[:cache].merge(opts)
+        cache_opts[:value_max_bytes] ||= 8 * 1024 * 1024
+
         @client = ConnectionPool.new(size: pool_size, timeout: timeout) do
-          Dalli::Client.new(servers, Legion::Settings[:cache].merge(opts))
+          Dalli::Client.new(servers, cache_opts)
         end
 
         @connected = true
@@ -23,19 +28,27 @@ module Legion
       end
 
       def get(key)
-        client.with { |conn| conn.get(key) }
+        result = client.with { |conn| conn.get(key) }
+        Legion::Logging.debug "[cache] GET #{key} hit=#{!result.nil?}"
+        result
       end
 
       def fetch(key, ttl = nil)
-        client.with { |conn| conn.fetch(key, ttl) }
+        result = client.with { |conn| conn.fetch(key, ttl) }
+        Legion::Logging.debug "[cache] FETCH #{key} hit=#{!result.nil?}"
+        result
       end
 
       def set(key, value, ttl = 180)
-        client.with { |conn| conn.set(key, value, ttl).positive? }
+        result = client.with { |conn| conn.set(key, value, ttl).positive? }
+        Legion::Logging.debug "[cache] SET #{key} ttl=#{ttl} success=#{result} value_class=#{value.class}"
+        result
       end
 
       def delete(key)
-        client.with { |conn| conn.delete(key) == true }
+        result = client.with { |conn| conn.delete(key) == true }
+        Legion::Logging.debug "[cache] DELETE #{key} success=#{result}"
+        result
       end
 
       def flush(delay = 0)

data/lib/legion/cache/pool.rb

@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+
 require 'connection_pool'
 
 module Legion
   module Cache
     module Pool
+      extend self # rubocop:disable Style/ModuleFunction
+
       def connected?
         @connected ||= false
       end

data/lib/legion/cache/redis.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'redis'
 require 'legion/cache/pool'
 
@@ -5,7 +7,7 @@ module Legion
   module Cache
     module Redis
       include Legion::Cache::Pool
-      extend self
+      extend self # rubocop:disable Style/ModuleFunction
 
       def client(pool_size: 20, timeout: 5, **)
         return @client unless @client.nil?

data/lib/legion/cache/settings.rb

@@ -1,30 +1,57 @@
+# frozen_string_literal: true
+
+begin
+  require 'legion/settings'
+rescue StandardError
+  # empty block
+end
+
 module Legion
   module Cache
     module Settings
       Legion::Settings.merge_settings(:cache, default) if Legion::Settings.method_defined? :merge_settings
+      Legion::Settings.merge_settings(:cache_local, local) if Legion::Settings.method_defined? :merge_settings
       def self.default
         {
-          driver: driver,
-          servers: ['127.0.0.1:11211'],
-          connected: false,
-          enabled: true,
-          namespace: 'legion',
-          compress: false,
-          failover: true,
+          driver:     driver,
+          servers:    ['127.0.0.1:11211'],
+          connected:  false,
+          enabled:    true,
+          namespace:  'legion',
+          compress:   false,
+          failover:   true,
+          threadsafe: true,
+          expires_in: 0,
+          cache_nils: false,
+          pool_size:  10,
+          timeout:    5,
+          serializer: Legion::JSON
+        }
+      end
+
+      def self.local
+        {
+          driver:     driver,
+          servers:    ['127.0.0.1:11211'],
+          connected:  false,
+          enabled:    true,
+          namespace:  'legion_local',
+          compress:   false,
+          failover:   true,
           threadsafe: true,
           expires_in: 0,
           cache_nils: false,
-          pool_size: 10,
-          timeout: 5,
+          pool_size:  5,
+          timeout:    3,
           serializer: Legion::JSON
         }
       end
 
       def self.driver(prefer = 'dalli')
         secondary = prefer == 'dalli' ? 'redis' : 'dalli'
-        if Gem::Specification.find_all_by_name(prefer).count.positive?
+        if Gem::Specification.find_all_by_name(prefer).any?
           prefer
-        elsif Gem::Specification.find_all_by_name(secondary).count.positive?
+        elsif Gem::Specification.find_all_by_name(secondary).any?
           secondary
         else
           raise NameError('Legion::Cache.driver is nil')

data/lib/legion/cache/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Cache
-    VERSION = '1.1.1'
+    VERSION = '1.3.0'
   end
 end

data/lib/legion/cache.rb

@@ -1,29 +1,101 @@
-require_relative 'cache/version'
-require_relative 'cache/settings'
+# frozen_string_literal: true
 
-require_relative 'cache/memcached'
-require_relative 'cache/redis'
+require 'legion/cache/version'
+require 'legion/cache/settings'
+
+require 'legion/cache/memcached'
+require 'legion/cache/redis'
+require 'legion/cache/local'
 
 module Legion
   module Cache
-    class << self
-      include Legion::Cache::Memcached if Legion::Settings[:cache][:driver] == 'dalli'
-      include Legion::Cache::Redis if Legion::Settings[:cache][:driver] == 'redis'
+    if Legion::Settings[:cache][:driver] == 'redis'
+      extend Legion::Cache::Redis
+    else
+      extend Legion::Cache::Memcached
+    end
 
-      def setup(**opts)
+    class << self
+      def setup(**)
         return Legion::Settings[:cache][:connected] = true if connected?
 
-        return unless client(**Legion::Settings[:cache], **opts)
-
-        @connected = true
-        Legion::Settings[:cache][:connected] = true
+        setup_local
+        setup_shared(**)
       end
 
       def shutdown
         Legion::Logging.info 'Shutting down Legion::Cache'
-        close
+        close unless @using_local
+        Legion::Cache::Local.shutdown if Legion::Cache::Local.connected?
+        @using_local = false
+        @connected = false
         Legion::Settings[:cache][:connected] = false
       end
+
+      def local
+        Legion::Cache::Local
+      end
+
+      def using_local?
+        @using_local == true
+      end
+
+      def get(key)
+        return Legion::Cache::Local.get(key) if @using_local
+
+        super
+      end
+
+      def set(key, value, ttl = 180)
+        return Legion::Cache::Local.set(key, value, ttl) if @using_local
+
+        super
+      end
+
+      def fetch(key, ttl = nil)
+        return Legion::Cache::Local.fetch(key, ttl) if @using_local
+
+        super
+      end
+
+      def delete(key)
+        return Legion::Cache::Local.delete(key) if @using_local
+
+        super
+      end
+
+      def flush(delay = 0)
+        return Legion::Cache::Local.flush(delay) if @using_local
+
+        super
+      end
+
+      private
+
+      def setup_local
+        return if Legion::Cache::Local.connected?
+
+        Legion::Cache::Local.setup
+      rescue StandardError => e
+        Legion::Logging.warn "Local cache setup failed: #{e.message}" if defined?(Legion::Logging)
+      end
+
+      def setup_shared(**)
+        client(**Legion::Settings[:cache], **)
+        @connected = true
+        @using_local = false
+        Legion::Settings[:cache][:connected] = true
+      rescue StandardError => e
+        Legion::Logging.warn "Shared cache unavailable (#{e.message}), falling back to Local" if defined?(Legion::Logging)
+        if Legion::Cache::Local.connected?
+          @using_local = true
+          @connected = true
+          Legion::Settings[:cache][:connected] = true
+        else
+          @connected = false
+          Legion::Settings[:cache][:connected] = false
+        end
+      end
     end
   end
 end