frivol 0.3.1 → 0.4.0

data/lib/frivol/backend/redis.rb

@@ -0,0 +1,93 @@
+require "redis"
+
+module Frivol
+  module Backend
+    # == Configuration
+    # This is a connection to a single Redis server and the simplest backend.
+    #   REDIS_CONFIG = {
+    #     :host => "localhost",
+    #     :port => 6379
+    #   }
+    #   Frivol::Config.backend = Frivol::Backend::Redis.new(REDIS_CONFIG)
+    class Redis
+      # :nodoc:
+      def initialize(config)
+        @config = config
+      end
+
+      # Hashes
+      def get(key, expiry = Frivol::NEVER_EXPIRE)
+        connection.get(key)
+      end
+      alias_method :getc, :get # Counter method alias
+
+      def set(key, val, expiry = Frivol::NEVER_EXPIRE)
+        set_with_expiry(key, val, expiry)
+      end
+      alias_method :setc, :set # Counter method alias
+
+      def del(key)
+        connection.del(key)
+      end
+      alias_method :delc, :del # Counter method alias
+
+      def exists(key)
+        connection.exists(key)
+      end
+      alias_method :existsc, :exists # Counter method alias
+
+      # Counters
+      def incr(key, expiry = Frivol::NEVER_EXPIRE)
+        set_with_expiry(key, 1, expiry, :incrby)
+      end
+
+      def decr(key, expiry = Frivol::NEVER_EXPIRE)
+        set_with_expiry(key, 1, expiry, :decrby)
+      end
+
+      def incrby(key, amt, expiry = Frivol::NEVER_EXPIRE)
+        set_with_expiry(key, amt, expiry, :incrby)
+      end
+
+      def decrby(key, amt, expiry = Frivol::NEVER_EXPIRE)
+        set_with_expiry(key, amt, expiry, :decrby)
+      end
+
+      # Expiry/TTL
+      def expire(key, ttl)
+        connection.expire(key, ttl)
+      end
+
+      def ttl(key)
+        time = connection.ttl(key)
+        time < 0 ? nil : time
+      end
+
+      # Connection
+      def flushdb
+        connection.flushdb
+      end
+
+      def connection
+        Thread.current[thread_key] ||= ::Redis.new(@config)
+      end
+
+    private
+      def thread_key
+        @thread_key ||= @config.hash.to_s.to_sym
+      end
+
+      def set_with_expiry(key, val, expiry, method = :set)
+        if expiry == Frivol::NEVER_EXPIRE
+          connection.send(method, key, val)
+        else
+          result = connection.multi do |redis|
+            redis.send(method, key, val)
+            redis.expire(key, expiry)
+          end
+          result[0]
+        end
+      end
+    end
+  end
+end

data/lib/frivol/backend/redis_distributed.rb

@@ -0,0 +1,51 @@
+require "redis"
+require "redis/distributed"
+require File.join(File.dirname(__FILE__), "redis")
+
+module Frivol
+  module Backend
+    # == Configuration
+    # While it's not well known or documented, the Redis gem includes a sharding implementation in
+    # Redis::Distributed[http://www.rubydoc.info/gems/redis/3.2.1/Redis/Distributed]. This backend
+    # makes that available for Frivol.
+    #   REDIS_CONFIG = [{
+    #     :host => "localhost",
+    #     :port => 6379
+    #   }, {
+    #     :host => "localhost",
+    #     :port => 6380
+    #   }]
+    #   Frivol::Config.backend = Frivol::Backend::RedisDistributed.new(REDIS_CONFIG)
+    class RedisDistributed < Frivol::Backend::Redis
+      # :nodoc:
+      def set(key, val, expiry = Frivol::NEVER_EXPIRE)
+        if expiry == Frivol::NEVER_EXPIRE
+          connection.set(key, val)
+        else
+          connection.node_for(key).multi do |redis|
+            redis.set(key, val)
+            redis.expire(key, expiry)
+          end
+        end
+      end
+      alias_method :setc, :set # Counter method alias
+
+      def connection
+        Thread.current[thread_key] ||= ::Redis::Distributed.new(@config)
+      end
+
+    private
+      def set_with_expiry(key, val, expiry, method = :set)
+        if expiry == Frivol::NEVER_EXPIRE
+          connection.send(method, key, val)
+        else
+          results = connection.node_for(key).multi do |redis|
+            redis.send(method, key, val)
+            redis.expire(key, expiry)
+          end
+          results[0]
+        end
+      end
+    end
+  end
+end

