legion-cache 0.2.0 → 1.2.0

data/NOTICE.txt

@@ -0,0 +1,9 @@
+Legion::Cache(legion-cache)
+Copyright 2021 Optum
+
+Project Description:
+====================
+A Wrapper class for the LegionIO framework to interface with both Memcached and Redis for caching purposes
+
+Author(s):
+Esity

data/README.md

@@ -1,38 +1,59 @@
-# Legion::Cache
+Legion::Cache
+=====
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/legion/cache`. To experiment with that code, run `bin/console` for an interactive prompt.
+Legion::Cache is a wrapper class to handle requests to the caching tier. It supports both memcached and redis
 
-## Installation
+Supported Ruby versions and implementations
+------------------------------------------------
 
-Add this line to your application's Gemfile:
+Legion::Json should work identically on:
 
-```ruby
-gem 'legion-cache'
-```
-
-And then execute:
-
-    $ bundle install
-
-Or install it yourself as:
-
-    $ gem install legion-cache
+* JRuby 9.2+
+* Ruby 2.4+
 
-## Usage
 
+Installation and Usage
+------------------------
 
+You can verify your installation using this piece of code:
 
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+```bash
+gem install legion-cache
+```
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+```ruby
+require 'legion/cache'
 
-## Contributing
+Legion::Cache.setup
+Legion::Cache.connected? # => true
+Legion::Cache.set('foobar', 'testing', ttl: 10)
+Legion::Cache.get('foobar') # => 'testing'
+sleep(11)
+Legion::Cache.get('foobar') # => nil
 
-Bug reports and pull requests are welcome on GitHub at https://bitbucket.org/legion-io/legion-cache/issues
+```
 
+Settings
+----------
+
+```json
+{
+  "driver": "dalli",
+  "servers": [
+    "127.0.0.1:11211"
+  ],
+  "connected": false,
+  "enabled": true,
+  "namespace": "legion",
+  "compress": false,
+  "cache_nils": false,
+  "pool_size": 10,
+  "timeout": 10,
+  "expires_in": 0
+}
+```
 
-## License
+Authors
+----------
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+* [Matthew Iverson](https://github.com/Esity) - current maintainer

data/SECURITY.md

@@ -0,0 +1,9 @@
+# Security Policy
+
+## Supported Versions
+| Version | Supported          |
+| ------- | ------------------ |
+| 1.x.x   | :white_check_mark: |
+
+## Reporting a Vulnerability
+To be added

data/attribution.txt

@@ -0,0 +1 @@
+Add attributions here.

data/legion-cache.gemspec

@@ -3,40 +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.email         = %w[matthewdiverson@gmail.com ruby@optum.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.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  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/Optum/legion-cache'
+  spec.license       = 'Apache-2.0'
   spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 2.4'
+  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.test_files        = spec.files.select { |p| p =~ %r{^test/.*_test.rb} }
+  spec.extra_rdoc_files  = %w[README.md LICENSE CHANGELOG.md]
+  spec.metadata = {
+    'bug_tracker_uri' => 'https://github.com/Optum/legion-cache/issues',
+    'changelog_uri' => 'https://github.com/Optum/legion-cache/src/main/CHANGELOG.md',
+    'documentation_uri' => 'https://github.com/Optum/legion-cache',
+    'homepage_uri' => 'https://github.com/Optum/LegionIO',
+    'source_code_uri' => 'https://github.com/Optum/legion-cache',
+    'wiki_uri' => 'https://github.com/Optum/legion-cache/wiki'
+  }
 
-  spec.add_development_dependency 'bundler'
-  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'
-
-  spec.add_dependency 'connection_pool'
-  spec.add_dependency 'dalli'
-  spec.add_dependency 'redis'
+  spec.add_dependency 'connection_pool', '>= 2.2.3'
+  spec.add_dependency 'dalli', '>= 2.7'
+  spec.add_dependency 'legion-logging'
+  spec.add_dependency 'legion-settings'
+  spec.add_dependency 'redis', '>= 4.2'
 end

data/lib/legion/cache.rb

@@ -1,19 +1,25 @@
-require_relative 'cache/version'
-require_relative 'cache/settings'
+require 'legion/cache/version'
+require 'legion/cache/settings'
 
-require_relative 'cache/memcached'
-require_relative 'cache/redis'
+require 'legion/cache/memcached'
+require 'legion/cache/redis'
 
 module Legion
   module Cache
     class << self
-      attr_reader :client
-      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'
+        include Legion::Cache::Redis
+      else
+        include Legion::Cache::Memcached
+      end
+
+      def setup(**opts)
+        return Legion::Settings[:cache][:connected] = true if connected?
+
+        return unless client(**Legion::Settings[:cache], **opts)
 
-      def setup
-        connect
-        Legion::Logging.info 'Legion::Cache connected and enabled'
+        @connected = true
+        Legion::Settings[:cache][:connected] = true
       end
 
       def shutdown

data/lib/legion/cache/memcached.rb

@@ -1,47 +1,45 @@
 require 'dalli'
+require 'legion/cache/pool'
 
 module Legion
   module Cache
     module Memcached
-      def connect
-        Legion::Logging.debug 'Using Memcached module for Legion::Cache'
-        options = { compress:  true,
-                    serializer: Legion::JSON,
-                    failover:  Legion::Settings[:cache][:failover],
-                    namespace: Legion::Settings[:cache][:namespace], foo: 'test' }
-        Dalli.logger = Legion::Logging
-        @client = Dalli::Client.new(Legion::Settings[:cache][:servers], options)
-        Legion::Logging.debug "Legion::Cache successfully connected to #{Legion::Settings[:cache][:servers]}"
-        Legion::Settings[:cache][:connected] = true
-      end
+      include Legion::Cache::Pool
+      extend self
 
-      def close
-        @client.close
-      end
+      def client(servers: Legion::Settings[:cache][:servers], **opts)
+        return @client unless @client.nil?
+
+        @pool_size = opts.key?(:pool_size) ? opts[:pool_size] : Legion::Settings[:cache][:pool_size] || 10
+        @timeout = opts.key?(:timeout) ? opts[:timeout] : Legion::Settings[:cache][:timeout] || 5
+
+        Dalli.logger = Legion::Logging
+        @client = ConnectionPool.new(size: pool_size, timeout: timeout) do
+          Dalli::Client.new(servers, Legion::Settings[:cache].merge(opts))
+        end
 
-      def restart
-        close
-        connect
+        @connected = true
+        @client
       end
 
       def get(key)
-        @client.get(key)
+        client.with { |conn| conn.get(key) }
       end
 
       def fetch(key, ttl = nil)
-        @client.fetch(key, ttl)
+        client.with { |conn| conn.fetch(key, ttl) }
       end
 
       def set(key, value, ttl = 180)
-        @client.set(key, value, ttl)
+        client.with { |conn| conn.set(key, value, ttl).positive? }
       end
 
       def delete(key)
-        @client.delete(key)
+        client.with { |conn| conn.delete(key) == true }
       end
 
       def flush(delay = 0)
-        @client.flush(delay)
+        client.with { |conn| conn.flush(delay).first }
       end
     end
   end

data/lib/legion/cache/pool.rb

@@ -0,0 +1,43 @@
+require 'connection_pool'
+
+module Legion
+  module Cache
+    module Pool
+      def connected?
+        @connected ||= false
+      end
+
+      def size
+        client.size
+      end
+
+      def timeout
+        @timeout ||= Legion::Settings[:cache][:timeout] || 5
+      end
+
+      def pool_size
+        @pool_size ||= Legion::Settings[:cache][:pool_size] || 10
+      end
+
+      def available
+        client.available
+      end
+
+      def close
+        client.shutdown(&:close)
+        @client = nil
+        @connected = false
+      end
+
+      def restart(**opts)
+        close
+        @client = nil
+        client_hash = opts
+        client_hash[:pool_size] = opts[:pool_size] if opts.key? :pool_size
+        client_hash[:timeout] = opts[:timeout] if opts.key? :timeout
+        client(**client_hash)
+        @connected = true
+      end
+    end
+  end
+end

data/lib/legion/cache/redis.rb

@@ -1,35 +1,42 @@
 require 'redis'
+require 'legion/cache/pool'
 
 module Legion
   module Cache
     module Redis
-      def connect
-        @client = Redis.new
-      end
+      include Legion::Cache::Pool
+      extend self
 
-      def close
-        @client.close
-      end
+      def client(pool_size: 20, timeout: 5, **)
+        return @client unless @client.nil?
+
+        @pool_size = pool_size
+        @timeout = timeout
 
-      def restart
-        close
-        connect
+        @client = ConnectionPool.new(size: pool_size, timeout: timeout) do
+          ::Redis.new
+        end
+        @connected = true
+        @client
       end
 
       def get(key)
-        @client[key]
+        client.with { |conn| conn.get(key) }
       end
+      alias fetch get
 
-      def set(key, value)
-        @client[key] = value
+      def set(key, value, ttl: nil)
+        args = {}
+        args[:ex] = ttl unless ttl.nil?
+        client.with { |conn| conn.set(key, value, **args) == 'OK' }
       end
 
       def delete(key)
-        @client.del key
+        client.with { |conn| conn.del(key) == 1 }
       end
 
       def flush
-        @client.flushdb
+        client.with { |conn| conn.flushdb == 'OK' }
       end
     end
   end

data/lib/legion/cache/settings.rb

@@ -1,28 +1,37 @@
+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
       def self.default
         {
-          driver:     'dalli',
-          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:  1,
+          pool_size: 10,
+          timeout: 5,
           serializer: Legion::JSON
         }
       end
 
-      def self.driver
-        if Gem::Specification.find_by_name('dalli')
-          'dalli'
-        elsif Gem::Specification.find_by_name('redis')
-          'redis'
+      def self.driver(prefer = 'dalli')
+        secondary = prefer == 'dalli' ? 'redis' : 'dalli'
+        if Gem::Specification.find_all_by_name(prefer).count.positive?
+          prefer
+        elsif Gem::Specification.find_all_by_name(secondary).count.positive?
+          secondary
         else
           raise NameError('Legion::Cache.driver is nil')
         end

data/lib/legion/cache/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Cache
-    VERSION = '0.2.0'
+    VERSION = '1.2.0'
   end
 end

data/sonar-project.properties

@@ -0,0 +1,13 @@
+sonar.projectKey=legion-io_legion-cache
+sonar.organization=legion-io
+sonar.projectName=Legion::Cache
+sonar.sources=.
+sonar.exclusions=vendor/**
+sonar.coverage.exclusions=spec/**
+sonar.cpd.exclusions=spec/**
+sonar.ruby.coverage.reportPath=coverage/.resultset.json
+sonar.ruby.file.suffixes=rb,ruby
+sonar.ruby.coverage.framework=RSpec
+sonar.ruby.rubocopConfig=.rubocop.yml
+sonar.ruby.rubocop.reportPath=rubocop-result.json
+sonar.ruby.rubocop.filePath=.