stockpile_cache 1.0.1 → 1.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be776cc6d3422c9cf860af58b463cdbc72dff81c615511484e29e3d646b00ce4
-  data.tar.gz: ae98206437c01ed7b15a92a502450e4c31370822e5a003b74d2d177a0aafb2ee
+  metadata.gz: 20736110c100d25c51d088d39cf3e4cb2f47ca5fdcf96b6c57da63d24cddd3d4
+  data.tar.gz: 0c19227851550c6433b799764ee7624dd36bc3f0f5d9a327e48e352a39237d29
 SHA512:
-  metadata.gz: 6aaf1c67c7593e9788bc595d9a42815e840714c70d63b70f7891e5aeb52a8d018e0b784fd0c2801b33fae3599e93e3874edf6478b1100b88aae31ef00d302547
-  data.tar.gz: a3ce357ee412fb2d01d695a75257b8eb7aac84b1b81a410b0debc80e555ad19ac80504e7c935de741f5a1bba9d97c68fb6faf2ed4afbd8a21f6142bca36dbdf4
+  metadata.gz: b798877e58889a4421d046352c67a8e7af5c73e900cae4d7c25f4e1b23fc5cd172e18815a4b94bf43e7e8d9f175862292a7bdacde04a8d99a62472876e4bbce3
+  data.tar.gz: 036f9031079c8e1ca06052474207d139f6b1373e203f9110278d56e9ff3c9767bba2dc85588ccb700b6624383cca8fc0b135438b45c11adfa51e17e4ac73346b

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 1.3.2
+- Fixing bug where cached content was not read
+
+## 1.3.1
+- Parsing ERB in YAML configs
+- Fill in missing README about cache expiration
+
+## 1.3.0
+- Allowing optional compression of cached content
+
+## 1.2.0
+- Adding support for multiple Redis databases/server
+
+## 1.1.0
+- Allowing expiration of cached value
+
 ## 1.0.1
 - Adding CHANGELOG.md
 - Removing homepage from gemspec as we don't have proper one yet

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    stockpile_cache (1.0.0)
+    stockpile_cache (1.3.2)
       connection_pool
       oj
       rake
@@ -14,13 +14,13 @@ GEM
     connection_pool (2.2.2)
     diff-lcs (1.3)
     jaro_winkler (1.5.3)
-    oj (3.9.1)
+    oj (3.10.6)
     parallel (1.17.0)
     parser (2.6.4.1)
       ast (~> 2.4.0)
     rainbow (3.0.0)
-    rake (12.3.3)
-    redis (4.1.2)
+    rake (13.0.1)
+    redis (4.1.4)
     rspec (3.8.0)
       rspec-core (~> 3.8.0)
       rspec-expectations (~> 3.8.0)
@@ -53,4 +53,4 @@ DEPENDENCIES
   stockpile_cache!
 
 BUNDLED WITH
-   2.0.2
+   2.1.4

data/README.md

@@ -1,7 +1,7 @@
 # Stockpile [![Build Status][ci-image]][ci] [![Code Climate][codeclimate-image]][codeclimate] [![Gem Version][version-image]][version]
 Stockpile is a simple cache written in Ruby backed by Redis. It has built in
 [cache-stampede](https://en.wikipedia.org/wiki/Cache_stampede) (also known as
-dog-piling) protection.
+dog-piling) protection and support for multiple Redis servers.
 
 Can be used with any Ruby or Ruby on Rails project. Can be used as a replacement for
 existing Ruby on Rails cache.
@@ -71,6 +71,7 @@ Following settings are supported:
 | `STOCKPILE_REDIS_URL` | `redis_url` | URL of your Redis server that will be used for caching. Defaults to `redis://localhost:6379/1`. |
 | `STOCKPILE_REDIS_SENTINELS` | `sentinels` | (optional) Comma separated list of Sentinels IPs for Redis. Defaults to `nil`. Example value: `8.8.8.8:42,8.8.4.4:42`. |
 | `STOCKPILE_SLUMBER` | `slumber` | Timeout (in seconds) for stampede protection lock. After timeout passed in code will be executed instead of reading a value from cache. Defaults to `2`. |