data/lib/frivol/backend/riak.rb

@@ -0,0 +1,186 @@
+require "riak"
+
+module Frivol #:nodoc:
+  module Backend
+    # == Configuration
+    # This backend is experimental. I have not used this in production. YMMV.
+    #   RIAK_CONFIG = {
+    #     :protocol => 'http',
+    #     :nodes => [ { :host => '127.0.0.1' } ]
+    #   }
+    #   Frivol::Config.backend = Frivol::Backend::Riak.new(RIAK_CONFIG)
+    class Riak
+      # :nodoc:
+      def initialize(config)
+        @prefix = config.delete(:prefix) || ''
+        @config = config
+      end
+
+      # Hashes
+      def get(key, expiry = Frivol::NEVER_EXPIRE)
+        obj = objects_bucket.get_or_new(key)
+        expires_in = ttl(key)
+        if expires_in.nil? || expires_in > 0
+          obj.raw_data
+        else
+          obj.delete
+          nil
+        end
+      end
+
+      def set(key, val, expiry = Frivol::NEVER_EXPIRE)
+        obj = objects_bucket.get_or_new(key)
+        obj.raw_data = val
+        obj.content_type = 'text/plain'
+        obj.store
+        expire(key, expiry) unless expiry == Frivol::NEVER_EXPIRE
+      end
+
+      def del(key)
+        objects_bucket.delete(key)
+        expires_bucket.delete(key)
+      end
+
+      def exists(key)
+        exists = objects_bucket.exist?(key)
+        if exists
+          expires_in = ttl(key)
+          if expires_in.nil? || expires_in > 0
+            true
+          else
+            objects_bucket.delete(key)
+            false
+          end
+        end
+      end
+
+      # Counters
+      def getc(key, expiry = Frivol::NEVER_EXPIRE)
+        cnt = counters_bucket.counter(key) if existsc(key)
+        expires_in = ttl(key)
+        if expires_in.nil? || expires_in > 0
+          cnt ? cnt.value : nil
+        else
+          delc(key)
+          nil
+        end
+      end
+
+      def setc(key, val, expiry = Frivol::NEVER_EXPIRE)
+        delc(key)
+        cnt = counters_bucket.counter(key)
+        cnt.increment(val)
+        expire(key, expiry) unless expiry == Frivol::NEVER_EXPIRE
+      end
+
+      def delc(key)
+        counters_bucket.delete(key)
+        expires_bucket.delete(key)
+      end
+
+      def existsc(key)
+        exists = counters_bucket.exist?(key)
+        if exists
+          expires_in = ttl(key)
+          if expires_in.nil? || expires_in > 0
+            true
+          else
+            counters_bucket.delete(key)
+            false
+          end
+        end
+      end
+
+      def incr(key, expiry = Frivol::NEVER_EXPIRE)
+        cnt = counters_bucket.counter(key)
+        cnt.increment
+        expire(key, expiry) unless expiry == Frivol::NEVER_EXPIRE
+        cnt.value
+      end
+
+      def decr(key, expiry = Frivol::NEVER_EXPIRE)
+        cnt = counters_bucket.counter(key)
+        cnt.decrement
+        expire(key, expiry) unless expiry == Frivol::NEVER_EXPIRE
+        cnt.value
+      end
+
+      def incrby(key, amt, expiry = Frivol::NEVER_EXPIRE)
+        cnt = counters_bucket.counter(key)
+        cnt.increment(amt)
+        expire(key, expiry) unless expiry == Frivol::NEVER_EXPIRE
+        cnt.value
+      end
+
+      def decrby(key, amt, expiry = Frivol::NEVER_EXPIRE)
+        cnt = counters_bucket.counter(key)
+        cnt.decrement(amt)
+        expire(key, expiry) unless expiry == Frivol::NEVER_EXPIRE
+        cnt.value
+      end
+
+      # Expiry/TTL
+      def expire(key, ttl)
+        obj = expires_bucket.get_or_new(key)
+        obj.raw_data = (Time.now.to_i + ttl).to_s
+        obj.content_type = 'text/plain'
+        obj.store
+      end
+
+      def ttl(key)
+        obj = expires_bucket.get_or_new(key)
+        expiry = obj.raw_data.to_i
+        if expiry == 0
+          nil
+        else
+          expiry - Time.now.to_i
+        end
+      end
+
+      # Connection
+      def flushdb
+        objects_bucket.keys.each { |k| objects_bucket.delete(k) }
+        counters_bucket.keys.each { |k| counters_bucket.delete(k) }
+        expires_bucket.keys.each { |k| expires_bucket.delete(k) }
+      end
+
+      def connection
+        Thread.current[thread_key] ||= begin
+          @objects_bucket = nil
+          @counters_bucket = nil
+          @expires_bucket = nil
+          ::Riak::Client.new(@config)
+        end
+      end
+
+    private
+      def objects_bucket
+        @objects_bucket ||= begin
+          bkt = connection.bucket("#{@prefix}frivol_objects")
+          bkt.props = { :last_write_wins => true }
+          bkt
+        end
+      end
+
+      def counters_bucket
+        @counters_bucket ||= begin
+          bkt = connection.bucket("#{@prefix}frivol_counters")
+          bkt.allow_mult = true
+          bkt
+        end
+      end
+
+      def expires_bucket
+        @expires_bucket ||= begin
+          bkt = connection.bucket("#{@prefix}frivol_expires")
+          bkt.props = { :last_write_wins => true }
+          bkt
+        end
+      end
+
+      def thread_key
+        @thread_key ||= @config.hash.to_s.to_sym
+      end
+    end
+  end
+end

