response_bank 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 22412918297172ba47f51811bb250ace6dbb2b3d8eb26405f0f970a18b2479de
+  data.tar.gz: 94022c0b2e796e9a0a8a0fcc47f7f4ba40f64118458695554683d21452009388
+SHA512:
+  metadata.gz: eb15b72956d34a954d829f1ac5666568e5b0c1b4eeebd7a127d8f88b5d103efbd856fe0d4466c675826868a2e8fb8fd572004891753a0bf1799ba3bc04a1cc81
+  data.tar.gz: 86ac266abcbe74dbf7fb72c833def9283fdd5943c0666fc1bf6dbed34008161c3458d85f1d365f7b8d6aacdd4af1a5b8822bc792c33de094668490d6108d4a87

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2008-2019 Tobias Lütke
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,91 @@
+# ResponseBank [![Build Status](https://secure.travis-ci.org/Shopify/response_bank.png)](http://travis-ci.org/Shopify/response_bank)
+
+### Features
+
+* Serve gzip'd content
+* Add ETag and 304 Not Modified headers
+* Generational caching
+* No explicit expiry
+
+### Support
+
+This gem supports the following versions of Ruby and Rails:
+
+* Ruby 2.4.0+
+* Rails 5.0.0+
+
+### Usage
+
+1. include the gem in your Gemfile
+
+```ruby
+gem 'response_bank'
+```
+
+2. use `#response_cache` method to any desired controller's action
+
+```ruby
+class PostsController < ApplicationController
+  def show
+    response_cache do
+      @post = @shop.posts.find(params[:id])
+      respond_with(@post)
+    end
+  end
+end
+```
+
+3. **(optional)** override custom cache key data. For default, cache key is defined by URL and query string
+
+```ruby
+class PostsController < ApplicationController
+  before_action :set_shop
+
+  def index
+    response_cache do
+      @post = @shop.posts
+      respond_with(@post)
+    end
+  end
+
+  def show
+    response_cache do
+      @post = @shop.posts.find(params[:id])
+      respond_with(@post)
+    end
+  end
+
+  def another_action
+    # custom cache key data
+    cache_key = {
+      action: action_name,
+      format: request.format,
+      shop_updated_at: @shop.updated_at
+      # you may add more keys here
+    }
+    response_cache cache_key do
+      @post = @shop.posts.find(params[:id])
+      respond_with(@post)
+    end
+  end
+
+  # override default cache key data globally per class
+  def cache_key_data
+    {
+      action: action_name,
+      format: request.format,
+      params: params.slice(:id),
+      shop_version: @shop.version
+      # you may add more keys here
+     }
+  end
+
+  def set_shop
+    # @shop = ...
+  end
+end
+```
+
+### License
+
+ResponseBank is released under the [MIT License](LICENSE.txt).

data/lib/response_bank.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+require 'response_bank/middleware'
+require 'response_bank/railtie' if defined?(Rails)
+require 'response_bank/response_cache_handler'
+require 'msgpack'
+
+module ResponseBank
+  class << self
+    attr_accessor :cache_store
+    attr_writer :logger
+
+    def log(message)
+      @logger.info("[ResponseBank] #{message}")
+    end
+
+    def acquire_lock(_cache_key)
+      raise NotImplementedError, "Override ResponseBank.acquire_lock in an initializer."
+    end
+
+    def write_to_cache(_key)
+      yield
+    end
+
+    def compress(content)
+      io = StringIO.new
+      gz = Zlib::GzipWriter.new(io)
+      gz.write(content)
+      io.string
+    ensure
+      gz.close
+    end
+
+    def decompress(content)
+      Zlib::GzipReader.new(StringIO.new(content)).read
+    end
+
+    def cache_key_for(data)
+      case data
+      when Hash
+        return data.inspect unless data.key?(:key)
+
+        key = hash_value_str(data[:key])
+
+        return key unless data.key?(:version)
+
+        version = hash_value_str(data[:version])
+
+        [key, version].join(":")
+      when Array
+        data.inspect
+      when Time, DateTime
+        data.to_i
+      when Date
+        data.to_time.to_i
+      when true, false, Integer, Symbol, String
+        data.inspect
+      else
+        data.to_s.inspect
+      end
+    end
+
+    private
+
+    def hash_value_str(data)
+      if data.is_a?(Hash)
+        data.values.join(",")
+      else
+        data.to_s
+      end
+    end
+  end
+end

