chimera 0.0.1

data/lib/redis/objects/locks.rb

@@ -0,0 +1,71 @@
+# This is the class loader, for use as "include Redis::Objects::Locks"
+# For the object itself, see "Redis::Lock"
+require 'redis/lock'
+class Redis
+  module Objects
+    class UndefinedLock < StandardError; end #:nodoc:
+    module Locks
+      def self.included(klass)
+        klass.send :include, InstanceMethods
+        klass.extend ClassMethods
+      end
+
+      # Class methods that appear in your class when you include Redis::Objects.
+      module ClassMethods
+        # Define a new lock.  It will function like a model attribute,
+        # so it can be used alongside ActiveRecord/DataMapper, etc.
+        def lock(name, options={})
+          options[:timeout] ||= 5  # seconds
+          options[:init] = false if options[:init].nil? # default :init to false
+          @redis_objects[name] = options.merge(:type => :lock)
+          if options[:global]
+            instance_eval <<-EndMethods
+              def #{name}_lock(&block)
+                @#{name} ||= Redis::Lock.new(field_key(:#{name}_lock, ''), redis, @redis_objects[:#{name}])
+              end
+            EndMethods
+            class_eval <<-EndMethods
+              def #{name}_lock(&block)
+                self.class.#{name}(block)
+              end
+            EndMethods
+          else
+            class_eval <<-EndMethods
+              def #{name}_lock(&block)
+                raise(ActiveRedis::Errors::NotSavedError) if self.new?
+                @#{name} ||= Redis::Lock.new(field_key(:#{name}_lock), redis, self.class.redis_objects[:#{name}])
+              end
+            EndMethods
+          end
+
+          
+          
+        end
+
+        # Obtain a lock, and execute the block synchronously.  Any other code
+        # (on any server) will spin waiting for the lock up to the :timeout
+        # that was specified when the lock was defined.
+        def obtain_lock(name, id, &block)
+          verify_lock_defined!(name)
+          raise ArgumentError, "Missing block to #{self.name}.obtain_lock" unless block_given?
+          lock_name = field_key("#{name}_lock", id)
+          Redis::Lock.new(lock_name, redis, self.redis_objects[name]).lock(&block)
+        end
+
+        # Clear the lock.  Use with care - usually only in an Admin page to clear
+        # stale locks (a stale lock should only happen if a server crashes.)
+        def clear_lock(name, id)
+          verify_lock_defined!(name)
+          lock_name = field_key("#{name}_lock", id)
+          redis.del(lock_name)
+        end
+        
+        private
+        
+        def verify_lock_defined!(name)
+          raise Redis::Objects::UndefinedLock, "Undefined lock :#{name} for class #{self.name}" unless @redis_objects.has_key?(name)
+        end
+      end
+    end
+  end
+end

data/lib/redis/objects/sets.rb

@@ -0,0 +1,46 @@
+# This is the class loader, for use as "include Redis::Objects::Sets"
+# For the object itself, see "Redis::Set"
+require 'redis/set'
+class Redis
+  module Objects
+    module Sets
+      def self.included(klass)
+        klass.send :include, InstanceMethods
+        klass.extend ClassMethods
+      end
+
+      # Class methods that appear in your class when you include Redis::Objects.
+      module ClassMethods
+        # Define a new list.  It will function like a regular instance
+        # method, so it can be used alongside ActiveRecord, DataMapper, etc.
+        def set(name, options={})
+          @redis_objects[name] = options.merge(:type => :set)
+          if options[:global]
+            instance_eval <<-EndMethods
+              def #{name}
+                @#{name} ||= Redis::Set.new(field_key(:#{name}, ''), redis, @redis_objects[:#{name}])
+              end
+            EndMethods
+            class_eval <<-EndMethods
+              def #{name}
+                self.class.#{name}
+              end
+            EndMethods
+          else
+            class_eval <<-EndMethods
+              def #{name}
+                raise(ActiveRedis::Errors::NotSavedError) if self.new?
+                @#{name} ||= Redis::Set.new(field_key(:#{name}), redis, self.class.redis_objects[:#{name}])
+              end
+            EndMethods
+          end
+          
+        end
+      end
+
+      # Instance methods that appear in your class when you include Redis::Objects.
+      module InstanceMethods
+      end
+    end
+  end
+end