data/lib/frivol/class_methods.rb

@@ -92,6 +92,12 @@ module Frivol
           define_method "decrement_#{bucket}_by" do |amount|
             Frivol::Helpers.decrement_counter_by(self, bucket, amount, seed_callback)
           end
+
+          define_method "delete_#{bucket}" do
+            condition_evaluation("delete_#{bucket}") do
+              Frivol::Helpers.delete_counter(self, bucket)
+            end
+          end
         else
           define_method "store_#{bucket}" do |keys_and_values|
             condition_evaluation("store_#{bucket}", keys_and_values) do
@@ -115,11 +121,11 @@ module Frivol
             return result.first if result.size == 1
             result
           end
-        end
 
-        define_method "delete_#{bucket}" do
-          condition_evaluation("delete_#{bucket}") do
-            Frivol::Helpers.delete_hash(self, bucket)
+          define_method "delete_#{bucket}" do
+            condition_evaluation("delete_#{bucket}") do
+              Frivol::Helpers.delete_hash(self, bucket)
+            end
           end
         end
 

data/lib/frivol/config.rb

@@ -3,31 +3,17 @@ module Frivol
   # Sets the Frivol configuration (currently only the Redis config), allows access to the configured Redis instance,
   # and has a helper method to include Frivol in a class with an optional storage expiry parameter
   module Config
-    # Set the Redis configuration.
+    # Set the Backend.
     #
-    # Expects a hash such as
-    #   REDIS_CONFIG = {
-    #     :host => "localhost",
-    #     :port => 6379
-    #   }
-    #   Frivol::Config.redis_config = REDIS_CONFIG
-    def self.redis_config=(config)
-      @@redis_config = config
-      @@redis_version = nil
-      Thread.current[:frivol_redis] = nil
-    end
-
-    # Returns the configured Redis instance
-    def self.redis
-      Thread.current[:frivol_redis] ||= Redis.new(@@redis_config)
-    end
-
-    def self.redis_version
-      redis.info('server')['redis_version'].to_f
+    # Expects one of Frivol::Backend::Redis, Frivol::Backend::RedisDistributed,
+    # Frivol::Backend::Riak or Frivol::Backend::Multi
+    def self.backend=(new_backend)
+      @@backend = new_backend
     end
 
-    def self.requires_expiry_reset?
-      redis_version < 2.2
+    # Get the Backend.
+    def self.backend
+      @@backend
     end
 
     def self.allow_json_create

data/lib/frivol/helpers.rb

@@ -29,41 +29,23 @@ module Frivol
       data, is_new = get_data_and_is_new instance
       data[bucket.to_s] = hash
 
-      store_value instance, is_new[bucket.to_s], dump_json(hash), bucket
-
-      self.set_data_and_is_new instance, data, is_new
-    end
-
-    def self.store_value(instance, is_new, value, bucket = nil)
       key = instance.send(:storage_key, bucket)
       time = instance.class.storage_expiry(bucket)