data/lib/response_bank/controller.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+module ResponseBank
+  module Controller
+    private
+
+    # Only get? and head? requests should be cached.
+    def cacheable_request?
+      (request.get? || request.head?) && (request.params[:cache] != 'false')
+    end
+
+    # Override this method with additional information that changes to invalidate the cache.
+    def cache_version_data
+      {}
+    end
+
+    def cache_key_data
+      { 'request' => { 'env' => request.env.slice('PATH_INFO', 'QUERY_STRING') } }
+    end
+
+    def force_refill_cache?
+      params[:fill_cache] == "true"
+    end
+
+    def serve_unversioned_cacheable_entry?
+      false
+    end
+
+    # If you're okay with serving pages that are not at the newest version, bump this up
+    # to whatever number of seconds you're comfortable with.
+    def cache_age_tolerance_in_seconds
+      0
+    end
+
+    def response_cache(key_data = nil, version_data = nil, &block)
+      cacheable_req = cacheable_request?
+
+      unless cache_configured? && cacheable_req
+        ResponseBank.log("Uncacheable request. cache_configured='#{!!cache_configured?}'" \
+            " cacheable_request='#{cacheable_req}' params_cache='#{request.params[:cache] != 'false'}'")
+        response.headers['Cache-Control'] = 'no-cache, no-store' unless cacheable_req
+        return yield
+      end
+
+      handler = ResponseBank::ResponseCacheHandler.new(
+        key_data: key_data || cache_key_data,
+        version_data: version_data || cache_version_data,
+        env: request.env,
+        cache_age_tolerance: cache_age_tolerance_in_seconds,
+        serve_unversioned: serve_unversioned_cacheable_entry?,
+        force_refill_cache: force_refill_cache?,
+        headers: response.headers,
+        &block
+      )
+
+      status, _headers, body = handler.run!
+
+      return if request.env['cacheable.miss']
+
+      case request.env['cacheable.store']
+      when 'server'
+        render(status: status, plain: body.first)
+      when 'client'
+        head(:not_modified)
+      end
+    end
+  end
+end

data/lib/response_bank/middleware.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+require 'useragent'
+
+module ResponseBank
+  class Middleware
+    REQUESTED_WITH = "HTTP_X_REQUESTED_WITH"
+    ACCEPT = "HTTP_ACCEPT"
+    USER_AGENT = "HTTP_USER_AGENT"
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      env['cacheable.cache'] = false
+      gzip = env['gzip'] = env['HTTP_ACCEPT_ENCODING'].to_s.include?("gzip")
+
+      status, headers, body = @app.call(env)
+
+      if env['cacheable.cache']
+        if [200, 404, 301, 304].include?(status)
+          headers['ETag'] = env['cacheable.key']
+          headers['X-Alternate-Cache-Key'] = env['cacheable.unversioned-key']
+
+          if ie_ajax_request?(env)
+            headers["Expires"] = "-1"
+          end
+        end
+
+        if [200, 404, 301].include?(status) && env['cacheable.miss']
+          # Flatten down the result so that it can be stored to memcached.
+          if body.is_a?(String)
+            body_string = body
+          else
+            body_string = +""
+            body.each { |part| body_string << part }
+          end
+
+          body_gz = ResponseBank.compress(body_string)
+
+          # Store result
+          cache_data = [status, headers['Content-Type'], body_gz, timestamp]
+          cache_data << headers['Location'] if status == 301
+
+          ResponseBank.write_to_cache(env['cacheable.key']) do
+            payload = MessagePack.dump(cache_data)
+            ResponseBank.cache_store.write(env['cacheable.key'], payload, raw: true)
+
+            if env['cacheable.unversioned-key']
+              ResponseBank.cache_store.write(env['cacheable.unversioned-key'], payload, raw: true)
+            end
+          end
+
+          # since we had to generate the gz version above already we may
+          # as well serve it if the client wants it
+          if gzip
+            headers['Content-Encoding'] = "gzip"
+            body = [body_gz]
+          end
+        end
+
+        # Add X-Cache header
+        miss = env['cacheable.miss']
+        x_cache = miss ? 'miss' : 'hit'
+        x_cache += ", #{env['cacheable.store']}" unless miss
+        headers['X-Cache'] = x_cache
+      end
+
+      [status, headers, body]
+    end
+
+    private
+
+    def timestamp
+      Time.now.to_i
+    end
+
+    def ie_ajax_request?(env)
+      return false unless !env[USER_AGENT].nil? && !env[USER_AGENT].empty?
+
+      if env[REQUESTED_WITH] == "XmlHttpRequest" || env[ACCEPT] == "application/json"
+        UserAgent.parse(env["HTTP_USER_AGENT"]).is_a?(UserAgent::Browsers::InternetExplorer)
+      else
+        false
+      end
+    end
+  end
+end