data/lib/redis/objects/values.rb

@@ -0,0 +1,56 @@
+# This is the class loader, for use as "include Redis::Objects::Values"
+# For the object itself, see "Redis::Value"
+require 'redis/value'
+class Redis
+  module Objects
+    module Values
+      def self.included(klass)
+        klass.send :include, InstanceMethods
+        klass.extend ClassMethods
+      end
+
+      # Class methods that appear in your class when you include Redis::Objects.
+      module ClassMethods
+        # Define a new simple value.  It will function like a regular instance
+        # method, so it can be used alongside ActiveRecord, DataMapper, etc.
+        def value(name, options={})
+          @redis_objects[name] = options.merge(:type => :value)
+          if options[:global]
+            instance_eval <<-EndMethods
+              def #{name}
+                @#{name} ||= Redis::Value.new(field_key(:#{name}, ''), redis, @redis_objects[:#{name}])
+              end
+              def #{name}=(value)
+                #{name}.value = value
+              end
+            EndMethods
+            class_eval <<-EndMethods
+              def #{name}
+                self.class.#{name}
+              end
+              def #{name}=(value)
+                self.class.#{name} = value
+              end
+            EndMethods
+          else
+            class_eval <<-EndMethods
+              def #{name}
+                raise(ActiveRedis::Errors::NotSavedError) if self.new?
+                @#{name} ||= Redis::Value.new(field_key(:#{name}), redis, self.class.redis_objects[:#{name}])
+              end
+              def #{name}=(value)
+                raise(ActiveRedis::Errors::NotSavedError) if self.new?
+                #{name}.value = value
+              end
+            EndMethods
+          end
+          
+        end
+      end
+      
+      # Instance methods that appear in your class when you include Redis::Objects.
+      module InstanceMethods
+      end
+    end
+  end
+end

data/lib/redis/pipeline.rb

@@ -0,0 +1,21 @@
+class Redis
+  class Pipeline < Redis
+    BUFFER_SIZE = 50_000
+
+    def initialize(redis)
+      @redis = redis
+      @commands = []
+    end
+
+    def call_command(command)
+      @commands << command
+    end
+
+    def execute
+      return if @commands.empty?
+      @redis.call_command(@commands)
+      @commands.clear
+    end
+
+  end
+end

data/lib/redis/set.rb

@@ -0,0 +1,156 @@
+class Redis
+  #
+  # Class representing a set.
+  #
+  class Set
+    require 'enumerator'
+    include Enumerable
+    require 'redis/helpers/core_commands'
+    include Redis::Helpers::CoreCommands
+    require 'redis/helpers/serialize'
+    include Redis::Helpers::Serialize
+
+    attr_reader :key, :options, :redis
+    
+    # Create a new Set.
+    def initialize(key, redis=$redis, options={})
+      @key = key
+      @redis = redis
+      @options = options
+    end
+
+    # Works like add.  Can chain together: list << 'a' << 'b'
+    def <<(value)
+      add(value)
+      self  # for << 'a' << 'b'
+    end
+    
+    # Add the specified value to the set only if it does not exist already.
+    # Redis: SADD
+    def add(value)
+      redis.sadd(key, to_redis(value))
+    end
+
+    # Return all members in the set.  Redis: SMEMBERS
+    def members
+      from_redis redis.smembers(key)
+    end
+    alias_method :get, :members
+
+    # Returns true if the specified value is in the set.  Redis: SISMEMBER
+    def member?(value)
+      redis.sismember(key, to_redis(value))
+    end
+    alias_method :include?, :member?
+
+    # Delete the value from the set.  Redis: SREM
+    def delete(value)
+      redis.srem(key, value)
+    end
+
+    # Iterate through each member of the set.  Redis::Objects mixes in Enumerable,
+    # so you can also use familiar methods like +collect+, +detect+, and so forth.
+    def each(&block)
+      members.each(&block)
+    end
+
+    # Return the intersection with another set.  Can pass it either another set
+    # object or set name.  Also available as & which is a bit cleaner:
+    #
+    #    members_in_both = set1 & set2
+    #
+    # If you want to specify multiple sets, you must use +intersection+:
+    #
+    #    members_in_all = set1.intersection(set2, set3, set4)
+    #    members_in_all = set1.inter(set2, set3, set4)  # alias
+    #
+    # Redis: SINTER
+    def intersection(*sets)
+      from_redis redis.sinter(key, *keys_from_objects(sets))
+    end
+    alias_method :intersect, :intersection
+    alias_method :inter, :intersection
+    alias_method :&, :intersection
+    
+    # Calculate the intersection and store it in Redis as +name+. Returns the number
+    # of elements in the stored intersection. Redis: SUNIONSTORE
+    def interstore(name, *sets)
+      redis.sinterstore(name, key, *keys_from_objects(sets))
+    end
+
+    # Return the union with another set.  Can pass it either another set
+    # object or set name. Also available as | and + which are a bit cleaner:
+    #
+    #    members_in_either = set1 | set2
+    #    members_in_either = set1 + set2
+    #
+    # If you want to specify multiple sets, you must use +union+:
+    #
+    #    members_in_all = set1.union(set2, set3, set4)
+    #
+    # Redis: SUNION
+    def union(*sets)
+      from_redis redis.sunion(key, *keys_from_objects(sets))
+    end
+    alias_method :|, :union
+    alias_method :+, :union
+
+    # Calculate the union and store it in Redis as +name+. Returns the number
+    # of elements in the stored union. Redis: SUNIONSTORE
+    def unionstore(name, *sets)
+      redis.sunionstore(name, key, *keys_from_objects(sets))
+    end
+
+    # Return the difference vs another set.  Can pass it either another set
+    # object or set name. Also available as ^ or - which is a bit cleaner:
+    #
+    #    members_difference = set1 ^ set2
+    #    members_difference = set1 - set2
+    #
+    # If you want to specify multiple sets, you must use +difference+:
+    #
+    #    members_difference = set1.difference(set2, set3, set4)
+    #    members_difference = set1.diff(set2, set3, set4)
+    #
+    # Redis: SDIFF
+    def difference(*sets)
+      from_redis redis.sdiff(key, *keys_from_objects(sets))
+    end
+    alias_method :diff, :difference
+    alias_method :^, :difference
+    alias_method :-, :difference
+
+    # Calculate the diff and store it in Redis as +name+. Returns the number
+    # of elements in the stored union. Redis: SDIFFSTORE
+    def diffstore(name, *sets)
+      redis.sdiffstore(name, key, *keys_from_objects(sets))
+    end
+
+    # The number of members in the set. Aliased as size. Redis: SCARD
+    def length
+      redis.scard(key)
+    end
+    alias_method :size, :length
+
+    # Returns true if the set has no members. Redis: SCARD == 0
+    def empty?
+      length == 0
+    end
+
+    def ==(x)
+      members == x
+    end
+    
+    def to_s
+      members.join(', ')
+    end
+    
+    private
+    
+    def keys_from_objects(sets)
+      raise ArgumentError, "Must pass in one or more set names" if sets.empty?
+      sets.collect{|set| set.is_a?(Redis::Set) ? set.key : set}
+    end
+    
+  end
+end

data/lib/redis/value.rb

@@ -0,0 +1,35 @@
+class Redis
+  #
+  # Class representing a simple value.  You can use standard Ruby operations on it.
+  #
+  class Value
+    require 'redis/helpers/core_commands'
+    include Redis::Helpers::CoreCommands
+    require 'redis/helpers/serialize'
+    include Redis::Helpers::Serialize
+
+    attr_reader :key, :options, :redis
+    def initialize(key, redis=$redis, options={})
+      @key = key
+      @redis = redis
+      @options = options
+      @redis.setnx(key, @options[:default]) if @options[:default]
+    end
+
+    def value=(val)
+      redis.set key, to_redis(val)
+    end
+    alias_method :set, :value=
+
+    def value
+      from_redis redis.get(key)
+    end
+    alias_method :get, :value
+
+    def to_s;  value.to_s; end
+    alias_method :to_str, :to_s
+
+    def ==(x); value == x; end
+    def nil?;  value.nil?; end
+  end
+end