-      if time == Frivol::NEVER_EXPIRE
-        Frivol::Config.redis[key] = value
-      elsif Frivol::Config.requires_expiry_reset?
-        time = redis.ttl(key).to_i unless is_new
-        Frivol::Config.redis.multi do |redis|
-          redis[key] = value
-          redis.expire(key, time)
-        end
-      elsif is_new
-        Frivol::Config.redis.multi do |redis|
-          redis[key] = value
-          redis.expire(key, time)
-        end
-      else
-        Frivol::Config.redis[key] = value
-      end
+      Frivol::Config.backend.set(key, dump_json(hash), is_new ? time : nil)
+
+      self.set_data_and_is_new instance, data, is_new
     end
 
     def self.retrieve_hash(instance, bucket = nil)
       data, is_new = get_data_and_is_new instance
       return data[bucket.to_s] if data.key?(bucket.to_s)
       key = instance.send(:storage_key, bucket)
-      json = Frivol::Config.redis[key]
+      time = instance.class.storage_expiry(bucket)
+      json = Frivol::Config.backend.get(key, time).to_s
 
-      is_new[bucket.to_s] = json.nil?
+      is_new[bucket.to_s] = json.empty?
 
-      hash = json.nil? ? {} : load_json(json)
+      hash = json.empty? ? {} : load_json(json)
       data[bucket.to_s] = hash
 
       self.set_data_and_is_new instance, data, is_new
@@ -72,7 +54,7 @@ module Frivol
 
     def self.delete_hash(instance, bucket = nil)
       key = instance.send(:storage_key, bucket)
-      Frivol::Config.redis.del key
+      Frivol::Config.backend.del key
       clear_hash(instance, bucket)
     end
 
@@ -96,41 +78,57 @@ module Frivol
 
     def self.store_counter(instance, counter, value)
       key = instance.send(:storage_key, counter)
-      is_new = !Frivol::Config.redis.exists(key)
-      store_value instance, is_new, value, counter
+      exists = Frivol::Config.backend.existsc(key)
+      time = instance.class.storage_expiry(counter)
+      Frivol::Config.backend.setc(key, value, exists ? nil : time)
     end
 
     def self.retrieve_counter(instance, counter, default)
       key = instance.send(:storage_key, counter)
-      (Frivol::Config.redis[key] || default).to_i
+      time = instance.class.storage_expiry(counter)
+      (Frivol::Config.backend.getc(key, time) || default).to_i
     end
 
     def self.increment_counter(instance, counter, seed_callback=nil)
       key = instance.send(:storage_key, counter)
       store_counter_seed_value(key, instance, counter, seed_callback)
-      Frivol::Config.redis.incr(key)
+      exists = Frivol::Config.backend.existsc(key)
+      time = instance.class.storage_expiry(counter)
+      Frivol::Config.backend.incr(key, exists ? nil : time)
     end
 
     def self.increment_counter_by(instance, counter, amount, seed_callback=nil)
       key = instance.send(:storage_key, counter)
       store_counter_seed_value(key, instance, counter, seed_callback)
-      Frivol::Config.redis.incrby(key, amount)
+      exists = Frivol::Config.backend.existsc(key)
+      time = instance.class.storage_expiry(counter)
+      Frivol::Config.backend.incrby(key, amount, exists ? nil : time)
     end
 
     def self.decrement_counter(instance, counter, seed_callback=nil)
       key = instance.send(:storage_key, counter)
       store_counter_seed_value(key, instance, counter, seed_callback)
-      Frivol::Config.redis.decr(key)
+      exists = Frivol::Config.backend.existsc(key)
+      time = instance.class.storage_expiry(counter)
+      Frivol::Config.backend.decr(key, exists ? nil : time)
     end
 
     def self.decrement_counter_by(instance, counter, amount, seed_callback=nil)
       key = instance.send(:storage_key, counter)
       store_counter_seed_value(key, instance, counter, seed_callback)
-      Frivol::Config.redis.decrby(key, amount)
+      exists = Frivol::Config.backend.existsc(key)
+      time = instance.class.storage_expiry(counter)
+      Frivol::Config.backend.decrby(key, amount, exists ? nil : time)
+    end
+
+    def self.delete_counter(instance, counter = nil)
+      key = instance.send(:storage_key, counter)
+      Frivol::Config.backend.delc key
+      clear_hash(instance, counter)
     end
 
     def self.store_counter_seed_value(key, instance, counter, seed_callback)
-      unless Frivol::Config.redis.exists(key) || seed_callback.nil?
+      unless Frivol::Config.backend.existsc(key) || seed_callback.nil?
         store_counter( instance, counter, seed_callback.call(instance))
       end
     end