lock_and_cache_msgpack 4.0.7.pre1

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/benchmarks/allowed_in_keys.rb

@@ -0,0 +1,87 @@
+require 'set'
+require 'date'
+require 'benchmark/ips'
+
+ALLOWED_IN_KEYS = [
+  ::String,
+  ::Symbol,
+  ::Numeric,
+  ::TrueClass,
+  ::FalseClass,
+  ::NilClass,
+  ::Integer,
+  ::Float,
+  ::Date,
+  ::DateTime,
+  ::Time,
+].to_set
+parts = RUBY_VERSION.split('.').map(&:to_i)
+unless parts[0] >= 2 and parts[1] >= 4
+  ALLOWED_IN_KEYS << ::Fixnum
+  ALLOWED_IN_KEYS << ::Bignum  
+end
+
+EXAMPLES = [
+  'hi',
+  :there,
+  123,
+  123.54,
+  1e99,
+  123456789 ** 2,
+  1e999,
+  true,
+  false,
+  nil,
+  Date.new(2015,1,1),
+  Time.now,
+  DateTime.now,
+  Mutex,
+  Mutex.new,
+  Benchmark,
+  { hi: :world },
+  [[]],
+  Fixnum,
+  Struct,
+  Struct.new(:a),
+  Struct.new(:a).new(123)
+]
+EXAMPLES.each do |example|
+  puts "#{example} -> #{example.class}"
+end
+
+puts
+
+[
+  Date.new(2015,1,1),
+  Time.now,
+  DateTime.now,
+].each do |x|
+    puts x.to_s
+end
+
+puts
+
+EXAMPLES.each do |example|
+  a = ALLOWED_IN_KEYS.any? { |thing| example.is_a?(thing) }
+  b = ALLOWED_IN_KEYS.include? example.class
+  unless a == b
+    raise "#{example.inspect}: #{a.inspect} vs #{b.inspect}"
+  end
+end
+
+Benchmark.ips do |x|
+  x.report("any") do
+    example = EXAMPLES.sample
+    y = ALLOWED_IN_KEYS.any? { |thing| example.is_a?(thing) }
+    a = 1
+    y
+  end
+
+  x.report("include") do
+    example = EXAMPLES.sample
+    y = ALLOWED_IN_KEYS.include? example.class
+    a = 1
+    y
+  end
+
+end

data/lib/lock_and_cache_msgpack.rb

