vinted-memcached_store 2.3.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a6675c19521b317f6a5a3915a39b7d8ff82efed1f12cbffc5d97ec86f2348e0a
+  data.tar.gz: 542e1943df8e5c95a1127b91c2823e490a0a9058a8ae7f9231a04c1209f80588
+SHA512:
+  metadata.gz: d3bb0bf65bf86f5269761b9bcfb0adebc1c20aaf896e093f44c8f25a65b9481196299508c7c2fedead98b8a7a1d434b957062f748f0450a222db1dc099be1447
+  data.tar.gz: 3a4695a77dea72f8b3fa9db8f9353b30c47ee1ed3c7e6ba247ac1842b8810670bd9ef27c1aeecd759ed33998def06cd23b8bdd3d928f859657a46ed40d8c4af1

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013-2016 Shopify Inc.
+
+MIT License
+
+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,60 @@
+# ActiveSupport MemcachedStore
+
+This gem includes two memcached stores.
+
+### MemcachedStore
+
+ActiveSupport memcached store. This wraps the memcached gem into a ActiveSupport::Cache::Store, so it could be used inside Rails.
+
+### MemcachedSnappyStore
+
+ActiveSupport cache store that adds snappy compression at the cost of making the `incr, decr` operations unavailable.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```
+gem 'memcached_store'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install memcached_store
+```
+
+## Usage
+
+In your environment file:
+
+```ruby
+# for memcached store
+config.cache_store = :memcached_store,
+
+# for snappy store
+config.cache_store = :memcached_snappy_store,
+  Memcached.new(['memcached1.foo.com', 'memcached2.foo.com'])
+```
+
+## Benchmarks
+
+For benchmarks please refer to https://github.com/basecamp/memcached_bench.
+
+## Code status
+
+[![Build Status](https://travis-ci.org/Shopify/memcached_store.svg?branch=master)](https://travis-ci.org/Shopify/memcached_store)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/lib/active_support/cache/memcached_snappy_store.rb

@@ -0,0 +1,45 @@
+begin
+  require 'snappy'
+rescue LoadError => e
+  $stderr.puts "You don't have snappy installed in your application. Please add `gem \"snappy\"` to your Gemfile and run bundle install"
+  raise e
+end
+
+require 'active_support/cache/memcached_store'
+
+module ActiveSupport
+  module Cache
+    class MemcachedSnappyStore < MemcachedStore
+      class UnsupportedOperation < StandardError; end
+
+      module SnappyCompressor
+        def self.compress(source)
+          Snappy.deflate(source)
+        end
+
+        def self.decompress(source)
+          Snappy.inflate(source)
+        end
+      end
+
+      def increment(*)
+        raise UnsupportedOperation, "increment is not supported by: #{self.class.name}"
+      end
+
+      def decrement(*)
+        raise UnsupportedOperation, "decrement is not supported by: #{self.class.name}"
+      end
+
+      # IdentityCache has its own handling for read only.
+      def read_only
+        false
+      end
+
+      def initialize(*addresses, **options)
+        options[:codec] ||= ActiveSupport::Cache::MemcachedStore::Codec.new(compressor: SnappyCompressor)
+        options[:compress] = false
+        super(*addresses, **options)
+      end
+    end
+  end
+end

data/lib/active_support/cache/memcached_store.rb

@@ -0,0 +1,392 @@
+# file havily based out off https://github.com/rails/rails/blob/3-2-stable/activesupport/lib/active_support/cache/mem_cache_store.rb
+require 'digest/md5'
+require 'delegate'
+
+module ActiveSupport
+  module Cache
+    # A cache store implementation which stores data in Memcached:
+    # http://memcached.org/
+    #
+    # MemcachedStore uses memcached gem as backend to connect to Memcached server.
+    #
+    # MemcachedStore implements the Strategy::LocalCache strategy which implements
+    # an in-memory cache inside of a block.
+    class MemcachedStore < Store
+      ESCAPE_KEY_CHARS = /[\x00-\x20%\x7F-\xFF]/n
+
+      class Codec
+        # use dalli compatible flags
+        SERIALIZED_FLAG = 0x1
+        COMPRESSED_FLAG = 0x2
+
+        # Older versions of this gem would use 0 for the flags whether or not
+        # the value was marshal dumped. By setting this flag, we can tell if
+        # it were set with an older version for backwards compatible decoding.
+        RAW_FLAG = 0x10
+
+        def initialize(serializer: Marshal, compressor: nil)
+          @serializer = serializer
+          @compressor = compressor
+        end
+
+        def encode(_key, value, flags)
+          unless value.is_a?(String)
+            flags |= SERIALIZED_FLAG
+            value = @serializer.dump(value)
+          end
+          if @compressor
+            flags |= COMPRESSED_FLAG
+            value = @compressor.compress(value)
+          end
+          flags |= RAW_FLAG if flags == 0
+          [value, flags]
+        end
+
+        def decode(_key, value, flags)
+          if (flags & COMPRESSED_FLAG) != 0
+            value = @compressor.decompress(value)
+          end
+
+          if (flags & SERIALIZED_FLAG) != 0
+            @serializer.load(value)
+          elsif flags == 0 # legacy cache value
+            @serializer.load(value) rescue value
+          else
+            value
+          end
+        end
+      end
+
+      attr_accessor :read_only, :swallow_exceptions
+
+      prepend(Strategy::LocalCache)
+
+      def initialize(*addresses, **options)
+        addresses = addresses.flatten
+        options[:codec] ||= Codec.new
+        @swallow_exceptions = true
+        @swallow_exceptions = options.delete(:swallow_exceptions) if options.key?(:swallow_exceptions)
+
+        if options.key?(:coder)
+          raise ArgumentError, "ActiveSupport::Cache::MemcachedStore doesn't support custom coders"
+        end
+
+        # We don't use a coder, so we set it to nil so Active Support don't think we're using
+        # a deprecated one.
+        super(options.merge(coder: nil))
+
+        if addresses.first.is_a?(Memcached)
+          @connection = addresses.first
+          raise "Memcached::Rails is no longer supported, "\
+                "use a Memcached instance instead" if @connection.is_a?(Memcached::Rails)
+        else
+          mem_cache_options = options.dup
+          servers = mem_cache_options.delete(:servers)
+          UNIVERSAL_OPTIONS.each { |name| mem_cache_options.delete(name) }
+          @connection = Memcached.new([*addresses, *servers], mem_cache_options)
+        end
+      end
+
+      def append(name, value, options = nil)
+        return true if read_only
+        options = merged_options(options)
+        normalized_key = normalize_key(name, options)
+
+        handle_exceptions(return_value_on_error: nil, on_miss: false, miss_exceptions: [Memcached::NotStored]) do
+          instrument(:append, name) do
+            @connection.append(normalized_key, value)
+          end
+          true
+        end
+      end
+
+      def write(*)
+        return true if read_only
+        super
+      end
+
+      def delete(*)
+        return true if read_only
+        super
+      end
+
+      def read_multi(*names)
+        options = names.extract_options!
+        return {} if names.empty?
+
+        options = merged_options(options)
+        keys_to_names = Hash[names.map { |name| [normalize_key(name, options), name] }]
+        values = {}
+
+        handle_exceptions(return_value_on_error: {}) do
+          instrument(:read_multi, names, options) do
+            if raw_values = @connection.get(keys_to_names.keys)
+              raw_values.each do |key, value|
+                entry = deserialize_entry(value)
+                values[keys_to_names[key]] = entry.value unless entry.expired?
+              end
+            end
+          end
+          values
+        end
+      end
+
+      def cas(name, options = nil)
+        options = merged_options(options)
+        key = normalize_key(name, options)
+        payload = nil
+
+        success = handle_exceptions(return_value_on_error: false) do
+          instrument(:cas, name, options) do
+            @connection.cas(key, expiration(options)) do |raw_value|
+              entry = deserialize_entry(raw_value)
+              value = yield entry.value
+              break true if read_only
+              payload = serialize_entry(Entry.new(value, **options), options)
+            end
+          end
+          true
+        end
+
+        if success
+          local_cache.write_entry(key, payload) if local_cache
+        else
+          local_cache.delete_entry(key) if local_cache
+        end
+
+        success
+      end
+
+      def cas_multi(*names, **options)
+        return if names.empty?
+
+        options = merged_options(options)
+        keys_to_names = Hash[names.map { |name| [normalize_key(name, options), name] }]
+
+        sent_payloads = nil
+
+        handle_exceptions(return_value_on_error: false) do
+          instrument(:cas_multi, names, options) do
+            written_payloads = @connection.cas(keys_to_names.keys, expiration(options)) do |raw_values|
+              values = {}
+
+              raw_values.each do |key, raw_value|
+                entry = deserialize_entry(raw_value)
+                values[keys_to_names[key]] = entry.value unless entry.expired?
+              end
+
+              values = yield values
+
+              break true if read_only
+
+              serialized_values = values.map do |name, value|
+                [normalize_key(name, options), serialize_entry(Entry.new(value, **options), options)]
+              end
+
+              sent_payloads = Hash[serialized_values]
+            end
+
+            if local_cache && sent_payloads
+              sent_payloads.each_key do |key|
+                if written_payloads.key?(key)
+                  local_cache.write_entry(key, written_payloads[key])
+                else
+                  local_cache.delete_entry(key)
+                end
+              end
+            end
+
+            true
+          end
+        end
+      end
+
+      def increment(name, amount = 1, options = nil) # :nodoc:
+        options = merged_options(options)
+        handle_exceptions(return_value_on_error: nil) do
+          instrument(:increment, name, amount: amount) do
+            @connection.incr(normalize_key(name, options), amount)
+          end
+        end
+      end
+
+      def decrement(name, amount = 1, options = nil) # :nodoc:
+        options = merged_options(options)
+        handle_exceptions(return_value_on_error: nil) do
+          instrument(:decrement, name, amount: amount) do
+            @connection.decr(normalize_key(name, options), amount)
+          end
+        end
+      end
+
+      def clear(options = nil)
+        ActiveSupport::Notifications.instrument("cache_clear.active_support", options || {}) do
+          @connection.flush
+        end
+      end
+
+      def stats
+        ActiveSupport::Notifications.instrument("cache_stats.active_support") do
+          @connection.stats
+        end
+      end
+
+      def exist?(*)
+        !!super
+      end
+
+      def reset #:nodoc:
+        handle_exceptions(return_value_on_error: false) do
+          @connection.reset
+        end
+      end
+
+      private
+
+      if private_method_defined?(:read_serialized_entry)
+        class DupLocalStore < DelegateClass(Strategy::LocalCache::LocalStore)
+          def write_entry(_key, entry)
+            if entry.is_a?(Entry)
+              entry.dup_value!
+            end
+            super
+          end
+
+          def fetch_entry(key)
+            entry = super do
+              new_entry = yield
+              if entry.is_a?(Entry)
+                new_entry.dup_value!
+              end
+              new_entry
+            end
+            entry = entry.dup
+
+            if entry.is_a?(Entry)
+              entry.dup_value!
+            end
+
+            entry
+          end
+        end
+
+        module DupLocalCache
+          private
+
+          def local_cache
+            if local_cache = super
+              DupLocalStore.new(local_cache)
+            end
+          end
+        end
+
+        prepend DupLocalCache
+
+        def read_entry(key, **options) # :nodoc:
+          deserialize_entry(read_serialized_entry(key, **options))
+        end
+
+        def read_serialized_entry(key, **)
+          handle_exceptions(return_value_on_error: nil) do
+            @connection.get(key)
+          end
+        end
+
+        def write_entry(key, entry, **options) # :nodoc:
+          return true if read_only
+
+          write_serialized_entry(key, serialize_entry(entry, **options), **options)
+        end
+
+        def write_serialized_entry(key, value, **options)
+          method = options && options[:unless_exist] ? :add : :set
+          expires_in = expiration(options)
+          handle_exceptions(return_value_on_error: false) do
+            @connection.send(method, key, value, expires_in)
+            true
+          end
+        end
+      else
+        def read_entry(key, _options) # :nodoc:
+          handle_exceptions(return_value_on_error: nil) do
+            deserialize_entry(@connection.get(key))
+          end
+        end
+
+        def write_entry(key, entry, options) # :nodoc:
+          return true if read_only
+          method = options && options[:unless_exist] ? :add : :set
+          expires_in = expiration(options)
+          value = serialize_entry(entry, options)
+          handle_exceptions(return_value_on_error: false) do
+            @connection.send(method, key, value, expires_in)
+            true
+          end
+        end
+      end
+
+      def delete_entry(key, _options) # :nodoc:
+        return true if read_only
+        handle_exceptions(return_value_on_error: false, on_miss: true) do
+          @connection.delete(key)
+          true
+        end
+      end
+
+      private
+
+      def normalize_key(key, options)
+        key = super.dup
+        key = key.force_encoding(Encoding::ASCII_8BIT)
+        key = key.gsub(ESCAPE_KEY_CHARS) { |match| "%#{match.getbyte(0).to_s(16).upcase}" }
+        # When we remove support to Rails 5.1 we can change the code to use ActiveSupport::Digest
+        key = "#{key[0, 213]}:md5:#{::Digest::MD5.hexdigest(key)}" if key.size > 250
+        key
+      end
+
+      def deserialize_entry(value)
+        unless value.nil?
+          value.is_a?(Entry) ? value : Entry.new(value, compress: false)
+        end
+      end
+
+      def serialize_entry(entry, options)
+        if options[:raw]
+          entry.value.to_s
+        else
+          entry
+        end
+      end
+
+      def expiration(options)
+        expires_in = options[:expires_in].to_i
+        if expires_in > 0 && options[:race_condition_ttl] && !options[:raw]
+          expires_in += options[:race_condition_ttl].to_i
+        end
+        expires_in
+      end
+
+      def handle_exceptions(return_value_on_error:, on_miss: return_value_on_error, miss_exceptions: [])
+        yield
+      rescue Memcached::NotFound, Memcached::ConnectionDataExists, *miss_exceptions
+        on_miss
+      rescue Memcached::Error => e
+        log_warning(e)
+        raise unless @swallow_exceptions
+        return_value_on_error
+      end
+
+      def log_warning(err)
+        return unless logger
+        return if err.is_a?(Memcached::NotStored) && @swallow_exceptions
+
+        logger.warn(
+          "[MEMCACHED_ERROR] swallowed=#{@swallow_exceptions}" \
+          " exception_class=#{err.class} exception_message=#{err.message}"
+        )
+      end
+
+      ActiveSupport.run_load_hooks(:memcached_store)
+    end
+  end
+end

data/lib/memcached_store/railtie.rb

@@ -0,0 +1,9 @@
+module MemcachedStore
+  class Railtie < Rails::Railtie
+    initializer 'memcached_store.configuration' do
+      ActiveSupport.on_load(:memcached_store) do
+        ActiveSupport::Cache::MemcachedStore.logger ||= Rails.logger
+      end
+    end
+  end
+end

data/lib/memcached_store/version.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+module MemcachedStore
+  VERSION = "2.3.2"
+end

data/lib/memcached_store.rb

@@ -0,0 +1,4 @@
+require "memcached"
+require "active_support"
+require "active_support/cache"
+require "memcached_store/railtie" if defined?(Rails)

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: vinted-memcached_store
+version: !ruby/object:Gem::Version
+  version: 2.3.2
+platform: ruby
+authors:
+- Camilo Lopez
+- Tom Burns
+- Arthur Neves
+- Francis Bogsanyi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-08-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: memcached
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !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: mocha
+  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: timecop
+  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'
+description: Plugin-able Memcached adapters to add features (compression, safety)
+email:
+- camilo@camilolopez.com
+- tom.burns@shopify.com
+- arthurnn@gmail.com
+- francis.bogsanyi@shopify.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/active_support/cache/memcached_snappy_store.rb
+- lib/active_support/cache/memcached_store.rb
+- lib/memcached_store.rb
+- lib/memcached_store/railtie.rb
+- lib/memcached_store/version.rb
+homepage: https://github.com/Shopify/memcached_store/
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key: 
+specification_version: 4
+summary: Plugin-able Memcached adapters to add features (compression, safety)
+test_files: []