data/lib/response_bank/model_extensions.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module ResponseBank
+  module ModelExtensions
+    def self.included(base)
+      super
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def cache_store
+        ActionController::Base.cache_store
+      end
+    end
+
+    def cache_store
+      ActionController::Base.cache_store
+    end
+  end
+end

data/lib/response_bank/railtie.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+require 'rails'
+require 'response_bank/controller'
+require 'response_bank/model_extensions'
+
+module ResponseBank
+  class Railtie < ::Rails::Railtie
+    initializer "cachable.configure_active_record" do |config|
+      config.middleware.insert_after(Rack::Head, ResponseBank::Middleware)
+
+      ActiveSupport.on_load(:action_controller) do
+        include ResponseBank::Controller
+      end
+
+      ActiveSupport.on_load(:active_record) do
+        include ResponseBank::ModelExtensions
+      end
+    end
+  end
+end

data/lib/response_bank/response_cache_handler.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+require 'digest/md5'
+
+module ResponseBank
+  class ResponseCacheHandler
+    def initialize(
+      key_data:,
+      version_data:,
+      env:,
+      cache_age_tolerance:,
+      serve_unversioned:,
+      headers:,
+      force_refill_cache: false,
+      cache_store: ResponseBank.cache_store,
+      &block
+    )
+      @cache_miss_block = block
+
+      @key_data = key_data
+      @version_data = version_data
+      @env = env
+      @cache_age_tolerance = cache_age_tolerance
+
+      @serve_unversioned = serve_unversioned
+      @force_refill_cache = force_refill_cache
+      @cache_store = cache_store
+      @headers = headers || {}
+    end
+
+    def run!
+      @env['cacheable.cache']           = true
+      @env['cacheable.key']             = versioned_key_hash
+      @env['cacheable.unversioned-key'] = unversioned_key_hash
+
+      ResponseBank.log(cacheable_info_dump)
+
+      if @force_refill_cache
+        refill_cache
+      else
+        try_to_serve_from_cache
+      end
+    end
+
+    def versioned_key_hash
+      @versioned_key_hash ||= key_hash(versioned_key)
+    end
+
+    def unversioned_key_hash
+      @unversioned_key_hash ||= key_hash(unversioned_key)
+    end
+
+    private
+
+    def key_hash(key)
+      "cacheable:#{Digest::MD5.hexdigest(key)}"
+    end
+
+    def versioned_key
+      @versioned_key ||= ResponseBank.cache_key_for(key: @key_data, version: @version_data)
+    end
+
+    def unversioned_key
+      @unversioned_key ||= ResponseBank.cache_key_for(key: @key_data)
+    end
+
+    def cacheable_info_dump
+      log_info = [
+        "Raw cacheable.key: #{versioned_key}",
+        "cacheable.key: #{versioned_key_hash}",
+      ]
+
+      if @env['HTTP_IF_NONE_MATCH']
+        log_info.push("If-None-Match: #{@env['HTTP_IF_NONE_MATCH']}")
+      end
+
+      log_info.join(', ')
+    end
+
+    def try_to_serve_from_cache
+      # Etag
+      response = serve_from_browser_cache(versioned_key_hash)
+
+      return response if response
+
+      # Memcached
+      response = if @serve_unversioned
+        serve_from_cache(unversioned_key_hash, "Cache hit: server (unversioned)")
+      else
+        serve_from_cache(versioned_key_hash, "Cache hit: server")
+      end
+
+      return response if response
+
+      @env['cacheable.locked'] ||= false
+
+      if @env['cacheable.locked'] || ResponseBank.acquire_lock(versioned_key_hash)
+        # execute if we can get the lock
+        @env['cacheable.locked'] = true
+      elsif serving_from_noncurrent_but_recent_version_acceptable?
+        # serve a stale version
+        response = serve_from_cache(unversioned_key_hash, "Cache hit: server (recent)", @cache_age_tolerance)
+
+        return response if response
+      end
+
+      # No cache hit; this request cannot be handled from cache.
+      # Yield to the controller and mark for writing into cache.
+      refill_cache
+    end
+
+    def serving_from_noncurrent_but_recent_version_acceptable?
+      @cache_age_tolerance > 0
+    end
+
+    def serve_from_browser_cache(cache_key_hash)
+      if @env["HTTP_IF_NONE_MATCH"] == cache_key_hash
+        @env['cacheable.miss']  = false
+        @env['cacheable.store'] = 'client'
+
+        @headers.delete('Content-Type')
+        @headers.delete('Content-Length')
+
+        ResponseBank.log("Cache hit: client")
+
+        [304, @headers, []]
+      end
+    end
+
+    def serve_from_cache(cache_key_hash, message, cache_age_tolerance = nil)
+      raw = @cache_store.read(cache_key_hash)
+
+      if raw
+        hit = MessagePack.load(raw)
+
+        @env['cacheable.miss']  = false
+        @env['cacheable.store'] = 'server'
+
+        status, content_type, body, timestamp, location = hit
+
+        if cache_age_tolerance && page_too_old?(timestamp, cache_age_tolerance)
+          ResponseBank.log("Found an unversioned cache entry, but it was too old (#{timestamp})")
+
+          nil
+        else
+          @headers['Content-Type'] = content_type
+
+          @headers['Location'] = location if location
+
+          if @env["gzip"]
+            @headers['Content-Encoding'] = "gzip"
+          else
+            # we have to uncompress because the client doesn't support gzip
+            ResponseBank.log("uncompressing for client without gzip")
+            body = ResponseBank.decompress(body)
+          end
+
+          ResponseBank.log(message)
+
+          [status, @headers, [body]]
+        end
+      end
+    end
+
+    def page_too_old?(timestamp, cache_age_tolerance)
+      !timestamp || timestamp < (Time.now.to_i - cache_age_tolerance)
+    end
+
+    def refill_cache
+      @env['cacheable.miss'] = true
+
+      ResponseBank.log("Refilling cache")
+
+      @cache_miss_block.call
+    end
+  end
+end

data/lib/response_bank/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module ResponseBank
+  VERSION = "1.0.0"
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: response_bank
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Tobias Lütke
+- Burke Libbey
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-01-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: useragent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: msgpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.13.0
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.10.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: tzinfo-data
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2019.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2019.3
+description: 
+email:
+- tobi@shopify.com
+- burke@burkelibbey.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/response_bank.rb
+- lib/response_bank/controller.rb
+- lib/response_bank/middleware.rb
+- lib/response_bank/model_extensions.rb
+- lib/response_bank/railtie.rb
+- lib/response_bank/response_cache_handler.rb
+- lib/response_bank/version.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Simple response caching for Ruby applications
+test_files: []