@@ -0,0 +1,164 @@
+require 'logger'
+require 'timeout'
+require 'digest/sha1'
+require 'base64'
+require 'redis'
+require 'redlock'
+require 'active_support'
+require 'active_support/core_ext'
+require 'msgpack'
+require 'messagepack_ext'
+
+require_relative 'lock_and_cache_msgpack/version'
+require_relative 'lock_and_cache_msgpack/action'
+require_relative 'lock_and_cache_msgpack/key'
+
+# Lock and cache using redis!
+#
+# Most caching libraries don't do locking, meaning that >1 process can be calculating a cached value at the same time. Since you presumably cache things because they cost CPU, database reads, or money, doesn't it make sense to lock while caching?
+module LockAndCacheMsgpack
+  DEFAULT_MAX_LOCK_WAIT = 60 * 60 * 24 # 1 day in seconds
+
+  DEFAULT_HEARTBEAT_EXPIRES = 32 # 32 seconds
+
+  class TimeoutWaitingForLock < StandardError; end
+
+  # @param redis_connection [Redis] A redis connection to be used for lock and cached value storage
+  def LockAndCacheMsgpack.storage=(redis_connection)
+    raise "only redis for now" unless redis_connection.class.to_s == 'Redis'
+    @storage = redis_connection
+    @lock_manager = Redlock::Client.new [redis_connection], retry_count: 1
+  end
+
+  # @return [Redis] The redis connection used for lock and cached value storage
+  def LockAndCacheMsgpack.storage
+    @storage
+  end
+
+  # @param logger [Logger] A logger.
+  def LockAndCacheMsgpack.logger=(logger)
+    @logger = logger
+  end
+
+  # @return [Logger] The logger.
+  def LockAndCacheMsgpack.logger
+    @logger
+  end
+
+  # Flush LockAndCacheMsgpack's storage.
+  #
+  # @note If you are sharing a redis database, it will clear it...
+  #
+  # @note If you want to clear a single key, try `LockAndCacheMsgpack.clear(key)` (standalone mode) or `#lock_and_cache_clear(method_id, *key_parts)` in context mode.
+  def LockAndCacheMsgpack.flush
+    storage.flushdb
+  end
+
+  # Lock and cache based on a key.
+  #
+  # @param key_parts [*] Parts that should be used to construct a key.
+  #
+  # @note Standalone mode. See also "context mode," where you mix LockAndCacheMsgpack into a class and call it from within its methods.
+  #
+  # @note A single hash arg is treated as a cache key, e.g. `LockAndCacheMsgpack.lock_and_cache(foo: :bar, expires: 100)` will be treated as a cache key of `foo: :bar, expires: 100` (which is probably wrong!!!). Try `LockAndCacheMsgpack.lock_and_cache({ foo: :bar }, expires: 100)` instead. This is the opposite of context mode.
+  def LockAndCacheMsgpack.lock_and_cache(*key_parts_and_options, &blk)
+    options = (key_parts_and_options.last.is_a?(Hash) && key_parts_and_options.length > 1) ? key_parts_and_options.pop : {}
+    raise "need a cache key" unless key_parts_and_options.length > 0
+    key = LockAndCacheMsgpack::Key.new key_parts_and_options
+    action = LockAndCacheMsgpack::Action.new key, options, blk
+    action.perform
+  end
+
+  # Clear a single key
+  #
+  # @note Standalone mode. See also "context mode," where you mix LockAndCacheMsgpack into a class and call it from within its methods.
+  def LockAndCacheMsgpack.clear(*key_parts)
+    key = LockAndCacheMsgpack::Key.new key_parts
+    key.clear
+  end
+
+  # Check if a key is locked
+  #
+  # @note Standalone mode. See also "context mode," where you mix LockAndCacheMsgpack into a class and call it from within its methods.
+  def LockAndCacheMsgpack.locked?(*key_parts)
+    key = LockAndCacheMsgpack::Key.new key_parts
+    key.locked?
+  end
+
+  # Check if a key is cached already
+  #
+  # @note Standalone mode. See also "context mode," where you mix LockAndCacheMsgpack into a class and call it from within its methods.
+  def LockAndCacheMsgpack.cached?(*key_parts)
+    key = LockAndCacheMsgpack::Key.new key_parts
+    key.cached?
+  end
+
+  # @param seconds [Numeric] Maximum wait time to get a lock
+  #
+  # @note Can be overridden by putting `max_lock_wait:` in your call to `#lock_and_cache`
+  def LockAndCacheMsgpack.max_lock_wait=(seconds)
+    @max_lock_wait = seconds.to_f
+  end
+
+  # @private
+  def LockAndCacheMsgpack.max_lock_wait
+    @max_lock_wait || DEFAULT_MAX_LOCK_WAIT
+  end
+
+  # @param seconds [Numeric] How often a process has to heartbeat in order to keep a lock
+  #
+  # @note Can be overridden by putting `heartbeat_expires:` in your call to `#lock_and_cache`
+  def LockAndCacheMsgpack.heartbeat_expires=(seconds)
+    memo = seconds.to_f
+    raise "heartbeat_expires must be greater than 2 seconds" unless memo >= 2
+    @heartbeat_expires = memo
+  end
+
+  # @private
+  def LockAndCacheMsgpack.heartbeat_expires
+    @heartbeat_expires || DEFAULT_HEARTBEAT_EXPIRES
+  end
+
+  # @private
+  def LockAndCacheMsgpack.lock_manager
+    @lock_manager
+  end
+
+  # Check if a method is locked on an object.
+  #
+  # @note Subject mode - this is expected to be called on an object whose class has LockAndCacheMsgpack mixed in. See also standalone mode.
+  def lock_and_cache_locked?(method_id, *key_parts)
+    key = LockAndCacheMsgpack::Key.new key_parts, context: self, method_id: method_id
+    key.locked?
+  end
+
+  # Clear a lock and cache given exactly the method and exactly the same arguments
+  #
+  # @note Subject mode - this is expected to be called on an object whose class has LockAndCacheMsgpack mixed in. See also standalone mode.
+  def lock_and_cache_clear(method_id, *key_parts)
+    key = LockAndCacheMsgpack::Key.new key_parts, context: self, method_id: method_id
+    key.clear
+  end
+
+  # Lock and cache a method given key parts.
+  #
+  # The cache key will automatically include the class name of the object calling it (the context!) and the name of the method it is called from.
+  #
+  # @param key_parts_and_options [*] Parts that you want to include in the lock and cache key. If the last element is a Hash, it will be treated as options.
+  #
+  # @return The cached value (possibly newly calculated).
+  #
+  # @note Subject mode - this is expected to be called on an object whose class has LockAndCacheMsgpack mixed in. See also standalone mode.
+  #
+  # @note A single hash arg is treated as an options hash, e.g. `lock_and_cache(expires: 100)` will be treated as options `expires: 100`. This is the opposite of standalone mode.
+  def lock_and_cache(*key_parts_and_options, &blk)
+    options = key_parts_and_options.last.is_a?(Hash) ? key_parts_and_options.pop : {}
+    key = LockAndCacheMsgpack::Key.new key_parts_and_options, context: self, caller: caller
+    action = LockAndCacheMsgpack::Action.new key, options, blk
+    action.perform
+  end
+end
+
+logger = Logger.new $stderr
+logger.level = (ENV['LOCK_AND_CACHE_DEBUG'] == 'true') ? Logger::DEBUG : Logger::INFO
+LockAndCacheMsgpack.logger = logger

data/lib/lock_and_cache_msgpack/action.rb

@@ -0,0 +1,109 @@
+module LockAndCacheMsgpack
+  # @private
+  class Action
+    attr_reader :key
+    attr_reader :options
+    attr_reader :blk
+
+    def initialize(key, options, blk)
+      raise "need a block" unless blk
+      @key = key
+      @options = options.stringify_keys
+      @blk = blk
+    end
+
+    def expires
+      return @expires if defined?(@expires)
+      @expires = options.has_key?('expires') ? options['expires'].to_f.round : nil
+    end
+
+    def nil_expires
+      return @nil_expires if defined?(@nil_expires)
+      @nil_expires = options.has_key?('nil_expires') ? options['nil_expires'].to_f.round : nil
+    end
+
+    def digest
+      @digest ||= key.digest
+    end
+
+    def lock_digest
+      @lock_digest ||= key.lock_digest
+    end
+
+    def storage
+      @storage ||= LockAndCacheMsgpack.storage or raise("must set LockAndCacheMsgpack.storage=[Redis]")
+    end
+
+    def perform
+      max_lock_wait = options.fetch 'max_lock_wait', LockAndCacheMsgpack.max_lock_wait
+      heartbeat_expires = options.fetch('heartbeat_expires', LockAndCacheMsgpack.heartbeat_expires).to_f.ceil
+      raise "heartbeat_expires must be >= 2 seconds" unless heartbeat_expires >= 2
+      heartbeat_frequency = (heartbeat_expires / 2).ceil
+      LockAndCacheMsgpack.logger.debug { "[lock_and_cache] A1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
+      if storage.exists(digest) and (existing = storage.get(digest)).is_a?(String)
+        return MessagePack.unpack(existing)
+      end
+      LockAndCacheMsgpack.logger.debug { "[lock_and_cache] B1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
+      retval = nil
+      lock_manager = LockAndCacheMsgpack.lock_manager
+      lock_info = nil
+      begin
+        Timeout.timeout(max_lock_wait, TimeoutWaitingForLock) do
+          until lock_info = lock_manager.lock(lock_digest, heartbeat_expires*1000)
+            LockAndCacheMsgpack.logger.debug { "[lock_and_cache] C1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
+            sleep rand
+          end
+        end
+        LockAndCacheMsgpack.logger.debug { "[lock_and_cache] D1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
+        if storage.exists(digest) and (existing = storage.get(digest)).is_a?(String)
+          LockAndCacheMsgpack.logger.debug { "[lock_and_cache] E1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
+          retval = MessagePack.unpack existing
+        end
+        unless retval
+          LockAndCacheMsgpack.logger.debug { "[lock_and_cache] F1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
+          done = false
+          begin
+            lock_extender = Thread.new do
+              loop do
+                LockAndCacheMsgpack.logger.debug { "[lock_and_cache] heartbeat1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
+                break if done
+                sleep heartbeat_frequency
+                break if done
+                LockAndCacheMsgpack.logger.debug { "[lock_and_cache] heartbeat2 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
+                lock_manager.lock lock_digest, heartbeat_expires*1000, extend: lock_info
+              end
+            end
+            retval = blk.call
+            retval.nil? ? set_nil : set_non_nil(retval)
+          ensure
+            done = true
+            lock_extender.join if lock_extender.status.nil?
+          end
+        end
+      ensure
+        lock_manager.unlock lock_info if lock_info
+      end
+      retval
+    end
+
+    NIL = MessagePack.pack nil
+    def set_nil
+      if nil_expires
+        storage.setex digest, nil_expires, NIL
+      elsif expires
+        storage.setex digest, expires, NIL
+      else
+        storage.set digest, NIL
+      end
+    end
+
+    def set_non_nil(retval)
+      raise "expected not null #{retval.inspect}" if retval.nil?
+      if expires
+        storage.setex digest, expires, MessagePack.pack(retval)
+      else
+        storage.set digest, MessagePack.pack(retval)
+      end
+    end
+  end
+end

data/lib/lock_and_cache_msgpack/key.rb

@@ -0,0 +1,135 @@
+require 'date'
+
+module LockAndCacheMsgpack
+  # @private
+  class Key
+    class << self
+      # @private
+      #
+      # Extract the method id from a method's caller array.
+      def extract_method_id_from_caller(kaller)
+        kaller[0] =~ METHOD_NAME_IN_CALLER
+        raise "couldn't get method_id from #{kaller[0]}" unless $1
+        $1.to_sym
+      end
+
+      # @private
+      #
+      # Get a context object's class name, which is its own name if it's an object.
+      def extract_class_name(context)
+        (context.class == ::Class) ? context.name : context.class.name
+      end
+
+      # @private
+      #
+      # Recursively extract id from obj. Calls #lock_and_cache_key if available, otherwise #id
+      def extract_obj_id(obj)
+        klass = obj.class
+        if ALLOWED_IN_KEYS.include?(klass)
+          obj
+        elsif DATE.include?(klass)
+          obj.to_s
+        elsif obj.respond_to?(:lock_and_cache_key)
+          extract_obj_id obj.lock_and_cache_key
+        elsif obj.respond_to?(:id)
+          extract_obj_id obj.id
+        elsif obj.respond_to?(:map)
+          obj.map { |objj| extract_obj_id objj }
+        else
+          raise "#{obj.inspect} must respond to #lock_and_cache_key or #id"
+        end
+      end
+    end
+
+    ALLOWED_IN_KEYS = [
+      ::String,
+      ::Symbol,
+      ::Numeric,
+      ::TrueClass,
+      ::FalseClass,
+      ::NilClass,
+      ::Integer,
+      ::Float,
+    ].to_set
+    parts = ::RUBY_VERSION.split('.').map(&:to_i)
+    unless parts[0] >= 2 and parts[1] >= 4
+      ALLOWED_IN_KEYS << ::Fixnum
+      ALLOWED_IN_KEYS << ::Bignum  
+    end
+    DATE = [
+      ::Date,
+      ::DateTime,
+      ::Time,
+    ].to_set
+    METHOD_NAME_IN_CALLER = /in `([^']+)'/
+
+    attr_reader :context
+    attr_reader :method_id
+
+    def initialize(parts, options = {})
+      @_parts = parts
+      @context = options[:context]
+      @method_id = if options.has_key?(:method_id)
+        options[:method_id]
+      elsif options.has_key?(:caller)
+        Key.extract_method_id_from_caller options[:caller]
+      elsif context
+        raise "supposed to call context with method_id or caller"
+      end
+    end
+
+    # A (non-cryptographic) digest of the key parts for use as the cache key
+    def digest
+      @digest ||= ::Digest::SHA1.hexdigest MessagePack.pack(key)
+    end
+
+    # A (non-cryptographic) digest of the key parts for use as the lock key
+    def lock_digest
+      @lock_digest ||= 'lock/' + digest
+    end
+
+    # A human-readable representation of the key parts
+    def key
+      @key ||= if context
+        [class_name, context_id, method_id, parts].compact
+      else
+        parts
+      end
+    end
+
+    def locked?
+      LockAndCacheMsgpack.storage.exists lock_digest
+    end
+
+    def cached?
+      LockAndCacheMsgpack.storage.exists digest
+    end
+
+    def clear
+      LockAndCacheMsgpack.logger.debug { "[lock_and_cache] clear #{debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
+      storage = LockAndCacheMsgpack.storage
+      storage.del digest
+      storage.del lock_digest
+    end
+
+    alias debug key
+
+    def context_id
+      return @context_id if defined?(@context_id)
+      @context_id = if context.class == ::Class
+        nil
+      else
+        Key.extract_obj_id context
+      end
+    end
+
+    def class_name
+      @class_name ||= Key.extract_class_name context
+    end
+
+    # An array of the parts we use for the key
+    def parts
+      @parts ||= Key.extract_obj_id @_parts
+    end
+  end
+end