+| `STOCKPILE_CONFIGURATION_FILE` | `configuration_file` | (optional) `.yml` configuration file to read connection information from. See [Multiple Database](#multiple-database). |
 
 ## Usage
 To use simply wrap your code into `perform_cached` block:
@@ -81,14 +82,117 @@ Stockpile.perform_cached(key: 'meaning_of_life', ttl: 42) do
 end
 ```
 
-`perform` method accepts 3 named arguments:
+`perform` method accepts 4 named arguments:
 
 | Argument | Meaning |
 | ------------- | ------------- |
 | `key` | Pointer in cache by which a value will be either looked up or stored in cache once code provided in block is executed. |
 | `ttl` | (optional) Time in seconds for which a cached value will be stored. Defaults to 300 seconds (5 minutes). |
+| `db` | (optional) Name of the Redis database to cache value in. Defaults to `:default` |
 | `&block` | Block of code to execute; it's return value will be stored in cache. |
 
+To expire your cache immediately run:
+
+```
+Stockpile.expire_cached(key: 'meaning_of_life')
+```
+
+### Multiple Database
+Stockpile comes with a support for multiple databases. A word of caution: unless
+you have very good reason to run multiple databases within single instance of
+Redis server you probably should avoid doing so as you will not see any performance
+improvements in doing so.
+
+To allow multi-database support you have to do two things. First you have to set
+`configuration_file` setting to point at `.yml` containing your configuration.
+You can do so by either setting a `STOCKPILE_CONFIGURATION_FILE` environment
+variable or by executing a configuration block during runtime (for Rails create
+`config/initializers/stockpile.rb` with following content):
+
+```
+Stockpile.configure do |configuration|
+  configuration.configuration_file = <PATH/TO/FILE>
+end
+```
+
+Second thing to do is to create a `.yml` configuration file. It has to have at
+least one database definition. Providing `sentinels` is optional. Everything
+else is mandatory:
+
+```
+---
+master:
+  url: 'redis://redis-1-host:6379/1'
+  sentinels: '8.8.8.8:42,8.8.4.4:42'
+  pool_options:
+    size: 5
+    timeout: 5
+
+commander:
+  url: 'redis://redis-2-host:6379/1'
+  pool_options:
+    size: 5
+    timeout: 5
+```
+
+To query different databases provide a corresponding `db:` param with
+`perform_cached` method:
+
+```
+Stockpile.perform_cached(db: :master, key: 'meaning_of_life', ttl: 42) do
+  21 + 21
+end
+
+Stockpile.perform_cached(db: :commander, key: 'meaning_of_life', ttl: 21) do
+  21
+end
+```
+
+If you do not provide a `db:` param then a `:default` database will be used; if
+you do not define it in a configuration file your request will error out.
+
+Using `configuration_file` setting will make Stockpile ignore all other
+Redis connection related settings and it will read configuration from `.yml`
+file instead.
+
+### Compression of Cached Content
+Stockpile optionally supports compression of cached content; you will not see
+much benefit from compressing small strings but once you start caching bigger
+payloads like fragments of HTML you could see some improvements by using
+compression. To use compression you will have to use configuration file set by
+`STOCKPILE_CONFIGURATION_FILE`.
+
+To enable compression you have to do two things. First you have to set
+`configuration_file` setting to point at `.yml` containing your configuration.
+You can do so by either setting a `STOCKPILE_CONFIGURATION_FILE` environment
+variable or by executing a configuration block during runtime (for Rails create
+`config/initializers/stockpile.rb` with following content):
+
+```
+Stockpile.configure do |configuration|
+  configuration.configuration_file = <PATH/TO/FILE>
+end
+```
+
+Second thing to do is to create a `.yml` configuration file. It has to have at
+least one database definition. Providing `sentinels` and `compression` is
+optional. Everything else is mandatory:
+
+
+```
+---
+master:
+  url: 'redis://redis-1-host:6379/1'
+  sentinels: '8.8.8.8:42,8.8.4.4:42'
+  compression: true
+  pool_options:
+    size: 5
+    timeout: 5
+```
+
+From that point everything that will be cached in `master` database will be
+compressed.
+
 ## Caveats
 There is no timeout or rescue set for code you will be running through the cache. If
 you need to do either you have to handle it outside of Stockpile.

data/lib/stockpile.rb

@@ -14,14 +14,20 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'base64'
 require 'connection_pool'
 require 'oj'
 require 'redis'
 require 'timeout'
+require 'yaml'
+require 'zlib'
 
 require 'stockpile/constants'
 require 'stockpile/configuration'
-require 'stockpile/redis_connection'
+require 'stockpile/redis_connections_factory'
+require 'stockpile/default_redis_configuration'
+require 'stockpile/yaml_redis_configuration'
+require 'stockpile/redis_connections'
 
 require 'stockpile/lock'
 require 'stockpile/locked_execution_result'
@@ -29,22 +35,24 @@ require 'stockpile/failed_lock_execution'
 
 require 'stockpile/cache'
 require 'stockpile/cached_value_reader'
+require 'stockpile/cached_value_expirer'
 
 require 'stockpile/executor'
 
 # = Stockpile
 #
 # Simple cache with Redis as a backend and a built in cache-stampede
-# protection. For more information on general usage consider consulting
-# README.md file.
+# protection and multiple Redis database support. For more information on
+# general usage consider consulting README.md file.
 #
 # While interacting with the cache from within your application
 # avoid re-using anything after :: notation as it is part of internal API
 # and is subject to an un-announced breaking change.
 #
-# Stockpile provides 5 methods as part of it's public API:
+# Stockpile provides 6 methods as part of it's public API:
 # * configuration
 # * configure
+# * expire_cached
 # * perform_cached
 # * redis
 # * redis_connection_pool
@@ -58,7 +66,9 @@ module Stockpile
     @configuration ||= Configuration.new
   end
 
-  # API to configure cache dynamically during runtime.
+  # API to configure cache dynamically during runtime. Running dynamic
+  # configuration will rebuild connection pools releasing existing
+  # connections.
   #
   # @yield [configuration] Takes in a block of code of code that is setting
   #   or changing configuration values
@@ -69,15 +79,31 @@ module Stockpile
   # @return [void]
   def configure
     yield(configuration)
+    @redis_connections = Stockpile::RedisConnectionsFactory.build_connections
+
     nil
   end
 
+  # Immediatelly expires a cached value for a given key.
+  #
+  # @params key [String] Key to expire
+  # @param db [Symbol] (optional) Which Redis database to expire data from.
+  #   Defaults to `:default`
+  #
+  # @return [true, false] Returns true if value existed in cache and was
+  #   succesfully expired. Returns false if value did not exist in cache.
+  def expire_cached(db: :default, key:)
+    Stockpile::CachedValueExpirer.expire_cached(db: db, key: key)
+  end
+
   # Attempts to fetch a value from cache (for a given key). In case of miss
   # will execute given block of code and cache it's result at the provided
   # key for a specified TTL.
   #
   # @param key [String] Key to use for a value lookup from cache or key
   #   to store value at once it is computed
+  # @param db [Symbol] (optional) Which Redis database to cache data in.
+  #   Defaults to `:default`
   # @param ttl [Integer] (optional) Time in seconds to expire cache after.
   #   Defaults to Stockpile::DEFAULT_TTL
   #
@@ -87,8 +113,13 @@ module Stockpile
   #   Stockpile.perform_cached(key: 'meaning_of_life', ttl: 42) { 21 * 2 }
   #
   # @return Returns a result of block execution
-  def perform_cached(key:, ttl: Stockpile::DEFAULT_TTL, &block)
-    Stockpile::CachedValueReader.read_or_yield(key: key, ttl: ttl, &block)
+  def perform_cached(db: :default, key:, ttl: Stockpile::DEFAULT_TTL, &block)
+    Stockpile::CachedValueReader.read_or_yield(
+      db: db,
+      key: key,
+      ttl: ttl,
+      &block
+    )
   end
 
   # API to communicate with Redis database backing cache up.
@@ -99,8 +130,8 @@ module Stockpile
   #   Store.redis { |r| r.set('meaning_of_life', 42) }
   #
   # @return Returns a result of interaction with Redis
-  def redis
-    redis_connection_pool.with do |connection|
+  def redis(db: :default)
+    redis_connections.with(db: db) do |connection|
       yield connection
     end
   end
@@ -108,8 +139,9 @@ module Stockpile
   # Accessor to connection pool. Defined on top level so it can be memoized
   # on the topmost level
   #
-  # @return [ConnectionPool] ConnectionPool object from connection_pool gem
-  def redis_connection_pool
-    @redis_connection_pool ||= Stockpile::RedisConnection.connection_pool
+  # @return [Stockpile::RedisConnections] RedisConnections object holding all defined
+  #   connection pools
+  def redis_connections
+    @redis_connections ||= Stockpile::RedisConnectionsFactory.build_connections
   end
 end

data/lib/stockpile/cache.rb

@@ -22,21 +22,32 @@ module Stockpile
   module Cache
     module_function
 
-    def get(key:)
-      value_from_cache = Stockpile.redis { |r| r.get(key) }
-      Oj.load(value_from_cache) if value_from_cache
+    def get(db: :default, key:, compress: false)
+      value_from_cache = Stockpile.redis(db: db) { |r| r.get(key) }
+
+      return unless value_from_cache
+
+      if compress && value_from_cache
+        Oj.load(Zlib::Inflate.inflate(Base64.decode64(value_from_cache)))
+      else
+        Oj.load(value_from_cache)
+      end
     end
 
-    def get_deferred(key:)
-      sleep(Stockpile::SLUMBER_COOLDOWN) until Stockpile.redis { |r| r.exists(key) }
-      value_from_cache = Stockpile.redis { |r| r.get(key) }
-      Oj.load(value_from_cache)
+    def get_deferred(db: :default, key:, compress: false)
+      sleep(Stockpile::SLUMBER_COOLDOWN) until Stockpile.redis(db: db) { |r| r.exists(key) }
+
+      get(db: db, key: key, compress: compress)
     end
 
-    def set(key:, payload:, ttl:)
-      payload = Oj.dump(payload)
-      Stockpile.redis { |r| r.set(key, payload) }
-      Stockpile.redis { |r| r.expire(key, ttl) }
+    def set(db: :default, key:, payload:, ttl:, compress: false)
+      payload = if compress
+                  Base64.encode64(Zlib::Deflate.deflate(Oj.dump(payload)))
+                else
+                  Oj.dump(payload)
+                end
+
+      Stockpile.redis(db: db) { |r| r.setex(key, ttl, payload) }
     end
   end
 end

data/lib/stockpile/cached_value_expirer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Copyright 2019 ConvertKit, LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Stockpile
+  # == Stockpile::CachedValueExpirer
+  #
+  # Service class to wrap expiration of of cached value
+  module CachedValueExpirer
+    module_function
+
+    def expire_cached(db: :default, key:)
+      Stockpile.redis(db: db) { |r| r.expire(key, 0) }
+    end
+  end
+end

data/lib/stockpile/cached_value_reader.rb

@@ -22,11 +22,11 @@ module Stockpile
   module CachedValueReader
     module_function
 
-    def read_or_yield(key:, ttl:, &block)
-      if (result = Stockpile::Cache.get(key: key))
+    def read_or_yield(db: :default, key:, ttl:, &block)
+      if (result = Stockpile::Cache.get(db: db, key: key, compress: RedisConnections.compression?(db: db)))
         result
       else
-        Stockpile::Executor.perform(key: key, ttl: ttl, &block)
+        Stockpile::Executor.perform(db: db, key: key, ttl: ttl, &block)
       end
     end
   end

data/lib/stockpile/configuration.rb

@@ -20,20 +20,25 @@ module Stockpile
   # Holds configuration for cache with writeable attributes allowing
   # dynamic change of configuration during runtime
   class Configuration
-    attr_accessor :connection_pool, :connection_timeout, :lock_expiration,
-                  :redis_url, :sentinels, :slumber
+    attr_accessor :configuration_file, :connection_pool, :connection_timeout,
+                  :lock_expiration, :redis_url, :sentinels, :slumber
 
     def initialize
+      @configuration_file = extract_configuration_file
       @connection_pool = extract_connection_pool
       @connection_timeout = extract_connection_timeout
       @lock_expiration = extract_lock_expiration
       @redis_url = extract_redis_url
-      @sentinels = process_sentinels
+      @sentinels = extract_sentinels
       @slumber = extract_slumber
     end
 
     private
 
+    def extract_configuration_file
+      ENV.fetch('STOCKPILE_CONFIGURATION_FILE', nil)
+    end
+
     def extract_connection_pool
       ENV.fetch(
         'STOCKPILE_CONNECTION_POOL',
@@ -69,11 +74,10 @@ module Stockpile
       ).to_i
     end
 
-    def process_sentinels
-      ENV.fetch('STOCKPILE_REDIS_SENTINELS', '').split(',').map do |sentinel|
-        host, port = sentinel.split(':')
-        { host: host, port: port.to_i }
-      end
+    def extract_sentinels
+      Stockpile::RedisConnectionsFactory.process_sentinels(
+        sentinels: ENV.fetch('STOCKPILE_REDIS_SENTINELS', '')
+      )
     end
   end
 end

data/lib/stockpile/constants.rb

@@ -23,5 +23,5 @@ module Stockpile
   DEFAULT_TTL = 60 * 5
   LOCK_PREFIX = 'stockpile_lock::'
   SLUMBER_COOLDOWN = 0.05
-  VERSION = '1.0.1'
+  VERSION = '1.3.2'
 end

data/lib/stockpile/{redis_connection.rb → default_redis_configuration.rb}

@@ -15,27 +15,32 @@
 # limitations under the License.
 
 module Stockpile
-  # == Stockpile::RedisConnection
+  # == Stockpile::DefaultRedisConfiguration
   #
-  # Wrapper around ConnectionPool and Redis to provide connectivity
-  # to Redis with desired configuration and sane connection pool
-  module RedisConnection
+  # Confiuration object for a single Redis database cache setup.
+  # Reads values out of environment, default values or uses
+  # configuration provided during runtime.
+  module DefaultRedisConfiguration
     module_function
 
-    def connection_pool
-      @connection_pool = ConnectionPool.new(connection_pool_options) do
-        Redis.new(connection_options)
-      end
+    def configuration
+      [
+        {
+          db: :default,
+          pool_configuration: pool_configuration,
+          redis_configuration: redis_configuration
+        }
+      ]
     end
 
-    def connection_options
+    def redis_configuration
       {
         url: redis_url,
         sentinels: sentinels
       }.delete_if { |_k, v| v.nil? || v.empty? }
     end
 
-    def connection_pool_options
+    def pool_configuration
       {
         size: pool_size,
         timeout: connection_timeout

data/lib/stockpile/executor.rb

@@ -22,13 +22,14 @@ module Stockpile
   # value to appear in cache instead. Will timeout after given amount of time
   # and will execute block if no value can be read from cache.
   class Executor
-    attr_reader :key, :ttl
+    attr_reader :db, :key, :ttl
 
-    def self.perform(key:, ttl:, &block)
-      new(key, ttl).perform(&block)
+    def self.perform(db: :default, key:, ttl:, &block)
+      new(db, key, ttl).perform(&block)
     end
 
-    def initialize(key, ttl)
+    def initialize(db, key, ttl)
+      @db = db
       @key = key
       @ttl = ttl
     end
@@ -43,17 +44,23 @@ module Stockpile
 
     private
 
+    def compress?
+      RedisConnections.compression?(db: db)
+    end
+
     def execution
-      @execution ||= Stockpile::Lock.perform_locked(lock_key: lock_key) do
+      @execution ||= Stockpile::Lock.perform_locked(db: db, lock_key: lock_key) do
         yield
       end
     end
 
     def cache_and_release_execution
       Stockpile::Cache.set(
+        db: db,
         key: key,
         payload: execution.result,
-        ttl: ttl
+        ttl: ttl,
+        compress: compress?
       )
 
       execution.release_lock
@@ -66,7 +73,7 @@ module Stockpile
 
     def wait_for_cache_or_yield
       Timeout.timeout(Stockpile.configuration.slumber) do
-        Stockpile::Cache.get_deferred(key: key)
+        Stockpile::Cache.get_deferred(db: db, key: key, compress: compress?)
       end
     rescue Timeout::Error
       yield

data/lib/stockpile/lock.rb

@@ -23,13 +23,14 @@ module Stockpile
   # Stockpile::LockedExcutionResult will hold Stockpile::FailedLockExecution
   # as a result of execution
   class Lock
-    attr_reader :lock_key
+    attr_reader :db, :lock_key
 
-    def self.perform_locked(lock_key:, &block)
-      new(lock_key).perform_locked(&block)
+    def self.perform_locked(db: :default, lock_key:, &block)
+      new(db, lock_key).perform_locked(&block)
     end
 
-    def initialize(lock_key)
+    def initialize(db, lock_key)
+      @db = db
       @lock_key = lock_key
     end
 
@@ -44,7 +45,7 @@ module Stockpile
     private
 
     def failed_execution
-      Stockpile::LockedExcutionResult.new(result: failed_lock, lock_key: lock_key)
+      Stockpile::LockedExcutionResult.new(db: db, result: failed_lock, lock_key: lock_key)
     end
 
     def failed_lock
@@ -52,11 +53,11 @@ module Stockpile
     end
 
     def lock
-      Stockpile.redis { |r| r.set(lock_key, 1, nx: true, ex: Stockpile.configuration.lock_expiration) }
+      Stockpile.redis(db: db) { |r| r.set(lock_key, 1, nx: true, ex: Stockpile.configuration.lock_expiration) }
     end
 
     def successful_execution
-      Stockpile::LockedExcutionResult.new(result: yield, lock_key: lock_key)
+      Stockpile::LockedExcutionResult.new(db: db, result: yield, lock_key: lock_key)
     end
   end
 end

data/lib/stockpile/locked_execution_result.rb

@@ -19,15 +19,16 @@ module Stockpile
   #
   # Wrapper containing result of locked execution
   class LockedExcutionResult
-    attr_reader :lock_key, :result
+    attr_reader :db, :lock_key, :result
 
-    def initialize(lock_key:, result:)
+    def initialize(db: :default, lock_key:, result:)
+      @db = db
       @lock_key = lock_key
       @result = result
     end
 
     def release_lock
-      Stockpile.redis { |r| r.expire(lock_key, 0) }
+      Stockpile.redis(db: db) { |r| r.expire(lock_key, 0) }
     end
 
     def success?

data/lib/stockpile/redis_connections.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Copyright 2019 ConvertKit, LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Stockpile
+  # == Stockpile::RedisConnections
+  #
+  # Wrapper around pools of Redis connections to allow multiple
+  # Redis database support
+  module RedisConnections
+    module_function
+
+    def compression?(db:)
+      instance_variable_get("@#{db}_compression".to_sym)
+    end
+
+    def with(db:)
+      instance_variable_get("@#{db}".to_sym).with do |connection|
+        yield connection
+      end
+    end
+  end
+end

data/lib/stockpile/redis_connections_factory.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# Copyright 2019 ConvertKit, LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Stockpile
+  # == Stockpile::RedisConnectionsFactory
+  #
+  # Builds out connection pools out of provided configuration. Configurations
+  # are built with `*RedisConfiguration` classes. Providing a `.yml` file will
+  # override everything else and use that to build a config.
+  module RedisConnectionsFactory
+    module_function
+
+    def build_connections
+      configuration.each do |database|
+        pool = ConnectionPool.new(database[:pool_configuration]) do
+          Redis.new(database[:redis_configuration])
+        end
+
+        RedisConnections.instance_variable_set("@#{database[:db]}".to_sym, pool)
+        RedisConnections.instance_variable_set("@#{database[:db]}_compression".to_sym, database[:compression])
+      end
+
+      RedisConnections
+    end
+
+    def configuration
+      if Stockpile.configuration.configuration_file
+        Stockpile::YamlRedisConfiguration.configuration
+      else
+        Stockpile::DefaultRedisConfiguration.configuration
+      end
+    end
+
+    def process_sentinels(sentinels:)
+      sentinels.split(',').map do |sentinel|
+        host, port = sentinel.split(':')
+        { host: host, port: port.to_i }
+      end
+    end
+  end
+end

data/lib/stockpile/yaml_redis_configuration.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# Copyright 2019 ConvertKit, LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Stockpile
+  # == Stockpile::YamlRedisConfiguration
+  #
+  # Confiuration object a multiple Redis database cache setup. Reads
+  # configuration out of provided `.yml` file.
+  module YamlRedisConfiguration
+    module_function
+
+    def configuration
+      parsed_configuration.map do |database, settings|
+        {
+          db: database,
+          pool_configuration: extract_pool(settings: settings),
+          redis_configuration: extract_redis(settings: settings),
+          compression: extract_compression(settings: settings)
+        }
+      end
+    end
+
+    def extract_compression(settings:)
+      return true if settings['compression'].eql?(true)
+
+      false
+    end
+
+    def extract_redis(settings:)
+      sentinels = Stockpile::RedisConnectionsFactory.process_sentinels(
+        sentinels: settings['sentinels'] || ''
+      )
+
+      {
+        url: settings['url'],
+        sentinels: sentinels
+      }.delete_if { |_k, v| v.nil? || v.empty? }
+    end
+
+    def extract_pool(settings:)
+      {
+        size: settings.dig('pool_options', 'size'),
+        timeout: settings.dig('pool_options', 'timeout')
+      }
+    end
+
+    def parsed_configuration
+      YAML.safe_load(
+        ERB.new(
+          raw_configuration
+        ).result
+      )
+    end
+
+    def raw_configuration
+      File.open(Stockpile.configuration.configuration_file).read
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stockpile_cache
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.3.2
 platform: ruby
 authors:
 - ConvertKit, LLC
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-12 00:00:00.000000000 Z
+date: 2020-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: connection_pool
@@ -89,14 +89,18 @@ files:
 - bin/setup
 - lib/stockpile.rb
 - lib/stockpile/cache.rb
+- lib/stockpile/cached_value_expirer.rb
 - lib/stockpile/cached_value_reader.rb
 - lib/stockpile/configuration.rb
 - lib/stockpile/constants.rb
+- lib/stockpile/default_redis_configuration.rb
 - lib/stockpile/executor.rb
 - lib/stockpile/failed_lock_execution.rb
 - lib/stockpile/lock.rb
 - lib/stockpile/locked_execution_result.rb
-- lib/stockpile/redis_connection.rb
+- lib/stockpile/redis_connections.rb
+- lib/stockpile/redis_connections_factory.rb
+- lib/stockpile/yaml_redis_configuration.rb
 - lib/stockpile_cache.rb
 - stockpile-cache.gemspec
 homepage: