lock_and_cache_msgpack 4.0.7.pre1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 221660e4bbdfdf8d620d9623503e2e1f503052cf
+  data.tar.gz: 496b11c457fa396fad2a702049737b33b28b0c1d
+SHA512:
+  metadata.gz: 3a6e2422232cd578907be08ce3e4e480856245799dbdb746174fc5e489007fc96e68133f76b93a1a63cd4f78b142a52f217506b6c4a511cdb5881c8944d7541a
+  data.tar.gz: 5cccb26f41913573aadd2ebeee600c5aba51bec366b565c43faff5fa3ecdf73f3fe1a6a9dd17e8016956fa4ae823a62731c742a80cb182cb8e6b41b2ae84dc04

data/CHANGELOG

@@ -0,0 +1,215 @@
+4.0.6
+
+* ?
+
+  * Don't test on ruby 2.1
+
+* Enhancements
+
+  * LockAndCacheMsgpack.cached?(*key_parts) to check if a value is cached
+
+4.0.5 / 2017-04-01
+
+* Enhancements
+
+  * allow dates and times in keys
+  * Test on ruby 2.3.0 and 2.4.1
+  * 2x faster key generation
+
+4.0.4 / 2016-04-11
+
+* Bug fixes
+
+  * Don't default to debug logging
+
+4.0.3 / 2016-04-11
+
+* Bug fixes
+
+  * Allow true or false in keys
+
+4.0.2 / 2016-04-11
+
+* Bug fixes
+
+  * When generating key, recurse into #lock_and_cache_key
+
+4.0.1 / 2016-04-11
+
+* Bug fixes
+
+  * Avoid deadlocks related to logging
+
+4.0.0 / 2016-04-11
+
+* Breaking changes
+
+  * The cache key generation I've always wanted: recursively call #id or #lock_and_cache_key
+
+3.0.1 / 2016-04-04
+
+* Enhancements
+
+  * Don't use deprecated Thread.exclusive
+
+3.0.0 / 2016-04-02
+
+* Breaking changes
+
+  * In context mode (when you `include LockAndCacheMsgpack`), really call #lock_and_cache_key or #id on the instance
+
+2.2.2 / 2015-12-18
+
+* Bug fixes
+
+  * Don't die if you pass a non-integer expires - round it
+
+2.2.1 / 2015-12-14
+
+* Bug fixes
+
+  * Construct key using the correct class name
+
+2.2.0 / 2015-11-15
+
+* Enhancements
+
+  * Increase default heartbeat expires to 32 seconds from 2 (which was too strict IMO)
+  * Allow setting heartbeat_expires: globally (LockAndCacheMsgpack.heartbeat_expires=) or per call
+  * Provide LockAndCacheMsgpack.locked?()
+
+2.1.1 / 2015-10-26
+
+* Bug fixes
+
+  * Blow up if you try to use standalone mode without a key
+
+2.1.0 / 2015-10-26
+
+* Enhancements
+
+  * Better documentation
+  * Standalone mode (LockAndCacheMsgpack.lock_and_cache([...]) {})
+  * Nulls can be set to expire sooner than non-null return values (`nil_expires`)
+
+2.0.2 / 2015-10-16
+
+* Bug fixes (?)
+
+  * Make sure cached values are valid marshal format (seen in the wild that they're nil)
+
+* Enhancements
+
+  * Use original redlock gem now that it supports extend
+
+2.0.1 / 2015-09-14
+
+* Bug fixes
+
+  * Don't explicitly kill the lock extender thread because that sometimes causes deadlocks (don't know why)
+
+2.0.0 / 2015-09-11
+
+* Breaking changes
+
+  * Stricter key digest - differentiates symbols and strings
+  * No more lock_expires or lock_spin options
+
+* Bug fixes
+
+  * Allow method names with non-word chars like #foo?
+
+* Enhancements
+
+  * heartbeats so that SIGKILL will effectively clear the lock
+  * #lock_and_cache_clear now clears lock too
+
+1.1.0 / 2015-08-07
+
+* Breaking changes
+
+  * Reduce default lock expiry to 1 day instead of weird 3 days
+
+* Enhancements
+
+  * Added :max_lock_wait option inspired by @leandromoreira
+
+1.0.3 / 2015-08-06
+
+* Enhancements
+
+  * More granular debug output
+
+1.0.2 / 2015-08-06
+
+* Bug fixes
+
+  * Put LockAndCacheMsgpack.flush back
+
+1.0.1 / 2015-08-06
+
+* Bug fixes
+
+  * Return value properly if lock was acquired but cached value immediately found
+
+* Enhancements
+
+  * Documentation
+
+1.0.0 / 2015-08-05
+
+* Enhancements
+
+  * Use Redis redlock http://redis.io/topics/distlock instead of Postgres advisory locks
+  * No more dependency on ActiveRecord or Postgres!
+
+0.1.2 / 2015-06-24
+
+* Enhancements
+
+  * Add :expires option in seconds
+
+0.1.1 / 2015-02-04
+
+* Enhancements
+
+  * Clear individual cached things with #lock_and_cache_clear
+
+0.1.0 / 2015-01-22
+
+* Breaking changes
+
+  * Redis only
+  * Now you use it inside methods (like Rails.cache.fetch) instead of outside (like cache_method)
+
+* Enhancements
+
+  * Way simpler, no dependency on CacheMethod
+
+0.0.5 / 2014-12-12
+
+* Enhancements
+
+  * ENV['LOCK_AND_CACHE_DEBUG'] == 'true' debug output to $stderr
+
+0.0.4 / 2014-12-12
+
+* Bug fixes
+
+  * Pass arguments while caching method results
+
+0.0.3 / 2014-12-12
+
+* Enhancements
+
+  * Save a trip to the database if something is already cached
+
+0.0.2 / 2014-12-11
+
+* Bug fixes
+
+  * Gem name is activerecord
+
+0.0.1 / 2014-12-11
+
+initial release!

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lock_and_cache.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,68 @@
+PATH
+  remote: .
+  specs:
+    lock_and_cache_msgpack (4.0.6)
+      activesupport
+      msgpack (~> 1.1.0)
+      redis
+      redlock (>= 0.1.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (5.1.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    coderay (1.1.1)
+    concurrent-ruby (1.0.5)
+    diff-lcs (1.3)
+    i18n (0.8.6)
+    method_source (0.8.2)
+    minitest (5.10.3)
+    msgpack (1.1.0)
+    pry (0.10.4)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.5.0)
+    redcarpet (3.4.0)
+    redis (3.3.3)
+    redlock (0.2.0)
+      redis (~> 3, >= 3.0.0)
+    rspec (3.6.0)
+      rspec-core (~> 3.6.0)
+      rspec-expectations (~> 3.6.0)
+      rspec-mocks (~> 3.6.0)
+    rspec-core (3.6.0)
+      rspec-support (~> 3.6.0)
+    rspec-expectations (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-mocks (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-support (3.6.0)
+    slop (3.6.0)
+    thread (0.2.2)
+    thread_safe (0.3.6)
+    tzinfo (1.2.3)
+      thread_safe (~> 0.1)
+    yard (0.9.9)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.6)
+  lock_and_cache_msgpack!
+  pry
+  rake (~> 10.0)
+  redcarpet
+  rspec
+  thread
+  yard
+
+BUNDLED WITH
+   1.15.3

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2014 Seamus Abshere
+Forked and modified 2017 Matt E. Patterson
+
+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,236 @@
+# LockAndCacheMsgpack
+
+[![Build Status](https://travis-ci.org/seamusabshere/lock_and_cache.svg?branch=master&v=2.2.0)](https://travis-ci.org/seamusabshere/lock_and_cache)
+[![Code Climate](https://codeclimate.com/github/seamusabshere/lock_and_cache/badges/gpa.svg?v=2.2.0)](https://codeclimate.com/github/seamusabshere/lock_and_cache)
+[![Dependency Status](https://gemnasium.com/seamusabshere/lock_and_cache.svg?v=2.2.0)](https://gemnasium.com/seamusabshere/lock_and_cache)
+[![Gem Version](https://badge.fury.io/rb/lock_and_cache.svg?v=2.2.0)](http://badge.fury.io/rb/lock_and_cache)
+[![Security](https://hakiri.io/github/seamusabshere/lock_and_cache/master.svg?v=2.2.0)](https://hakiri.io/github/seamusabshere/lock_and_cache/master)
+[![Inline docs](http://inch-ci.org/github/seamusabshere/lock_and_cache.svg?branch=master&v=2.2.0)](http://inch-ci.org/github/seamusabshere/lock_and_cache)
+
+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?
+
+## Quickstart
+
+```ruby
+LockAndCacheMsgpack.storage = Redis.new
+
+LockAndCacheMsgpack.lock_and_cache(:stock_price, {company: 'MSFT', date: '2015-05-05'}, expires: 10, nil_expires: 1) do
+  # get yer stock quote
+  # if 50 processes call this at the same time, only 1 will call the stock quote service
+  # the other 49 will wait on the lock, then get the cached value
+  # the value will expire in 10 seconds
+  # but if the value you get back is nil, that will expire after 1 second
+end
+```
+
+## Sponsor
+
+<p><a href="http://faraday.io"><img src="http://cdn2.hubspot.net/hubfs/515497/img/logo.svg" alt="Faraday logo"/></a></p>
+
+We use [`lock_and_cache`](https://github.com/seamusabshere/lock_and_cache) for [data-driven marketing at Faraday](http://faraday.io).
+
+## TOC
+
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+
+
+  - [Theory](#theory)
+  - [Practice](#practice)
+    - [Setup](#setup)
+    - [Locking](#locking)
+    - [Caching](#caching)
+      - [Standalone mode](#standalone-mode)
+      - [Context mode](#context-mode)
+  - [Special features](#special-features)
+    - [Locking of course!](#locking-of-course)
+    - [Heartbeat](#heartbeat)
+    - [Context mode](#context-mode-1)
+    - [nil_expires](#nil_expires)
+  - [Tunables](#tunables)
+  - [Few dependencies](#few-dependencies)
+  - [Wishlist](#wishlist)
+  - [Contributing](#contributing)
+- [Copyright](#copyright)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
+## Theory
+
+`lock_and_cache`...
+
+1. <span style="color: red;">returns cached value</span> (if exists)
+2. <span style="color: green;">acquires a lock</span>
+3. <span style="color: red;">returns cached value</span> (just in case it was calculated while we were waiting for a lock)
+4. <span style="color: red;">calculates and caches the value</span>
+5. <span style="color: green;">releases the lock</span>
+6. <span style="color: red;">returns the value</span>
+
+As you can see, most caching libraries only take care of (1) and (4) (well, and (5) of course).
+
+## Practice
+
+### Setup
+
+```ruby
+LockAndCacheMsgpack.storage = Redis.new
+```
+
+It will use this redis for both locking and storing cached values.
+
+### Locking
+
+Based on [antirez's Redlock algorithm](http://redis.io/topics/distlock).
+
+Above and beyond Redlock, a 32-second heartbeat is used that will clear the lock if a process is killed. This is implemented using lock extensions.
+
+### Caching
+
+This gem is a simplified, improved version of https://github.com/seamusabshere/cache_method. In that library, you could only cache a method call.
+
+In this library, you have two options: providing the whole cache key every time (standalone) or letting the library pull information about its context.
+
+```ruby
+# standalone example
+LockAndCacheMsgpack.lock_and_cache(:stock_price, {company: 'MSFT', date: '2015-05-05'}, expires: 10) do
+  # ...
+end
+
+# context example
+def stock_price(date)
+  lock_and_cache(date, expires: 10) do
+    # ...
+  end
+end
+def lock_and_cache_key
+  company
+end
+```
+
+#### Standalone mode
+
+```ruby
+LockAndCacheMsgpack.lock_and_cache(:stock_price, company: 'MSFT', date: '2015-05-05') do
+  # get yer stock quote
+end
+```
+
+You probably want an expiry
+
+```ruby
+LockAndCacheMsgpack.lock_and_cache(:stock_price, {company: 'MSFT', date: '2015-05-05'}, expires: 10) do
+  # get yer stock quote
+end
+```
+
+Note how we separated options (`{expires: 10}`) from a hash that is part of the cache key (`{company: 'MSFT', date: '2015-05-05'}`).
+
+One other crazy thing: `nil_expires` - for when you want to check more often if the external stock price service returned nil
+
+```ruby
+LockAndCacheMsgpack.lock_and_cache(:stock_price, {company: 'MSFT', date: '2015-05-05'}, expires: 10, nil_expires: 1) do
+  # get yer stock quote
+end
+```
+
+Clear it with
+
+```ruby
+LockAndCacheMsgpack.clear :stock_price, company: 'MSFT', date: '2015-05-05'
+```
+
+Check locks with
+
+```ruby
+LockAndCacheMsgpack.locked? :stock_price, company: 'MSFT', date: '2015-05-05'
+```
+
+#### Context mode
+
+"Context mode" simply adds the class name, method name, and context key (the results of `#id` or `#lock_and_cache_key`) of the caller to the cache key.
+
+```ruby
+class Stock
+  include LockAndCacheMsgpack
+
+  def initialize(company)
+    [...]
+  end
+
+  def stock_price(date)
+    lock_and_cache(date, expires: 10) do
+      # the cache key will be StockQuote (the class) + get (the method name) + id (the instance identifier) + date (the arg you specified)
+    end
+  end
+
+  def lock_and_cache_key # <---------- if you don't define this, it will try to call #id
+    company
+  end
+end
+```
+
+The cache key will be StockQuote (the class) + get (the method name) + id (the instance identifier) + date (the arg you specified).
+
+In other words, it auto-detects the class, method, context key ... and you add other args if you want.
+
+Clear it with
+
+```ruby
+blog.lock_and_cache_clear(:get, date)
+```
+
+## Special features
+
+### Locking of course!
+
+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?
+
+### Heartbeat
+
+If the process holding the lock dies, we automatically remove the lock so somebody else can do it (using heartbeats and redlock extends).
+
+### Context mode
+
+This pulls information about the context of a lock_and_cache block from the surrounding class, method, and object... so that you don't have to!
+
+Standalone mode is cool too, tho.
+
+### nil_expires
+
+You can expire nil values with a different timeout (`nil_expires`) than other values (`expires`).
+
+## Tunables
+
+* `LockAndCacheMsgpack.storage=[redis]`
+* `ENV['LOCK_AND_CACHE_DEBUG']='true'` if you want some debugging output on `$stderr`
+
+## Few dependencies
+
+* [activesupport](https://rubygems.org/gems/activesupport) (come on, it's the bomb)
+* [redis](https://github.com/redis/redis-rb)
+* [redlock](https://github.com/leandromoreira/redlock-rb)
+
+## Known issues
+
+* In cache keys, can't distinguish {a: 1} from [[:a, 1]]
+
+## Wishlist
+
+* Convert most tests to use standalone mode, which is easier to understand
+* Check options
+* Lengthen heartbeat so it's not so sensitive
+* Clarify which options are seconds or milliseconds
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/lock_and_cache/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+# Copyright 
+
+Copyright 2015 Seamus Abshere