data/lib/riak_raw.rb

@@ -0,0 +1,100 @@
+# gem "typhoeus", "= 0.1.18"
+# gem "uuidtools", "= 2.1.1"
+# gem "brianmario-yajl-ruby", "= 0.6.3"
+# require "typhoeus"
+# require "uuidtools"
+# require "uri"
+# require "yajl"
+
+# A Ruby interface for the Riak (http://riak.basho.com/) key-value store.
+# 
+#    Example Usage:
+#    
+#    > client = RiakRaw::Client.new('127.0.0.1', 8098, 'raw')
+#    > client.delete('raw_example', 'doctestkey')
+#    > obj = client.store('raw_example', 'doctestkey', {'foo':2})
+#    > client.fetch('raw_example', 'doctestkey')
+module RiakRaw
+  VERSION = '0.0.1'
+  
+  class Client
+    attr_accessor :host, :port, :prefix, :client_id
+        
+    def initialize(host="127.0.0.1", port=8098, prefix='riak', client_id=SecureRandom.base64)
+      @host = host
+      @port = port
+      @prefix = prefix
+      @client_id = client_id
+    end
+    
+    def bucket(bucket_name,keys=false)
+      #request(:get, build_path(bucket_name))
+      response = request(:get, 
+        build_path(bucket_name),
+        nil, nil,
+        {"returnbody" => "true", "keys" => keys})
+      if response.code == 200
+        if json = response.body
+          return Yajl::Parser.parse(json)
+        end
+      end; nil
+    end
+    
+    def store(bucket_name, key, content, vclock=nil, links=[], content_type='application/json', w=2, dw=2, r=2)
+      headers = { 'Content-Type' => content_type,
+                  'X-Riak-ClientId' => self.client_id }
+      if vclock
+        headers['X-Riak-Vclock'] = vclock
+      end
+
+      response = request(:put, 
+        build_path(bucket_name,key),
+        content, headers,
+        {"returnbody" => "false", "w" => w, "dw" => dw})
+      
+      # returnbody=true could cause issues. instead we'll do a
+      # separate fetch. see: https://issues.basho.com/show_bug.cgi?id=52
+      if response.code == 204
+        response = fetch(bucket_name, key, r)
+      end
+      
+      response
+    end
+    
+    def fetch(bucket_name, key, r=2)
+      response = request(:get,
+        build_path(bucket_name, key),
+        nil, {}, {"r" => r})
+    end
+    
+    # there could be concurrency issues if we don't force a short sleep
+    # after delete. see: https://issues.basho.com/show_bug.cgi?id=52
+    def delete(bucket_name, key, dw=2)
+      response = request(:delete,
+        build_path(bucket_name, key),
+        nil, {}, {"dw" => dw})
+    end
+    
+    private
+    
+    def build_path(bucket_name, key='')
+      "http://#{self.host}:#{self.port}/#{self.prefix}/#{URI.escape(bucket_name)}/#{URI.escape(key)}"
+    end
+    
+    def request(method, uri, body="", headers={}, params={})
+      hydra = Typhoeus::Hydra.new
+      case method
+      when :get then
+        req = Typhoeus::Request.new(uri, :method => :get, :body => body, :headers => headers, :params => params)
+      when :post then
+        req = Typhoeus::Request.new(uri, :method => :post, :body => body, :headers => headers, :params => params)
+      when :put then
+        req = Typhoeus::Request.new(uri, :method => :put, :body => body, :headers => headers, :params => params)
+      when :delete then
+        req = Typhoeus::Request.new(uri, :method => :delete, :body => body, :headers => headers, :params => params)
+      end
+      hydra.queue(req); hydra.run
+      req.handled_response
+    end
+  end # Client
+end