related 0.5.0 → 0.6.0

data/CHANGELOG

@@ -1,4 +1,9 @@
 
+*0.6*
+
+* Made it possible to use Related with another database for storing node data
+* Made sure all redis-server processes gets killed when running tests in distributed mode
+
 *0.5*
 
 * Real-time stream processing

data/README.md

@@ -1,18 +1,20 @@
 Related
 =======
 
-Related is a Redis-backed high performance graph database.
+Related is a Redis-backed high performance distributed graph database.
 
 Raison d'être
 -------------
 
 Related is meant to be a simple graph database that is fun, free and easy to
-use. The intention is not to compete with industrial grade graph databases
-like Neo4j, but rather to be a replacement for a relational database when your
-data is better described as a graph. For example when building social
-software. Related is meant to be web scale, but ultimately relies on the
-ability of Redis to scale (using Redis cluster for example). Read more about
-the philosophy behind Related in the
+use. The intention is not to compete with "real" graph databases like Neo4j,
+but rather to be a replacement for a relational database when your data is
+better described as a graph. For example when building social software.
+Related is very similar in scope and functionality to Twitters FlockDB, but is
+among other things designed to be easier to setup and use. Related also has
+better documentation and is easier to hack on. The intention is to be web
+scale, but we ultimately rely on the ability of Redis to scale (using Redis
+Cluster for example). Read more about the philosophy behind Related in the
 [Wiki](http://github.com/sutajio/related/wiki).
 
 Setup
@@ -43,6 +45,10 @@ node.attributes
 node.has_attribute?(:popularity)
 node.read_attribute(:popularity)
 node.write_attribute(:popularity, 50)
+node.increment!(:popularity, 10)
+node.decrement!(:popularity, 10)
+Related::Node.increment!(node, :popularity, 10)
+Related::Node.decrement!(node, :popularity, 10)
 node.save
 node.persisted?
 node = Related::Node.find(node.id)
@@ -206,12 +212,21 @@ class Comment < Related::Relationship
 end
 ```
 
-The weight is always an integer and is sorted in descending order.
+The weight is always a double precision floating point number and is sorted in
+descending order.
 
-The weight for the links get updated every time the relationship is saved. So
-if you update the points for a Comment in the example above, the weight is
-automatically updated. You can access the weight and rank (0 based position)
-of a relationship like this:
+To change the weight an existing relationship you can use the
+`increment_weight!` and `decrement_weight!` methods. They are atomic, which
+means that you can have any number of clients updating the weight
+simultaneously without conflict.
+
+```ruby
+comment.increment_weight!(:out, 4.2)
+comment.decrement_weight!(:in, 4.2)
+```
+
+You can access the current weight and rank (0 based position) of a
+relationship like this:
 
 ```ruby
 comment.weight(:out)
@@ -332,6 +347,72 @@ To start a stream processor:
 You can start as many stream processors as you may need to scale
 up.
 
+Distributed cluster setup
+-------------------------
+
+It is easy to use Related in a distributed cluster setup. As of writing this
+(November 2011) Redis Cluster is not yet ready for production use, but is
+expected for Redis 3.0 sometime in 2012. Redis Cluster will then be the
+preferred solution as it will allow you to setup up a dynamic cluster that can
+re-configure on the fly. If you don't need to add or remove machines for the
+cluster you can still use Related in a distributed setup right now using the
+consistent hashing client Redis::Distributed which is included in the "redis"
+gem.
+
+```ruby
+Related.redis = Redis::Distributed.new %w[
+  redis://redis-1.example.com
+  redis://redis-2.example.com
+  redis://redis-3.example.com
+  redis://redis-4.example.com],
+  :tag => /^related:([^:]+)/
+```
+
+The regular expression supplied in the `:tag` option tells Redis::Distributed
+how to distribute keys between the different machines. The regexp in the
+example is the recommended way of setting it up as it will partition the key
+space based on the Related ID part of the key, in effect localizing all data
+directly related to a specific node on a single machine. This is generally
+good both for reliability (if a machine goes down, it only takes down a part
+of the graph) and speed (set operations on relationships originating from the
+same node can be done on the server side, which is a lot faster, for example).
+
+You could also specify a regexp like `/:(n|r):/` that will locate all
+relationships on the same machine, making set operations on relationships
+a lot faster overall. But with the obvious drawback that the total size of
+your graph will be limited by that single machine.
+
+Using Related with another database
+-----------------------------------
+
+Related can easily be used together with other databases than Redis to store
+Node data. Relationships are always stored in Redis, but node data can often
+have characteristics that make Redis unsuitable (like large size).
+
+You can for example use Related together with the Ripple gem to store nodes
+in Riak:
+
+```ruby
+class CustomNode
+  include Ripple::Document
+  include Related::Node::QueryMethods
+
+  def query
+    Related::Node::Query.new(self)
+  end
+end
+```
+
+You can then use the `CustomNode` class as an ordinary Related graph Node and
+query the graph like usual:
+
+```ruby
+node1 = CustomNode.create
+node2 = CustomNode.create
+Related::Relationship.create(:friend, node1, node2)
+node1.shortest_path_to(node2).outgoing(:friend)
+```
+
 Development
 -----------
 

data/lib/related/entity.rb

@@ -7,6 +7,7 @@ module Related
     include ActiveModel::Serializers::JSON
     include ActiveModel::Serializers::Xml
     include ActiveModel::Translation
+    include ActiveModel::AttributeMethods
 
     self.include_root_in_json = false
 
@@ -116,6 +117,24 @@ module Related
       @properties ? @properties.keys : []
     end
 
+    def self.increment!(id, attribute, by = 1)
+      raise Related::NotFound if id.blank?
+      Related.redis.hincrby(id.to_s, attribute.to_s, by.to_i)
+    end
+
+    def self.decrement!(id, attribute, by = 1)
+      raise Related::NotFound if id.blank?
+      Related.redis.hincrby(id.to_s, attribute.to_s, -by.to_i)
+    end
+
+    def increment!(attribute, by = 1)
+      self.class.increment!(@id, attribute, by)
+    end
+
+    def decrement!(attribute, by = 1)
+      self.class.decrement!(@id, attribute, by)
+    end
+
   private
 
     def load_attributes(id, attributes)
@@ -184,14 +203,12 @@ module Related
     end
 
     def self.find_many(ids, options = {})
-      res = Related.redis.pipelined do
-        ids.each {|id|
-          if options[:fields]
-            Related.redis.hmget(id.to_s, *options[:fields])
-          else
-            Related.redis.hgetall(id.to_s)
-          end
-        }
+      res = pipelined_fetch(ids) do |id|
+        if options[:fields]
+          Related.redis.hmget(id.to_s, *options[:fields])
+        else
+          Related.redis.hgetall(id.to_s)
+        end
       end
       objects = []
       ids.each_with_index do |id,i|
@@ -203,7 +220,7 @@ module Related
           klass = options[:model] ? options[:model].call(attributes) : self
           objects << klass.new.send(:load_attributes, id, attributes)
         else
-          attributes = Hash[*res[i]]
+          attributes = res[i].is_a?(Array) ? Hash[*res[i]] : res[i]
           klass = options[:model] ? options[:model].call(attributes) : self
           objects << klass.new.send(:load_attributes, id, attributes)
         end
@@ -211,6 +228,18 @@ module Related
       objects
     end
 
+    def self.pipelined_fetch(ids, &block)
+      Related.redis.pipelined do
+        ids.each do |id|
+          block.call(id)
+        end
+      end
+    rescue Redis::Distributed::CannotDistribute
+      ids.map do |id|
+        block.call(id)
+      end
+    end
+
     def self.property_serializer(property)
       @properties ||= {}
       @properties[property.to_sym]

data/lib/related/node.rb

@@ -113,7 +113,7 @@ module Related
       def to_a
         perform_query unless @result
         if @result_type == :nodes
-          Related::Node.find(@result, @options)
+          node_class.find(@result, @options)
         else
           Related::Relationship.find(@result, @options)
         end
@@ -134,7 +134,7 @@ module Related
         if @destination
           self.to_a.include?(entity)
         else
-          if entity.is_a?(Related::Node)
+          if entity.is_a?(node_class)
             @result_type = :nodes
             Related.redis.sismember(key, entity.to_s)
           elsif entity.is_a?(Related::Relationship)
@@ -147,7 +147,7 @@ module Related
       def find(node)
         if @result_type == :nodes
           if Related.redis.sismember(key, node.to_s)
-            Related::Node.find(node.to_s, @options)
+            node_class.find(node.to_s, @options)
           end
         else
           if id = Related.redis.get(dir_key(node))
@@ -162,18 +162,51 @@ module Related
         self
       end
 
+      def union_with_distributed_fallback(query)
+        union_without_distributed_fallback(query)
+      rescue Redis::Distributed::CannotDistribute
+        s1 = Related.redis.smembers(key)
+        s2 = Related.redis.smembers(query.key)
+        @result = s1 | s2
+        self
+      end
+
+      alias_method_chain :union, :distributed_fallback
+
       def diff(query)
         @result_type = :nodes
         @result = Related.redis.sdiff(key, query.key)
         self
       end
 
+      def diff_with_distributed_fallback(query)
+        diff_without_distributed_fallback(query)
+      rescue Redis::Distributed::CannotDistribute
+        s1 = Related.redis.smembers(key)
+        s2 = Related.redis.smembers(query.key)
+        @result = s1 - s2
+        self
+      end
+
+      alias_method_chain :diff, :distributed_fallback
+
       def intersect(query)
         @result_type = :nodes
         @result = Related.redis.sinter(key, query.key)
         self
       end
 
+      def intersect_with_distributed_fallback(query)
+        intersect_without_distributed_fallback(query)
+      rescue Redis::Distributed::CannotDistribute
+        s1 = Related.redis.smembers(key)
+        s2 = Related.redis.smembers(query.key)
+        @result = s1 & s2
+        self
+      end
+
+      alias_method_chain :intersect, :distributed_fallback
+
       def as_json(options = {})
         self.to_a
       end
@@ -184,6 +217,10 @@ module Related
 
     protected
 
+      def node_class
+        @node.class
+      end
+
       def page_start
         if @page.nil? || @page.to_i.to_s == @page.to_s
           @page && @page.to_i != 1 ? (@page.to_i * @limit.to_i) - @limit.to_i : 0

data/lib/related/relationship.rb

@@ -23,7 +23,15 @@ module Related
     end
 
     def weight(direction)
-      Related.redis.zscore(r_key(direction), self.id).to_i
+      Related.redis.zscore(r_key(direction), self.id).to_f
+    end
+
+    def increment_weight!(direction, by = 1)
+      Related.redis.zincrby(r_key(direction), by.to_f, self.id)
+    end
+
+    def decrement_weight!(direction, by = 1)
+      Related.redis.zincrby(r_key(direction), -by.to_f, self.id)
     end
 
     def self.weight(&block)
@@ -64,42 +72,38 @@ module Related
       if @weight
         relationship.instance_exec(direction, &@weight).to_i
       else
-        Time.parse(relationship.created_at).to_i
+        Time.now.to_f
       end
     end
 
     def create
-      Related.redis.multi do
+      #Related.redis.multi do
         super
         Related.redis.zadd(r_key(:out), self.class.weight_for(self, :out), self.id)
         Related.redis.zadd(r_key(:in), self.class.weight_for(self, :in), self.id)
         Related.redis.sadd(n_key(:out), self.end_node_id)
         Related.redis.sadd(n_key(:in), self.start_node_id)
         Related.redis.set(dir_key, self.id)
-      end
+      #end
       Related.execute_data_flow(self.label, self)
       self
     end
 
     def update
-      Related.redis.multi do
-        super
-        Related.redis.zadd(r_key(:out), self.class.weight_for(self, :out), self.id)
-        Related.redis.zadd(r_key(:in), self.class.weight_for(self, :in), self.id)
-      end
+      super
       Related.execute_data_flow(self.label, self)
       self
     end
 
     def delete
-      Related.redis.multi do
+      #Related.redis.multi do
         Related.redis.zrem(r_key(:out), self.id)
         Related.redis.zrem(r_key(:in), self.id)
         Related.redis.srem(n_key(:out), self.end_node_id)
         Related.redis.srem(n_key(:in), self.start_node_id)
         Related.redis.del(dir_key)
         super
-      end
+      #end
       Related.execute_data_flow(self.label, self)
       self
     end

data/lib/related/version.rb

@@ -1,3 +1,3 @@
 module Related
-  Version = VERSION = '0.5.0'
+  Version = VERSION = '0.6.0'
 end

data/lib/related.rb

@@ -21,7 +21,7 @@ module Related
   #   2. A 'hostname:port:db' string (to select the Redis db)
   #   3. A 'hostname:port/namespace' string (to set the Redis namespace)
   #   4. A redis URL string 'redis://host:port'
-  #   5. An instance of `Redis`, `Redis::Client`, `Redis::DistRedis`,
+  #   5. An instance of `Redis`, `Redis::Client`, `Redis::Distributed`,
   #      or `Redis::Namespace`.
   def redis=(server)
     if server.respond_to? :split

data/test/custom_node_test.rb

@@ -0,0 +1,46 @@
+require File.expand_path('test/test_helper')
+require 'pp'
+
+class CustomNodeTest < ActiveModel::TestCase
+
+  class CustomNode
+    include Related::Node::QueryMethods
+    attr_accessor :id
+    def self.flush
+      @database = {}
+    end
+    def self.create
+      n = self.new
+      n.id = Related.generate_id
+      @database ||= {}
+      @database[n.id] = n
+      n
+    end
+    def self.find(*ids)
+      ids.pop if ids.size > 1 && ids.last.is_a?(Hash)
+      ids.flatten.map do |id|
+        @database[id]
+      end
+    end
+    def to_s
+      @id
+    end
+    protected
+      def query
+        Related::Node::Query.new(self)
+      end
+  end
+
+  def setup
+    Related.redis.flushall
+    CustomNode.flush
+  end
+
+  def test_property_conversion
+    node1 = CustomNode.create
+    node2 = CustomNode.create
+    Related::Relationship.create(:friend, node1, node2)
+    assert_equal [node2], node1.shortest_path_to(node2).outgoing(:friend).nodes.to_a
+  end
+
+end

data/test/model_test.rb

@@ -58,10 +58,6 @@ class ModelTest < ActiveModel::TestCase
     like = Like.create(:like, node1, node2, :in_score => 42, :out_score => 10)
     assert_equal 42, like.weight(:in)
     assert_equal 10, like.weight(:out)
-    like.in_score = 50
-    like.save
-    assert_equal 50, like.weight(:in)
-    assert_equal 10, like.weight(:out)
   end
 
   def test_weight_sorting

data/test/{redis-test.conf → redis-test-1.conf}

@@ -6,10 +6,10 @@ daemonize yes
 
 # When run as a daemon, Redis write a pid file in /var/run/redis.pid by default.
 # You can specify a custom pid file location here.
-pidfile ./test/redis-test.pid
+pidfile ./test/redis-test-1.pid
 
 # Accept connections on the specified port, default is 6379
-port 9736
+port 6379
 
 # If you want you can bind a single interface, if the bind option is not
 # specified all the interfaces will listen for connections.
@@ -35,7 +35,7 @@ save 300 10
 save 60 10000
 
 # The filename where to dump the DB
-dbfilename dump.rdb
+dbfilename dump-1.rdb
 
 # For default save/load DB in/from the working directory
 # Note that you must specify a directory not a file name.

data/test/redis-test-2.conf

@@ -0,0 +1,115 @@
+# Redis configuration file example
+
+# By default Redis does not run as a daemon. Use 'yes' if you need it.
+# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
+daemonize yes
+
+# When run as a daemon, Redis write a pid file in /var/run/redis.pid by default.
+# You can specify a custom pid file location here.
+pidfile ./test/redis-test-2.pid
+
+# Accept connections on the specified port, default is 6379
+port 6380
+
+# If you want you can bind a single interface, if the bind option is not
+# specified all the interfaces will listen for connections.
+#
+# bind 127.0.0.1
+
+# Close the connection after a client is idle for N seconds (0 to disable)
+timeout 300
+
+# Save the DB on disk:
+#
+#   save <seconds> <changes>
+#
+#   Will save the DB if both the given number of seconds and the given
+#   number of write operations against the DB occurred.
+#
+#   In the example below the behaviour will be to save:
+#   after 900 sec (15 min) if at least 1 key changed
+#   after 300 sec (5 min) if at least 10 keys changed
+#   after 60 sec if at least 10000 keys changed
+save 900 1
+save 300 10
+save 60 10000
+
+# The filename where to dump the DB
+dbfilename dump-2.rdb
+
+# For default save/load DB in/from the working directory
+# Note that you must specify a directory not a file name.
+dir ./test/
+
+# Set server verbosity to 'debug'
+# it can be one of:
+# debug (a lot of information, useful for development/testing)
+# notice (moderately verbose, what you want in production probably)
+# warning (only very important / critical messages are logged)
+loglevel debug
+
+# Specify the log file name. Also 'stdout' can be used to force
+# the demon to log on the standard output. Note that if you use standard
+# output for logging but daemonize, logs will be sent to /dev/null
+logfile stdout
+
+# Set the number of databases. The default database is DB 0, you can select
+# a different one on a per-connection basis using SELECT <dbid> where
+# dbid is a number between 0 and 'databases'-1
+databases 16
+
+################################# REPLICATION #################################
+
+# Master-Slave replication. Use slaveof to make a Redis instance a copy of
+# another Redis server. Note that the configuration is local to the slave
+# so for example it is possible to configure the slave to save the DB with a
+# different interval, or to listen to another port, and so on.
+
+# slaveof <masterip> <masterport>
+
+################################## SECURITY ###################################
+
+# Require clients to issue AUTH <PASSWORD> before processing any other
+# commands.  This might be useful in environments in which you do not trust
+# others with access to the host running redis-server.
+#
+# This should stay commented out for backward compatibility and because most
+# people do not need auth (e.g. they run their own servers).
+
+# requirepass foobared
+
+################################### LIMITS ####################################
+
+# Set the max number of connected clients at the same time. By default there
+# is no limit, and it's up to the number of file descriptors the Redis process
+# is able to open. The special value '0' means no limts.
+# Once the limit is reached Redis will close all the new connections sending
+# an error 'max number of clients reached'.
+
+# maxclients 128
+
+# Don't use more memory than the specified amount of bytes.
+# When the memory limit is reached Redis will try to remove keys with an
+# EXPIRE set. It will try to start freeing keys that are going to expire
+# in little time and preserve keys with a longer time to live.
+# Redis will also try to remove objects from free lists if possible.
+#
+# If all this fails, Redis will start to reply with errors to commands
+# that will use more memory, like SET, LPUSH, and so on, and will continue
+# to reply to most read-only commands like GET.
+#
+# WARNING: maxmemory can be a good idea mainly if you want to use Redis as a
+# 'state' server or cache, not as a real DB. When Redis is used as a real
+# database the memory usage will grow over the weeks, it will be obvious if
+# it is going to use too much memory in the long run, and you'll have the time
+# to upgrade. With maxmemory after the limit is reached you'll start to get
+# errors for write operations, and this may even lead to DB inconsistency.
+
+# maxmemory <bytes>
+
+############################### ADVANCED CONFIG ###############################
+
+# Glue small output buffers together in order to send small replies in a
+# single TCP packet. Uses a bit more CPU but most of the times it is a win
+# in terms of number of queries per second. Use 'yes' if unsure.
+glueoutputbuf yes

data/test/redis-test-3.conf

@@ -0,0 +1,115 @@
+# Redis configuration file example
+
+# By default Redis does not run as a daemon. Use 'yes' if you need it.
+# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
+daemonize yes
+
+# When run as a daemon, Redis write a pid file in /var/run/redis.pid by default.
+# You can specify a custom pid file location here.
+pidfile ./test/redis-test-3.pid
+
+# Accept connections on the specified port, default is 6379
+port 6381
+
+# If you want you can bind a single interface, if the bind option is not
+# specified all the interfaces will listen for connections.
+#
+# bind 127.0.0.1
+
+# Close the connection after a client is idle for N seconds (0 to disable)
+timeout 300
+
+# Save the DB on disk:
+#
+#   save <seconds> <changes>
+#
+#   Will save the DB if both the given number of seconds and the given
+#   number of write operations against the DB occurred.
+#
+#   In the example below the behaviour will be to save:
+#   after 900 sec (15 min) if at least 1 key changed
+#   after 300 sec (5 min) if at least 10 keys changed
+#   after 60 sec if at least 10000 keys changed
+save 900 1
+save 300 10
+save 60 10000
+
+# The filename where to dump the DB
+dbfilename dump-3.rdb
+
+# For default save/load DB in/from the working directory
+# Note that you must specify a directory not a file name.
+dir ./test/
+
+# Set server verbosity to 'debug'
+# it can be one of:
+# debug (a lot of information, useful for development/testing)
+# notice (moderately verbose, what you want in production probably)
+# warning (only very important / critical messages are logged)
+loglevel debug
+
+# Specify the log file name. Also 'stdout' can be used to force
+# the demon to log on the standard output. Note that if you use standard
+# output for logging but daemonize, logs will be sent to /dev/null
+logfile stdout
+
+# Set the number of databases. The default database is DB 0, you can select
+# a different one on a per-connection basis using SELECT <dbid> where
+# dbid is a number between 0 and 'databases'-1
+databases 16
+
+################################# REPLICATION #################################
+
+# Master-Slave replication. Use slaveof to make a Redis instance a copy of
+# another Redis server. Note that the configuration is local to the slave
+# so for example it is possible to configure the slave to save the DB with a
+# different interval, or to listen to another port, and so on.
+
+# slaveof <masterip> <masterport>
+
+################################## SECURITY ###################################
+
+# Require clients to issue AUTH <PASSWORD> before processing any other
+# commands.  This might be useful in environments in which you do not trust
+# others with access to the host running redis-server.
+#
+# This should stay commented out for backward compatibility and because most
+# people do not need auth (e.g. they run their own servers).
+
+# requirepass foobared
+
+################################### LIMITS ####################################
+
+# Set the max number of connected clients at the same time. By default there
+# is no limit, and it's up to the number of file descriptors the Redis process
+# is able to open. The special value '0' means no limts.
+# Once the limit is reached Redis will close all the new connections sending
+# an error 'max number of clients reached'.
+
+# maxclients 128
+
+# Don't use more memory than the specified amount of bytes.
+# When the memory limit is reached Redis will try to remove keys with an
+# EXPIRE set. It will try to start freeing keys that are going to expire
+# in little time and preserve keys with a longer time to live.
+# Redis will also try to remove objects from free lists if possible.
+#
+# If all this fails, Redis will start to reply with errors to commands
+# that will use more memory, like SET, LPUSH, and so on, and will continue
+# to reply to most read-only commands like GET.
+#
+# WARNING: maxmemory can be a good idea mainly if you want to use Redis as a
+# 'state' server or cache, not as a real DB. When Redis is used as a real
+# database the memory usage will grow over the weeks, it will be obvious if
+# it is going to use too much memory in the long run, and you'll have the time
+# to upgrade. With maxmemory after the limit is reached you'll start to get
+# errors for write operations, and this may even lead to DB inconsistency.
+
+# maxmemory <bytes>
+
+############################### ADVANCED CONFIG ###############################
+
+# Glue small output buffers together in order to send small replies in a
+# single TCP packet. Uses a bit more CPU but most of the times it is a win
+# in terms of number of queries per second. Use 'yes' if unsure.
+glueoutputbuf yes

data/test/redis-test-4.conf

@@ -0,0 +1,115 @@
+# Redis configuration file example
+
+# By default Redis does not run as a daemon. Use 'yes' if you need it.
+# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
+daemonize yes
+
+# When run as a daemon, Redis write a pid file in /var/run/redis.pid by default.
+# You can specify a custom pid file location here.
+pidfile ./test/redis-test-4.pid
+
+# Accept connections on the specified port, default is 6379
+port 6382
+
+# If you want you can bind a single interface, if the bind option is not
+# specified all the interfaces will listen for connections.
+#
+# bind 127.0.0.1
+
+# Close the connection after a client is idle for N seconds (0 to disable)
+timeout 300
+
+# Save the DB on disk:
+#
+#   save <seconds> <changes>
+#
+#   Will save the DB if both the given number of seconds and the given
+#   number of write operations against the DB occurred.
+#
+#   In the example below the behaviour will be to save:
+#   after 900 sec (15 min) if at least 1 key changed
+#   after 300 sec (5 min) if at least 10 keys changed
+#   after 60 sec if at least 10000 keys changed
+save 900 1
+save 300 10
+save 60 10000
+
+# The filename where to dump the DB
+dbfilename dump-4.rdb
+
+# For default save/load DB in/from the working directory
+# Note that you must specify a directory not a file name.
+dir ./test/
+
+# Set server verbosity to 'debug'
+# it can be one of:
+# debug (a lot of information, useful for development/testing)
+# notice (moderately verbose, what you want in production probably)
+# warning (only very important / critical messages are logged)
+loglevel debug
+
+# Specify the log file name. Also 'stdout' can be used to force
+# the demon to log on the standard output. Note that if you use standard
+# output for logging but daemonize, logs will be sent to /dev/null
+logfile stdout
+
+# Set the number of databases. The default database is DB 0, you can select
+# a different one on a per-connection basis using SELECT <dbid> where
+# dbid is a number between 0 and 'databases'-1
+databases 16
+
+################################# REPLICATION #################################
+
+# Master-Slave replication. Use slaveof to make a Redis instance a copy of
+# another Redis server. Note that the configuration is local to the slave
+# so for example it is possible to configure the slave to save the DB with a
+# different interval, or to listen to another port, and so on.
+
+# slaveof <masterip> <masterport>
+
+################################## SECURITY ###################################
+
+# Require clients to issue AUTH <PASSWORD> before processing any other
+# commands.  This might be useful in environments in which you do not trust
+# others with access to the host running redis-server.
+#
+# This should stay commented out for backward compatibility and because most
+# people do not need auth (e.g. they run their own servers).
+
+# requirepass foobared
+
+################################### LIMITS ####################################
+
+# Set the max number of connected clients at the same time. By default there
+# is no limit, and it's up to the number of file descriptors the Redis process
+# is able to open. The special value '0' means no limts.
+# Once the limit is reached Redis will close all the new connections sending
+# an error 'max number of clients reached'.
+
+# maxclients 128
+
+# Don't use more memory than the specified amount of bytes.
+# When the memory limit is reached Redis will try to remove keys with an
+# EXPIRE set. It will try to start freeing keys that are going to expire
+# in little time and preserve keys with a longer time to live.
+# Redis will also try to remove objects from free lists if possible.
+#
+# If all this fails, Redis will start to reply with errors to commands
+# that will use more memory, like SET, LPUSH, and so on, and will continue
+# to reply to most read-only commands like GET.
+#
+# WARNING: maxmemory can be a good idea mainly if you want to use Redis as a
+# 'state' server or cache, not as a real DB. When Redis is used as a real
+# database the memory usage will grow over the weeks, it will be obvious if
+# it is going to use too much memory in the long run, and you'll have the time
+# to upgrade. With maxmemory after the limit is reached you'll start to get
+# errors for write operations, and this may even lead to DB inconsistency.
+
+# maxmemory <bytes>
+
+############################### ADVANCED CONFIG ###############################
+
+# Glue small output buffers together in order to send small replies in a
+# single TCP packet. Uses a bit more CPU but most of the times it is a win
+# in terms of number of queries per second. Use 'yes' if unsure.
+glueoutputbuf yes

data/test/related_test.rb

@@ -9,8 +9,10 @@ class RelatedTest < Test::Unit::TestCase
   def test_can_set_a_namespace_through_a_url_like_string
     assert Related.redis
     assert_equal :related, Related.redis.namespace
+    old_redis = Related.redis
     Related.redis = 'localhost:9736/namespace'
     assert_equal 'namespace', Related.redis.namespace
+    Related.redis = old_redis
   end
 
   def test_can_create_node
@@ -312,4 +314,29 @@ class RelatedTest < Test::Unit::TestCase
     assert_equal nil, node2.incoming(:friend).relationships.find(node2)
   end
 
+  def test_can_increment_and_decrement
+    node = Related::Node.create(:test => 1)
+    assert_equal 1, Related::Node.find(node.id).test.to_i
+    node.increment!(:test, 5)
+    assert_equal 6, Related::Node.find(node.id).test.to_i
+    node.decrement!(:test, 4)
+    assert_equal 2, Related::Node.find(node.id).test.to_i
+  end
+
+  def test_can_increment_and_decrement_relationship_weights
+    node1 = Related::Node.create
+    node2 = Related::Node.create
+    rel = Related::Relationship.create(:friend, node1, node2)
+    original_in_weight = Related::Relationship.find(rel.id).weight(:in)
+    rel.increment_weight!(:in, 4.2)
+    assert_equal original_in_weight + 4.2, Related::Relationship.find(rel.id).weight(:in)
+    rel.decrement_weight!(:in, 2.2)
+    assert_equal original_in_weight + 2.0, Related::Relationship.find(rel.id).weight(:in)
+    original_out_weight = Related::Relationship.find(rel.id).weight(:out)
+    rel.increment_weight!(:out, 5.2)
+    assert_equal original_out_weight + 5.2, Related::Relationship.find(rel.id).weight(:out)
+    rel.decrement_weight!(:out, 4.2)
+    assert_equal original_out_weight + 1.0, Related::Relationship.find(rel.id).weight(:out)
+  end
+
 end

data/test/test_helper.rb

@@ -5,6 +5,7 @@ $LOAD_PATH.unshift dir + '/../lib'
 require 'rubygems'
 require 'test/unit'
 require 'related'
+require 'redis/distributed'
 
 #
 # make sure we can run redis
@@ -31,13 +32,29 @@ at_exit do
     exit_code = Test::Unit::AutoRunner.run
   end
 
-  pid = `ps -A -o pid,command | grep [r]edis-test`.split(" ")[0]
   puts "Killing test redis server..."
-  `rm -f #{dir}/dump.rdb`
-  Process.kill("KILL", pid.to_i)
+  loop do
+    pid = `ps -A -o pid,command | grep [r]edis-test`.split(" ")[0]
+    break if pid.nil?
+    Process.kill("KILL", pid.to_i)
+  end
+  `rm -f #{dir}/*.rdb`
   exit exit_code
 end
 
-puts "Starting redis for testing at localhost:9736..."
-`redis-server #{dir}/redis-test.conf`
-Related.redis = 'localhost:9736'
+puts "Starting redis for testing..."
+
+# `redis-server #{dir}/redis-test-1.conf`
+# Related.redis = 'localhost:6379'
+
+`redis-server #{dir}/redis-test-1.conf`
+`redis-server #{dir}/redis-test-2.conf`
+`redis-server #{dir}/redis-test-3.conf`
+`redis-server #{dir}/redis-test-4.conf`
+
+Related.redis = Redis::Distributed.new %w[
+  redis://localhost:6379
+  redis://localhost:6380
+  redis://localhost:6381
+  redis://localhost:6382],
+  :tag => /^related:([^:]+)/

metadata

@@ -1,75 +1,57 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: related
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 5
-  - 0
-  version: 0.5.0
+version: !ruby/object:Gem::Version
+  version: 0.6.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Niklas Holmgren
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-11-02 00:00:00 +01:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-02-10 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: redis
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &70275674186620 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">"
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 2
-        - 0
-        - 0
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
         version: 2.0.0
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: redis-namespace
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *70275674186620
+- !ruby/object:Gem::Dependency
+  name: redis-namespace
+  requirement: &70275674186120 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">"
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 8
-        - 0
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
         version: 0.8.0
   type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: activemodel
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: *70275674186120
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: &70275674185740 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id003
-description: Related is a Redis-backed high performance graph database.
+  prerelease: false
+  version_requirements: *70275674185740
+description: Related is a Redis-backed high performance distributed graph database.
 email: niklas@sutajio.se
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - LICENSE
 - README.md
-files: 
+files:
 - README.md
 - Rakefile
 - LICENSE
@@ -85,44 +67,44 @@ files:
 - lib/related/version.rb
 - lib/related.rb
 - test/active_model_test.rb
+- test/custom_node_test.rb
 - test/data_flow_test.rb
+- test/dump-1.rdb
+- test/dump-2.rdb
+- test/dump-3.rdb
+- test/dump-4.rdb
 - test/follower_test.rb
 - test/model_test.rb
 - test/performance_test.rb
-- test/redis-test.conf
+- test/redis-test-1.conf
+- test/redis-test-2.conf
+- test/redis-test-3.conf
+- test/redis-test-4.conf
 - test/related_test.rb
 - test/test_helper.rb
-has_rdoc: true
 homepage: http://github.com/sutajio/related/
 licenses: []
-
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --charset=UTF-8
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
-summary: Related is a Redis-backed high performance graph database.
+summary: Related is a Redis-backed high performance distributed graph database.
 test_files: []
-